Emi/kochab
Emi/kochab
1
1
Fork 0
Code Issues Pull requests Releases Activity

Merge branch 'routes' into allow-async-handlers

Browse source
This commit is contained in:
Emi Tatsuo 2020-11-20 14:00:49 -05:00
parent f0798b66a3 536e404fdf
commit 2604b02e2b
Signed by: Emi
GPG key ID: 68FAB2E2E6DFC98B
4 changed files with 97 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
examples/routing.rs
View file

@ -16,25 +16,27 @@ async fn main() -> Result<()> {
.await
}
async fn handle_base(_: Request) -> Result<Response> {
let doc = generate_doc("base");
async fn handle_base(req: Request) -> Result<Response> {
let doc = generate_doc("base", &req);
Ok(Response::document(doc))
}
async fn handle_short(_: Request) -> Result<Response> {
let doc = generate_doc("short");
async fn handle_short(req: Request) -> Result<Response> {
let doc = generate_doc("short", &req);
Ok(Response::document(doc))
}
async fn handle_long(_: Request) -> Result<Response> {
let doc = generate_doc("long");
async fn handle_long(req: Request) -> Result<Response> {
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("/")

10
src/lib.rs
View file

@ -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> {

73
src/routing.rs
View file

@ -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 routing requests
/// A node for linking values to routes
///
/// 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 {
/// Attempt to identify a handler based on path segments
impl<T> RoutingNode<T> {
/// 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.
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<String>, &T)> {
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();

31
src/types/request.rs
View file

@ -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()
}