execution-policy 0.0.3

Closure-first, runtime-light reliability policies (retry, timeout, circuit breaking, bounded concurrency, retry budgets) for any async Rust operation.
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

//! Per-attempt metadata handed to operation closures.

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

/// Metadata for the current attempt. `number()` is 1-based.
#[non_exhaustive]
#[derive(Debug, Clone, Copy)]
pub struct Attempt<'a> {
    number: u32,
    start: Instant,
    now: Instant,
    _borrow: PhantomData<&'a ()>,
}

impl<'a> Attempt<'a> {
    pub(crate) fn new(number: u32, start: Instant, now: Instant) -> Self {
        Self {
            number,
            start,
            now,
            _borrow: PhantomData,
        }
    }

    /// 1-based attempt index (first attempt returns 1).
    pub fn number(&self) -> u32 {
        self.number
    }

    /// Time elapsed since the first attempt began.
    pub fn elapsed(&self) -> Duration {
        self.now.duration_since(self.start)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn number_is_one_based() {
        let t = Instant::now();
        let a = Attempt::new(1, t, t);
        assert_eq!(a.number(), 1);
    }

    #[test]
    fn elapsed_reflects_clock() {
        let start = Instant::now();
        let now = start + Duration::from_millis(250);
        let a = Attempt::new(2, start, now);
        assert_eq!(a.elapsed(), Duration::from_millis(250));
    }
}