Struct sync15::clients::engine::Engine

pub struct Engine<'a> {
    pub command_processor: &'a dyn CommandProcessor,
    pub interruptee: &'a dyn Interruptee,
    pub recent_clients: HashMap<String, RemoteClient>,
}

Fields

command_processor: &'a dyn CommandProcessor

interruptee: &'a dyn Interruptee

recent_clients: HashMap<String, RemoteClient>

Implementations

impl<'a> Engine<'a>

pub fn new<'b>(
    command_processor: &'b dyn CommandProcessor,
    interruptee: &'b dyn Interruptee
) -> Engine<'b>

Creates a new clients engine that delegates to the given command processor to apply incoming commands.

pub fn sync(
    &mut self,
    storage_client: &Sync15StorageClient,
    global_state: &GlobalState,
    root_sync_key: &KeyBundle,
    should_refresh_client: bool
) -> Result<()>

Syncs the clients collection. This works a little differently than other collections:

1. It can't be disabled or declined.
2. The sync ID and last sync time aren't meaningful, since we always fetch all client records on every sync. As such, the LocalCollStateMachine that we use for other engines doesn't apply to it.
3. It doesn't persist state directly, but relies on the sync manager to persist device settings, and process commands.
4. Failing to sync the clients collection is fatal, and aborts the sync.

For these reasons, we implement this engine directly in the sync15 crate, and provide a specialized sync method instead of implementing sync15::Store.

fn fetch_incoming(
    &self,
    storage_client: &Sync15StorageClient,
    coll_state: &mut CollState
) -> Result<IncomingChangeset>

pub fn local_client_id(&self) -> String

pub fn get_client_data(&self) -> ClientData