Struct BlockingRetry

pub struct BlockingRetry<B: Backoff, T, E, F: FnMut() -> Result<T, E>, SF: MaybeBlockingSleeper = DefaultBlockingSleeper, RF = fn(_: &E) -> bool, NF = fn(_: &E, _: Duration)> { /* 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: BlockingSleeper>( self, sleep_fn: SN, ) -> BlockingRetry<B, T, E, F, SN, RF, NF>

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: FnMut(&E) -> bool>( self, retryable: RN, ) -> BlockingRetry<B, T, E, F, SF, RN, NF>

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: FnMut(&E, Duration)>( self, notify: NN, ) -> BlockingRetry<B, T, E, F, SF, RF, NN>

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.