Serve<Router, Router> is not a future

[leshow]

Summary

I ran into this a few times, it's easily fixable by wrapping axum::serve in an extra async {} block but I'm wondering if this behaviour is intended. If you spawnaxum::serve into a task for instance you get:

error[E0277]: `Serve<Router, Router>` is not a future
  --> libs/eidp_app/src/http.rs:52:20
   |
52 |     let foobar = tokio::spawn(axum::serve(
   |                    ^^^^^^^^^^^^ `Serve<Router, Router>` is not a future
   |
   = help: the trait `Future` is not implemented for `Serve<Router, Router>`
   = note: Serve<Router, Router> must be a future or must implement `IntoFuture` to be awaited

Same with using tokio::try_join! on a Serve, or anything that uses IntoFuture. My axum server is very simple:

   let foobar = axum::serve(
            TcpListener::bind(&addr)).await?,
            Router::new().route("/", axum::routing::get(ready)),
        );

Serve does appear to implement IntoFuture but the bounds must not be valid for the way I've defined it here.

axum version

0.7.2

[davidpdrsn]

It’s because tokio::spawn takes a Future and not an IntoFuture. That trait didn’t exist when tokio went 1.0.

[jplatte]

… which means that the solution is to call .into_future() on the Serve value returned by axum::serve().

[davidpdrsn]

Yes 😅

[0xfrian]

Thank you! Using .into_future() did the trick for me as well

[mcluseau]

also, I would like to document another super-complex-compiler-error-taking-hours-to-solve close to this one here: when building routers from another fn, with_state must be last (or at least after route call?).

ie, with the following code:

#[tokio::main]
async fn main() {
    let app = axum::Router::new().nest("/test", other_mod::router());

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

mod other_mod {
    use axum::{extract::State, routing::get, Router};

    #[derive(Clone)]
    struct AppState {}

    pub fn router() -> Router {
        Router::new()
            .with_state(AppState {})
            .route("/", get(get_something))
    }

    async fn get_something(State(_state): State<AppState>) {}
}

you get the following error:

   Compiling test_axum v0.1.0 (.../test_axum)
error[E0308]: mismatched types
   --> src/main.rs:18:25
    |
18  |             .route("/", get(get_something))
    |              -----      ^^^^^^^^^^^^^^^^^^ expected `MethodRouter`, found `MethodRouter<AppState>`
    |              |
    |              arguments to this method are incorrect
    |
    = note: expected struct `MethodRouter<()>`
               found struct `MethodRouter<AppState>`
note: method defined here
   --> .../.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.5/src/routing/mod.rs:159:12
    |
159 |     pub fn route(self, path: &str, method_router: MethodRouter<S>) -> Self {
    |            ^^^^^

And if you get the bad idea of adding the type parameter like that:

#[tokio::main]
async fn main() {
    let app = axum::Router::new().nest("/test", other_mod::router());

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

mod other_mod {
    use axum::{extract::State, routing::get, Router};

    #[derive(Clone)]
    struct AppState {}

    pub fn router() -> Router<AppState> {
        Router::new()
            .route("/", get(get_something))
            .with_state(AppState {})
    }

    async fn get_something(State(_state): State<AppState>) {}
}

you end up with the following error:

$ cargo build
   Compiling test_axum v0.1.0 (.../test_axum)
error[E0277]: the trait bound `for<'a> Router<AppState>: tower_service::Service<IncomingStream<'a>>` is not satisfied
  --> src/main.rs:6:27
   |
6  |     axum::serve(listener, app).await.unwrap();
   |     -----------           ^^^ the trait `for<'a> tower_service::Service<IncomingStream<'a>>` is not implemented for `Router<AppState>`
   |     |
   |     required by a bound introduced by this call
   |
   = help: the following other types implement trait `tower_service::Service<Request>`:
             <Router as tower_service::Service<IncomingStream<'_>>>
             <Router as tower_service::Service<axum::http::Request<B>>>
note: required by a bound in `serve`
  --> .../.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.5/src/serve.rs:97:8
   |
95 | pub fn serve<M, S>(tcp_listener: TcpListener, make_service: M) -> Serve<M, S>
   |        ----- required by a bound in this function
96 | where
97 |     M: for<'a> Service<IncomingStream<'a>, Error = Infallible, Response = S>,
   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `serve`

error[E0277]: `Serve<Router<AppState>, _>` is not a future
 --> src/main.rs:6:32
  |
6 |     axum::serve(listener, app).await.unwrap();
  |     ---------------------------^^^^^
  |     |                         ||
  |     |                         |`Serve<Router<AppState>, _>` is not a future
  |     |                         help: remove the `.await`
  |     this call returns `Serve<Router<AppState>, _>`
  |
  = help: the trait `IntoFuture` is not implemented for `Serve<Router<AppState>, _>`
  = note: Serve<Router<AppState>, _> must be a future or must implement `IntoFuture` to be awaited
  = help: the trait `IntoFuture` is implemented for `Serve<M, S>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `test_axum` (bin "test_axum") due to 2 previous errors

This code compile:

#[tokio::main]
async fn main() {
    let app = axum::Router::new().nest("/test", other_mod::router());

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

mod other_mod {
    use axum::{extract::State, routing::get, Router};

    #[derive(Clone)]
    struct AppState {}

    pub fn router() -> Router {
        Router::new()
            .route("/", get(get_something))
            .with_state(AppState {})
    }

    async fn get_something(State(_state): State<AppState>) {}
}

[mladedav]

Try replacing the generic S with (). Or just return Router without any generics (there is a default which is the unit type).

Would you say the docs on with_state cover your issue or do you think they could be improved? Or should this information also be accessible somewhere else?

[mcluseau]

Hi @mladedav , thanks for the pointer :) Replacing with () and nothing also works. It's really about the order of calls. I'll update accordingly.

TLDR: with .with_state(..).route(..) I got this error:

   --> src/main.rs:18:25
    |
18  |             .route("/", get(get_something))
    |              -----      ^^^^^^^^^^^^^^^^^^ expected `MethodRouter`, found `MethodRouter<AppState>`
    |              |
    |              arguments to this method are incorrect
    |
    = note: expected struct `MethodRouter<()>`
               found struct `MethodRouter<AppState>`
note: method defined here

Which led me to add the <AppState>, which is where I begun to dig my grave.

By "document" I meant "give search engines a pointer to the solution". The documentation is great, but did not came up when looking for the compilation error.