Apply tower layer/middleware only on one service

[harscoet]

Hello,

I have 2 services, one for the reflection, and one for my main service
I would like to not apply my auth middleware (a tower service) on the reflection service, I can't replace this middleware using with_interceptor because my auth middleware is async

Server::builder()
  .layer(my_auth_middleware)
  .add_service(reflection_service) // <-- I would like not apply auth middleware for this service
  .add_service(my_service)

layer wraps all services so not sure how to do it

Thanks for the help!

[LucioFranco]

I would check the incoming path of the http request and match on that. Each service provides a https://docs.rs/tonic/latest/tonic/server/trait.NamedService.html trait impl that you can use to match only on that one inbound services requests.

[harscoet]

Thanks, it's not the best modular solution but it works! I created a basic tower service as example if someone needs

use tower::{Layer, Service};

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

impl<B, S> Service<hyper::Request<B>> for AuthMiddleware<S>
where
    S: Service<hyper::Request<B>>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

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

    fn call(&mut self, req: hyper::Request<B>) -> Self::Future {
        if !req
            .uri()
            .path()
            .contains("grpc.reflection.v1alpha.ServerReflection")
            // .contains(tonic_reflection::server::ServerReflectionServer::<ReflectionService>::NAME)
            // I don't know how to use the constant as ReflectionService is private in tonic-reflection crate but it's for the example
        {
            println!("Will check auth...");
        }

        self.inner.call(req)
    }
}

#[derive(Clone, Debug)]
pub struct AuthLayer;

impl<S> Layer<S> for AuthLayer {
    type Service = AuthMiddleware<S>;

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

[teimuraz]

@harscoet this is small wrapper around tonic middleware which does exactly what you need https://github.com/teimuraz/tonic-middleware

[Zhethan]

@harscoet I know this is old, but a perhaps slightly more elegant solution I found is that you can do the following

let my_auth_middleware = MyAuthLayer::new();

let my_service = GenericService::default();
let my_service = tower::ServiceBuilder::new()
    .layer(my_auth_middleware)
    .into_inner()
    .named_layer(GenericServer::new(my_service));

Server::builder()
  .add_service(reflection_service) // <-- Now reflection service shouldn't apply auth middleware
  .add_service(my_service)