Struct LoopProgressMark 

pub struct LoopProgressMark { /* private fields */ }

Where one integrator’s loop had got to the last time it asked.

Three numbers and nothing else: the furthest record this binding has been offered something from, how many of its deliveries had been closed, and how many asks it has spent since either of those last moved. A round is one ask, which is the only thing that makes “going round without getting anywhere” measurable — the ledger can say what is outstanding but not how many times a host has come back to look at it, and a lease is about exclusion rather than rounds.

The head is this binding’s own, not the engine’s. A cursor walks the global feed and advances over every ceremony in the deployment, so a busy neighbour would move it every second and hide a stall for ever.

Kept on the binding because it is the binding’s, and durable because a process that restarted mid-loop would otherwise come back with a fresh count and go round for ever.

Implementations

impl LoopProgressMark

pub const fn new( head: Option<GlobalPosition>, closed: u32, rounds: u32, stuck: u32, ) -> Self

pub fn observing( self, head: Option<GlobalPosition>, closed: u32, owed: Owed, ) -> Self

The mark after one more ask, given what that ask could see.

A round counts against the loop only when the binding was holding work and neither the news nor the work moved. The two halves matter separately. Without the first, a loop that polls while an agent works a long step is declared stuck on its third second. Without the second, a host that takes something and does nothing with it is never noticed.

Both readings are of durable facts — what this binding has been offered, and what it has closed — so the same ask reaches the same conclusion before and after a restart.

pub fn differs_from(self, previous: Self) -> bool

Whether this mark says anything the last one did not.

The ask count always moves, and on its own it changes no decision unless the policy set a ceiling. Everything else is what the stall is read from.

pub const fn head(self) -> Option<GlobalPosition>

How far the feed had been projected when this binding last asked.

pub const fn closed(self) -> u32

Deliveries of this binding’s that had been closed by then.

pub const fn rounds(self) -> u32

Asks this binding has made, over its life.

pub const fn stuck(self) -> u32

Consecutive asks that found the same head and the same closed count as the one before.

Trait Implementations

impl Clone for LoopProgressMark

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for LoopProgressMark

impl Debug for LoopProgressMark

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

Formats the value using the given formatter.

impl Default for LoopProgressMark

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LoopProgressMark

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LoopProgressMark

impl PartialEq for LoopProgressMark

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for LoopProgressMark

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LoopProgressMark