Struct Retry 

pub struct Retry { /* private fields */ }

Available on crate feature std only.

A retry policy: a Backoff, an attempt ceiling, and whether to honor a server’s Retry-After.

The policy is independent of the limiters — retry any fallible async operation, or wrap a limiter’s acquire call. The error is classified per attempt by a closure you supply, so retry works with any error type; for errors that implement error_forge::ForgeError, the retry_if_retryable helper classifies by the error’s own retryability.

Examples

use throttle_net::{Backoff, Retry, RetryAction};

let retry = Retry::new(Backoff::default()).max_attempts(4);

let result: Result<u32, &str> = retry
    .run(
        || async { Err("transient") },
        |_err| RetryAction::Retry,
    )
    .await;
assert_eq!(result, Err("transient")); // gave up after 4 attempts

Implementations

impl Retry

pub fn new(backoff: Backoff) -> Self

Creates a retry policy with the given backoff, a default of five attempts, and Retry-After honored.

pub fn max_attempts(self, attempts: u32) -> Self

Sets the maximum number of attempts (including the first). A value of 1 disables retrying; 0 is treated as 1.

pub fn respect_retry_after(self, yes: bool) -> Self

Sets whether a RetryAction::RetryAfter delay overrides the computed backoff. On by default.

pub const fn attempts(&self) -> u32

The configured attempt ceiling.

pub const fn backoff(&self) -> &Backoff

The configured backoff policy.

impl Retry

pub async fn run<F, Fut, T, E, C>( &self, operation: F, classify: C, ) -> Result<T, E>

where F: FnMut() -> Fut, Fut: Future<Output = Result<T, E>>, C: Fn(&E) -> RetryAction,

Available on crate feature runtime only.

Runs operation, retrying on failure per the policy until it succeeds, the classifier says to stop, or the attempt ceiling is reached.

operation is called once per attempt. classify inspects each error and returns a RetryAction: retry with the backoff delay, retry honoring a Retry-After, or give up. The last error is returned when attempts run out or the classifier gives up.

Examples

Retry on a Retry-After the server sent, parsed with parse_retry_after:

use std::time::Duration;
use throttle_net::{Backoff, Retry, RetryAction};

struct Rejected { retry_after: Option<Duration> }

let retry = Retry::new(Backoff::default()).respect_retry_after(true);
let result: Result<(), &str> = retry
    .run(
        || async { Err::<(), _>(Rejected { retry_after: Some(Duration::from_millis(10)) }) },
        |err: &Rejected| match err.retry_after {
            Some(after) => RetryAction::RetryAfter(after),
            None => RetryAction::Retry,
        },
    )
    .await
    .map(|_| ())
    .map_err(|_| "exhausted");
assert_eq!(result, Err("exhausted"));

Trait Implementations

impl Clone for Retry

fn clone(&self) -> Retry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Retry

impl Debug for Retry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.