Struct openraft_memstore::ClientRequest

pub struct ClientRequest {
    pub client: String,
    pub serial: u64,
    pub status: String,
}

The application data request type which the MemStore works with.

Conceptually, for demo purposes, this represents an update to a client’s status info, returning the previously recorded status.

Fields

client: String

The ID of the client which has sent the request.

serial: u64

The serial number of this request.

status: String

A string describing the status of the client. For a real application, this should probably be an enum representing all of the various types of requests / operations which a client can perform.

Trait Implementations

impl Clone for ClientRequest

fn clone(&self) -> ClientRequest

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ClientRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClientRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl RaftStorage<ClientRequest, ClientResponse> for MemStore

type SnapshotData = Cursor<Vec<u8, Global>>

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

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

Get the latest membership config found in the log or in state machine.

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

Get Raft’s state information from storage.

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

Save Raft’s hard-state.

fn read_hard_state<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<HardState>, StorageError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

fn get_log_entries<'life0, 'async_trait, RNG>(
    &'life0 self,
    range: RNG
) -> Pin<Box<dyn Future<Output = Result<Vec<Entry<ClientRequest>>, StorageError>> + Send + 'async_trait>> where
    RNG: 'async_trait + RangeBounds<u64> + Clone + Debug + Send + Sync,
    'life0: 'async_trait,
    Self: 'async_trait, 

Get a series of log entries from storage.

fn try_get_log_entries<'life0, 'async_trait, RNG>(
    &'life0 self,
    range: RNG
) -> Pin<Box<dyn Future<Output = Result<Vec<Entry<ClientRequest>>, StorageError>> + Send + 'async_trait>> where
    RNG: 'async_trait + RangeBounds<u64> + Clone + Debug + Send + Sync,
    'life0: 'async_trait,
    Self: 'async_trait, 

Get a series of log entries from storage.

fn try_get_log_entry<'life0, 'async_trait>(
    &'life0 self,
    log_index: u64
) -> Pin<Box<dyn Future<Output = Result<Option<Entry<ClientRequest>>, StorageError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Try to get an log entry. It does not return an error if in defensive mode and the log entry at log_index is not found.

fn first_id_in_log<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<LogId>, StorageError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns the first log id in log.

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

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

Returns the last log id in log.

fn last_applied_state<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(LogId, Option<EffectiveMembership>), StorageError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

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

fn delete_logs_from<'life0, 'async_trait, R>(
    &'life0 self,
    range: R
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>> where
    R: 'async_trait + RangeBounds<u64> + Clone + Debug + Send + Sync,
    'life0: 'async_trait,
    Self: 'async_trait, 

Delete all logs in a range.

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

Append a payload of entries to the log.

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

Apply the given payload of entries to the state machine.

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

Build snapshot

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

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

fn finalize_snapshot_installation<'life0, 'life1, 'async_trait>(
    &'life0 self,
    meta: &'life1 SnapshotMeta,
    snapshot: Box<Self::SnapshotData>
) -> Pin<Box<dyn Future<Output = Result<StateMachineChanges, StorageError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Install a snapshot which has finished streaming from the cluster leader.

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

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

impl Serialize for ClientRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl AppData for ClientRequest