mettle 0.1.1

A resilience toolkit for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//! A synchronous time source for [blocking retry](super).

use std::time::{Duration, Instant};

/// A synchronous time source: read "now", and block for a duration.
///
/// Injected so tests can supply a mock that advances a *virtual* clock and returns from
/// `sleep` instantly. Open on purpose: implement it for a mock or a simulation runtime.
///
/// This is the blocking counterpart of mettle's async `Clock` trait; the two are separate
/// because the async one's `sleep` returns a `Future` and this one just blocks.
pub trait Clock {
    /// The current instant.
    fn now(&self) -> Instant;

    /// Block the current thread for `dur`.
    fn sleep(&self, dur: Duration);
}

/// A [`Clock`] backed by [`std::thread::sleep`] and [`std::time::Instant`].
#[derive(Debug, Clone, Copy, Default)]
pub struct StdClock;

impl Clock for StdClock {
    fn now(&self) -> Instant {
        Instant::now()
    }

    fn sleep(&self, dur: Duration) {
        std::thread::sleep(dur);
    }
}