Per-endpoint configuration

examples/configuration.rs

@@ -0,0 +1,29 @@
+#![feature(async_await, futures_api)]
+
+use tide::{head::Path, ExtractConfiguration};
+
+/// A type that represents how much value will be added by the `add` handler.
+#[derive(Clone, Default)]
+struct IncreaseBy(i32);
+
+async fn add(
+    Path(base): Path<i32>,
+    // `ExtractConfiguration` will extract the configuration item of given type, and provide it as
+    // `Option<T>`. If it is not set, the inner value will be `None`.
+    ExtractConfiguration(amount): ExtractConfiguration<IncreaseBy>,
+) -> String {
+    let IncreaseBy(amount) = amount.unwrap_or_default();
+    format!("{} plus {} is {}", base, amount, base + amount)
+}
+
+fn main() {
+    let mut app = tide::App::new(());
+    // `App::config` sets the default configuration of the app (that is, a top-level router).
+    app.config(IncreaseBy(1));
+    app.at("add_one/{}").get(add); // `IncreaseBy` is set to 1
+    app.at("add_two/{}").get(add).config(IncreaseBy(2)); // `IncreaseBy` is overridden to 2
+
+    let address = "127.0.0.1:8000".to_owned();
+    println!("Server is listening on http://{}", address);
+    app.serve(address);
+}

src/app.rs

@@ -5,17 +5,19 @@ use futures::{
 };
 use hyper::service::Service;
 use std::{
+    any::Any,
     ops::{Deref, DerefMut},
     sync::Arc,
 };
 
 use crate::{
     body::Body,
+    configuration::Configuration,
     endpoint::BoxedEndpoint,
     endpoint::Endpoint,
     extract::Extract,
     middleware::{logger::RootLogger, RequestContext},
-    router::{Resource, RouteResult, Router},
+    router::{EndpointData, Resource, RouteResult, Router},
     Middleware, Request, Response, RouteMatch,
 };
 
@@ -84,7 +86,7 @@ use crate::{
 pub struct App<Data> {
     data: Data,
     router: Router<Data>,
-    default_handler: BoxedEndpoint<Data>,
+    default_handler: EndpointData<Data>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> App<Data> {
@@ -94,7 +96,10 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         let mut app = App {
             data,
             router: Router::new(),
-            default_handler: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
+            default_handler: EndpointData {
+                endpoint: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
+                config: Configuration::new(),
+            },
         };
 
         // Add RootLogger as a default middleware
@@ -114,9 +119,16 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
     }
 
     /// Set the default handler for the app, a fallback function when there is no match to the route requested
-    pub fn default_handler<T: Endpoint<Data, U>, U>(&mut self, handler: T) -> &mut Self {
-        self.default_handler = BoxedEndpoint::new(handler);
-        self
+    pub fn default_handler<T: Endpoint<Data, U>, U>(
+        &mut self,
+        handler: T,
+    ) -> &mut EndpointData<Data> {
+        let endpoint = EndpointData {
+            endpoint: BoxedEndpoint::new(handler),
+            config: self.router.config_base.clone(),
+        };
+        self.default_handler = endpoint;
+        &mut self.default_handler
     }
 
     /// Apply `middleware` to the whole app. Note that the order of nesting subrouters and applying
@@ -126,7 +138,14 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         self
     }
 
-    fn into_server(self) -> Server<Data> {
+    /// Add a default configuration `item` for the whole app.
+    pub fn config<T: Any + Clone + Send + Sync>(&mut self, item: T) -> &mut Self {
+        self.router.config(item);
+        self
+    }
+
+    fn into_server(mut self) -> Server<Data> {
+        self.router.apply_default_config();
         Server {
             data: self.data,
             router: Arc::new(self.router),
@@ -162,7 +181,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
 struct Server<Data> {
     data: Data,
     router: Arc<Router<Data>>,
-    default_handler: Arc<BoxedEndpoint<Data>>,
+    default_handler: Arc<EndpointData<Data>>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> Service for Server<Data> {
@@ -223,7 +242,12 @@ impl<T> DerefMut for AppData<T> {
 
 impl<T: Clone + Send + 'static> Extract<T> for AppData<T> {
     type Fut = future::Ready<Result<Self, Response>>;
-    fn extract(data: &mut T, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut T,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         future::ok(AppData(data.clone()))
     }
 }

src/body.rs

@@ -80,7 +80,7 @@ use pin_utils::pin_mut;
 use std::io::Cursor;
 use std::ops::{Deref, DerefMut};
 
-use crate::{Extract, IntoResponse, Request, Response, RouteMatch};
+use crate::{configuration::Configuration, Extract, IntoResponse, Request, Response, RouteMatch};
 
 /// The raw contents of an http request or response.
 ///
@@ -202,7 +202,12 @@ impl<S: 'static> Extract<S> for MultipartForm {
     // Note: cannot use `existential type` here due to ICE
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         // https://stackoverflow.com/questions/43424982/how-to-parse-multipart-forms-using-abonander-multipart-with-rocket
 
         const BOUNDARY: &str = "boundary=";
@@ -248,7 +253,12 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
     // Note: cannot use `existential type` here due to ICE
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
         FutureObj::new(Box::new(
             async move {
@@ -295,7 +305,12 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
     // Note: cannot use `existential type` here due to ICE
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
         FutureObj::new(Box::new(
             async move {
@@ -338,7 +353,12 @@ pub struct Str(pub String);
 impl<S: 'static> Extract<S> for Str {
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
 
         FutureObj::new(Box::new(
@@ -369,7 +389,12 @@ pub struct StrLossy(pub String);
 impl<S: 'static> Extract<S> for StrLossy {
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
 
         FutureObj::new(Box::new(
@@ -400,7 +425,12 @@ pub struct Bytes(pub Vec<u8>);
 impl<S: 'static> Extract<S> for Bytes {
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(data: &mut S, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
 
         FutureObj::new(Box::new(

src/configuration.rs

@@ -0,0 +1,128 @@
+//! Types for managing and extracting configuration.
+
+use std::any::{Any, TypeId};
+use std::collections::HashMap;
+
+use futures::future::FutureObj;
+
+use crate::{Extract, Request, Response, RouteMatch};
+
+trait ConfigurationItem: Any + Send + Sync {
+    fn clone_any(&self) -> Box<dyn ConfigurationItem>;
+    fn as_dyn_any(&self) -> &(dyn Any + Send + Sync);
+    fn as_dyn_any_mut(&mut self) -> &mut (dyn Any + Send + Sync);
+}
+
+impl<T> ConfigurationItem for T
+where
+    T: Any + Clone + Send + Sync,
+{
+    fn clone_any(&self) -> Box<dyn ConfigurationItem> {
+        Box::new(self.clone())
+    }
+
+    fn as_dyn_any(&self) -> &(dyn Any + Send + Sync) {
+        self
+    }
+
+    fn as_dyn_any_mut(&mut self) -> &mut (dyn Any + Send + Sync) {
+        self
+    }
+}
+
+impl Clone for Box<dyn ConfigurationItem> {
+    fn clone(&self) -> Box<dyn ConfigurationItem> {
+        (&**self).clone_any()
+    }
+}
+
+/// A cloneable typemap for saving per-endpoint configuration.
+///
+/// Configuration is mostly managed by `App` and `Router`, so this is normally not used directly.
+#[derive(Clone)]
+pub struct Configuration(HashMap<TypeId, Box<dyn ConfigurationItem>>);
+
+impl Configuration {
+    pub(crate) fn new() -> Self {
+        Configuration(HashMap::new())
+    }
+
+    pub(crate) fn merge(&mut self, base: &Configuration) {
+        let overlay = std::mem::replace(&mut self.0, base.0.clone());
+        self.0.extend(overlay);
+    }
+
+    /// Retrieve the configuration item of given type, returning `None` if it is not found.
+    pub fn read<T: Any + Clone + Send + Sync>(&self) -> Option<&T> {
+        let id = TypeId::of::<T>();
+        self.0
+            .get(&id)
+            .and_then(|v| (**v).as_dyn_any().downcast_ref::<T>())
+    }
+
+    /// Save the given configuration item.
+    pub fn write<T: Any + Clone + Send + Sync>(&mut self, value: T) {
+        let id = TypeId::of::<T>();
+        self.0
+            .insert(id, Box::new(value) as Box<dyn ConfigurationItem>);
+    }
+}
+
+/// An extractor for reading configuration from endpoints.
+///
+/// It will try to retrieve the given configuration item. If it is not set, the extracted value
+/// will be `None`.
+pub struct ExtractConfiguration<T>(pub Option<T>);
+
+impl<S: 'static, T: Any + Clone + Send + Sync + 'static> Extract<S> for ExtractConfiguration<T> {
+    type Fut = FutureObj<'static, Result<Self, Response>>;
+
+    fn extract(
+        data: &mut S,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        config: &Configuration,
+    ) -> Self::Fut {
+        let config_item = config.read().cloned();
+        FutureObj::new(Box::new(
+            async move { Ok(ExtractConfiguration(config_item)) },
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn configuration_read_write() {
+        let mut config = Configuration::new();
+        assert_eq!(config.read::<usize>(), None);
+        assert_eq!(config.read::<isize>(), None);
+        config.write(42usize);
+        config.write(-3isize);
+        assert_eq!(config.read::<usize>(), Some(&42));
+        assert_eq!(config.read::<isize>(), Some(&-3));
+        config.write(3usize);
+        assert_eq!(config.read::<usize>(), Some(&3));
+    }
+
+    #[test]
+    fn configuration_clone() {
+        let mut config = Configuration::new();
+        config.write(42usize);
+        config.write(String::from("foo"));
+
+        let mut new_config = config.clone();
+        new_config.write(3usize);
+        new_config.write(4u32);
+
+        assert_eq!(config.read::<usize>(), Some(&42));
+        assert_eq!(config.read::<u32>(), None);
+        assert_eq!(config.read::<String>(), Some(&"foo".into()));
+
+        assert_eq!(new_config.read::<usize>(), Some(&3));
+        assert_eq!(new_config.read::<u32>(), Some(&4));
+        assert_eq!(new_config.read::<String>(), Some(&"foo".into()));
+    }
+}