Struct LazyProbabilisticBroadcast 

pub struct LazyProbabilisticBroadcast<P, L = FairLossLink<Recovery<P>>, G = FairLossLink<Carried<Data<P>>>>
where
    P: Clone + Serialize + DeserializeOwned,
    L: VolatileLink<Recovery<P>>,
    L::Scope: Clone,
    G: VolatileLink<Carried<Data<P>>, Scope = L::Scope>,
{ /* private fields */ }

Gossip with recovery.

Two links, both parameters: L carries the recovery traffic and G carries the gossip. Over sessions both are session links — two instances each holding one epoch per peer, both handed every scope event, on one wire — which is how crate::uniform_reliable_broadcast already puts a broadcast and a detector together. Their scopes must agree (G::Scope = L::Scope), because a scope event reaching this layer is one event about one session and goes to both.

Implementations

impl<P> LazyProbabilisticBroadcast<P, FairLossLink<Recovery<P>>>

where P: Clone + Serialize + DeserializeOwned,

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

Lazy probabilistic broadcast among peers, over the fair-loss links the book names.

impl<P, L> LazyProbabilisticBroadcast<P, L>

where P: Clone + Serialize + DeserializeOwned, L: VolatileLink<Recovery<P>, Scope = Infallible>,

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

Lazy probabilistic broadcast, over the link supplied for its recovery traffic and the book’s fair-loss link for the gossip.

Only for a recovery link that reports no boundary: the gossip beneath runs over a fair-loss link here, and the two links’ scopes have to agree. Over sessions use LazyProbabilisticBroadcast::with_links with a session link for both.

impl<P, L, G> LazyProbabilisticBroadcast<P, L, G>

where P: Clone + Serialize + DeserializeOwned, L: VolatileLink<Recovery<P>>, L::Scope: Clone, G: VolatileLink<Carried<Data<P>>, Scope = L::Scope>,

pub fn with_links( me: NodeId, peers: impl IntoIterator<Item = NodeId>, gossip: G, recovery: L, config: Config, ) -> Self

Lazy probabilistic broadcast over two links: gossip beneath the eager broadcast that disseminates data, recovery for the requests and answers that repair gaps.

pub fn gossip_link(&self) -> &G

The link the gossip travels over.

pub fn recovery_link(&self) -> &L

The link the recovery traffic travels over.

pub fn next_expected_of(&self, sender: Sender) -> u64

next[s], which is one until this process has delivered anything from s.

pub fn next_expected(&self, from: NodeId) -> u64

next[s] for the incarnation of from most recently heard from, or one if none has been.

pub fn latest(&self, from: NodeId) -> Option<Sender>

The incarnation of from most recently admitted, if any.

pub fn incarnations_of(&self, from: NodeId) -> usize

How many incarnations of from this process keeps state for.

pub fn pending_count(&self) -> usize

How many messages this process is holding ahead of a gap.

pub fn stored_count(&self) -> usize

How many copies this process is holding for answering requests.

pub fn has_stored(&self, origin: NodeId, seq: u64) -> bool

Whether this process could answer a request for seq from the incarnation of origin most recently heard from.

Trait Implementations

impl<P, L, G> Protocol for LazyProbabilisticBroadcast<P, L, G>

where P: Clone + Serialize + DeserializeOwned, L: VolatileLink<Recovery<P>>, L::Scope: Clone, G: VolatileLink<Carried<Data<P>>, Scope = L::Scope>,

type Meta = Infallible

Keeps nothing durably.

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

upon event ⟨ pb, Broadcast | m ⟩ do lsn := lsn + 1; trigger ⟨ upb, Broadcast | [DATA, …] ⟩.

Note what is not here: no delivery to self. The eager child beneath delivers a broadcast to its own process, and that arrives back through on_upb_deliver like any other, which is what puts this process’s own messages through the same sequence check as everyone else’s.

fn on_timer(&mut self, id: TimerId, cx: &mut ProtoCx<'_, Self>)

upon event ⟨ Timeout | s, sn ⟩ do if sn > next[s] then next[s] := sn + 1.

The gap is abandoned, and sn with it — the book skips past the message the timer was waiting on, not to it. Whatever is now deliverable is released by the standing condition, which is why the drain follows.

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

Both children run over the same session, so both are told when it ends or begins.

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

Name this incarnation, then start the children. Runs on every restart, which is the point.

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<<G as Protocol>::Msg, <L as Protocol>::Msg>

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

type Scope = <L as Protocol>::Scope

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_msg(&mut self, from: NodeId, msg: Self::Msg, cx: &mut ProtoCx<'_, Self>)

Handle a message received from from.

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.