Custom middleware error type exception #3150

silent-rain · 2025-01-05T14:24:11Z

silent-rain
Jan 5, 2025

Bug Report

Version

cargo tree | grep axum
├── axum v0.7.9

Platform

Linux 6.12.6-arch1-1 #1 SMP PREEMPT_DYNAMIC Thu, 19 Dec 2024 21:29:01 +0000 x86_64 GNU/Linux

Description

I have customized two middleware with almost identical structures, and both middleware use BoxError to return errors. At this point, the translation fails.
When I can compile normally using only one middleware in '. layer (layers)', please help me see how to fix errors when using multiple middleware.

//! middleware Demo1
use std::{boxed::Box, task::Poll};

use axum::{
    body::{Body, HttpBody},
    extract::Request,
    BoxError, Extension,
};
use axum_context::{ApiAuthType, Context};
use bytes::Bytes;
use futures::future::BoxFuture;
use tower::{Layer, Service};

use axum_response::ResponseErr;
use code::Error; // Custom error
use service_hub::inject::AInjectProvider;

#[derive(Clone)]
pub struct Demo1Layer;

impl<S> Layer<S> for Demo1Layer {
    type Service = DemoService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        DemoService { inner }
    }
}

#[derive(Clone)]
pub struct DemoService<S> {
    inner: S,
}

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for DemoService<S>
where
    S: Service<Request<ReqBody>, Response = axum::response::Response<ResBody>>
        + Clone
        + Send
        + 'static,
    S::Future: Send + 'static,
    S::Error: Send + Sync + std::error::Error + Into<BoxError>,
    ReqBody: Send + 'static,
    ResBody: HttpBody<Data = Bytes> + Send + 'static + From<Body>,
    ResBody::Error: Into<BoxError>,
{
    type Response = S::Response;
    type Error = BoxError;
    // `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx).map_err(Into::into)
    }

    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
        let not_ready_inner = self.inner.clone();
        let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);

        Box::pin(async move {
            let _inject_provider = match req.extensions().get::<Extension<AInjectProvider>>() {
                Some(v) => &v.0,
                None => {
                    return Err(Into::into(Box::new(ResponseErr::new(
                        Error::InjectAproviderObj,
                    ))));
                }
            };

            // ...

            if let Some(ctx) = req.extensions_mut().get_mut::<Context>() {
                ctx.set_user_id(1);
                ctx.set_user_name("demo".to_owned());
                ctx.set_api_auth_type(ApiAuthType::Openapi);
            }

            // ...

            let resp = inner.call(req).await?;
            Ok(resp)
        })
    }
}

//! middleware Demo2
use std::{boxed::Box, task::Poll};

use axum::{
    body::{Body, HttpBody},
    extract::Request,
    BoxError, Extension,
};
use axum_context::{ApiAuthType, Context};
use bytes::Bytes;
use futures::future::BoxFuture;
use tower::{Layer, Service};

use axum_response::ResponseErr;
use code::Error; // Custom error
use service_hub::inject::AInjectProvider;

#[derive(Clone)]
pub struct Demo2Layer;

impl<S> Layer<S> for Demo2Layer {
    type Service = DemoService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        DemoService { inner }
    }
}

#[derive(Clone)]
pub struct DemoService<S> {
    inner: S,
}

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for DemoService<S>
where
    S: Service<Request<ReqBody>, Response = axum::response::Response<ResBody>>
        + Clone
        + Send
        + 'static,
    S::Future: Send + 'static,
    S::Error: Send + Sync + std::error::Error + Into<BoxError>,
    ReqBody: Send + 'static,
    ResBody: HttpBody<Data = Bytes> + Send + 'static + From<Body>,
    ResBody::Error: Into<BoxError>,
{
    type Response = S::Response;
    type Error = BoxError;
    // `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx).map_err(Into::into)
    }

    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
        let not_ready_inner = self.inner.clone();
        let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);

        Box::pin(async move {
            let _inject_provider = match req.extensions().get::<Extension<AInjectProvider>>() {
                Some(v) => &v.0,
                None => {
                    return Err(Into::into(Box::new(ResponseErr::new(
                        Error::InjectAproviderObj,
                    ))));
                }
            };

            // ...

            if let Some(ctx) = req.extensions_mut().get_mut::<Context>() {
                ctx.set_user_id(1);
                ctx.set_user_name("demo".to_owned());
                ctx.set_api_auth_type(ApiAuthType::Openapi);
            }

            // ...

            let resp = inner.call(req).await?;
            Ok(resp)
        })
    }
}

use axum::{error_handling::HandleErrorLayer, http::StatusCode, BoxError, Extension, Router};
use tower::ServiceBuilder;

use app_state::AppState;
use axum_middleware::{demo1::Demo1Layer, demo2::Demo2Layer};

async fn handle_error(err: BoxError) -> (StatusCode, String) {
    (
        StatusCode::INTERNAL_SERVER_ERROR,
        format!("Unhandled internal error: {err}"),
    )
}

pub fn register() -> Router {
    let state = AppState {};

    let layers = ServiceBuilder::new()
        .layer(HandleErrorLayer::new(handle_error))
        .layer(Demo1Layer)
        .layer(Demo2Layer)
        .layer(Extension(state)); // 扩展

    Router::new().layer(layers)
}

// error info

error[E0277]: the trait bound `HandleError<axum_middleware::demo1::DemoService<axum_middleware::demo2::DemoService<AddExtension<Route, AppState>>>, fn(Box<(dyn StdError + Send + Sync + 'static)>) -> impl Future<Output = (axum::http::StatusCode, std::string::String)> {router_demo::handle_error}, _>: Service<axum::http::Request<Body>>` is not satisfied
   --> admin/src/router_demo.rs:23:25
    |
23  |     Router::new().layer(layers)
    |                   ----- ^^^^^^ the trait `Service<axum::http::Request<Body>>` is not implemented for `HandleError<DemoService<DemoService<...>>, ..., ...>`
    |                   |
    |                   required by a bound introduced by this call
    |
    = help: the following other types implement trait `Service<Request>`:
              HandleError<S, F, ()>
              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)>
              HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7, T8)>
            and 9 others
note: the method call chain might not have had the expected associated types
   --> admin/src/router_demo.rs:18:10
    |
17  |     let layers = ServiceBuilder::new()
    |                  --------------------- this expression has type `ServiceBuilder<Identity>`
18  |         .layer(HandleErrorLayer::new(handle_error))
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Layer::Service` is `HandleError<_, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = (StatusCode, String)> {handle_error}, _>` here
19  |         .layer(Demo1Layer)
    |          ----------------- `Layer::Service` remains `HandleError<DemoService<_>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = (StatusCode, String)> {handle_error}, _>` here
20  |         .layer(Demo2Layer)
    |          ----------------- `Layer::Service` remains `HandleError<DemoService<DemoService<_>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = (StatusCode, String)> {handle_error}, _>` here
21  |         .layer(Extension(state)); // 扩展
    |          ----------------------- `Layer::Service` remains `HandleError<DemoService<DemoService<AddExtension<_, AppState>>>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = (StatusCode, String)> {handle_error}, _>` here
note: required by a bound in `Router::<S>::layer`
   --> /home/one/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.9/src/routing/mod.rs:284:21
    |
281 |     pub fn layer<L>(self, layer: L) -> Router<S>
    |            ----- required by a bound in this associated function
...
284 |         L::Service: Service<Request> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^ required by this bound in `Router::<S>::layer`

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Custom middleware error type exception #3150

{{title}}

Replies: 0 comments

Select a reply

Custom middleware error type exception #3150

silent-rain Jan 5, 2025

Bug Report

Version

Platform

Description

Replies: 0 comments

silent-rain
Jan 5, 2025