How to implement wrapper function that implements Handler?

[muusbolla]

edit: Solution here: #1082

Like #1052, I was inspired by https://www.fpcomplete.com/blog/axum-hyper-tonic-tower-part4/ to create a combined Tonic/Axum server. However I want to take it a step further by just having a single implementation for each RPC (the GRPC handler) and having Axum endpoints be wrappers around the GRPC handlers. For the Axum endpoint, this involves accepting JSON, deserializing into the GRPC type, calling the Tonic handler, then re-serializing the result back to JSON. This works fine with a manually crafted wrapper function like this:

struct MyHandler;

#[async_trait]
impl Echo for MyGrpcHandler {
    async fn echo(
        &self,
        request: tonic::Request<EchoRequest>,
    ) -> Result<tonic::Response<EchoReply>, tonic::Status> {
        Ok(tonic::Response::new(EchoReply {
            message: format!("Echoing back: {}", request.get_ref().message),
        }))
    }
}

async fn EchoHandlerWrapper(Json(body): Json<EchoRequest>) -> Result<Json<EchoReply>, HybridError> {
    let handler = MyGrpcHandler {};
    let r = handler.echo(tonic::Request::new(body)).await;
    match r {
        Ok(r) => Ok(Json(r.into_inner())),
        Err(e) => Err(HybridError(e)) // wrap GRPC errors into HTTP errors, not relevant to this issue
    }
}

#[tokio::main]
async fn main() {
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    let axum_make_service = axum::Router::new()
        .route("/Echo", axum::handler::any(EchoHandlerWrapper))
        .into_make_service();
    let grpc_service = tonic::transport::Server::builder()
        .add_service(EchoServer::from_arc(arcHandler))
        .into_service();
    let hybrid_make_service = hybrid(axum_make_service, grpc_service);
    let server = hyper::Server::bind(&addr).serve(hybrid_make_service);
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

However, I'd like to reduce the boilerplate associated with creating a new wrapper function for each new GRPC endpoint. So I attempted to create a generic wrapper function that takes a GRPC handler and transforms it into a closure that implements axum::Handler. Due to the structure of this function, I cannot apply the #[debug_handler] macro to it. Here's where I'm at now:

// This compiles. The input func is supposed to be a GRPC handler func. The output should be compatible with axum::Handler.
fn WrapGrpcHandler<'a, ReqT, ResT, FIn, FOut> (
    func: fn(&MyHandler, tonic::Request<ReqT>) -> Pin<Box<dyn Future<Output = Result<tonic::Response<ResT>, tonic::Status>> + Send + 'a>>)
       -> impl Fn(Json<ReqT>) -> Pin<Box<dyn Future<Output = Result<Json<ResT>, HybridError>> + 'a>> where //,HandlerFn
for<'de> ReqT: serde::Deserialize<'de> + 'a,
ResT: serde::Serialize + 'a{
    move |Json(req): Json<ReqT>| {Box::pin((|Json(req): Json<ReqT>| async move {
        let handler = std::sync::Arc::new(MyHandler {});
        let r = async move { func(handler.as_ref(), tonic::Request::new(req)).await }.await;
        match r {
            Ok(r) => Ok(Json(r.into_inner())),
            Err(e) => Err(HybridError(e))
        }
    })(Json(req)))}
}

But when I try to call it with a concrete function I get very unhelpful errors, and despite my best efforts I'm not able to coerce the function pointer into the right type:

// Gives error: the trait bound `impl Fn(Json<_>)-> Pin<Box<dyn futures::Future<Output = Result<Json<_>, HybridError>>>>: Handler<_, _>` is not satisfied
// the trait `Handler<ReqBody, T>` is implemented for `axum::handler::Layered<S, T>`rustcE0277
// server-hybrid.rs(263, 25): required by a bound introduced by this call
// mod.rs(52, 8): required by a bound in `axum::handler::any`
// the trait bound `impl Fn(axum::Json<_>)-> Pin<Box<dyn futures::Future<Output = Result<axum::Json<_>, HybridError>>>>: Handler<_, _>` is not satisfied
// the trait `Handler<ReqBody, T>` is implemented for `axum::handler::Layered<S, T>`rustcE0277
// server-hybrid.rs(263, 25): required by a bound introduced by this call
// mod.rs(52, 8): required by a bound in `axum::handler::any`
let axum_make_service = axum::Router::new()
        .route("/Echo", axum::handler::any(WrapGrpcHandler(MyGrpcHandler::echo)))
        .into_make_service();



// Gives error: mismatched types
// expected fn pointer `for<'r> fn(&'r MyHandler, tonic::Request<_>) -> Pin<Box<dyn futures::Future<Output = Result<tonic::Response<_>, Status>> + std::marker::Send>>`
// found fn item `fn(&MyHandler, tonic::Request<tonic_example::echo::EchoRequest>) -> Pin<Box<dyn futures::Future<Output = Result<tonic::Response<tonic_example::echo::EchoReply>, Status>> + std::marker::Send>> {<MyHandler as Echo>::echo::<'_, '_>}`rustcE0308
let x = WrapGrpcHandler(MyHandler::echo);

Apologies in advance if this is not the right forum to ask this question. But perhaps this can still be of use to others who are trying to do this kind of thing.

[jplatte]

I don't have any suggestions for debugging, but it looks like at least part of the issue is missing auto traits: You return impl Fn(…) -> Pin<Box<dyn Future + 'a>>, which is a function-like type whose output is not Send, but that is required of handler return types. That is, you will at least have to add + Send to that dyn Future trait object. You may also be missing Send and/or 'static in other places in the type signature.

[davidpdrsn]

Rather than returning functions (that is often hard in Rust) I'd consider writing a type that implements Handler and returning that instead.

[muusbolla]

I don't think the problem is with the return type. I tried simplifying it greatly, down to a single-function wrapper that is not generic over request/response type, and rather than returning a closure, it returns the result directly. Then I try to build the closure on the outside of the wrapper manually. I am now basing this off the rest-grpc-multiplex example. I am also able to successfully attach the #[debug_handler] macro to the wrapper functions and it doesn't show any errors.

// example of the simple wrapper. it works fine
#[debug_handler]
async fn HelloWrapper(Json(body): Json<HelloRequest>) -> Result<Json<HelloReply>, HybridError> {
    let handler = GrpcServiceImpl {};
    let r = handler.say_hello(tonic::Request::new(body)).await;
    match r {
        Ok(r) => Ok(Json(r.into_inner())),
        Err(e) => Err(HybridError(e))
    }
}

// generic wrapper that is implemented only for a single request/response type.
// debug_handler doesn't error
#[debug_handler]
async fn GenericWrapper(func: fn(&GrpcServiceImpl, tonic::Request<HelloRequest>) -> tonic::codegen::Pin<Box<dyn tonic::codegen::Future<Output = Result<tonic::Response<HelloReply>, tonic::Status>> + Send>>,
    Json(body): Json<HelloRequest>) -> Result<Json<HelloReply>, HybridError> {
    let handler = GrpcServiceImpl {};
    let r = func(&handler, tonic::Request::new(body)).await;
    match r {
        Ok(r) => Ok(Json(r.into_inner())),
        Err(e) => Err(HybridError(e))
    }
}


#[tokio::main]
async fn main() {
    // I'm able to convert the basic wrapper into a service
    let rest = Router::new().route("/Hello", axum::routing::any(HelloWrapper));

    // basic closure over the raw implementation. works fine
    let h = GrpcServiceImpl {};
    let a = Box::pin((|| async {h.say_hello(tonic::Request::<HelloRequest>::new(HelloRequest {name:"asdf".to_string()}))})());

    // closure over basic wrapper. it works fine also
    let b = Box::pin((|| async {HelloWrapper(Json(HelloRequest {name: "asdf".to_string()})).await})());

    // errors on the type of say_hello
    let c = Box::pin((|| async {GenericWrapper(GrpcServiceImpl::say_hello, Json(HelloRequest {name: "asdf".to_string()})).await})());

    // just attempting to pass the say_hello function to the GenericWrapper, without all the async await stuff, gives the same error
    let d = GenericWrapper(GrpcServiceImpl::say_hello, Json(HelloRequest {name: "asdf".to_string()}));
}

When I inspect the return type inlays with rust-analyzer, it says that b and c are both the same type, so I think I have those closures implemented correctly:
Pin<Box<impl Future<Output = Result<Json, HybridError>>>>

But c and d both give the same error on the GrpcServiceImpl::say_hello parameter:

mismatched types
expected fn pointer `for<'r> fn(&'r GrpcServiceImpl, tonic::Request<_>) -> Pin<Box<(dyn futures::Future<Output = Result<tonic::Response<helloworld::HelloReply>, Status>> + std::marker::Send + 'static)>>`
   found fn pointer `fn(&GrpcServiceImpl, tonic::Request<_>) -> Pin<Box<dyn futures::Future<Output = Result<tonic::Response<helloworld::HelloReply>, Status>> + std::marker::Send>>`rustc[E0308](https://doc.rust-lang.org/error-index.html#E0308)

This is pretty much exactly the same as the original error, but it's clear now that it isn't tied to the return type of the function.

[jplatte]

I don't see how you gather that it's not about the return type from that. To me it looks like the main remaining problem is likely the missing + 'static after dyn Future + Send.

[muusbolla]

You're right. I should have clarified, the issue is not with the return type of the wrapping function, but with the wrapped function. The problem is that the #[async_trait] macro generates a Pin<Box> without an explicit lifetime, but the func parameter to my wrapper function demands a 'static lifetime. And a func that satisfies my wrapper function doesn't implement the trait that the tonic generator creates, so in order to make both work, I have to implement an inner function with a 'static lifetime and wrap it for the GRPC trait implementation. Here is a working example:

#[derive(Default)]
struct GrpcServiceImpl {}

impl GrpcServiceImpl {
    // manually write code that's equivalent to that generated by #[async_trait]
    // except add the 'static lifetime parameter
    fn inner_hello(
        &self,
        request: tonic::Request<HelloRequest>,
    ) -> tonic::codegen::Pin<Box<dyn tonic::codegen::Future<Output = Result<tonic::Response<HelloReply>, tonic::Status>> + Send + 'static>> {
        async fn run(request: tonic::Request<HelloRequest>) -> Result<tonic::Response<HelloReply>, tonic::Status>{
            tracing::info!("Got a request from {:?}", request.remote_addr());
    
            let reply = HelloReply {
                message: format!("Hello {}!", request.into_inner().name),
            };
            Ok(TonicResponse::new(reply))
        }

        Box::pin(run(request))
    }
}

#[tonic::async_trait]
impl Greeter for GrpcServiceImpl {
    async fn say_hello(
        &self,
        request: tonic::Request<HelloRequest>,
    ) -> Result<tonic::Response<HelloReply>, tonic::Status> {
        GrpcServiceImpl::inner_hello(self, request).await
    }
}

#[tokio::main]
async fn main() {
    // build the rest service
    let rest = Router::new()
    .route("/Hello2", axum::routing::any(|Json(req): Json<HelloRequest>| async {GenericWrapper(GrpcServiceImpl::inner_hello, Json(req)).await}));
}

This does NOT succeed in meeting my primary objective of reducing boilerplate. Anyway, it's clearly not an Axum problem at this point, so I'll take up the issue with tonic or async_trait developers. Thanks for your time. Unless you can tell me how to easily coerce these function types...

[davidpdrsn]

Axum and tonic are both based on tower. So maybe you're able to express things as just tower::Service.

[takkuumi]

Have you tried using macro to solve this problem?

[davidpdrsn]

How would that work? What code would the macro expand to?

[muusbolla]

I was able to resolve the issue. Once I got the return type nailed down, I was running afoul of one of these compiler bugs:
rust-lang/rust#41078
rust-lang/rust#36582
Fixing it required making the lifetime 'r generic on the outer function rather than on the inner function, and making the referenced service object static, which is for the best anyway since then I can pass the same service object to both Tokio and the wrapper function.

See PR #1082. Maybe this can be useful to others too.