不起服务器的测试

pub fn mount(router: Router, assets_root: &str) -> Router {
  let router = router
    .nest_service("/images", ServeDir::new(format!("{}/images", assets_root)))
    .nest_service("/posts", ServeDir::new(app_core::utils::content_dir("posts")))
    // 脚本文件名不带哈希：每次使用前向服务端确认（未变时 304），改版后立即生效
    .nest(
      "/js",
      Router::new()
        .fallback_service(ServeDir::new(format!("{}/js", assets_root)))
        .layer(middleware::map_response(cache_control("no-cache"))),
    )
    .nest_service("/uploads", ServeDir::new(format!("{}/uploads", assets_root)))
    // ...
    .nest_service("/assets/font", ServeDir::new(format!("{}/font", assets_root)));
  // ...
  router
}

  use tower::ServiceExt;

  async fn get(assets_root: &str, uri: &str) -> axum::response::Response {
    super::mount(axum::Router::new(), assets_root)
      .oneshot(Request::builder().uri(uri).body(Body::empty()).unwrap())
      .await
      .unwrap()
  }

axum = "=0.8.9"
tower-http = { version = "=0.6.11", features = ["fs"] }
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread"] }

use std::{future::poll_fn, path::PathBuf};

use axum::{
  Router,
  body::{Body, to_bytes},
  http::{HeaderValue, Request, header},
  middleware::map_response,
  response::Response,
};
use tower::{Service, ServiceExt};
use tower_http::services::ServeDir;

fn req(uri: &str) -> Request<Body> {
  Request::builder().uri(uri).body(Body::empty()).unwrap()
}

async fn show(label: &str, res: Response<Body>) {
  let status = res.status().as_u16();
  let cc = res.headers().get(header::CACHE_CONTROL).and_then(|v| v.to_str().ok()).map(str::to_owned);
  let body = to_bytes(res.into_body(), 1024).await.unwrap();
  println!("{label:<28} {status} cache-control={cc:?} body={body:?}");
}

#[tokio::main]
async fn main() {
  let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixture");
  std::fs::create_dir_all(root.join("js")).unwrap();
  std::fs::create_dir_all(root.join("images")).unwrap();
  std::fs::write(root.join("js/a.js"), "1").unwrap();
  std::fs::write(root.join("images/x.txt"), "img").unwrap();

  // 1. ServeDir 自己就是 Service：poll_ready 立刻 Ready，oneshot 直接发请求
  let mut dir = ServeDir::new(root.join("js"));
  let ready = poll_fn(|cx| std::task::Poll::Ready(Service::<Request<Body>>::poll_ready(&mut dir, cx))).await;
  println!("ServeDir poll_ready: {ready:?}");
  show("ServeDir /a.js", dir.clone().oneshot(req("/a.js")).await.unwrap().map(Body::new)).await;
  show("ServeDir /nope.js", dir.oneshot(req("/nope.js")).await.unwrap().map(Body::new)).await;

  // 2. 和 static_assets::mount 同样的挂法
  let cache = |mut res: Response| {
    res.headers_mut().insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
    std::future::ready(res)
  };
  let router = Router::new()
    .nest_service("/images", ServeDir::new(root.join("images")))
    .nest(
      "/js",
      Router::new().fallback_service(ServeDir::new(root.join("js"))).layer(map_response(cache)),
    );
  for uri in ["/images/x.txt", "/js/a.js", "/js/nope.js", "/other"] {
    show(&format!("Router {uri}"), router.clone().oneshot(req(uri)).await.unwrap()).await;
  }
}

ServeDir poll_ready: Ready(Ok(()))
ServeDir /a.js               200 cache-control=None body=b"1"
ServeDir /nope.js            404 cache-control=None body=b""
Router /images/x.txt         200 cache-control=None body=b"img"
Router /js/a.js              200 cache-control=Some("no-cache") body=b"1"
Router /js/nope.js           404 cache-control=Some("no-cache") body=b""
Router /other                404 cache-control=None body=b""

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["limit", "util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "time"] }

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

use axum::{Router, body::Body, extract::Request, routing::get};
use tower::{ServiceExt, limit::ConcurrencyLimitLayer};

fn req(path: &str) -> Request {
  Request::builder().uri(path).body(Body::empty()).unwrap()
}

#[tokio::main]
async fn main() {
  for eager in [false, true] {
    println!("ConcurrencyLimitLayer::new(1), with_state: {eager}");
    let mut router = Router::new()
      .route("/a", get(|| async { tokio::time::sleep(Duration::from_millis(100)).await }))
      .route("/b", get(|| async { tokio::time::sleep(Duration::from_millis(100)).await }))
      .layer(ConcurrencyLimitLayer::new(1));
    if eager {
      // into_make_service 内部就是这么做的：提前把 handler 变成 Route
      router = router.with_state(());
    }
    let start = Instant::now();
    let send = |path: &'static str| {
      let router = router.clone();
      tokio::spawn(async move {
        router.oneshot(req(path)).await.unwrap();
        (path, start.elapsed().as_millis() / 10 * 10)
      })
    };
    // 同时发三个请求：两个 /a，一个 /b
    let tasks = [send("/a"), send("/a"), send("/b")];
    for t in tasks {
      let (path, ms) = t.await.unwrap();
      println!("  {path} done at ~{ms}ms");
    }
  }
}

ConcurrencyLimitLayer::new(1), with_state: false
  /a done at ~100ms
  /a done at ~100ms
  /b done at ~100ms
ConcurrencyLimitLayer::new(1), with_state: true
  /a done at ~100ms
  /a done at ~200ms
  /b done at ~100ms