Less allocation in the router

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

crates/http/src/routes.rs

@@ -173,11 +173,12 @@ impl Router {
             .ok_or_else(|| anyhow!("Cannot match route for path {path}"))?;
 
         let route_handler = best_match.handler();
+        let captures = best_match.captures();
 
         Ok(RouteMatch {
             inner: RouteMatchKind::Real {
                 route_handler,
-                best_match,
+                captures,
                 path,
             },
         })
@@ -253,13 +254,12 @@ impl<'router, 'path> RouteMatch<'router, 'path> {
     }
 
     /// The matched route, excluding any trailing wildcard, combined with the base.
-    pub fn based_route_or_prefix(&self) -> String {
+    pub fn based_route_or_prefix(&self) -> &str {
         self.inner
             .route_handler()
             .based_route
             .strip_suffix("/...")
             .unwrap_or(&self.inner.route_handler().based_route)
-            .to_string()
     }
 
     /// The matched route, as originally written in the manifest.
@@ -268,22 +268,21 @@ impl<'router, 'path> RouteMatch<'router, 'path> {
     }
 
     /// The matched route, excluding any trailing wildcard.
-    pub fn raw_route_or_prefix(&self) -> String {
+    pub fn raw_route_or_prefix(&self) -> &str {
         self.inner
             .route_handler()
             .raw_route
             .strip_suffix("/...")
             .unwrap_or(&self.inner.route_handler().raw_route)
-            .to_string()
     }
 
     /// The named wildcards captured from the path, if any
-    pub fn named_wildcards(&self) -> HashMap<String, String> {
+    pub fn named_wildcards(&self) -> HashMap<&str, &str> {
         self.inner.named_wildcards()
     }
 
     /// The trailing wildcard part of the path, if any
-    pub fn trailing_wildcard(&self) -> String {
+    pub fn trailing_wildcard(&self) -> Cow<'_, str> {
         self.inner.trailing_wildcard()
     }
 }
@@ -304,7 +303,7 @@ enum RouteMatchKind<'router, 'path> {
         /// The route handler that matched the path.
         route_handler: &'router RouteHandler,
         /// The best match for the path.
-        best_match: routefinder::Match<'router, 'path, RouteHandler>,
+        captures: routefinder::Captures<'router, 'path>,
         /// The path that was matched.
         path: &'path str,
     },
@@ -320,44 +319,37 @@ impl<'router, 'path> RouteMatchKind<'router, 'path> {
     }
 
     /// The named wildcards captured from the path, if any
-    pub fn named_wildcards(&self) -> HashMap<String, String> {
-        let Self::Real { best_match, .. } = &self else {
+    pub fn named_wildcards(&self) -> HashMap<&str, &str> {
+        let Self::Real { captures, .. } = &self else {
             return HashMap::new();
         };
-        best_match
-            .captures()
-            .iter()
-            .map(|(k, v)| (k.to_owned(), v.to_owned()))
-            .collect()
+        captures.iter().collect()
     }
 
     /// The trailing wildcard part of the path, if any
-    pub fn trailing_wildcard(&self) -> String {
-        let (best_match, path) = match self {
+    pub fn trailing_wildcard(&self) -> Cow<'_, str> {
+        let (captures, path) = match self {
             // If we have a synthetic match, we already have the trailing wildcard.
             Self::Synthetic {
                 trailing_wildcard, ..
-            } => return trailing_wildcard.clone(),
-            Self::Real {
-                best_match, path, ..
-            } => (best_match, path),
+            } => return trailing_wildcard.into(),
+            Self::Real { captures, path, .. } => (captures, path),
         };
 
-        best_match
-            .captures()
+        captures
             .wildcard()
             .map(|s|
             // Backward compatibility considerations - Spin has traditionally
             // captured trailing slashes, but routefinder does not.
             match (s.is_empty(), path.ends_with('/')) {
                 // route: /foo/..., path: /foo
-                (true, false) => s.to_owned(),
+                (true, false) => s.into(),
                 // route: /foo/..., path: /foo/
-                (true, true) => "/".to_owned(),
+                (true, true) => "/".into(),
                 // route: /foo/..., path: /foo/bar
-                (false, false) => format!("/{s}"),
+                (false, false) => format!("/{s}").into(),
                 // route: /foo/..., path: /foo/bar/
-                (false, true) => format!("/{s}/"),
+                (false, true) => format!("/{s}/").into(),
             })
             .unwrap_or_default()
     }

crates/http/src/wagi/mod.rs

@@ -105,7 +105,7 @@ pub fn build_headers(
     // https://datatracker.ietf.org/doc/html/rfc3875#section-4.1.13
     headers.insert(
         "SCRIPT_NAME".to_owned(),
-        route_match.based_route_or_prefix(),
+        route_match.based_route_or_prefix().to_owned(),
     );
     // PATH_INFO is any path information after SCRIPT_NAME
     //
@@ -117,7 +117,10 @@ pub fn build_headers(
     // https://datatracker.ietf.org/doc/html/rfc3875#section-4.1.5
     let pathsegment = path_info;
     let pathinfo = percent_encoding::percent_decode_str(&pathsegment).decode_utf8_lossy();
-    headers.insert("X_RAW_PATH_INFO".to_owned(), pathsegment.clone());
+    headers.insert(
+        "X_RAW_PATH_INFO".to_owned(),
+        pathsegment.as_ref().to_owned(),
+    );
     headers.insert("PATH_INFO".to_owned(), pathinfo.to_string());
     // PATH_TRANSLATED is the url-decoded version of PATH_INFO
     // https://datatracker.ietf.org/doc/html/rfc3875#section-4.1.6

crates/trigger-http/src/headers.rs

@@ -1,4 +1,8 @@
-use std::{net::SocketAddr, str, str::FromStr};
+use std::{
+    borrow::Cow,
+    net::SocketAddr,
+    str::{self, FromStr},
+};
 
 use anyhow::Result;
 use http::Uri;
@@ -21,23 +25,23 @@ pub const RAW_COMPONENT_ROUTE: [&str; 2] = ["SPIN_RAW_COMPONENT_ROUTE", "X_RAW_C
 pub const BASE_PATH: [&str; 2] = ["SPIN_BASE_PATH", "X_BASE_PATH"];
 pub const CLIENT_ADDR: [&str; 2] = ["SPIN_CLIENT_ADDR", "X_CLIENT_ADDR"];
 
-pub fn compute_default_headers(
+pub fn compute_default_headers<'a>(
     uri: &Uri,
     host: &str,
-    route_match: &RouteMatch,
+    route_match: &'a RouteMatch,
     client_addr: SocketAddr,
-) -> anyhow::Result<Vec<([String; 2], String)>> {
-    fn owned(strs: &[&'static str; 2]) -> [String; 2] {
-        [strs[0].to_owned(), strs[1].to_owned()]
+) -> anyhow::Result<Vec<([Cow<'static, str>; 2], Cow<'a, str>)>> {
+    fn owned(strs: &[&'static str; 2]) -> [Cow<'static, str>; 2] {
+        [strs[0].into(), strs[1].into()]
     }
 
-    let owned_full_url: [String; 2] = owned(&FULL_URL);
-    let owned_path_info: [String; 2] = owned(&PATH_INFO);
-    let owned_matched_route: [String; 2] = owned(&MATCHED_ROUTE);
-    let owned_component_route: [String; 2] = owned(&COMPONENT_ROUTE);
-    let owned_raw_component_route: [String; 2] = owned(&RAW_COMPONENT_ROUTE);
-    let owned_base_path: [String; 2] = owned(&BASE_PATH);
-    let owned_client_addr: [String; 2] = owned(&CLIENT_ADDR);
+    let owned_full_url = owned(&FULL_URL);
+    let owned_path_info = owned(&PATH_INFO);
+    let owned_matched_route = owned(&MATCHED_ROUTE);
+    let owned_component_route = owned(&COMPONENT_ROUTE);
+    let owned_raw_component_route = owned(&RAW_COMPONENT_ROUTE);
+    let owned_base_path = owned(&BASE_PATH);
+    let owned_client_addr = owned(&CLIENT_ADDR);
 
     let mut res = vec![];
     let abs_path = uri
@@ -52,21 +56,21 @@ pub fn compute_default_headers(
     let full_url = format!("{}://{}{}", scheme, host, abs_path);
 
     res.push((owned_path_info, path_info));
-    res.push((owned_full_url, full_url));
-    res.push((owned_matched_route, route_match.based_route().to_string()));
+    res.push((owned_full_url, full_url.into()));
+    res.push((owned_matched_route, route_match.based_route().into()));
 
-    res.push((owned_base_path, "/".to_string()));
+    res.push((owned_base_path, "/".into()));
+    res.push((owned_raw_component_route, route_match.raw_route().into()));
     res.push((
-        owned_raw_component_route,
-        route_match.raw_route().to_string(),
+        owned_component_route,
+        route_match.raw_route_or_prefix().into(),
     ));
-    res.push((owned_component_route, route_match.raw_route_or_prefix()));
-    res.push((owned_client_addr, client_addr.to_string()));
+    res.push((owned_client_addr, client_addr.to_string().into()));
 
     for (wild_name, wild_value) in route_match.named_wildcards() {
-        let wild_header = format!("SPIN_PATH_MATCH_{}", wild_name.to_ascii_uppercase()); // TODO: safer
-        let wild_wagi_header = format!("X_PATH_MATCH_{}", wild_name.to_ascii_uppercase()); // TODO: safer
-        res.push(([wild_header, wild_wagi_header], wild_value.clone()));
+        let wild_header = format!("SPIN_PATH_MATCH_{}", wild_name.to_ascii_uppercase()).into();
+        let wild_wagi_header = format!("X_PATH_MATCH_{}", wild_name.to_ascii_uppercase()).into();
+        res.push(([wild_header, wild_wagi_header], wild_value.into()));
     }
 
     Ok(res)
@@ -110,7 +114,7 @@ pub fn prepare_request_headers(
     // In the future, we might want to have this information in a context
     // object as opposed to headers.
     for (keys, val) in compute_default_headers(req.uri(), host, route_match, client_addr)? {
-        res.push((prepare_header_key(&keys[0]), val));
+        res.push((prepare_header_key(&keys[0]), val.into_owned()));
     }
 
     Ok(res)
@@ -138,6 +142,8 @@ fn prepare_header_key(key: &str) -> String {
 
 #[cfg(test)]
 mod tests {
+    use std::borrow::Cow;
+
     use super::*;
     use anyhow::Result;
     use spin_http::routes::Router;
@@ -318,11 +324,14 @@ mod tests {
         assert!(req.headers().get("Host").is_some());
     }
 
-    fn search(keys: &[&str; 2], headers: &[([String; 2], String)]) -> Option<String> {
+    fn search(
+        keys: &[&str; 2],
+        headers: &[([Cow<'static, str>; 2], Cow<'_, str>)],
+    ) -> Option<String> {
         let mut res: Option<String> = None;
         for (k, v) in headers {
             if k[0] == keys[0] && k[1] == keys[1] {
-                res = Some(v.clone());
+                res = Some(v.as_ref().to_owned());
             }
         }
 

crates/trigger-http/src/wagi.rs

@@ -71,7 +71,7 @@ impl HttpExecutor for WagiHttpExecutor<'_> {
         // `PATH_INFO`, or `X_FULL_URL`).
         // Note that this overrides any existing headers previously set by Wagi.
         for (keys, val) in compute_default_headers(&parts.uri, host, route_match, client_addr)? {
-            headers.insert(keys[1].to_string(), val);
+            headers.insert(keys[1].to_string(), val.into_owned());
         }
 
         let stdout = MemoryOutputPipe::new(usize::MAX);