retrying 0.1.0

General-purpose retrying library for Rust with macros and functions
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use crate::RetryingContext;

pub trait Stop {
    fn stop_execution(&self, ctx: &RetryingContext) -> bool;
}

pub struct StopAttempts {
    attempts: u32,
}

impl StopAttempts {
    pub fn new(attempts: u32) -> StopAttempts {
        StopAttempts { attempts }
    }
}

impl Stop for StopAttempts {
    fn stop_execution(&self, ctx: &RetryingContext) -> bool {
        ctx.attempt_num >= self.attempts
    }
}

pub struct StopDuration {
    duration: f32,
}

impl StopDuration {
    pub fn new(duration: f32) -> StopDuration {
        StopDuration { duration }
    }
}

impl Stop for StopDuration {
    fn stop_execution(&self, ctx: &RetryingContext) -> bool {
        ::std::time::SystemTime::now()
            .duration_since(ctx.started_at())
            .unwrap()
            .as_secs_f32()
            >= self.duration
    }
}

pub struct StopAttemptsOrDuration {
    attempts: StopAttempts,
    duration: StopDuration,
}

impl StopAttemptsOrDuration {
    pub fn new(attempts: u32, duration: f32) -> StopAttemptsOrDuration {
        StopAttemptsOrDuration {
            attempts: StopAttempts { attempts },
            duration: StopDuration { duration },
        }
    }
}

impl Stop for StopAttemptsOrDuration {
    fn stop_execution(&self, ctx: &RetryingContext) -> bool {
        self.attempts.stop_execution(ctx) || self.duration.stop_execution(ctx)
    }
}

mod tests {

    #[test]
    fn test_attemps_stop_execution() {
        use super::*;
        use crate::stop::Stop;

        let stop = StopAttempts { attempts: 2u32 };
        let mut ctx = RetryingContext::default();

        assert!(!stop.stop_execution(&ctx));

        ctx.add_attempt();
        assert!(stop.stop_execution(&ctx));
    }

    #[test]
    fn test_duration_stop_execution() {
        use super::*;
        use crate::*;

        let ctx = RetryingContext::default();
        let stop = StopDuration { duration: 0.1f32 };

        sleep_sync(Duration::from_secs_f32(0.2f32));
        assert!(stop.stop_execution(&ctx));
    }
}