Merge branch 'routes' into allow-async-handlers

examples/routing.rs

@@ -16,25 +16,27 @@ async fn main() -> Result<()> {
         .await
 }
 
-async fn handle_base(_: Request) -> Result<Response> {
+async fn handle_base(req: Request) -> Result<Response> {
-    let doc = generate_doc("base");
+    let doc = generate_doc("base", &req);
     Ok(Response::document(doc))
 }
 
-async fn handle_short(_: Request) -> Result<Response> {
+async fn handle_short(req: Request) -> Result<Response> {
-    let doc = generate_doc("short");
+    let doc = generate_doc("short", &req);
     Ok(Response::document(doc))
 }
 
-async fn handle_long(_: Request) -> Result<Response> {
+async fn handle_long(req: Request) -> Result<Response> {
-    let doc = generate_doc("long");
+    let doc = generate_doc("long", &req);
     Ok(Response::document(doc))
 }
 
-fn generate_doc(route_name: &str) -> Document {
+fn generate_doc(route_name: &str, req: &Request) -> Document {
+    let trailing = req.trailing_segments().join("/");
     let mut doc = Document::new();
     doc.add_heading(HeadingLevel::H1, "Routing Demo")
        .add_text(&format!("You're currently on the {} route", route_name))
+       .add_text(&format!("Trailing segments: /{}", trailing))
        .add_blank_line()
        .add_text("Here's some links to try:")
        .add_link_without_label("/")

src/lib.rs

@@ -36,14 +36,14 @@ pub use types::*;
 pub const REQUEST_URI_MAX_LEN: usize = 1024;
 pub const GEMINI_PORT: u16 = 1965;
 
-pub (crate) type Handler = Arc<dyn Fn(Request) -> HandlerResponse + Send + Sync>;
+type Handler = Arc<dyn Fn(Request) -> HandlerResponse + Send + Sync>;
 pub (crate) type HandlerResponse = Pin<Box<dyn Future<Output = Result<Response>> + Send>>;
 
 #[derive(Clone)]
 pub struct Server {
     tls_acceptor: TlsAcceptor,
     listener: Arc<TcpListener>,
-    routes: Arc<RoutingNode>,
+    routes: Arc<RoutingNode<Handler>>,
     timeout: Duration,
     complex_timeout: Option<Duration>,
 }
@@ -96,7 +96,9 @@ impl Server {
 
         request.set_cert(client_cert);
 
-        let response = if let Some(handler) = self.routes.match_request(&request) {
+        let response = if let Some((trailing, handler)) = self.routes.match_request(&request) {
+
+            request.set_trailing(trailing);
 
             let handler = (handler)(request);
             let handler = AssertUnwindSafe(handler);
@@ -171,7 +173,7 @@ pub struct Builder<A> {
     key_path: PathBuf,
     timeout: Duration,
     complex_body_timeout_override: Option<Duration>,
-    routes: RoutingNode,
+    routes: RoutingNode<Handler>,
 }
 
 impl<A: ToSocketAddrs> Builder<A> {

src/routing.rs

@@ -2,21 +2,19 @@
 //!
 //! See [`RoutingNode`] for details on how routes are matched.
 
-use uriparse::path::Path;
+use uriparse::path::{Path, Segment};
 
 use std::collections::HashMap;
 use std::convert::TryInto;
 
-use crate::Handler;
 use crate::types::Request;
 
-#[derive(Default)]
+/// A node for linking values to routes
-/// A node for routing requests
 ///
 /// Routing is processed by a tree, with each child being a single path segment.  For
-/// example, if a handler existed at "/trans/rights", then the root-level node would have
+/// example, if an entry existed at "/trans/rights", then the root-level node would have
 /// a child "trans", which would have a child "rights".  "rights" would have no children,
-/// but would have an attached handler.
+/// but would have an attached entry.
 ///
 /// If one route is shorter than another, say "/trans/rights" and
 /// "/trans/rights/r/human", then the longer route always matches first, so a request for
@@ -25,48 +23,73 @@ use crate::types::Request;
 ///
 /// Routing is only performed on normalized paths, so "/endpoint" and "/endpoint/" are
 /// considered to be the same route.
-pub struct RoutingNode(Option<Handler>, HashMap<String, Self>);
+pub struct RoutingNode<T>(Option<T>, HashMap<String, Self>);
 
-impl RoutingNode {
+impl<T> RoutingNode<T> {
-    /// Attempt to identify a handler based on path segments
+    /// Attempt to find and entry based on path segments
     ///
     /// This searches the network of routing nodes attempting to match a specific request,
     /// represented as a sequence of path segments.  For example, "/dir/image.png?text"
     /// should be represented as `&["dir", "image.png"]`.
     ///
+    /// If a match is found, it is returned, along with the segments of the path trailing
+    /// the subpath matcing the route.  For example, a route `/foo` recieving a request to
+    /// `/foo/bar` would produce `vec!["bar"]`
+    ///
     /// See [`RoutingNode`] for details on how routes are matched.
-    pub fn match_path<I,S>(&self, path: I) -> Option<&Handler>
+    pub fn match_path<I,S>(&self, path: I) -> Option<(Vec<S>, &T)>
     where
         I: IntoIterator<Item=S>,
         S: AsRef<str>,
     {
         let mut node = self;
-        let mut path = path.into_iter();
+        let mut path = path.into_iter().filter(|seg| !seg.as_ref().is_empty());
         let mut last_seen_handler = None;
+        let mut since_last_handler = Vec::new();
         loop {
             let Self(maybe_handler, map) = node;
 
-            last_seen_handler = maybe_handler.as_ref().or(last_seen_handler);
+            if maybe_handler.is_some() {
+                last_seen_handler = maybe_handler.as_ref();
+                since_last_handler.clear();
+            }
 
             if let Some(segment) = path.next() {
-                if let Some(route) = map.get(segment.as_ref()) {
+                let maybe_route = map.get(segment.as_ref());
+                since_last_handler.push(segment);
+
+                if let Some(route) = maybe_route {
                     node = route;
                 } else {
-                    return last_seen_handler;
+                    break;
                 }
             } else {
-                return last_seen_handler;
+                break;
             }
+        };
+
+        if let Some(handler) = last_seen_handler {
+            since_last_handler.extend(path);
+            Some((since_last_handler, handler))
+        } else {
+            None
         }
     }
 
     /// Attempt to identify a route for a given [`Request`]
     ///
-    /// See [`RoutingNode`] for details on how routes are matched.
+    /// See [`RoutingNode::match_path()`] for more information
-    pub fn match_request(&self, req: &Request) -> Option<&Handler> {
+    pub fn match_request(&self, req: &Request) -> Option<(Vec<String>, &T)> {
-        let mut path = req.path().to_owned();
+        let mut path = req.path().to_borrowed();
         path.normalize(false);
         self.match_path(path.segments())
+            .map(|(segs, h)| (
+                segs.into_iter()
+                    .map(Segment::as_str)
+                    .map(str::to_owned)
+                    .collect(),
+                h,
+            ))
     }
 
     /// Add a route to the network
@@ -76,9 +99,9 @@ impl RoutingNode {
     /// static strings.  If you would like to add a string dynamically, please use
     /// [`RoutingNode::add_route_by_path()`] in order to appropriately deal with any
     /// errors that might arise.
-    pub fn add_route(&mut self, path: &'static str, handler: Handler) {
+    pub fn add_route(&mut self, path: &'static str, data: T) {
         let path: Path = path.try_into().expect("Malformed path route received");
-        self.add_route_by_path(path, handler).unwrap();
+        self.add_route_by_path(path, data).unwrap();
     }
 
     /// Add a route to the network
@@ -87,7 +110,7 @@ impl RoutingNode {
     /// this method.
     ///
     /// For information about how routes work, see [`RoutingNode::match_path()`]
-    pub fn add_route_by_path(&mut self, mut path: Path, handler: Handler) -> Result<(), ConflictingRouteError>{
+    pub fn add_route_by_path(&mut self, mut path: Path, data: T) -> Result<(), ConflictingRouteError>{
         debug_assert!(path.is_absolute());
         path.normalize(false);
 
@@ -101,7 +124,7 @@ impl RoutingNode {
         if node.0.is_some() {
             Err(ConflictingRouteError())
         } else {
-            node.0 = Some(handler);
+            node.0 = Some(data);
             Ok(())
         }
     }
@@ -116,6 +139,12 @@ impl RoutingNode {
     }
 }
 
+impl<T> Default for RoutingNode<T> {
+    fn default() -> Self {
+        Self(None, HashMap::default())
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct ConflictingRouteError();
 

src/types/request.rs

@@ -8,6 +8,7 @@ pub struct Request {
     uri: URIReference<'static>,
     input: Option<String>,
     certificate: Option<Certificate>,
+    trailing_segments: Option<Vec<String>>,
 }
 
 impl Request {
@@ -36,6 +37,7 @@ impl Request {
             uri,
             input,
             certificate,
+            trailing_segments: None,
         })
     }
 
@@ -43,6 +45,31 @@ impl Request {
         &self.uri
     }
 
+    #[allow(clippy::missing_const_for_fn)]
+    /// All of the path segments following the route to which this request was bound.
+    ///
+    /// For example, if this handler was bound to the `/api` route, and a request was
+    /// received to `/api/v1/endpoint`, then this value would be `["v1", "endpoint"]`.
+    /// This should not be confused with [`path_segments()`](Self::path_segments()), which
+    /// contains *all* of the segments, not just those trailing the route.
+    ///
+    /// If the trailing segments have not been set, this method will panic, but this
+    /// should only be possible if you are constructing the Request yourself.  Requests
+    /// to handlers registered through [`add_route`](northstar::Builder::add_route()) will
+    /// always have trailing segments set.
+    pub fn trailing_segments(&self) -> &Vec<String> {
+        self.trailing_segments.as_ref().unwrap()
+    }
+
+    /// All of the segments in this path, percent decoded
+    ///
+    /// For example, for a request to `/api/v1/endpoint`, this would return `["api", "v1",
+    /// "endpoint"]`, no matter what route the handler that recieved this request was
+    /// bound to.  This is not to be confused with
+    /// [`trailing_segments()`](Self::trailing_segments), which contains only the segments
+    /// following the bound route.
+    ///
+    /// Additionally, unlike `trailing_segments()`, this method percent decodes the path.
     pub fn path_segments(&self) -> Vec<String> {
         self.uri()
             .path()
@@ -60,6 +87,10 @@ impl Request {
         self.certificate = cert;
     }
 
+    pub fn set_trailing(&mut self, segments: Vec<String>) {
+        self.trailing_segments = Some(segments);
+    }
+
     pub const fn certificate(&self) -> Option<&Certificate> {
         self.certificate.as_ref()
     }