Struct MemStateMachine 

pub struct MemStateMachine<C, S, F>
where
    C: RaftTypeConfig<NodeId = NodeId>,
    S: Default + Clone + Serialize + DeserializeOwned + Send + Sync + 'static,
    F: Fn(&mut S, &C::D) -> C::R + Send + Sync + 'static,
{ /* private fields */ }

In-memory Raft state machine (v2 API).

Generic over:

• C: openraft RaftTypeConfig
• S: application state type
• F: a function fn(&mut S, &C::D) -> C::R that applies a log entry to the state.

The apply_fn approach keeps the state machine generic: the application provides a closure that knows how to mutate S given a log entry payload of type C::D.

Implementations

impl<C, S, F> MemStateMachine<C, S, F>

where C: RaftTypeConfig<NodeId = NodeId>, S: Default + Clone + Serialize + DeserializeOwned + Send + Sync + 'static, F: Fn(&mut S, &C::D) -> C::R + Send + Sync + 'static,

pub fn new(apply_fn: F) -> Self

Create a new state machine with the given apply function.

pub fn data(&self) -> Arc<RwLock<SmData<C, S>>>

Get a read handle to the inner state machine data (for reading application state).

Trait Implementations

impl<C, S, F> Clone for MemStateMachine<C, S, F>

where C: RaftTypeConfig<NodeId = NodeId>, S: Default + Clone + Serialize + DeserializeOwned + Send + Sync + 'static, F: Fn(&mut S, &C::D) -> C::R + Send + Sync + 'static,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, S, F> RaftStateMachine<C> for MemStateMachine<C, S, F>

where C: RaftTypeConfig<NodeId = NodeId, SnapshotData = Cursor<Vec<u8>>, Entry = Entry<C>>, C::D: Clone + Serialize + DeserializeOwned, C::R: Default, S: Default + Clone + Serialize + DeserializeOwned + Send + Sync + 'static, F: Fn(&mut S, &C::D) -> C::R + Send + Sync + 'static,

type SnapshotBuilder = MemSnapshotBuilder<C, S, F>

Snapshot builder type.

async fn applied_state( &mut self, ) -> Result<(Option<LogId<NodeId>>, StoredMembership<NodeId, C::Node>), StorageError<NodeId>>

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

async fn apply<I>( &mut self, entries: I, ) -> Result<Vec<C::R>, StorageError<NodeId>>

where I: IntoIterator<Item = C::Entry> + OptionalSend, I::IntoIter: 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<Box<Cursor<Vec<u8>>>, StorageError<NodeId>>

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

async fn install_snapshot( &mut self, meta: &SnapshotMeta<NodeId, C::Node>, snapshot: Box<Cursor<Vec<u8>>>, ) -> Result<(), StorageError<NodeId>>

Install a snapshot which has finished streaming from the leader.

async fn get_current_snapshot( &mut self, ) -> Result<Option<Snapshot<C>>, StorageError<NodeId>>

Get a readable handle to the current snapshot.