How do I read and mutate the HttpResponse<B> in a Service<ServiceRequest> middleware?

[jsoneaday]

In this code I would like to update the response body, the res variable towards bottom of code, which is of type B. After a check for its content type I would like to take the json response deserialize it into the rust type and mutate the data. Similar action is successful with the req but cannot figure out how to do it with the res. Is there no way?

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

    forward_ready!(next_service);

    fn call(&self, mut req: ServiceRequest) -> Self::Future {  
        let fut = self.next_service.clone();

        Box::pin(async move {
            let body_original = req.extract::<Bytes>().await.unwrap();

            if req.content_type() == ContentType::json().0 {                               
                let body_str = String::from_utf8(body_original.to_vec());
                match body_str {
                    Ok(str) => {
                        let req_body_json: Result<RequestBodyJson, serde_json::Error> = serde_json::from_str(&str);
                        match req_body_json {
                            Ok(mut rbj) => {
                                rbj.msg = format!("{}. how are you?", rbj.msg);
                                let new_rbj_result = serde_json::to_string(&rbj);
                                let new_rbj_str = new_rbj_result.unwrap().clone();
                                let body_final = Bytes::from(new_rbj_str.clone());
                                req.set_payload(bytes_to_payload(body_final));
                            },
                            Err(_) => println!("Not of type RequestBodyJson, continuing")
                        };
                    },
                    Err(_) => println!("Payload not string, continuing")
                };
            }            
            
            let res = fut.call(req).await?;
            Ok(res)
        })
    }
}

[jsoneaday]

I've managed to get a lot closer now, but my return type is now screwed up and I get the error shown because HttpResponse::build is returning a HttpResponse, but my return type is B.

if and else have incompatible types
expected enum Result<ServiceResponse<BoxBody>, _>
found enum Result<ServiceResponse<B>, _>

impl<S, B> Service<ServiceRequest> for ReqAppenderMiddlewareExecutor<S> 
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
    S::Future: 'static,
    B: MessageBody + 'static
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(next_service);

    fn call(&self, mut req: ServiceRequest) -> Self::Future {  
        let fut = self.next_service.clone();

        Box::pin(async move {
            let request = req.request().clone();
            let body_original = req.extract::<Bytes>().await.unwrap();

            if req.content_type() == ContentType::json().0 {                               
                let body_str = String::from_utf8(body_original.to_vec());
                match body_str {
                    Ok(str) => {
                        let req_body_json: Result<RequestMessage, serde_json::Error> = serde_json::from_str(&str);
                        match req_body_json {
                            Ok(mut rbj) => {
                                rbj.msg = format!("{}. I modified the request.", rbj.msg);
                                let new_rbj_result = serde_json::to_string(&rbj);
                                let new_rbj_str = new_rbj_result.unwrap();
                                let body_final = Bytes::from(new_rbj_str);
                                req.set_payload(bytes_to_payload(body_final));
                            },
                            Err(_) => {
                                println!("Not of type RequestMessage, continuing");
                            }
                        };
                    },
                    Err(_) => {
                        println!("Payload not string, continuing");
                    }
                };
            }            
            
            let res = fut.call(req).await?;
            if res.headers().contains_key("content-type") {
                let status = res.status();
                let body = res.into_body();
                let body_bytes_result = body.try_into_bytes();             
                match body_bytes_result {
                    Ok(body_bytes) => {
                        let body_str = String::from_utf8(body_bytes.to_vec());
                        match body_str {
                            Ok(str) => {
                                let body_obj: Result<ResponseMessage, serde_json::Error> = serde_json::from_str(&str);
                                match body_obj {
                                    Ok(mut body_obj) => {
                                        body_obj.msg = format!("{}. I modified the response.", body_obj.msg);
                                        let resp = HttpResponse::build(status)
                                            .content_type("application/json")
                                            .body(body_obj);                                        
                                        let response = req.into_response(resp);
                                        Ok(response)
                                    },
                                    Err(_) => {
                                        println!("Not of type ResponseMessage, continuing");
                                        Err(MiddleWareError.into()) 
                                    }
                                }
                            },
                            Err(_) => {
                                println!("To string failed");
                                Err(MiddleWareError.into()) 
                            }
                        }                          
                    },
                    Err(_) => {
                        println!("Payload not string, continuing");
                        Err(MiddleWareError.into()) 
                    }
                }
            } else {
                Ok(req.into_response(*res.response()))
            }
        })
    }
}

[RoDmitry]

Try this:

Box::pin(async move {
            let res = fut.call(req).await?;
            if just_pass {
                return Ok(res.map_into_left_body());
            }
            ...
            body_obj.msg = format!("{}. I modified the response.", body_obj.msg);

            let response = HttpResponse::build(status)
                .content_type("application/json")
                .body(body_obj)               
                .finish() // maybe it's extra
                // constructed responses map to "right" body
                .map_into_right_body();

            let (request, _pl) = req.into_parts();

            Ok(ServiceResponse::new(request, response))
        })

req.into_parts() is probably wrong, but hope it helps.

Also too many match, try let body_bytes = body_bytes_result.map_err(|_e| MiddleWareError.into())?

[jsoneaday]

There's no finish function showing up, but my call function's sig is not returning an EitherBody and not sure Transform would accept it.

[jsoneaday]

The main thing I don't get is that BoxBody implements MessageBody and the B is constrained to need an impl of MessageBody. So then why isn't a return of BoxBody sufficient to be B?

[RoDmitry]

B is constrained to need an impl of MessageBody

Actually MessageBody is not required. My middleware works without it.

[jsoneaday]

I needed MessageBody so I could run try_into_bytes.I need to be able to get the original body value so I can update it.

[jsoneaday]

I've almost got it to work by using EitherBody, but now it gets stuck on an infinite loop on the poll_next function of the impl MessageBody for ResponseMessage. But I need this impl so I can do try_into_bytes. Any ideas?

impl<S, B> Service<ServiceRequest> for ReqAppenderMiddlewareExecutor<S> 
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
    S::Future: 'static,
    B: MessageBody + 'static
{
    type Response = ServiceResponse<EitherBody<B, BoxBody>>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(next_service);

    fn call(&self, mut req: ServiceRequest) -> Self::Future {  
        let fut = self.next_service.clone();

        Box::pin(async move {
            let body_original = req.extract::<Bytes>().await.unwrap();

            if req.content_type() == ContentType::json().0 {                               
                let body_str = String::from_utf8(body_original.to_vec());
                match body_str {
                    Ok(str) => {
                        let req_body_json: Result<RequestMessage, serde_json::Error> = serde_json::from_str(&str);
                        match req_body_json {
                            Ok(mut rbj) => {
                                rbj.msg = format!("{}. I modified the request.", rbj.msg);
                                let new_rbj_result = serde_json::to_string(&rbj);
                                let new_rbj_str = new_rbj_result.unwrap();
                                let body_final = Bytes::from(new_rbj_str);
                                req.set_payload(bytes_to_payload(body_final));
                            },
                            Err(_) => println!("Not of type RequestMessage, continuing")
                        };
                    },
                    Err(_) => println!("Payload not string, continuing")
                };
            }            
            
            let res = fut.call(req).await?;
            if res.headers().clone().contains_key("content-type") {
                let status = res.status();
                let headers = res.headers().clone();
                let request = res.request().clone();
                let body = res.into_body().boxed();
                
                let body_bytes_result = body.try_into_bytes();             
                match body_bytes_result {
                    Ok(body_bytes) => {
                        let body_str = String::from_utf8(body_bytes.to_vec());
                        match body_str {
                            Ok(str) => {
                                let body_obj_result: Result<ResponseMessage, serde_json::Error> = serde_json::from_str(&str);
                                match body_obj_result {
                                    Ok(mut body_obj) => {
                                        body_obj.msg = format!("{}. I modified the response.", body_obj.msg);
                                        
                                        let mut resp = HttpResponse::build(status)
                                            .content_type("application/json")
                                            .body(body_obj);
                                        headers.iter().for_each(|(key, value)| {
                                            resp.headers_mut().insert(key.clone(), value.clone());
                                        });                                        
                                        let new_res = ServiceResponse::new(request, resp);
                                        Ok(new_res.map_into_right_body())
                                    },
                                    Err(_) => Err(MiddleWareError.into()) 
                                }
                            },
                            Err(_) => Err(MiddleWareError.into()) 
                        }                          
                    },
                    Err(_) => Err(MiddleWareError.into()) 
                }
            } else {
                Ok(res.map_into_left_body())
            }
        })
    }
}

#[derive(Deserialize, Serialize, Clone)]
pub struct RequestMessage {
    pub msg: String
}

#[derive(Deserialize, Serialize, Clone)]
pub struct ResponseMessage {
    pub msg: String
}
impl MessageBody for ResponseMessage {
    type Error = Infallible;

    fn size(&self) -> actix_http::body::BodySize {
        actix_http::body::BodySize::Sized(self.msg.len() as u64)
    }

    fn poll_next(
        self: Pin<&mut Self>,
        _cx: &mut Context<'_>,
    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        std::task::Poll::Ready(Some(Ok(actix_web::web::Bytes::from(self.msg.clone()))))
    }   
}

[robjtede]

Firstly, using EitherBody is the right solution here, following a similar pattern to this case from the examples repo.

Check out the docs for poll_next to see what should be returned. In this case, you have an infinite loop because you never return Ok(None).

Though, I'd advise against using a custom impl here, since String implements MessageBody already.

[jsoneaday]

Yeah I had to switch to using the json function instead of body for HttpResponse building, but yes removing the impl MessageBody works. Thank you.