Struct ForkJoinLayer 

pub struct ForkJoinLayer<A, B> {
    pub left: A,
    pub right: B,
}

Fork-join composition layer that tries both left and right concurrently.

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

Both services are called concurrently, and the first successful result is returned. If both fail, an error is returned (currently the left error, but this may change).

This implements the “happy eyeballs” pattern commonly used for IPv4/IPv6 racing, cache racing, or trying multiple backends simultaneously.

Example

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

// Race two caches - use whichever responds first
let cache_a = Policy(TimeoutLayer::new(Duration::from_millis(100))?);
let cache_b = Policy(TimeoutLayer::new(Duration::from_millis(100))?);
let _policy = cache_a & cache_b;
// Tries both concurrently, returns first Ok result

IPv4/IPv6 Happy Eyeballs Example

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

// Try IPv4 and IPv6 in parallel
let ipv4_path = Policy(TimeoutLayer::new(Duration::from_millis(300))?);
let ipv6_path = Policy(TimeoutLayer::new(Duration::from_millis(300))?);
let _policy = ipv4_path & ipv6_path;

Fields

left: A

The left strategy (tried concurrently with right)

right: B

The right strategy (tried concurrently with left)

Trait Implementations

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

fn clone(&self) -> ForkJoinLayer<A, B>

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 ForkJoinLayer<A, B>

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

Formats the value using the given formatter.

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

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

type Service = ForkJoinService<<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.