Struct Compactor 

pub struct Compactor {
    replica_id: String,
    config: CompactionConfig,
    snapshots: SnapshotManager,
    stability: StabilityMonitor,
    pruner: Pruner,
    stats: CompactionStats,
    current_time: u64,
}

High-level compactor that orchestrates all compaction operations.

Fields

replica_id: String

Our replica ID.

config: CompactionConfig

Configuration.

snapshots: SnapshotManager

Snapshot manager.

stability: StabilityMonitor

Stability monitor.

pruner: Pruner

Pruner.

stats: CompactionStats

Statistics.

current_time: u64

Current logical time.

Implementations

impl Compactor

pub fn new(replica_id: impl Into<String>) -> Self

Create a new compactor.

pub fn with_config( replica_id: impl Into<String>, config: CompactionConfig, ) -> Self

Create a compactor with custom configuration.

pub fn replica_id(&self) -> &str

Get the replica ID.

pub fn config(&self) -> &CompactionConfig

Get the configuration.

pub fn snapshots(&self) -> &SnapshotManager

Get the snapshot manager.

pub fn snapshots_mut(&mut self) -> &mut SnapshotManager

Get mutable snapshot manager.

pub fn stability(&self) -> &StabilityMonitor

Get the stability monitor.

pub fn stability_mut(&mut self) -> &mut StabilityMonitor

Get mutable stability monitor.

pub fn pruner(&self) -> &Pruner

Get the pruner.

pub fn pruner_mut(&mut self) -> &mut Pruner

Get mutable pruner.

pub fn stats(&self) -> &CompactionStats

Get statistics.

pub fn set_time(&mut self, time: u64)

Update the current time.

pub fn update_local_frontier(&mut self, vv: VersionVector, heads: Vec<Hash>)

Update local frontier (call after state changes).

pub fn process_peer_update(&mut self, update: FrontierUpdate)

Process a frontier update from a peer.

pub fn create_frontier_update(&self) -> FrontierUpdate

Create a frontier update for broadcasting.

pub fn should_snapshot(&self) -> bool

Check if a snapshot should be created.

pub fn create_snapshot<F>( &mut self, superseded_roots: Vec<Hash>, state_serializer: F, ) -> Result<Hash, CompactionError>

where F: FnOnce() -> Result<Vec<u8>, String>,

Create a snapshot from the current state.

The state_serializer function should serialize the current CRDT state.

pub fn should_compact<S: DAGStore>(&self, _store: &S) -> bool

Check if compaction should be performed.

pub fn compact<S, F>( &mut self, store: &mut S, state_serializer: F, ) -> Result<CompactionResult, CompactionError>

where S: DAGStore + PrunableStore, F: FnOnce() -> Result<Vec<u8>, String>,

Perform compaction (snapshot + prune if needed).

pub fn tick<S, F>( &mut self, store: &mut S, state_serializer: F, time: u64, ) -> Result<Option<CompactionResult>, CompactionError>

where S: DAGStore + PrunableStore, F: FnOnce() -> Result<Vec<u8>, String>,

Perform automatic maintenance (GC stale peers, auto-compact if needed).

pub fn bootstrap_from_snapshot( &mut self, snapshot: Snapshot, ) -> Result<(Vec<u8>, VersionVector), CompactionError>

Bootstrap from a snapshot.

Returns the deserialized state data and the version vector.

pub fn get_bootstrap_snapshot(&self) -> Option<&Snapshot>

Get the best snapshot for bootstrapping a new replica.