Struct LoggedUniformReliableBroadcast 

pub struct LoggedUniformReliableBroadcast<P: Clone + Ord> { /* private fields */ }

Uniform agreement over log-delivery, in the fail-recovery model.

Implementations

impl<P: Clone + Ord> LoggedUniformReliableBroadcast<P>

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

Broadcast among members, which must include me, retransmitting every interval.

pub fn log(&self) -> &Logged<P>

The durable log. The same value the layer above is handed.

pub fn majority(&self) -> usize

How many processes must have re-broadcast a message before it is log-delivered.

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

Which processes have been seen to re-broadcast id. Volatile, and rebuilt on recovery.

Trait Implementations

impl<P: Debug + Clone + Ord> Debug for LoggedUniformReliableBroadcast<P>

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

Formats the value using the given formatter.

impl<P: Clone + Ord> Protocol for LoggedUniformReliableBroadcast<P>

type Meta = ()

Nothing is rewritten; the metadata is written once so a restart finds something.

type Entry = Record<P>

One record per message seen or log-delivered. ack is not among them, by design.

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

⟨ lurb, Init ⟩ do delivered := ∅; pending := ∅; ...; store(pending, delivered).

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

upon event ⟨ lurb, Recovery ⟩.

Re-announce the log, then re-broadcast everything pending — which is what rebuilds ack, and why it need not be durable. The replay also restores the send counter, so a process that goes on to broadcast something new does not reuse an identifier.

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 = Data<P>

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

type Scope = Infallible

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.

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: Data<P>, 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_scope_event( &mut self, _scope: Self::Scope, _cx: &mut Cx<'_, Self::Msg, Self::Ind, Self::Note, Self::Meta, Self::Entry>, )

Handle a boundary of a scope this protocol’s guarantees depend on — its end, or the beginning of the one that succeeds it.