Struct App 

pub struct App { /* private fields */ }

Main application struct

Implementations

impl App

pub fn new() -> Self

pub fn max_body_size(self, size: Option<usize>) -> Self

Set maximum request body size in bytes (None = unlimited)

pub fn state<T: Send + Sync + 'static>(self, value: T) -> Self

Register shared application state, readable in handlers and middleware with Request::state

One value per type; registering the same type again replaces it. Use interior mutability (Mutex, RwLock, atomics) for mutable state: the value is shared by all requests and is not cloned.

use ullun::prelude::*;
use std::sync::atomic::{AtomicU64, Ordering};

#[derive(Default)]
struct Hits(AtomicU64);

async fn count(req: Request) -> Result<Response> {
    let hits = req.state::<Hits>()?.0.fetch_add(1, Ordering::Relaxed) + 1;
    Ok(Response::text(hits.to_string()))
}

let app = App::new().state(Hits::default()).get("/", count);

pub fn group( self, prefix: &str, configure: impl FnOnce(RouteGroup) -> RouteGroup, ) -> Self

Create a route group with a common prefix

pub fn doc(self, method: &str, path: &str, operation: Operation) -> Self

Describe a registered route for the OpenAPI document

path is the path exactly as registered, e.g. /users/{id}.

pub fn openapi(self, info: OpenApiInfo) -> Self

Publish an OpenAPI 3.1 document of all routes (and optionally Swagger UI)

See the openapi module.

pub fn get<H>(self, path: &str, handler: H) -> Self

where H: Handler,

Add GET route

pub fn get_with_params<F, Fut>(self, path: &str, handler: F) -> Self

where F: Fn(Params) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Response>> + Send + 'static,

Add GET route with path params extractor

pub fn post<H>(self, path: &str, handler: H) -> Self

where H: Handler,

Add POST route

pub fn put<H>(self, path: &str, handler: H) -> Self

where H: Handler,

Add PUT route

pub fn delete<H>(self, path: &str, handler: H) -> Self

where H: Handler,

Add DELETE route

pub fn patch<H>(self, path: &str, handler: H) -> Self

where H: Handler,

Add PATCH route

pub fn ws<F, Fut>(self, path: &str, handler: F) -> Self

where F: Fn(Request, WebSocket) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Accept WebSocket connections on path (feature websocket)

The handler receives the original request (path params, query, headers, extensions set by middleware) and the upgraded socket, and runs on its own task until it returns.

pub fn ws_with<F, Fut>(self, path: &str, options: WsOptions, handler: F) -> Self

where F: Fn(Request, WebSocket) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Like App::ws with explicit size limit and allowed origins

pub fn middleware<M>(self, middleware: M) -> Self

where M: Middleware,

Add middleware

pub fn serve_static(self, route_prefix: &str, dir_path: &str) -> Self

Serve static files from a directory

pub async fn run(self, addr: &str) -> Result<()>

Run the server with graceful shutdown on CTRL+C

pub async fn serve(self, listener: TcpListener) -> Result<()>

Serve on an already bound listener until the future is dropped.

Useful for tests, benchmarks and embedding: bind to port 0, read the assigned port from listener.local_addr(), then call serve. Unlike App::run, this does not install a CTRL+C handler.

Trait Implementations

impl Default for App

fn default() -> Self

Returns the “default value” for a type.