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 {

src/middleware/require_user_agent.rs

@@ -20,7 +20,7 @@ impl AroundMiddleware for RequireUserAgent {
 }
 
 impl Handler for RequireUserAgent {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         let has_user_agent = request_header(req, "User-Agent") != "";
         let is_download = req.path().ends_with("download");
         if !has_user_agent && !is_download {

src/middleware/security_headers.rs

@@ -57,11 +57,7 @@ impl SecurityHeaders {
 }
 
 impl Middleware for SecurityHeaders {
-    fn after(
-        &self,
-        _: &mut dyn Request,
-        mut res: Result<Response, Box<dyn Error + Send>>,
-    ) -> Result<Response, Box<dyn Error + Send>> {
+    fn after(&self, _: &mut dyn Request, mut res: Result<Response>) -> Result<Response> {
         if let Ok(ref mut response) = res {
             response.headers.extend(self.headers.clone());
         }

src/middleware/static_or_continue.rs

@@ -27,7 +27,7 @@ impl AroundMiddleware for StaticOrContinue {
 }
 
 impl Handler for StaticOrContinue {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> Result<Response> {
         match self.static_handler.call(req) {
             Ok(ref resp) if resp.status.0 == 404 => {}
             ret => return ret,

src/router.rs

@@ -1,4 +1,3 @@
-use std::error::Error;
 use std::sync::Arc;
 
 use conduit::{Handler, Request, Response};
@@ -7,7 +6,7 @@ use conduit_router::{RequestParams, RouteBuilder};
 use crate::controllers::*;
 use crate::util::errors::{std_error, AppError, AppResult, NotFound};
 use crate::util::RequestProxy;
-use crate::{App, Env};
+use crate::{middleware, App, Env};
 
 pub fn build_router(app: &App) -> R404 {
     let mut api_router = RouteBuilder::new();
@@ -136,7 +135,7 @@ pub fn build_router(app: &App) -> R404 {
 struct C(pub fn(&mut dyn Request) -> AppResult<Response>);
 
 impl Handler for C {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> middleware::Result<Response> {
         let C(f) = *self;
         match f(req) {
             Ok(resp) => Ok(resp),
@@ -151,7 +150,7 @@ impl Handler for C {
 struct R<H>(pub Arc<H>);
 
 impl<H: Handler> Handler for R<H> {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> middleware::Result<Response> {
         let path = req.params()["path"].to_string();
         let R(ref sub_router) = *self;
         sub_router.call(&mut RequestProxy::rewrite_path(req, &path))
@@ -163,7 +162,7 @@ impl<H: Handler> Handler for R<H> {
 pub struct R404(pub RouteBuilder);
 
 impl Handler for R404 {
-    fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
+    fn call(&self, req: &mut dyn Request) -> middleware::Result<Response> {
         let R404(ref router) = *self;
         match router.recognize(&req.method(), req.path()) {
             Ok(m) => {