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 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.