Struct FilterLayer

pub struct FilterLayer<F, S, T, R, E>
where
    F: Filter<T>,
    S: Service<T, Response = R, Error = E>,
{ /* private fields */ }

A Tower layer that executes the provided service only if the given filter returns true. Otherwise it falls through to the inner server.

Example

use tower_fallthrough_filter::{Filter, FilterLayer};
use tower::{Service, Layer};

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

impl Filter<bool> for MyFilter {
    fn matches(&self, data: &bool) -> bool {
        *data
    }
}

#[derive(Debug, Clone)]
struct StringService(String);

impl Service<bool> for StringService {
    type Response = String;
    type Error = std::convert::Infallible;
    type Future = std::future::Ready::<Result<Self::Response, Self::Error>>;

    fn poll_ready(
        &mut self,
        _: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: bool) -> Self::Future {
        std::future::ready(Ok(self.0.clone()))
    }
}

#[tokio::main]
async fn main() {
    let service_a = StringService("A".to_string());
    let service_b = StringService("B".to_string());
    let filter = MyFilter;

    let mut middleware = FilterLayer::new(filter, service_a).layer(service_b);

    assert_eq!(middleware.call(true).await, Ok("A".to_string()));
    assert_eq!(middleware.call(false).await, Ok("B".to_string()));
}

Implementations

impl<F: Filter<T>, S: Service<T>, T> FilterLayer<F, S, T, S::Response, S::Error>

pub fn new(filter: F, service: S) -> Self

Creates a new FilterLayer given a Service and a Filter.

NOTE: The Service and the Filter have to operate on the same type T.

Trait Implementations

impl<F, S, R, E, T> Clone for FilterLayer<F, S, T, R, E>

where F: Filter<T> + Clone, S: Service<T, Response = R, Error = E> + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, S, T: Debug, R: Debug, E: Debug> Debug for FilterLayer<F, S, T, R, E>

where F: Filter<T> + Debug, S: Service<T, Response = R, Error = E> + Debug,

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

Formats the value using the given formatter.

impl<F, S, I, T, R, E> Layer<I> for FilterLayer<F, S, T, R, E>

where F: Filter<T> + Clone, S: Service<T, Response = R, Error = E> + Clone, I: Service<T, Response = R, Error = E> + Clone,

type Service = FilterService<F, S, I, T, R, E>

The wrapped service

fn layer(&self, inner_service: I) -> Self::Service

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