Enum Ind 

pub enum Ind<C> {
    Decision {
        slot: Slot,
        command: C,
    },
    Collected {
        slot: Slot,
    },
    CatchUpWanted {
        peer: NodeId,
        from_slot: Slot,
    },
    SessionEnded {
        peer: NodeId,
        epoch: u64,
    },
    SessionEstablished {
        peer: NodeId,
        epoch: u64,
    },
}

Indications to the layer above.

Variants

Decision

send(ρ, ⟨decision, s, c⟩) — a majority of acceptors accepted this pvalue, so command is chosen for slot. Figure 6(a) addresses this to the replicas; there is no replica here, so it is raised to whatever is above.

Fields

slot: Slot

command: C

Collected

A proposal was refused because the slot is below this process’s collection watermark: it is decided, f + 1 members hold the decision, and this layer no longer does.

The layer above must catch up from a peer, which is what Cmd::CatchUp asks for. Without it a correct process that missed one decision is stranded for ever, because the only other way back — a leader answering a re-proposal — needs the record this layer discarded.

Fields

slot: Slot

CatchUpWanted

peer has fallen behind and wants the decisions from from_slot onwards. The layer above answers with Cmd::Teach for what it still holds.

Fields

peer: NodeId

from_slot: Slot

SessionEnded

The scope with peer ended at epoch. Propagated, not absorbed: this layer holds no redundancy that outlives a session — what it knows of a ballot is in memory a crash takes, and its redundancy is the other processes rather than a resend across an ending. A layer above may need to know that an answer it was waiting for will not arrive.

Fields

peer: NodeId

epoch: u64

SessionEstablished

A scope with peer is in force at epoch.

Fields

peer: NodeId

epoch: u64

Trait Implementations

impl<C: Clone> Clone for Ind<C>

fn clone(&self) -> Ind<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for Ind<C>

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

Formats the value using the given formatter.

impl<C: Eq> Eq for Ind<C>

impl<C: PartialEq> PartialEq for Ind<C>

fn eq(&self, other: &Ind<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C: PartialEq> StructuralPartialEq for Ind<C>