maybe-backoff 0.5.0

Retry operations with exponential backoff policy.
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

fn main() {
    match example::run("https::///wrong URL") {
        Ok(_) => println!("Successfully fetched"),
        Err(err) => panic!("Failed to fetch: {}", err),
    }
}

#[cfg(target_arch = "wasm32")]
mod example {
    pub fn run(_url: &str) -> Result<String, maybe_backoff::Error<std::io::Error>> {
        unimplemented!("This example is not implemented for wasm32 target");
    }
}

#[cfg(not(target_arch = "wasm32"))]
mod example {
    use maybe_backoff::{Error, ExponentialBackoff};
    use reqwest::Url;

    use std::fmt::Display;
    use std::io::{self, Read};

    fn new_io_err<E: Display>(err: E) -> io::Error {
        io::Error::other(err.to_string())
    }

    pub fn run(url: &str) -> Result<String, Error<io::Error>> {
        let op = || {
            println!("Fetching {}", url);
            let url = Url::parse(url)
                .map_err(new_io_err)
                // Permanent errors need to be explicitly constructed.
                .map_err(Error::Permanent)?;

            let mut resp = reqwest::blocking::get(url)
                // Transient errors can be constructed with the ? operator
                // or with the try! macro. No explicit conversion needed
                // from E: Error to backoff::Error;
                .map_err(new_io_err)?;

            let mut content = String::new();
            let _ = resp.read_to_string(&mut content);
            Ok(content)
        };

        let backoff = ExponentialBackoff::default();
        maybe_backoff::retry(backoff, op)
    }
}