Struct BlockingRetry 

pub struct BlockingRetry<B, T, E, F, SF = StdSleeper, RF = fn(&E) -> bool, NF = fn(&E, Duration)>
where
    B: Backoff,
    F: FnMut() -> Result<T, E>,
    SF: MaybeBlockingSleeper,
{ /* private fields */ }

Retry structure generated by BlockingRetryable.

Implementations

impl<B, T, E, F, SF, RF, NF> BlockingRetry<B, T, E, F, SF, RF, NF>

where B: Backoff, F: FnMut() -> Result<T, E>, SF: MaybeBlockingSleeper, RF: FnMut(&E) -> bool, NF: FnMut(&E, Duration),

pub fn sleep<SN>(self, sleep_fn: SN) -> BlockingRetry<B, T, E, F, SN, RF, NF>

where SN: BlockingSleeper,

Set the sleeper for retrying.

The sleeper should implement the BlockingSleeper trait. The simplest way is to use a closure like Fn(Duration).

If not specified, we use the DefaultBlockingSleeper.

Examples

use anyhow::Result;
use backon::BlockingRetryable;
use backon::ExponentialBuilder;

fn fetch() -> Result<String> {
    Ok("hello, world!".to_string())
}

fn main() -> Result<()> {
    let retry = fetch
        .retry(ExponentialBuilder::default())
        .sleep(std::thread::sleep);
    let content = retry.call()?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

pub fn when<RN>(self, retryable: RN) -> BlockingRetry<B, T, E, F, SF, RN, NF>

where RN: FnMut(&E) -> bool,

Set the conditions for retrying.

If not specified, all errors are considered retryable.

Examples

use anyhow::Result;
use backon::BlockingRetryable;
use backon::ExponentialBuilder;

fn fetch() -> Result<String> {
    Ok("hello, world!".to_string())
}

fn main() -> Result<()> {
    let retry = fetch
        .retry(ExponentialBuilder::default())
        .when(|e| e.to_string() == "EOF");
    let content = retry.call()?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

pub fn notify<NN>(self, notify: NN) -> BlockingRetry<B, T, E, F, SF, RF, NN>

where NN: FnMut(&E, Duration),

Set to notify for all retry attempts.

When a retry happens, the input function will be invoked with the error and the sleep duration before pausing.

If not specified, this operation does nothing.

Examples

use core::time::Duration;

use anyhow::Result;
use backon::BlockingRetryable;
use backon::ExponentialBuilder;

fn fetch() -> Result<String> {
    Ok("hello, world!".to_string())
}

fn main() -> Result<()> {
    let retry = fetch.retry(ExponentialBuilder::default()).notify(
        |err: &anyhow::Error, dur: Duration| {
            println!("retrying error {:?} with sleeping {:?}", err, dur);
        },
    );
    let content = retry.call()?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

impl<B, T, E, F, SF, RF, NF> BlockingRetry<B, T, E, F, SF, RF, NF>

where B: Backoff, F: FnMut() -> Result<T, E>, SF: BlockingSleeper, RF: FnMut(&E) -> bool, NF: FnMut(&E, Duration),

pub fn call(self) -> Result<T, E>

Call the retried function.

TODO: implement FnOnce after it stable.