Struct backon::BlockingRetry

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

Retry struct generated by [Retryable].

Implementations

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

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

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

Set the conditions for retrying.

If not specified, we treat all errors as 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, RF, NN>

Set to notify for everything retrying.

If not specified, this is a no-op.

Examples

use std::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(())
}

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

Call the retried function.

TODO: implment std::ops::FnOnce after it stable.