Struct HighWaterStateMachine 

pub struct HighWaterStateMachine { /* private fields */ }

RaftStateMachine for the high-water counter, with pluggable snapshot persistence.

Clone-cheap: the Arc<Mutex<Core>>, the Arc<dyn SnapshotStore>, and the Arc<Mutex<()>> persist lock are all shared by clone. Required by openraft’s get_snapshot_builder contract which uses SnapshotBuilder = Self.

Implementations

impl HighWaterStateMachine

pub fn new() -> Self

Build a state machine backed by an in-memory snapshot store.

Equivalent to HighWaterStateMachine::with_store(Arc::new(InMemorySnapshotStore::new())). Snapshots survive within a process but not across restarts; for that use HighWaterStateMachine::with_store with a durable backend such as crate::snapshot_store::RocksdbSnapshotStore.

pub fn with_store(store: Arc<dyn SnapshotStore>) -> Result<Self>

Build a state machine backed by store and rehydrated from whatever snapshot the store currently holds.

If store.load() returns a snapshot, the state machine’s current_value, last_applied, last_membership, dense state, and get_current_snapshot() all reflect that snapshot on return. This is the contract that lets openraft re-enable the default snapshot policy: after a restart the log store’s last_purged_log_id may sit above index 0, and the state machine must already cover those purged entries or openraft will panic during recovery.

The active write version is recovered to at least the persisted snapshot’s leading version byte, so a store holding a v5/dense snapshot does not come back at the baseline (which would trip the fail-loud NotRepresentable guard on the next build_snapshot). For full max-of-evidence recovery — folding in the highest version byte among durable log records as well — seed the cell via recover_active_write_version and pass it to with_store_and_active_version; with_store only sees the snapshot store.

pub fn with_store_and_active_version( store: Arc<dyn SnapshotStore>, active_write_version: ActiveWriteVersion, ) -> Result<Self>

Build a state machine backed by store, sharing active_write_version with the log store (and, in a later phase, the wire sender). Bootstrap constructs and seeds the cell once, then threads the same clone here and into the log store; non-bootstrap callers use with_store, which supplies a fresh BASELINE cell.

pub fn active_write_version(&self) -> u8

The version this SM currently stamps onto snapshots.

pub async fn current_value(&self) -> u64

Read the current high-water value without going through raft.

Returns the value most-recently written by apply or install_snapshot. This is a state-machine-local read; callers that need linearizability must coordinate a read barrier through Raft before calling.

pub fn dense_value(&self, key: &str) -> u64

Read a dense counter by key, returning 0 if absent. State-machine-local read; callers needing linearizability must issue a read barrier first.

Trait Implementations

impl Clone for HighWaterStateMachine

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for HighWaterStateMachine

fn default() -> Self

Returns the “default value” for a type.

impl RaftSnapshotBuilder<TypeConfig> for HighWaterStateMachine

type SnapshotData = Cursor<Vec<u8>>

Snapshot data this builder produces.

async fn build_snapshot( &mut self, ) -> Result<SnapshotOf<TypeConfig, Cursor<Vec<u8>>>, Error>

Build snapshot

impl RaftStateMachine<TypeConfig> for HighWaterStateMachine

type SnapshotData = Cursor<Vec<u8>>

Snapshot data for exposing a snapshot for reading & writing.

type SnapshotBuilder = HighWaterStateMachine

Snapshot builder type.

async fn applied_state( &mut self, ) -> Result<(Option<LogIdOf<TypeConfig>>, StoredMembershipOf<TypeConfig>), Error>

Returns the last applied log id which is recorded in state machine, and the last applied membership config.

async fn apply<Strm>(&mut self, entries: Strm) -> Result<(), Error>

where Strm: Stream<Item = Result<EntryResponder<TypeConfig>, Error>> + Unpin + OptionalSend,

Apply the given payload of entries to the state machine.

async fn get_snapshot_builder(&mut self) -> Self::SnapshotBuilder

Get the snapshot builder for the state machine.

async fn begin_receiving_snapshot(&mut self) -> Result<Cursor<Vec<u8>>, Error>

Create a new blank snapshot, returning a writable handle to the snapshot object.

async fn install_snapshot( &mut self, meta: &SnapshotMetaOf<TypeConfig>, snapshot: Cursor<Vec<u8>>, ) -> Result<(), Error>

Install a snapshot which has finished streaming from the leader.

async fn get_current_snapshot( &mut self, ) -> Result<Option<SnapshotOf<TypeConfig, Cursor<Vec<u8>>>>, Error>

Get a readable handle to the current snapshot.

fn try_create_snapshot_builder( &mut self, force: bool, ) -> impl Future<Output = Option<Self::SnapshotBuilder>> + Send

Try to create a snapshot builder for the state machine.