How to handle subdomains

[AeonSolstice]

Summary

I want to handle api.my.domain and all.my.domain separately from my.domain. I tried using Host extractor but nothing worked. I looked into the wildcard path routing but the docs are so obscure about that.

Paths can end in /*key which matches all segments and will store the segments captured at key.

Store where? "Captured at key" - what does that even mean?
Then I found https://github.com/tokio-rs/axum/blob/main/axum/src/docs/routing/route.md where a new syntax was being used?

/{*key}

Any why does wildcard not handle /?
Furthermore, any code that I did get to compile silently sent an error as the http body, and was not helpful in any way.

The only discussion I found regarding axum and subdomains had a non working solution, not to mention "use reverse proxy" "use nginx" "dont handle that with axum" "use loadbalancer" "dont do it like this"

I do not want to do any of that. I just want to handle subdomains in rust code directly. Any help besides "use nginx" is appreciated.

If this sounds like a rant, it is probably because I come from a nodejs + express background.

axum version

=0.7.9

[dayvejones]

Then I found https://github.com/tokio-rs/axum/blob/main/axum/src/docs/routing/route.md where a new syntax was being used?

Route works with part of the url, which is located after the host.

Applications cannot manage their DNS names themselves. However, several names can refer to one instance. And this instance is able to distinguish from which Hostname request came

If you want two third level domains to refer to one instance of the axum application, then this is done outside the Axum. Before. It doesn’t matter through Nginx, or through something else. You need to ensure that the right header HOST reaches the application.

And then inside the axum application get from the “request” Host header and branch the subsequent logic as you wish.

[AeonSolstice]

Yes I already have a wildcard dns entry and my app can receive requests from all subdomains.
The issue is that I can not figure out a way to route them inside of axum. I tried using the Host extractor, pattern matching, and then calling .oneshot on the detached routers, but the issue is that I need to have 2 routes to handle that: / and /*path since the latter does not match the first. That is the issue, because I cannot have the same closure for both paths as they both need to .oneshot both routers.

I also tried the following

let api_router = Router::new().route("/", get(api)).fallback(fof);

let all_router = Router::new()
  .route("/", get(|| async { "Coming soon!" }))
  .fallback(fof);

let app = Router::new()
  .route("/", get(root))
  .route("/api", get(api))
  .fallback(fof);

let subdomain_handler = |Host(h), req, next: Next| async {
  println!("{h}");
  match h.as_str() {
    h if h == format!("api.{}", *DOMAIN) => api_router.oneshot(req).await,
    h if h == format!("all.{}", *DOMAIN) => all_router.oneshot(req).await,
    _ => Ok(next.run(req).await),
  }
};

let main = axum::serve(
  TcpListener::bind(format!("0.0.0.0:{}", *PORT))
    .await
    .unwrap(),
  app.layer(middleware::from_fn(subdomain_handler)),
);

with no luck:

error[E0525]: expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
   --> server/src/main.rs:50:27
    |
50  |   let subdomain_handler = |Host(h), req, next: Next| async {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ this closure implements `FnOnce`, not `FnMut`
...
53  |       h if h == format!("api.{}", *DOMAIN) => api_router.oneshot(req).await,
    |                                               ---------- closure is `FnOnce` because it moves the variable `api_router` out of its environment
...
63  |     app.layer(middleware::from_fn(subdomain_handler)),
    |         ----- -------------------------------------- the requirement to implement `FnMut` derives from here
    |         |
    |         required by a bound introduced by this call
    |
    = note: required for `FromFn<{[email protected]:50:27}, (), Route, (Host, Request<Body>)>` to implement `tower::Service<axum::http::Request<axum::body::Body>>`
note: required by a bound in `axum::Router::<S>::layer`
   --> /home/user/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.9/src/routing/mod.rs:284:21
    |
281 |     pub fn layer<L>(self, layer: L) -> Router<S>
    |            ----- required by a bound in this associated function
...
284 |         L::Service: Service<Request> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^ required by this bound in `Router::<S>::layer`
    = note: the full name for the type has been written to '/home/user/aeon/site/target/debug/deps/server-8873704a23ade9cc.long-type-18064066039487957363.txt'
    = note: consider using `--verbose` to print the full type name to the console

[AeonSolstice]

I managed to solve it.

1. Searched for wildcard in issues
2. Found "/*path" does not match "/" anymore with axum 0.6 ... #1607 in closed issues
3. Searched for Router.fallback() based on "/*path" does not match "/" anymore with axum 0.6 ... #1607 (comment)
4. "Handling all requests without other routes"

Using Router::new().fallback(...) to accept all request regardless of path or method, if you don’t have other routes, isn’t optimal:
...
Running the handler directly is faster since it avoids the overhead of routing:

use axum::handler::HandlerWithoutStateExt;

async fn handler() {}

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, handler.into_make_service()).await.unwrap();

New code (I did have to add the Router and axum::extract::Request types):

let api_router: Router = Router::new().route("/", get(api)).fallback(fof);

let all_router: Router = Router::new()
  .route("/", get(|| async { "Coming soon!" }))
  .fallback(fof);

let app: Router = Router::new()
  .route("/", get(root))
  .route("/api", get(api))
  .fallback(fof);

let subdomain_handler = |Host(h), req: Request| async move {
  println!("{h}");
  match h.as_str() {
    h if h == format!("api.{}", *DOMAIN) => api_router.oneshot(req).await,
    h if h == format!("all.{}", *DOMAIN) => all_router.oneshot(req).await,
    _ => app.oneshot(req).await,
  }
};

let main = axum::serve(
  TcpListener::bind(format!("0.0.0.0:{}", *PORT))
    .await
    .unwrap(),
  subdomain_handler.into_make_service(),
);