Compile error when upgrading the axum async_graphql example to shared Arc state

[LasseRosenow]

Hi everyone, I am writing a graphql api and I need to have a shared state object that I can continuously upgrade to react to configuration changes.

This is why I decided to use the shared_state from the key_store example. But I get a compile error... I tried for many hours, but I cannot find out what is causing it.

I get this error:

error[E0277]: the trait bound `fn(State<Arc<std::sync::RwLock<AppState>>>, axum::Json<async_graphql::Request>) -> impl std::future::Future<Output = axum::Json<async_graphql::Response>> {graphql_handler}: Handler<_, _, _>` is not satisfied
   --> apps\graphql\src\main.rs:52:50
    |
52  |         .route("/", get(graphql_playground).post(graphql_handler))
    |                                             ---- ^^^^^^^^^^^^^^^ the trait `Handler<_, _, _>` is not implemented for fn item `fn(State<Arc<std::sync::RwLock<AppState>>>, axum::Json<async_graphql::Request>) -> impl std::future::Future<Output = axum::Json<async_graphql::Response>> {graphql_handler}`
    |                                             |
    |                                             required by a bound introduced by this call
    |
    = help: the trait `Handler<T, S, B2>` is implemented for `Layered<L, H, T, S, B, B2>`
note: required by a bound in `MethodRouter::<S, B>::post`
   --> C:\Users\Lasse\.cargo\registry\src\github.com-1ecc6299db9ec823\axum-0.6.0\src\routing\method_routing.rs:618:5
    |
618 |     chained_handler_fn!(post, POST);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `MethodRouter::<S, B>::post`
    = note: this error originates in the macro `chained_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

This is my code:

use std::sync::{Arc, RwLock};

use async_graphql::{
    http::{playground_source, GraphQLPlaygroundConfig},
    EmptyMutation, EmptySubscription, Request, Response, Schema, Object, Context,
};
use axum::{
    extract::State,
    response::{Html, IntoResponse},
    routing::get,
    Json, Router,
};

pub struct QueryRoot;

#[Object]
impl QueryRoot {
    async fn example(&self, ctx: &Context<'_>, id: i32) -> Option<String> {
        Some(String::new())
    }
}

type SharedState = Arc<RwLock<AppState>>;

struct AppState {
    schema: Schema<QueryRoot, EmptyMutation, EmptySubscription>,
}

async fn graphql_handler(state: State<SharedState>, req: Json<Request>) -> Json<Response> {
    state.read().unwrap().schema.execute(req.0).await.into()
}

async fn graphql_playground() -> impl IntoResponse {
    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
}

#[tokio::main]
async fn main() {
    let state = Arc::new(RwLock::new(AppState {
        schema: Schema::new(QueryRoot, EmptyMutation, EmptySubscription)
    }));

    let app = Router::new()
        .route("/", get(graphql_playground).post(graphql_handler))
        .with_state(Arc::clone(&state));

    println!("Playground: http://localhost:3000");

    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

[davidpdrsn]

Have you tried https://docs.rs/axum/latest/axum/attr.debug_handler.html?

[LasseRosenow]

Thank you so much that helped me identity the issue. Seems I should use the Tokio RwLock instead of the one from the standard library as it seems there is some issue with using the value across await. Still a bit confused about it, but at least it works for now.

But after I implement the FromRequestParts trait, I again get some similar issue, which I don't know how to fix yet. But I would keep on trying and maybe ask again if I cannot fix it :)

Also there is a reddit that helped me fix the first issue:
https://www.reddit.com/r/rust/comments/pnzple/future_is_not_send_as_this_value_is_used_across/

one guy in the thread says this:

In general, I recommend that you never lock the standard library mutex from async functions. Instead, create a non-async function that locks it and accesses it, then call that non-async function from your async code.

So I wonder if this might be a better solution that could work without using the Tokio RwLock? But I am not really sure what this person exactly wants me to do, since I need the state value in the async function and not some sync function isn't it?

[davidpdrsn]

Seems I should use the Tokio RwLock instead of the one from the standard library as it seems there is some issue with using the value across await. Still a bit confused about it, but at least it works for now.

You generally never wanna hold locks across awaits. That is deadlocks waiting to happen.

Maybe I'm missing something but it seems to me that async_graph::Schema::execute just needs a &self and not &mut self. So why are you putting it behind a lock? Maybe an Arc<Schema> alone would be enough?

[davidpdrsn]

Actually Schema is an Arc on the inside https://docs.rs/async-graphql/latest/src/async_graphql/schema.rs.html#292 so you can just clone it directly. Don't need the additional Arc.

[LasseRosenow]

Oh that is because this is simplified, sorry in my application there would be more data in the state, like a config object that is regularly updated from external consul and another object containing the database connection, that could also be altered by configuration changes :)

[davidpdrsn]

Then keep the parts of your state that needs the lock in one struct and the rest in another.