Struct kernel::retry::Retry

pub struct Retry<P = AlwaysRetry, B = ExpBackoff> {
    predicate: P,
    backoff: B,
}

Fields

predicate: P

backoff: B

Implementations

impl<P, B> Retry<P, B>

where B: Backoff,

pub const fn new(predicate: P, backoff: B) -> Self

pub fn with_predicate<P2>(self, predicate: P2) -> Retry<P2, B>

Sets the predicate used to determine if an error is retryable.

If predicate.should_retry() returns true for a given error, the error is retried. Otherwise, the error is not retried.

pub fn with_backoff<B2: Backoff>(self, backoff: B2) -> Retry<P, B2>

Sets the backoff policy used to determine how long to back off for between retries.

pub fn with_max_retries(self, max: usize) -> Retry<WithMaxRetries<P>, B>

Sets a maximum retry limit of max retries. If an operation would be retried more than max times, it will fail, regardless of whether the P indicates it is retryable.

pub async fn retry<'op, T, E, F>( &mut self, op: impl FnMut() -> F, ) -> Result<T, E>

where F: Future<Output = Result<T, E>> + 'op, P: ShouldRetry<E>, E: Display,

pub async fn retry_with_input<I, T, E, F>( &mut self, input: I, op: impl FnMut(I) -> F, ) -> Result<T, E>

where F: Future<Output = (I, Result<T, E>)>, P: ShouldRetry<E>, E: Display,

Retry the asynchronous operation returned by F.

Trait Implementations

impl<P: Clone, B: Clone> Clone for Retry<P, B>

fn clone(&self) -> Retry<P, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, B: Debug> Debug for Retry<P, B>

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

Formats the value using the given formatter.

impl Default for Retry

fn default() -> Self

Returns the “default value” for a type.

impl<P: PartialEq, B: PartialEq> PartialEq for Retry<P, B>

fn eq(&self, other: &Retry<P, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Copy, B: Copy> Copy for Retry<P, B>

impl<P: Eq, B: Eq> Eq for Retry<P, B>

impl<P, B> StructuralPartialEq for Retry<P, B>