feat: initial support for route and HTTP method introspection

actix-web/CHANGES.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Add `resources-introspection` feature for retrieving configured route paths and HTTP methods.
 - Implement `Responder` for `Result<(), E: Into<Error>>`. Returning `Ok(())` responds with HTTP 204 No Content.
 - On Windows, an error is now returned from `HttpServer::bind()` (or TLS variants) when binding to a socket that's already in use.
 - Update `brotli` dependency to `7`.

actix-web/Cargo.toml

@@ -128,6 +128,9 @@ compat = [
 # Opt-out forwards-compatibility for handler visibility inheritance fix.
 compat-routing-macros-force-pub = ["actix-web-codegen?/compat-routing-macros-force-pub"]
 
+# Enabling the retrieval of metadata for initialized resources, including path and HTTP method.
+resources-introspection = []
+
 [dependencies]
 actix-codec = "0.5"
 actix-macros = { version = "0.2.3", optional = true }

actix-web/src/app_service.rs

@@ -82,13 +82,34 @@ where
 
         let (config, services) = config.into_services();
 
+        #[cfg(feature = "resources-introspection")]
+        let mut rdef_methods: Vec<(String, Vec<String>)> = Vec::new();
+
         // complete pipeline creation.
         *self.factory_ref.borrow_mut() = Some(AppRoutingFactory {
             default,
             services: services
                 .into_iter()
                 .map(|(mut rdef, srv, guards, nested)| {
                     rmap.add(&mut rdef, nested);
+
+                    #[cfg(feature = "resources-introspection")]
+                    {
+                        let http_methods: Vec<String> =
+                            guards.as_ref().map_or_else(Vec::new, |g| {
+                                g.iter()
+                                    .flat_map(|g| {
+                                        crate::guard::HttpMethodsExtractor::extract_http_methods(
+                                            &**g,
+                                        )
+                                    })
+                                    .collect::<Vec<_>>()
+                            });
+
+                        rdef_methods
+                            .push((rdef.pattern().unwrap_or_default().to_string(), http_methods));
+                    }
+
                     (rdef, srv, RefCell::new(guards))
                 })
                 .collect::<Vec<_>>()
@@ -105,6 +126,11 @@ where
         let rmap = Rc::new(rmap);
         ResourceMap::finish(&rmap);
 
+        #[cfg(feature = "resources-introspection")]
+        {
+            crate::introspection::process_introspection(Rc::clone(&rmap), rdef_methods);
+        }
+
         // construct all async data factory futures
         let factory_futs = join_all(self.async_data_factories.iter().map(|f| f()));
 

actix-web/src/guard/mod.rs

@@ -11,7 +11,7 @@
 //! or handler. This interface is defined by the [`Guard`] trait.
 //!
 //! Commonly-used guards are provided in this module as well as a way of creating a guard from a
-//! closure ([`fn_guard`]). The [`Not`], [`Any`], and [`All`] guards are noteworthy, as they can be
+//! closure ([`fn_guard`]). The [`Not`], [`Any()`], and [`All`] guards are noteworthy, as they can be
 //! used to compose other guards in a more flexible and semantic way than calling `.guard(...)` on
 //! services multiple times (which might have different combining behavior than you want).
 //!
@@ -50,6 +50,7 @@
 //! [`Route`]: crate::Route::guard()
 
 use std::{
+    any::Any,
     cell::{Ref, RefMut},
     rc::Rc,
 };
@@ -121,7 +122,7 @@ impl<'a> GuardContext<'a> {
 /// Interface for routing guards.
 ///
 /// See [module level documentation](self) for more.
-pub trait Guard {
+pub trait Guard: AsAny {
     /// Returns true if predicate condition is met for a given request.
     fn check(&self, ctx: &GuardContext<'_>) -> bool;
 }
@@ -146,7 +147,7 @@ impl Guard for Rc<dyn Guard> {
 /// ```
 pub fn fn_guard<F>(f: F) -> impl Guard
 where
-    F: Fn(&GuardContext<'_>) -> bool,
+    F: Fn(&GuardContext<'_>) -> bool + 'static,
 {
     FnGuard(f)
 }
@@ -155,7 +156,7 @@ struct FnGuard<F: Fn(&GuardContext<'_>) -> bool>(F);
 
 impl<F> Guard for FnGuard<F>
 where
-    F: Fn(&GuardContext<'_>) -> bool,
+    F: Fn(&GuardContext<'_>) -> bool + 'static,
 {
     fn check(&self, ctx: &GuardContext<'_>) -> bool {
         (self.0)(ctx)
@@ -164,7 +165,7 @@ where
 
 impl<F> Guard for F
 where
-    F: Fn(&GuardContext<'_>) -> bool,
+    F: for<'a> Fn(&'a GuardContext<'a>) -> bool + 'static,
 {
     fn check(&self, ctx: &GuardContext<'_>) -> bool {
         (self)(ctx)
@@ -195,7 +196,7 @@ pub fn Any<F: Guard + 'static>(guard: F) -> AnyGuard {
 ///
 /// That is, only one contained guard needs to match in order for the aggregate guard to match.
 ///
-/// Construct an `AnyGuard` using [`Any`].
+/// Construct an `AnyGuard` using [`Any()`].
 pub struct AnyGuard {
     guards: Vec<Box<dyn Guard>>,
 }
@@ -284,7 +285,7 @@ impl Guard for AllGuard {
 ///     .guard(guard::Not(guard::Get()))
 ///     .to(|| HttpResponse::Ok());
 /// ```
-pub struct Not<G>(pub G);
+pub struct Not<G: 'static>(pub G);
 
 impl<G: Guard> Guard for Not<G> {
     #[inline]
@@ -322,6 +323,81 @@ impl Guard for MethodGuard {
     }
 }
 
+#[cfg(feature = "resources-introspection")]
+pub trait HttpMethodsExtractor {
+    fn extract_http_methods(&self) -> Vec<String>;
+}
+
+#[cfg(feature = "resources-introspection")]
+impl HttpMethodsExtractor for dyn Guard {
+    fn extract_http_methods(&self) -> Vec<String> {
+        if let Some(method_guard) = self.as_any().downcast_ref::<MethodGuard>() {
+            vec![method_guard.0.to_string()]
+        } else if let Some(any_guard) = self.as_any().downcast_ref::<AnyGuard>() {
+            any_guard
+                .guards
+                .iter()
+                .flat_map(|g| g.extract_http_methods())
+                .collect()
+        } else if let Some(all_guard) = self.as_any().downcast_ref::<AllGuard>() {
+            all_guard
+                .guards
+                .iter()
+                .flat_map(|g| g.extract_http_methods())
+                .collect()
+        } else {
+            vec!["UNKNOWN".to_string()]
+        }
+    }
+}
+
+#[cfg(feature = "resources-introspection")]
+impl std::fmt::Display for MethodGuard {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[{}]", self.0)
+    }
+}
+
+#[cfg(feature = "resources-introspection")]
+impl std::fmt::Display for AllGuard {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let methods: Vec<String> = self
+            .guards
+            .iter()
+            .filter_map(|guard| {
+                guard
+                    .as_any()
+                    .downcast_ref::<MethodGuard>()
+                    .map(|method_guard| method_guard.0.to_string())
+            })
+            .collect();
+
+        write!(f, "[{}]", methods.join(", "))
+    }
+}
+
+#[cfg(feature = "resources-introspection")]
+impl std::fmt::Display for AnyGuard {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let methods: Vec<String> = self
+            .guards
+            .iter()
+            .map(|guard| {
+                let guard_ref = &**guard;
+                if let Some(method_guard) = guard_ref.as_any().downcast_ref::<MethodGuard>() {
+                    method_guard.0.to_string()
+                } else if let Some(all_guard) = guard_ref.as_any().downcast_ref::<AllGuard>() {
+                    all_guard.to_string()
+                } else {
+                    "UNKNOWN".to_string()
+                }
+            })
+            .collect();
+
+        write!(f, "[{}]", methods.join(", "))
+    }
+}
+
 macro_rules! method_guard {
     ($method_fn:ident, $method_const:ident) => {
         #[doc = concat!("Creates a guard that matches the `", stringify!($method_const), "` request method.")]
@@ -384,6 +460,16 @@ impl Guard for HeaderGuard {
     }
 }
 
+pub trait AsAny {
+    fn as_any(&self) -> &dyn Any;
+}
+
+impl<T: Any> AsAny for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use actix_http::Method;
@@ -495,7 +581,7 @@ mod tests {
     #[test]
     fn function_guard() {
         let domain = "rust-lang.org".to_owned();
-        let guard = fn_guard(|ctx| ctx.head().uri.host().unwrap().ends_with(&domain));
+        let guard = fn_guard(move |ctx| ctx.head().uri.host().unwrap().ends_with(&domain));
 
         let req = TestRequest::default()
             .uri("blog.rust-lang.org")