Struct LogStore 

pub struct LogStore<T>
where
    T: RaftTypeConfig,
{
    pub writer: Sender<Action>,
    pub reader: Sender<Action>,
    /* private fields */
}

T::NodeId MUST be a u64 for the LogStore to work correctly.

Fields

writer: Sender<Action>

reader: Sender<Action>

Implementations

impl<T> LogStore<T>

where T: RaftTypeConfig,

pub async fn start( base_path: String, sync: LogSync, wal_size: u32, ) -> Result<Self, Error>

Start the LogStore

pub async fn start_writer_migration( base_path: String, wal_size: u32, ) -> Result<Sender<Action>, Error>

Gives you a raw handle to the writer channel to perform manual migrations. Does not start a log store and does not do anything on its own.

pub fn shutdown_handle(&self) -> ShutdownHandle

pub async fn stop(self) -> Result<(), Error>

Trait Implementations

impl<T> Debug for LogStore<T>

where T: RaftTypeConfig + Debug,

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

Formats the value using the given formatter.

impl<T> RaftLogReader<T> for LogStore<T>

where T: RaftTypeConfig,

async fn try_get_log_entries<RB: RangeBounds<u64> + Clone + Debug + OptionalSend>( &mut self, range: RB, ) -> Result<Vec<T::Entry>, StorageError<T::NodeId>>

Get a series of log entries from storage.

fn limited_get_log_entries( &mut self, start: u64, end: u64, ) -> impl Future<Output = Result<Vec<<C as RaftTypeConfig>::Entry>, StorageError<<C as RaftTypeConfig>::NodeId>>> + Send

Returns log entries within range [start, end), end is exclusive, potentially limited by implementation-defined constraints.

impl<T> RaftLogStorage<T> for LogStore<T>

where T: RaftTypeConfig,

type LogReader = LogStoreReader<T>

Log reader type.

async fn get_log_state( &mut self, ) -> Result<LogState<T>, StorageError<T::NodeId>>

Returns the last deleted log id and the last log id.

async fn get_log_reader(&mut self) -> Self::LogReader

Get the log reader.

async fn save_vote( &mut self, vote: &Vote<T::NodeId>, ) -> Result<(), StorageError<T::NodeId>>

Save vote to storage.

async fn read_vote( &mut self, ) -> Result<Option<Vote<T::NodeId>>, StorageError<T::NodeId>>

Return the last saved vote by Self::save_vote.

async fn append<I>( &mut self, entries: I, callback: LogFlushed<T>, ) -> Result<(), StorageError<T::NodeId>>

where I: IntoIterator<Item = T::Entry> + Send, I::IntoIter: Send,

Append log entries and call the callback once logs are persisted on disk.

async fn truncate( &mut self, log_id: LogId<T::NodeId>, ) -> Result<(), StorageError<T::NodeId>>

Truncate logs since log_id, inclusive

async fn purge( &mut self, log_id: LogId<T::NodeId>, ) -> Result<(), StorageError<T::NodeId>>

Purge logs upto log_id, inclusive

fn save_committed( &mut self, _committed: Option<LogId<<C as RaftTypeConfig>::NodeId>>, ) -> impl Future<Output = Result<(), StorageError<<C as RaftTypeConfig>::NodeId>>> + Send

Saves the last committed log id to storage.

fn read_committed( &mut self, ) -> impl Future<Output = Result<Option<LogId<<C as RaftTypeConfig>::NodeId>>, StorageError<<C as RaftTypeConfig>::NodeId>>> + Send

Return the last saved committed log id by Self::save_committed.