From 59e3222ce8513b591f43be0b2fac4b6502c6c27a Mon Sep 17 00:00:00 2001 From: Emi Tatsuo Date: Fri, 20 Nov 2020 13:22:34 -0500 Subject: [PATCH] Add trailing segments to request --- examples/routing.rs | 16 +++++++++------- src/lib.rs | 4 +++- src/routing.rs | 45 ++++++++++++++++++++++++++++++++++---------- src/types/request.rs | 31 ++++++++++++++++++++++++++++++ 4 files changed, 78 insertions(+), 18 deletions(-) diff --git a/examples/routing.rs b/examples/routing.rs index 742a620..04bded6 100644 --- a/examples/routing.rs +++ b/examples/routing.rs @@ -18,31 +18,33 @@ async fn main() -> Result<()> { .await } -fn handle_base(_: Request) -> BoxFuture<'static, Result> { - let doc = generate_doc("base"); +fn handle_base(req: Request) -> BoxFuture<'static, Result> { + let doc = generate_doc("base", &req); async move { Ok(Response::document(doc)) }.boxed() } -fn handle_short(_: Request) -> BoxFuture<'static, Result> { - let doc = generate_doc("short"); +fn handle_short(req: Request) -> BoxFuture<'static, Result> { + let doc = generate_doc("short", &req); async move { Ok(Response::document(doc)) }.boxed() } -fn handle_long(_: Request) -> BoxFuture<'static, Result> { - let doc = generate_doc("long"); +fn handle_long(req: Request) -> BoxFuture<'static, Result> { + let doc = generate_doc("long", &req); async move { Ok(Response::document(doc)) }.boxed() } -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("/") diff --git a/src/lib.rs b/src/lib.rs index 1812967..2aa41e0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -95,7 +95,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); diff --git a/src/routing.rs b/src/routing.rs index 28966cb..1179601 100644 --- a/src/routing.rs +++ b/src/routing.rs @@ -2,7 +2,7 @@ //! //! 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; @@ -34,39 +34,64 @@ impl RoutingNode { /// 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 handler. For example, a route `/foo` recieving a request to `/foo/bar` would + /// receive `vec!["bar"]` + /// /// See [`RoutingNode`] for details on how routes are matched. - pub fn match_path(&self, path: I) -> Option<&Handler> + pub fn match_path(&self, path: I) -> Option<(Vec, &Handler)> where I: IntoIterator, S: AsRef, { 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. - pub fn match_request(&self, req: &Request) -> Option<&Handler> { - let mut path = req.path().to_owned(); + /// See [`RoutingNode::match_path()`] for more information + pub fn match_request(&self, req: &Request) -> Option<(Vec, &Handler)> { + 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 diff --git a/src/types/request.rs b/src/types/request.rs index 76eace2..02d841b 100644 --- a/src/types/request.rs +++ b/src/types/request.rs @@ -8,6 +8,7 @@ pub struct Request { uri: URIReference<'static>, input: Option, certificate: Option, + trailing_segments: Option>, } 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 { + 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 { self.uri() .path() @@ -60,6 +87,10 @@ impl Request { self.certificate = cert; } + pub fn set_trailing(&mut self, segments: Vec) { + self.trailing_segments = Some(segments); + } + pub const fn certificate(&self) -> Option<&Certificate> { self.certificate.as_ref() }