Can no longer combine with tower-http's RequestDecompression

[tisonkun]

Summary

Worked in axum 0.6:

    fn route_influxdb<S>(influxdb_handler: InfluxdbLineProtocolHandlerRef) -> Router<S> {
        Router::new()
            .route("/write", routing::post(influxdb_write_v1))
            .route("/api/v2/write", routing::post(influxdb_write_v2))
            .layer(
                ServiceBuilder::new()
                    .layer(HandleErrorLayer::new(handle_error))
                    .layer(RequestDecompressionLayer::new()),
            )
            .route("/ping", routing::get(influxdb_ping))
            .route("/health", routing::get(influxdb_health))
            .with_state(influxdb_handler)
    }

async fn handle_error(err: BoxError) -> Json<HttpResponse> {
    error!(err; "Unhandled internal error");
    Json(HttpResponse::Error(ErrorResponse::from_error_message(
        StatusCode::Unexpected,
        format!("Unhandled internal error: {err}"),
    )))
}

But on axum 0.7:

error[E0277]: the trait bound `HandleError<RequestDecompression<Route>, fn(Box<(dyn StdError + std::marker::Send + std::marker::Sync + 'static)>) -> impl futures::Future<Output = axum::Json<HttpResponse>> {http::handle_error}, _>: tower::Service<hyper::Request<axum::body::Body>>` is not satisfied
   --> src/servers/src/http.rs:718:17
    |
717 |               .layer(
    |                ----- required by a bound introduced by this call
718 | /                 ServiceBuilder::new()
719 | |                     .layer(HandleErrorLayer::new(handle_error))
720 | |                     .layer(RequestDecompressionLayer::new()),
    | |____________________________________________________________^ the trait `tower::Service<hyper::Request<axum::body::Body>>` is not implemented for `HandleError<RequestDecompression<Route>, ..., ...>`
    |
    = help: the following other types implement trait `tower::Service<Request>`:
              HandleError<S, F, ()>
              HandleError<S, F, (T1,)>
              HandleError<S, F, (T1, T2)>
              HandleError<S, F, (T1, T2, T3)>
              HandleError<S, F, (T1, T2, T3, T4)>
              HandleError<S, F, (T1, T2, T3, T4, T5)>
              HandleError<S, F, (T1, T2, T3, T4, T5, T6)>
              HandleError<S, F, (T1, T2, T3, T4, T5, T6, T7)>
            and 9 others
note: the method call chain might not have had the expected associated types
   --> src/servers/src/http.rs:719:22
    |
718 |                 ServiceBuilder::new()
    |                 --------------------- this expression has type `ServiceBuilder<Identity>`
719 |                     .layer(HandleErrorLayer::new(handle_error))
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Layer::Service` is `HandleError<_, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = Json<HttpResponse>> {handle_error}, _>` here
720 |                     .layer(RequestDecompressionLayer::new()),
    |                      --------------------------------------- `Layer::Service` remains `HandleError<RequestDecompression<_>, fn(Box<dyn Error + Send + Sync>) -> impl Future<Output = Json<HttpResponse>> {handle_error}, _>` here
note: required by a bound in `axum::Router::<S>::layer`
   --> /Users/tison/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.4/src/routing/mod.rs:278:21
    |
275 |     pub fn layer<L>(self, layer: L) -> Router<S>
    |            ----- required by a bound in this associated function
...
278 |         L::Service: Service<Request> + Clone + Send + 'static,
    |                     ^^^^^^^^^^^^^^^^ required by this bound in `Router::<S>::layer`

axum version

0.7.4

[Congyuwang]

I just dealt with this problem. In fact with the new version, the code is greatly simplified.

First note that you have to depend on tower-http v0.5 and tower v0.4.

Next, you no longer need:

.layer(
                ServiceBuilder::new()
                    .layer(HandleErrorLayer::new(handle_error))
                    .layer(RequestDecompressionLayer::new()),
            )

instead just write something like:

.layer(RequestDecompressionLayer::new().gzip(true))

I think it's because RequestDecompressionLayer is infallible now, and so no longer needs an error handling layer. The decompression error, if any, is propagated to reading the data from the request body.

With regard to the handlers, put/patch, etc.. To read the body, you also no longer need Request<DecompressionBody<Body>>, and can use Request<Body> directly. Then, use req.into_body().into_data_stream(); to read the decompressed stream of data in a loop. If there is an error decompressing, that will be reported when you iterate through the decompressed chunks.

[tisonkun]

Thanks a lot. This works.