Struct FallbackConfigBuilder 

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

Builder for constructing a FallbackLayer.

Implementations

impl<Req, Res, E> FallbackConfigBuilder<Req, Res, E>

pub fn new() -> Self

Creates a new builder with default settings.

pub fn name(self, name: impl Into<String>) -> Self

Sets the name for this fallback instance (used in metrics and events).

pub fn value(self, value: Res) -> Self

where Res: Clone,

Sets a static fallback value.

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

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

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

Sets a fallback value generator 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> = FallbackLayer::builder()
    .value_fn(|| MyResponse { data: vec![0; 1024] })
    .build();

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

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

Sets a fallback function that computes a response from the error.

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

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

Sets a fallback function that has access to both request and error.

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

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

Sets a backup service to call on failure.

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

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

Sets an error transformation function.

pub fn handle<F>(self, predicate: F) -> Self

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

Only trigger fallback for errors matching this predicate.

Errors that don’t match the predicate will be propagated as-is.

pub fn handle_response<F>(self, predicate: F) -> Self

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

Trigger fallback for successful responses matching this predicate.

When this predicate returns true for a response, the fallback strategy is applied as if the service had returned an error. This is useful when errors are encoded inside successful responses, such as:

• JSON-RPC error codes in the response body
• HTTP 200 responses containing error payloads
• Responses indicating degraded or stale data

Example

use tower_resilience_fallback::FallbackLayer;

#[derive(Debug, Clone)]
struct MyError;

#[derive(Clone)]
struct ApiResponse {
    is_stale: bool,
    data: String,
}

let layer: FallbackLayer<String, ApiResponse, MyError> = FallbackLayer::builder()
    .value_fn(|| ApiResponse { is_stale: false, data: "default".to_string() })
    .handle_response(|resp: &ApiResponse| resp.is_stale)
    .build();

pub fn on_event<F>(self, listener: F) -> Self

where F: Fn(&FallbackEvent) + Send + Sync + 'static,

Adds an event listener.

pub fn build(self) -> FallbackLayer<Req, Res, E>

Builds the fallback layer.

Panics

Panics if no fallback strategy was configured.

Trait Implementations

impl<Req, Res, E> Default for FallbackConfigBuilder<Req, Res, E>

fn default() -> Self

Returns the “default value” for a type.