upgrade to axum 0.6

Author: syphar

Cargo.lock

@@ -91,7 +91,8 @@ iron = "0.6"
 router = "0.6"
 
 # axum dependencies
-axum = "0.5.17"
+axum = "0.6.0"
+axum-extra = "0.4.0"
 hyper = { version = "0.14.15", default-features = false }
 tower = "0.4.11"
 tower-service = "0.3.2"

Cargo.toml

@@ -587,7 +587,7 @@ impl TestFrontend {
                         .unwrap()
                         .serve(
                             axum_app
-                                .fallback(
+                                .fallback_service(
                                     build_strangler_service(iron_server.socket)
                                         .expect("could not build strangler service"),
                                 )

src/test/mod.rs

@@ -490,7 +490,7 @@ pub fn start_web_server(addr: Option<&str>, context: &dyn Context) -> Result<(),
         axum::Server::bind(&axum_addr)
             .serve(
                 build_axum_app(context, template_data)?
-                    .fallback(build_strangler_service(iron_server.socket)?)
+                    .fallback_service(build_strangler_service(iron_server.socket)?)
                     .into_make_service(),
             )
             .await?;

src/web/mod.rs

@@ -6,29 +6,32 @@ use axum::{
     handler::Handler as AxumHandler, middleware, response::Redirect, routing::get,
     routing::MethodRouter, Router as AxumRouter,
 };
+use axum_extra::routing::RouterExt;
 use iron::middleware::Handler;
 use router::Router as IronRouter;
 use std::{borrow::Cow, collections::HashSet, convert::Infallible};
 use tracing::instrument;
 
 #[instrument(skip_all)]
-fn get_static<H, T, B>(handler: H) -> MethodRouter<B, Infallible>
+fn get_static<H, T, S, B>(handler: H) -> MethodRouter<S, B, Infallible>
 where
-    H: AxumHandler<T, B>,
+    H: AxumHandler<T, S, B>,
     B: Send + 'static + hyper::body::HttpBody,
     T: 'static,
+    S: Clone + Send + Sync + 'static,
 {
     get(handler).route_layer(middleware::from_fn(|request, next| async {
         request_recorder(request, next, Some("static resource")).await
     }))
 }
 
 #[instrument(skip_all)]
-fn get_internal<H, T, B>(handler: H) -> MethodRouter<B, Infallible>
+fn get_internal<H, T, S, B>(handler: H) -> MethodRouter<S, B, Infallible>
 where
-    H: AxumHandler<T, B>,
+    H: AxumHandler<T, S, B>,
     B: Send + 'static + hyper::body::HttpBody,
     T: 'static,
+    S: Clone + Send + Sync + 'static,
 {
     get(handler).route_layer(middleware::from_fn(|request, next| async {
         request_recorder(request, next, None).await
@@ -41,64 +44,64 @@ pub(super) fn build_axum_routes() -> AxumRouter {
         // must live at the site root:
         //   https://developers.google.com/search/reference/robots_txt#handling-http-result-codes
         //   https://support.google.com/webmasters/answer/183668?hl=en
-        .route(
+        .route_with_tsr(
             "/robots.txt",
             get_static(|| async { Redirect::permanent("/-/static/robots.txt") }),
         )
-        .route(
+        .route_with_tsr(
             "/favicon.ico",
             get_static(|| async { Redirect::permanent("/-/static/favicon.ico") }),
         )
-        .route(
+        .route_with_tsr(
             "/sitemap.xml",
             get_internal(super::sitemap::sitemapindex_handler),
         )
-        .route(
+        .route_with_tsr(
             "/-/sitemap/:letter/sitemap.xml",
             get_internal(super::sitemap::sitemap_handler),
         )
-        .route(
+        .route_with_tsr(
             "/about/builds",
             get_internal(super::sitemap::about_builds_handler),
         )
-        .route(
+        .route_with_tsr(
             "/about/metrics",
             get_internal(super::metrics::metrics_handler),
         )
-        .route("/about", get_internal(super::sitemap::about_handler))
-        .route(
+        .route_with_tsr("/about", get_internal(super::sitemap::about_handler))
+        .route_with_tsr(
             "/about/:subpage",
             get_internal(super::sitemap::about_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases",
             get_internal(super::releases::recent_releases_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/recent/:page",
             get_internal(super::releases::recent_releases_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/stars",
             get_internal(super::releases::releases_by_stars_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/stars/:page",
             get_internal(super::releases::releases_by_stars_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/recent-failures",
             get_internal(super::releases::releases_recent_failures_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/recent-failures/:page",
             get_internal(super::releases::releases_recent_failures_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/failures",
             get_internal(super::releases::releases_failures_by_stars_handler),
         )
-        .route(
+        .route_with_tsr(
             "/releases/failures/:page",
             get_internal(super::releases::releases_failures_by_stars_handler),
         )

src/web/routes.rs

@@ -20,10 +20,7 @@ use std::{
     task::{Context, Poll},
 };
 
-use axum::{
-    extract::RequestParts,
-    http::{uri::Authority, Uri},
-};
+use axum::http::{uri::Authority, Uri};
 use tower_service::Service;
 
 /// Service that forwards all requests to another service
@@ -33,7 +30,7 @@ use tower_service::Service;
 ///     let strangler_svc = StranglerService::new(
 ///         axum::http::uri::Authority::from_static("127.0.0.1:3333"),
 ///     );
-///     let router = axum::Router::new().fallback(strangler_svc);
+///     let router = axum::Router::new().fallback_service(strangler_svc);
 ///     axum::Server::bind(&"127.0.0.1:0".parse()?)
 ///         .serve(router.into_make_service())
 ///         # .with_graceful_shutdown(async {
@@ -90,13 +87,9 @@ impl Service<axum::http::Request<axum::body::Body>> for StranglerService {
 async fn forward_call_to_strangled(
     http_client: hyper::Client<hyper::client::HttpConnector>,
     inner: Arc<InnerStranglerService>,
-    req: axum::http::Request<axum::body::Body>,
+    mut req: axum::http::Request<axum::body::Body>,
 ) -> Result<axum::response::Response, Infallible> {
     tracing::debug!("handling a request");
-    let mut request_parts = RequestParts::new(req);
-    let req: Result<axum::http::Request<axum::body::Body>, _> = request_parts.extract().await;
-    let mut req = req.unwrap();
-
     let uri: Uri = {
         // Not really anything to do, because this could just not be a websocket
         // request.
@@ -145,13 +138,13 @@ mod tests {
 
     #[tokio::test]
     async fn can_be_used_as_fallback() {
-        let router = Router::new().fallback(make_svc());
+        let router = Router::new().fallback_service(make_svc());
         axum::Server::bind(&"0.0.0.0:0".parse().unwrap()).serve(router.into_make_service());
     }
 
     #[tokio::test]
     async fn can_be_used_for_a_route() {
-        let router = Router::new().route("/api", make_svc());
+        let router = Router::new().route_service("/api", make_svc());
         axum::Server::bind(&"0.0.0.0:0".parse().unwrap()).serve(router.into_make_service());
     }
 
@@ -204,7 +197,7 @@ mod tests {
         });
 
         let background_strangler_handle = tokio::spawn(async move {
-            let router = Router::new().fallback(strangler_svc);
+            let router = Router::new().fallback_service(strangler_svc);
             axum::Server::from_tcp(strangler_tcp)
                 .unwrap()
                 .serve(router.into_make_service())