Struct Router 

pub struct Router { /* private fields */ }

Maps HTTP method + path pairs to handler functions.

Routes are inserted into a trie during registration, then frozen via freeze() before serving. Static segments take priority over parameterized segments (:name) during matching.

Implementations

impl Router

pub fn new() -> Self

Create an empty router with default buffer settings.

pub fn max_request_body(self, bytes: usize) -> Self

Set the maximum request body size in bytes (capped at 256 MB).

pub fn sse_buffer_size(self, size: usize) -> Self

Set the channel buffer size for SSE connections.

Controls how many events can be queued before backpressure applies. Default: 32.

pub fn ws_buffer_size(self, size: usize) -> Self

Set the channel buffer size for WebSocket connections.

Controls how many messages can be queued in each direction before backpressure applies. Default: 32.

pub fn skip_middleware_for_internal(self, skip: bool) -> Self

Skip middleware for internal routes (/health, /metrics, /debug/pprof/cpu).

Default: false (middleware applies to all routes including internal ones). Set to true to restore the pre-v3 behavior where internal routes bypass middleware, useful when health probes (Kubernetes, load balancers) cannot send auth headers.

pub fn use_middleware<F, Fut>(&mut self, mw: F)

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

Register async middleware that wraps all route handlers.

Middleware registered first executes outermost (wraps all later middleware). Each middleware receives the request and a Next handle — call next.call(req).await to continue the chain.

router.use_middleware(|req, next| async move {
    let resp = next.call(req).await;
    resp.with_header("X-Custom", "value")
});

pub fn get<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a GET handler for path.

Path segments beginning with : are captured as named parameters.

pub fn post<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a POST handler for path.

pub fn put<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a PUT handler for path.

pub fn delete<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a DELETE handler for path.

pub fn patch<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a PATCH handler for path.

pub fn head<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register a HEAD handler for path.

If you do not register one, Camber can still answer HEAD requests for matching GET routes by stripping the response body automatically.

pub fn options<F, Fut, R>(&mut self, path: &str, handler: F)

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

Register an OPTIONS handler for path.

pub fn get_stream( &mut self, path: &str, handler: impl Fn(&Request) -> Pin<Box<dyn Future<Output = StreamResponse> + Send>> + Send + Sync + 'static, )

Register an async streaming handler for GET requests.

The handler returns a StreamResponse for incremental body delivery. Use StreamResponse::new() to get both the response and a sender.

pub fn post_stream( &mut self, path: &str, handler: impl Fn(&Request) -> Pin<Box<dyn Future<Output = StreamResponse> + Send>> + Send + Sync + 'static, )

Register an async streaming handler for POST requests.

pub fn get_sse( &mut self, path: &str, handler: impl Fn(&Request, &mut SseWriter) -> Result<(), RuntimeError> + Send + Sync + 'static, )

Register an SSE streaming handler for GET requests.

The handler receives the request and an SseWriter for sending events. The connection stays open until the handler returns or the client disconnects.

pub fn ws( &mut self, path: &str, handler: impl Fn(&Request, WsConn) -> Result<(), RuntimeError> + Send + Sync + 'static, )

Register a WebSocket handler for the given path.

The handler receives the upgrade request and a bidirectional WsConn. The connection stays open until the handler returns or the client disconnects.

pub fn grpc(&mut self, grpc_router: GrpcRouter)

Register a gRPC service (generated by camber-build).

Requests with content-type: application/grpc are forwarded to the tonic service. All other requests go through normal HTTP routing.

pub fn proxy(&mut self, prefix: &str, backend: &str)

Register a reverse proxy that forwards requests under prefix to backend.

The prefix is stripped from the request path before forwarding. All HTTP methods are handled. The full upstream response is buffered, so middleware can inspect and modify the response body. On backend failure, returns 502.

pub fn proxy_checked( &mut self, prefix: &str, backend: &str, healthy: Arc<AtomicBool>, )

Register a health-checked reverse proxy.

Behaves like proxy() but checks the healthy flag before forwarding. When healthy is false, returns 503 immediately.

pub fn proxy_stream(&mut self, prefix: &str, backend: &str)

Register a streaming reverse proxy under prefix.

Like proxy(), but the upstream response body is forwarded chunk-by-chunk with backpressure instead of being buffered in memory. Middleware acts as a request gate only — it can reject before the upstream call, but does not wrap the streamed response.

pub fn proxy_checked_stream( &mut self, prefix: &str, backend: &str, healthy: Arc<AtomicBool>, )

Register a health-checked streaming reverse proxy.

Behaves like proxy_stream() but checks the healthy flag before forwarding. When healthy is false, returns 503 immediately.

pub fn static_files(&mut self, prefix: &str, dir: &str)

Serve static files from dir under the given URL prefix.

Trait Implementations

impl Debug for Router

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

Formats the value using the given formatter.

impl Default for Router

fn default() -> Self

Returns the “default value” for a type.