Update Next to use cursors with Arc references

- Removes for<'a> and <'_> &'a lifetimes on Next
- Changes all references to endpoints and middleware to use Arc<T>
- Updates selection routing to return Arc handlers instead of Boxed
- Simplfy server respond to pass along endpoint and middleware

Author: nyxtom

examples/middleware.rs

@@ -25,10 +25,7 @@ impl UserDatabase {
 // This is an example of a function middleware that uses the
 // application state. Because it depends on a specific request state,
 // it would likely be closely tied to a specific application
-fn user_loader<'a>(
-    mut request: Request,
-    next: Next<'a>,
-) -> Pin<Box<dyn Future<Output = Result> + Send + 'a>> {
+fn user_loader(mut request: Request, next: Next) -> Pin<Box<dyn Future<Output = Result> + Send>> {
     Box::pin(async {
         if let Some(user) = request.state().find_user().await {
             tide::log::trace!("user loaded", {user: user.name});
@@ -62,7 +59,7 @@ struct RequestCount(usize);
 
 #[tide::utils::async_trait]
 impl Middleware for RequestCounterMiddleware {
-    async fn handle(&self, mut req: Request, next: Next<'_>) -> Result {
+    async fn handle(&self, mut req: Request, next: Next) -> Result {
         let count = self.requests_counted.fetch_add(1, Ordering::Relaxed);
         tide::log::trace!("request counter", { count: count });
         req.set_ext(RequestCount(count));

src/cookies/middleware.rs

@@ -35,8 +35,8 @@ impl CookiesMiddleware {
 }
 
 #[async_trait]
-impl<State: Clone + Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
-    async fn handle(&self, mut ctx: Request, next: Next<'_, State>) -> crate::Result {
+impl Middleware for CookiesMiddleware {
+    async fn handle(&self, mut ctx: Request, next: Next) -> crate::Result {
         let cookie_jar = if let Some(cookie_data) = ctx.ext::<CookieData>() {
             cookie_data.content.clone()
         } else {

src/endpoint.rs

@@ -67,8 +67,8 @@ where
 }
 
 pub(crate) struct MiddlewareEndpoint<E> {
-    endpoint: E,
-    middleware: Vec<Arc<dyn Middleware>>,
+    endpoint: Arc<E>,
+    middleware: Arc<Vec<Arc<dyn Middleware>>>,
 }
 
 impl<E: Clone> Clone for MiddlewareEndpoint<E> {
@@ -96,14 +96,14 @@ where
 {
     pub(crate) fn wrap_with_middleware(
         ep: E,
-        middleware: &[Arc<dyn Middleware>],
-    ) -> Box<dyn Endpoint + Send + Sync + 'static> {
+        middleware: Vec<Arc<dyn Middleware>>,
+    ) -> Arc<dyn Endpoint + Send + Sync + 'static> {
         if middleware.is_empty() {
-            Box::new(ep)
+            Arc::new(ep)
         } else {
-            Box::new(Self {
-                endpoint: ep,
-                middleware: middleware.to_vec(),
+            Arc::new(Self {
+                endpoint: Arc::new(ep),
+                middleware: Arc::new(middleware),
             })
         }
     }
@@ -115,10 +115,7 @@ where
     E: Endpoint,
 {
     async fn call(&self, req: Request) -> crate::Result {
-        let next = Next {
-            endpoint: &self.endpoint,
-            next_middleware: &self.middleware,
-        };
+        let next = Next::new(self.endpoint.clone(), self.middleware.clone());
         Ok(next.run(req).await)
     }
 }

src/log/middleware.rs

@@ -26,7 +26,7 @@ impl LogMiddleware {
     }
 
     /// Log a request and a response.
-    async fn log<'a>(&'a self, mut req: Request, next: Next<'a>) -> crate::Result {
+    async fn log(&self, mut req: Request, next: Next) -> crate::Result {
         if req.ext::<LogMiddlewareHasBeenRun>().is_some() {
             return Ok(next.run(req).await);
         }
@@ -91,7 +91,7 @@ impl LogMiddleware {
 
 #[async_trait::async_trait]
 impl Middleware for LogMiddleware {
-    async fn handle(&self, req: Request, next: Next<'_>) -> crate::Result {
+    async fn handle(&self, req: Request, next: Next) -> crate::Result {
         self.log(req, next).await
     }
 }

src/middleware.rs

@@ -2,8 +2,7 @@
 
 use std::sync::Arc;
 
-use crate::endpoint::DynEndpoint;
-use crate::{Request, Response};
+use crate::{Endpoint, Request, Response};
 use async_trait::async_trait;
 use std::future::Future;
 use std::pin::Pin;
@@ -12,7 +11,7 @@ use std::pin::Pin;
 #[async_trait]
 pub trait Middleware: Send + Sync + 'static {
     /// Asynchronously handle the request, and return a response.
-    async fn handle(&self, request: Request, next: Next<'_>) -> crate::Result;
+    async fn handle(&self, request: Request, next: Next) -> crate::Result;
 
     /// Set the middleware's name. By default it uses the type signature.
     fn name(&self) -> &str {
@@ -26,32 +25,42 @@ where
     F: Send
         + Sync
         + 'static
-        + for<'a> Fn(Request, Next<'a>) -> Pin<Box<dyn Future<Output = crate::Result> + 'a + Send>>,
+        + Fn(Request, Next) -> Pin<Box<dyn Future<Output = crate::Result> + Send>>,
 {
-    async fn handle(&self, req: Request, next: Next<'_>) -> crate::Result {
+    async fn handle(&self, req: Request, next: Next) -> crate::Result {
         (self)(req, next).await
     }
 }
 
 /// The remainder of a middleware chain, including the endpoint.
 #[allow(missing_debug_implementations)]
-pub struct Next<'a> {
-    pub(crate) endpoint: &'a DynEndpoint,
-    pub(crate) next_middleware: &'a [Arc<dyn Middleware>],
+pub struct Next {
+    cursor: usize,
+    endpoint: Arc<dyn Endpoint>,
+    middleware: Arc<Vec<Arc<dyn Middleware>>>,
 }
 
-impl 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 {
+        Self {
+            cursor: 0,
+            endpoint,
+            middleware,
+        }
+    }
+
     /// Asynchronously execute the remaining middleware chain.
     pub async fn run(mut self, req: Request) -> Response {
-        if let Some((current, next)) = self.next_middleware.split_first() {
-            self.next_middleware = next;
-            match current.handle(req, self).await {
-                Ok(request) => request,
+        if let Some(mid) = self.middleware.get(self.cursor) {
+            self.cursor += 1;
+            match mid.to_owned().handle(req, self).await {
+                Ok(response) => response,
                 Err(err) => err.into(),
             }
         } else {
             match self.endpoint.call(req).await {
-                Ok(request) => request,
+                Ok(response) => response,
                 Err(err) => err.into(),
             }
         }

src/route.rs

@@ -187,13 +187,13 @@ impl<'a> Route<'a> {
             wildcard.router.add(
                 &wildcard.path,
                 method,
-                MiddlewareEndpoint::wrap_with_middleware(ep, &wildcard.middleware),
+                MiddlewareEndpoint::wrap_with_middleware(ep, wildcard.middleware.clone()),
             );
         } else {
             self.router.add(
                 &self.path,
                 method,
-                MiddlewareEndpoint::wrap_with_middleware(ep, &self.middleware),
+                MiddlewareEndpoint::wrap_with_middleware(ep, self.middleware.clone()),
             );
         }
         self
@@ -208,12 +208,12 @@ impl<'a> Route<'a> {
             let wildcard = self.at("*");
             wildcard.router.add_all(
                 &wildcard.path,
-                MiddlewareEndpoint::wrap_with_middleware(ep, &wildcard.middleware),
+                MiddlewareEndpoint::wrap_with_middleware(ep, wildcard.middleware.clone()),
             );
         } else {
             self.router.add_all(
                 &self.path,
-                MiddlewareEndpoint::wrap_with_middleware(ep, &self.middleware),
+                MiddlewareEndpoint::wrap_with_middleware(ep, self.middleware.clone()),
             );
         }
         self

src/router.rs

@@ -1,5 +1,6 @@
 use routefinder::{Captures, Router as MethodRouter};
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use crate::endpoint::DynEndpoint;
 use crate::{Request, Response, StatusCode};
@@ -10,8 +11,8 @@ use crate::{Request, Response, StatusCode};
 /// 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<Box<DynEndpoint>>>,
-    all_method_router: MethodRouter<Box<DynEndpoint>>,
+    method_map: HashMap<http_types::Method, MethodRouter<Arc<DynEndpoint>>>,
+    all_method_router: MethodRouter<Arc<DynEndpoint>>,
 }
 
 impl std::fmt::Debug for Router {
@@ -24,8 +25,8 @@ impl std::fmt::Debug for Router {
 }
 
 /// The result of routing a URL
-pub(crate) struct Selection<'a> {
-    pub(crate) endpoint: &'a DynEndpoint,
+pub(crate) struct Selection {
+    pub(crate) endpoint: Arc<DynEndpoint>,
     pub(crate) params: Captures<'static, 'static>,
 }
 
@@ -37,31 +38,31 @@ impl Router {
         }
     }
 
-    pub(crate) fn add(&mut self, path: &str, method: http_types::Method, ep: Box<DynEndpoint>) {
+    pub(crate) fn add(&mut self, path: &str, method: http_types::Method, ep: Arc<DynEndpoint>) {
         self.method_map
             .entry(method)
             .or_insert_with(MethodRouter::new)
             .add(path, ep)
             .unwrap()
     }
 
-    pub(crate) fn add_all(&mut self, path: &str, ep: Box<DynEndpoint>) {
+    pub(crate) fn add_all(&mut self, path: &str, ep: Arc<DynEndpoint>) {
         self.all_method_router.add(path, ep).unwrap()
     }
 
-    pub(crate) fn route(&self, path: &str, method: http_types::Method) -> Selection<'_> {
+    pub(crate) fn route(&self, path: &str, method: http_types::Method) -> Selection {
         if let Some(m) = self
             .method_map
             .get(&method)
             .and_then(|r| r.best_match(path))
         {
             Selection {
-                endpoint: m.handler(),
+                endpoint: m.handler().to_owned(),
                 params: m.captures().into_owned(),
             }
         } else if let Some(m) = self.all_method_router.best_match(path) {
             Selection {
-                endpoint: m.handler(),
+                endpoint: m.handler().to_owned(),
                 params: m.captures().into_owned(),
             }
         } else if method == http_types::Method::Head {
@@ -78,12 +79,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: &method_not_allowed,
+                endpoint: Arc::new(method_not_allowed),
                 params: Captures::default(),
             }
         } else {
             Selection {
-                endpoint: &not_found_endpoint,
+                endpoint: Arc::new(not_found_endpoint),
                 params: Captures::default(),
             }
         }

src/security/cors.rs

@@ -137,7 +137,7 @@ impl CorsMiddleware {
 
 #[async_trait::async_trait]
 impl Middleware for CorsMiddleware {
-    async fn handle(&self, req: Request, next: Next<'_>) -> Result {
+    async fn handle(&self, req: Request, next: Next) -> Result {
         // TODO: how should multiple origin values be handled?
         let origins = req.header(&headers::ORIGIN).cloned();
 

src/server.rs

@@ -297,11 +297,7 @@ where
         let route_params = vec![params];
         let req = Request::with_state(state, req, route_params);
 
-        let next = Next {
-            endpoint,
-            next_middleware: &middleware,
-        };
-
+        let next = Next::new(endpoint, middleware);
         let res = next.run(req).await;
         let res: http_types::Response = res.into();
         Ok(res.into())
@@ -357,11 +353,7 @@ impl<InnerState: Clone + Sync + Send + 'static> Endpoint for Server<InnerState>
         route_params.push(params);
         let req = Request::with_state(state, req, route_params);
 
-        let next = Next {
-            endpoint,
-            next_middleware: &middleware,
-        };
-
+        let next = Next::new(endpoint, middleware);
         Ok(next.run(req).await)
     }
 }

src/sessions/middleware.rs

@@ -79,7 +79,7 @@ where
     Store: SessionStore,
     State: Clone + Send + Sync + 'static,
 {
-    async fn handle(&self, mut request: Request, next: Next<'_, State>) -> crate::Result {
+    async fn handle(&self, mut request: Request, next: Next) -> crate::Result {
         let cookie = request.cookie(&self.cookie_name);
         let cookie_value = cookie
             .clone()