Struct Pace 

pub struct Pace { /* private fields */ }

The waits a watch loop makes.

Two of them, and a loop needs both: the pause between healthy rounds, spread so a fleet does not poll in lockstep, and the growing pause after a failure, so a store that is down is not hammered by everything that depends on it. A loop that sleeps its plain interval after an error is the shape that turns one outage into two.

let mut pace = Pace::new(Duration::from_secs(30));

while watching.keep_going() {
    match fetch() {
        Ok(()) => pace.succeeded(),
        Err(()) => pace.failed(),
    }

    pace.wait(watching);
}

Implementations

impl Pace

pub fn new(interval: Duration) -> Self

Rounds interval apart when things are going well.

pub fn with_ceiling(self, ceiling: Duration) -> Self

Caps how far a backoff grows. Five minutes by default.

pub fn succeeded(&mut self)

A round went well: the next wait is the plain interval again.

pub fn failed(&mut self)

A round failed: the next wait is longer than the last one.

pub fn next_wait(&mut self) -> Duration

How long to wait before the next round, jittered.

The interval while things work; doubling from it after each failure, up to the ceiling.

pub fn wait(&mut self, watching: &Watching)

Waits for next_wait, waking early if the watch is stopped.

pub fn spread(&mut self, base: Duration) -> Duration

base, moved by up to a quarter of itself in either direction.

Deterministic given the seed, so a test can pin it; drawn from the clock at construction, so two processes do not share a phase.

Trait Implementations

impl Clone for Pace

fn clone(&self) -> Pace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pace

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

Formats the value using the given formatter.