oxihttp-server — Pure-Rust HTTP server for the OxiHTTP stack

oxihttp-server is the HTTP server of the OxiHTTP stack. It serves HTTP/1.1 and HTTP/2 (auto-negotiated) with a path-parameter router, virtual hosts, nested routers, typed request extraction, application state injection, graceful shutdown, connection limits, TCP/HTTP-2 tuning, and a built-in middleware pipeline (CORS, body-size limits, token-bucket rate limiting, timeouts). Optional features add response compression, static-file serving, Server-Sent Events, WebSockets, Tower-layer integration, mutual-TLS, and HTTP/3.

The server builds on hyper and hyper-util's auto connection builder; all shared types (OxiHttpError, Body, typed headers, content negotiation) come from oxihttp-core. TLS is Pure Rust via oxitls + rustls/tokio-rustls (no OpenSSL); compression is Pure Rust via oxiarc-deflate; HTTP/3 is Pure Rust via oxiquic-h3. The crate is #![forbid(unsafe_code)].

Installation

[dependencies]
# Core HTTP/1.1 + HTTP/2 server
oxihttp-server = "0.1.0"

# With TLS, compression, static files, and WebSockets
oxihttp-server = { version = "0.1.0", features = ["tls", "compression", "static-files", "websocket"] }

Quick Start

use oxihttp_server::{Server, Router, response};

# async fn example() -> Result<(), oxihttp_core::OxiHttpError> {
let router = Router::new()
    .get("/hello", |_req| async {
        response::text_response("Hello, World!")
    })
    .get("/users/:id", |req| async move {
        let id = req.param("id").unwrap_or("?").to_string();
        response::text_response(format!("user {id}"))
    })
    .health("/health");

Server::bind("127.0.0.1:3000")
    .serve(router)
    .await?;
# Ok(())
# }

Graceful shutdown and a JSON handler

use oxihttp_server::{Server, Router, response};

# async fn example() -> Result<(), oxihttp_core::OxiHttpError> {
let router = Router::new().post("/echo", |req| async move {
    let value: serde_json::Value = req.body_json().await?;
    response::json_response(&value)
});

Server::bind("127.0.0.1:0")
    .with_max_connections(1024)
    .shutdown_on_ctrl_c()
    .serve(router)
    .await?;
# Ok(())
# }

API Overview

Server / ServerBuilder / BoundServer

Server::bind(addr) -> ServerBuilder starts configuration.

BoundServer exposes local_addr() -> SocketAddr and serve(Router) — useful when binding port 0 in tests.

ServerHttp2Settings

A Default struct of optional HTTP/2 knobs: initial_stream_window_size, initial_connection_window_size, adaptive_window, max_concurrent_streams, max_frame_size, keep_alive_interval, keep_alive_timeout.

Router (router module)

Path patterns support literal segments, :param parameters, and *wildcard (matches the remainder). Router implements Display (route listing) and Debug.

Public type aliases: HandlerFn, DispatchFuture<'a>.

Request (router module)

The handler argument. Path-params + query plus body consumers.

Extraction (extractor module)

Response helpers (response module)

Free functions returning Result<hyper::Response<Full<Bytes>>, OxiHttpError>:

Middleware (middleware module)

These are composed internally via the MiddlewarePipeline configured by the ServerBuilder::with_* methods.

Compression — feature compression (compression module)

Static files — feature static-files (static_files module)

Server-Sent Events — feature sse (sse module)

WebSockets — feature websocket (ws module)

Tower integration — feature tower (tower_compat, tower_middleware modules)

TLS — feature tls (tls module)

HTTP/3 — feature h3 (h3 module)

Feature Flags

Error type

Handlers and builder methods return oxihttp_core::OxiHttpError. The server commonly produces Server, Io, Http, Body, Json, Tls, RouteNotFound, and MethodNotAllowed; see the oxihttp-core README for the full variant table and the status_code() mapping.

Related crates

• oxihttp — the unified facade re-exporting this server.
• oxihttp-core — shared types (OxiHttpError, Body, typed headers, negotiation).
• oxihttp-client — the matching HTTP client.

License

Apache-2.0 — COOLJAPAN OU (Team Kitasan)