How to get an endpoint's actual response in a middleware?

[danilhendrasr]

Hi, I'm new to Actix Web and Rust in general and I'm trying to create a custom middleware to cache endpoint responses using Redis. My approach is that I'll retrieve the endpoint's response and store it in redis.

impl<'a, S, B> Service<ServiceRequest> for SomethingMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static + std::fmt::Debug,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        println!("Hi from start. You requested: {}", req.path());
        let req_path = req.path().to_owned();
        let req_queries = format!("?{}", req.query_string().to_owned());
        let redis_key = format!("{req_path}{req_queries}");

        let redis_client = req.app_data::<web::Data<redis::Client>>().unwrap();
        let mut redis_conn = redis_client.get_connection().unwrap();

        let fut = self.service.call(req);

        Box::pin(async move {
            let res = fut.await?;

            let _: Result<(), redis::RedisError> =
                redis_conn.set(&redis_key, &format!("{:?}", res.response().body()));

            println!("Hi from response");
            println!("{:#?}", res.response().body());
            Ok(res)
        })
    }
}

Currently I've successfully stored the response, but it's in the Debug form.

How do I get the actual response body? I'm using actix-web = "4.0.1" by the way.

[robjtede]

actix_web::body::to_bytes().await is made for this purpose but you should only use this in a middleware if you are confident that no responses use streaming bodies.

Since it requires ownership of the body, you'll need to "replace" the body, read it and then, put the body back later.

type Response = ServiceResponse<Bytes>;

// [snip]

let (req, res)  = res.into_parts(());
let (res, body) = res.into_parts();
let body_bytes = actix_web::body::to_bytes(body).await.ok().unwrap();
println!("{:?}", body_bytes);
let res = res.set_body(body_bytes);
let res = ServiceResponse::new(req, res);

[danilhendrasr]

I've tried implementing it but got the following error:

type mismatch resolving `<impl futures_util::Future<Output = std::result::Result<actix_web::dev::ServiceResponse<std::result::Result<actix_web::web::Bytes, <B as actix_web::body::MessageBody>::Error>>, _>> as futures_util::Future>::Output == std::result::Result<actix_web::dev::ServiceResponse<actix_web::web::Bytes>, actix_web::Error>`
expected enum `std::result::Result<actix_web::dev::ServiceResponse<actix_web::web::Bytes>, actix_web::Error>`
   found enum `std::result::Result<actix_web::dev::ServiceResponse<std::result::Result<actix_web::web::Bytes, <B as actix_web::body::MessageBody>::Error>>, _>`
required for the cast to the object type `dyn futures_util::Future<Output = std::result::Result<actix_web::dev::ServiceResponse<actix_web::web::Bytes>, actix_web::Error>>

Here's the full middleware code:

pub struct SomethingMiddlewareFactory;

impl<S> Transform<S, ServiceRequest> for SomethingMiddlewareFactory
where
    S: Service<ServiceRequest, Response = ServiceResponse<Bytes>, Error = Error>,
    S::Future: 'static,
{
    type Response = ServiceResponse<Bytes>;
    type Error = Error;
    type InitError = ();
    type Transform = SomethingMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(SomethingMiddleware { service }))
    }
}

pub struct SomethingMiddleware<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for SomethingMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static + std::fmt::Debug + actix_web::body::MessageBody,
{
    type Response = ServiceResponse<Bytes>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        println!("Hi from start. You requested: {}", req.path());
        let req_path = req.path().to_owned();
        let req_queries = format!("?{}", req.query_string().to_owned());
        let redis_key = format!("{req_path}{req_queries}");

        let redis_client = req.app_data::<web::Data<redis::Client>>().unwrap();
        let mut redis_conn = redis_client.get_connection().unwrap();

        let fut = self.service.call(req);

        Box::pin(async move {
            let res = fut.await?;

            let _: Result<(), redis::RedisError> =
                redis_conn.set(&redis_key, &format!("{:?}", res.response().body()));

            let (req, res) = res.into_parts();
            let (res, body) = res.into_parts();
            let body_bytes = actix_web::body::to_bytes(body).await;
            println!("{:?}", body_bytes);
            let res = res.set_body(body_bytes);
            let res = ServiceResponse::new(req, res);
            println!("{:?}", body);
            Ok(res)
        })
    }
}

Any idea what am I doing wrong?

[robjtede]

updated my example code

- let body_bytes = actix_web::body::to_bytes(body).await;
+ let body_bytes = actix_web::body::to_bytes(body).await.unwrap();

[danilhendrasr]

Now I got the following error:

`<B as actix_web::body::MessageBody>::Error` doesn't implement `std::fmt::Debug`
the trait `std::fmt::Debug` is not implemented for `<B as actix_web::body::MessageBody>::Error`

It seems I need to implement the Debug trait for the error type, but how do I implement a trait for a type which depends on an argument type? Because it's not possible inside of an impl block.

[robjtede]

.ok().unwrap() avoids this usually

[danilhendrasr]

That does it, thanks a lot.