Struct ServerLimits 

pub struct ServerLimits {
    pub max_connections: usize,
    pub max_pending_connections: usize,
    pub wait_strategy: WaitStrategy,
    pub count_503_handlers: usize,
    pub json_errors: bool,
    /* private fields */
}

Controls server-level concurrency, queueing, and performance behavior.

Configures how the server handles connection admission, worker pools, and overload protection with tunable parameters for different workloads.

Connection management

                           [------------]
                           [ Tcp accept ]
                           [------------]
                                 ||
                                 || TCP_STREAM
                                 \/
[--------------]   Yes   /----------------\   No   [-------------]
[ Add to queue ] <====== | Queue if full? | =====> [ Sending 503 ]
[--------------]         \----------------/        [-------------]
       ||                       
       \==================\\          //====================\
                           V          V                    ||
[---------]   Yes   /--------------------------\   No   [------]
[ Handler ] <====== | Is there a free handler? | =====> [ Wait ]
[---------]         \--------------------------/        [------]

The queue acts as a buffer between connection acceptance and processing. Workers continuously poll the queue using the configured wait_strategy.

Handler

A worker process is a continuously running asynchronous task, created once during initialization (from tokio::spawn). It runs in an infinite loop, processing connections from a shared queue, which is replenished by a TCP listener. This design eliminates the need to create tasks for each connection, allowing for efficient resource reuse across an unlimited number of connections.

Fields

max_connections: usize

Maximum number of concurrent active connections being processed (default: 100).

When the server starts, exactly max_connections handlers are created and used.

max_pending_connections: usize

Maximum number of TCP connections waiting in the admission queue (default: 250).

All accepted connections first go into this queue. Worker processes select connections from here. If the queue becomes full, new connections receive immediate HTTP 503 responses.

For more information, see Connection management.

wait_strategy: WaitStrategy

Strategy for worker task waiting behavior (default: Sleep(50μs))

Controls how worker tasks wait when connection buffers are empty (the size is set by field max_pending_connections). Affects latency, CPU usage, and throughput characteristics.

count_503_handlers: usize

Dedicated handlers for queue overflow responses (default: 1).

When the connection queue becomes full, these handlers immediately send responses with the 503 code. Using multiple handlers prevents bottlenecks in scenarios with a large volume of rejected requests. Set to 0 to silently close the connection (not recommended for production HTTP servers).

json_errors: bool

Format for error responses (default: true)

Examples

If true, then on error the server will return:

HTTP/1.1 400 Bad Request\r
connection: close\r
content-length: 55\r
content-type: application/json\r
\r
{"error":"Invalid HTTP method","code":"INVALID_METHOD"}

If false, then on error the server will return:

HTTP/1.1 400 Bad Request\r
connection: close\r
content-length: 0\r
\r

Trait Implementations

impl Clone for ServerLimits

fn clone(&self) -> ServerLimits

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ServerLimits

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

Formats the value using the given formatter.

impl Default for ServerLimits

fn default() -> Self

Returns the “default value” for a type.