nest、merge 与 fallback

    pub fn nest(self, path: &str, router: Router<S>) -> Self {
        if path.is_empty() || path == "/" {
            panic!("Nesting at the root is no longer supported. Use merge instead.");
        }

        let RouterInner {
            path_router,
            fallback_router,
            default_fallback,
            // we don't need to inherit the catch-all fallback. It is only used for CONNECT
            // requests with an empty path. If we were to inherit the catch-all fallback
            // it would end up matching `/{path}/*` which doesn't match empty paths.
            catch_all_fallback: _,
        } = router.into_inner();

        tap_inner!(self, mut this => {
            panic_on_err!(this.path_router.nest(path, path_router));

            if !default_fallback {
                panic_on_err!(this.fallback_router.nest(path, fallback_router));
            }
        })
    }

    if prefix.ends_with('/') {
        format!("{prefix}{}", path.trim_start_matches('/')).into()
    } else if path == "/" {
        prefix.into()
    } else {
        format!("{prefix}{path}").into()
    }

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "0.1"

use axum::{Router, body::Body, http::{Request, Uri}, routing::get};
use http_body_util::BodyExt;
use tower::ServiceExt;

#[tokio::main]
async fn main() {
  let inner = || Router::new().route("/", get(|uri: Uri| async move { format!("inner / sees {uri}") }));
  let app = Router::new().nest("/n", inner()).nest_service("/s", inner());

  for uri in ["/n", "/n/", "/s", "/s/", "/s/x"] {
    let req = Request::get(uri).body(Body::empty()).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    let status = res.status().as_u16();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{uri:<5} {status} {:?}", String::from_utf8_lossy(&body));
  }
}

/n    200 "inner / sees /"
/n/   404 ""
/s    200 "inner / sees /"
/s/   200 "inner / sees /"
/s/x  404 ""

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }

use std::panic::{self, AssertUnwindSafe};

use axum::{Router, routing::get};

fn try_build(label: &str, f: impl FnOnce() -> Router) {
  match panic::catch_unwind(AssertUnwindSafe(f)) {
    Ok(_) => println!("{label}\n  ok"),
    Err(e) => {
      let msg = e
        .downcast_ref::<String>()
        .cloned()
        .or_else(|| e.downcast_ref::<&str>().map(|s| s.to_string()))
        .unwrap_or_default();
      println!("{label}\n  panic: {msg}");
    }
  }
}

fn main() {
  panic::set_hook(Box::new(|_| {}));
  let h = || get(|| async {});
  let inner = || Router::new().route("/users", get(|| async {}));
  let svc = || tower::service_fn(|_| async { Ok::<_, std::convert::Infallible>("svc") });

  try_build("nest(\"/\", inner)", || Router::new().nest("/", inner()));
  try_build("nest_service(\"/\", svc)", || Router::new().nest_service("/", svc()));
  try_build("nest(\"/files/{*rest}\", inner)", || Router::new().nest("/files/{*rest}", inner()));
  try_build("nest(\"/:version\", inner)", || Router::new().nest("/:version", inner()));
  try_build("nest(\"/api\", a).nest(\"/api\", b)", || {
    Router::new().nest("/api", inner()).nest("/api", Router::new().route("/teams", h()))
  });
  try_build("nest(\"/api\", inner).route(\"/api/users\", ..)", || {
    Router::new().nest("/api", inner()).route("/api/users", h())
  });
  try_build("nest_service(\"/api\", svc).route(\"/api\", ..)", || {
    Router::new().nest_service("/api", svc()).route("/api", h())
  });
  try_build("route(\"/users\", get).merge(route(\"/users\", post))", || {
    Router::new()
      .route("/users", h())
      .merge(Router::new().route("/users", axum::routing::post(|| async {})))
  });
  try_build("route(\"/users\", get).merge(route(\"/users\", get))", || {
    Router::new().route("/users", h()).merge(Router::new().route("/users", h()))
  });
  try_build("route(\"/{id}\").merge(route(\"/{name}\"))", || {
    Router::new().route("/{id}", h()).merge(Router::new().route("/{name}", h()))
  });
  try_build("a.fallback(f).merge(b.fallback(f))", || {
    Router::new()
      .fallback(|| async {})
      .merge(Router::new().fallback(|| async {}))
  });
  try_build("a.fallback(f).merge(b.fallback(f).reset_fallback())", || {
    Router::new()
      .fallback(|| async {})
      .merge(Router::new().fallback(|| async {}).reset_fallback())
  });
  try_build("route_service(\"/api\", Router)", || {
    Router::new().route_service("/api", inner())
  });
  try_build("nest(\"/api\", a.fallback(f)).nest(\"/api\", b.fallback(f))", || {
    Router::new()
      .nest("/api", inner().fallback(|| async {}))
      .nest("/api", Router::new().route("/teams", h()).fallback(|| async {}))
  });
}

nest("/", inner)
  panic: Nesting at the root is no longer supported. Use merge instead.
nest_service("/", svc)
  panic: Nesting at the root is no longer supported. Use fallback_service instead.
nest("/files/{*rest}", inner)
  panic: Invalid route: nested routes cannot contain wildcards (*)
nest("/:version", inner)
  panic: called `Result::unwrap()` on an `Err` value: "Path segments must not start with `:`. For capture groups, use `{capture}`. If you meant to literally match a segment starting with a colon, call `without_v07_checks` on the router."
nest("/api", a).nest("/api", b)
  ok
nest("/api", inner).route("/api/users", ..)
  panic: Overlapping method route. Handler for `GET /api/users` already exists
nest_service("/api", svc).route("/api", ..)
  panic: Invalid route "/api": Insertion failed due to conflict with previously registered route: /api
route("/users", get).merge(route("/users", post))
  ok
route("/users", get).merge(route("/users", get))
  panic: Overlapping method route. Handler for `GET /users` already exists
route("/{id}").merge(route("/{name}"))
  panic: Invalid route "/{name}": Insertion failed due to conflict with previously registered route: /{id}
a.fallback(f).merge(b.fallback(f))
  panic: Cannot merge two `Router`s that both have a fallback
a.fallback(f).merge(b.fallback(f).reset_fallback())
  ok
route_service("/api", Router)
  panic: Invalid route: `Router::route_service` cannot be used with `Router`s. Use `Router::nest` instead
nest("/api", a.fallback(f)).nest("/api", b.fallback(f))
  panic: Cannot merge two `MethodRouter`s that both have a fallback

            match (this.default_fallback, default_fallback) {
                // both have the default fallback
                // use the one from other
                (true, true) => {
                    this.fallback_router.merge(other_fallback).expect(PANIC_MSG);
                }
                // this has default fallback, other has a custom fallback
                (true, false) => {
                    this.fallback_router.merge(other_fallback).expect(PANIC_MSG);
                    this.default_fallback = false;
                }
                // this has a custom fallback, other has a default
                (false, true) => {
                    let fallback_router = std::mem::take(&mut this.fallback_router);
                    other_fallback.merge(fallback_router).expect(PANIC_MSG);
                    this.fallback_router = other_fallback;
                }
                // both have a custom fallback, not allowed
                (false, false) => {
                    panic!("Cannot merge two `Router`s that both have a fallback")
                }
            };

    pub(super) fn set_fallback(&mut self, endpoint: Endpoint<S>) {
        self.replace_endpoint("/", endpoint.clone());
        self.replace_endpoint(FALLBACK_PARAM_PATH, endpoint);
    }

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "0.1"

use axum::{
  Router,
  body::Body,
  http::{Method, Request, StatusCode, Uri},
  routing::get,
};
use http_body_util::BodyExt;
use tower::ServiceExt;

fn fb(name: &'static str) -> impl Fn(Uri) -> std::future::Ready<String> + Clone {
  move |uri: Uri| std::future::ready(format!("{name} sees {uri}"))
}

async fn send(app: &Router, method: Method, uri: &str) {
  let req = Request::builder().method(method.clone()).uri(uri).body(Body::empty()).unwrap();
  let res = app.clone().oneshot(req).await.unwrap();
  let status = res.status().as_u16();
  let body = res.into_body().collect().await.unwrap().to_bytes();
  println!("{:<5}{uri:<10} {status} {:?}", method.as_str(), String::from_utf8_lossy(&body));
}

#[tokio::main]
async fn main() {
  let users = || Router::new().route("/users", get(|| async { "users" }));

  let app = Router::new()
    .nest("/a", users())
    .nest("/b", users().fallback(fb("b_fallback")))
    .nest_service("/c", users())
    .nest_service("/d", users().fallback(fb("d_fallback")))
    .fallback(fb("outer_fallback"));

  for uri in ["/a/x", "/b/x", "/c/x", "/d/x", "/x", "/a", "/b", "/b/", "/c"] {
    send(&app, Method::GET, uri).await;
  }
  send(&app, Method::POST, "/a/users").await;

  println!("-- fallback set before nest");
  let app = Router::new().fallback(fb("outer_fallback")).nest("/a", users());
  send(&app, Method::GET, "/a/x").await;

  println!("-- method_not_allowed_fallback before / after nest");
  let m405 = |m: Method| async move { (StatusCode::METHOD_NOT_ALLOWED, format!("custom 405 for {m}")) };
  let before = Router::new().method_not_allowed_fallback(m405).nest("/a", users());
  let after = Router::new().nest("/a", users()).method_not_allowed_fallback(m405);
  send(&before, Method::POST, "/a/users").await;
  send(&after, Method::POST, "/a/users").await;

  println!("-- merge keeps whichever side has the fallback");
  let left = users().fallback(fb("left_fallback")).merge(Router::new().route("/teams", get(|| async { "teams" })));
  let right = Router::new().route("/teams", get(|| async { "teams" })).merge(users().fallback(fb("right_fallback")));
  send(&left, Method::GET, "/x").await;
  send(&right, Method::GET, "/x").await;
}

GET  /a/x       200 "outer_fallback sees /a/x"
GET  /b/x       200 "b_fallback sees /x"
GET  /c/x       404 ""
GET  /d/x       200 "d_fallback sees /x"
GET  /x         200 "outer_fallback sees /x"
GET  /a         200 "outer_fallback sees /a"
GET  /b         200 "b_fallback sees /"
GET  /b/        200 "outer_fallback sees /b/"
GET  /c         404 ""
POST /a/users   405 ""
-- fallback set before nest
GET  /a/x       200 "outer_fallback sees /a/x"
-- method_not_allowed_fallback before / after nest
POST /a/users   405 ""
POST /a/users   405 "custom 405 for POST"
-- merge keeps whichever side has the fallback
GET  /x         200 "left_fallback sees /x"
GET  /x         200 "right_fallback sees /x"