Struct LoggedEpochConsensus 

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

Abortable consensus within one epoch, whose acceptances survive a restart.

Implementations

impl<V: Clone> LoggedEpochConsensus<V>

pub fn new( me: NodeId, peers: impl IntoIterator<Item = NodeId>, ets: u64, leader: NodeId, state: State<V>, retransmit: Duration, ) -> Self

⟨ lep, Init | state ⟩ — an instance for epoch ets led by leader, beginning from state.

The book’s store(valts, val) in Init happens on the first event this instance handles, because a constructor has no context to write through. [Protocol::on_init] is where it lands, and it lands before anything is sent.

pub fn timestamp(&self) -> u64

ets.

pub fn is_aborted(&self) -> bool

Whether this instance has been abandoned.

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

(valts, val) — what this process has accepted.

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

epochdecision — what this epoch decided, if this process saw it decide.

Read by the layer above after a recovery: retrieve(epochdecision) of instance lep.ets is how Algorithm 5.10 learns that a process had decided before it went down.

Trait Implementations

impl<V: Debug + Clone> Debug for LoggedEpochConsensus<V>

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

Formats the value using the given formatter.

impl<V: Clone> Protocol for LoggedEpochConsensus<V>

type Entry = Infallible

An epoch accepts at most one value and decides at most one. Nothing accumulates.

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

such that ts = ets, applied at the door.

Unlike crate::epoch_consensus, the link beneath keeps no duplicate set for a foreign message to poison — it deduplicates nothing at all. The guard is here for the safety reason alone: an acceptance recorded at the wrong timestamp is an acceptance that never happened.

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

upon event ⟨ lep, Init | state ⟩ do (valts, val) := state; store(valts, val); …

The state came in through the constructor; this is where it becomes durable, before this instance answers anything.

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

upon event ⟨ lep, Recovery ⟩ do retrieve(valts, val).

epochdecision comes back with it, because they share one metadata value. Nothing is re-indicated: a process that decided before it went down told the layer above at the time, and it is that layer’s own record — not a second Decide from here — that restores it. See LoggedEpochConsensus::epoch_decision.

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_cmd(&mut self, cmd: Cmd<V>, cx: &mut ProtoCx<'_, Self>)

Handle a request from the layer above.

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.