ease-off 0.1.3

An easy, opinionated exponential backoff 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
62
63
64
65
66
67

use ease_off::RetryableError;
use std::time::Duration;

struct FallibleOperation {
    tries_required: usize,
}

struct Success {
    message: String,
}

#[derive(Debug)]
pub struct Error {
    pub message: String,
}

impl RetryableError for Error {
    fn can_retry(&self) -> bool {
        true
    }
}

impl FallibleOperation {
    async fn try_op(&mut self) -> Result<Success, Error> {
        if self.tries_required > 0 {
            let remaining = self.tries_required;
            self.tries_required -= 1;

            Err(Error {
                message: format!("failure! tries remaining: {remaining}"),
            })
        } else {
            Ok(Success {
                message: "yay! completed successfully!".to_string(),
            })
        }
    }
}

const OPTIONS: ease_off::Options = ease_off::Options::new()
    // Set a longer `initial_delay` so we can see it working
    .initial_delay(Duration::from_secs(1));

#[async_std::main]
async fn main() -> Result<(), Error> {
    let mut fallible = FallibleOperation { tries_required: 3 };

    // If you just want to use the default options:
    // let mut ease_off = EaseOff::start_timeout(Duration::from_secs(60));
    let mut ease_off = OPTIONS.start_timeout(Duration::from_secs(60));

    loop {
        let Some(Success { message }) = ease_off
            .try_async(fallible.try_op())
            .await
            .inspect_err(|e| println!("error: {e:?}"))
            .or_retry()?
        else {
            continue;
        };

        println!("completed with message: {message}");
        break;
    }

    Ok(())
}