Struct SyncServiceManager 

pub struct SyncServiceManager { /* private fields */ }

Manager for background journal synchronization

Integrates aura_sync::SyncService into the agent runtime lifecycle. Handles startup, shutdown, and coordination with other agent services.

Implementations

impl SyncServiceManager

pub const ACTOR_BOUNDARY_CATEGORY: BoundaryDeclarationCategory = ::aura_core::BoundaryDeclarationCategory::ActorOwned

pub const ACTOR_OWNER_NAME: &'static str = "sync_service_manager"

pub const ACTOR_DOMAIN_NAME: &'static str = "sync"

pub const ACTOR_INGRESS_GATE: &'static str = "sync_command_ingress"

pub const ACTOR_DECLARATION_CATEGORY_LITERAL: &'static str = "actor_owned"

pub fn actor_declaration() -> ActorDeclaration<Self, SyncCommand>

pub fn actor_ingress() -> BoundedActorIngress<Self, SyncCommand>

pub fn register_actor_supervision<HandleId>( handle_id: HandleId, shutdown: OwnedShutdownToken, ) -> SupervisionRegistration<Self, SyncCommand, HandleId>

impl SyncServiceManager

pub const OWNERSHIP_CATEGORY: OwnershipCategory = OwnershipCategory::ActorOwned

pub fn new(config: SyncManagerConfig) -> Self

Create a new sync service manager

pub fn with_indexed_journal( config: SyncManagerConfig, indexed_journal: Arc<dyn IndexedJournalEffects + Send + Sync>, time: Arc<dyn PhysicalTimeEffects>, ) -> Self

Create a new sync service manager with indexed journal for Merkle verification

This enables fact sync with cryptographic verification of facts using Merkle trees and Bloom filters from the indexed journal.

pub fn with_defaults() -> Self

Create with default configuration

pub async fn state(&self) -> SyncManagerState

Get the current state

pub async fn is_running(&self) -> bool

Check if the service is running

pub async fn sync_with_peers<E>( &self, effects: &E, peers: Vec<DeviceId>, ) -> Result<(), SyncManagerError>

where E: JournalEffects + NetworkEffects + PhysicalTimeEffects + GuardContextProvider + Send + Sync,

Perform a manual sync with specific peers

Arguments

• effects: Effect system providing journal, network, and time capabilities
• peers: List of peers to sync with

pub async fn add_peer(&self, peer: DeviceId)

Add a peer to the known peers list

pub async fn remove_peer(&self, peer: &DeviceId)

Remove a peer from the known peers list

pub async fn peers(&self) -> Vec<DeviceId>

Get the list of known peers

pub async fn sync_service_health(&self) -> Option<SyncServiceHealth>

Get service health information

pub async fn metrics(&self) -> Option<ServiceMetrics>

Get service metrics

pub fn config(&self) -> &SyncManagerConfig

Get the configuration

pub fn has_merkle_verification(&self) -> bool

Check if Merkle verification is available

Returns true if the manager was created with an indexed journal, enabling cryptographic fact verification.

pub async fn local_merkle_root(&self) -> Option<[u8; 32]>

Get the local Merkle root for exchange with peers

Returns None if Merkle verification is not enabled (no indexed journal). The root represents the current state of the local fact journal and can be compared with remote roots to determine if synchronization is needed.

pub async fn verify_facts( &self, facts: Vec<IndexedFact>, claimed_root: [u8; 32], ) -> Option<VerificationResult>

Verify incoming facts against the local Merkle tree

Returns None if Merkle verification is not enabled. Otherwise returns the verification result containing:

• verified: Facts that passed verification
• rejected: Facts that failed verification with reasons
• merkle_root: Current local Merkle root after verification

pub fn merkle_verifier(&self) -> Option<&Arc<MerkleVerifier>>

Get the internal Merkle verifier reference

Returns None if Merkle verification is not enabled. Use this for direct access to verification operations like compare_roots() or local_bloom_filter().

impl SyncServiceManager

Async health check implementation

pub async fn health_async(&self) -> ServiceHealth

Get the service health status asynchronously

This provides full health information including underlying service health. For the synchronous RuntimeService::health(), a simplified status is returned.

impl SyncServiceManager

pub async fn execute_epoch_rotation_coordinator( &self, effects: Arc<AuraEffectSystem>, coordinator_id: AuthorityId, participant1_id: AuthorityId, participant2_id: AuthorityId, proposal: EpochRotationProposal, commit: EpochCommit, ) -> Result<(), SyncManagerError>

Execute epoch rotation protocol as coordinator.

pub async fn execute_epoch_rotation_participant( &self, effects: Arc<AuraEffectSystem>, role: EpochRotationProtocolRole, coordinator_id: AuthorityId, participant1_id: AuthorityId, participant2_id: AuthorityId, confirmation: EpochConfirmation, ) -> Result<(), SyncManagerError>

Execute epoch rotation protocol as participant.

pub async fn delegate_epoch_rotation_session( &self, effects: Arc<AuraEffectSystem>, rotation_id: &str, from_authority: AuthorityId, to_authority: AuthorityId, bundle_id: Option<String>, ) -> Result<DelegationReceipt, SyncManagerError>

Delegate ownership of an epoch-rotation session to another authority.

This updates runtime session footprints and records a relational protocol fact.

Trait Implementations

impl Clone for SyncServiceManager

fn clone(&self) -> SyncServiceManager

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for SyncServiceManager

fn default() -> Self

Returns the “default value” for a type.

impl RuntimeService for SyncServiceManager

fn name(&self) -> &'static str

Returns the unique name of this service

fn dependencies(&self) -> &[&'static str]

Returns the names of services this service depends on

fn start<'life0, 'life1, 'async_trait>( &'life0 self, context: &'life1 RuntimeServiceContext, ) -> Pin<Box<dyn Future<Output = Result<(), ServiceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Start the service

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ServiceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop the service gracefully

fn health<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ServiceHealth> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current health status of the service