Struct Server 

pub struct Server { /* private fields */ }

A native HTTP/1 server whose request execution remains thread-local.

Keeping one compiled app per worker means operation futures, plugin hooks, and request-scoped dependencies do not need Send or Sync.

Implementations

impl Server

pub fn new(app: ExecutableApp) -> Self

pub fn with_max_body_bytes(self, max_body_bytes: usize) -> Self

pub fn with_middleware(self, middleware: impl HttpMiddleware + 'static) -> Self

Registers runtime-neutral HTTP middleware in registration order.

Middleware runs for every request this server dispatches, so header policy, compression, rate limiting, and security layers apply on the socket path and not only in the in-memory test client.

pub fn with_shared_middleware(self, middleware: Rc<dyn HttpMiddleware>) -> Self

Registers middleware whose state is shared with the caller.

pub const fn with_max_connections( self, connections: Option<NonZeroUsize>, ) -> Self

Bounds concurrently served connections. None accepts without a cap.

A connection accepted while the cap is reached is closed immediately instead of being dispatched.

pub const fn with_tcp_nodelay(self, nodelay: bool) -> Self

Enables or disables TCP_NODELAY on accepted sockets. Enabled by default so a small response is not delayed by Nagle’s algorithm.

pub fn with_limits(self, limits: ServerLimits) -> Self

pub fn with_openapi(self, config: OpenApiConfig) -> Self

Mounts precompiled /openapi.json and API reference UI assets.

pub const fn with_request_timeout(self, timeout: Duration) -> Self

Sets a wall-clock limit for provider, hook, and handler execution.

Dependency finalizers and response hooks are shielded so cleanup still completes after the timeout fires.

pub fn serve(self, address: impl ToSocketAddrs) -> Result<()>

Binds and serves HTTP/1 connections until the process is stopped.

Errors

Returns a socket error if address resolution, binding, or accepting a connection fails.

pub fn serve_gracefully( self, address: impl ToSocketAddrs, shutdown: ShutdownSignal, drain_timeout: Duration, ) -> Result<()>

Stops accepting when shutdown resolves, closes keep-alive connections after their current response, and drains active work.

Errors

Returns an I/O error if binding or accepting a connection fails.

pub async fn serve_io<IO>(&self, io: &mut IO) -> Result<()>

where IO: AsyncRead + AsyncWrite + Unpin,

Serves HTTP/1 requests over a borrowed futures-I/O transport.

This is useful for in-memory protocol tests. A borrowed transport cannot transfer ownership, so protocol upgrades are refused here; owned transports reach Self::serve and keep the upgrade capability.

Errors

Returns an I/O error if the transport cannot be read or written.

pub async fn serve_owned_io<IO>(&self, io: IO) -> Result<()>

where IO: AsyncRead + AsyncWrite + Unpin + 'static,

Serves HTTP/1 requests over an owned futures-I/O transport.

Ownership stays with the connection loop, so a protocol upgrade moves the transport into its session handler instead of being refused. TLS connections and in-memory compatibility transports take this path.

Errors

Returns an I/O error if the transport cannot be read or written, or the failure reported by an upgraded protocol session.

Trait Implementations

impl Debug for Server

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

Formats the value using the given formatter.