Struct DefaultRetryPolicy

pub struct DefaultRetryPolicy {
    pub min_retries: Option<u32>,
    pub initial_backoff: Duration,
    pub backoff_coefficient: f64,
    pub max_backoff: Duration,
    pub backoff_on_transport_errors: bool,
    pub retryable_json_rpc_errors: Vec<i64>,
    pub retryable_http_errors: Vec<StatusCode>,
    pub max_retry_queue_size: u32,
}

Defines a default retry policy suitable for RpcClient. This is a reimplementation of the legacy “retry policy suitable for JsonRpcProviderClient”

This retry policy distinguishes between 4 types of RPC request failures:

• JSON RPC error (based on error code)
• HTTP error (based on HTTP status)
• Transport error (e.g. connection timeout)
• Serde error (some of these are treated as JSON RPC error above, if an error code can be obtained).

The standard RetryBackoffLayer defines the following properties:

• max_rate_limit_retries: (u32) The maximum number of retries for rate limit errors. Different from the legacy implementation, there is always an upper limit.
• initial_backoff: (u64) The initial backoff in milliseconds
• compute_units_per_second: (u64) The number of compute units per second for this service

The policy will make up to max_retries once a JSON RPC request fails. The minimum number of retries min_retries can be also specified and applies to any type of error regardless. Each retry k > 0 will be separated by a delay of initial_backoff * (1 + backoff_coefficient)^(k - 1), namely all the JSON RPC error codes specified in retryable_json_rpc_errors and all the HTTP errors specified in retryable_http_errors.

The total wait time will be (initial_backoff/backoff_coefficient) * ((1 + backoff_coefficient)^max_retries - 1). or max_backoff, whatever is lower.

Transport and connection errors (such as connection timeouts) are retried without backoff at a constant delay of initial_backoff if backoff_on_transport_errors is not set.

No more additional retries are allowed on new requests, if the maximum number of concurrent requests being retried has reached max_retry_queue_size.

Fields

min_retries: Option<u32>

Minimum number of retries of any error, regardless the error code.

Default is 0.

initial_backoff: Duration

Initial wait before retries.

NOTE: Transport and connection errors (such as connection timeouts) are retried at a constant rate (no backoff) with this delay if backoff_on_transport_errors is not set.

Default is 1 second.

backoff_coefficient: f64

Backoff coefficient by which will be each retry multiplied.

Must be non-negative. If set to 0, no backoff will be applied and the requests will be retried at a constant rate.

Default is 0.3

max_backoff: Duration

Maximum backoff value.

Once reached, the requests will be retried at a constant rate with this timeout.

Default is 30 seconds.

backoff_on_transport_errors: bool

Indicates whether to also apply backoff to transport and connection errors (such as connection timeouts).

Default is false.

retryable_json_rpc_errors: Vec<i64>

List of JSON RPC errors that should be retried with backoff

Default is [429, -32005, -32016]

retryable_http_errors: Vec<StatusCode>

List of HTTP errors that should be retried with backoff.

Default is [429, 504, 503]

max_retry_queue_size: u32

Maximum number of different requests that are being retried at the same time.

If any additional request fails after this number is attained, it won’t be retried.

Default is 100

Trait Implementations

impl Clone for DefaultRetryPolicy

fn clone(&self) -> DefaultRetryPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefaultRetryPolicy

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

Formats the value using the given formatter.

impl Default for DefaultRetryPolicy

fn default() -> Self

Return DefaultRetryPolicy { min_retries: Some(0), initial_backoff: Duration::from_secs(1), backoff_coefficient: 0.3, max_backoff: Duration::from_secs(30), backoff_on_transport_errors: Default::default(), retryable_json_rpc_errors: vec! [- 32005, - 32016, 429], retryable_http_errors: vec! [http :: StatusCode :: TOO_MANY_REQUESTS, http :: StatusCode :: GATEWAY_TIMEOUT, http :: StatusCode :: SERVICE_UNAVAILABLE], max_retry_queue_size: 100 }

impl<'de> Deserialize<'de> for DefaultRetryPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DefaultRetryPolicy

fn eq(&self, other: &DefaultRetryPolicy) -> 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 RetryPolicy for DefaultRetryPolicy

fn should_retry(&self, err: &TransportError) -> bool

Whether to retry the request based on the given error

fn backoff_hint(&self, _error: &TransportError) -> Option<Duration>

Providers may include the backoff in the error response directly

impl Serialize for DefaultRetryPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Validate for DefaultRetryPolicy

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a> ValidateArgs<'v_a> for DefaultRetryPolicy

type Args = ()

fn validate_with_args(&self, args: Self::Args) -> Result<(), ValidationErrors>

impl StructuralPartialEq for DefaultRetryPolicy