Struct PerfectLink 

pub struct PerfectLink<P> { /* private fields */ }

Reliable delivery, exactly once, over a stubborn link.

Implementations

impl<P> PerfectLink<P>

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

A perfect link for process me, retransmitting every interval underneath.

pub fn delivered_count(&self) -> usize

How many distinct messages have been delivered upward.

pub fn outstanding(&self) -> usize

How many transmissions the layer below is still retrying.

Trait Implementations

impl<P: Debug> Debug for PerfectLink<P>

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

Formats the value using the given formatter.

impl<P> Link<P> for PerfectLink<P>

where P: Clone,

The perfect link satisfies the link port, and reports no scope boundary.

Link::classify here never yields LinkInd::Boundary: PL2’s no-duplication holds within one incarnation of the recipient, and this link has no means of observing that incarnation ending. A link that reported a boundary it cannot see would be asserting something it does not know, which docs/scope-annotated-modules.md forbids by Definition 2a.

Nothing in the type system enforces that, and crate::link records why: a ScopedLink marker trait existed for exactly this and was deleted for want of a consumer — the one layer that should have bounded on it could not, because its resend lives in the Link impl and the tighter bound would have fallen on every link. What keeps it honest instead is the classification itself, and tests/link_port.rs pins both halves: that this link’s classification never yields a boundary, and that the session link’s yields one for each variant that reports it.

fn send(to: NodeId, msg: P) -> Cmd<P>

The request that sends msg to to.

fn classify(_: Ind<P>) -> LinkInd<P>

What this indication means to the layer above.

impl<P: Clone> Protocol for PerfectLink<P>

type Scope = Infallible

No scope conditions: this protocol’s guarantees do not lapse.

type Meta = Infallible

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

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 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<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_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.

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.