Struct LeaderDrivenConsensus 

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

Paxos: uniform consensus over an epoch-change and a sequence of abortable epoch consensuses.

Implementations

impl<V: Clone> LeaderDrivenConsensus<V>

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

Paxos among peers.

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 has_decided(&self) -> bool

Whether this process has reported a decision.

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

(valts, val) as the epoch now live holds it.

This is what the abort handshake carries forward: the state a new instance is constructed from is the state the aborted one returned, so a value accepted in an early epoch is still here after several leadership changes.

Trait Implementations

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

type Meta = Infallible

Keeps nothing durably. logged_leader_driven_consensus is the variant that does.

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

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

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<<EpochChange as Protocol>::Msg, Wire<Tagged<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 Entry = Infallible

The durable entries this protocol appends: what accumulates.

fn on_msg(&mut self, from: NodeId, msg: Self::Msg, 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_init(&mut self, cx: &mut ProtoCx<'_, Self>)

Begin, on a first start — when nothing has been written down.

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

Resume after a crash, reading what survived.

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.