Struct FallbackLayer 

pub struct FallbackLayer<Req, Res, E> { /* private fields */ }

A Tower layer that applies fallback behavior to a service.

See the module-level documentation for usage examples.

Implementations

impl<Req, Res, E> FallbackLayer<Req, Res, E>

pub fn builder() -> FallbackConfigBuilder<Req, Res, E>

Creates a new builder for configuring a fallback layer.

pub fn value_fn<F>(f: F) -> Self

where F: Fn() -> Res + Send + Sync + 'static,

Creates a fallback layer that generates a value using a function.

Unlike value, this doesn’t require Res: Clone since the function generates a fresh value for each fallback.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, MyResponse, MyError>::value_fn(|| {
    MyResponse { data: vec![0; 1024] }
});

impl<Req, Res, E> FallbackLayer<Req, Res, E>

where Res: Clone,

pub fn value(value: Res) -> Self

Creates a fallback layer that returns a static value on failure.

Note: This requires Res: Clone. If your response type doesn’t implement Clone, use value_fn instead.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, String, MyError>::value("default".to_string());

pub fn from_error<F>(f: F) -> Self

where F: Fn(&E) -> Res + Send + Sync + 'static,

Creates a fallback layer that computes a response from the error.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, String, MyError>::from_error(|e| {
    format!("Error: {}", e.msg)
});

pub fn from_request_error<F>(f: F) -> Self

where F: Fn(&Req, &E) -> Res + Send + Sync + 'static,

Creates a fallback layer that computes a response from request and error.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, String, MyError>::from_request_error(|req, _err| {
    format!("Fallback for request: {}", req)
});

pub fn service<S, Fut>(service: S) -> Self

where S: Fn(Req) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Res, E>> + Send + 'static,

Creates a fallback layer that routes to a backup service.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, String, MyError>::service(|req: String| async move {
    Ok::<_, MyError>(format!("backup: {}", req))
});

pub fn exception<F>(f: F) -> Self

where F: Fn(E) -> E + Send + Sync + 'static,

Creates a fallback layer that transforms errors.

Note: This still returns an error, just a transformed one.

Example

use tower_resilience_fallback::FallbackLayer;

let layer = FallbackLayer::<String, String, MyError>::exception(|e| {
    MyError { code: 500 }
});

Trait Implementations

impl<Req, Res, E> Clone for FallbackLayer<Req, Res, E>

where Res: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, Req, Res, E> Layer<S> for FallbackLayer<Req, Res, E>

where Res: Clone,

type Service = Fallback<S, Req, Res, E>

The wrapped service

fn layer(&self, service: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.