Trait error when I try to use await in handler

[advilm]

Hello, I'm relatively new to rust and I'm come across a very strange trait error.

Full code:

use axum::{
    extract::{
        ws::{Message, WebSocket, WebSocketUpgrade},
        Extension, Query,
    },
    response::IntoResponse,
    routing::get,
    Router,
};

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

type WebSockets = Arc<Mutex<Vec<WebSocket>>>;

#[derive(serde_derive::Deserialize)]
struct Parameters {
    command: String,
}

#[tokio::main]
async fn main() {
    // create vector of shared websockets
    let ws_connections: WebSockets = Arc::new(Mutex::new(Vec::new()));

    let app = Router::new()
        .route("/ws", get(upgrade_ws))
        .route("/run", post(handle_run))
        .layer(Extension(ws_connections));

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

async fn upgrade_ws(
    ws: WebSocketUpgrade,
    Extension(websockets): Extension<WebSockets>,
) -> impl IntoResponse {
    ws.on_upgrade(move |socket| handle_socket(socket, websockets))
}

async fn handle_socket(socket: WebSocket, websockets: WebSockets) {
    println!("New connection");
    if let Ok(mut ws_connections) = websockets.lock() {
        ws_connections.push(socket);
    }
}

async fn handle_run(query: Query<Parameters>, Extension(websockets): Extension<WebSockets>) {
    if let Ok(mut ws_connections) = websockets.lock() {
        for ws in ws_connections.iter_mut() {
            ws.send(Message::Text(query.command.clone())).await.unwrap();
        }
    }
}

Error:

error[E0277]: the trait bound `fn(Query<Parameters>, Extension<Arc<std::sync::Mutex<Vec<WebSocket>>>>) -> impl Future<Output = ()> {handle_run}: Handler<_, _>` is not satisfied
   --> src/main.rs:27:28
    |
27  |         .route("/run", get(handle_run))
    |                        --- ^^^^^^^^^^ the trait `Handler<_, _>` is not implemented for `fn(Query<Parameters>, Extension<Arc<std::sync::Mutex<Vec<WebSocket>>>>) -> impl Future<Output = ()> {handle_run}`
    |                        |
    |                        required by a bound introduced by this call
    |
note: required by a bound in `axum::routing::get`
   --> /home/advil/.cargo/registry/src/github.com-1ecc6299db9ec823/axum-0.4.8/src/routing/method_routing.rs:394:1
    |
394 | top_level_handler_fn!(get, GET);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `axum::routing::get`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

I know the await probably has a hand in this because if I comment out the ws.send(Message::Text(query.command.clone())).await.unwrap(); line it runs fine.
But if I call an async function the error comes back:

async fn handle_run(query: Query<Parameters>, Extension(websockets): Extension<WebSockets>) {
    if let Ok(mut ws_connections) = websockets.lock() {
        for ws in ws_connections.iter_mut() {
            // ws.send(Message::Text(query.command.clone())).await.unwrap();
        }
        test().await;
    }
}
async fn test() {}

The error only occurs when I put the call inside the if statement though?
Not sure if that means a combination of the mutex locking and await messing it up.

Note: the purpose of this code is to send a message to all connections when it receives an http request. I'm aware that disconnected connections aren't being removed from the vector with this code.

[davidpdrsn]

See https://docs.rs/axum/latest/axum/handler/index.html#debugging-handler-type-errors in particular the hint about debug_handler.

[advilm]

Alright, I have taken a look at that, but I sadly cannot figure out what am I doing that Handler isn't satisfied with.

Are async fns.

My function is async

Take no more than 16 arguments that all implement FromRequest.

I don't have more than 16 arguments

Returns something that implements IntoResponse.

I'm not explicitly returning anything so I don't think this is the issue

If a closure is used it must implement Clone + Send and be 'static.

I'm not using a closure

Returns a future that is Send. The most common way to accidentally make a future !Send is to hold a !Send type across an await.

I'm not really sure what this means, but I'm not explicitly returning anything so I don't think this is it either. Actually, after some thinking it might be this one? Since an async function returns a future and I'm making the function wait with my .await. I don't understand why this is an issue or how to fix it though.

[davidpdrsn]

Did you try the debug_handler macro? It's designed to improve errors like this.

[advilm]

Ah, I tried it right now and it gave me "error: future cannot be sent between threads safely."
The problem was using std::sync::Mutex with async code. I fixed it by switching to futures::lock::Mutex as instructed by this stack overflow post.

Thank you for your help.

[filipmacek]

@advilm Yes, you are right, it was bugging me too. Idea is to use Mutex from futures or tokio because they are designed for async code and don't block thread when locking.