Struct LoggedLeaderDrivenConsensus 

pub struct LoggedLeaderDrivenConsensus<V: Clone> { /* private fields */ }

Paxos in the fail-recovery model.

Implementations

impl<V: Clone + PartialEq> LoggedLeaderDrivenConsensus<V>

pub fn new( me: NodeId, peers: impl IntoIterator<Item = NodeId>, timing: Timing, ) -> Self

Paxos among peers, over stable storage.

pub fn epoch(&self) -> u64

The epoch now live at this process.

pub fn leader(&self) -> NodeId

Who leads the epoch now live.

pub fn decision(&self) -> Option<&V>

What this process decided, if it has.

pub fn state(&self) -> &State<V>

(valts, val) as the epoch now live holds it — what the abort handshake carries forward.

Trait Implementations

impl<V: Clone + PartialEq> Protocol for LoggedLeaderDrivenConsensus<V>

type Entry = Infallible

Nothing accumulates: one epoch, one leader, one decision, and one record per child.

fn on_cmd(&mut self, Cmd::Propose: Cmd<V>, cx: &mut ProtoCx<'_, Self>)

upon event ⟨ luc, Propose | v ⟩ do val := v.

fn on_init(&mut self, cx: &mut ProtoCx<'_, Self>)

upon event ⟨ luc, Init ⟩ … store(ets, ℓ, decision).

This process’s own record goes down first, then each child’s, so the record exists before anything writes into a slot of it.

fn on_recovery(&mut self, cx: &mut ProtoCx<'_, Self>)

upon event ⟨ luc, Recovery ⟩.

The book reads its children’s records by name — retrieve(startts, start) of instance lec, retrieve(epochdecision) of instance lep.ets. Here each child reads its own slot in its own Recovery, which is the same statement in the direction the composition runs.

type Cmd = Cmd<V>

Requests from the layer above.

type Ind = Ind<V>

Indications to the layer above — this protocol delivering on its guarantee.

type Msg = Wire<V>

What crosses the wire to a peer running the same protocol.

type Scope = Infallible

Scopes whose boundaries this protocol’s guarantees depend on, and which it can observe.

type Note = Note

The vocabulary in which this protocol narrates its decisions.

type Meta = Durable<V>

The durable value this protocol rewrites: a position, a count, an epoch. Small enough that rewriting it costs nothing.

fn on_msg(&mut self, from: NodeId, msg: Wire<V>, cx: &mut ProtoCx<'_, Self>)

Handle a message received from from.

fn on_timer(&mut self, id: TimerId, cx: &mut ProtoCx<'_, Self>)

Handle a timer that fired somewhere in this protocol or in what it composes.

fn on_scope_event( &mut self, _scope: Self::Scope, _cx: &mut Cx<'_, Self::Msg, Self::Ind, Self::Note, Self::Meta, Self::Entry>, )

Handle a boundary of a scope this protocol’s guarantees depend on — its end, or the beginning of the one that succeeds it.