Trait Middleware 

pub trait Middleware<S> {
    type Request;
    type Response;
    type Error;
    type Service: Service<Request = Self::Request, Response = Self::Response, Error = Self::Error>;

    // Required method
    fn wrap(&self, inner: S) -> Self::Service;

    // Provided method
    fn chain<T>(self, middleware: T) -> Chain<Self, T>
       where T: Middleware<Self::Service>,
             Self: Sized { ... }
}

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 Middleware 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:

use tower_service::Service;
use tower_web::middleware::Middleware;
use futures::{Future, Poll};

use std::fmt;

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

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

    fn wrap(&self, service: S) -> LogService<S> {
        LogService {
            target: self.target,
            service
        }
    }
}

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

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

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        self.service.poll_ready()
    }

    fn call(&mut self, request: Self::Request) -> Self::Future {
        info!(target: self.target, "request = {:?}", request);
        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.

Required Associated Types

type Request

The wrapped service request type

type Response

The wrapped service response type

type Error

The wrapped service’s error type

type Service: Service<Request = Self::Request, Response = Self::Response, Error = Self::Error>

The wrapped service

Required Methods

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

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

Provided Methods

fn chain<T>(self, middleware: T) -> Chain<Self, T>

where T: Middleware<Self::Service>, Self: Sized,

Return a new Middleware instance that applies both self and middleware to services being wrapped.

This defines a middleware stack.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<S, Inner, Outer> Middleware<S> for Chain<Inner, Outer>

where S: Service, Inner: Middleware<S>, Outer: Middleware<Inner::Service>,

type Request = <Outer as Middleware<<Inner as Middleware<S>>::Service>>::Request

type Response = <Outer as Middleware<<Inner as Middleware<S>>::Service>>::Response

type Error = <Outer as Middleware<<Inner as Middleware<S>>::Service>>::Error

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

impl<S, RequestBody, ResponseBody> Middleware<S> for DeflateMiddleware

where S: Service<Request = Request<RequestBody>, Response = Response<ResponseBody>>, RequestBody: BufStream, ResponseBody: BufStream, S::Error: Error,

type Request = Request<RequestBody>

type Response = Response<CompressStream<ResponseBody>>

type Error = <S as Service>::Error

type Service = DeflateService<S>

impl<S, RequestBody, ResponseBody> Middleware<S> for LogMiddleware

where S: Service<Request = Request<RequestBody>, Response = Response<ResponseBody>>, S::Error: Error,

type Request = Request<RequestBody>

type Response = Response<ResponseBody>

type Error = <S as Service>::Error

type Service = LogService<S>

impl<S: Service> Middleware<S> for Identity

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

type Request = <S as Service>::Request

type Response = <S as Service>::Response

type Error = <S as Service>::Error

type Service = S

impl<S> Middleware<S> for CorsMiddleware

where S: HttpService,

type Request = Request<<S as HttpService>::RequestBody>

type Response = Response<Option<<S as HttpService>::ResponseBody>>

type Error = <S as HttpService>::Error

type Service = CorsService<S>