hyper::Error

pub struct Error {
    inner: Box<ErrorImpl>,
}

struct ErrorImpl {
    kind: Kind,
    cause: Option<Cause>,
}

#[derive(Debug)]
pub(super) enum Kind {
    Parse(Parse),
    User(User),
    /// A message reached EOF, but is not complete.
    #[cfg(all(any(feature = "client", feature = "server"), feature = "http1"))]
    IncompleteMessage,
    /// A connection received a message (or bytes) when not waiting for one.
    #[cfg(all(any(feature = "client", feature = "server"), feature = "http1"))]
    UnexpectedMessage,
    /// A pending item was dropped before ever being processed.
    Canceled,
    /// Indicates a channel (client or body sender) is closed.
    #[cfg(any(
        all(feature = "http1", any(feature = "client", feature = "server")),
        all(feature = "http2", feature = "client")
    ))]
    ChannelClosed,
    /// An `io::Error` that occurred while trying to read or write to a network stream.
    #[cfg(all(
        any(feature = "client", feature = "server"),
        any(feature = "http1", feature = "http2")
    ))]
    Io,
    /// User took too long to send headers.
    #[cfg(all(feature = "http1", feature = "server"))]
    HeaderTimeout,
    /// Error while reading a body from connection.
    #[cfg(all(
        any(feature = "client", feature = "server"),
        any(feature = "http1", feature = "http2")
    ))]
    Body,
    /// Error while writing a body to connection.
    #[cfg(all(
        any(feature = "client", feature = "server"),
        any(feature = "http1", feature = "http2")
    ))]
    BodyWrite,
    /// Error calling `AsyncWrite::shutdown()`.
    #[cfg(all(any(feature = "client", feature = "server"), feature = "http1"))]
    Shutdown,

    /// A general error from h2.
    #[cfg(all(any(feature = "client", feature = "server"), feature = "http2"))]
    Http2,
}

    pub fn is_timeout(&self) -> bool {
        #[cfg(all(feature = "http1", feature = "server"))]
        if matches!(self.inner.kind, Kind::HeaderTimeout) {
            return true;
        }
        self.find_source::<TimedOut>().is_some()
    }

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.description())
    }
}

impl StdError for Error {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        self.inner
            .cause
            .as_ref()
            .map(|cause| &**cause as &(dyn StdError + 'static))
    }
}

use std::convert::Infallible;

use bytes::Bytes;
use http_body_util::Empty;
use hyper::body::Incoming;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::rt::TokioIo;
use tokio::io::AsyncWriteExt;
use tokio::net::{TcpListener, TcpStream};

async fn handle(_: Request<Incoming>) -> Result<Response<Empty<Bytes>>, Infallible> {
  Ok(Response::new(Empty::new()))
}

#[tokio::main]
async fn main() {
  for bytes in [&b"G@T / HTTP/1.1\r\n\r\n"[..], &b"GET / HTTP/1.1\r\n"[..]] {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    tokio::spawn(async move {
      let mut tcp = TcpStream::connect(addr).await.unwrap();
      tcp.write_all(bytes).await.unwrap();
      tcp.shutdown().await.unwrap();
      tokio::time::sleep(std::time::Duration::from_millis(100)).await;
    });
    let (stream, _) = listener.accept().await.unwrap();
    let e = http1::Builder::new().serve_connection(TokioIo::new(stream), service_fn(handle)).await.unwrap_err();
    println!("Display: {e}");
    println!("Debug:   {e:?}");
    println!("size_of::<hyper::Error>() = {}", std::mem::size_of::<hyper::Error>());
  }
}

Display: invalid HTTP method parsed
Debug:   hyper::Error(Parse(Method))
size_of::<hyper::Error>() = 8
Display: connection closed before message completed
Debug:   hyper::Error(IncompleteMessage)
size_of::<hyper::Error>() = 8

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

use std::error::Error as StdError;
use std::future::Future;
use std::io;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;

use bytes::Bytes;
use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full, StreamBody};
use hyper::body::{Body, Frame, Incoming, SizeHint};
use hyper::client::conn::http1 as client_h1;
use hyper::rt::{Read, ReadBufCursor, Write};
use hyper::server::conn::{http1, http2};
use hyper::service::service_fn;
use hyper::{Request, Response, StatusCode};
use hyper_util::client::legacy::Client;
use hyper_util::rt::{TokioExecutor, TokioIo, TokioTimer};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

type BoxError = Box<dyn StdError + Send + Sync>;
type B = BoxBody<Bytes, BoxError>;

// ---------- printing ----------

fn chain(e: &(dyn StdError + 'static)) -> String {
  let mut s = String::new();
  let mut src = e.source();
  while let Some(inner) = src {
    s.push_str(&format!(" -> {inner}"));
    src = inner.source();
  }
  s
}

fn report(label: &str, e: &hyper::Error) {
  let checks: [(&str, bool); 11] = [
    ("parse", e.is_parse()),
    ("parse_too_large", e.is_parse_too_large()),
    ("parse_status", e.is_parse_status()),
    ("parse_version_h2", e.is_parse_version_h2()),
    ("user", e.is_user()),
    ("canceled", e.is_canceled()),
    ("closed", e.is_closed()),
    ("incomplete_message", e.is_incomplete_message()),
    ("body_write_aborted", e.is_body_write_aborted()),
    ("shutdown", e.is_shutdown()),
    ("timeout", e.is_timeout()),
  ];
  let yes: Vec<&str> = checks.iter().filter(|(_, b)| *b).map(|(n, _)| *n).collect();
  println!("{label:<24} {e}{}", chain(e));
  println!("{:<24} is_*: {}", "", if yes.is_empty() { "(none)".to_string() } else { yes.join(", ") });
}

// ---------- an IO wrapper that fails flush or shutdown on demand ----------

struct Faulty {
  inner: TokioIo<TcpStream>,
  fail_flush: bool,
  fail_shutdown: bool,
}

impl Read for Faulty {
  fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: ReadBufCursor<'_>) -> Poll<io::Result<()>> {
    Pin::new(&mut self.inner).poll_read(cx, buf)
  }
}

impl Write for Faulty {
  fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
    Pin::new(&mut self.inner).poll_write(cx, buf)
  }
  fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
    if self.fail_flush {
      return Poll::Ready(Err(io::Error::other("injected flush error")));
    }
    Pin::new(&mut self.inner).poll_flush(cx)
  }
  fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
    if self.fail_shutdown {
      return Poll::Ready(Err(io::Error::other("injected shutdown error")));
    }
    Pin::new(&mut self.inner).poll_shutdown(cx)
  }
}

// ---------- the server's service ----------

// Claims 5 bytes, delivers 3.
struct Short(bool);

impl Body for Short {
  type Data = Bytes;
  type Error = BoxError;
  fn poll_frame(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Result<Frame<Bytes>, BoxError>>> {
    if self.0 {
      return Poll::Ready(None);
    }
    self.0 = true;
    Poll::Ready(Some(Ok(Frame::data(Bytes::from_static(b"abc")))))
  }
  fn size_hint(&self) -> SizeHint {
    SizeHint::with_exact(5)
  }
}

fn full(s: &'static str) -> B {
  Full::new(Bytes::from(s)).map_err(|e| match e {}).boxed()
}

async fn handle(mut req: Request<Incoming>) -> Result<Response<B>, BoxError> {
  let res = match req.uri().path() {
    "/svc-err" => return Err("boom".into()),
    "/body-err" => {
      let frames: Vec<Result<Frame<Bytes>, BoxError>> = vec![Ok(Frame::data(Bytes::from("a"))), Err("bad chunk".into())];
      Response::new(StreamBody::new(futures::stream::iter(frames)).boxed())
    }
    "/short" => Response::new(Short(false).boxed()),
    "/103" => Response::builder().status(StatusCode::EARLY_HINTS).body(full("")).unwrap(),
    "/two-cl" => {
      // a body of unknown length, so hyper has to trust the headers
      let frames: Vec<Result<Frame<Bytes>, BoxError>> = vec![Ok(Frame::data(Bytes::from("abc")))];
      let mut res = Response::new(StreamBody::new(futures::stream::iter(frames)).boxed());
      res.headers_mut().append("content-length", "3".parse().unwrap());
      res.headers_mut().append("content-length", "4".parse().unwrap());
      res
    }
    "/no-upgrade" => {
      if let Err(e) = hyper::upgrade::on(&mut req).await {
        report("  upgrade::on", &e);
      }
      Response::new(full("ok"))
    }
    "/upgrade" => {
      let on = hyper::upgrade::on(&mut req);
      tokio::spawn(async move {
        if let Err(e) = on.await {
          report("  upgrade::on", &e);
        }
      });
      Response::builder()
        .status(StatusCode::SWITCHING_PROTOCOLS)
        .header("connection", "upgrade")
        .header("upgrade", "foo")
        .body(full(""))
        .unwrap()
    }
    "/read-body" => {
      if let Err(e) = req.into_body().collect().await {
        report("  request body", &e);
      }
      Response::new(full("ok"))
    }
    _ => Response::new(full("ok")),
  };
  Ok(res)
}

// ---------- harnesses ----------

#[derive(Clone, Copy)]
enum Then {
  ReadToEnd,     // write the bytes, read until the server closes
  ShutdownWrite, // write the bytes, close our write half, read until close
  Reset,         // write the bytes, then RST the connection
}

#[derive(Clone, Copy, Default)]
struct Opts {
  header_timeout: bool,
  fail_flush: bool,
  fail_shutdown: bool,
}

async fn server_case(label: &str, bytes: &'static [u8], then: Then, opts: Opts) {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  let client = tokio::spawn(async move {
    let mut tcp = TcpStream::connect(addr).await.unwrap();
    let _ = tcp.write_all(bytes).await;
    match then {
      Then::ReadToEnd => {}
      Then::ShutdownWrite => {
        let _ = tcp.shutdown().await;
      }
      Then::Reset => {
        tokio::time::sleep(Duration::from_millis(50)).await;
        #[allow(deprecated)]
        tcp.set_linger(Some(Duration::ZERO)).unwrap();
        drop(tcp);
        return String::from("(reset by client)");
      }
    }
    let mut got = Vec::new();
    let _ = tcp.read_to_end(&mut got).await;
    match String::from_utf8_lossy(&got).lines().next() {
      Some(line) => line.to_string(),
      None => String::from("(nothing)"),
    }
  });
  let (stream, _) = listener.accept().await.unwrap();
  let io = Faulty { inner: TokioIo::new(stream), fail_flush: opts.fail_flush, fail_shutdown: opts.fail_shutdown };
  let mut b = http1::Builder::new();
  if opts.header_timeout {
    b.timer(TokioTimer::new()).header_read_timeout(Duration::from_millis(100));
  }
  match tokio::time::timeout(Duration::from_secs(2), b.serve_connection(io, service_fn(handle))).await {
    Ok(Ok(())) => println!("{label:<24} Ok(())"),
    Ok(Err(e)) => report(label, &e),
    Err(_) => println!("{label:<24} still running after 2 s"),
  }
  if let Ok(Ok(line)) = tokio::time::timeout(Duration::from_millis(500), client).await {
    println!("{:<24} wire: {line}", "");
  }
}

// A raw server that runs `script` on the accepted socket; returns its address.
async fn raw_server<F, Fut>(script: F) -> std::net::SocketAddr
where
  F: FnOnce(TcpStream) -> Fut + Send + 'static,
  Fut: Future<Output = ()> + Send,
{
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(async move {
    let (stream, _) = listener.accept().await.unwrap();
    script(stream).await;
  });
  addr
}

async fn read_head(tcp: &mut TcpStream) {
  let mut buf = vec![0u8; 4096];
  let mut got = Vec::new();
  while !got.windows(4).any(|w| w == b"\r\n\r\n") {
    let n = tcp.read(&mut buf).await.unwrap();
    if n == 0 {
      return;
    }
    got.extend_from_slice(&buf[..n]);
  }
}

async fn h1_client(addr: std::net::SocketAddr) -> (client_h1::SendRequest<Empty<Bytes>>, client_h1::Connection<TokioIo<TcpStream>, Empty<Bytes>>) {
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  client_h1::handshake(io).await.unwrap()
}

fn get(path: &str) -> Request<Empty<Bytes>> {
  Request::get(path).body(Empty::new()).unwrap()
}

#[tokio::main]
async fn main() {
  let d = Opts::default();
  println!("--- server side: hyper::server::conn::http1, raw TCP client");
  server_case("bad method", b"G@T / HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("bad uri", b"GET /a\x7fb HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("bad version", b"GET / HTTP/1.2\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("h2 preface", b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("bad header", b"GET / HTTP/1.1\r\nbad header: x\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("content-length abc", b"POST / HTTP/1.1\r\ncontent-length: abc\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("te: gzip", b"POST / HTTP/1.1\r\ntransfer-encoding: gzip\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("te on HTTP/1.0", b"POST / HTTP/1.0\r\ntransfer-encoding: chunked\r\n\r\n", Then::ReadToEnd, d).await;
  let many: &'static str = Box::leak(
    format!("GET / HTTP/1.1\r\n{}\r\n", (0..101).map(|i| format!("x-h{i}: v\r\n")).collect::<String>()).into_boxed_str(),
  );
  server_case("101 headers", many.as_bytes(), Then::ReadToEnd, d).await;
  let long: &'static str = Box::leak(format!("GET /{} HTTP/1.1\r\n\r\n", "a".repeat(65534)).into_boxed_str());
  server_case("uri 65535 bytes", long.as_bytes(), Then::ReadToEnd, d).await;
  let to = Opts { header_timeout: true, ..d };
  server_case("slow head", b"GET / HTTP/1.1\r\n", Then::ReadToEnd, to).await;
  server_case("EOF mid head", b"GET / HTTP/1.1\r\n", Then::ShutdownWrite, d).await;
  server_case("RST mid head", b"GET / HTTP/1.1\r\n", Then::Reset, d).await;
  server_case("EOF mid body", b"POST /read-body HTTP/1.1\r\ncontent-length: 10\r\n\r\nabc", Then::ShutdownWrite, d).await;
  server_case("RST mid body", b"POST /read-body HTTP/1.1\r\ncontent-length: 10\r\n\r\nabc", Then::Reset, d).await;
  server_case("service Err", b"GET /svc-err HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("body Err", b"GET /body-err HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("body too short", b"GET /short HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("status 103", b"GET /103 HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("two content-lengths", b"GET /two-cl HTTP/1.1\r\n\r\n", Then::ReadToEnd, d).await;
  server_case("upgrade::on, no upgrade", b"GET /no-upgrade HTTP/1.1\r\nconnection: close\r\n\r\n", Then::ReadToEnd, d).await;
  server_case(
    "101 w/o with_upgrades",
    b"GET /upgrade HTTP/1.1\r\nconnection: upgrade\r\nupgrade: foo\r\n\r\n",
    Then::ReadToEnd,
    d,
  )
  .await;
  tokio::time::sleep(Duration::from_millis(50)).await;
  let ff = Opts { fail_flush: true, ..d };
  server_case("flush fails", b"GET / HTTP/1.1\r\n\r\n", Then::ReadToEnd, ff).await;
  let fs = Opts { fail_shutdown: true, ..d };
  server_case("shutdown fails", b"GET / HTTP/1.1\r\nconnection: close\r\n\r\n", Then::ReadToEnd, fs).await;

  println!("--- server side: hyper::server::conn::http2");
  {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let client = tokio::spawn(async move {
      let mut tcp = TcpStream::connect(addr).await.unwrap();
      tcp.write_all(b"GET / HTTP/1.1\r\n\r\n").await.unwrap();
      let mut sink = Vec::new();
      let _ = tcp.read_to_end(&mut sink).await;
    });
    let (stream, _) = listener.accept().await.unwrap();
    let r = http2::Builder::new(TokioExecutor::new()).serve_connection(TokioIo::new(stream), service_fn(handle)).await;
    if let Err(e) = r {
      report("h1 bytes to h2 server", &e);
    }
    let _ = client.await;
  }
  {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let client = tokio::spawn(async move {
      let mut tcp = TcpStream::connect(addr).await.unwrap();
      // preface + empty SETTINGS, then never answer anything (no PING ack)
      tcp.write_all(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n\x00\x00\x00\x04\x00\x00\x00\x00\x00").await.unwrap();
      let mut sink = Vec::new();
      let _ = tcp.read_to_end(&mut sink).await;
    });
    let (stream, _) = listener.accept().await.unwrap();
    let r = http2::Builder::new(TokioExecutor::new())
      .timer(TokioTimer::new())
      .keep_alive_interval(Duration::from_millis(100))
      .keep_alive_timeout(Duration::from_millis(100))
      .serve_connection(TokioIo::new(stream), service_fn(handle))
      .await;
    if let Err(e) = r {
      report("h2 ping unanswered", &e);
    }
    let _ = client.await;
  }

  println!("--- client side: hyper::client::conn::http1, raw TCP server");
  {
    let addr = raw_server(|mut tcp| async move {
      read_head(&mut tcp).await;
      drop(tcp);
    })
    .await;
    let (mut tx, conn) = h1_client(addr).await;
    tokio::spawn(conn);
    if let Err(e) = tx.send_request(get("/")).await {
      report("closed before response", &e);
    }
  }
  {
    let addr = raw_server(|mut tcp| async move {
      read_head(&mut tcp).await;
      tcp.write_all(b"HTTP/1.1 abc OK\r\n\r\n").await.unwrap();
      tokio::time::sleep(Duration::from_millis(100)).await;
    })
    .await;
    let (mut tx, conn) = h1_client(addr).await;
    tokio::spawn(conn);
    if let Err(e) = tx.send_request(get("/")).await {
      report("bad status line", &e);
    }
  }
  {
    let addr = raw_server(|mut tcp| async move {
      tcp.write_all(b"HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n").await.unwrap();
      tokio::time::sleep(Duration::from_millis(100)).await;
    })
    .await;
    let (_tx, conn) = h1_client(addr).await;
    if let Err(e) = conn.await {
      report("response before request", &e);
    }
  }
  {
    let addr = raw_server(|mut tcp| async move {
      read_head(&mut tcp).await;
      tokio::time::sleep(Duration::from_millis(100)).await;
    })
    .await;
    let (mut tx, conn) = h1_client(addr).await;
    tokio::spawn(conn);
    let _first = tx.send_request(get("/1"));
    if let Err(e) = tx.send_request(get("/2")).await {
      report("2nd send, not ready", &e);
    }
  }
  {
    let addr = raw_server(|tcp| async move {
      drop(tcp);
    })
    .await;
    let (mut tx, conn) = h1_client(addr).await;
    let _ = conn.await;
    if let Err(e) = tx.ready().await {
      report("ready() after conn ended", &e);
    }
  }
  {
    let (got_tx, got_rx) = tokio::sync::oneshot::channel();
    let addr = raw_server(|mut tcp| async move {
      read_head(&mut tcp).await;
      let _ = got_tx.send(());
      tokio::time::sleep(Duration::from_millis(200)).await;
    })
    .await;
    let (mut tx, conn) = h1_client(addr).await;
    let task = tokio::spawn(conn);
    let fut = tx.send_request(get("/"));
    let waiter = tokio::spawn(fut);
    got_rx.await.unwrap();
    task.abort();
    if let Err(e) = waiter.await.unwrap() {
      report("conn task aborted", &e);
    }
  }

  println!("--- hyper_util::client::legacy::Client");
  let client: Client<_, Empty<Bytes>> = Client::builder(TokioExecutor::new()).build_http();
  {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    drop(listener);
    let uri = format!("http://{addr}/").parse().unwrap();
    if let Err(e) = client.get(uri).await {
      println!("{:<24} {e}{}", "connection refused", chain(&e));
      println!("{:<24} is_connect: {}", "", e.is_connect());
    }
  }
  {
    let addr = raw_server(|mut tcp| async move {
      read_head(&mut tcp).await;
      drop(tcp);
    })
    .await;
    let uri = format!("http://{addr}/").parse().unwrap();
    if let Err(e) = client.get(uri).await {
      println!("{:<24} {e}{}", "closed before response", chain(&e));
      let inner = e.source().and_then(|s| s.downcast_ref::<hyper::Error>());
      println!("{:<24} is_connect: {}, source is hyper::Error: {}", "", e.is_connect(), inner.is_some());
    }
  }
}

--- server side: hyper::server::conn::http1, raw TCP client
bad method               invalid HTTP method parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
bad uri                  invalid URI
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
bad version              invalid HTTP version parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
h2 preface               invalid HTTP version parsed (found HTTP2 preface)
                         is_*: parse, parse_version_h2
                         wire: (nothing)
bad header               invalid HTTP header parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
content-length abc       invalid content-length parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
te: gzip                 invalid transfer-encoding parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
te on HTTP/1.0           unexpected transfer-encoding parsed
                         is_*: parse
                         wire: HTTP/1.1 400 Bad Request
101 headers              message head is too large
                         is_*: parse, parse_too_large
                         wire: HTTP/1.1 431 Request Header Fields Too Large
uri 65535 bytes          URI too long
                         is_*: parse, parse_too_large
                         wire: HTTP/1.1 414 URI Too Long

slow head                read header from client timeout
                         is_*: timeout
                         wire: (nothing)
EOF mid head             connection closed before message completed
                         is_*: incomplete_message
                         wire: (nothing)
RST mid head             connection error -> Connection reset by peer (os error 54)
                         is_*: (none)
                         wire: (reset by client)
  request body           error reading a body from connection -> end of file before message length reached
                         is_*: (none)
EOF mid body             Ok(())
                         wire: HTTP/1.1 200 OK
  request body           error reading a body from connection -> Connection reset by peer (os error 54)
                         is_*: (none)
RST mid body             error writing a body to connection -> Broken pipe (os error 32)
                         is_*: (none)
                         wire: (reset by client)

body too short           user body write aborted -> early end, expected 2 more bytes
                         is_*: user, body_write_aborted
                         wire: (nothing)
status 103               response has 1xx status code, not supported by server
                         is_*: user
                         wire: HTTP/1.1 500 Internal Server Error
two content-lengths      user sent unexpected header
                         is_*: user
                         wire: (nothing)
  upgrade::on            no upgrade available
                         is_*: user
upgrade::on, no upgrade  Ok(())
                         wire: HTTP/1.1 200 OK
101 w/o with_upgrades    Ok(())
  upgrade::on            upgrade expected but low level API in use
                         is_*: user
                         wire: HTTP/1.1 101 Switching Protocols
flush fails              error writing a body to connection -> injected flush error
                         is_*: (none)
                         wire: HTTP/1.1 200 OK
shutdown fails           error shutting down connection -> injected shutdown error
                         is_*: shutdown
                         wire: HTTP/1.1 200 OK

--- server side: hyper::server::conn::http2
h1 bytes to h2 server    http2 error -> connection error detected: unspecific protocol error detected
                         is_*: (none)
h2 ping unanswered       http2 error -> keep-alive timed out -> operation timed out
                         is_*: timeout

--- client side: hyper::client::conn::http1, raw TCP server
closed before response   connection closed before message completed
                         is_*: incomplete_message
bad status line          invalid HTTP status-code parsed
                         is_*: parse, parse_status
response before request  received unexpected message from connection
                         is_*: (none)
2nd send, not ready      operation was canceled -> connection was not ready
                         is_*: canceled
ready() after conn ended channel closed
                         is_*: closed
conn task aborted        dispatch task is gone -> runtime dropped the dispatch task
                         is_*: user

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "client error ({:?})", self.kind)
    }
}

--- hyper_util::client::legacy::Client
connection refused       client error (Connect) -> tcp connect error -> Connection refused (os error 61)
                         is_connect: true
closed before response   client error (SendRequest) -> connection closed before message completed
                         is_connect: false, source is hyper::Error: true

service Err              error from user's Service -> boom
                         is_*: user
                         wire: (nothing)
body Err                 error from user's Body stream -> bad chunk
                         is_*: user
                         wire: (nothing)