Struct WithMiddleware 

pub struct WithMiddleware<A> { /* private fields */ }

An Application that applies a stack of Middleware layers before dispatching to an inner application.

Layers are applied in registration order: the first .wrap()ed middleware runs first on the request path and last on the response path.

Implementations

impl<A> WithMiddleware<A>

where A: Application,

pub fn new(app: A) -> WithMiddleware<A>

Wrap app with no initial middleware.

pub fn wrap(self, layer: impl Middleware + 'static) -> WithMiddleware<A>

Add a middleware layer. Layers run in registration order.

impl<A> WithMiddleware<A>

where A: Application + Send + Sync + Clone + 'static,

pub fn mcp( self, name: impl Into<String>, version: impl Into<String>, ) -> McpServer

Attach an MCP server that handles POST /mcp; all other requests fall through to this middleware stack.

Trait Implementations

impl<A> Application for WithMiddleware<A>

where A: Application,

fn execute( &self, request: &Request, connection: &ConnectionInfo, ) -> Result<Response, String>

Receives a parsed request and returns a fully-built response. Walk your controller list with is_matching / process and return the first match.

fn runs_inline(&self, request: &Request, connection: &ConnectionInfo) -> bool

true when executing request is quick and never waits on anything but the local filesystem — health checks, metrics, small static files. The async servers (HTTP/1.1, HTTP/2, HTTP/3) then call execute directly on the event loop, as nginx does, instead of handing the request to tokio’s blocking pool: that handoff (a shared lock and two cross-thread wake-ups) costs more than serving a small file.

fn execute_async<'a>( &'a self, request: &'a Request, connection: &'a ConnectionInfo, ) -> Option<Pin<Box<dyn Future<Output = Result<Response, String>> + Send + 'a>>>

An asynchronous version of execute for this request, when the application has one: the async servers await it on the connection’s task instead of tying up a blocking-pool thread while it waits (the config-driven proxy uses this to wait for a backend without holding a thread). None (the default) means “use execute”. Wrappers return Some only when they add no synchronous work of their own.

fn streams_body(&self, request: &Request, connection: &ConnectionInfo) -> bool

true to receive this request’s body as a stream (Body::Stream) instead of read into memory first: execute then runs while the body is still arriving, on a blocking-pool thread, and reads it with std::io::Read — a multi-gigabyte upload in a few chunks of memory. Asked after the head is read, so request.body is empty here; decide from the method, path and headers.

impl<A> Clone for WithMiddleware<A>

where A: Clone,

fn clone(&self) -> WithMiddleware<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.