middleware gRPC usage fails after migrating from axum 0.6.20 to 0.7.4?

[CloverOS]

Summary

Version

axum: 0.7.4
hyper:1.1.0
tower:0.4.13
tower-http:0.5.0

Description

Version: axum 0.6.20

Code:

pub async fn auth_token<B>(
    State(service_context): State<ServiceContext>,
    request: Request<B>,
    next: Next<B>,
) -> Result<Response, StatusCode> {
    let token = if let Some(token_str) = get_token(request.headers()) {
        token_str
    } else {
        return Err(StatusCode::UNAUTHORIZED);
    };
    let mut token_client = service_context.token_client.clone();
    let resp = token_client
        .auth_token(AuthReq {
            token: token.to_string(),
            method: request.method().to_string(),
            path: request.uri().path().to_string(),
        })
        .await;
    match resp {
        Ok(ok_resp) => {
            if ok_resp.into_inner().pass {
                return Ok(next.run(request).await);
            }
        }
        _ => {}
    };
    Err(StatusCode::UNAUTHORIZED)
}

// Route registration code:
pub fn get_routes(service_context: &ServiceContext) -> Router {
    Router::new()
        .route(
            "/test",
            get(test_handler),
        )
        .route_layer(axum::middleware::from_fn_with_state(
            service_context.clone(),
            crate::layers::auth::auth_token,
        ))
        .with_state(service_context.clone())
}

The aforementioned code works perfectly, but after upgrading to axum 0.7.4 (along with hyper to 1.1.0 and tower-http to 0.5.0), I updated my code as follows:

use axum::http::{HeaderMap, StatusCode};
use axum::{extract::Request, extract::State, middleware::Next, response::Response};
use tower::{Layer, Service};

use token_rpc::token::AuthReq;

use crate::ServiceContext;
pub async fn auth_token(
    State(service_context): State<ServiceContext>,
    request: Request,
    next: Next,
) -> Result<Response, StatusCode> {
    // ... [rest of the auth_token function remains unchanged] ...
}

// Route registration code remains unchanged

However, after the update, I encounter the following error:

error[E0277]: the trait bound `axum::middleware::FromFn<fn(State<ServiceContext>, axum::http::Request<axum::body::Body>, Next) -> impl Future<Output = Result<axum::http::Response<axum::body::Body>, axum::http::StatusCode>> {layers::auth::auth_token}, ServiceContext, Route, _>: Service<axum::http::Request<axum::body::Body>>` is not satisfied
   --> test\src\api\routes.rs:14:22
    |
14  |           .route_layer(axum::middleware::from_fn_with_state(
    |  __________-----------_^
    | |          |
    | |          required by a bound introduced by this call
15  | |             service_context.clone(),
16  | |             crate::layers::auth::auth_token,
17  | |         ))
    | |_________^ the trait `Service<axum::http::Request<axum::body::Body>>` is not implemented for `axum::middleware::FromFn<fn(State<ServiceContext>, axum::http::Request<axum::body::Body>, Next) -> impl Future<Output = Result<axum::http::Response<axum::body::Body>, axum::http::StatusCode>> {layers::auth::auth_token}, ServiceContext, Route, _>`
    |
    = help: the following other types implement trait `Service<Request>`:
              axum::middleware::FromFn<F, S, I, (T1,)>
              axum::middleware::FromFn<F, S, I, (T1, T2)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>
              axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>
            and 8 others
note: required by a bound in `axum::Router::<S>::route_layer`
   --> xxx\srcrouting\mod.rs:296:21
    |
293 |     pub fn route_layer<L>(self, layer: L) -> Self
    |            ----------- required by a bound in this associated function
...
296 |         L::Service: Service<Request> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^ required by this bound in `Router::<S>::route_layer`

When I removed the token_client.auth_token() call, the error was no longer present.

How can I comply with this trait requirement? (I apologize as I am new to Rust and somewhat confused with this design.)

axum version

0.7.4

[davidpdrsn]

Not really sure what could be wrong.

Are you perhaps using another library that’s not compatible with axum 0.7?

[CloverOS]

emmm.... just use tonic "0.10.2" to gen a grpc client ,and the problem is that it was working fine before the upgrade. i don't understand why trait is not satisfied

[davidpdrsn]

Can you post a reproduction script that I can download and cargo check?

[CloverOS]

my cargo.toml:

[package]
name = "fun_ai"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
clap = { version = "4.4.8", features = ["derive"] }
axum = { version = "0.7.4" }
hyper = { version = "1.1.0", features = ["full"] }
tower = { version = "0.4.13", features = ["util", "filter"] }
tower-http = { version = "0.5.0", features = ["full"] }
tokio = { version = "1.33.0", features = ["full"] }
tracing-subscriber = { version = "0.3.18", features = ["env-filter", "time"] }
tracing = { version = "0.1.40" }
tracing-appender = { version = "0.2.2" }
time = { version = "0.3.30", features = ["macros"] }
sea-orm = { version = "0.12.4", features = ["sqlx-postgres", "runtime-tokio-rustls", "macros"] }
serde = { version = "1.0.192", features = ["derive"] }
hyper-util = { version = "0.1.2", features = ["full"] }
anyhow = "1.0.75"

micro-rs = { path = "../../micro-rs/micro-rs" }
model = { path = "../model" }
tonic = "0.10.2"
prost = "0.12.3"

token_rpc = { path = "../token_rpc" }

utoipa = "4.1.0"
headers = "0.4.0"
futures-util = "0.3.29"

about ServerContext:

#[derive(Clone)]
pub struct ServiceContext {
    pub pg_db: DatabaseConnection,
    pub config: ServiceConfig,
    pub token_client: TokenClient<Timeout<Channel>>,
}

TokenClient:

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AuthReq {
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub method: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AuthResp {
    #[prost(bool, tag = "1")]
    pub pass: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAdminResp {
    #[prost(bool, tag = "1")]
    pub pass: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTokenDataReq {
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TokenData {
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClearAllLoginReq {
    #[prost(string, tag = "1")]
    pub clear: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClearAllLoginResp {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Empty {}
/// Generated client implementations.
pub mod token_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct TokenClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl TokenClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> TokenClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> TokenClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            TokenClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn auth_token(
            &mut self,
            request: impl tonic::IntoRequest<super::AuthReq>,
        ) -> std::result::Result<tonic::Response<super::AuthResp>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/token.Token/AuthToken");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("token.Token", "AuthToken"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_admin(
            &mut self,
            request: impl tonic::IntoRequest<super::Empty>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateAdminResp>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/token.Token/UpdateAdmin");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("token.Token", "UpdateAdmin"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_token_data(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTokenDataReq>,
        ) -> std::result::Result<tonic::Response<super::TokenData>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/token.Token/GetTokenData");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("token.Token", "GetTokenData"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_all_login(
            &mut self,
            request: impl tonic::IntoRequest<super::ClearAllLoginReq>,
        ) -> std::result::Result<
            tonic::Response<super::ClearAllLoginResp>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/token.Token/ClearAllLogin",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("token.Token", "ClearAllLogin"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod token_server {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with TokenServer.
    #[async_trait]
    pub trait Token: Send + Sync + 'static {
        async fn auth_token(
            &self,
            request: tonic::Request<super::AuthReq>,
        ) -> std::result::Result<tonic::Response<super::AuthResp>, tonic::Status>;
        async fn update_admin(
            &self,
            request: tonic::Request<super::Empty>,
        ) -> std::result::Result<tonic::Response<super::UpdateAdminResp>, tonic::Status>;
        async fn get_token_data(
            &self,
            request: tonic::Request<super::GetTokenDataReq>,
        ) -> std::result::Result<tonic::Response<super::TokenData>, tonic::Status>;
        async fn clear_all_login(
            &self,
            request: tonic::Request<super::ClearAllLoginReq>,
        ) -> std::result::Result<
            tonic::Response<super::ClearAllLoginResp>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct TokenServer<T: Token> {
        inner: _Inner<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    struct _Inner<T>(Arc<T>);
    impl<T: Token> TokenServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            let inner = _Inner(inner);
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for TokenServer<T>
    where
        T: Token,
        B: Body + Send + 'static,
        B::Error: Into<StdError> + Send + 'static,
    {
        type Response = http::Response<tonic::body::BoxBody>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            let inner = self.inner.clone();
            match req.uri().path() {
                "/token.Token/AuthToken" => {
                    #[allow(non_camel_case_types)]
                    struct AuthTokenSvc<T: Token>(pub Arc<T>);
                    impl<T: Token> tonic::server::UnaryService<super::AuthReq>
                    for AuthTokenSvc<T> {
                        type Response = super::AuthResp;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AuthReq>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as Token>::auth_token(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = AuthTokenSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/token.Token/UpdateAdmin" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateAdminSvc<T: Token>(pub Arc<T>);
                    impl<T: Token> tonic::server::UnaryService<super::Empty>
                    for UpdateAdminSvc<T> {
                        type Response = super::UpdateAdminResp;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Empty>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as Token>::update_admin(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = UpdateAdminSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/token.Token/GetTokenData" => {
                    #[allow(non_camel_case_types)]
                    struct GetTokenDataSvc<T: Token>(pub Arc<T>);
                    impl<T: Token> tonic::server::UnaryService<super::GetTokenDataReq>
                    for GetTokenDataSvc<T> {
                        type Response = super::TokenData;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetTokenDataReq>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as Token>::get_token_data(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = GetTokenDataSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/token.Token/ClearAllLogin" => {
                    #[allow(non_camel_case_types)]
                    struct ClearAllLoginSvc<T: Token>(pub Arc<T>);
                    impl<T: Token> tonic::server::UnaryService<super::ClearAllLoginReq>
                    for ClearAllLoginSvc<T> {
                        type Response = super::ClearAllLoginResp;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ClearAllLoginReq>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as Token>::clear_all_login(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = ClearAllLoginSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        Ok(
                            http::Response::builder()
                                .status(200)
                                .header("grpc-status", "12")
                                .header("content-type", "application/grpc")
                                .body(empty_body())
                                .unwrap(),
                        )
                    })
                }
            }
        }
    }
    impl<T: Token> Clone for TokenServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    impl<T: Token> Clone for _Inner<T> {
        fn clone(&self) -> Self {
            Self(Arc::clone(&self.0))
        }
    }
    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "{:?}", self.0)
        }
    }
    impl<T: Token> tonic::server::NamedService for TokenServer<T> {
        const NAME: &'static str = "token.Token";
    }
}

If possible, please tell me what else you need.

[davidpdrsn]

I need all the code (or some kind of repro), otherwise I can't cargo check it.