You must supply a timer. 与 timeout header_read_timeout set, but no timer set

hyper = { version = "=1.12.0", features = ["client", "server", "http1", "http2"] }
hyper-util = { version = "=0.1.21", features = ["client-legacy", "server-auto", "http1", "http2", "tokio"] }
http-body-util = "=0.1.5"
bytes = "1"
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "time", "sync"] }

use std::convert::Infallible;
use std::sync::Mutex;
use std::time::Duration;

use bytes::Bytes;
use http_body_util::{Empty, Full};
use hyper::client::conn::{http1 as client_h1, http2 as client_h2};
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::client::legacy::Client;
use hyper_util::rt::{TokioExecutor, TokioIo, TokioTimer};
use hyper_util::server::conn::auto;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::mpsc;

static PANIC_MSG: Mutex<Option<String>> = Mutex::new(None);

async fn hello(_: Request<hyper::body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
  Ok(Response::new(Full::new(Bytes::from_static(b"ok"))))
}

fn panic_text() -> String {
  PANIC_MSG.lock().unwrap().take().unwrap_or_default()
}

// An accept loop like axum::serve's: one task per connection; report how each task ended.
async fn spawn_server(make: fn() -> auto::Builder<TokioExecutor>) -> (std::net::SocketAddr, mpsc::UnboundedReceiver<String>) {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  let (tx, rx) = mpsc::unbounded_channel();
  tokio::spawn(async move {
    loop {
      let (stream, _) = listener.accept().await.unwrap();
      let task = tokio::spawn(async move {
        make().serve_connection(TokioIo::new(stream), service_fn(hello)).await.map_err(|e| e.to_string())
      });
      let tx = tx.clone();
      tokio::spawn(async move {
        let s = match task.await {
          Ok(Ok(())) => "Ok(())".to_string(),
          Ok(Err(e)) => format!("Err({e})"),
          Err(e) if e.is_panic() => format!("panic: {}", panic_text()),
          Err(e) => format!("{e}"),
        };
        let _ = tx.send(s);
      });
    }
  });
  (addr, rx)
}

async fn h1_get(addr: std::net::SocketAddr) -> String {
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  let (mut tx, conn) = match client_h1::handshake::<_, Empty<Bytes>>(io).await {
    Ok(p) => p,
    Err(e) => return format!("Err({e})"),
  };
  tokio::spawn(conn);
  match tx.send_request(Request::get("/").header("host", "x").body(Empty::new()).unwrap()).await {
    Ok(r) => format!("{}", r.status()),
    Err(e) => format!("Err({e})"),
  }
}

async fn h2_get(addr: std::net::SocketAddr) -> String {
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  let (mut tx, conn) = match client_h2::handshake::<_, _, Empty<Bytes>>(TokioExecutor::new(), io).await {
    Ok(p) => p,
    Err(e) => return format!("Err({e})"),
  };
  tokio::spawn(conn);
  match tx.send_request(Request::get("http://x/").body(Empty::new()).unwrap()).await {
    Ok(r) => format!("{}", r.status()),
    Err(e) => format!("Err({e})"),
  }
}

async fn server_case(name: &str, make: fn() -> auto::Builder<TokioExecutor>) {
  println!("{name}");
  let (addr, mut rx) = spawn_server(make).await;
  for (proto, client) in [("h1", h1_get(addr).await), ("h2", h2_get(addr).await)] {
    let server = tokio::time::timeout(Duration::from_millis(500), rx.recv()).await;
    let server = match server {
      Ok(Some(s)) => s,
      _ => "(still running)".to_string(),
    };
    println!("  {proto} client: {client:<24} server conn: {server}");
  }
}

#[tokio::main]
async fn main() {
  std::panic::set_hook(Box::new(|info| {
    let loc = info.location().map(|l| {
      let file = l.file();
      let short = file.find("hyper-1.12.0/").map_or(file, |i| &file[i..]);
      format!("{short}:{}", l.line())
    });
    let msg = info
      .payload()
      .downcast_ref::<String>()
      .cloned()
      .or_else(|| info.payload().downcast_ref::<&str>().map(|s| s.to_string()))
      .unwrap_or_default();
    *PANIC_MSG.lock().unwrap() = Some(format!("{msg} at {}", loc.unwrap_or_default()));
  }));

  server_case("A http2().keep_alive_interval, no timer", || {
    let mut b = auto::Builder::new(TokioExecutor::new());
    b.http2().keep_alive_interval(Duration::from_secs(10));
    b
  })
  .await;
  server_case("B timer on http1() only, http2().keep_alive_interval", || {
    let mut b = auto::Builder::new(TokioExecutor::new());
    b.http1().timer(TokioTimer::new());
    b.http2().keep_alive_interval(Duration::from_secs(10));
    b
  })
  .await;
  server_case("C http1().header_read_timeout, no timer", || {
    let mut b = auto::Builder::new(TokioExecutor::new());
    b.http1().header_read_timeout(Duration::from_secs(5));
    b
  })
  .await;
  server_case("D both, timer on both halves", || {
    let mut b = auto::Builder::new(TokioExecutor::new());
    b.http1().timer(TokioTimer::new()).header_read_timeout(Duration::from_secs(5));
    b.http2().timer(TokioTimer::new()).keep_alive_interval(Duration::from_secs(10));
    b
  })
  .await;

  // legacy Client: HTTP/2 keep-alive without a timer
  println!("E legacy Client, http2_keep_alive_interval, no timer");
  let (addr, _rx) = spawn_server(|| auto::Builder::new(TokioExecutor::new())).await;
  let client = Client::builder(TokioExecutor::new())
    .http2_only(true)
    .http2_keep_alive_interval(Duration::from_secs(10))
    .build_http::<Empty<Bytes>>();
  let url: hyper::Uri = format!("http://{addr}/").parse().unwrap();
  let r = tokio::spawn(async move { client.get(url).await.map(|r| r.status()) }).await;
  match r {
    Ok(Ok(s)) => println!("  request: {s}"),
    Ok(Err(e)) => println!("  request: Err({e:?})"),
    Err(e) if e.is_panic() => println!("  request task: panic: {}", panic_text()),
    Err(e) => println!("  request task: {e}"),
  }
}

A http2().keep_alive_interval, no timer
  h1 client: 200 OK                   server conn: Ok(())
  h2 client: Err(connection error)    server conn: panic: You must supply a timer. at hyper-1.12.0/src/common/time.rs:38
B timer on http1() only, http2().keep_alive_interval
  h1 client: 200 OK                   server conn: Ok(())
  h2 client: Err(connection error)    server conn: panic: You must supply a timer. at hyper-1.12.0/src/common/time.rs:38
C http1().header_read_timeout, no timer
  h1 client: Err(connection error)    server conn: panic: timeout `header_read_timeout` set, but no timer set at hyper-1.12.0/src/common/time.rs:84
  h2 client: 200 OK                   server conn: Ok(())
D both, timer on both halves
  h1 client: 200 OK                   server conn: Ok(())
  h2 client: 200 OK                   server conn: Ok(())
E legacy Client, http2_keep_alive_interval, no timer
  request task: panic: You must supply a timer. at hyper-1.12.0/src/common/time.rs:38

let mut builder = auto::Builder::new(TokioExecutor::new());
builder.http1().timer(TokioTimer::new());
builder.http2().timer(TokioTimer::new());