axum-server

The Handle object allows you to control the server's lifecycle from outside the serve() loop. You can attach a handle to your server using .handle(handle) before calling .serve().

Key capabilities:

• Graceful Shutdown: Call handle.graceful_shutdown(Some(Duration)) to stop accepting new connections and wait for existing requests to finish within a specified timeout. If None is provided, it waits indefinitely.
• Immediate Shutdown: Call handle.shutdown() to stop the server immediately.
• Listening Status: Use handle.listening().await to wait until the server has successfully bound to the address and is ready to accept connections.

use axum_server::{bind, Handle};
use axum::{routing::get, Router};
use std::time::Duration;

let handle = Handle::new();
let app = Router::new().route("/", get(|| async { "Hello" }));
let addr = "127.0.0.1:3000".parse().unwrap();

// Spawn the server in a background task
let server_task = tokio::spawn(async move {
    bind(addr)
        .handle(handle.clone())
        .serve(app.into_make_service())
        .await
});

// Wait until the server is actually listening
let listening_addr = handle.listening().await.unwrap();
println!("Listening on {}", listening_addr);

// Perform graceful shutdown after some time
tokio::time::sleep(Duration::from_secs(5)).await;
handle.graceful_shutdown(Some(Duration::from_secs(10)));

server_task.await.unwrap().unwrap();

The OpenSSLConfig struct manages the TLS acceptor and supports hot-reloading of certificates without restarting the server. You can initialize it from various formats:

• PEM files: from_pem_file(cert, key) or from_pem_chain_file(chain, key)
• PEM bytes: from_pem(cert, key)
• DER bytes: from_der(cert, key)
• Existing Acceptor: from_acceptor(Arc<SslAcceptor>)
• Builder: try_from(SslAcceptorBuilder) for fine-grained control over OpenSSL settings.

All configuration methods use strong cipher suites (Mozilla modern v5) and support ALPN for HTTP/2 and HTTP/1.1.

// Example: Creating config from PEM files
let config = OpenSSLConfig::from_pem_file("cert.pem", "key.pem").unwrap();

// Example: Creating config from an OpenSSL SslAcceptorBuilder for custom settings
use openssl::ssl::{SslAcceptorBuilder, SslMethod};
use std::convert::TryFrom;

let mut tls_builder = SslAcceptorBuilder::mozilla_modern_v5(SslMethod::tls()).unwrap();
// ... customize tls_builder ...
let config = OpenSSLConfig::try_from(tls_builder).unwrap();

The Accept<I, S> trait allows you to intercept and modify the IO stream and the service produced during the connection acceptance phase. This is useful for applying configurations (like socket options) or wrapping the service before it is handed off to the server.

To implement it, you must define:

• Stream: The type of the IO stream (e.g., TcpStream).
• Service: The type of the service produced.
• Future: An asynchronous operation that returns io::Result<(Self::Stream, Self::Service)>.

use axum_server::Accept;
use std::io;
use tokio::net::TcpStream;

struct MyCustomAcceptor;

impl<S> Accept<TcpStream, S> for MyCustomAcceptor {
    type Stream = TcpStream;
    type Service = S;
    type Future = std::future::Ready<io::Result<(Self::Stream, Self::Service)>>;

    fn accept(&self, stream: TcpStream, service: S) -> Self::Future {
        // Perform custom logic here, e.g., setting socket options
        std::future::ready(Ok((stream, service)))
    }
}