Rust Axum handler issue

Question

Below is my simple Axum server code:

...
use std::sync::Mutex;
...


type Cache = Arc<Mutex<LruCache<u64, Bytes>>>;
...

#[tokio::main]
async fn main() {
    let cache: Cache = Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(100).unwrap())));

    let app = Router::new()
        .route("/image/:spec/:url", get(generate))
        .layer(ServiceBuilder::new().layer(Extension(cache)));

    ...

}

Handler code for generate function:

async fn generate(Path(Params { spec, url }): Path<Params>, Extension(cache): Extension<Cache>) 
    -> Result<(HeaderMap, Vec<u8>), StatusCode> {

    let mut hasher = DefaultHasher::new();
    url.hash(&mut hasher);
    let key = hasher.finish();

    let mut g = cache.lock().unwrap();
    let data = match g.get(&key) {
        Some(v) => {
            info!("Match cache {}", key);
            v.to_owned()
        }
        None => {
            info!("Retrieve url");
            match reqwest::get("https://www.rust-lang.org/").await {
                Ok(response) => {
                    match response.bytes().await {
                        Ok(body) => {
                            g.put(key, body.clone());
                            body
                        }
                        Err(_) => {
                            Bytes::new()
                        }
                    }
                },
                Err(_) => {
                    Bytes::new()
                }
            }
        }
    };

    let mut headers = HeaderMap::new();
    headers.insert("content-type", HeaderValue::from_static("image/jpeg"));
    Ok((headers, data.to_vec()))
}

But I got this error:

the trait bound `fn(axum::extract::Path<Params>, Extension<Arc<std::sync::Mutex<LruCache<u64, bytes::Bytes>>>>) -> impl Future<Output = Result<(HeaderMap, Vec<u8>), StatusCode>> {generate}: Handler<_, _, _>` is not satisfied
Consider using `#[axum::debug_handler]` to improve the error message
the following other types implement trait `Handler<T, S, B>`:
  <axum::handler::Layered<L, H, T, S, B, B2> as Handler<T, S, B2>>
  <MethodRouter<S, B> as Handler<(), S, B>>

I spent a long time but didn't figure it out, I think the issue is this statement: let mut g = cache.lock().unwrap();, because if I changed it to let mut g: HashMap<u64, Bytes> = HashMap::new();, the error will be gone.

Update: I change the std::sync::Mutex to tokio::sync::Mutex and it works now, I don't know the difference between these two, and why tokio::sync::Mutex can pass the compiling while std::sync::Mutex cannot.

Answer 1

For

let cache: Cache = Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(100).unwrap())));

I use the wrong Mutex which is std::sync::Mutex, after I change it to tokio::sync::Mutex, it works.