Struct LoggedEpochChange 

pub struct LoggedEpochChange { /* private fields */ }

A sequence of epochs whose current position survives a restart.

Implementations

impl LoggedEpochChange

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

Epoch-change among peers, over a leader detector with the given heartbeat and timeout and stubborn children retransmitting every retransmit.

pub fn last_timestamp(&self) -> u64

startts — the epoch this process has entered, as its durable record has it.

pub fn last_leader(&self) -> NodeId

start — who leads the epoch this process has entered.

pub fn trusted(&self) -> NodeId

Who this process currently trusts.

pub fn candidate(&self) -> u64

ts — this process’s own next candidate. Volatile; see the module documentation.

Trait Implementations

impl Debug for LoggedEpochChange

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

Formats the value using the given formatter.

impl Protocol for LoggedEpochChange

type Entry = Infallible

Nothing accumulates: the epoch entered is one value, rewritten.

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

upon event ⟨ lec, Init ⟩ — the state is set in new; this starts the detector.

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

upon event ⟨ lec, Recovery ⟩ do retrieve(startts, start).

No StartEpoch is raised. The epoch is not new — this process entered it before it went down, and told the layer above so at the time. Re-raising it would announce as fresh an epoch whose consensus instance already exists, which is the layer above’s business to reconstruct from its own record and not this layer’s to invent.

type Cmd = Infallible

Requests from the layer above.

type Ind = Ind

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

type Msg = Wire

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 = Started

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, _: &mut ProtoCx<'_, Self>)

Handle a request from the layer above.

fn on_msg(&mut self, from: NodeId, msg: Wire, 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.