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 connection builder
• 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.

The configuration is applied once and the configured builder is cloned for each connection, providing optimal performance.

Example

use std::time::Duration;

serve(listener, service)
    .configure_hyper(|builder| {
        builder
            .http1()
            .keep_alive(true)
            .http2()
            .max_concurrent_streams(200)
    })
    .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 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.