backoff/
retry.rs

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
use std::thread;
use std::time::Duration;

use crate::backoff::Backoff;
use crate::error::Error;

/// Retries this operation according to the backoff policy.
/// backoff is reset before it is used.
///
/// # Examples
///
/// ```rust
/// # use backoff::{ExponentialBackoff, Error, retry};
/// let f = || -> Result<(), Error<&str>> {
///     // Business logic...
///     // Give up.
///     Err(Error::Permanent("error"))
/// };
///
/// let backoff = ExponentialBackoff::default();
/// let _ = retry(backoff, f).err().unwrap();
/// ```
pub fn retry<F, B, T, E>(backoff: B, op: F) -> Result<T, Error<E>>
where
    F: FnMut() -> Result<T, Error<E>>,
    B: Backoff,
{
    let mut retry = Retry {
        backoff,
        notify: NoopNotify,
        sleep: ThreadSleep,
    };

    retry.retry_notify(op)
}

/// Retries this operation according to the backoff policy.
/// Calls notify on failed attempts (in case of transient errors).
/// backoff is reset before it is used.
///
/// # Examples
///
/// ```rust
/// # use backoff::{Error, retry_notify};
/// # use backoff::backoff::Stop;
/// # use std::time::Duration;
/// let notify = |err, dur| { println!("Error happened at {:?}: {}", dur, err); };
/// let f = || -> Result<(), Error<&str>> {
///     // Business logic...
///     Err(Error::transient("error"))
/// };
///
/// let backoff = Stop{};
/// let _ = retry_notify(backoff, f, notify).err().unwrap();
/// ```
pub fn retry_notify<F, B, N, T, E>(backoff: B, op: F, notify: N) -> Result<T, Error<E>>
where
    F: FnMut() -> Result<T, Error<E>>,
    B: Backoff,
    N: Notify<E>,
{
    let mut retry = Retry {
        backoff,
        notify,
        sleep: ThreadSleep,
    };

    retry.retry_notify(op)
}

struct Retry<B, N, S> {
    backoff: B,
    notify: N,
    sleep: S,
}

impl<B, N, S> Retry<B, N, S> {
    pub fn retry_notify<F, T, E>(&mut self, mut op: F) -> Result<T, Error<E>>
    where
        F: FnMut() -> Result<T, Error<E>>,
        B: Backoff,
        N: Notify<E>,
        S: Sleep,
    {
        self.backoff.reset();

        loop {
            let err = match op() {
                Ok(v) => return Ok(v),
                Err(err) => err,
            };

            let (err, next) = match err {
                Error::Permanent(err) => return Err(Error::Permanent(err)),
                Error::Transient { err, retry_after } => {
                    match retry_after.or_else(|| self.backoff.next_backoff()) {
                        Some(next) => (err, next),
                        None => return Err(Error::transient(err)),
                    }
                }
            };

            self.notify.notify(err, next);

            self.sleep.sleep(next);
        }
    }
}

trait Sleep {
    fn sleep(&mut self, dur: Duration);
}

struct ThreadSleep;

impl Sleep for ThreadSleep {
    fn sleep(&mut self, dur: Duration) {
        thread::sleep(dur);
    }
}

/// Notify is called in [`retry_notify`](trait.Operation.html#method.retry_notify) in case of errors.
pub trait Notify<E> {
    fn notify(&mut self, err: E, duration: Duration);
}

impl<E, F> Notify<E> for F
where
    F: FnMut(E, Duration),
{
    fn notify(&mut self, err: E, duration: Duration) {
        self(err, duration)
    }
}

/// No-op implementation of [`Notify`]. Literally does nothing.
#[derive(Debug, Clone, Copy)]
pub struct NoopNotify;

impl<E> Notify<E> for NoopNotify {
    fn notify(&mut self, _: E, _: Duration) {}
}