Struct UniformReliableBroadcast 

pub struct UniformReliableBroadcast<P: Clone, L: VolatileLink<Data<P>> = PerfectLink<Data<P>>> { /* private fields */ }

Broadcast with uniform agreement, over best-effort broadcast and a failure detector.

Implementations

impl<P: Clone> UniformReliableBroadcast<P, PerfectLink<Data<P>>>

pub fn new( me: NodeId, members: impl IntoIterator<Item = NodeId>, retransmit: Duration, heartbeat: Duration, detect_after: Duration, ) -> Self

Broadcast among members, which must include me.

heartbeat and detect_after configure the failure detector; detect_after must exceed heartbeat plus the network’s delivery bound, or the detector will accuse correct processes and uniform agreement can break.

impl<P: Clone, L: VolatileLink<Data<P>>> UniformReliableBroadcast<P, L>

pub fn with_link( me: NodeId, members: impl IntoIterator<Item = NodeId>, link: L, heartbeat: Duration, detect_after: Duration, ) -> Self

Broadcast among members, over the link supplied.

pub fn correct(&self) -> impl Iterator<Item = NodeId> + '_

The processes still believed correct, in a stable order.

pub fn delivered_count(&self) -> usize

How many distinct messages have been delivered upward.

pub fn pending_count(&self) -> usize

Messages seen but not yet deliverable.

pub fn acknowledged_by( &self, id: BroadcastId, ) -> impl Iterator<Item = NodeId> + '_

Which processes have acknowledged id, for tests that need to see the condition forming.

Trait Implementations

impl<P: Debug + Clone, L: Debug + VolatileLink<Data<P>>> Debug for UniformReliableBroadcast<P, L>

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

Formats the value using the given formatter.

impl<P: Clone, L> Protocol for UniformReliableBroadcast<P, L>

where L: VolatileLink<Data<P>>,

type Scope = <L as Protocol>::Scope

No scope conditions: this protocol’s guarantees do not lapse. Whatever the link’s guarantees are conditional on. This layer bridges an ending rather than absorbing it, but bridging is not the same as never having lapsed.

type Meta = Infallible

Keeps nothing durably: a crash loses everything this protocol knows.

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

Failure detection begins here, as Module 2.6 has it. It used to need a Start command because there was no init event to hang the detector’s first timer on.

fn on_scope_event(&mut self, scope: L::Scope, cx: &mut ProtoCx<'_, Self>)

Hand the scope ending down to the children. The trait’s default would drop it.

type Cmd = Cmd<P>

Requests from the layer above.

type Ind = Ind<P>

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

type Msg = Wire<<L as Protocol>::Msg>

What crosses the wire to a peer running the same protocol.

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

Handle a request from the layer above.

fn on_msg( &mut self, from: NodeId, msg: Wire<L::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_recovery( &mut self, _cx: &mut Cx<'_, Self::Msg, Self::Ind, Self::Note, Self::Meta, Self::Entry>, )

Resume after a crash, reading what survived.