Struct Builder

pub struct Builder { /* private fields */ }

Builder to configure retries

Construct with [for_host()].

Implementations

impl Builder

fn scoped(scope: impl Scope) -> Self

Create a scoped retry policy.

For a more convenient constructor, see [for_host()].

fn no_budget(self) -> Self

Set no retry budget.

Sets that no budget will be enforced. This could also be considered to be an infinite budget.

This is NOT recommended. Disabling the budget can make your system more susceptible to retry storms.

fn max_extra_load(self, extra_percent: f32) -> Self

Sets the max extra load the budget will allow.

Think of the amount of requests your client generates, and how much load that puts on the server. This option configures as a percentage how much extra load is allowed via retries.

For example, if you send 1,000 requests per second, setting a maximum extra load value of 0.3 would allow 300 more requests per second in retries. A value of 2.5 would allow 2,500 more requests.

Panics

The extra_percent value must be within reasonable values for a percentage. This method will panic if it is less than 0.0, or greater than 1000.0.

fn max_retries_per_request(self, max: u32) -> Self

Set the max retries allowed per request.

For each logical (initial) request, only retry up to max times.

This value is used in combination with a token budget that is applied to all requests. Even if the budget would allow more requests, this limit will prevent. Likewise, the budget may prevent retrying up to max times. This setting prevents a single request from consuming the entire budget.

Default is currently 2 retries.

fn classify_fn<F>(self, func: F) -> Self
where
    F: Fn(ReqRep<'_>) -> Action + Send + Sync + 'static,

Provide a classifier to determine if a request should be retried.

Example

# fn with_builder(builder: reqwest::retry::Builder) -> reqwest::retry::Builder {
builder.classify_fn(|req_rep| {
    match (req_rep.method(), req_rep.status()) {
        (&http::Method::GET, Some(http::StatusCode::SERVICE_UNAVAILABLE)) => {
            req_rep.retryable()
        },
        _ => req_rep.success()
    }
})
# }
fn classify(self, classifier: impl Classify) -> Self

Provide a classifier to determine if a request should be retried.

Trait Implementations

impl Debug for Builder

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

Auto Trait Implementations

impl !RefUnwindSafe for Builder

impl !UnwindSafe for Builder

impl Freeze for Builder

impl Send for Builder

impl Sync for Builder

impl Unpin for Builder

impl UnsafeUnpin for Builder

Blanket Implementations

impl<T> Any for Builder where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Builder where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Builder where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for Builder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for Builder

impl<T> PolicyExt for Builder where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where
    T: Sized + Policy<B, E>,
    P: Policy<B, E>,
fn or<P, B, E>(self, other: P) -> Or<T, P>
where
    T: Sized + Policy<B, E>,
    P: Policy<B, E>,

impl<T> WithSubscriber for Builder

impl<T, U> Into<U> for Builder where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Builder where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Builder where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>