use read only self for Middleware

src/middleware/cors.rs

@@ -356,7 +356,7 @@ impl Cors {
 }
 
 impl<S> Middleware<S> for Cors {
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         if self.inner.preflight && Method::OPTIONS == *req.method() {
             self.validate_origin(req)?;
             self.validate_allowed_method(req)?;
@@ -434,7 +434,7 @@ impl<S> Middleware<S> for Cors {
     }
 
     fn response(
-        &mut self, req: &mut HttpRequest<S>, mut resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, mut resp: HttpResponse,
     ) -> Result<Response> {
         match self.inner.origins {
             AllOrSome::All => {
@@ -944,7 +944,7 @@ mod tests {
 
     #[test]
     fn validate_origin_allows_all_origins() {
-        let mut cors = Cors::default();
+        let cors = Cors::default();
         let mut req =
             TestRequest::with_header("Origin", "https://www.example.com").finish();
 
@@ -1013,7 +1013,7 @@ mod tests {
     // #[test]
     // #[should_panic(expected = "MissingOrigin")]
     // fn test_validate_missing_origin() {
-    //    let mut cors = Cors::build()
+    //    let cors = Cors::build()
     //        .allowed_origin("https://www.example.com")
     //        .finish();
     //    let mut req = HttpRequest::default();
@@ -1023,7 +1023,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "OriginNotAllowed")]
     fn test_validate_not_allowed_origin() {
-        let mut cors = Cors::build()
+        let cors = Cors::build()
             .allowed_origin("https://www.example.com")
             .finish();
 
@@ -1035,7 +1035,7 @@ mod tests {
 
     #[test]
     fn test_validate_origin() {
-        let mut cors = Cors::build()
+        let cors = Cors::build()
             .allowed_origin("https://www.example.com")
             .finish();
 
@@ -1048,7 +1048,7 @@ mod tests {
 
     #[test]
     fn test_no_origin_response() {
-        let mut cors = Cors::build().finish();
+        let cors = Cors::build().finish();
 
         let mut req = TestRequest::default().method(Method::GET).finish();
         let resp: HttpResponse = HttpResponse::Ok().into();
@@ -1074,7 +1074,7 @@ mod tests {
 
     #[test]
     fn test_response() {
-        let mut cors = Cors::build()
+        let cors = Cors::build()
             .send_wildcard()
             .disable_preflight()
             .max_age(3600)
@@ -1109,7 +1109,7 @@ mod tests {
             resp.headers().get(header::VARY).unwrap().as_bytes()
         );
 
-        let mut cors = Cors::build()
+        let cors = Cors::build()
             .disable_vary_header()
             .allowed_origin("https://www.example.com")
             .finish();

src/middleware/csrf.rs

@@ -209,7 +209,7 @@ impl CsrfFilter {
 }
 
 impl<S> Middleware<S> for CsrfFilter {
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         self.validate(req)?;
         Ok(Started::Done)
     }
@@ -223,7 +223,7 @@ mod tests {
 
     #[test]
     fn test_safe() {
-        let mut csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
+        let csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
 
         let mut req = TestRequest::with_header("Origin", "https://www.w3.org")
             .method(Method::HEAD)
@@ -234,7 +234,7 @@ mod tests {
 
     #[test]
     fn test_csrf() {
-        let mut csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
+        let csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
 
         let mut req = TestRequest::with_header("Origin", "https://www.w3.org")
             .method(Method::POST)
@@ -245,7 +245,7 @@ mod tests {
 
     #[test]
     fn test_referer() {
-        let mut csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
+        let csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
 
         let mut req = TestRequest::with_header(
             "Referer",
@@ -258,9 +258,9 @@ mod tests {
 
     #[test]
     fn test_upgrade() {
-        let mut strict_csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
+        let strict_csrf = CsrfFilter::new().allowed_origin("https://www.example.com");
 
-        let mut lax_csrf = CsrfFilter::new()
+        let lax_csrf = CsrfFilter::new()
             .allowed_origin("https://www.example.com")
             .allow_upgrade();
 

src/middleware/defaultheaders.rs

@@ -75,7 +75,7 @@ impl DefaultHeaders {
 
 impl<S> Middleware<S> for DefaultHeaders {
     fn response(
-        &mut self, _: &mut HttpRequest<S>, mut resp: HttpResponse,
+        &self, _: &mut HttpRequest<S>, mut resp: HttpResponse,
     ) -> Result<Response> {
         for (key, value) in self.headers.iter() {
             if !resp.headers().contains_key(key) {
@@ -100,7 +100,7 @@ mod tests {
 
     #[test]
     fn test_default_headers() {
-        let mut mw = DefaultHeaders::new().header(CONTENT_TYPE, "0001");
+        let mw = DefaultHeaders::new().header(CONTENT_TYPE, "0001");
 
         let mut req = HttpRequest::default();
 

src/middleware/errhandlers.rs

@@ -71,7 +71,7 @@ impl<S> ErrorHandlers<S> {
 
 impl<S: 'static> Middleware<S> for ErrorHandlers<S> {
     fn response(
-        &mut self, req: &mut HttpRequest<S>, resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, resp: HttpResponse,
     ) -> Result<Response> {
         if let Some(handler) = self.handlers.get(&resp.status()) {
             handler(req, resp)
@@ -99,7 +99,7 @@ mod tests {
 
     #[test]
     fn test_handler() {
-        let mut mw =
+        let mw =
             ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500);
 
         let mut req = HttpRequest::default();
@@ -121,7 +121,7 @@ mod tests {
     struct MiddlewareOne;
 
     impl<S> Middleware<S> for MiddlewareOne {
-        fn start(&mut self, _req: &mut HttpRequest<S>) -> Result<Started, Error> {
+        fn start(&self, _req: &mut HttpRequest<S>) -> Result<Started, Error> {
             Err(ErrorInternalServerError("middleware error"))
         }
     }

src/middleware/identity.rs

@@ -178,7 +178,7 @@ impl<T> IdentityService<T> {
 struct IdentityBox(Box<Identity>);
 
 impl<S: 'static, T: IdentityPolicy<S>> Middleware<S> for IdentityService<T> {
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         let mut req = req.clone();
 
         let fut = self
@@ -195,7 +195,7 @@ impl<S: 'static, T: IdentityPolicy<S>> Middleware<S> for IdentityService<T> {
     }
 
     fn response(
-        &mut self, req: &mut HttpRequest<S>, resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, resp: HttpResponse,
     ) -> Result<Response> {
         if let Some(mut id) = req.extensions_mut().remove::<IdentityBox>() {
             id.0.write(resp)

src/middleware/logger.rs

@@ -124,14 +124,14 @@ impl Logger {
 }
 
 impl<S> Middleware<S> for Logger {
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         if !self.exclude.contains(req.path()) {
             req.extensions_mut().insert(StartTime(time::now()));
         }
         Ok(Started::Done)
     }
 
-    fn finish(&mut self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
+    fn finish(&self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
         self.log(req, resp);
         Finished::Done
     }
@@ -322,7 +322,7 @@ mod tests {
 
     #[test]
     fn test_logger() {
-        let mut logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");
+        let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");
 
         let mut headers = HeaderMap::new();
         headers.insert(

src/middleware/mod.rs

@@ -51,20 +51,20 @@ pub enum Finished {
 pub trait Middleware<S>: 'static {
     /// Method is called when request is ready. It may return
     /// future, which should resolve before next middleware get called.
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         Ok(Started::Done)
     }
 
     /// Method is called when handler returns response,
     /// but before sending http message to peer.
     fn response(
-        &mut self, req: &mut HttpRequest<S>, resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, resp: HttpResponse,
     ) -> Result<Response> {
         Ok(Response::Done(resp))
     }
 
     /// Method is called after body stream get sent to peer.
-    fn finish(&mut self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
+    fn finish(&self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
         Finished::Done
     }
 }

src/middleware/session.rs

@@ -246,7 +246,7 @@ impl<S, T: SessionBackend<S>> SessionStorage<T, S> {
 }
 
 impl<S: 'static, T: SessionBackend<S>> Middleware<S> for SessionStorage<T, S> {
-    fn start(&mut self, req: &mut HttpRequest<S>) -> Result<Started> {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         let mut req = req.clone();
 
         let fut = self.0.from_request(&mut req).then(move |res| match res {
@@ -261,7 +261,7 @@ impl<S: 'static, T: SessionBackend<S>> Middleware<S> for SessionStorage<T, S> {
     }
 
     fn response(
-        &mut self, req: &mut HttpRequest<S>, resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, resp: HttpResponse,
     ) -> Result<Response> {
         if let Some(s_box) = req.extensions_mut().remove::<Arc<SessionImplCell>>() {
             s_box.0.borrow_mut().write(resp)