Struct EpochConsensus 

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

Abortable consensus within one epoch.

Implementations

impl<V: Clone> EpochConsensus<V>

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

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

pub fn timestamp(&self) -> u64

This epoch’s timestamp.

pub fn is_aborted(&self) -> bool

Whether this instance has been abandoned and is therefore silent.

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

What this process has accepted, and when.

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Meta = Infallible

Keeps nothing durably. logged_epoch_consensus is the variant that does.

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

such that ts = ets, applied at the door rather than after the link beneath.

The guard has to be here, not only where the delivery is handled, and the reason is the perfect link’s duplicate-detection set. Each epoch gets a new instance, so each epoch gets a new link, and a new link restarts its sequence numbers at one — while the receiver’s set is cleared at a different moment, when its own epoch changes. Hand a foreign-epoch message to the link and it records (src, 1) as delivered; the real epoch-ets message with sequence one is then discarded as a duplicate, silently, and that process never answers the leader again. Three of five processes stalled this way before the guard moved up here.

This is CLAUDE.md’s “identity is as durable as the state it keys” seen from the other side: the identifier’s scope is one epoch, so nothing outside that epoch may enter the set that keys on it.

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<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_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_init( &mut self, _cx: &mut Cx<'_, Self::Msg, Self::Ind, Self::Note, Self::Meta, Self::Entry>, )

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.