Struct memstore::MemStore

pub struct MemStore { /* fields omitted */ }

An in-memory storage system implementing the async_raft::RaftStorage trait.

Implementations

impl MemStore

pub fn new(id: NodeId) -> Self

Create a new MemStore instance.

pub async fn get_log(
    &self
) -> RwLockWriteGuard<'_, BTreeMap<u64, Entry<ClientRequest>>>

Get a handle to the log for testing purposes.

pub async fn get_state_machine(
    &self
) -> RwLockWriteGuard<'_, MemStoreStateMachine>

Get a handle to the state machine for testing purposes.

pub async fn read_hard_state(&self) -> RwLockReadGuard<'_, Option<HardState>>

Get a handle to the current hard state for testing purposes.

Trait Implementations

impl RaftStorage<ClientRequest, ClientResponse> for MemStore

type Snapshot = Cursor<Vec<u8>>

The storage engine's associated type used for exposing a snapshot for reading & writing.

type ShutdownError = ShutdownError

The error type used to indicate to Raft that shutdown is needed when calling the apply_entry_to_state_machine method.

pub fn get_membership_config<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<MembershipConfig>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the latest membership config found in the log.

pub fn get_initial_state<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<InitialState>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get Raft's state information from storage.

pub fn save_hard_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hs: &'life1 HardState
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Save Raft's hard-state.

pub fn get_log_entries<'life0, 'async_trait>(
    &'life0 self,
    start: u64,
    stop: u64
) -> Pin<Box<dyn Future<Output = Result<Vec<Entry<ClientRequest>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get a series of log entries from storage.

pub fn delete_logs_from<'life0, 'async_trait>(
    &'life0 self,
    start: u64,
    stop: Option<u64>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Delete all logs starting from start and stopping at stop, else continuing to the end of the log if stop is None.

pub fn append_entry_to_log<'life0, 'life1, 'async_trait>(
    &'life0 self,
    entry: &'life1 Entry<ClientRequest>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Append a new entry to the log.

pub fn replicate_to_log<'life0, 'life1, 'async_trait>(
    &'life0 self,
    entries: &'life1 [Entry<ClientRequest>]
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Replicate a payload of entries to the log.

pub fn apply_entry_to_state_machine<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    index: &'life1 u64,
    data: &'life2 ClientRequest
) -> Pin<Box<dyn Future<Output = Result<ClientResponse>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Apply the given log entry to the state machine.

pub fn replicate_to_state_machine<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    entries: &'life1 [(&'life2 u64, &'life3 ClientRequest)]
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Apply the given payload of entries to the state machine, as part of replication.

pub fn do_log_compaction<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<CurrentSnapshotData<Self::Snapshot>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Perform log compaction, returning a handle to the generated snapshot.

pub fn create_snapshot<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(String, Box<Self::Snapshot>)>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Create a new blank snapshot, returning a writable handle to the snapshot object along with the ID of the snapshot.

pub fn finalize_snapshot_installation<'life0, 'async_trait>(
    &'life0 self,
    index: u64,
    term: u64,
    delete_through: Option<u64>,
    id: String,
    snapshot: Box<Self::Snapshot>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Finalize the installation of a snapshot which has finished streaming from the cluster leader.

pub fn get_current_snapshot<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<CurrentSnapshotData<Self::Snapshot>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get a readable handle to the current snapshot, along with its metadata.