Struct RaftLog 

pub struct RaftLog<T: Types> { /* private fields */ }

RaftLog is a Write-Ahead-Log implementation for the Raft consensus protocol.

It provides persistent storage for Raft log entries and state, with the following features:

• Append-only log storage with chunk-based organization
• In-memory caching of log payloads
• Exclusive file locking for thread-safe operations
• Support for log truncation and purging
• Statistics tracking for monitoring

Implementations

impl<T: Types> RaftLog<T>

pub fn dump_data(&self) -> DumpRaftLog<T>

Dump the RaftLog data for debugging purposes.

Returns a DumpRaftLog struct containing a complete snapshot of the RaftLog state.

pub fn dump(&self) -> RefDump<'_, T>

Dump the WAL data in this Raft-log for debugging purposes.

This method returns a reference type RefDump containing the RaftLog configuration and the RaftLog instance itself.

pub fn config(&self) -> &Config

Get a reference to the RaftLog configuration.

pub fn open(config: Arc<Config>) -> Result<Self, Error>

Opens a RaftLog at the specified directory.

This operation:

1. Acquires an exclusive lock on the directory
2. Loads existing chunks in order
3. Replays WAL records to rebuild the state
4. Creates a new open chunk for future writes

Errors

Returns an error if:

• Directory operations fail
• There are gaps between chunk offsets
• WAL records are invalid

pub fn load_chunk_ids(config: &Config) -> Result<Vec<ChunkId>, Error>

pub fn update_state(&mut self, state: RaftLogState<T>) -> Result<Segment, Error>

Update the RaftLog state.

This method updates the RaftLog state with a new state and appends it to the WAL.

pub fn read( &self, from: u64, to: u64, ) -> impl Iterator<Item = Result<(T::LogId, T::LogPayload), Error>> + '_

Reads log entries in the specified index range.

Returns an iterator over log entries, attempting to serve them from cache first, falling back to disk reads if necessary.

pub fn log_state(&self) -> &RaftLogState<T>

Get a reference to the latest RaftLog state.

The state is the latest state of the RaftLog, even if the corresponding WAL record is not committed yet.

pub fn stat(&self) -> Stat<T>

Get a reference to the RaftLog statistics.

This method returns a Stat struct containing statistics about the RaftLog, including:

• The number of closed chunks
• The open chunk statistics

pub fn access_stat(&self) -> &AccessStat

Get a reference to the access statistics.

This method returns a reference to the AccessStat struct, which contains statistics about the access patterns of the RaftLog.

pub fn wait_worker_idle(&self)

Block until the FlushWorker has processed all queued requests.

After this returns, all file writes, syncs, and cache eviction boundary updates issued before this call are complete. Note that the payload cache item count may still be non-deterministic because eviction is lazy; call drain_cache_evictable() afterwards to normalize it.

pub fn drain_cache_evictable(&self)

Drain all evictable entries from the payload cache.

Call after wait_worker_idle() to normalize the cache to a deterministic state. See PayloadCache::drain_evictable for details.

pub fn on_disk_size(&self) -> u64

Returns the current size of the log on disk in bytes.

This includes all closed chunks and the open chunk, measuring from the start of the earliest chunk to the end of the open chunk.

Trait Implementations

impl<T: Debug + Types> Debug for RaftLog<T>

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

Formats the value using the given formatter.

impl<T: Types> RaftLogWriter<T> for RaftLog<T>

fn truncate(&mut self, index: u64) -> Result<Segment, Error>

Truncate at index, keep the record before index.

fn save_user_data( &mut self, user_data: Option<T::UserData>, ) -> Result<Segment, Error>

Update the user data of the Raft log.

fn save_vote(&mut self, vote: T::Vote) -> Result<Segment, Error>

Save the vote information.

fn append<I>(&mut self, entries: I) -> Result<Segment, Error>

where I: IntoIterator<Item = (T::LogId, T::LogPayload)>,

Append a batch of entries to the log.

fn purge(&mut self, upto: T::LogId) -> Result<Segment, Error>

Purge log entries up to and including the given log id.

fn commit(&mut self, log_id: T::LogId) -> Result<Segment, Error>

Update the committed log id.

fn flush(&mut self, callback: T::Callback) -> Result<(), Error>

Initiate an asynchronous flush operation to persist all written data.