Trait tower::layer::Layer

pub trait Layer<S> {
    type Service;
    fn layer(&self, inner: S) -> Self::Service;
}

Decorates a Service, transforming either the request or the response.

Often, many of the pieces needed for writing network applications can be reused across multiple services. The Layer trait can be used to write reusable components that can be applied to very different kinds of services; for example, it can be applied to services operating on different protocols, and to both the client and server side of a network transaction.

Log

Take request logging as an example:

pub struct LogLayer {
    target: &'static str,
}

impl<S> Layer<S> for LogLayer {
    type Service = LogService<S>;

    fn layer(&self, service: S) -> Self::Service {
        LogService {
            target: self.target,
            service
        }
    }
}

// This service implements the Log behavior
pub struct LogService<S> {
    target: &'static str,
    service: S,
}

impl<S, Request> Service<Request> for LogService<S>
where
    S: Service<Request>,
    Request: fmt::Debug,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&mut self, request: Request) -> Self::Future {
        // Insert log statement here or other functionality
        println!("request = {:?}, target = {:?}", request, self.target);
        self.service.call(request)
    }
}

The above log implementation is decoupled from the underlying protocol and is also decoupled from client or server concerns. In other words, the same log middleware could be used in either a client or a server.

Associated Types

type Service

The wrapped service

Loading content...

Required methods

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

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

Loading content...

Implementations on Foreign Types

impl<'a, T, S> Layer<S> for &'a T where
    T: Layer<S> + ?Sized, 

type Service = <T as Layer<S>>::Service

pub fn layer(&self, inner: S) -> <&'a T as Layer<S>>::Service

Loading content...

Implementors

impl<F, S, Out> Layer<S> for LayerFn<F> where
    F: Fn(S) -> Out, 

type Service = Out

pub fn layer(&self, inner: S) -> <LayerFn<F> as Layer<S>>::Service

impl<S> Layer<S> for Identity

Decorates a Service, transforming either the request or the response.

type Service = S

pub fn layer(&self, inner: S) -> <Identity as Layer<S>>::Service

impl<S> Layer<S> for ConcurrencyLimitLayer

type Service = ConcurrencyLimit<S>

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

impl<S> Layer<S> for RateLimitLayer

type Service = RateLimit<S>

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

impl<S> Layer<S> for TimeoutLayer

type Service = Timeout<S>

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

impl<S, A, B> Layer<S> for Either<A, B> where
    A: Layer<S>,
    B: Layer<S>, 

type Service = Either<A::Service, B::Service>

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

impl<S, F> Layer<S> for AndThenLayer<F> where
    F: Clone, 

type Service = AndThen<S, F>

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

impl<S, F> Layer<S> for MapErrLayer<F> where
    F: Clone, 

type Service = MapErr<S, F>

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

impl<S, F> Layer<S> for MapRequestLayer<F> where
    F: Clone, 

type Service = MapRequest<S, F>

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

impl<S, F> Layer<S> for MapResponseLayer<F> where
    F: Clone, 

type Service = MapResponse<S, F>

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

impl<S, F> Layer<S> for MapResultLayer<F> where
    F: Clone, 

type Service = MapResult<S, F>

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

impl<S, F> Layer<S> for ThenLayer<F> where
    F: Clone, 

type Service = Then<S, F>

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

impl<S, Inner, Outer> Layer<S> for Stack<Inner, Outer> where
    Inner: Layer<S>,
    Outer: Layer<<Inner as Layer<S>>::Service>, 

type Service = <Outer as Layer<<Inner as Layer<S>>::Service>>::Service

pub fn layer(&self, service: S) -> <Stack<Inner, Outer> as Layer<S>>::Service

impl<S, Req> Layer<S> for MakeBalanceLayer<S, Req>

type Service = MakeBalance<S, Req>

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

impl<S, Request> Layer<S> for BufferLayer<Request> where
    S: Service<Request> + Send + 'static,
    S::Future: Send,
    S::Error: Into<BoxError> + Send + Sync,
    Request: Send + 'static, 

type Service = Buffer<S, Request>

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

Loading content...