Struct ServeWithGracefulShutdown 

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

A server future with graceful shutdown enabled.

This type is created by calling Serve::with_graceful_shutdown. It implements IntoFuture, so you can directly .await it.

When the shutdown signal completes, the server will:

1. Stop accepting new connections
2. Wait for all in-flight requests to complete (or until timeout if configured)
3. Return once all connections are closed

Configure the shutdown timeout with with_shutdown_timeout.

Created by Serve::with_graceful_shutdown.

Implementations

impl<L: Listener, M, S, F, B> ServeWithGracefulShutdown<L, M, S, F, B>

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

Set a timeout for graceful shutdown.

If the timeout expires before all connections complete, a warning is logged and the server returns successfully. Note that this does not forcibly terminate connections - it only stops waiting for them.

Example

use std::time::Duration;

serve(listener, app.into_make_service())
    .with_graceful_shutdown(shutdown_signal())
    .with_shutdown_timeout(Duration::from_secs(30))
    .await?;  // Returns Ok(()) even if timeout expires

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. Pass None or Some(Duration::ZERO) to disable it. See Serve::header_read_timeout for details.

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

Returns the local address this server is bound to.

Trait Implementations

impl<L, M, S, F, B> Debug for ServeWithGracefulShutdown<L, M, S, F, B>

where L: Listener + Debug,

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

Formats the value using the given formatter.

impl<L, M, S, F, B> IntoFuture for ServeWithGracefulShutdown<L, M, S, F, 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, F: Future<Output = ()> + Send + 'static,

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.