Struct App 

pub struct App { /* private fields */ }

A configured web application.

The App holds all routes, middleware, state, and lifecycle hooks, and provides methods to handle incoming requests.

Implementations

impl App

pub fn builder() -> AppBuilder

Creates a new application builder.

pub fn test_client(self: Arc<Self>) -> TestClient<Arc<Self>>

Create an in-process test client for this app.

This takes Arc<Self> so tests can keep using shared Arc<App> values without extra boilerplate.

pub fn test_client_with_seed( self: Arc<Self>, seed: u64, ) -> TestClient<Arc<Self>>

Create an in-process test client with a deterministic seed.

pub fn config(&self) -> &AppConfig

Returns the application configuration.

pub fn route_count(&self) -> usize

Returns the number of registered routes.

pub fn websocket_route_count(&self) -> usize

Returns the number of registered websocket routes.

pub fn has_websocket_route(&self, path: &str) -> bool

Returns true if a websocket route matches the given path.

pub fn routes(&self) -> impl Iterator<Item = (Method, &str)>

Returns an iterator over route metadata (method, path).

This is useful for generating OpenAPI specifications or debugging.

pub fn openapi_spec(&self) -> Option<&str>

Returns the generated OpenAPI specification JSON, if OpenAPI is enabled.

Example

let app = App::builder()
    .openapi(OpenApiConfig::new().title("My API"))
    .build();

if let Some(spec) = app.openapi_spec() {
    println!("OpenAPI spec: {}", spec);
}

pub fn state(&self) -> &Arc<StateContainer>

Returns the shared state container.

pub fn get_state<T: Send + Sync + 'static>(&self) -> Option<Arc<T>>

Gets a reference to shared state of type T.

pub fn exception_handlers(&self) -> &Arc<ExceptionHandlers>

Returns the exception handlers registry.

pub fn override_dependency_value<T>(&self, value: T)

where T: FromDependency,

Register a fixed override value for a dependency type.

This is a test-focused convenience API; production code typically wires dependencies via crate::dependency::FromDependency implementations.

pub fn clear_dependency_overrides(&self)

Clear all registered dependency overrides.

pub fn dependency_overrides(&self) -> Arc<DependencyOverrides>

Returns the shared dependency overrides registry.

pub fn take_background_tasks(req: &mut Request) -> Option<BackgroundTasks>

Take request-scoped background tasks (if any) from a request.

The HTTP server calls this after writing the response so any deferred work runs outside the main request handler path.

pub fn handle_error<E>(&self, ctx: &RequestContext, err: E) -> Option<Response>

where E: Error + Send + Sync + 'static,

Handles an error using registered exception handlers.

If a handler is registered for the error type, it will be invoked. Otherwise, returns None.

pub fn handle_error_or_default<E>( &self, ctx: &RequestContext, err: E, ) -> Response

where E: Error + Send + Sync + 'static,

Handles an error, returning a 500 response if no handler is registered.

pub async fn handle(&self, ctx: &RequestContext, req: &mut Request) -> Response

Handles an incoming request.

This matches the request against registered routes, runs middleware, and returns the response.

pub async fn handle_websocket( &self, ctx: &RequestContext, req: &mut Request, ws: WebSocket, ) -> Result<(), WebSocketError>

Handles an incoming websocket upgrade request after the handshake has been accepted.

The HTTP server is responsible for validating the upgrade headers and writing the 101 response. This function only performs path matching and calls the websocket handler.

pub async fn run_startup_hooks(&self) -> StartupOutcome

Runs all startup hooks.

Hooks run in registration order (FIFO). If a hook returns an error with abort: true, execution stops and returns StartupOutcome::Aborted.

This consumes the startup hooks - they can only be run once.

Returns

• StartupOutcome::Success if all hooks succeeded
• StartupOutcome::PartialSuccess if some hooks had non-fatal errors
• StartupOutcome::Aborted if a fatal hook error occurred

pub async fn run_shutdown_hooks(&self)

Runs all shutdown hooks.

Hooks run in reverse registration order (LIFO). Errors are logged but do not stop other hooks from running.

This consumes the shutdown hooks - they can only be run once.

pub fn transfer_shutdown_hooks(&self, controller: &ShutdownController)

Transfers shutdown hooks to a ShutdownController.

This moves all registered shutdown hooks to the controller, which will run them during the appropriate shutdown phase.

Call this when integrating with the server’s shutdown mechanism.

pub fn pending_startup_hooks(&self) -> usize

Returns the number of pending startup hooks.

pub fn pending_shutdown_hooks(&self) -> usize

Returns the number of pending shutdown hooks.

Trait Implementations

impl Debug for App

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Handler for App

fn call<'a>( &'a self, ctx: &'a RequestContext, req: &'a mut Request, ) -> BoxFuture<'a, Response>

Process a request and return a response.

fn dependency_overrides(&self) -> Option<Arc<DependencyOverrides>>

Optional dependency overrides to apply when building request contexts.