本站的服务端路径

  dioxus::serve(|| async move {
    use axum::routing::get;
    // ...
    let router = dioxus::server::router(App)
      // S3：健康检查（ok/degraded），供 LB / 监控 / 部署脚本判活。
      .route("/healthz", get(crate::server::health::healthz));
    // ...
    Ok(router)
  });

pub async fn serve_router(
    mut serve_callback: impl FnMut() -> Pin<Box<dyn Future<Output = Result<Router, anyhow::Error>>>>,
    addr: SocketAddr,
) {
    dioxus_logger::initialize_default();

    let listener = TcpListener::bind(addr)
        .await
        .with_context(|| format!("Failed to bind to address {addr}"))
        .unwrap();

    // If we're not in debug mode, just serve the app normally
    if !cfg!(debug_assertions) {
        axum::serve(listener, serve_callback().await.unwrap())
            .await
            .unwrap();
        return;
    }
    // ...

                    // upgrades needed for websockets
                    let builder = HyperBuilder::new(TokioExecutor::new());
                    let connection = builder.serve_connection_with_upgrades(
                        tcp_stream,
                        TowerToHyperService::new(
                            make_service
                                .call(())
                                .await
                                .unwrap()
                                .map_request(|req: Request<Incoming>| req.map(Body::new)),
                        ),
                    );

                    tokio::select! {
                        res = connection => {
                            // ...
                        }
                        _res = shutdown_rx.recv() => {}
                    }

    let hyper_service = TowerToHyperService::new(tower_service);
    let signal_tx = signal_tx.clone();
    let close_rx = close_rx.clone();

    tokio::spawn(async move {
        #[allow(unused_mut)]
        let mut builder = Builder::new(TokioExecutor::new());
        // CONNECT protocol needed for HTTP/2 websockets
        #[cfg(feature = "http2")]
        builder.http2().enable_connect_protocol();

        let mut conn = pin!(builder.serve_connection_with_upgrades(io, hyper_service));
        let mut signal_closed = pin!(signal_tx.closed().fuse());

        loop {
            tokio::select! {
                result = conn.as_mut() => {
                    if let Err(_err) = result {
                        trace!("failed to serve connection: {_err:#}");
                    }
                    break;
                }
                _ = &mut signal_closed => {
                    trace!("signal received in task, starting graceful shutdown");
                    conn.as_mut().graceful_shutdown();
                }
            }
        }

        drop(close_rx);
    });

axum = "=0.8.9"
hyper = { version = "=1.12.0", features = ["client", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio", "server-auto", "service"] }
http = "1"
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "time", "io-util"] }

use std::time::{Duration, Instant};

use axum::{Router, routing::get};
use hyper::body::Incoming;
use hyper_util::{
  rt::{TokioExecutor, TokioIo, TokioTimer},
  server::conn::auto::Builder,
  service::TowerToHyperService,
};
use tokio::{
  io::{AsyncReadExt, AsyncWriteExt},
  net::{TcpListener, TcpStream},
};
use tower::ServiceExt;

fn app() -> Router {
  Router::new().route("/", get(|| async { "ok" }))
}

// 本站 release 路径：axum::serve，内部 auto::Builder::new(TokioExecutor::new())，不设 timer
async fn axum_serve() -> u16 {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let port = listener.local_addr().unwrap().port();
  tokio::spawn(async move { axum::serve(listener, app()).await.unwrap() });
  port
}

// 对照：同样的 auto::Builder，只多一句 http1().timer(TokioTimer::new())
async fn auto_with_timer() -> u16 {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let port = listener.local_addr().unwrap().port();
  tokio::spawn(async move {
    loop {
      let (stream, _) = listener.accept().await.unwrap();
      tokio::spawn(async move {
        let mut builder = Builder::new(TokioExecutor::new());
        builder.http1().timer(TokioTimer::new());
        let svc = app().map_request(|req: http::Request<Incoming>| req.map(axum::body::Body::new));
        let _ = builder
          .serve_connection_with_upgrades(TokioIo::new(stream), TowerToHyperService::new(svc))
          .await;
      });
    }
  });
  port
}

async fn client(server: &'static str, port: u16, case: &'static str, first: &'static [u8]) {
  let t0 = Instant::now();
  let mut s = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
  s.write_all(first).await.unwrap();
  tokio::time::sleep(Duration::from_secs(35)).await;
  let rest: &[u8] = if first.is_empty() { b"GET / HTTP/1.1\r\nhost: x\r\n\r\n" } else { b"host: x\r\n\r\n" };
  let _ = s.write_all(rest).await;
  let mut buf = [0u8; 256];
  let got = match tokio::time::timeout(Duration::from_secs(2), s.read(&mut buf)).await {
    Ok(Ok(0)) => "EOF (server closed)".to_string(),
    Ok(Ok(n)) => String::from_utf8_lossy(&buf[..n]).lines().next().unwrap_or("").to_string(),
    Ok(Err(e)) => format!("error: {e}"),
    Err(_) => "no reply in 2s".to_string(),
  };
  println!("{server:<16} {case:<13} after {}s: {got}", t0.elapsed().as_secs());
}

#[tokio::main]
async fn main() {
  let a = axum_serve().await;
  let b = auto_with_timer().await;
  let partial: &[u8] = b"GET / HTTP/1.1\r\n";
  tokio::join!(
    client("axum::serve", a, "nothing sent", b""),
    client("axum::serve", a, "partial head", partial),
    client("auto + timer", b, "nothing sent", b""),
    client("auto + timer", b, "partial head", partial),
  );
}

auto + timer     partial head  after 35s: EOF (server closed)
axum::serve      nothing sent  after 35s: HTTP/1.1 200 OK
axum::serve      partial head  after 35s: HTTP/1.1 200 OK
auto + timer     nothing sent  after 35s: HTTP/1.1 200 OK

# tini 处理信号；server 自身就是入口可执行文件
ENTRYPOINT ["/usr/bin/tini", "--"]
CMD ["/app/server"]

axum = "=0.8.9"
hyper = { version = "=1.12.0", features = ["client", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio"] }
http-body-util = "0.1"
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "time", "signal", "sync"] }

use std::{
  sync::{Arc, OnceLock},
  time::{Duration, Instant},
};

use axum::{Router, routing::get};
use tokio::{
  net::TcpListener,
  signal::unix::{SignalKind, signal},
  sync::Notify,
};

#[tokio::main]
async fn main() {
  let mode = std::env::args().nth(1).unwrap_or_default();
  let app = Router::new().route(
    "/slow",
    get(|| async {
      tokio::time::sleep(Duration::from_secs(2)).await;
      "done"
    }),
  );
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  println!("{}", listener.local_addr().unwrap().port());

  if mode == "plain" {
    // 和 dioxus-server release 路径一样：axum::serve(listener, router)
    axum::serve(listener, app).await.unwrap();
    return;
  }

  // 修法的形状：收到 SIGTERM 才让 axum 开始优雅停机，另给排空设一个期限
  let drain_limit = if mode == "deadline" { Duration::from_secs(1) } else { Duration::from_secs(8) };
  let mut term = signal(SignalKind::terminate()).unwrap();
  let got_term = Arc::new(OnceLock::new());
  let started = Arc::new(Notify::new());
  let (mark, notify) = (got_term.clone(), started.clone());
  let server = axum::serve(listener, app).with_graceful_shutdown(async move {
    term.recv().await;
    mark.set(Instant::now()).unwrap();
    notify.notify_one();
    eprintln!("        server: SIGTERM received, draining");
  });
  tokio::select! {
    res = server => {
      res.unwrap();
      let waited = got_term.get().unwrap().elapsed().as_millis();
      eprintln!("        server: drained {waited}ms after SIGTERM, exiting");
    }
    _ = async { started.notified().await; tokio::time::sleep(drain_limit).await } => {
      eprintln!("        server: drain limit {drain_limit:?} hit, exiting anyway");
    }
  }
}

use std::{
  io::{BufRead, BufReader},
  os::unix::process::ExitStatusExt,
  process::{Command, Stdio},
  time::{Duration, Instant},
};

use http_body_util::{BodyExt, Empty};
use hyper::{Request, body::Bytes, client::conn::http1};
use hyper_util::rt::TokioIo;
use tokio::net::TcpStream;

async fn run(mode: &str) {
  println!("--- {mode}");
  let exe = std::env::current_exe().unwrap().with_file_name("sigterm_server");
  let mut child = Command::new(exe).arg(mode).stdout(Stdio::piped()).spawn().unwrap();
  let mut line = String::new();
  BufReader::new(child.stdout.take().unwrap()).read_line(&mut line).unwrap();
  let port: u16 = line.trim().parse().unwrap();
  let pid = child.id();

  let t0 = Instant::now();
  let stream = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
  let (mut sender, conn) = http1::handshake(TokioIo::new(stream)).await.unwrap();
  tokio::spawn(conn);
  let req = Request::get("/slow").header("host", "x").body(Empty::<Bytes>::new()).unwrap();
  let resp = tokio::spawn(async move { sender.send_request(req).await });

  tokio::time::sleep(Duration::from_millis(500)).await;
  println!("{:>5}ms client: kill -TERM <server pid>", t0.elapsed().as_millis());
  Command::new("kill").args(["-TERM", &pid.to_string()]).status().unwrap();

  match resp.await.unwrap() {
    Ok(res) => {
      let status = res.status();
      let body = res.into_body().collect().await.unwrap().to_bytes();
      println!("{:>5}ms client: {status} {body:?}", t0.elapsed().as_millis());
    }
    Err(e) => println!(
      "{:>5}ms client: error: {e} (is_incomplete_message={})",
      t0.elapsed().as_millis(),
      e.is_incomplete_message()
    ),
  }
  let status = child.wait().unwrap();
  println!(
    "{:>5}ms server process: code={:?} signal={:?}",
    t0.elapsed().as_millis(),
    status.code(),
    status.signal()
  );
}

#[tokio::main]
async fn main() {
  run("plain").await;
  run("graceful").await;
  run("deadline").await;
}

--- plain
  503ms client: kill -TERM <server pid>
  507ms client: error: connection closed before message completed (is_incomplete_message=true)
  507ms server process: code=None signal=Some(15)
--- graceful
  502ms client: kill -TERM <server pid>
        server: SIGTERM received, draining
        server: drained 1493ms after SIGTERM, exiting
 2002ms client: 200 OK b"done"
 2004ms server process: code=Some(0) signal=None
--- deadline
  503ms client: kill -TERM <server pid>
        server: SIGTERM received, draining
        server: drain limit 1s hit, exiting anyway
 1509ms client: error: connection closed before message completed (is_incomplete_message=true)
 1510ms server process: code=Some(0) signal=None