Struct PeerSyncProtocol 

pub struct PeerSyncProtocol {
    pub state: SyncState,
    pub conflict_policy: ConflictPolicy,
    pub pending_ops: VecDeque<SyncOperation>,
    pub sync_log: VecDeque<(String, SyncOperation, u64)>,
}

Bidirectional state-synchronisation protocol backed by vector clocks and CRDTs.

Fields

state: SyncState

The local replicated state.

conflict_policy: ConflictPolicy

How concurrent writes to the same key are resolved.

pending_ops: VecDeque<SyncOperation>

Operations that have been enqueued but not yet dispatched to remote peers.

sync_log: VecDeque<(String, SyncOperation, u64)>

Audit log: (peer_id, operation, wall_timestamp).

Implementations

impl PeerSyncProtocol

pub fn new(node_id: String, conflict_policy: ConflictPolicy) -> Self

Create a new protocol instance for the given node.

Arguments

• node_id — a stable, globally-unique identifier for this node.
• conflict_policy — the policy applied when concurrent writes collide.

pub fn local_put(&mut self, key: String, value: Vec<u8>, now: u64) -> SyncEntry

Write value at key and return the resulting SyncEntry.

The local vector clock is incremented before the entry is stored so that the returned entry strictly succeeds every previously stored entry from this node.

pub fn local_delete(&mut self, key: String, _now: u64)

Mark key as deleted.

The key is added to the tombstone set and any live entry for it is removed. The local clock is incremented so that the deletion causally succeeds any previous entry.

pub fn apply_remote_op( &mut self, peer_id: &str, op: SyncOperation, now: u64, ) -> Result<(), SyncError>

Apply an operation received from a remote peer.

The sync audit log is updated regardless of whether the operation caused a state change.

Errors

• SyncError::Tombstoned — a Put arrived for a tombstoned key.
• SyncError::ConflictRejected — ConflictPolicy::RejectConflict rejected a conflicting Put.
• SyncError::InvalidOperation — a Merge with zero entries was supplied.

pub fn resolve_conflict( &self, existing: &SyncEntry, incoming: &SyncEntry, ) -> Result<SyncEntry, SyncError>

Resolve a write–write conflict between existing and incoming according to the active ConflictPolicy.

Errors

Returns SyncError::ConflictRejected when the policy is ConflictPolicy::RejectConflict.

pub fn generate_delta(&self, since_clock: &VectorClock) -> Vec<SyncOperation>

Generate the set of local entries that a peer is missing.

An entry is considered missing from the peer when its clock does not happen-before since_clock (i.e. the peer has not yet observed it). All matching entries are returned as a single SyncOperation::Merge. An empty Vec is returned when nothing needs to be sent.

pub fn full_sync(&self) -> SyncOperation

Return all live (non-tombstoned) entries as a single SyncOperation::Merge suitable for a full-state transfer.

pub fn get(&self, key: &str) -> Option<&SyncEntry>

Look up a live entry by key.

pub fn contains(&self, key: &str) -> bool

Returns true if key exists as a live entry.

pub fn is_tombstoned(&self, key: &str) -> bool

Returns true if key has been deleted (tombstoned).

pub fn entry_count(&self) -> usize

Number of live (non-tombstoned) entries.

pub fn clock_value(&self, node_id: &str) -> u64

The current vector-clock counter for node_id, or 0 if unknown.

pub fn stats(&self) -> PspSyncStats

Return a statistics snapshot for this instance.