Middleware error: Service<axum::http::Request<axum::body::Body>> is not satisfied

[shengsheng]

Summary

routers.layer(ServiceBuilder::new()
    // Handle errors from middleware
    .layer(HandleErrorLayer::new(handle_error))
    .concurrency_limit(1024)
    .layer(TraceLayer::new_for_http()))

error[E0277]: the trait bound HandleError<ConcurrencyLimit<tower_http::trace::Trace<Route, SharedClassifier<ServerErrorsAsFailures>>>, fn(Box<(dyn StdError + Send + Sync + 'static)>) -> impl Future<Output = impl axum::IntoResponse> {app::handle_error}, _>: Service<axum::http::Request<axum::body::Body>> is not satisfied

If I add .load_shed() before concurrency_limit(), the error disappears.
I presume this is because load_shed() returns an error, while concurrency_limit() does not.

My Question are:

1. How to determine whether a middleware returns an error or not?
2. What does "Service<axum::http::Request<axum::body::Body>> is not satisfied" mean in this context? Why report this error?

My question actually stems from the situation below. I presume that the error output below and the above error are caused by the same issue:

When I test the crate axum-login oauth2 example,
https://github.com/maxcountryman/axum-login/blob/v0.13.1/examples/oauth2/src/web/app.rs#L61-L65

Code in examples/oauth2/src/web/app.rs#L61-L65:

let app = protected::router()
    .route_layer(login_required!(Backend, login_url = "/login"))
    .merge(auth::router())
    .merge(oauth::router())
    .layer(auth_layer);

When following the axum document's suggestion to apply multiple middleware at once, I moved auth_layer into ServiceBuilder:

ServiceBuilder::new()
    // Handle errors from middleware
    .layer(HandleErrorLayer::new(handle_error))
    .layer(auth_layer)
    .load_shed()
    .concurrency_limit(1024)
    .timeout(Duration::from_secs(10))
    .layer(TraceLayer::new_for_http()),

Output:

error[E0277]: the trait bound `HandleError<tower_cookies::service::CookieManager<SessionManager<AuthManager<LoadShed<ConcurrencyLimit<tower::timeout::Timeout<tower_http::trace::Trace<Route, SharedClassifier<ServerErrorsAsFailures>>>>>, users::Backend>, MemoryStore>>, fn(Box<(dyn StdError + Send + Sync + 'static)>) -> impl std::future::Future<Output = impl askama_axum::IntoResponse> {app::handle_error}, _>: Service<axum::http::Request<axum::body::Body>>` is not satisfied
   --> src/app/mod.rs:141:17
    |
140 |               .layer(
    |                ----- required by a bound introduced by this call
141 | /                 ServiceBuilder::new()
142 | |                     // Handle errors from middleware
143 | |                     .layer(HandleErrorLayer::new(handle_error))
144 | |                     .layer(auth_layer)
...   |
147 | |                     .timeout(Duration::from_secs(10))
148 | |                     .layer(TraceLayer::new_for_http()),
    | |______________________________________________________^ the trait `Service<axum::http::Request<axum::body::Body>>` is not implemented for `HandleError<tower_cookies::service::CookieManager<SessionManager<AuthManager<LoadShed<ConcurrencyLimit<tower::timeout::Timeout<tower_http::trace::Trace<Route, SharedClassifier<ServerErrorsAsFailures>>>>>, users::Backend>, MemoryStore>>, fn(Box<(dyn StdError + Send + Sync + 'static)>) -> impl std::future::Future<Output = impl askama_axum::IntoResponse> {app::handle_error}, _>`
    |
    = help: the following other types implement trait `Service<Request>`:
              HandleError<S, F, ()>
              HandleError<S, F, (T1,)>
              HandleError<S, F, (T1, T2)>
              HandleError<S, F, (T1, T2, T3)>
              HandleError<S, F, (T1, T2, T3, T4)>
              HandleError<S, F, (T1, T2, T3, T4, T5)>
              HandleError<S, F, (T1, T2, T3, T4, T5, T6)>
              HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7)>
            and 9 others
note: the method call chain might not have had the expected associated types
   --> src/app/mod.rs:143:22
    |
141 |                 ServiceBuilder::new()
    |                 --------------------- this expression has type `ServiceBuilder<Identity>`
142 |                     // Handle errors from middleware
143 |                     .layer(HandleErrorLayer::new(handle_error))
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Layer::Service` is `HandleError<_, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
144 |                     .layer(auth_layer)
    |                      ----------------- `Layer::Service` remains `HandleError<CookieManager<SessionManager<AuthManager<_, Backend>, MemoryStore>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
145 |                     .load_shed()
    |                      ----------- `Layer::Service` remains `HandleError<CookieManager<SessionManager<AuthManager<LoadShed<_>, Backend>, MemoryStore>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
146 |                     .concurrency_limit(1024)
    |                      ----------------------- `Layer::Service` remains `HandleError<CookieManager<SessionManager<AuthManager<LoadShed<ConcurrencyLimit<_>>, Backend>, MemoryStore>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
147 |                     .timeout(Duration::from_secs(10))
    |                      -------------------------------- `Layer::Service` remains `HandleError<CookieManager<SessionManager<AuthManager<LoadShed<ConcurrencyLimit<Timeout<_>>>, Backend>, MemoryStore>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
148 |                     .layer(TraceLayer::new_for_http()),
    |                      --------------------------------- `Layer::Service` remains `HandleError<CookieManager<SessionManager<AuthManager<LoadShed<ConcurrencyLimit<Timeout<Trace<_, SharedClassifier<ServerErrorsAsFailures>>>>>, Backend>, MemoryStore>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = impl IntoResponse> {handle_error}, _>` here
note: required by a bound in `Router::<S>::layer`
    |
275 |     pub fn layer<L>(self, layer: L) -> Router<S>
    |            ----- required by a bound in this associated function
...
278 |         L::Service: Service<Request> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^ required by this bound in `Router::<S>::layer`

For more information about this error, try `rustc --explain E0277`.

axum version

0.7.4

[davidpdrsn]

The issue is that you're not using any fallible middleware so there are no errors to handle with HandleErrorLayer. ConcurrencyLimit and TraceLayer aren't fallilbe. HandleErrorLayer is for service level errors, not HTTP errors such as returning 500.

[shengsheng]

Thank you!
How to determine whether a middleware returns an error or not?
What does "Service<axum::http::Requestaxum::body::Body> is not satisfied" mean in this context?