failsafe 1.3.0

A circuit breaker implementation
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

thread_local!(static CLOCK: Cell<Option<*const MockClock>> = const { Cell::new(None) });

#[derive(Debug)]
pub struct MockClock(Instant);

impl MockClock {
    fn new() -> MockClock {
        MockClock(Instant::now())
    }

    #[inline]
    pub fn now(&self) -> Instant {
        self.0
    }

    #[inline]
    pub fn advance(&mut self, diff: Duration) {
        self.0 += diff
    }
}

pub fn freeze<F, R>(f: F) -> R
where
    F: FnOnce(&mut MockClock) -> R,
{
    CLOCK.with(|cell| {
        let mut clock = MockClock::new();

        assert!(
            cell.get().is_none(),
            "default clock already set for execution context"
        );

        // Ensure that the clock is removed from the thread-local context
        // when leaving the scope. This handles cases that involve panicking.
        struct Reset<'a>(&'a Cell<Option<*const MockClock>>);

        impl<'a> Drop for Reset<'a> {
            fn drop(&mut self) {
                self.0.set(None);
            }
        }

        let _reset = Reset(cell);

        cell.set(Some(&clock as *const MockClock));

        f(&mut clock)
    })
}

#[inline]
pub fn now() -> Instant {
    CLOCK.with(|current| match current.get() {
        Some(ptr) => unsafe { (*ptr).now() },
        None => Instant::now(),
    })
}