Struct RaftLog 

pub struct RaftLog { /* private fields */ }

In-memory log with persistent backing

Implementations

impl RaftLog

pub fn new() -> Self

Create a new empty log

pub fn append(&mut self, term: Term, command: Command) -> LogIndex

Append a new entry to the log

pub fn append_entries(&mut self, entries: Vec<LogEntry>) -> RaftResult<()>

Append multiple entries to the log

pub fn get(&self, index: LogIndex) -> Option<&LogEntry>

Get an entry by index

pub fn get_entries_from( &self, start_index: LogIndex, max_count: usize, ) -> Vec<LogEntry>

Get entries starting from a given index

pub fn get_term(&self, index: LogIndex) -> Option<Term>

Get the term of an entry by index

pub fn last_index(&self) -> LogIndex

Get the index of the last entry

pub fn last_term(&self) -> Term

Get the term of the last entry

pub fn truncate_from(&mut self, from_index: LogIndex) -> RaftResult<()>

Delete entries from a given index onwards

pub fn matches(&self, index: LogIndex, term: Term) -> bool

Check if the log contains an entry at the given index with the given term

pub fn commit_index(&self) -> LogIndex

Get the commit index

pub fn set_commit_index(&mut self, index: LogIndex) -> RaftResult<()>

Set the commit index (must be monotonically increasing)

pub fn applied_index(&self) -> LogIndex

Get the applied index

pub fn set_applied_index(&mut self, index: LogIndex) -> RaftResult<()>

Set the applied index (must be monotonically increasing)

pub fn get_uncommitted_entries(&self) -> Vec<LogEntry>

Get entries that are committed but not yet applied

pub fn compact_until(&mut self, index: LogIndex, term: Term) -> RaftResult<()>

Compact the log up to and including the given index

This removes all log entries up to index, setting the snapshot metadata to reflect the compacted state. The compacted entries are permanently discarded.

Preconditions:

• index must be at or below the applied index (already applied to state machine)
• index must be at or above the current snapshot_index

pub fn get_snapshot_point(&self) -> (LogIndex, Term)

Get the current snapshot point (last compacted index)

pub fn snapshot_index(&self) -> LogIndex

Get the snapshot index

pub fn snapshot_term(&self) -> Term

Get the snapshot term

pub fn install_snapshot( &mut self, last_included_index: LogIndex, last_included_term: Term, )

Reset the log state after installing a snapshot from a leader

This discards all existing log entries and sets the log’s base to the snapshot’s last included entry.

pub fn entries_since_snapshot(&self) -> u64

Get the number of entries since the last snapshot (useful for threshold checks)

pub fn is_empty(&self) -> bool

Check if the log is empty

pub fn len(&self) -> usize

Get the number of entries in the log

pub fn set_apply_callback<F>(&mut self, callback: F)

where F: FnMut(&LogEntry) -> RaftResult<Vec<u8>> + Send + 'static,

Register a callback that is invoked for every entry applied to the state machine. The callback receives the LogEntry and must return output bytes or an error.

pub fn apply_committed_entries(&mut self) -> RaftResult<Vec<ApplyResult>>

Apply all committed-but-not-yet-applied entries, invoking the registered callback (if any) for each one.

Returns an ApplyResult per applied entry. If no entries are pending, an empty vector is returned.

pub fn apply_batch( &mut self, max_entries: usize, ) -> RaftResult<Vec<ApplyResult>>

Apply up to max_entries committed-but-not-yet-applied entries.

If the callback returns an error mid-batch the applied_index is rolled back to its value before the call and the error is propagated.

pub fn create_snapshot(&self) -> RaftResult<SnapshotData>

Create a SnapshotData reflecting the current applied state.

The data field is left empty; callers should fill it via StateMachine::snapshot().

pub fn pending_apply_count(&self) -> usize

Number of committed entries that have not yet been applied.

pub fn is_fully_applied(&self) -> bool

Returns true when the applied index has caught up with the commit index.

Trait Implementations

impl Default for RaftLog

fn default() -> Self

Returns the “default value” for a type.