Struct AsyncAppWithState 

pub struct AsyncAppWithState<S> { /* private fields */ }

Available on crate feature http2 only.

An Application whose route handlers are async functions.

State is stored as Arc<S> and passed by value (cheap clone) to each handler invocation. Handlers receive owned Request, PathParams, and ConnectionInfo values so the returned future is 'static.

Implementations

impl<S> AsyncAppWithState<S>

where S: Send + Sync + 'static,

pub fn new(state: S) -> AsyncAppWithState<S>

Create a new AsyncAppWithState wrapping state.

pub fn with_config(self, config: ServerConfig) -> AsyncAppWithState<S>

Pin the fallback App (used for any request this app’s own routes don’t match) to an explicit crate::server_config::ServerConfig, instead of reading RWS_CONFIG_* environment variables per request.

Mirrors App::with_config / crate::state::AppWithState::with_config.

pub fn state(&self) -> &S

Return a reference to the shared state.

pub fn route_entries(&self) -> Vec<RouteInfo>

Return a snapshot of all registered routes as (method, pattern) pairs.

pub fn route_conflicts(&self) -> Vec<RouteConflict>

Routes that never run because an earlier one with the same method matches every path they do (18.28.0). See Router::route_conflicts; each is also printed once to stderr when it’s registered.

pub fn route<H>(self, handler: H) -> AsyncAppWithState<S>

where H: AsyncHandler<S>,

Register a typed handler (18.28.0): an async fn (or a sync function) with extractor arguments annotated #[get("/path")] & co.; the method and pattern come from the attribute.

#[get("/posts/{id}")]
async fn show_post(Path(id): Path<i64>, State(pool): State<DbPool>) -> Result<Json<Post>, AppError> {
    // … .await …
}

let app = App::with_async_state(pool).route(show_post);

pub fn get<F, Fut>(self, pattern: &str, handler: F) -> AsyncAppWithState<S>

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async GET handler for pattern.

pub fn post<F, Fut>(self, pattern: &str, handler: F) -> AsyncAppWithState<S>

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async POST handler for pattern.

pub fn put<F, Fut>(self, pattern: &str, handler: F) -> AsyncAppWithState<S>

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async PUT handler for pattern.

pub fn patch<F, Fut>(self, pattern: &str, handler: F) -> AsyncAppWithState<S>

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async PATCH handler for pattern.

pub fn delete<F, Fut>(self, pattern: &str, handler: F) -> AsyncAppWithState<S>

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async DELETE handler for pattern.

pub fn openapi(self, config: OpenApiConfig) -> AsyncAppWithState<S>

Available on crate feature openapi only.

Add GET /openapi.json (a generated OpenAPI 3.1 document covering every route registered so far) and GET /docs (Swagger UI, loaded from a CDN, pointed at /openapi.json).

Call this after registering your routes — routes added afterward still work but won’t appear in the generated spec, since it’s built once at this call rather than read dynamically per request.

Requires the openapi feature (and http2, since AsyncAppWithState already requires it).

Trait Implementations

impl<S> Application for AsyncAppWithState<S>

where S: Send + Sync + 'static,

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 registered_routes(&self) -> Vec<RouteInfo>

The routes this application registers, as (method, pattern) — what AppWithState::route_entries returns; wrappers (WithMiddleware, McpServer) report the routes of the application inside. For tools that describe an app (the dev MCP server’s routes tool), not for dispatch. Default: none. Since 18.28.0.

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

Available on crate feature http2 only.

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.

fn middleware_names(&self) -> Vec<&'static str>

The names of the middleware layers around this application’s routes, in the order a request passes them (Middleware::layer_name). Default: none; WithMiddleware lists its layers, then the inner application’s. Since 18.28.0.

impl<S> Clone for AsyncAppWithState<S>

where S: Clone,

fn clone(&self) -> AsyncAppWithState<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.