Struct TowerLayer 

pub struct TowerLayer<L> { /* private fields */ }

Available on crate feature tower only.

A Tower Layer — tower-http’s SetResponseHeaderLayer, ValidateRequestHeaderLayer, TimeoutLayer, NormalizePathLayer, … — as rws Middleware: app.wrap(TowerLayer::new(layer)).

Per request the layer wraps the rest of the stack (Next); the request goes in as http::Request<Body> and the response comes back through the layer as http::Response<_>. Streamed responses (files, SSE, proxied streams) stay streams. Request bodies reach the layer read into memory. It runs on a blocking-pool thread, never inline on the event loop.

Implementations

impl<L> TowerLayer<L>

pub fn new(layer: L) -> TowerLayer<L>

Trait Implementations

impl<L, ResBody> Middleware for TowerLayer<L>

where L: for<'a> Layer<Next<'a>> + Send + Sync, <L as Layer<Next<'a>>>::Service: for<'a> Service<Request<Body>, Response = Response<ResBody>>, <<L as Layer<Next<'a>>>::Service as Service<Request<Body>>>::Error: for<'a> Into<Box<dyn Error + Send + Sync>>, ResBody: Body<Data = Bytes> + Send + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

fn handle( &self, request: &Request, connection: &ConnectionInfo, next: &dyn Application, ) -> Result<Response, String>

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true when this layer’s own work for request never blocks (in-memory state, atomics, short mutexes) — see Application::runs_inline. A WithMiddleware stack runs inline only if every layer and the inner application agree. Default false.

fn is_passthrough( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when handle would do nothing for request but call next (e.g. a rate limit that isn’t configured). A WithMiddleware stack offers the inner application’s execute_async only if every layer passes the request through. Default false.

fn accepts_streamed_body( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when this layer never reads request.body, so the inner application may receive it as a stream (Application::streams_body). A layer that inspects the body (CSRF tokens in a form, request signatures, rewriting) must keep the default false: it would see an empty body.

fn answers_streamed_body( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when this layer answers request itself — it doesn’t call next — and reads its body as a stream (a proxy forwarding it as it arrives). The body is then streamed whatever the layers after it and the application would say. Requires accepts_streamed_body. Since 18.3.0.

fn layer_name(&self) -> &'static str

A short name for this layer, as tools that describe an app list it (Application::middleware_names): by default the type’s name without its module path or generic parameters (CacheLayer). Since 18.28.0.