Struct ReliableBroadcast 

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

Broadcast with agreement, over best-effort broadcast.

Implementations

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

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

Reliable broadcast for process me among peers, over links retransmitting every interval.

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

pub fn with_link( me: NodeId, peers: impl IntoIterator<Item = NodeId>, link: L, ) -> Self

Reliable broadcast for process me among peers, over the link supplied.

pub fn delivered_count(&self) -> usize

How many distinct broadcasts this process has delivered upward.

pub fn has_delivered(&self, id: BroadcastId) -> bool

Whether this process has already delivered id.

Trait Implementations

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

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

Formats the value using the given formatter.

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

where L: VolatileLink<Data<P>>,

type Scope = <L as Protocol>::Scope

Whatever the link’s guarantees are conditional on. RB4 is scoped to the sessions that carried the relay, and this layer cannot bridge one ending.

type Meta = Infallible

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

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

Hand the scope ending down. This layer cannot bridge one, and the 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 = <BestEffortBroadcast<Data<P>, 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::Broadcast: Cmd<P>, cx: &mut ProtoCx<'_, Self>)

Handle a request from the layer above.

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