Struct Policy 

pub struct Policy { /* private fields */ }

A retry policy.

Implementations

impl Policy

pub fn never() -> Policy

Create a retry policy that will never retry any request.

This is useful for disabling the Clients default behavior of retrying protocol nacks.

pub fn for_host<S>(host: S) -> Policy

where S: for<'a> PartialEq<&'a str> + Send + Sync + 'static,

Create a retry policy scoped to requests for a specific host.

This is a convenience method that creates a retry policy which only applies to requests targeting the specified host. Requests to other hosts will not be retried under this policy.

Arguments

• host - The hostname to match against request URIs (e.g., “api.example.com”)

Example

use hpx::retry::Policy;

// Only retry requests to rust-lang.org
let policy = Policy::for_host("rust-lang.org");

pub 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.

pub 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.

pub 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.

pub 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

policy.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(),
})

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Policy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Policy

fn default() -> Self

Returns the “default value” for a type.