Struct Serve 

pub struct Serve<L, M, S, B> { /* private fields */ }

A server future that serves HTTP connections.

This is the return type of serve. It implements IntoFuture, so you can directly .await it:

serve(listener, service).await?;

Before awaiting, you can configure it:

• configure_hyper - Configure Hyper’s automatic connection builder
• max_connections - Configure the accepted-connection limit
• header_read_timeout - Configure the request-header deadline
• with_graceful_shutdown - Enable graceful shutdown
• local_addr - Get the bound address

Created by serve.

Implementations

impl<L, M, S, B> Serve<L, M, S, B>

where L: Listener,

pub fn configure_hyper<F>(self, f: F) -> Self

where F: FnOnce(Builder<TokioExecutor>) -> Builder<TokioExecutor>,

Configure the underlying Hyper connection builder.

This allows you to customize Hyper’s HTTP/1 and HTTP/2 settings, such as timeouts, max concurrent streams, keep-alive behavior, etc.

Note: Calling this replaces the default builder entirely, opting out of the built-in HTTP/2 defaults. You are responsible for setting your own HTTP/2 timeouts. The connection limit and Self::header_read_timeout remain enabled. When HTTP/1 is enabled, serve supplies its timer and applies header_read_timeout after this configuration, overriding any HTTP/1 header-read timeout set on the builder.

http1_only() and http2_only() restrict the accepted protocol and use Hyper’s regular connection API without HTTP/1 upgrades. When both protocols are enabled, serve uses serve_connection_with_upgrades. For HTTP/1-only upgrades, use a custom serve loop.

The configuration callback runs once when this method is called. The configured builder is shared across connections.

Example

use std::time::Duration;

serve(listener, service)
    .configure_hyper(|mut builder| {
        builder.http1().keep_alive(true);
        builder.http2().max_concurrent_streams(200);
        builder
    })
    .await?;

Advanced: Per-Connection Configuration

If you need per-connection customization (e.g., different settings based on the remote address), you can implement your own connection loop. See the module-level documentation for examples.

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

Set the maximum number of concurrently accepted connections.

The default limit is 16,384. Once the limit is reached, serve stops accepting connections until an existing connection closes.

Passing 0 disables the limit, equivalent to disable_connection_limit. Values above [tokio::sync::Semaphore::MAX_PERMITS] are clamped to that value.

pub fn disable_connection_limit(self) -> Self

Disable the default accepted-connection limit.

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

Set the timeout for receiving a complete request head.

The default is one minute. The first-request deadline starts when the connection task begins driving Hyper, after make_service finishes. It includes protocol negotiation and header parsing and does not reset as bytes arrive. It ends before Tower readiness, middleware, or body reads.

The same setting configures Hyper’s HTTP/1 header-read timeout for later requests. Per-request header-read timeout protection is currently supported only for HTTP/1. HTTP/2 is covered only until the first request head arrives; later HTTP/2 streams have no header-read deadline. This deadline does not limit body reads or time spent waiting for server events. This setting takes precedence over the HTTP/1 header-read timeout supplied through Self::configure_hyper. Pass None or Some(Duration::ZERO) to disable both deadlines.

pub fn with_graceful_shutdown<F>( self, signal: F, ) -> ServeWithGracefulShutdown<L, M, S, F, B>

where F: Future<Output = ()> + Send + 'static,

Enable graceful shutdown for the server.

pub fn local_addr(&self) -> Result<L::Addr>

Returns the local address this server is bound to.

Trait Implementations

impl<L, M, S, B> Debug for Serve<L, M, S, B>

where L: Debug,

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

Formats the value using the given formatter.

impl<L, M, S, B> IntoFuture for Serve<L, M, S, B>

where L: Listener, L::Addr: Debug, B: HttpBody + Send + 'static, B::Data: Send, B::Error: Into<Box<dyn StdError + Send + Sync>>, S: Service<Request<Incoming>, Response = Response<B>, Error = Infallible> + Clone + Send + 'static, S::Future: Send, M: for<'a> Service<IncomingStream<'a, L>, Error = Infallible, Response = S> + Send + 'static, for<'a> <M as Service<IncomingStream<'a, L>>>::Future: Send,

type Output = Result<(), Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.