Struct ProbabilisticBroadcast 

pub struct ProbabilisticBroadcast<P: Clone, L: VolatileLink<Carried<P>> = FairLossLink<Gossip<P>>> { /* private fields */ }

Gossip: relay to a random few, for a bounded number of rounds.

L is the link beneath and it is a parameter, so this composes over a perfect link, a session link, or an application’s own. It bounds on crate::link::Link rather than anything narrower because gossip needs nothing of a scope boundary beyond passing it upward.

Implementations

impl<P: Clone> ProbabilisticBroadcast<P, FairLossLink<Gossip<P>>>

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

Gossip among peers, over the fair-loss link Algorithm 3.9 names.

The book says Uses: FairLossPointToPointLinks and this default honours it. A perfect link would retransmit until delivery, which masks the probabilistic guarantee this abstraction exists to provide — and would never fall silent, because the stubborn link beneath it re-sends everything it has ever sent. Gossip over a link that does not lose is gossip with nothing to do.

impl<P: Clone, L: VolatileLink<Carried<P>>> ProbabilisticBroadcast<P, L>

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

Gossip among peers, over the link supplied.

pub fn remembered(&self) -> usize

How many identifiers this process is currently remembering. For the bound test.

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

Whether this process has delivered id and still remembers doing so.

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

The processes this instance gossips among, in a stable order.

impl<P: Clone, L> ProbabilisticBroadcast<P, L>

where L: VolatileLink<Carried<P>>,

pub fn link(&self) -> &L

The link beneath.

Trait Implementations

impl<P: Debug + Clone, L: Debug + VolatileLink<Carried<P>>> Debug for ProbabilisticBroadcast<P, L>

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

Formats the value using the given formatter.

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

where L: VolatileLink<Carried<P>>,

type Scope = <L as Protocol>::Scope

Whatever the link’s guarantees are conditional on. This layer adds no condition of its own and cannot bridge the link’s.

type Meta = Infallible

Keeps nothing durably: a crash loses everything this protocol knows, which is why PB2 is scoped to the window within an incarnation and says nothing across one.

fn on_cmd(&mut self, Cmd::Broadcast: Cmd<P>, cx: &mut ProtoCx<'_, Self>)

upon event ⟨ pb, Broadcast | m ⟩ — deliver to self, then gossip.

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

Name this incarnation. Runs on a first start and on every restart, which is the point: a restarted process is a new incarnation and its identifiers must say so.

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

Hand the scope ending down to the link. 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 = <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_msg(&mut self, from: NodeId, msg: 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.