Struct Machine 

pub(crate) struct Machine {

    config: Config,
    relay: String,
    state: Option<PresenceState>,
    since_wall_ms: u64,
    reason: Option<String>,
    last_ok_wall_ms: Option<u64>,
    failures: u32,
    due_ms: u64,
    health_due_ms: Option<u64>,
    dirty: bool,
    followups: Followups,
    older_until_ms: HashMap<String, (u32, u64)>,
    offset_ms: Option<i64>,
    relay_version: Option<String>,
    version_at_404: Option<String>,
    outage_since_ms: Option<u64>,
    outage_warned: bool,
    off: Option<PresenceOffReason>,
    goodbye_sent: bool,
}

Fields

config: Config

relay: String

state: Option<PresenceState>

None until the first state is entered.

since_wall_ms: u64

reason: Option<String>

last_ok_wall_ms: Option<u64>

failures: u32

due_ms: u64

health_due_ms: Option<u64>

dirty: bool

followups: Followups

older_until_ms: HashMap<String, (u32, u64)>

Relays that took only an older version: which, and until when.

offset_ms: Option<i64>

relay_version: Option<String>

version_at_404: Option<String>

The relay’s version just after its 404.

outage_since_ms: Option<u64>

outage_warned: bool

off: Option<PresenceOffReason>

Why this install doesn’t publish; None while it does.

goodbye_sent: bool

This machine asked for a goodbye (Action::Goodbye) whose result hasn’t come back yet. A sign-out reports Event::Goodbye too, even when none was due, so only this says the result is worth logging.

Implementations

impl Machine

pub(crate) fn new(config: Config, relay: &str) -> Self

pub(crate) fn follows_changes(&self) -> bool

Whether a snapshot change is published (after the debounce), rather than only marked dirty.

pub(crate) fn stamp(&self, wall_ms: u64) -> u64

published_at_ms for a record sent at wall_ms: on the relay’s clock when an answer has told it, else this computer’s.

pub(crate) fn farewell(&self, now: &Now) -> Option<Farewell>

Whether a goodbye is due if this install went away now: something was published, publishing is on and no goodbye has been said since, and the relay takes v2 or later (one that took only v1 would refuse v3).

pub(crate) fn record_version(&self, now: &Now) -> u32

The version a fresh try sends: an older one while this relay is remembered as taking only that.

pub(crate) fn next(&mut self, event: Event, now: Now) -> Step

fn next_while_off( &mut self, event: Event, now: &Now, logs: &mut Vec<Log>, ) -> Action

Off: nothing is sent until publishing is turned on again; a goodbye in flight when it was turned off lands here.

fn enter_off( &mut self, reason: PresenceOffReason, now: &Now, logs: &mut Vec<Log>, )

Stop publishing for reason; one log line per new reason.

fn next_while_on( &mut self, event: Event, now: Now, logs: &mut Vec<Log>, ) -> Action

fn attempt(&mut self, v: Option<u32>, now: &Now) -> Action

Send the latest snapshot. v is set for a second try of the same record; a fresh try forgets the second tries spent.

fn on_answer( &mut self, sent_v: u32, answer: Answer, now: &Now, logs: &mut Vec<Log>, ) -> Action

fn reject(&mut self, why: String, now: &Now, logs: &mut Vec<Log>) -> Action

fn on_health( &mut self, version: Option<String>, now: &Now, logs: &mut Vec<Log>, ) -> Action

fn backoff(&self, now: &Now) -> u64

Full jitter: anywhere up to base * 2^(failures - 1), capped, but no less than the floor.

fn observe_date( &mut self, relay_date_ms: Option<u64>, now: &Now, logs: &mut Vec<Log>, )

Learn the relay’s clock from an answer’s Date.

fn clock_skewed(&self) -> bool

fn enter( &mut self, state: PresenceState, reason: Option<String>, text: &str, now: &Now, logs: &mut Vec<Log>, )

Enter state for reason; one log line when the state changes.

fn warn_long_outage(&mut self, now: &Now, logs: &mut Vec<Log>)

pub(crate) fn status(&self, now: &Now) -> Option<PresenceStatusResult>

The status for presence.status; None before the first state.

Trait Implementations

impl Debug for Machine

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

Formats the value using the given formatter.