Refactor selection/routing to just use Next as an endpoint

nyxtom · nyxtom · commit e21b4edf02ac · 2022-07-18T22:22:41.000-05:00
diff --git a/src/endpoint.rs b/src/endpoint.rs
@@ -1,10 +1,8 @@
 use async_std::future::Future;
-use async_std::sync::Arc;
 use async_trait::async_trait;
 use http_types::Result;
 
-use crate::middleware::Next;
-use crate::{Middleware, Request, Response};
+use crate::{Request, Response};
 
 /// An HTTP request handler.
 ///
@@ -50,8 +48,6 @@ pub trait Endpoint: Send + Sync + 'static {
     async fn call(&self, req: Request) -> crate::Result;
 }
 
-pub(crate) type DynEndpoint = dyn Endpoint;
-
 #[async_trait]
 impl<F, Fut, Res> Endpoint for F
 where
@@ -66,60 +62,6 @@ where
     }
 }
 
-pub(crate) struct MiddlewareEndpoint<E> {
-    endpoint: Arc<E>,
-    middleware: Arc<Vec<Arc<dyn Middleware>>>,
-}
-
-impl<E: Clone> Clone for MiddlewareEndpoint<E> {
-    fn clone(&self) -> Self {
-        Self {
-            endpoint: self.endpoint.clone(),
-            middleware: self.middleware.clone(),
-        }
-    }
-}
-
-impl<E> std::fmt::Debug for MiddlewareEndpoint<E> {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            fmt,
-            "MiddlewareEndpoint (length: {})",
-            self.middleware.len(),
-        )
-    }
-}
-
-impl<E> MiddlewareEndpoint<E>
-where
-    E: Endpoint,
-{
-    pub(crate) fn wrap_with_middleware(
-        ep: E,
-        middleware: Vec<Arc<dyn Middleware>>,
-    ) -> Arc<dyn Endpoint + Send + Sync + 'static> {
-        if middleware.is_empty() {
-            Arc::new(ep)
-        } else {
-            Arc::new(Self {
-                endpoint: Arc::new(ep),
-                middleware: Arc::new(middleware),
-            })
-        }
-    }
-}
-
-#[async_trait]
-impl<E> Endpoint for MiddlewareEndpoint<E>
-where
-    E: Endpoint,
-{
-    async fn call(&self, req: Request) -> crate::Result {
-        let next = Next::new(self.endpoint.clone(), self.middleware.clone());
-        Ok(next.run(req).await)
-    }
-}
-
 #[async_trait]
 impl Endpoint for Box<dyn Endpoint> {
     async fn call(&self, request: Request) -> crate::Result {
diff --git a/src/middleware.rs b/src/middleware.rs
@@ -42,10 +42,28 @@ pub struct Next {
 
 impl Next {
     /// Creates a new Next middleware with an arc to the endpoint and middleware
-    pub fn new(endpoint: Arc<dyn Endpoint>, middleware: Arc<Vec<Arc<dyn Middleware>>>) -> Self {
+    pub fn new(endpoint: impl Endpoint, middleware: Vec<Arc<dyn Middleware>>) -> Self {
         Self {
             cursor: 0,
-            endpoint,
+            endpoint: Arc::new(endpoint),
+            middleware: Arc::new(middleware),
+        }
+    }
+
+    /// Creates a new Next middleware from the given endpoint with empty middleware
+    pub fn from_endpoint(endpoint: impl Endpoint) -> Self {
+        Self {
+            cursor: 0,
+            endpoint: Arc::new(endpoint),
+            middleware: Arc::default(),
+        }
+    }
+
+    /// Creates a new Next middleware from an existing next middleware (as an endpoint)
+    pub fn from_next(endpoint: Next, middleware: Arc<Vec<Arc<dyn Middleware>>>) -> Self {
+        Self {
+            cursor: 0,
+            endpoint: Arc::new(endpoint),
             middleware,
         }
     }
@@ -66,3 +84,22 @@ impl Next {
         }
     }
 }
+
+#[async_trait]
+impl Endpoint for Next {
+    async fn call(&self, req: Request) -> crate::Result {
+        let next = self.clone();
+        let response = next.run(req).await;
+        Ok(response)
+    }
+}
+
+impl Clone for Next {
+    fn clone(&self) -> Self {
+        Next {
+            cursor: 0,
+            endpoint: self.endpoint.clone(),
+            middleware: self.middleware.clone(),
+        }
+    }
+}
diff --git a/src/route.rs b/src/route.rs
@@ -3,9 +3,8 @@ use std::io;
 use std::path::Path;
 use std::sync::Arc;
 
-use crate::endpoint::MiddlewareEndpoint;
 use crate::fs::{ServeDir, ServeFile};
-use crate::log;
+use crate::{log, Next};
 use crate::{router::Router, Endpoint, Middleware};
 
 /// A handle to a route.
@@ -178,17 +177,11 @@ impl<'a> Route<'a> {
         if self.prefix {
             let ep = StripPrefixEndpoint::new(ep);
             let wildcard = self.at("*");
-            wildcard.router.add(
-                &wildcard.path,
-                method,
-                MiddlewareEndpoint::wrap_with_middleware(ep, wildcard.middleware.clone()),
-            );
+            let next = Next::new(ep, wildcard.middleware.clone());
+            wildcard.router.add(&wildcard.path, method, next);
         } else {
-            self.router.add(
-                &self.path,
-                method,
-                MiddlewareEndpoint::wrap_with_middleware(ep, self.middleware.clone()),
-            );
+            let next = Next::new(ep, self.middleware.clone());
+            self.router.add(&self.path, method, next);
         }
         self
     }
@@ -200,15 +193,11 @@ impl<'a> Route<'a> {
         if self.prefix {
             let ep = StripPrefixEndpoint::new(ep);
             let wildcard = self.at("*");
-            wildcard.router.add_all(
-                &wildcard.path,
-                MiddlewareEndpoint::wrap_with_middleware(ep, wildcard.middleware.clone()),
-            );
+            let next = Next::new(ep, wildcard.middleware.clone());
+            wildcard.router.add_all(&wildcard.path, next);
         } else {
-            self.router.add_all(
-                &self.path,
-                MiddlewareEndpoint::wrap_with_middleware(ep, self.middleware.clone()),
-            );
+            let next = Next::new(ep, self.middleware.clone());
+            self.router.add_all(&self.path, next);
         }
         self
     }
diff --git a/src/router.rs b/src/router.rs
@@ -1,18 +1,16 @@
 use routefinder::{Captures, Router as MethodRouter};
 use std::collections::HashMap;
-use std::sync::Arc;
 
-use crate::endpoint::DynEndpoint;
-use crate::{Request, Response, StatusCode};
+use crate::{Next, Request, Response, StatusCode};
 
 /// The routing table used by `Server`
 ///
 /// Internally, we have a separate state machine per http method; indexing
 /// by the method first allows the table itself to be more efficient.
 #[allow(missing_debug_implementations)]
 pub(crate) struct Router {
-    method_map: HashMap<http_types::Method, MethodRouter<Arc<DynEndpoint>>>,
-    all_method_router: MethodRouter<Arc<DynEndpoint>>,
+    method_map: HashMap<http_types::Method, MethodRouter<Next>>,
+    all_method_router: MethodRouter<Next>,
 }
 
 impl std::fmt::Debug for Router {
@@ -26,7 +24,7 @@ impl std::fmt::Debug for Router {
 
 /// The result of routing a URL
 pub(crate) struct Selection {
-    pub(crate) endpoint: Arc<DynEndpoint>,
+    pub(crate) next: Next,
     pub(crate) params: Captures<'static, 'static>,
 }
 
@@ -38,15 +36,15 @@ impl Router {
         }
     }
 
-    pub(crate) fn add(&mut self, path: &str, method: http_types::Method, ep: Arc<DynEndpoint>) {
+    pub(crate) fn add(&mut self, path: &str, method: http_types::Method, ep: Next) {
         self.method_map
             .entry(method)
             .or_insert_with(MethodRouter::new)
             .add(path, ep)
             .unwrap()
     }
 
-    pub(crate) fn add_all(&mut self, path: &str, ep: Arc<DynEndpoint>) {
+    pub(crate) fn add_all(&mut self, path: &str, ep: Next) {
         self.all_method_router.add(path, ep).unwrap()
     }
 
@@ -57,12 +55,12 @@ impl Router {
             .and_then(|r| r.best_match(path))
         {
             Selection {
-                endpoint: m.handler().to_owned(),
+                next: m.handler().clone(),
                 params: m.captures().into_owned(),
             }
         } else if let Some(m) = self.all_method_router.best_match(path) {
             Selection {
-                endpoint: m.handler().to_owned(),
+                next: m.handler().clone(),
                 params: m.captures().into_owned(),
             }
         } else if method == http_types::Method::Head {
@@ -79,12 +77,12 @@ impl Router {
             // If this `path` can be handled by a callback registered with a different HTTP method
             // should return 405 Method Not Allowed
             Selection {
-                endpoint: Arc::new(method_not_allowed),
+                next: Next::from_endpoint(method_not_allowed),
                 params: Captures::default(),
             }
         } else {
             Selection {
-                endpoint: Arc::new(not_found_endpoint),
+                next: Next::from_endpoint(not_found_endpoint),
                 params: Captures::default(),
             }
         }
diff --git a/src/server.rs b/src/server.rs
@@ -6,10 +6,10 @@ use async_std::sync::Arc;
 #[cfg(feature = "cookies")]
 use crate::cookies;
 use crate::listener::{Listener, ToListener};
-use crate::log;
-use crate::middleware::{Middleware, Next};
+use crate::middleware::Middleware;
 use crate::router::{Router, Selection};
 use crate::state::StateMiddleware;
+use crate::{log, Next};
 use crate::{Endpoint, Request, Route};
 
 /// An HTTP server.
@@ -271,10 +271,10 @@ impl Server {
         let req = req.into();
 
         let method = req.method().to_owned();
-        let Selection { endpoint, params } = self.router.route(req.url().path(), method);
+        let Selection { next, params } = self.router.route(req.url().path(), method);
         let route_params = vec![params];
         let req = Request::new(req, route_params);
-        let next = Next::new(endpoint, self.middleware.clone());
+        let next = Next::from_next(next, self.middleware.clone());
         let res = next.run(req).await;
         let res: http_types::Response = res.into();
         Ok(res.into())
@@ -307,10 +307,10 @@ impl Endpoint for Server {
         let path = req.url().path().to_owned();
         let method = req.method().to_owned();
 
-        let Selection { endpoint, params } = self.router.route(&path, method);
+        let Selection { next, params } = self.router.route(&path, method);
         route_params.push(params);
         let req = Request::new(req, route_params);
-        let next = Next::new(endpoint, self.middleware.clone());
+        let next = Next::from_next(next, self.middleware.clone());
         Ok(next.run(req).await)
     }
 }
