本站的出站客户端

async fn send(pr: &PayRequest, label: &str) -> Result<String, PayError> {
  // 必须有超时：对账循环逐单 await，一个挂住的连接会让对账永久停住（Y5）。
  let client = reqwest::Client::builder()
    .connect_timeout(std::time::Duration::from_secs(5))
    .timeout(std::time::Duration::from_secs(15))
    .build()
    .map_err(|e| PayError::Gateway(format!("创建 HTTP 客户端失败: {e}")))?;
  // ...

        let mut builder =
            hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new());
        // ...
        builder.timer(hyper_util::rt::TokioTimer::new());
        builder.pool_timer(hyper_util::rt::TokioTimer::new());
        builder.pool_idle_timeout(config.pool_idle_timeout);
        builder.pool_max_idle_per_host(config.pool_max_idle_per_host);
        // ...
        let hyper_client = builder.build(connector_builder.build(config.connector_layers));

reqwest = { version = "=0.12.28", default-features = false }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "time", "io-util"] }

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

use tokio::{io::AsyncReadExt, net::TcpListener};

#[tokio::main]
async fn main() {
  // 一个挂住的上游：收下请求，永远不回
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let url = format!("http://{}/", listener.local_addr().unwrap());
  tokio::spawn(async move {
    loop {
      let (mut s, _) = listener.accept().await.unwrap();
      tokio::spawn(async move {
        let mut buf = [0u8; 1024];
        let _ = s.read(&mut buf).await;
        std::future::pending::<()>().await;
        drop(s);
      });
    }
  });

  let plain = reqwest::Client::builder().no_proxy().build().unwrap();
  let timed = reqwest::Client::builder()
    .no_proxy()
    .connect_timeout(Duration::from_secs(5))
    .timeout(Duration::from_millis(500))
    .build()
    .unwrap();

  let t0 = Instant::now();
  match tokio::time::timeout(Duration::from_secs(3), plain.get(&url).send()).await {
    Ok(r) => println!("no timeout:   {:?}", r.map(|r| r.status())),
    Err(_) => println!("no timeout:   still pending after {}ms", t0.elapsed().as_millis()),
  }

  let t0 = Instant::now();
  match timed.get(&url).send().await {
    Ok(r) => println!("timeout(500ms): {}", r.status()),
    Err(e) => println!(
      "timeout(500ms): after {}ms: {e} (is_timeout={})",
      t0.elapsed().as_millis(),
      e.is_timeout()
    ),
  }
}

no timeout:   still pending after 3003ms
timeout(500ms): after 503ms: error sending request for url (http://127.0.0.1:59935/) (is_timeout=true)

reqwest = { version = "=0.12.28", default-features = false }
hyper = { version = "=1.12.0", features = ["server", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "time"] }

use std::{
  convert::Infallible,
  sync::atomic::{AtomicUsize, Ordering},
  time::{Duration, Instant},
};

use hyper::{Request, Response, body::Incoming, server::conn::http1, service::service_fn};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;

static CONNS: AtomicUsize = AtomicUsize::new(0);

async fn server() -> String {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let url = format!("http://{}/", listener.local_addr().unwrap());
  let t0 = Instant::now();
  tokio::spawn(async move {
    loop {
      let (s, _) = listener.accept().await.unwrap();
      let n = CONNS.fetch_add(1, Ordering::SeqCst) + 1;
      println!("  {:>4}ms server: conn #{n} open", t0.elapsed().as_millis());
      tokio::spawn(async move {
        let svc = service_fn(|_req: Request<Incoming>| async { Ok::<_, Infallible>(Response::new("ok".to_string())) });
        let _ = http1::Builder::new().serve_connection(TokioIo::new(s), svc).await;
        println!("  {:>4}ms server: conn #{n} closed", t0.elapsed().as_millis());
      });
    }
  });
  url
}

fn client() -> reqwest::Client {
  reqwest::Client::builder()
    .no_proxy()
    .connect_timeout(Duration::from_secs(5))
    .timeout(Duration::from_secs(15))
    .build()
    .unwrap()
}

#[tokio::main]
async fn main() {
  println!("one shared Client (like crates/llm):");
  let url = server().await;
  let shared = client();
  for _ in 0..3 {
    shared.get(&url).send().await.unwrap().text().await.unwrap();
    tokio::time::sleep(Duration::from_millis(100)).await;
  }
  drop(shared);
  tokio::time::sleep(Duration::from_millis(100)).await;

  println!("a new Client per call (like OAuth / payment host.rs):");
  CONNS.store(0, Ordering::SeqCst);
  let url = server().await;
  for _ in 0..3 {
    let c = client();
    c.get(&url).send().await.unwrap().text().await.unwrap();
    tokio::time::sleep(Duration::from_millis(100)).await;
  }
  tokio::time::sleep(Duration::from_millis(100)).await;
}

hyper-util = { version = "=0.1.21", features = ["client-proxy", "client-proxy-system"] }

use hyper_util::client::proxy::matcher::Matcher;

fn main() {
  // 只读配置，不发任何请求：reqwest 0.12 默认用的就是 Matcher::from_system()
  let m = Matcher::from_system();
  for dst in ["http://127.0.0.1:8080/", "http://localhost:8080/", "https://api.github.com/"] {
    let hit = m.intercept(&dst.parse().unwrap()).map(|i| i.uri().to_string());
    println!("{dst:<26} -> {hit:?}");
  }
}

== shell env
http://127.0.0.1:8080/     -> None
http://localhost:8080/     -> None
https://api.github.com/    -> Some("http://127.0.0.1:7890/")
== no proxy env vars
http://127.0.0.1:8080/     -> Some("http://127.0.0.1:7890/")
http://localhost:8080/     -> Some("http://127.0.0.1:7890/")
https://api.github.com/    -> Some("http://127.0.0.1:7890/")

reqwest = { version = "=0.12.28", default-features = false, features = ["system-proxy"] }
axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["rt-multi-thread", "net", "io-util"] }

use std::error::Error;

use axum::{Router, routing::get};
use tokio::{io::AsyncReadExt, net::TcpListener};

fn main() {
  // 一个「代理」：收下请求、打印第一行、什么也不回就关连接
  let proxy = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
  let proxy_url = format!("http://{}", proxy.local_addr().unwrap());
  // 在任何线程启动之前设置；reqwest 构造 Client 时读环境变量
  unsafe { std::env::set_var("HTTP_PROXY", &proxy_url) };

  tokio::runtime::Runtime::new().unwrap().block_on(async move {
    proxy.set_nonblocking(true).unwrap();
    let proxy = TcpListener::from_std(proxy).unwrap();
    tokio::spawn(async move {
      loop {
        let (mut s, _) = proxy.accept().await.unwrap();
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).await.unwrap();
        let line = String::from_utf8_lossy(&buf[..n]).lines().next().unwrap_or("").to_string();
        println!("  proxy got: {line}");
        drop(s);
      }
    });

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let url = format!("http://{}/", listener.local_addr().unwrap());
    tokio::spawn(async move {
      axum::serve(listener, Router::new().route("/", get(|| async { "ok" }))).await.unwrap()
    });

    for (name, client) in [
      ("Client::new()", reqwest::Client::new()),
      ("builder().no_proxy()", reqwest::Client::builder().no_proxy().build().unwrap()),
    ] {
      println!("{name}:");
      match client.get(&url).send().await {
        Ok(res) => println!("  {} {:?}", res.status(), res.text().await.unwrap()),
        Err(e) => {
          println!("  error: {e}");
          let mut src = e.source();
          while let Some(s) = src {
            println!("  caused by: {s}");
            src = s.source();
          }
        }
      }
    }
  });
}

Client::new():
  proxy got: GET http://127.0.0.1:59396/ HTTP/1.1
  error: error sending request for url (http://127.0.0.1:59396/)
  caused by: client error (SendRequest)
  caused by: connection closed before message completed
builder().no_proxy():
  200 OK "ok"

    // 项目约定（CLAUDE.md::Rust HTTP Testing）：测试场景需用 `.no_proxy()`
    // 避免本地代理拦截 loopback；生产环境保持默认 client 行为。
    // 这里在测试时由 [`Self::with_client`] 注入 `.no_proxy()` 的 client。

one shared Client (like crates/llm):
     1ms server: conn #1 open
   311ms server: conn #1 closed
a new Client per call (like OAuth / payment host.rs):
     0ms server: conn #1 open
   102ms server: conn #1 closed
   103ms server: conn #2 open
   206ms server: conn #2 closed
   206ms server: conn #3 open
   309ms server: conn #3 closed