Struct FallbackLayer 

pub struct FallbackLayer<A, B> {
    pub primary: A,
    pub secondary: B,
}

Fallback composition layer that tries primary, falling back to secondary on error.

Created by the | operator on Policy<L> types: Policy(A) | Policy(B) produces Policy<FallbackLayer<A, B>>.

When a request fails through the primary stack, the original request is retried through the secondary stack. This enables graceful degradation and multi-tier resilience strategies.

Example

use ninelives::prelude::*;
use std::time::Duration;
use tower_layer::Layer;

// Try fast timeout first, fall back to longer timeout on failure
let fast = Policy(TimeoutLayer::new(Duration::from_millis(100))?);
let slow = Policy(TimeoutLayer::new(Duration::from_secs(5))?);
let _fallback = fast | slow;

Complex Example

use ninelives::prelude::*;
use std::time::Duration;
use tower_layer::Layer;

// Try aggressive strategy, fallback to defensive strategy
let aggressive = Policy(TimeoutLayer::new(Duration::from_millis(50))?);
let defensive = Policy(TimeoutLayer::new(Duration::from_secs(10))?)
              + Policy(TimeoutLayer::new(Duration::from_secs(5))?);
let _policy = aggressive | defensive;
// First tries 50ms timeout, on failure tries nested 10s+5s timeouts

Fields

primary: A

The primary layer strategy (tried first)

secondary: B

The secondary layer strategy (fallback on primary failure)

Trait Implementations

impl<A: Clone, B: Clone> Clone for FallbackLayer<A, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for FallbackLayer<A, B>

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

Formats the value using the given formatter.

impl<S, A, B> Layer<S> for FallbackLayer<A, B>

where S: Clone + Send + 'static, A: Layer<S>, B: Layer<S>, A::Service: Send + 'static, B::Service: Send + 'static,

type Service = FallbackService<<A as Layer<S>>::Service, <B as Layer<S>>::Service>

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.