Struct DefaultStateMachineHandler 

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

Implementations

impl<T> DefaultStateMachineHandler<T>

where T: TypeConfig,

pub fn new( node_id: u32, last_applied_index: u64, max_entries_per_chunk: usize, state_machine: Arc<SMOF<T>>, snapshot_config: SnapshotConfig, snapshot_policy: SNP<T>, watch_event_tx: Option<Sender<WatchResponse>>, ) -> Self

Trait Implementations

impl<T> Debug for DefaultStateMachineHandler<T>

where T: TypeConfig + Debug,

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

Formats the value using the given formatter.

impl<T> StateMachineHandler<T> for DefaultStateMachineHandler<T>

where T: TypeConfig,

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

Get the interval to be processed

fn update_pending(&self, new_commit: u64)

Update pending commit index

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

TODO: decouple client related commands with RAFT internal logic

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,

Load snapshot data as a stream of chunks (ZERO-COPY)

fn last_applied(&self) -> u64

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.

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 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:

fn cleanup_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, retain_count: 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_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