Struct ServeConfig 

#[non_exhaustive]
pub struct ServeConfig {
    pub max_connections: Option<usize>,
    pub drain_timeout: Duration,
    pub header_read_timeout: Option<Duration>,
    pub idle_timeout: Option<Duration>,
}

Limits applied to a Server.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

max_connections: Option<usize>

Ceiling on connections being served at once. None is unbounded, which is serve’s behaviour and is kept as an explicit choice rather than a default.

The permit is taken before accept(), so the ceiling is on accepted sockets. Load past it queues in the listen backlog and is refused by the kernel when that fills — which is a far better failure than an unbounded task spawn that turns a traffic spike into an OOM.

drain_timeout: Duration

How long to wait for watched connections to finish after shutdown is signalled, before giving up and reporting them abandoned.

header_read_timeout: Option<Duration>

How long a peer may take to send complete request headers. None disables the check.

This is the slowloris defence: a connection dribbling headers a byte at a time is refused instead of holding a task indefinitely.

idle_timeout: Option<Duration>

How long a connection may go with no traffic in either direction before it is closed. None disables the check.

Covers what the header timeout cannot: a peer that sent its headers promptly and then stopped mid-body, or one that finished a request and kept the connection open doing nothing.

Implementations

impl ServeConfig

pub fn new() -> Self

The defaults: unbounded connections, DEFAULT_DRAIN_TIMEOUT, DEFAULT_HEADER_READ_TIMEOUT and DEFAULT_IDLE_TIMEOUT.

Both timeouts default to on. An unbounded connection is the kind of default that only looks harmless until someone points a slowloris at it, and this constructor is new enough to have no callers relying on the permissive behaviour.

pub const fn with_max_connections(self, max: usize) -> Self

Caps the connections served at once.

This type is #[non_exhaustive] — a header-read timeout and an idle timeout are the obvious next fields — so it is built with setters rather than a struct literal, and gaining one of those is not a breaking change.

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

Sets how long shutdown waits for in-flight connections.

pub const fn with_header_read_timeout(self, timeout: Option<Duration>) -> Self

Sets how long a peer may take to send complete request headers.

None disables it. Do that only behind a proxy that already enforces one — this is the check that makes a slowloris cost the attacker something.

pub const fn with_idle_timeout(self, timeout: Option<Duration>) -> Self

Sets how long a connection may go with no traffic before it is closed.

None disables it. Raise it rather than disabling it if a deployment streams responses with long quiet stretches, and keep it above the SSE keep-alive interval — see DEFAULT_IDLE_TIMEOUT.

Trait Implementations

impl Clone for ServeConfig

fn clone(&self) -> ServeConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ServeConfig

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

Formats the value using the given formatter.

impl Default for ServeConfig

fn default() -> Self

Returns the “default value” for a type.