Update to tower-http 0.4 (#1783)

Author: davidpdrsn

axum-core/Cargo.toml

@@ -29,7 +29,7 @@ axum = { path = "../axum", version = "0.6.0", features = ["headers"] }
 futures-util = "0.3"
 hyper = "0.14"
 tokio = { version = "1.0", features = ["macros"] }
-tower-http = { version = "0.3.4", features = ["limit"] }
+tower-http = { version = "0.4", features = ["limit"] }
 
 [package.metadata.cargo-public-api-crates]
 allowed = [

axum-extra/CHANGELOG.md

@@ -7,8 +7,10 @@ and this project adheres to [Semantic Versioning].
 
 # Unreleased
 
+- **breaking:** `SpaRouter::handle_error` has been removed ([#1783])
 - **breaking:**  Change casing of `ProtoBuf` to `Protobuf` ([#1595])
 
+[#1783]: https://github.com/tokio-rs/axum/pull/1783
 [#1595]: https://github.com/tokio-rs/axum/pull/1595
 
 # 0.5.0 (12. February, 2022)

axum-extra/Cargo.toml

@@ -43,7 +43,7 @@ mime = "0.3"
 pin-project-lite = "0.2"
 tokio = "1.19"
 tower = { version = "0.4", default_features = false, features = ["util"] }
-tower-http = { version = "0.3", features = ["map-response-body"] }
+tower-http = { version = "0.4", features = ["map-response-body"] }
 tower-layer = "0.3"
 tower-service = "0.3"
 
@@ -68,7 +68,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.71"
 tokio = { version = "1.14", features = ["full"] }
 tower = { version = "0.4", features = ["util"] }
-tower-http = { version = "0.3", features = ["map-response-body", "timeout"] }
+tower-http = { version = "0.4", features = ["map-response-body", "timeout"] }
 
 [package.metadata.docs.rs]
 all-features = true

axum-extra/src/routing/spa.rs

@@ -1,23 +1,15 @@
 use axum::{
     body::{Body, HttpBody},
-    error_handling::HandleError,
-    response::IntoResponse,
-    routing::{get_service, Route},
     Router,
 };
-use http::{Request, StatusCode};
 use std::{
     any::type_name,
-    convert::Infallible,
     fmt,
-    future::{ready, Ready},
-    io,
     marker::PhantomData,
     path::{Path, PathBuf},
     sync::Arc,
 };
 use tower_http::services::{ServeDir, ServeFile};
-use tower_service::Service;
 
 /// Router for single page applications.
 ///
@@ -50,10 +42,9 @@ use tower_service::Service;
 /// - `GET /some/other/path` will serve `index.html` since there isn't another
 ///   route for it
 /// - `GET /api/foo` will serve the `api_foo` handler function
-pub struct SpaRouter<S = (), B = Body, T = (), F = fn(io::Error) -> Ready<StatusCode>> {
+pub struct SpaRouter<S = (), B = Body> {
     paths: Arc<Paths>,
-    handle_error: F,
-    _marker: PhantomData<fn() -> (S, B, T)>,
+    _marker: PhantomData<fn() -> (S, B)>,
 }
 
 #[derive(Debug)]
@@ -63,7 +54,7 @@ struct Paths {
     index_file: PathBuf,
 }
 
-impl<S, B> SpaRouter<S, B, (), fn(io::Error) -> Ready<StatusCode>> {
+impl<S, B> SpaRouter<S, B> {
     /// Create a new `SpaRouter`.
     ///
     /// Assets will be served at `GET /{serve_assets_at}` from the directory at `assets_dir`.
@@ -80,13 +71,12 @@ impl<S, B> SpaRouter<S, B, (), fn(io::Error) -> Ready<StatusCode>> {
                 assets_dir: path.to_owned(),
                 index_file: path.join("index.html"),
             }),
-            handle_error: |_| ready(StatusCode::INTERNAL_SERVER_ERROR),
             _marker: PhantomData,
         }
     }
 }
 
-impl<S, B, T, F> SpaRouter<S, B, T, F> {
+impl<S, B> SpaRouter<S, B> {
     /// Set the path to the index file.
     ///
     /// `path` must be relative to `assets_dir` passed to [`SpaRouter::new`].
@@ -114,72 +104,27 @@ impl<S, B, T, F> SpaRouter<S, B, T, F> {
         });
         self
     }
-
-    /// Change the function used to handle unknown IO errors.
-    ///
-    /// `SpaRouter` automatically maps missing files and permission denied to
-    /// `404 Not Found`. The callback given here will be used for other IO errors.
-    ///
-    /// See [`axum::error_handling::HandleErrorLayer`] for more details.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::io;
-    /// use axum_extra::routing::SpaRouter;
-    /// use axum::{Router, http::{Method, Uri}};
-    ///
-    /// let spa = SpaRouter::new("/assets", "dist").handle_error(handle_error);
-    ///
-    /// async fn handle_error(method: Method, uri: Uri, err: io::Error) -> String {
-    ///     format!("{} {} failed with {}", method, uri, err)
-    /// }
-    ///
-    /// let app = Router::new().merge(spa);
-    /// # let _: Router = app;
-    /// ```
-    pub fn handle_error<T2, F2>(self, f: F2) -> SpaRouter<S, B, T2, F2> {
-        SpaRouter {
-            paths: self.paths,
-            handle_error: f,
-            _marker: PhantomData,
-        }
-    }
 }
 
-impl<S, B, F, T> From<SpaRouter<S, B, T, F>> for Router<S, B>
+impl<S, B> From<SpaRouter<S, B>> for Router<S, B>
 where
-    F: Clone + Send + Sync + 'static,
-    HandleError<Route<B, io::Error>, F, T>: Service<Request<B>, Error = Infallible>,
-    <HandleError<Route<B, io::Error>, F, T> as Service<Request<B>>>::Response: IntoResponse + Send,
-    <HandleError<Route<B, io::Error>, F, T> as Service<Request<B>>>::Future: Send,
     B: HttpBody + Send + 'static,
-    T: 'static,
     S: Clone + Send + Sync + 'static,
 {
-    fn from(spa: SpaRouter<S, B, T, F>) -> Router<S, B> {
-        let assets_service = get_service(ServeDir::new(&spa.paths.assets_dir))
-            .handle_error(spa.handle_error.clone());
-
+    fn from(spa: SpaRouter<S, B>) -> Router<S, B> {
+        let assets_service = ServeDir::new(&spa.paths.assets_dir);
         Router::new()
             .nest_service(&spa.paths.assets_path, assets_service)
-            .fallback_service(
-                get_service(ServeFile::new(&spa.paths.index_file)).handle_error(spa.handle_error),
-            )
+            .fallback_service(ServeFile::new(&spa.paths.index_file))
     }
 }
 
-impl<B, T, F> fmt::Debug for SpaRouter<B, T, F> {
+impl<B, T> fmt::Debug for SpaRouter<B, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self {
-            paths,
-            handle_error: _,
-            _marker,
-        } = self;
+        let Self { paths, _marker } = self;
 
         f.debug_struct("SpaRouter")
             .field("paths", &paths)
-            .field("handle_error", &format_args!("{}", type_name::<F>()))
             .field("request_body_type", &format_args!("{}", type_name::<B>()))
             .field(
                 "extractor_input_type",
@@ -189,14 +134,10 @@ impl<B, T, F> fmt::Debug for SpaRouter<B, T, F> {
     }
 }
 
-impl<B, T, F> Clone for SpaRouter<B, T, F>
-where
-    F: Clone,
-{
+impl<B, T> Clone for SpaRouter<B, T> {
     fn clone(&self) -> Self {
         Self {
             paths: self.paths.clone(),
-            handle_error: self.handle_error,
             _marker: self._marker,
         }
     }
@@ -206,10 +147,8 @@ where
 mod tests {
     use super::*;
     use crate::test_helpers::*;
-    use axum::{
-        http::{Method, Uri},
-        routing::get,
-    };
+    use axum::routing::get;
+    use http::StatusCode;
 
     #[tokio::test]
     async fn basic() {
@@ -253,21 +192,6 @@ mod tests {
         assert_eq!(res.text().await, "<strong>Hello, World!</strong>\n");
     }
 
-    // this should just compile
-    #[allow(dead_code)]
-    fn setting_error_handler() {
-        async fn handle_error(method: Method, uri: Uri, err: io::Error) -> (StatusCode, String) {
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("{} {} failed. Error: {}", method, uri, err),
-            )
-        }
-
-        let spa = SpaRouter::new("/assets", "test_files").handle_error(handle_error);
-
-        Router::<(), Body>::new().merge(spa);
-    }
-
     #[allow(dead_code)]
     fn works_with_router_with_state() {
         let _: Router = Router::new()

axum/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 # Unreleased
 
-- None.
+- **changed:** Update to tower-http 0.4. axum is still compatible with tower-http 0.3
 
 # 0.6.8 (24. February, 2023)
 

axum/Cargo.toml

@@ -27,7 +27,38 @@ tower-log = ["tower/log"]
 ws = ["tokio", "dep:tokio-tungstenite", "dep:sha1", "dep:base64"]
 
 # Required for intra-doc links to resolve correctly
-__private_docs = ["tower/full", "tower-http/full"]
+__private_docs = [
+    "tower/full",
+    # all tower-http features except (de)?compression-zstd which doesn't
+    # build on `--target armv5te-unknown-linux-musleabi`
+    "tower-http/add-extension",
+    "tower-http/auth",
+    "tower-http/catch-panic",
+    "tower-http/compression-br",
+    "tower-http/compression-deflate",
+    "tower-http/compression-gzip",
+    "tower-http/cors",
+    "tower-http/decompression-br",
+    "tower-http/decompression-deflate",
+    "tower-http/decompression-gzip",
+    "tower-http/follow-redirect",
+    "tower-http/fs",
+    "tower-http/limit",
+    "tower-http/map-request-body",
+    "tower-http/map-response-body",
+    "tower-http/metrics",
+    "tower-http/normalize-path",
+    "tower-http/propagate-header",
+    "tower-http/redirect",
+    "tower-http/request-id",
+    "tower-http/sensitive-headers",
+    "tower-http/set-header",
+    "tower-http/set-status",
+    "tower-http/timeout",
+    "tower-http/trace",
+    "tower-http/util",
+    "tower-http/validate-request",
+]
 
 [dependencies]
 async-trait = "0.1.43"
@@ -47,7 +78,7 @@ pin-project-lite = "0.2.7"
 serde = "1.0"
 sync_wrapper = "0.1.1"
 tower = { version = "0.4.13", default-features = false, features = ["util"] }
-tower-http = { version = "0.3.0", features = ["util", "map-response-body"] }
+tower-http = { version = "0.4", features = ["util", "map-response-body"] }
 tower-layer = "0.3.2"
 tower-service = "0.3"
 
@@ -98,8 +129,38 @@ features = [
 ]
 
 [dev-dependencies.tower-http]
-version = "0.3.4"
-features = ["full"]
+version = "0.4"
+features = [
+    # all tower-http features except (de)?compression-zstd which doesn't
+    # build on `--target armv5te-unknown-linux-musleabi`
+    "add-extension",
+    "auth",
+    "catch-panic",
+    "compression-br",
+    "compression-deflate",
+    "compression-gzip",
+    "cors",
+    "decompression-br",
+    "decompression-deflate",
+    "decompression-gzip",
+    "follow-redirect",
+    "fs",
+    "limit",
+    "map-request-body",
+    "map-response-body",
+    "metrics",
+    "normalize-path",
+    "propagate-header",
+    "redirect",
+    "request-id",
+    "sensitive-headers",
+    "set-header",
+    "set-status",
+    "timeout",
+    "trace",
+    "util",
+    "validate-request",
+]
 
 [package.metadata.playground]
 features = [

axum/src/docs/method_routing/route_layer.md

@@ -17,12 +17,12 @@ use axum::{
     routing::get,
     Router,
 };
-use tower_http::auth::RequireAuthorizationLayer;
+use tower_http::validate_request::ValidateRequestHeaderLayer;
 
 let app = Router::new().route(
     "/foo",
     get(|| async {})
-        .route_layer(RequireAuthorizationLayer::bearer("password"))
+        .route_layer(ValidateRequestHeaderLayer::bearer("password"))
 );
 
 // `GET /foo` with a valid token will receive `200 OK`

axum/src/docs/routing/route_layer.md

@@ -17,11 +17,11 @@ use axum::{
     routing::get,
     Router,
 };
-use tower_http::auth::RequireAuthorizationLayer;
+use tower_http::validate_request::ValidateRequestHeaderLayer;
 
 let app = Router::new()
     .route("/foo", get(|| async {}))
-    .route_layer(RequireAuthorizationLayer::bearer("password"));
+    .route_layer(ValidateRequestHeaderLayer::bearer("password"));
 
 // `GET /foo` with a valid token will receive `200 OK`
 // `GET /foo` with a invalid token will receive `401 Unauthorized`

axum/src/docs/routing/route_service.md

@@ -38,17 +38,10 @@ let app = Router::new()
             Ok::<_, Infallible>(res)
         })
     )
-    .route(
+    .route_service(
         // GET `/static/Cargo.toml` goes to a service from tower-http
         "/static/Cargo.toml",
-        get_service(ServeFile::new("Cargo.toml"))
-            // though we must handle any potential errors
-            .handle_error(|error: io::Error| async move {
-                (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    format!("Unhandled internal error: {}", error),
-                )
-            })
+        ServeFile::new("Cargo.toml"),
     );
 # async {
 # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();