Struct WalLog 

pub struct WalLog { /* private fields */ }

Available on crate feature persistence only.

A durable RaftLog whose entries and hard state survive a process restart.

Open it with open and hand it to RaftNode::with_log. Reads are served from an in-memory index; writes are appended to the underlying wal-db log and become durable when sync returns Ok.

Examples

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

let mut log = WalLog::open("raft.wal")?;
log.append(&[LogEntry::new(1, 1, b"set x = 1".to_vec())])?;
log.sync()?; // durable from here

// After a restart, reopening the same path recovers the entry.
let recovered = WalLog::open("raft.wal")?;
assert_eq!(recovered.last_index(), 1);

Implementations

impl WalLog

pub fn open(path: impl AsRef<Path>) -> Result<Self>

Opens the durable log at path, replaying any existing records to recover the log entries and hard state.

Creates the file if it does not exist. Recovery is exact: the recovered state is the logical result of every mutation that was appended before the process stopped.

Errors

Returns Error::Storage if the WAL cannot be opened or a record fails to decode (for example, a checksum mismatch reported by wal-db).

Trait Implementations

impl RaftLog for WalLog

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.