feat(body): add `Body::wrap_body` #2913

davidpdrsn · 2022-07-11T12:01:25Z

This adds Body::wrap_body which creates a Body from any impl http_body::Body. This is required in axum for tokio-rs/axum#1154.

Note that I made the PR against 0.14.x because the Body struct is undergoing some big changes on master. If you want me to make this PR against master instead and backport this to 0.14.x then just let me know 😊

sfackler · 2022-07-11T12:52:24Z

Wouldn't BoxBody suffice for axum?

davidpdrsn · 2022-07-11T13:33:36Z

Wouldn't BoxBody suffice for axum?

No, I wish 😞

I want to support impl FromRequest for Request<hyper::Body> and also fix tokio-rs/axum#1110. That essentially requires being able to convert an impl http_body::Body into a hyper::Body.

I'll try an elaborate. This is a simplified version of what we have in axum today (everything is generic over the request body):

#![allow(warnings)]

use http::{Request, Response};
use http_body::combinators::UnsyncBoxBody;
use hyper::{body::Bytes, Body};
use std::{
    collections::HashMap,
    convert::Infallible,
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};
use tower::{util::BoxCloneService, Layer, Service, ServiceExt};

type BoxBody = UnsyncBoxBody<Bytes, hyper::Error>;
type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
type BoxError = Box<dyn std::error::Error + Send + Sync>;

struct Route<B> {
    inner: BoxCloneService<Request<B>, Response<BoxBody>, Infallible>,
}

impl<B> Clone for Route<B> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
        }
    }
}

impl<B> Service<Request<B>> for Route<B> {
    type Response = Response<BoxBody>;
    type Error = Infallible;
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        todo!()
    }

    fn call(&mut self, req: Request<B>) -> Self::Future {
        todo!()
    }
}

struct Router<B> {
    routes: HashMap<String, Route<B>>,
}

impl<B> Router<B> {
    fn new() -> Self {
        Router {
            routes: HashMap::new(),
        }
    }

    pub fn layer<L, NewReqBody, NewResBody>(self, _layer: L) -> Router<NewReqBody>
    where
        L: Layer<Route<B>>,
        L::Service:
            Service<Request<NewReqBody>, Response = Response<NewResBody>> + Clone + Send + 'static,
        <L::Service as Service<Request<NewReqBody>>>::Error: Into<Infallible> + 'static,
        <L::Service as Service<Request<NewReqBody>>>::Future: Send + 'static,
        NewResBody: http_body::Body<Data = Bytes> + Send + 'static,
        NewResBody::Error: Into<BoxError>,
    {
        todo!()
    }
}

impl<B> Service<Request<B>> for Router<B> {
    type Response = Response<BoxBody>;
    type Error = Infallible;
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request<B>) -> Self::Future {
        todo!()
    }
}

#[test]
fn a_test() {
    use http_body::Limited;
    use tower_http::limit::RequestBodyLimitLayer;

    let router: Router<Limited<Body>> = Router::new().layer(RequestBodyLimitLayer::new(1024));
}

We want Router (and thus Route) to not be generic to solve tokio-rs/axum#1110 so we need to decide on a request body in

struct Route<B> {
    inner: BoxCloneService<Request<B>, Response<BoxBody>, Infallible>,
}

If we pick hyper::Body that forces Router::layer to be:

pub fn layer<L, NewResBody>(self, _layer: L) -> Router
where
    L: Layer<Route>,
    // this says that the service the layer produces must accept `Request<Body>`
    L::Service:
        Service<Request<Body>, Response = Response<NewResBody>> + Clone + Send + 'static,
    <L::Service as Service<Request<Body>>>::Error: Into<Infallible> + 'static,
    <L::Service as Service<Request<Body>>>::Future: Send + 'static,
    NewResBody: http_body::Body<Data = Bytes> + Send + 'static,
    NewResBody::Error: Into<BoxError>,
{
    ...
}

and we are forced to implement Service as

impl Service<Request<Body>> for Route { ... }

impl Service<Request<Body>> for Router { ... }

However those two (fn layer and the Service impls) don't work with each other. If we do

let router = Router::new().layer(RequestBodyLimitLayer::new(1024));

Then RequestBodyLimit will require the inner service (a Route) to accept Request<Limited<Body>> but Route only accepts Request<Body>. So it doesn't work.

If we try to make the Service impl more general we also run into issues:

impl<B> Service<Request<B>> for Route {
    type Response = Response<BoxBody>;
    type Error = Infallible;
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request<B>) -> Self::Future {
        // but this doesn't work either because `Route` contains a
        // `BoxCloneService<Request<Body>, Response<BoxBody>, Infallible>`
        // which we must call with a `Request<Body>` but we have no way to convert
        // `B` into a `Body`
        todo!()
    }
}

So that is why Body::wrap_body is needed because it allows me to convert the generic B in these Service impls into Body.

You're right that I could "just" use BoxBody for axum and then all this goes away but then I cannot impl FromRequest for Request<Body>. Again because that requires converting a BoxBody into a Body. I'm worried its gonna be a source of confusion if this doesn't work.

I hope you're able to see some magic trick that makes this all work without Body::wrap_body but I don't see it 😞

davidpdrsn · 2023-03-20T20:09:21Z

axum is moving to its own body type (tokio-rs/axum#1584) so we don't actually need this anymore. Things have also changed for hyper 1.0 so I'll close this for now.

davidpdrsn added the A-body Area: body streaming. label Jul 11, 2022

davidpdrsn requested a review from seanmonstar July 11, 2022 12:01

davidpdrsn mentioned this pull request Jul 11, 2022

Remove request body type param tokio-rs/axum#1154

Closed

2 tasks

davidpdrsn force-pushed the david/body-wrap-body branch from 0414a3d to 3b95a6e Compare July 11, 2022 12:05

davidpdrsn mentioned this pull request Jul 11, 2022

Router re-export can cause confusion EmbarkStudios/server-framework#33

Open

davidpdrsn force-pushed the david/body-wrap-body branch from 3b95a6e to 96eb6c6 Compare July 11, 2022 12:14

davidpdrsn force-pushed the david/body-wrap-body branch from 96eb6c6 to 355b6fc Compare July 11, 2022 15:33

feat(body): add Body::wrap_body

5be673f

davidpdrsn force-pushed the david/body-wrap-body branch from 355b6fc to 5be673f Compare July 11, 2022 15:35

davidpdrsn closed this Mar 20, 2023

davidpdrsn deleted the david/body-wrap-body branch March 20, 2023 20:09

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat(body): add `Body::wrap_body` #2913

feat(body): add `Body::wrap_body` #2913

davidpdrsn commented Jul 11, 2022

sfackler commented Jul 11, 2022

davidpdrsn commented Jul 11, 2022 •

edited

Loading

davidpdrsn commented Mar 20, 2023

feat(body): add Body::wrap_body #2913

feat(body): add Body::wrap_body #2913

Conversation

davidpdrsn commented Jul 11, 2022

sfackler commented Jul 11, 2022

davidpdrsn commented Jul 11, 2022 • edited Loading

davidpdrsn commented Mar 20, 2023

feat(body): add `Body::wrap_body` #2913

feat(body): add `Body::wrap_body` #2913

davidpdrsn commented Jul 11, 2022 •

edited

Loading