Struct LoggedLink 

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

Perfect-link guarantees over log-delivery, so that they hold across a restart.

Implementations

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

pub fn new(me: NodeId, retransmit: Duration) -> Self

Log-deliver for me, retransmitting every retransmit.

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

What has been log-delivered. The same value the layer above is handed.

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Meta = u64

The send counter: one small value, rewritten before each send. See the module note.

type Entry = (MsgId, P)

One log-delivered message; appended, so the write cost is linear rather than quadratic.

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

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

The initial write is what makes the branch real: after it, storage holds something, so every later restart takes the recovery path rather than starting afresh. What is written is the send counter at zero — the empty set is the empty sequence of entries, which needs no write of its own.

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

upon event ⟨ lpl, Recovery ⟩ do retrieve(delivered); trigger ⟨ lpl, Deliver | delivered ⟩.

The record is read here rather than handed over, along with the send counter that keys it. Nothing else is dispatched until this returns, which is what makes it safe to have held an empty index a moment ago.

The layer above is told again: the notification sent before the crash may have been lost with the incarnation that sent 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<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<P>, cx: &mut ProtoCx<'_, Self>)

Handle a request from the layer above.

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