Add middleware Result type

Author: jtgeibel

src/middleware.rs

@@ -1,17 +1,22 @@
 mod prelude {
     pub use conduit::{Handler, Request, Response};
     pub use conduit_middleware::{AroundMiddleware, Middleware};
-    pub use std::error::Error;
+
+    use std::error::Error;
+    pub type BoxError = Box<dyn Error + Send>;
+    pub type Result<T> = std::result::Result<T, BoxError>;
 }
 
-pub use self::app::AppMiddleware;
-pub use self::current_user::CurrentUser;
-pub use self::debug::*;
-pub use self::ember_index_rewrite::EmberIndexRewrite;
-pub use self::head::Head;
+pub use prelude::Result;
+
+use self::app::AppMiddleware;
+use self::current_user::CurrentUser;
+use self::debug::*;
+use self::ember_index_rewrite::EmberIndexRewrite;
+use self::head::Head;
 use self::log_connection_pool_status::LogConnectionPoolStatus;
-pub use self::security_headers::SecurityHeaders;
-pub use self::static_or_continue::StaticOrContinue;
+use self::security_headers::SecurityHeaders;
+use self::static_or_continue::StaticOrContinue;
 
 pub mod app;
 mod block_traffic;

src/middleware/app.rs

@@ -17,16 +17,12 @@ impl AppMiddleware {
 }
 
 impl Middleware for AppMiddleware {
-    fn before(&self, req: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, req: &mut dyn Request) -> Result<()> {
         req.mut_extensions().insert(Arc::clone(&self.app));
         Ok(())
     }
 
-    fn after(
-        &self,
-        req: &mut dyn Request,
-        res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, req: &mut dyn Request, res: Result<Response>) -> Result<Response> {
         req.mut_extensions().pop::<Arc<App>>().unwrap();
         res
     }

src/middleware/block_traffic.rs

@@ -39,7 +39,7 @@ impl AroundMiddleware for BlockTraffic {
 }
 
 impl Handler for BlockTraffic {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         let has_blocked_value = req
             .headers()
             .find(&self.header_name)

src/middleware/current_user.rs

@@ -20,17 +20,15 @@ pub enum AuthenticationSource {
 }
 
 impl Middleware for CurrentUser {
-    fn before(&self, req: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, req: &mut dyn Request) -> Result<()> {
         // Check if the request has a session cookie with a `user_id` property inside
         let id = {
             req.session()
                 .get("user_id")
                 .and_then(|s| s.parse::<i32>().ok())
         };
 
-        let conn = req
-            .db_conn()
-            .map_err(|e| Box::new(e) as Box<dyn Error + Send>)?;
+        let conn = req.db_conn().map_err(|e| Box::new(e) as BoxError)?;
 
         if let Some(id) = id {
             // If it did, look for a user in the database with the given `user_id`
@@ -58,7 +56,7 @@ impl Middleware for CurrentUser {
                         })
                     })
                     .optional()
-                    .map_err(|e| Box::new(e) as Box<dyn Error + Send>)?
+                    .map_err(|e| Box::new(e) as BoxError)?
             } else {
                 None
             };

src/middleware/debug.rs

@@ -6,15 +6,11 @@ use super::prelude::*;
 pub struct Debug;
 
 impl Middleware for Debug {
-    fn before(&self, req: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, req: &mut dyn Request) -> Result<()> {
         DebugRequest.before(req)
     }
 
-    fn after(
-        &self,
-        _req: &mut dyn Request,
-        res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, _req: &mut dyn Request, res: Result<Response>) -> Result<Response> {
         res.map(|res| {
             println!("  <- {:?}", res.status);
             for (k, v) in &res.headers {
@@ -29,7 +25,7 @@ impl Middleware for Debug {
 pub struct DebugRequest;
 
 impl Middleware for DebugRequest {
-    fn before(&self, req: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, req: &mut dyn Request) -> Result<()> {
         println!("  version: {}", req.http_version());
         println!("  method: {:?}", req.method());
         println!("  scheme: {:?}", req.scheme());

src/middleware/ember_index_rewrite.rs

@@ -24,7 +24,7 @@ impl AroundMiddleware for EmberIndexRewrite {
 }
 
 impl Handler for EmberIndexRewrite {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         // If the client is requesting html, then we've only got one page so
         // rewrite the request.
         let wants_html = req

src/middleware/ensure_well_formed_500.rs

@@ -10,11 +10,7 @@ use std::collections::HashMap;
 pub struct EnsureWellFormed500;
 
 impl Middleware for EnsureWellFormed500 {
-    fn after(
-        &self,
-        _: &mut dyn Request,
-        res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, _: &mut dyn Request, res: Result<Response>) -> Result<Response> {
         res.or_else(|_| {
             let body = "Internal Server Error";
             let mut headers = HashMap::new();

src/middleware/head.rs

@@ -20,7 +20,7 @@ impl AroundMiddleware for Head {
 }
 
 impl Handler for Head {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         if req.method() == Method::Head {
             let mut req = RequestProxy::rewrite_method(req, Method::Get);
             self.handler

src/middleware/log_connection_pool_status.rs

@@ -28,7 +28,7 @@ impl LogConnectionPoolStatus {
 }
 
 impl Middleware for LogConnectionPoolStatus {
-    fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
+    fn before(&self, _: &mut dyn Request) -> Result<()> {
         let mut last_log_time = self
             .last_log_time
             .lock()
@@ -45,11 +45,7 @@ impl Middleware for LogConnectionPoolStatus {
         Ok(())
     }
 
-    fn after(
-        &self,
-        _: &mut dyn Request,
-        res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, _: &mut dyn Request, res: Result<Response>) -> Result<Response> {
         self.in_flight_requests.fetch_sub(1, Ordering::SeqCst);
         res
     }

src/middleware/log_request.rs

@@ -20,7 +20,7 @@ impl AroundMiddleware for LogRequests {
 }
 
 impl Handler for LogRequests {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         let request_start = Instant::now();
         let res = self.handler.as_ref().unwrap().call(req);
         let (level, response_code) = match res {