Struct opendal::layers::RetryLayer

pub struct RetryLayer<I = DefaultRetryInterceptor> { /* private fields */ }

Add retry for temporary failed operations.

Notes

This layer will retry failed operations when Error::is_temporary returns true. If operation still failed, this layer will set error to Persistent which means error has been retried.

Panics

While retrying Reader or Writer operations, please make sure either:

• All futures generated by Reader::read or Writer::close are resolved to Ready.
• Or, won’t call any Reader or Writer methods after retry returns final error.

Otherwise, RetryLayer could panic while hitting in bad states.

For example, while composing RetryLayer with TimeoutLayer. The order of layer is sensitive.

 let op = Operator::new(builder.clone())
    .unwrap()
    // This is fine, since timeout happen during retry.
    .layer(TimeoutLayer::new().with_io_timeout(Duration::from_nanos(1)))
    .layer(RetryLayer::new())
    // This is wrong. Since timeout layer will drop future, leaving retry layer in a bad state.
    .layer(TimeoutLayer::new().with_io_timeout(Duration::from_nanos(1)))
    .finish();

Examples

use anyhow::Result;
use opendal::layers::RetryLayer;
use opendal::services;
use opendal::Operator;
use opendal::Scheme;

let _ = Operator::new(services::Memory::default())
    .expect("must init")
    .layer(RetryLayer::new())
    .finish();

Customize retry interceptor

RetryLayer accepts RetryInterceptor to allow users to customize their own retry interceptor logic.

use std::time::Duration;

use anyhow::Result;
use opendal::layers::RetryInterceptor;
use opendal::layers::RetryLayer;
use opendal::services;
use opendal::Error;
use opendal::Operator;
use opendal::Scheme;

struct MyRetryInterceptor;

impl RetryInterceptor for MyRetryInterceptor {
    fn intercept(&self, err: &Error, dur: Duration) {
        // do something
    }
}

let _ = Operator::new(services::Memory::default())
    .expect("must init")
    .layer(RetryLayer::new().with_notify(MyRetryInterceptor))
    .finish();

Implementations

impl RetryLayer

pub fn new() -> Self

Create a new retry layer.

Examples

use anyhow::Result;
use opendal::layers::RetryLayer;
use opendal::services;
use opendal::Operator;
use opendal::Scheme;

let _ = Operator::new(services::Memory::default())
    .expect("must init")
    .layer(RetryLayer::new());

pub fn with_notify<I: RetryInterceptor>(self, notify: I) -> RetryLayer<I>

Set the retry interceptor as new notify.

use std::time::Duration;

use anyhow::Result;
use opendal::layers::RetryInterceptor;
use opendal::layers::RetryLayer;
use opendal::services;
use opendal::Error;
use opendal::Operator;
use opendal::Scheme;

struct MyRetryInterceptor;

impl RetryInterceptor for MyRetryInterceptor {
    fn intercept(&self, err: &Error, dur: Duration) {
        // do something
    }
}

let _ = Operator::new(services::Memory::default())
    .expect("must init")
    .layer(RetryLayer::new().with_notify(MyRetryInterceptor))
    .finish();

pub fn with_jitter(self) -> Self

Set jitter of current backoff.

If jitter is enabled, ExponentialBackoff will add a random jitter in `[0, min_delay) to current delay.

pub fn with_factor(self, factor: f32) -> Self

Set factor of current backoff.

Panics

This function will panic if input factor smaller than 1.0.

pub fn with_min_delay(self, min_delay: Duration) -> Self

Set min_delay of current backoff.

pub fn with_max_delay(self, max_delay: Duration) -> Self

Set max_delay of current backoff.

Delay will not increasing if current delay is larger than max_delay.

pub fn with_max_times(self, max_times: usize) -> Self

Set max_times of current backoff.

Backoff will return None if max times is reaching.

Trait Implementations

impl<I> Clone for RetryLayer<I>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for RetryLayer

fn default() -> Self

Returns the “default value” for a type.

impl<A: Access, I: RetryInterceptor> Layer<A> for RetryLayer<I>

type LayeredAccess = RetryAccessor<A, I>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> Self::LayeredAccess

Intercept the operations on the underlying storage.