zagreus 0.1.1

A featureful library for backoff handling
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

use crate::strategy::BackoffStrategy;
use std::{num::NonZeroU32, time::Duration};

///Retry strategy with backoffs that grow with n * i where n is the interval, and i is the number of requests.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub struct Linear {
    ///The constant factor of the backoff. The first backoff interval will be this long.
    ///All successive intervals will be this value multiplied by the number of attempts.
    constant: Duration,
    ///The maximum number of retries that may be attempted.
    limit: NonZeroU32,
}

impl Linear {
    pub fn new(constant: Duration, limit: NonZeroU32) -> Self {
        Linear { constant, limit }
    }
}

impl BackoffStrategy for Linear {
    fn interval(&self, attempts: u32) -> Option<Duration> {
        Some(self.constant.mul_f64(attempts as f64))
    }

    fn limit(&self) -> NonZeroU32 {
        self.limit
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
///Retry strategy with backoffs that do not grow with time.
pub struct Constant {
    ///The fixed amount by which the backoffs will be spaced
    constant: Duration,
    ///The maximum number of retries that may be attempted.
    limit: NonZeroU32,
}

impl BackoffStrategy for Constant {
    fn interval(&self, _attempts: u32) -> Option<Duration> {
        Some(self.constant)
    }

    fn limit(&self) -> NonZeroU32 {
        self.limit
    }
}

impl Constant {
    pub fn new(constant: Duration, limit: NonZeroU32) -> Self {
        Constant { constant, limit }
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
///Classic expontential backoff.
pub struct Exponential {
    ///The first backoff will take this long. Further backoffs
    ///will be multiplied by `factor` n times up to `limit`.
    constant: Duration,
    ///The factor by which the constant will grow.
    factor: NonZeroU32,
    ///The maximum number of retries that may be attempted.
    limit: NonZeroU32,
}

impl Exponential {
    pub fn new(constant: Duration, factor: NonZeroU32, limit: NonZeroU32) -> Self {
        Exponential {
            constant,
            factor,
            limit,
        }
    }
}

impl BackoffStrategy for Exponential {
    fn interval(&self, attempts: u32) -> Option<Duration> {
        Some(self.constant.mul_f64((self.factor.get() * attempts) as f64))
    }

    fn limit(&self) -> NonZeroU32 {
        self.limit
    }
}