Struct MemoryLog 

pub struct MemoryLog { /* private fields */ }

An in-memory RaftLog backed by a Vec.

This is the default store and the one RaftNode::new uses. It keeps entries in a vector (entry at index i lives at slot i - 1) and the hard state in a field. Nothing is durable across a process restart — it is for tests, examples, and the single-node path, not production. Its operations never fail except on a misuse that would corrupt the log (a non-contiguous append or a truncate(0)).

After a snapshot is installed the log is compacted: entries up to the snapshot’s index are dropped and base_index / base_term become the log’s new starting boundary, so reads below the boundary return None while term_at still answers for the boundary index itself.

Examples

use raft_io::{HardState, LogEntry, MemoryLog, RaftLog};

let mut log = MemoryLog::new();
assert_eq!(log.last_index(), 0);

log.append(&[LogEntry::new(1, 1, b"x".to_vec())]).unwrap();
log.set_hard_state(HardState { term: 1, voted_for: Some(1) }).unwrap();
log.sync().unwrap();

assert_eq!(log.last_index(), 1);
assert_eq!(log.hard_state().voted_for, Some(1));

Implementations

impl MemoryLog

pub fn new() -> Self

Creates an empty in-memory log.

Examples

use raft_io::{MemoryLog, RaftLog};

let log = MemoryLog::new();
assert_eq!(log.last_index(), 0);

pub fn len(&self) -> usize

Returns the number of entries currently stored.

Examples

use raft_io::{LogEntry, MemoryLog, RaftLog};

let mut log = MemoryLog::new();
log.append(&[LogEntry::new(1, 1, vec![])]).unwrap();
assert_eq!(log.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the log holds no entries.

Examples

use raft_io::MemoryLog;

assert!(MemoryLog::new().is_empty());

Trait Implementations

impl Clone for MemoryLog

fn clone(&self) -> MemoryLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryLog

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

Formats the value using the given formatter.

impl Default for MemoryLog

fn default() -> MemoryLog

Returns the “default value” for a type.

impl RaftLog for MemoryLog

fn last_index(&self) -> Index

Returns the index of the last entry, or 0 if the log is empty.

fn last_term(&self) -> Term

Returns the term of the last entry, or 0 if the log is empty.

fn term_at(&self, index: Index) -> Option<Term>

Returns the term of the entry at index.

fn entry(&self, index: Index) -> Option<LogEntry>

Returns the entry at index, or None if there is none.

fn entries(&self, from: Index, to: Index) -> Vec<LogEntry>

Returns the entries in the inclusive index range [from, to].

fn append(&mut self, entries: &[LogEntry]) -> Result<()>

Appends entries to the end of the log.

fn truncate(&mut self, from: Index) -> Result<()>

Removes every entry whose index is >= from.

fn hard_state(&self) -> HardState

Returns the persisted HardState (current term and vote).

fn set_hard_state(&mut self, state: HardState) -> Result<()>

Persists state as the new HardState.

fn sync(&mut self) -> Result<()>

Flushes all preceding writes to durable storage.

fn snapshot_index(&self) -> Index

Returns the index the log has been compacted up to — the last index a snapshot includes — or 0 if there is no snapshot.

fn snapshot(&self) -> Option<Snapshot>

Returns the current snapshot, if one exists.

fn apply_snapshot(&mut self, snapshot: &Snapshot) -> Result<()>

Installs snapshot, replacing the prefix it subsumes.