Internally Arc Router, without breaking changes (#2483)

Co-authored-by: Jonas Platte <jplatte+git@posteo.de>

axum/CHANGELOG.md

@@ -8,9 +8,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 # Unreleased
 
 - **fixed:** Improve `debug_handler` on tuple response types ([#2201])
+- **fixed:** Fix performance regression present since axum 0.7.0 ([#2483])
 - **added:** Add `must_use` attribute to `Serve` and `WithGracefulShutdown` ([#2484])
 - **added:** Re-export `axum_core::body::BodyDataStream` from axum
 
+[#2201]: https://github.com/tokio-rs/axum/pull/2201
+[#2483]: https://github.com/tokio-rs/axum/pull/2483
 [#2201]: https://github.com/tokio-rs/axum/pull/2201
 [#2484]: https://github.com/tokio-rs/axum/pull/2484
 

axum/clippy.toml

@@ -0,0 +1,3 @@
+disallowed-types = [
+    { path = "std::sync::Mutex", reason = "Use our internal AxumMutex instead" },
+]

axum/src/boxed.rs

@@ -1,6 +1,7 @@
-use std::{convert::Infallible, fmt, sync::Mutex};
+use std::{convert::Infallible, fmt};
 
 use crate::extract::Request;
+use crate::util::AxumMutex;
 use tower::Service;
 
 use crate::{
@@ -9,7 +10,7 @@ use crate::{
     Router,
 };
 
-pub(crate) struct BoxedIntoRoute<S, E>(Mutex<Box<dyn ErasedIntoRoute<S, E>>>);
+pub(crate) struct BoxedIntoRoute<S, E>(AxumMutex<Box<dyn ErasedIntoRoute<S, E>>>);
 
 impl<S> BoxedIntoRoute<S, Infallible>
 where
@@ -20,7 +21,7 @@ where
         H: Handler<T, S>,
         T: 'static,
     {
-        Self(Mutex::new(Box::new(MakeErasedHandler {
+        Self(AxumMutex::new(Box::new(MakeErasedHandler {
             handler,
             into_route: |handler, state| Route::new(Handler::with_state(handler, state)),
         })))
@@ -35,7 +36,7 @@ impl<S, E> BoxedIntoRoute<S, E> {
         F: FnOnce(Route<E>) -> Route<E2> + Clone + Send + 'static,
         E2: 'static,
     {
-        BoxedIntoRoute(Mutex::new(Box::new(Map {
+        BoxedIntoRoute(AxumMutex::new(Box::new(Map {
             inner: self.0.into_inner().unwrap(),
             layer: Box::new(f),
         })))
@@ -48,7 +49,7 @@ impl<S, E> BoxedIntoRoute<S, E> {
 
 impl<S, E> Clone for BoxedIntoRoute<S, E> {
     fn clone(&self) -> Self {
-        Self(Mutex::new(self.0.lock().unwrap().clone_box()))
+        Self(AxumMutex::new(self.0.lock().unwrap().clone_box()))
     }
 }
 
@@ -118,7 +119,7 @@ where
         (self.into_route)(self.router, state)
     }
 
-    fn call_with_state(mut self: Box<Self>, request: Request, state: S) -> RouteFuture<Infallible> {
+    fn call_with_state(self: Box<Self>, request: Request, state: S) -> RouteFuture<Infallible> {
         self.router.call_with_state(request, state)
     }
 }

axum/src/routing/method_routing.rs

@@ -1022,7 +1022,7 @@ where
         self
     }
 
-    pub(crate) fn call_with_state(&mut self, req: Request, state: S) -> RouteFuture<E> {
+    pub(crate) fn call_with_state(&self, req: Request, state: S) -> RouteFuture<E> {
         macro_rules! call {
             (
                 $req:expr,
@@ -1034,12 +1034,12 @@ where
                     match $svc {
                         MethodEndpoint::None => {}
                         MethodEndpoint::Route(route) => {
-                            return RouteFuture::from_future(route.oneshot_inner($req))
+                            return RouteFuture::from_future(route.clone().oneshot_inner($req))
                                 .strip_body($method == Method::HEAD);
                         }
                         MethodEndpoint::BoxedHandler(handler) => {
-                            let mut route = handler.clone().into_route(state);
-                            return RouteFuture::from_future(route.oneshot_inner($req))
+                            let route = handler.clone().into_route(state);
+                            return RouteFuture::from_future(route.clone().oneshot_inner($req))
                                 .strip_body($method == Method::HEAD);
                         }
                     }
@@ -1073,7 +1073,7 @@ where
         call!(req, method, DELETE, delete);
         call!(req, method, TRACE, trace);
 
-        let future = fallback.call_with_state(req, state);
+        let future = fallback.clone().call_with_state(req, state);
 
         match allow_header {
             AllowHeader::None => future.allow_header(Bytes::new()),
@@ -1219,7 +1219,7 @@ where
 {
     type Future = InfallibleRouteFuture;
 
-    fn call(mut self, req: Request, state: S) -> Self::Future {
+    fn call(self, req: Request, state: S) -> Self::Future {
         InfallibleRouteFuture::new(self.call_with_state(req, state))
     }
 }