mooncakes.io

README
U
AppendEntriesArgs
U
AppendEntriesReply
U
Changer
U
ChangerConfig
U
Cluster
U
ConfChange
U
ConfChangeTransition
U
ConfChangeType
U
ConfChangeV2
U
ConfDriver
U
ConfState
U
Config
U
ConfigError
U
DemoReport
U
Entry
U
EntryId
U
EntryType
U
FullStatus
U
HardState
U
HeartbeatArgs
U
HeartbeatReply
U
Inflight
U
Inflights
U
InstallSnapshotArgs
U
InstallSnapshotReply
U
LogCompacted
U
LogLevel
U
LogSlice
U
LogStore
U
Logger
U
Membership
U
MemoryStorage
U
Message
U
Node
U
NopLogger
U
NopTracer
U
Payload
U
Persisted
U
Progress
U
ProgressState
U
ProgressStatus
U
RaftLog
U
RaftNode
U
RaftStatus
U
RaftStorage
U
RawNode
U
ReadIndexResp
U
ReadOnlyOption
U
ReadState
U
Ready
U
RequestVoteArgs
U
RequestVoteReply
U
Role
U
Snapshot
U
SoftState
U
StateMachine
U
StorageAppend
U
StorageAppendResp
U
StorageApply
U
StorageApplyResp
U
StorageError
U
TraceEvent
U
Tracer
U
Transport
U
Unstable
U
VoteState
U
WalRecord
U
WalStore
V
committed_index
V
demo_report_lines
V
demo_run
V
describe
V
describe_conf_state
V
describe_entries
V
describe_entry
V
describe_hard_state
V
describe_snapshot
V
entry_encoding_size
V
ents_size
V
hard_state_equal
V
limit_size
V
must_sync
V
no_limit
V
payload_size
V
payloads_size
V
replicate
V
run_election
V
run_single_node
V
vote_result

moonbitstack/moonraft/storage does not have a README file

LogStore

pub(open) trait LogStore {
  fn persist(Self, Persisted) -> Unit
  fn restore(Self) -> Persisted?
}

Durable storage for a node's persistent state. A real deployment backs this with a file or a database; the tests use an in-memory implementation. Keeping it a trait decouples the consensus core from any particular I/O.

RaftStorage

source

pub(open) trait RaftStorage {
  fn initial_state(Self) -> @moonbitstack/moonraft/raftpb.HardState
HardState
  fn storage_entries(Self, UInt64, UInt64, UInt64) -> Array[@moonbitstack/moonraft/raftpb.Entry
Entry] raise StorageError
  fn storage_term(Self, UInt64) -> UInt64 raise StorageError
  fn first_index(Self) -> UInt64
  fn last_index(Self) -> UInt64
  fn storage_snapshot(Self) -> @moonbitstack/moonraft/raftpb.Snapshot
Snapshot raise StorageError
  fn append(Self, Array[@moonbitstack/moonraft/raftpb.Entry
Entry]) -> Unit
}

Read access to a node's durable log, modelled on etcd's Storage interface. The consensus core reads entries, terms and the snapshot back through this trait, which lets the same core run over memory, a file or a database.

The index/term accessors raise StorageError so a compacted index is reported distinctly from an unavailable one, exactly as etcd's Storage contract requires.

WalStore

source

pub(open) trait WalStore {
  fn append_record(Self, WalRecord) -> Unit
  fn load(Self) -> Array[WalRecord]
}

Durable, append-only write-ahead log. Implemented over a file in production; the in-memory MemWal in the tests is used for tests and single-process runs.

StorageError

source

pub(all) suberror StorageError {
  Compacted
  Unavailable
  SnapOutOfDate
  SnapshotTemporarilyUnavailable
} derive(Eq)

The failure modes a RaftStorage can report, one variant per distinguishable condition so a caller can tell "this index is gone forever" apart from "this index has not arrived yet" — a distinction etcd draws with distinct sentinel errors and one the consensus core depends on to decide between sending a snapshot and simply waiting.

MemoryStorage

source

pub struct MemoryStorage {
  hard : @moonbitstack/moonraft/raftpb.HardState
HardState
  snap : @moonbitstack/moonraft/raftpb.Snapshot
Snapshot
  ents : Array[@moonbitstack/moonraft/raftpb.Entry
Entry]
  snapshot_pending : Bool
}

An in-memory RaftStorage. ents[0] is a sentinel whose index and term are the snapshot baseline, so ents[i] always holds the entry at absolute index ents[0].index + i. This mirrors etcd's MemoryStorage layout, which keeps index arithmetic branch-free.

impl RaftStorage for MemoryStorage

fn append(self : MemoryStorage, entries : Array[@moonbitstack/moonraft/raftpb.Entry
Entry]) -> Unit

source

fn first_index(self : MemoryStorage) -> UInt64

source

fn initial_state(self : MemoryStorage) -> @moonbitstack/moonraft/raftpb.HardState
HardState

source

fn last_index(self : MemoryStorage) -> UInt64

source

fn storage_entries(self : MemoryStorage, lo : UInt64, hi : UInt64, max_size : UInt64) -> Array[@moonbitstack/moonraft/raftpb.Entry
Entry] raise StorageError

source

fn storage_snapshot(self : MemoryStorage) -> @moonbitstack/moonraft/raftpb.Snapshot
Snapshot raise StorageError

source

fn storage_term(self : MemoryStorage, index : UInt64) -> UInt64 raise StorageError

source

MemoryStorage::append

source

fn MemoryStorage::append(self : MemoryStorage, entries : Array[@moonbitstack/moonraft/raftpb.Entry
Entry]) -> Unit

Append entries to the log, overwriting any conflicting suffix. Entries whose indices fall at or before the sentinel are already compacted and are dropped; a gap between the log and the incoming entries is a programming error and aborts, matching etcd's panic.

MemoryStorage::apply_snapshot

source

fn MemoryStorage::apply_snapshot(self : MemoryStorage, snapshot : @moonbitstack/moonraft/raftpb.Snapshot
Snapshot) -> Unit raise StorageError

Replace the whole log with a snapshot baseline, resetting the sentinel to the snapshot's index and term (Raft §7). A snapshot no newer than the one already stored is rejected with SnapOutOfDate.

MemoryStorage::compact

source

fn MemoryStorage::compact(self : MemoryStorage, compact_index : UInt64) -> Unit raise StorageError

Discard every entry at or before compact_index, moving the sentinel up to that index. An index at or before the current sentinel is Compacted; one past the last entry aborts (etcd panics), since it is a caller error.

MemoryStorage::create_snapshot

source

fn MemoryStorage::create_snapshot(self : MemoryStorage, index : UInt64, data : Bytes, conf_state? : @moonbitstack/moonraft/raftpb.ConfState
ConfState?) -> @moonbitstack/moonraft/raftpb.Snapshot
Snapshot raise StorageError

Build a snapshot at index carrying data, remember it, and return it. An index at or before the current snapshot is SnapOutOfDate; one past the last entry aborts (etcd panics).

MemoryStorage::from_ents

source

fn MemoryStorage::from_ents(ents : Array[@moonbitstack/moonraft/raftpb.Entry
Entry]) -> MemoryStorage

Build storage directly over a given entry array, treating ents[0] as the compaction sentinel. Mirrors etcd's &MemoryStorage{ents: ents} test setup.

MemoryStorage::new

source

fn MemoryStorage::new() -> MemoryStorage

Create empty storage: an initial HardState, the empty snapshot, and a lone sentinel entry at index 0.

MemoryStorage::raw_ents

source

fn MemoryStorage::raw_ents(self : MemoryStorage) -> Array[@moonbitstack/moonraft/raftpb.Entry
Entry]

The raw entry array, sentinel included. Test-facing, to assert the exact post-compaction/append layout the way etcd's storage tests do.

MemoryStorage::seed_snapshot

source

fn MemoryStorage::seed_snapshot(self : MemoryStorage, snapshot : @moonbitstack/moonraft/raftpb.Snapshot
Snapshot) -> Unit

Install a snapshot baseline unconditionally, resetting the sentinel to its index and term. This is the write half of apply_snapshot without the out-of-date guard, for seeding a freshly created storage whose empty baseline cannot predate anything.

MemoryStorage::set_hard_state

source

fn MemoryStorage::set_hard_state(self : MemoryStorage, hs : @moonbitstack/moonraft/raftpb.HardState
HardState) -> Unit

Record the HardState (term, vote, commit) for the next restart.

MemoryStorage::set_snapshot_pending

source

fn MemoryStorage::set_snapshot_pending(self : MemoryStorage, pending : Bool) -> Unit

Report the snapshot as not-yet-ready (true) or ready (false). Lets a backend signal that storage_snapshot() should be retried rather than treated as an error.

MemoryStorage::slice

source

fn MemoryStorage::slice(self : MemoryStorage, lo : UInt64, hi : UInt64) -> Array[@moonbitstack/moonraft/raftpb.Entry
Entry]

A best-effort, clamping read of entries with indices in [lo, hi): indices at or before the sentinel and past the last entry are simply skipped rather than raising. Used where an approximate window is wanted without the strict etcd error contract.

Persisted

source

pub(all) struct Persisted {
  term : UInt64
  voted_for : String?
  log : Array[@moonbitstack/moonraft/raftpb.Entry
Entry]
}

The persistent state a Raft node must save to stable storage before responding to any RPC (Raft §5.3): the current term, the vote cast in that term, and the log. It is exactly what a node reloads to recover after a crash.

WalRecord

source

pub(all) enum WalRecord {
  WalHardState(@moonbitstack/moonraft/raftpb.HardState
HardState)
  WalEntry(@moonbitstack/moonraft/raftpb.Entry
Entry)
  WalSnapshot(@moonbitstack/moonraft/raftpb.Snapshot
Snapshot)
} derive(Eq)

One record in the write-ahead log. A real Raft node appends these to a file (fsync'd before it replies to any RPC) and replays them in order after a crash to rebuild exactly the state it had promised (Raft §5.3, §7). A WalSnapshot marks a compaction baseline; the WalEntry records after it carry the log tail; WalHardState records the term/vote/commit at the time.