Struct StandbyRow 

pub struct StandbyRow {
    pub name: String,
    pub remote: String,
    pub pending: u64,
    pub consecutive_failures: u32,
    pub last_error: String,
    pub last_success_unix_ms: i64,
    pub needs_full_resync: bool,
    pub stale: bool,
    pub in_flight: String,
    pub outstanding_for_ms: i64,
    pub behind: bool,
}

One standby’s state, flattened.

Fields

name: String

The operator’s name for it.

remote: String

Where it is.

pending: u64

Repositories with work outstanding.

consecutive_failures: u32

Consecutive failures for the job at the head of the queue.

last_error: String

The last failure since the last success.

last_success_unix_ms: i64

Zero means NEVER, and that is the value this whole module exists for. Not “unknown”, not “just now”.

needs_full_resync: bool

A hole retrying will not close; gunnar control replication resync is the fix.

stale: bool

Work is stuck and nothing has landed for STALENESS_FACTORx the retry ceiling. See is_stale — this is NOT “the last success is old”, which is what it used to be and what made an idle box shout. Never is not folded in here; it is Verdict::Never.

in_flight: String

The repository an attempt is in flight for, empty when none.

outstanding_for_ms: i64

How long the oldest outstanding repository has been outstanding, ms. Zero when there is none.

behind: bool

Outstanding work older than the retry ceiling. See BEHIND_AFTER_RETRY_MAX.

Implementations

impl StandbyRow

pub fn never_synced(&self) -> bool

Has a byte ever reached this standby?

The distinction is not cosmetic. “It has not synced for six hours” is a standby that was working and stopped; “it has never synced” is a standby that has never worked, and the second one means the durability promise on this box does not exist. They need different sentences because they need different actions.

pub fn verdict(&self) -> Verdict

The one word this row says. See Verdict.

Every surface asks this rather than reading the booleans itself: the console badge, the CLI row, the band and the alarm all print what this returns, so “is it stale?” has exactly one answer per snapshot.

pub fn since_last_success(&self, now_unix_ms: i64) -> Option<i64>

Seconds since the last success, or None when there has never been one.

pub fn describe(&self, synced: u64, failed: u64, now_unix_ms: i64) -> String

The band’s row and the log line, one writer (one implementation).

standby  synced 105  failed 40  last 00:00:03 ago  idle
standby  synced 0  failed 8  last successful replication: NEVER

The word comes from Self::verdict, so idle is printed rather than left blank: a row with no word on it is a row an operator has to guess about, and guessing is what STALE on a healthy box taught them to do. BEHIND is not repeated here — Self::outstanding carries it beside the work it is about.

pub fn outstanding(&self) -> String

The clock that keeps ticking while a standby is dead, as the tail of a row: pending 3 in flight alice/x outstanding 00:01:03 BEHIND.

Empty when nothing is outstanding, so a healthy idle standby’s row is unchanged.

Trait Implementations

impl Clone for StandbyRow

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StandbyRow

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

Formats the value using the given formatter.

impl Default for StandbyRow

fn default() -> Self

Returns the “default value” for a type.

impl Eq for StandbyRow

impl PartialEq for StandbyRow

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for StandbyRow