Struct MockStateMachineHandler 

pub struct MockStateMachineHandler<T>
where
    T: TypeConfig,
{ /* private fields */ }

Implementations

impl<T> MockStateMachineHandler<T>

where T: TypeConfig,

pub fn checkpoint(&mut self)

Validate that all current expectations for all methods have been satisfied, and discard them.

pub fn new() -> Self

Create a new mock object with no expectations.

This method will not be generated if the real struct already has a new method. However, it will be generated if the struct implements a trait with a new method. The trait’s new method can still be called like <MockX as TraitY>::new

impl<T> MockStateMachineHandler<T>

where T: TypeConfig,

pub fn expect_last_applied(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the last_applied method

pub fn expect_update_pending(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the update_pending method

pub fn expect_wait_applied(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the wait_applied method

pub fn expect_apply_chunk(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the apply_chunk method

pub fn expect_read_from_state_machine(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the read_from_state_machine method

pub fn expect_apply_snapshot_stream_from_leader( &mut self, ) -> &mut Expectation<T>

Create an Expectation for mocking the apply_snapshot_stream_from_leader method

pub fn expect_should_snapshot(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the should_snapshot method

pub fn expect_create_snapshot(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the create_snapshot method

pub fn expect_cleanup_snapshot(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the cleanup_snapshot method

pub fn expect_validate_purge_request(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the validate_purge_request method

pub fn expect_handle_purge_request(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the handle_purge_request method

pub fn expect_get_latest_snapshot_metadata(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the get_latest_snapshot_metadata method

pub fn expect_load_snapshot_data(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the load_snapshot_data method

pub fn expect_load_snapshot_chunk(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the load_snapshot_chunk method

pub fn expect_pending_range(&mut self) -> &mut Expectation<T>

Create an Expectation for mocking the pending_range method

Trait Implementations

impl<T> Debug for MockStateMachineHandler<T>

where T: TypeConfig,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for MockStateMachineHandler<T>

where T: TypeConfig,

fn default() -> Self

Returns the “default value” for a type.

impl<T> StateMachineHandler<T> for MockStateMachineHandler<T>

where T: TypeConfig,

fn update_pending(&self, new_commit: u64)

Updates the highest known committed log index that hasn’t been applied yet

fn wait_applied<'life0, 'async_trait>( &'life0 self, target_index: u64, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Waits until the state machine has applied entries up to the target index. Returns error if timeout is reached before the target is applied.

This is used to ensure linearizable reads: after leader confirms a log entry is committed (via quorum), we must wait for the state machine to apply it before reading to guarantee the read reflects all committed writes.

fn apply_chunk<'life0, 'async_trait>( &'life0 self, chunk: Vec<Entry>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Applies a batch of committed log entries to the state machine

fn read_from_state_machine(&self, keys: Vec<Bytes>) -> Option<Vec<ClientResult>>

Reads values from the state machine for given keys Returns None if any key doesn’t exist

fn apply_snapshot_stream_from_leader<'life0, 'life1, 'async_trait>( &'life0 self, current_term: u64, stream: Box<Streaming<SnapshotChunk>>, ack_tx: Sender<SnapshotAck>, config: &'life1 SnapshotConfig, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Receives and installs a snapshot stream pushed by the leader Used when leader proactively sends snapshot updates to followers

fn should_snapshot(&self, new_commit_data: NewCommitData) -> bool

Determines if a snapshot should be created based on new commit data

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

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

Asynchronously creates a state machine snapshot with the following steps:

1. Acquires a write lock to ensure exclusive access during snapshot creation
2. Prepares temporary and final snapshot file paths using:
   • Last applied index/term from state machine
3. Generates snapshot data to temporary file using state machine implementation
4. Atomically renames temporary file to final snapshot file to ensure consistency
5. Cleans up old snapshots based on last_included_index, retaining only the latest snapshot files as specified by cleanup_retain_count.

Returns new Snapshot metadata and final snapshot path to indicate the new snapshot file has been successfully created

fn cleanup_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, before_version: u64, snapshot_dir: &'life1 Path, snapshot_dir_prefix: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Cleans up old snapshots before specified version

fn validate_purge_request<'life0, 'life1, 'async_trait>( &'life0 self, current_term: u64, leader_id: Option<u32>, req: &'life1 PurgeLogRequest, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Validates if a log purge request from leader is authorized

fn handle_purge_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, current_term: u64, leader_id: Option<u32>, last_purged: Option<LogId>, req: &'life1 PurgeLogRequest, raft_log: &'life2 Arc<ROF<T>>, ) -> Pin<Box<dyn Future<Output = Result<PurgeLogResponse>> + Send + 'async_trait>>

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

Processes log purge requests (for non-leader nodes)

fn get_latest_snapshot_metadata(&self) -> Option<SnapshotMetadata>

Retrieves metadata of the latest valid snapshot

fn load_snapshot_data<'life0, 'async_trait>( &'life0 self, metadata: SnapshotMetadata, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, Result<SnapshotChunk>>>> + Send + 'async_trait>>

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

Loads snapshot data as a stream of chunks

fn load_snapshot_chunk<'life0, 'life1, 'async_trait>( &'life0 self, metadata: &'life1 SnapshotMetadata, seq: u32, ) -> Pin<Box<dyn Future<Output = Result<SnapshotChunk>> + Send + 'async_trait>>

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

Loads a specific chunk of snapshot data by sequence number

fn last_applied(&self) -> u64

fn pending_range(&self) -> Option<RangeInclusive<u64>>