nightly clippy warnings

< 0.1.4 failed to check for null when doing allocations which could lead to null dereferences.

.travis.yml

@@ -3,7 +3,7 @@ sudo: required
 dist: trusty
 
 cache:
-  cargo: true
+  # cargo: true
   apt: true
 
 matrix:
@@ -26,7 +26,7 @@ before_install:
 
 before_cache: |
   if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-04-02" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
   fi
 
 # Add clippy

CHANGES.md

@@ -1,6 +1,20 @@
 # Changes
 
-## [1.0.3] - unreleased
+## [1.0.4] - 2019-07-17
+
+### Added
+
+* Add `Responder` impl for `(T, StatusCode) where T: Responder`
+
+* Allow to access app's resource map via
+  `ServiceRequest::resource_map()` and `HttpRequest::resource_map()` methods.
+
+### Changed
+
+* Upgrade `rand` dependency version to 0.7
+
+
+## [1.0.3] - 2019-06-28
 
 ### Added
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "1.0.2"
+version = "1.0.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@@ -71,11 +71,11 @@ rust-tls = ["rustls", "actix-server/rust-tls"]
 [dependencies]
 actix-codec = "0.1.2"
 actix-service = "0.4.1"
-actix-utils = "0.4.1"
+actix-utils = "0.4.4"
 actix-router = "0.1.5"
-actix-rt = "0.2.2"
+actix-rt = "0.2.4"
 actix-web-codegen = "0.1.2"
-actix-http = "0.2.4"
+actix-http = "0.2.6"
 actix-server = "0.5.1"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.1"
@@ -89,7 +89,7 @@ hashbrown = "0.5.0"
 log = "0.4"
 mime = "0.3"
 net2 = "0.2.33"
-parking_lot = "0.8"
+parking_lot = "0.9"
 regex = "1.0"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
@@ -103,9 +103,9 @@ rustls = { version = "0.15", optional = true }
 
 [dev-dependencies]
 actix = { version = "0.8.3" }
-actix-http = { version = "0.2.4", features=["ssl", "brotli", "flate2-zlib"] }
+actix-http = { version = "0.2.5", features=["ssl", "brotli", "flate2-zlib"] }
 actix-http-test = { version = "0.2.2", features=["ssl"] }
-rand = "0.6"
+rand = "0.7"
 env_logger = "0.6"
 serde_derive = "1.0"
 tokio-timer = "0.2.8"

README.md

@@ -61,7 +61,7 @@ You may consider checking out
 
 ## Benchmarks
 
-* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r16&hw=ph&test=plaintext)
+* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r18)
 
 ## License
 

actix-cors/README.md

@@ -3,7 +3,7 @@
 ## Documentation & community resources
 
 * [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-identity/)
+* [API Documentation](https://docs.rs/actix-cors/)
 * [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-session](https://crates.io/crates/actix-identity)
+* Cargo package: [actix-cors](https://crates.io/crates/actix-cors)
 * Minimum supported Rust version: 1.34 or later

actix-cors/src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::borrow_interior_mutable_const, clippy::type_complexity)]
 //! Cross-origin resource sharing (CORS) for Actix applications
 //!
 //! CORS middleware could be used with application and with resource.
@@ -162,6 +163,7 @@ impl<T> AllOrSome<T> {
 ///     .max_age(3600);
 /// # }
 /// ```
+#[derive(Default)]
 pub struct Cors {
     cors: Option<Inner>,
     methods: bool,
@@ -585,10 +587,10 @@ impl Inner {
             }
             Err(CorsError::BadOrigin)
         } else {
-            return match self.origins {
+            match self.origins {
                 AllOrSome::All => Ok(()),
                 _ => Err(CorsError::MissingOrigin),
-            };
+            }
         }
     }
 
@@ -663,7 +665,7 @@ impl Inner {
                     }
                     Err(CorsError::BadRequestHeaders)
                 } else {
-                    return Ok(());
+                    Ok(())
                 }
             }
         }
@@ -681,7 +683,7 @@ where
     type Error = Error;
     type Future = Either<
         FutureResult<Self::Response, Error>,
-        Either<S::Future, Box<Future<Item = Self::Response, Error = Error>>>,
+        Either<S::Future, Box<dyn Future<Item = Self::Response, Error = Error>>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {

actix-files/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::borrow_interior_mutable_const, clippy::type_complexity)]
+
 //! Static files support
 use std::cell::RefCell;
 use std::fmt::Write;
@@ -50,14 +52,14 @@ pub struct ChunkedReadFile {
     size: u64,
     offset: u64,
     file: Option<File>,
-    fut: Option<Box<Future<Item = (File, Bytes), Error = BlockingError<io::Error>>>>,
+    fut: Option<Box<dyn Future<Item = (File, Bytes), Error = BlockingError<io::Error>>>>,
     counter: u64,
 }
 
 fn handle_error(err: BlockingError<io::Error>) -> Error {
     match err {
         BlockingError::Error(err) => err.into(),
-        BlockingError::Canceled => ErrorInternalServerError("Unexpected error").into(),
+        BlockingError::Canceled => ErrorInternalServerError("Unexpected error"),
     }
 }
 
@@ -105,7 +107,7 @@ impl Stream for ChunkedReadFile {
 }
 
 type DirectoryRenderer =
-    Fn(&Directory, &HttpRequest) -> Result<ServiceResponse, io::Error>;
+    dyn Fn(&Directory, &HttpRequest) -> Result<ServiceResponse, io::Error>;
 
 /// A directory; responds with the generated directory listing.
 #[derive(Debug)]
@@ -209,7 +211,7 @@ fn directory_listing(
     ))
 }
 
-type MimeOverride = Fn(&mime::Name) -> DispositionType;
+type MimeOverride = dyn Fn(&mime::Name) -> DispositionType;
 
 /// Static files handling
 ///
@@ -370,7 +372,7 @@ impl NewService for Files {
     type Error = Error;
     type Service = FilesService;
     type InitError = ();
-    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
 
     fn new_service(&self, _: &()) -> Self::Future {
         let mut srv = FilesService {
@@ -416,7 +418,7 @@ impl FilesService {
         req: ServiceRequest,
     ) -> Either<
         FutureResult<ServiceResponse, Error>,
-        Box<Future<Item = ServiceResponse, Error = Error>>,
+        Box<dyn Future<Item = ServiceResponse, Error = Error>>,
     > {
         log::debug!("Files: Failed to handle {}: {}", req.path(), e);
         if let Some(ref mut default) = self.default {
@@ -433,7 +435,7 @@ impl Service for FilesService {
     type Error = Error;
     type Future = Either<
         FutureResult<Self::Response, Self::Error>,
-        Box<Future<Item = Self::Response, Error = Self::Error>>,
+        Box<dyn Future<Item = Self::Response, Error = Self::Error>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -473,7 +475,7 @@ impl Service for FilesService {
                             Err(e) => ServiceResponse::from_err(e, req),
                         }))
                     }
-                    Err(e) => return self.handle_err(e, req),
+                    Err(e) => self.handle_err(e, req),
                 }
             } else if self.show_index {
                 let dir = Directory::new(self.directory.clone(), path);
@@ -481,7 +483,7 @@ impl Service for FilesService {
                 let x = (self.renderer)(&dir, &req);
                 match x {
                     Ok(resp) => Either::A(ok(resp)),
-                    Err(e) => return Either::A(ok(ServiceResponse::from_err(e, req))),
+                    Err(e) => Either::A(ok(ServiceResponse::from_err(e, req))),
                 }
             } else {
                 Either::A(ok(ServiceResponse::from_err(
@@ -855,7 +857,7 @@ mod tests {
 
     #[test]
     fn test_named_file_content_length_headers() {
-        use actix_web::body::{MessageBody, ResponseBody};
+        // use actix_web::body::{MessageBody, ResponseBody};
 
         let mut srv = test::init_service(
             App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
@@ -866,7 +868,7 @@ mod tests {
             .uri("/t%65st/tests/test.binary")
             .header(header::RANGE, "bytes=10-20")
             .to_request();
-        let response = test::call_service(&mut srv, request);
+        let _response = test::call_service(&mut srv, request);
 
         // let contentlength = response
         //     .headers()
@@ -889,7 +891,7 @@ mod tests {
             .uri("/t%65st/tests/test.binary")
             // .no_default_headers()
             .to_request();
-        let response = test::call_service(&mut srv, request);
+        let _response = test::call_service(&mut srv, request);
 
         // let contentlength = response
         //     .headers()
@@ -937,7 +939,7 @@ mod tests {
             .method(Method::HEAD)
             .uri("/t%65st/tests/test.binary")
             .to_request();
-        let response = test::call_service(&mut srv, request);
+        let _response = test::call_service(&mut srv, request);
 
         // TODO: fix check
         // let contentlength = response

actix-files/src/named.rs

@@ -24,8 +24,8 @@ use crate::ChunkedReadFile;
 
 bitflags! {
     pub(crate) struct Flags: u32 {
-        const ETAG = 0b00000001;
+        const ETAG = 0b0000_0001;
-        const LAST_MD = 0b00000010;
+        const LAST_MD = 0b0000_0010;
     }
 }
 
@@ -311,8 +311,8 @@ impl Responder for NamedFile {
             return Ok(resp.streaming(reader));
         }
 
-        match req.method() {
+        match *req.method() {
-            &Method::HEAD | &Method::GET => (),
+            Method::HEAD | Method::GET => (),
             _ => {
                 return Ok(HttpResponse::MethodNotAllowed()
                     .header(header::CONTENT_TYPE, "text/plain")

actix-files/src/range.rs

@@ -5,7 +5,7 @@ pub struct HttpRange {
     pub length: u64,
 }
 
-static PREFIX: &'static str = "bytes=";
+static PREFIX: &str = "bytes=";
 const PREFIX_LEN: usize = 6;
 
 impl HttpRange {

actix-framed/src/app.rs

@@ -13,7 +13,7 @@ use crate::helpers::{BoxedHttpNewService, BoxedHttpService, HttpNewService};
 use crate::request::FramedRequest;
 use crate::state::State;
 
-type BoxedResponse = Box<Future<Item = (), Error = Error>>;
+type BoxedResponse = Box<dyn Future<Item = (), Error = Error>>;
 
 pub trait HttpServiceFactory {
     type Factory: NewService;
@@ -61,7 +61,7 @@ impl<T: 'static, S: 'static> FramedApp<T, S> {
             Request = FramedRequest<T, S>,
             Response = (),
             Error = Error,
-            Future = Box<Future<Item = (), Error = Error>>,
+            Future = Box<dyn Future<Item = (), Error = Error>>,
         >,
     {
         let path = factory.path().to_string();
@@ -129,7 +129,7 @@ pub struct CreateService<T, S> {
 enum CreateServiceItem<T, S> {
     Future(
         Option<String>,
-        Box<Future<Item = BoxedHttpService<FramedRequest<T, S>>, Error = ()>>,
+        Box<dyn Future<Item = BoxedHttpService<FramedRequest<T, S>>, Error = ()>>,
     ),
     Service(String, BoxedHttpService<FramedRequest<T, S>>),
 }

actix-framed/src/helpers.rs

@@ -3,23 +3,23 @@ use actix_service::{NewService, Service};
 use futures::{Future, Poll};
 
 pub(crate) type BoxedHttpService<Req> = Box<
-    Service<
+    dyn Service<
         Request = Req,
         Response = (),
         Error = Error,
-        Future = Box<Future<Item = (), Error = Error>>,
+        Future = Box<dyn Future<Item = (), Error = Error>>,
     >,
 >;
 
 pub(crate) type BoxedHttpNewService<Req> = Box<
-    NewService<
+    dyn NewService<
         Config = (),
         Request = Req,
         Response = (),
         Error = Error,
         InitError = (),
         Service = BoxedHttpService<Req>,
-        Future = Box<Future<Item = BoxedHttpService<Req>, Error = ()>>,
+        Future = Box<dyn Future<Item = BoxedHttpService<Req>, Error = ()>>,
     >,
 >;
 
@@ -30,7 +30,7 @@ where
     T: NewService<Response = (), Error = Error>,
     T::Response: 'static,
     T::Future: 'static,
-    T::Service: Service<Future = Box<Future<Item = (), Error = Error>>> + 'static,
+    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
     <T::Service as Service>::Future: 'static,
 {
     pub fn new(service: T) -> Self {
@@ -43,7 +43,7 @@ where
     T: NewService<Config = (), Response = (), Error = Error>,
     T::Request: 'static,
     T::Future: 'static,
-    T::Service: Service<Future = Box<Future<Item = (), Error = Error>>> + 'static,
+    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
     <T::Service as Service>::Future: 'static,
 {
     type Config = ();
@@ -52,7 +52,7 @@ where
     type Error = Error;
     type InitError = ();
     type Service = BoxedHttpService<T::Request>;
-    type Future = Box<Future<Item = Self::Service, Error = ()>>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = ()>>;
 
     fn new_service(&self, _: &()) -> Self::Future {
         Box::new(self.0.new_service(&()).map_err(|_| ()).and_then(|service| {
@@ -70,7 +70,7 @@ impl<T> Service for HttpServiceWrapper<T>
 where
     T: Service<
         Response = (),
-        Future = Box<Future<Item = (), Error = Error>>,
+        Future = Box<dyn Future<Item = (), Error = Error>>,
         Error = Error,
     >,
     T::Request: 'static,
@@ -78,7 +78,7 @@ where
     type Request = T::Request;
     type Response = ();
     type Error = Error;
-    type Future = Box<Future<Item = (), Error = Error>>;
+    type Future = Box<dyn Future<Item = (), Error = Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()

actix-framed/src/lib.rs

@@ -1,3 +1,9 @@
+#![allow(
+    clippy::type_complexity,
+    clippy::new_without_default,
+    dead_code,
+    deprecated
+)]
 mod app;
 mod helpers;
 mod request;

actix-framed/src/route.rs

@@ -140,7 +140,7 @@ where
     type Request = FramedRequest<Io, S>;
     type Response = ();
     type Error = Error;
-    type Future = Box<Future<Item = (), Error = Error>>;
+    type Future = Box<dyn Future<Item = (), Error = Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))

actix-http/CHANGES.md

@@ -1,10 +1,26 @@
 # Changes
 
-## [0.2.5] - unreleased
+## [0.2.6] - 2019-07-17
 
 ### Changed
 
-*  Use `encoding_rs` crate instead of unmaintained `encoding` crate
+* Replace `ClonableService` with local copy
+
+* Upgrade `rand` dependency version to 0.7
+
+
+## [0.2.5] - 2019-06-28
+
+### Added
+
+* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
+
+### Changed
+
+* Use `encoding_rs` crate instead of unmaintained `encoding` crate
+
+* Add `Copy` and `Clone` impls for `ws::Codec`
+
 
 ## [0.2.4] - 2019-06-16
 

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "0.2.4"
+version = "0.2.6"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@@ -44,18 +44,18 @@ fail = ["failure"]
 secure-cookies = ["ring"]
 
 [dependencies]
-actix-service = "0.4.0"
+actix-service = "0.4.1"
 actix-codec = "0.1.2"
-actix-connect = "0.2.0"
+actix-connect = "0.2.1"
-actix-utils = "0.4.1"
+actix-utils = "0.4.4"
 actix-server-config = "0.1.1"
-actix-threadpool = "0.1.0"
+actix-threadpool = "0.1.1"
 
 base64 = "0.10"
 bitflags = "1.0"
 bytes = "0.4"
 byteorder = "1.2"
-copyless = "0.1.2"
+copyless = "0.1.4"
 derive_more = "0.15.0"
 either = "1.5.2"
 encoding_rs = "0.8"
@@ -70,7 +70,7 @@ language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "1.0"
-rand = "0.6"
+rand = "0.7"
 regex = "1.0"
 serde = "1.0"
 serde_json = "1.0"

actix-http/src/builder.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use std::marker::PhantomData;
+use std::rc::Rc;
 
 use actix_codec::Framed;
 use actix_server_config::ServerConfig as SrvConfig;
@@ -10,6 +11,7 @@ use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::Error;
 use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
 use crate::h2::H2Service;
+use crate::helpers::{Data, DataFactory};
 use crate::request::Request;
 use crate::response::Response;
 use crate::service::HttpService;
@@ -24,6 +26,7 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
     client_disconnect: u64,
     expect: X,
     upgrade: Option<U>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, S)>,
 }
 
@@ -41,6 +44,7 @@ where
             client_disconnect: 0,
             expect: ExpectHandler,
             upgrade: None,
+            on_connect: None,
             _t: PhantomData,
         }
     }
@@ -115,6 +119,7 @@ where
             client_disconnect: self.client_disconnect,
             expect: expect.into_new_service(),
             upgrade: self.upgrade,
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
@@ -140,10 +145,24 @@ where
             client_disconnect: self.client_disconnect,
             expect: self.expect,
             upgrade: Some(upgrade.into_new_service()),
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
 
+    /// Set on-connect callback.
+    ///
+    /// It get called once per connection and result of the call
+    /// get stored to the request's extensions.
+    pub fn on_connect<F, I>(mut self, f: F) -> Self
+    where
+        F: Fn(&T) -> I + 'static,
+        I: Clone + 'static,
+    {
+        self.on_connect = Some(Rc::new(move |io| Box::new(Data(f(io)))));
+        self
+    }
+
     /// Finish service configuration and create *http service* for HTTP/1 protocol.
     pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B, X, U>
     where
@@ -161,6 +180,7 @@ where
         H1Service::with_config(cfg, service.into_new_service())
             .expect(self.expect)
             .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
     }
 
     /// Finish service configuration and create *http service* for HTTP/2 protocol.
@@ -199,5 +219,6 @@ where
         HttpService::with_config(cfg, service.into_new_service())
             .expect(self.expect)
             .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
     }
 }

actix-http/src/client/connection.rs

@@ -94,7 +94,8 @@ where
     T: AsyncRead + AsyncWrite + 'static,
 {
     type Io = T;
-    type Future = Box<Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
+    type Future =
+        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
 
     fn protocol(&self) -> Protocol {
         match self.io {
@@ -129,7 +130,7 @@ where
 
     type TunnelFuture = Either<
         Box<
-            Future<
+            dyn Future<
                 Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
                 Error = SendRequestError,
             >,
@@ -169,7 +170,8 @@ where
     B: AsyncRead + AsyncWrite + 'static,
 {
     type Io = EitherIo<A, B>;
-    type Future = Box<Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
+    type Future =
+        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
 
     fn protocol(&self) -> Protocol {
         match self {
@@ -190,7 +192,7 @@ where
     }
 
     type TunnelFuture = Box<
-        Future<
+        dyn Future<
             Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
             Error = SendRequestError,
         >,

actix-http/src/client/connector.rs

@@ -47,6 +47,7 @@ pub struct Connector<T, U> {
 }
 
 impl Connector<(), ()> {
+    #[allow(clippy::new_ret_no_self)]
     pub fn new() -> Connector<
         impl Service<
                 Request = TcpConnect<Uri>,

actix-http/src/client/pool.rs

@@ -427,7 +427,9 @@ where
 
     fn check_availibility(&self) {
         if !self.waiters_queue.is_empty() && self.acquired < self.limit {
-            self.task.as_ref().map(|t| t.notify());
+            if let Some(t) = self.task.as_ref() {
+                t.notify()
+            }
         }
     }
 }

actix-http/src/cloneable.rs

@@ -0,0 +1,42 @@
+use std::cell::UnsafeCell;
+use std::rc::Rc;
+
+use actix_service::Service;
+use futures::Poll;
+
+#[doc(hidden)]
+/// Service that allows to turn non-clone service to a service with `Clone` impl
+pub(crate) struct CloneableService<T>(Rc<UnsafeCell<T>>);
+
+impl<T> CloneableService<T> {
+    pub(crate) fn new(service: T) -> Self
+    where
+        T: Service,
+    {
+        Self(Rc::new(UnsafeCell::new(service)))
+    }
+}
+
+impl<T> Clone for CloneableService<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T> Service for CloneableService<T>
+where
+    T: Service,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        unsafe { &mut *self.0.as_ref().get() }.poll_ready()
+    }
+
+    fn call(&mut self, req: T::Request) -> Self::Future {
+        unsafe { &mut *self.0.as_ref().get() }.call(req)
+    }
+}

actix-http/src/cookie/mod.rs

@@ -104,6 +104,7 @@ impl CookieStr {
         }
     }
 
+    #[allow(clippy::ptr_arg)]
     fn to_raw_str<'s, 'c: 's>(&'s self, string: &'s Cow<'c, str>) -> Option<&'c str> {
         match *self {
             CookieStr::Indexed(i, j) => match *string {

actix-http/src/cookie/secure/key.rs

@@ -6,8 +6,8 @@ use ring::rand::{SecureRandom, SystemRandom};
 use super::private::KEY_LEN as PRIVATE_KEY_LEN;
 use super::signed::KEY_LEN as SIGNED_KEY_LEN;
 
-static HKDF_DIGEST: &'static Algorithm = &SHA256;
+static HKDF_DIGEST: &Algorithm = &SHA256;
-const KEYS_INFO: &'static str = "COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM";
+const KEYS_INFO: &str = "COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM";
 
 /// A cryptographic master key for use with `Signed` and/or `Private` jars.
 ///

actix-http/src/cookie/secure/private.rs

@@ -10,7 +10,7 @@ use crate::cookie::{Cookie, CookieJar};
 
 // Keep these in sync, and keep the key len synced with the `private` docs as
 // well as the `KEYS_INFO` const in secure::Key.
-static ALGO: &'static Algorithm = &AES_256_GCM;
+static ALGO: &Algorithm = &AES_256_GCM;
 const NONCE_LEN: usize = 12;
 pub const KEY_LEN: usize = 32;
 

actix-http/src/cookie/secure/signed.rs

@@ -6,7 +6,7 @@ use crate::cookie::{Cookie, CookieJar};
 
 // Keep these in sync, and keep the key len synced with the `signed` docs as
 // well as the `KEYS_INFO` const in secure::Key.
-static HMAC_DIGEST: &'static Algorithm = &SHA256;
+static HMAC_DIGEST: &Algorithm = &SHA256;
 const BASE64_DIGEST_LEN: usize = 44;
 pub const KEY_LEN: usize = 32;
 

actix-http/src/error.rs

@@ -43,12 +43,12 @@ pub type Result<T, E = Error> = result::Result<T, E>;
 /// if you have access to an actix `Error` you can always get a
 /// `ResponseError` reference from it.
 pub struct Error {
-    cause: Box<ResponseError>,
+    cause: Box<dyn ResponseError>,
 }
 
 impl Error {
     /// Returns the reference to the underlying `ResponseError`.
-    pub fn as_response_error(&self) -> &ResponseError {
+    pub fn as_response_error(&self) -> &dyn ResponseError {
         self.cause.as_ref()
     }
 }

actix-http/src/extensions.rs

@@ -6,7 +6,7 @@ use hashbrown::HashMap;
 #[derive(Default)]
 /// A type map of request extensions.
 pub struct Extensions {
-    map: HashMap<TypeId, Box<Any>>,
+    map: HashMap<TypeId, Box<dyn Any>>,
 }
 
 impl Extensions {
@@ -35,14 +35,14 @@ impl Extensions {
     pub fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .get(&TypeId::of::<T>())
-            .and_then(|boxed| (&**boxed as &(Any + 'static)).downcast_ref())
+            .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
     }
 
     /// Get a mutable reference to a type previously inserted on this `Extensions`.
     pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
         self.map
             .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| (&mut **boxed as &mut (Any + 'static)).downcast_mut())
+            .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
     }
 
     /// Remove a type from this `Extensions`.
@@ -50,7 +50,7 @@ impl Extensions {
     /// If a extension of this type existed, it will be returned.
     pub fn remove<T: 'static>(&mut self) -> Option<T> {
         self.map.remove(&TypeId::of::<T>()).and_then(|boxed| {
-            (boxed as Box<Any + 'static>)
+            (boxed as Box<dyn Any + 'static>)
                 .downcast()
                 .ok()
                 .map(|boxed| *boxed)

actix-http/src/h1/decoder.rs

@@ -502,15 +502,15 @@ impl ChunkedState {
     fn read_size(rdr: &mut BytesMut, size: &mut u64) -> Poll<ChunkedState, io::Error> {
         let radix = 16;
         match byte!(rdr) {
-            b @ b'0'...b'9' => {
+            b @ b'0'..=b'9' => {
                 *size *= radix;
                 *size += u64::from(b - b'0');
             }
-            b @ b'a'...b'f' => {
+            b @ b'a'..=b'f' => {
                 *size *= radix;
                 *size += u64::from(b + 10 - b'a');
             }
-            b @ b'A'...b'F' => {
+            b @ b'A'..=b'F' => {
                 *size *= radix;
                 *size += u64::from(b + 10 - b'A');
             }

actix-http/src/h1/dispatcher.rs

@@ -5,7 +5,6 @@ use std::{fmt, io, net};
 use actix_codec::{Decoder, Encoder, Framed, FramedParts};
 use actix_server_config::IoStream;
 use actix_service::Service;
-use actix_utils::cloneable::CloneableService;
 use bitflags::bitflags;
 use bytes::{BufMut, BytesMut};
 use futures::{Async, Future, Poll};
@@ -13,9 +12,12 @@ use log::{error, trace};
 use tokio_timer::Delay;
 
 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
+use crate::cloneable::CloneableService;
 use crate::config::ServiceConfig;
 use crate::error::{DispatchError, Error};
 use crate::error::{ParseError, PayloadError};
+use crate::helpers::DataFactory;
+use crate::httpmessage::HttpMessage;
 use crate::request::Request;
 use crate::response::Response;
 
@@ -81,6 +83,7 @@ where
     service: CloneableService<S>,
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
+    on_connect: Option<Box<dyn DataFactory>>,
     flags: Flags,
     peer_addr: Option<net::SocketAddr>,
     error: Option<DispatchError>,
@@ -174,12 +177,13 @@ where
     U::Error: fmt::Display,
 {
     /// Create http/1 dispatcher.
-    pub fn new(
+    pub(crate) fn new(
         stream: T,
         config: ServiceConfig,
         service: CloneableService<S>,
         expect: CloneableService<X>,
         upgrade: Option<CloneableService<U>>,
+        on_connect: Option<Box<dyn DataFactory>>,
     ) -> Self {
         Dispatcher::with_timeout(
             stream,
@@ -190,11 +194,12 @@ where
             service,
             expect,
             upgrade,
+            on_connect,
         )
     }
 
     /// Create http/1 dispatcher with slow request timeout.
-    pub fn with_timeout(
+    pub(crate) fn with_timeout(
         io: T,
         codec: Codec,
         config: ServiceConfig,
@@ -203,6 +208,7 @@ where
         service: CloneableService<S>,
         expect: CloneableService<X>,
         upgrade: Option<CloneableService<U>>,
+        on_connect: Option<Box<dyn DataFactory>>,
     ) -> Self {
         let keepalive = config.keep_alive_enabled();
         let flags = if keepalive {
@@ -234,6 +240,7 @@ where
                 service,
                 expect,
                 upgrade,
+                on_connect,
                 flags,
                 ka_expire,
                 ka_timer,
@@ -495,6 +502,11 @@ where
                             let pl = self.codec.message_type();
                             req.head_mut().peer_addr = self.peer_addr;
 
+                            // on_connect data
+                            if let Some(ref on_connect) = self.on_connect {
+                                on_connect.set(&mut req.extensions_mut());
+                            }
+
                             if pl == MessageType::Stream && self.upgrade.is_some() {
                                 self.messages.push_back(DispatcherMessage::Upgrade(req));
                                 break;
@@ -851,6 +863,7 @@ mod tests {
                 ),
                 CloneableService::new(ExpectHandler),
                 None,
+                None,
             );
             assert!(h1.poll().is_err());
 

actix-http/src/h1/service.rs

@@ -1,16 +1,18 @@
 use std::fmt;
 use std::marker::PhantomData;
+use std::rc::Rc;
 
 use actix_codec::Framed;
 use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
 use actix_service::{IntoNewService, NewService, Service};
-use actix_utils::cloneable::CloneableService;
 use futures::future::{ok, FutureResult};
 use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};
 
 use crate::body::MessageBody;
+use crate::cloneable::CloneableService;
 use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::{DispatchError, Error, ParseError};
+use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;
 
@@ -24,6 +26,7 @@ pub struct H1Service<T, P, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
     cfg: ServiceConfig,
     expect: X,
     upgrade: Option<U>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B)>,
 }
 
@@ -44,6 +47,7 @@ where
             srv: service.into_new_service(),
             expect: ExpectHandler,
             upgrade: None,
+            on_connect: None,
             _t: PhantomData,
         }
     }
@@ -55,6 +59,7 @@ where
             srv: service.into_new_service(),
             expect: ExpectHandler,
             upgrade: None,
+            on_connect: None,
             _t: PhantomData,
         }
     }
@@ -79,6 +84,7 @@ where
             cfg: self.cfg,
             srv: self.srv,
             upgrade: self.upgrade,
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
@@ -94,9 +100,19 @@ where
             cfg: self.cfg,
             srv: self.srv,
             expect: self.expect,
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
 }
 
 impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U>
@@ -133,6 +149,7 @@ where
             fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
             expect: None,
             upgrade: None,
+            on_connect: self.on_connect.clone(),
             cfg: Some(self.cfg.clone()),
             _t: PhantomData,
         }
@@ -157,6 +174,7 @@ where
     fut_upg: Option<U::Future>,
     expect: Option<X::Service>,
     upgrade: Option<U::Service>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     cfg: Option<ServiceConfig>,
     _t: PhantomData<(T, P, B)>,
 }
@@ -205,6 +223,7 @@ where
             service,
             self.expect.take().unwrap(),
             self.upgrade.take(),
+            self.on_connect.clone(),
         )))
     }
 }
@@ -214,6 +233,7 @@ pub struct H1ServiceHandler<T, P, S, B, X, U> {
     srv: CloneableService<S>,
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     cfg: ServiceConfig,
     _t: PhantomData<(T, P, B)>,
 }
@@ -234,12 +254,14 @@ where
         srv: S,
         expect: X,
         upgrade: Option<U>,
+        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     ) -> H1ServiceHandler<T, P, S, B, X, U> {
         H1ServiceHandler {
             srv: CloneableService::new(srv),
             expect: CloneableService::new(expect),
-            upgrade: upgrade.map(|s| CloneableService::new(s)),
+            upgrade: upgrade.map(CloneableService::new),
             cfg,
+            on_connect,
             _t: PhantomData,
         }
     }
@@ -292,12 +314,21 @@ where
     }
 
     fn call(&mut self, req: Self::Request) -> Self::Future {
+        let io = req.into_parts().0;
+
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
         Dispatcher::new(
-            req.into_parts().0,
+            io,
             self.cfg.clone(),
             self.srv.clone(),
             self.expect.clone(),
             self.upgrade.clone(),
+            on_connect,
         )
     }
 }

actix-http/src/h2/dispatcher.rs

@@ -6,7 +6,6 @@ use std::{fmt, mem, net};
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_server_config::IoStream;
 use actix_service::Service;
-use actix_utils::cloneable::CloneableService;
 use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
 use futures::{try_ready, Async, Future, Poll, Sink, Stream};
@@ -20,8 +19,10 @@ use log::{debug, error, trace};
 use tokio_timer::Delay;
 
 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
+use crate::cloneable::CloneableService;
 use crate::config::ServiceConfig;
 use crate::error::{DispatchError, Error, ParseError, PayloadError, ResponseError};
+use crate::helpers::DataFactory;
 use crate::message::ResponseHead;
 use crate::payload::Payload;
 use crate::request::Request;
@@ -33,6 +34,7 @@ const CHUNK_SIZE: usize = 16_384;
 pub struct Dispatcher<T: IoStream, S: Service<Request = Request>, B: MessageBody> {
     service: CloneableService<S>,
     connection: Connection<T, Bytes>,
+    on_connect: Option<Box<dyn DataFactory>>,
     config: ServiceConfig,
     peer_addr: Option<net::SocketAddr>,
     ka_expire: Instant,
@@ -49,9 +51,10 @@ where
     S::Response: Into<Response<B>>,
     B: MessageBody + 'static,
 {
-    pub fn new(
+    pub(crate) fn new(
         service: CloneableService<S>,
         connection: Connection<T, Bytes>,
+        on_connect: Option<Box<dyn DataFactory>>,
         config: ServiceConfig,
         timeout: Option<Delay>,
         peer_addr: Option<net::SocketAddr>,
@@ -77,6 +80,7 @@ where
             config,
             peer_addr,
             connection,
+            on_connect,
             ka_expire,
             ka_timer,
             _t: PhantomData,

actix-http/src/h2/service.rs

@@ -1,11 +1,10 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
-use std::{io, net};
+use std::{io, net, rc};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
 use actix_service::{IntoNewService, NewService, Service};
-use actix_utils::cloneable::CloneableService;
 use bytes::Bytes;
 use futures::future::{ok, FutureResult};
 use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};
@@ -14,8 +13,10 @@ use h2::RecvStream;
 use log::error;
 
 use crate::body::MessageBody;
+use crate::cloneable::CloneableService;
 use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::{DispatchError, Error, ParseError, ResponseError};
+use crate::helpers::DataFactory;
 use crate::payload::Payload;
 use crate::request::Request;
 use crate::response::Response;
@@ -26,6 +27,7 @@ use super::dispatcher::Dispatcher;
 pub struct H2Service<T, P, S, B> {
     srv: S,
     cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B)>,
 }
 
@@ -43,6 +45,7 @@ where
 
         H2Service {
             cfg,
+            on_connect: None,
             srv: service.into_new_service(),
             _t: PhantomData,
         }
@@ -52,10 +55,20 @@ where
     pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
         H2Service {
             cfg,
+            on_connect: None,
             srv: service.into_new_service(),
             _t: PhantomData,
         }
     }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
 }
 
 impl<T, P, S, B> NewService for H2Service<T, P, S, B>
@@ -79,6 +92,7 @@ where
         H2ServiceResponse {
             fut: self.srv.new_service(cfg).into_future(),
             cfg: Some(self.cfg.clone()),
+            on_connect: self.on_connect.clone(),
             _t: PhantomData,
         }
     }
@@ -88,6 +102,7 @@ where
 pub struct H2ServiceResponse<T, P, S: NewService, B> {
     fut: <S::Future as IntoFuture>::Future,
     cfg: Option<ServiceConfig>,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B)>,
 }
 
@@ -107,6 +122,7 @@ where
         let service = try_ready!(self.fut.poll());
         Ok(Async::Ready(H2ServiceHandler::new(
             self.cfg.take().unwrap(),
+            self.on_connect.clone(),
             service,
         )))
     }
@@ -116,6 +132,7 @@ where
 pub struct H2ServiceHandler<T, P, S, B> {
     srv: CloneableService<S>,
     cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B)>,
 }
 
@@ -127,9 +144,14 @@ where
     S::Response: Into<Response<B>>,
     B: MessageBody + 'static,
 {
-    fn new(cfg: ServiceConfig, srv: S) -> H2ServiceHandler<T, P, S, B> {
+    fn new(
+        cfg: ServiceConfig,
+        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        srv: S,
+    ) -> H2ServiceHandler<T, P, S, B> {
         H2ServiceHandler {
             cfg,
+            on_connect,
             srv: CloneableService::new(srv),
             _t: PhantomData,
         }
@@ -161,11 +183,18 @@ where
     fn call(&mut self, req: Self::Request) -> Self::Future {
         let io = req.into_parts().0;
         let peer_addr = io.peer_addr();
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
         H2ServiceHandlerResponse {
             state: State::Handshake(
                 Some(self.srv.clone()),
                 Some(self.cfg.clone()),
                 peer_addr,
+                on_connect,
                 server::handshake(io),
             ),
         }
@@ -181,6 +210,7 @@ where
         Option<CloneableService<S>>,
         Option<ServiceConfig>,
         Option<net::SocketAddr>,
+        Option<Box<dyn DataFactory>>,
         Handshake<T, Bytes>,
     ),
 }
@@ -216,15 +246,17 @@ where
                 ref mut srv,
                 ref mut config,
                 ref peer_addr,
+                ref mut on_connect,
                 ref mut handshake,
             ) => match handshake.poll() {
                 Ok(Async::Ready(conn)) => {
                     self.state = State::Incoming(Dispatcher::new(
                         srv.take().unwrap(),
                         conn,
+                        on_connect.take(),
                         config.take().unwrap(),
                         None,
-                        peer_addr.clone(),
+                        *peer_addr,
                     ));
                     self.poll()
                 }

actix-http/src/header/common/content_disposition.rs

@@ -70,6 +70,7 @@ impl<'a> From<&'a str> for DispositionType {
 /// assert_eq!(param.as_filename().unwrap(), "sample.txt");
 /// ```
 #[derive(Clone, Debug, PartialEq)]
+#[allow(clippy::large_enum_variant)]
 pub enum DispositionParam {
     /// For [`DispositionType::FormData`] (i.e. *multipart/form-data*), the name of an field from
     /// the form.
@@ -719,8 +720,10 @@ mod tests {
         };
         assert_eq!(a, b);
 
-        let a =
+        let a = HeaderValue::from_str(
-            HeaderValue::from_str("form-data; name=upload; filename=\"余固知謇謇之為患兮，忍而不能舍也.pptx\"").unwrap();
+            "form-data; name=upload; filename=\"余固知謇謇之為患兮，忍而不能舍也.pptx\"",
+        )
+        .unwrap();
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::FormData,

actix-http/src/helpers.rs

@@ -3,6 +3,8 @@ use std::{io, mem, ptr, slice};
 use bytes::{BufMut, BytesMut};
 use http::Version;
 
+use crate::extensions::Extensions;
+
 const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
       2021222324252627282930313233343536373839\
       4041424344454647484950515253545556575859\
@@ -180,6 +182,18 @@ impl<'a> io::Write for Writer<'a> {
     }
 }
 
+pub(crate) trait DataFactory {
+    fn set(&self, ext: &mut Extensions);
+}
+
+pub(crate) struct Data<T>(pub(crate) T);
+
+impl<T: Clone + 'static> DataFactory for Data<T> {
+    fn set(&self, ext: &mut Extensions) {
+        ext.insert(self.0.clone())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

actix-http/src/lib.rs

@@ -1,8 +1,10 @@
 //! Basic http primitives for actix-net framework.
 #![allow(
     clippy::type_complexity,
+    clippy::too_many_arguments,
     clippy::new_without_default,
-    clippy::borrow_interior_mutable_const
+    clippy::borrow_interior_mutable_const,
+    clippy::write_with_newline
 )]
 
 #[macro_use]
@@ -11,6 +13,7 @@ extern crate log;
 pub mod body;
 mod builder;
 pub mod client;
+mod cloneable;
 mod config;
 pub mod encoding;
 mod extensions;

actix-http/src/message.rs

@@ -385,6 +385,7 @@ impl Drop for BoxedResponseHead {
 pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
 
 #[doc(hidden)]
+#[allow(clippy::vec_box)]
 /// Request's objects pool
 pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);
 

actix-http/src/service.rs

@@ -1,20 +1,21 @@
 use std::marker::PhantomData;
-use std::{fmt, io, net};
+use std::{fmt, io, net, rc};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_server_config::{
     Io as ServerIo, IoStream, Protocol, ServerConfig as SrvConfig,
 };
 use actix_service::{IntoNewService, NewService, Service};
-use actix_utils::cloneable::CloneableService;
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use futures::{try_ready, Async, Future, IntoFuture, Poll};
 use h2::server::{self, Handshake};
 
 use crate::body::MessageBody;
 use crate::builder::HttpServiceBuilder;
+use crate::cloneable::CloneableService;
 use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::{DispatchError, Error};
+use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;
 use crate::{h1, h2::Dispatcher};
@@ -25,6 +26,7 @@ pub struct HttpService<T, P, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler
     cfg: ServiceConfig,
     expect: X,
     upgrade: Option<U>,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B)>,
 }
 
@@ -61,6 +63,7 @@ where
             srv: service.into_new_service(),
             expect: h1::ExpectHandler,
             upgrade: None,
+            on_connect: None,
             _t: PhantomData,
         }
     }
@@ -75,6 +78,7 @@ where
             srv: service.into_new_service(),
             expect: h1::ExpectHandler,
             upgrade: None,
+            on_connect: None,
             _t: PhantomData,
         }
     }
@@ -104,6 +108,7 @@ where
             cfg: self.cfg,
             srv: self.srv,
             upgrade: self.upgrade,
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
@@ -127,9 +132,19 @@ where
             cfg: self.cfg,
             srv: self.srv,
             expect: self.expect,
+            on_connect: self.on_connect,
             _t: PhantomData,
         }
     }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
 }
 
 impl<T, P, S, B, X, U> NewService for HttpService<T, P, S, B, X, U>
@@ -167,6 +182,7 @@ where
             fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
             expect: None,
             upgrade: None,
+            on_connect: self.on_connect.clone(),
             cfg: Some(self.cfg.clone()),
             _t: PhantomData,
         }
@@ -180,6 +196,7 @@ pub struct HttpServiceResponse<T, P, S: NewService, B, X: NewService, U: NewServ
     fut_upg: Option<U::Future>,
     expect: Option<X::Service>,
     upgrade: Option<U::Service>,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     cfg: Option<ServiceConfig>,
     _t: PhantomData<(T, P, B)>,
 }
@@ -229,6 +246,7 @@ where
             service,
             self.expect.take().unwrap(),
             self.upgrade.take(),
+            self.on_connect.clone(),
         )))
     }
 }
@@ -239,6 +257,7 @@ pub struct HttpServiceHandler<T, P, S, B, X, U> {
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
     cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     _t: PhantomData<(T, P, B, X)>,
 }
 
@@ -259,12 +278,14 @@ where
         srv: S,
         expect: X,
         upgrade: Option<U>,
+        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     ) -> HttpServiceHandler<T, P, S, B, X, U> {
         HttpServiceHandler {
             cfg,
+            on_connect,
             srv: CloneableService::new(srv),
             expect: CloneableService::new(expect),
-            upgrade: upgrade.map(|s| CloneableService::new(s)),
+            upgrade: upgrade.map(CloneableService::new),
             _t: PhantomData,
         }
     }
@@ -319,6 +340,13 @@ where
 
     fn call(&mut self, req: Self::Request) -> Self::Future {
         let (io, _, proto) = req.into_parts();
+
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
         match proto {
             Protocol::Http2 => {
                 let peer_addr = io.peer_addr();
@@ -332,6 +360,7 @@ where
                         self.cfg.clone(),
                         self.srv.clone(),
                         peer_addr,
+                        on_connect,
                     ))),
                 }
             }
@@ -342,6 +371,7 @@ where
                     self.srv.clone(),
                     self.expect.clone(),
                     self.upgrade.clone(),
+                    on_connect,
                 )),
             },
             _ => HttpServiceHandlerResponse {
@@ -352,6 +382,7 @@ where
                     self.srv.clone(),
                     self.expect.clone(),
                     self.upgrade.clone(),
+                    on_connect,
                 ))),
             },
         }
@@ -380,6 +411,7 @@ where
             CloneableService<S>,
             CloneableService<X>,
             Option<CloneableService<U>>,
+            Option<Box<dyn DataFactory>>,
         )>,
     ),
     Handshake(
@@ -388,6 +420,7 @@ where
             ServiceConfig,
             CloneableService<S>,
             Option<net::SocketAddr>,
+            Option<Box<dyn DataFactory>>,
         )>,
     ),
 }
@@ -448,7 +481,8 @@ where
                 } else {
                     panic!()
                 }
-                let (io, buf, cfg, srv, expect, upgrade) = data.take().unwrap();
+                let (io, buf, cfg, srv, expect, upgrade, on_connect) =
+                    data.take().unwrap();
                 if buf[..14] == HTTP2_PREFACE[..] {
                     let peer_addr = io.peer_addr();
                     let io = Io {
@@ -460,6 +494,7 @@ where
                         cfg,
                         srv,
                         peer_addr,
+                        on_connect,
                     )));
                 } else {
                     self.state = State::H1(h1::Dispatcher::with_timeout(
@@ -471,6 +506,7 @@ where
                         srv,
                         expect,
                         upgrade,
+                        on_connect,
                     ))
                 }
                 self.poll()
@@ -488,8 +524,10 @@ where
                 } else {
                     panic!()
                 };
-                let (_, cfg, srv, peer_addr) = data.take().unwrap();
+                let (_, cfg, srv, peer_addr, on_connect) = data.take().unwrap();
-                self.state = State::H2(Dispatcher::new(srv, conn, cfg, None, peer_addr));
+                self.state = State::H2(Dispatcher::new(
+                    srv, conn, on_connect, cfg, None, peer_addr,
+                ));
                 self.poll()
             }
         }

actix-http/src/ws/proto.rs

@@ -47,10 +47,7 @@ impl Into<u8> for OpCode {
             Ping => 9,
             Pong => 10,
             Bad => {
-                debug_assert!(
+                log::error!("Attempted to convert invalid opcode to u8. This is a bug.");
-                    false,
-                    "Attempted to convert invalid opcode to u8. This is a bug."
-                );
                 8 // if this somehow happens, a close frame will help us tear down quickly
             }
         }
@@ -206,7 +203,7 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {
     }
 }
 
-static WS_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 // TODO: hash is always same size, we dont need String
 pub fn hash_key(key: &[u8]) -> String {

actix-identity/src/lib.rs

@@ -261,7 +261,7 @@ where
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.borrow_mut().poll_ready()
@@ -283,7 +283,7 @@ where
                                 res.request().extensions_mut().remove::<IdentityItem>();
 
                             if let Some(id) = id {
-                                return Either::A(
+                                Either::A(
                                     backend
                                         .to_response(id.id, id.changed, &mut res)
                                         .into_future()
@@ -291,7 +291,7 @@ where
                                             Ok(_) => Ok(res),
                                             Err(e) => Ok(res.error_response(e)),
                                         }),
-                                );
+                                )
                             } else {
                                 Either::B(ok(res))
                             }
@@ -333,8 +333,7 @@ struct CookieIdentityExtention {
 
 impl CookieIdentityInner {
     fn new(key: &[u8]) -> CookieIdentityInner {
-        let key_v2: Vec<u8> =
+        let key_v2: Vec<u8> = key.iter().chain([1, 0, 0, 0].iter()).cloned().collect();
-            key.iter().chain([1, 0, 0, 0].iter()).map(|e| *e).collect();
         CookieIdentityInner {
             key: Key::from_master(key),
             key_v2: Key::from_master(&key_v2),
@@ -585,13 +584,14 @@ impl IdentityPolicy for CookieIdentityPolicy {
             )
         } else if self.0.always_update_cookie() && id.is_some() {
             let visit_timestamp = SystemTime::now();
-            let mut login_timestamp = None;
+            let login_timestamp = if self.0.requires_oob_data() {
-            if self.0.requires_oob_data() {
                 let CookieIdentityExtention {
                     login_timestamp: lt,
                 } = res.request().extensions_mut().remove().unwrap();
-                login_timestamp = lt;
+                lt
-            }
+            } else {
+                None
+            };
             self.0.set_cookie(
                 res,
                 Some(CookieValue {

actix-multipart/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::borrow_interior_mutable_const)]
+
 mod error;
 mod extractor;
 mod server;

actix-multipart/src/server.rs

@@ -418,7 +418,7 @@ impl Stream for Field {
 
             inner.poll(&self.safety)
         } else if !self.safety.is_clean() {
-            return Err(MultipartError::NotConsumed);
+            Err(MultipartError::NotConsumed)
         } else {
             Ok(Async::NotReady)
         }
@@ -533,11 +533,9 @@ impl InnerField {
                 let b_size = boundary.len() + b_len;
                 if len < b_size {
                     return Ok(Async::NotReady);
-                } else {
+                } else if &payload.buf[b_len..b_size] == boundary.as_bytes() {
-                    if &payload.buf[b_len..b_size] == boundary.as_bytes() {
+                    // found boundary
-                        // found boundary
+                    return Ok(Async::Ready(None));
-                        return Ok(Async::Ready(None));
-                    }
                 }
             }
         }
@@ -557,7 +555,7 @@ impl InnerField {
                     // check boundary
                     if (&payload.buf[cur..cur + 2] == b"\r\n"
                         && &payload.buf[cur + 2..cur + 4] == b"--")
-                        || (&payload.buf[cur..cur + 1] == b"\r"
+                        || (&payload.buf[cur..=cur] == b"\r"
                             && &payload.buf[cur + 1..cur + 3] == b"--")
                     {
                         if cur != 0 {

actix-session/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## [0.2.0] - 2019-07-08
+
+*  Enhanced ``actix-session`` to facilitate state changes.  Use ``Session.renew()``
+   at successful login to cycle a session (new key/cookie but keeps state).
+   Use ``Session.purge()`` at logout to invalid a session cookie (and remove
+   from redis cache, if applicable).
+
 ## [0.1.1] - 2019-06-03
 
 * Fix optional cookie session support

actix-session/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-session"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Session for actix web framework."
 readme = "README.md"

actix-session/README.md

@@ -6,4 +6,4 @@
 * [API Documentation](https://docs.rs/actix-session/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-session](https://crates.io/crates/actix-session)
-* Minimum supported Rust version: 1.33 or later
+* Minimum supported Rust version: 1.34 or later

actix-session/src/cookie.rs

@@ -28,7 +28,7 @@ use futures::future::{ok, Future, FutureResult};
 use futures::Poll;
 use serde_json::error::Error as JsonError;
 
-use crate::Session;
+use crate::{Session, SessionStatus};
 
 /// Errors that can occur during handling cookie session
 #[derive(Debug, From, Display)]
@@ -119,7 +119,20 @@ impl CookieSessionInner {
         Ok(())
     }
 
-    fn load(&self, req: &ServiceRequest) -> HashMap<String, String> {
+    /// invalidates session cookie
+    fn remove_cookie<B>(&self, res: &mut ServiceResponse<B>) -> Result<(), Error> {
+        let mut cookie = Cookie::named(self.name.clone());
+        cookie.set_value("");
+        cookie.set_max_age(time::Duration::seconds(0));
+        cookie.set_expires(time::now() - time::Duration::days(365));
+
+        let val = HeaderValue::from_str(&cookie.to_string())?;
+        res.headers_mut().append(SET_COOKIE, val);
+
+        Ok(())
+    }
+
+    fn load(&self, req: &ServiceRequest) -> (bool, HashMap<String, String>) {
         if let Ok(cookies) = req.cookies() {
             for cookie in cookies.iter() {
                 if cookie.name() == self.name {
@@ -134,13 +147,13 @@ impl CookieSessionInner {
                     };
                     if let Some(cookie) = cookie_opt {
                         if let Ok(val) = serde_json::from_str(cookie.value()) {
-                            return val;
+                            return (false, val);
                         }
                     }
                 }
             }
         }
-        HashMap::new()
+        (true, HashMap::new())
     }
 }
 
@@ -296,22 +309,43 @@ where
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = S::Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
+    /// On first request, a new session cookie is returned in response, regardless
+    /// of whether any session state is set.  With subsequent requests, if the
+    /// session state changes, then set-cookie is returned in response.  As
+    /// a user logs out, call session.purge() to set SessionStatus accordingly
+    /// and this will trigger removal of the session cookie in the response.
     fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
         let inner = self.inner.clone();
-        let state = self.inner.load(&req);
+        let (is_new, state) = self.inner.load(&req);
         Session::set_session(state.into_iter(), &mut req);
 
         Box::new(self.service.call(req).map(move |mut res| {
-            if let Some(state) = Session::get_changes(&mut res) {
+            match Session::get_changes(&mut res) {
-                res.checked_expr(|res| inner.set_cookie(res, state))
+                (SessionStatus::Changed, Some(state))
-            } else {
+                | (SessionStatus::Renewed, Some(state)) => {
-                res
+                    res.checked_expr(|res| inner.set_cookie(res, state))
+                }
+                (SessionStatus::Unchanged, _) =>
+                // set a new session cookie upon first request (new client)
+                {
+                    if is_new {
+                        let state: HashMap<String, String> = HashMap::new();
+                        res.checked_expr(|res| inner.set_cookie(res, state.into_iter()))
+                    } else {
+                        res
+                    }
+                }
+                (SessionStatus::Purged, _) => {
+                    let _ = inner.remove_cookie(&mut res);
+                    res
+                }
+                _ => res,
             }
         }))
     }

actix-session/src/lib.rs

@@ -98,10 +98,23 @@ impl UserSession for ServiceRequest {
     }
 }
 
+#[derive(PartialEq, Clone, Debug)]
+pub enum SessionStatus {
+    Changed,
+    Purged,
+    Renewed,
+    Unchanged,
+}
+impl Default for SessionStatus {
+    fn default() -> SessionStatus {
+        SessionStatus::Unchanged
+    }
+}
+
 #[derive(Default)]
 struct SessionInner {
     state: HashMap<String, String>,
-    changed: bool,
+    pub status: SessionStatus,
 }
 
 impl Session {
@@ -117,25 +130,46 @@ impl Session {
     /// Set a `value` from the session.
     pub fn set<T: Serialize>(&self, key: &str, value: T) -> Result<(), Error> {
         let mut inner = self.0.borrow_mut();
-        inner.changed = true;
+        if inner.status != SessionStatus::Purged {
-        inner
+            inner.status = SessionStatus::Changed;
-            .state
+            inner
-            .insert(key.to_owned(), serde_json::to_string(&value)?);
+                .state
+                .insert(key.to_owned(), serde_json::to_string(&value)?);
+        }
         Ok(())
     }
 
     /// Remove value from the session.
     pub fn remove(&self, key: &str) {
         let mut inner = self.0.borrow_mut();
-        inner.changed = true;
+        if inner.status != SessionStatus::Purged {
-        inner.state.remove(key);
+            inner.status = SessionStatus::Changed;
+            inner.state.remove(key);
+        }
     }
 
     /// Clear the session.
     pub fn clear(&self) {
         let mut inner = self.0.borrow_mut();
-        inner.changed = true;
+        if inner.status != SessionStatus::Purged {
-        inner.state.clear()
+            inner.status = SessionStatus::Changed;
+            inner.state.clear()
+        }
+    }
+
+    /// Removes session, both client and server side.
+    pub fn purge(&self) {
+        let mut inner = self.0.borrow_mut();
+        inner.status = SessionStatus::Purged;
+        inner.state.clear();
+    }
+
+    /// Renews the session key, assigning existing session state to new key.
+    pub fn renew(&self) {
+        let mut inner = self.0.borrow_mut();
+        if inner.status != SessionStatus::Purged {
+            inner.status = SessionStatus::Renewed;
+        }
     }
 
     pub fn set_session(
@@ -149,7 +183,10 @@ impl Session {
 
     pub fn get_changes<B>(
         res: &mut ServiceResponse<B>,
-    ) -> Option<impl Iterator<Item = (String, String)>> {
+    ) -> (
+        SessionStatus,
+        Option<impl Iterator<Item = (String, String)>>,
+    ) {
         if let Some(s_impl) = res
             .request()
             .extensions()
@@ -157,9 +194,9 @@ impl Session {
         {
             let state =
                 std::mem::replace(&mut s_impl.borrow_mut().state, HashMap::new());
-            Some(state.into_iter())
+            (s_impl.borrow().status.clone(), Some(state.into_iter()))
         } else {
-            None
+            (SessionStatus::Unchanged, None)
         }
     }
 
@@ -224,7 +261,8 @@ mod tests {
         session.remove("key");
 
         let mut res = req.into_response(HttpResponse::Ok().finish());
-        let changes: Vec<_> = Session::get_changes(&mut res).unwrap().collect();
+        let (_status, state) = Session::get_changes(&mut res);
+        let changes: Vec<_> = state.unwrap().collect();
         assert_eq!(changes, [("key2".to_string(), "\"value2\"".to_string())]);
     }
 
@@ -241,4 +279,22 @@ mod tests {
         let res = session.get::<String>("key").unwrap();
         assert_eq!(res, Some("value".to_string()));
     }
+
+    #[test]
+    fn purge_session() {
+        let req = test::TestRequest::default().to_srv_request();
+        let session = Session::get_session(&mut *req.extensions_mut());
+        assert_eq!(session.0.borrow().status, SessionStatus::Unchanged);
+        session.purge();
+        assert_eq!(session.0.borrow().status, SessionStatus::Purged);
+    }
+
+    #[test]
+    fn renew_session() {
+        let req = test::TestRequest::default().to_srv_request();
+        let session = Session::get_session(&mut *req.extensions_mut());
+        assert_eq!(session.0.borrow().status, SessionStatus::Unchanged);
+        session.renew();
+        assert_eq!(session.0.borrow().status, SessionStatus::Renewed);
+    }
 }

actix-web-actors/Cargo.toml

@@ -19,8 +19,8 @@ path = "src/lib.rs"
 
 [dependencies]
 actix = "0.8.3"
-actix-web = "1.0.2"
+actix-web = "1.0.3"
-actix-http = "0.2.4"
+actix-http = "0.2.5"
 actix-codec = "0.1.2"
 bytes = "0.4"
 futures = "0.1.25"

actix-web-actors/src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::borrow_interior_mutable_const)]
 //! Actix actors integration for Actix web framework
 mod context;
 pub mod ws;

actix-web-actors/src/ws.rs

@@ -435,7 +435,7 @@ where
                         }
                     }
                     Frame::Binary(data) => Message::Binary(
-                        data.map(|b| b.freeze()).unwrap_or_else(|| Bytes::new()),
+                        data.map(|b| b.freeze()).unwrap_or_else(Bytes::new),
                     ),
                     Frame::Ping(s) => Message::Ping(s),
                     Frame::Pong(s) => Message::Pong(s),

actix-web-codegen/src/route.rs

@@ -12,9 +12,9 @@ enum ResourceType {
 
 impl fmt::Display for ResourceType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
+        match *self {
-            &ResourceType::Async => write!(f, "to_async"),
+            ResourceType::Async => write!(f, "to_async"),
-            &ResourceType::Sync => write!(f, "to"),
+            ResourceType::Sync => write!(f, "to"),
         }
     }
 }
@@ -34,16 +34,16 @@ pub enum GuardType {
 
 impl fmt::Display for GuardType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
+        match *self {
-            &GuardType::Get => write!(f, "Get"),
+            GuardType::Get => write!(f, "Get"),
-            &GuardType::Post => write!(f, "Post"),
+            GuardType::Post => write!(f, "Post"),
-            &GuardType::Put => write!(f, "Put"),
+            GuardType::Put => write!(f, "Put"),
-            &GuardType::Delete => write!(f, "Delete"),
+            GuardType::Delete => write!(f, "Delete"),
-            &GuardType::Head => write!(f, "Head"),
+            GuardType::Head => write!(f, "Head"),
-            &GuardType::Connect => write!(f, "Connect"),
+            GuardType::Connect => write!(f, "Connect"),
-            &GuardType::Options => write!(f, "Options"),
+            GuardType::Options => write!(f, "Options"),
-            &GuardType::Trace => write!(f, "Trace"),
+            GuardType::Trace => write!(f, "Trace"),
-            &GuardType::Patch => write!(f, "Patch"),
+            GuardType::Patch => write!(f, "Patch"),
         }
     }
 }
@@ -92,37 +92,27 @@ impl actix_web::dev::HttpServiceFactory for {name} {{
 fn guess_resource_type(typ: &syn::Type) -> ResourceType {
     let mut guess = ResourceType::Sync;
 
-    match typ {
+    if let syn::Type::ImplTrait(typ) = typ {
-        syn::Type::ImplTrait(typ) => {
+        for bound in typ.bounds.iter() {
-            for bound in typ.bounds.iter() {
+            if let syn::TypeParamBound::Trait(bound) = bound {
-                match bound {
+                for bound in bound.path.segments.iter() {
-                    syn::TypeParamBound::Trait(bound) => {
+                    if bound.ident == "Future" {
-                        for bound in bound.path.segments.iter() {
+                        guess = ResourceType::Async;
-                            if bound.ident == "Future" {
+                        break;
-                                guess = ResourceType::Async;
+                    } else if bound.ident == "Responder" {
-                                break;
+                        guess = ResourceType::Sync;
-                            } else if bound.ident == "Responder" {
+                        break;
-                                guess = ResourceType::Sync;
-                                break;
-                            }
-                        }
                     }
-                    _ => (),
                 }
             }
         }
-        _ => (),
     }
 
     guess
 }
 
 impl Args {
-    pub fn new(
+    pub fn new(args: &[syn::NestedMeta], input: TokenStream, guard: GuardType) -> Self {
-        args: &Vec<syn::NestedMeta>,
-        input: TokenStream,
-        guard: GuardType,
-    ) -> Self {
         if args.is_empty() {
             panic!(
                 "invalid server definition, expected: #[{}(\"some path\")]",
@@ -164,9 +154,10 @@ impl Args {
             ResourceType::Async
         } else {
             match ast.decl.output {
-                syn::ReturnType::Default => {
+                syn::ReturnType::Default => panic!(
-                    panic!("Function {} has no return type. Cannot be used as handler")
+                    "Function {} has no return type. Cannot be used as handler",
-                }
+                    name
+                ),
                 syn::ReturnType::Type(_, ref typ) => guess_resource_type(typ.as_ref()),
             }
         };

awc/CHANGES.md

@@ -1,5 +1,14 @@
 # Changes
 
+## [0.2.2] - 2019-07-01
+
+### Changed
+
+* Always append a colon after username in basic auth
+
+* Upgrade `rand` dependency version to 0.7
+
+
 ## [0.2.1] - 2019-06-05
 
 ### Added

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "0.2.1"
+version = "0.2.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http client."
 readme = "README.md"
@@ -49,7 +49,7 @@ futures = "0.1.25"
 log =" 0.4"
 mime = "0.3"
 percent-encoding = "1.0"
-rand = "0.6"
+rand = "0.7"
 serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.5.3"
@@ -66,5 +66,5 @@ actix-server = { version = "0.5.1", features=["ssl"] }
 brotli2 = { version="0.3.2" }
 flate2 = { version="1.0.2" }
 env_logger = "0.6"
-rand = "0.6"
+rand = "0.7"
-tokio-tcp = "0.1"
+tokio-tcp = "0.1"

awc/src/builder.rs

@@ -21,6 +21,12 @@ pub struct ClientBuilder {
     max_redirects: usize,
 }
 
+impl Default for ClientBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ClientBuilder {
     pub fn new() -> Self {
         ClientBuilder {
@@ -115,7 +121,7 @@ impl ClientBuilder {
     {
         let auth = match password {
             Some(password) => format!("{}:{}", username, password),
-            None => format!("{}", username),
+            None => format!("{}:", username),
         };
         self.header(
             header::AUTHORIZATION,
@@ -164,7 +170,7 @@ mod tests {
                 .unwrap()
                 .to_str()
                 .unwrap(),
-            "Basic dXNlcm5hbWU="
+            "Basic dXNlcm5hbWU6"
         );
     }
 

awc/src/connect.rs

@@ -20,7 +20,7 @@ pub(crate) trait Connect {
         head: RequestHead,
         body: Body,
         addr: Option<net::SocketAddr>,
-    ) -> Box<Future<Item = ClientResponse, Error = SendRequestError>>;
+    ) -> Box<dyn Future<Item = ClientResponse, Error = SendRequestError>>;
 
     /// Send request, returns Response and Framed
     fn open_tunnel(
@@ -28,7 +28,7 @@ pub(crate) trait Connect {
         head: RequestHead,
         addr: Option<net::SocketAddr>,
     ) -> Box<
-        Future<
+        dyn Future<
             Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
             Error = SendRequestError,
         >,
@@ -49,7 +49,7 @@ where
         head: RequestHead,
         body: Body,
         addr: Option<net::SocketAddr>,
-    ) -> Box<Future<Item = ClientResponse, Error = SendRequestError>> {
+    ) -> Box<dyn Future<Item = ClientResponse, Error = SendRequestError>> {
         Box::new(
             self.0
                 // connect to the host
@@ -69,7 +69,7 @@ where
         head: RequestHead,
         addr: Option<net::SocketAddr>,
     ) -> Box<
-        Future<
+        dyn Future<
             Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
             Error = SendRequestError,
         >,
@@ -93,21 +93,21 @@ where
 }
 
 trait AsyncSocket {
-    fn as_read(&self) -> &AsyncRead;
+    fn as_read(&self) -> &dyn AsyncRead;
-    fn as_read_mut(&mut self) -> &mut AsyncRead;
+    fn as_read_mut(&mut self) -> &mut dyn AsyncRead;
-    fn as_write(&mut self) -> &mut AsyncWrite;
+    fn as_write(&mut self) -> &mut dyn AsyncWrite;
 }
 
 struct Socket<T: AsyncRead + AsyncWrite>(T);
 
 impl<T: AsyncRead + AsyncWrite> AsyncSocket for Socket<T> {
-    fn as_read(&self) -> &AsyncRead {
+    fn as_read(&self) -> &dyn AsyncRead {
         &self.0
     }
-    fn as_read_mut(&mut self) -> &mut AsyncRead {
+    fn as_read_mut(&mut self) -> &mut dyn AsyncRead {
         &mut self.0
     }
-    fn as_write(&mut self) -> &mut AsyncWrite {
+    fn as_write(&mut self) -> &mut dyn AsyncWrite {
         &mut self.0
     }
 }

awc/src/lib.rs

@@ -1,7 +1,8 @@
+#![allow(clippy::borrow_interior_mutable_const)]
 //! An HTTP Client
 //!
 //! ```rust
-//! # use futures::future::{Future, lazy};
+//! use futures::future::{lazy, Future};
 //! use actix_rt::System;
 //! use awc::Client;
 //!

awc/src/request.rs

@@ -185,9 +185,7 @@ impl ClientRequest {
     {
         match HeaderName::try_from(key) {
             Ok(key) => match value.try_into() {
-                Ok(value) => {
+                Ok(value) => self.head.headers.append(key, value),
-                    let _ = self.head.headers.append(key, value);
-                }
                 Err(e) => self.err = Some(e.into()),
             },
             Err(e) => self.err = Some(e.into()),
@@ -203,9 +201,7 @@ impl ClientRequest {
     {
         match HeaderName::try_from(key) {
             Ok(key) => match value.try_into() {
-                Ok(value) => {
+                Ok(value) => self.head.headers.insert(key, value),
-                    let _ = self.head.headers.insert(key, value);
-                }
                 Err(e) => self.err = Some(e.into()),
             },
             Err(e) => self.err = Some(e.into()),
@@ -223,9 +219,7 @@ impl ClientRequest {
             Ok(key) => {
                 if !self.head.headers.contains_key(&key) {
                     match value.try_into() {
-                        Ok(value) => {
+                        Ok(value) => self.head.headers.insert(key, value),
-                            let _ = self.head.headers.insert(key, value);
-                        }
                         Err(e) => self.err = Some(e.into()),
                     }
                 }
@@ -257,9 +251,7 @@ impl ClientRequest {
         HeaderValue: HttpTryFrom<V>,
     {
         match HeaderValue::try_from(value) {
-            Ok(value) => {
+            Ok(value) => self.head.headers.insert(header::CONTENT_TYPE, value),
-                let _ = self.head.headers.insert(header::CONTENT_TYPE, value);
-            }
             Err(e) => self.err = Some(e.into()),
         }
         self
@@ -280,7 +272,7 @@ impl ClientRequest {
     {
         let auth = match password {
             Some(password) => format!("{}:{}", username, password),
-            None => format!("{}", username),
+            None => format!("{}:", username),
         };
         self.header(
             header::AUTHORIZATION,
@@ -321,7 +313,7 @@ impl ClientRequest {
     ///     }));
     /// }
     /// ```
-    pub fn cookie<'c>(mut self, cookie: Cookie<'c>) -> Self {
+    pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
         if self.cookies.is_none() {
             let mut jar = CookieJar::new();
             jar.add(cookie.into_owned());
@@ -465,7 +457,7 @@ impl ClientRequest {
             });
 
         // set request timeout
-        if let Some(timeout) = slf.timeout.or_else(|| config.timeout.clone()) {
+        if let Some(timeout) = slf.timeout.or_else(|| config.timeout) {
             Either::B(Either::A(Timeout::new(fut, timeout).map_err(|e| {
                 if let Some(e) = e.into_inner() {
                     e
@@ -664,7 +656,7 @@ mod tests {
                 .unwrap()
                 .to_str()
                 .unwrap(),
-            "Basic dXNlcm5hbWU="
+            "Basic dXNlcm5hbWU6"
         );
     }
 

awc/src/test.rs

@@ -68,7 +68,7 @@ impl TestResponse {
     }
 
     /// Set cookie for this response
-    pub fn cookie<'a>(mut self, cookie: Cookie<'a>) -> Self {
+    pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
         self.cookies.add(cookie.into_owned());
         self
     }

awc/src/ws.rs

@@ -90,7 +90,7 @@ impl WebsocketsRequest {
     }
 
     /// Set a cookie
-    pub fn cookie<'c>(mut self, cookie: Cookie<'c>) -> Self {
+    pub fn cookie(mut self, cookie: Cookie<'_>) -> Self {
         if self.cookies.is_none() {
             let mut jar = CookieJar::new();
             jar.add(cookie.into_owned());
@@ -195,7 +195,7 @@ impl WebsocketsRequest {
     {
         let auth = match password {
             Some(password) => format!("{}:{}", username, password),
-            None => format!("{}", username),
+            None => format!("{}:", username),
         };
         self.header(AUTHORIZATION, format!("Basic {}", base64::encode(&auth)))
     }
@@ -443,7 +443,7 @@ mod tests {
                 .unwrap()
                 .to_str()
                 .unwrap(),
-            "Basic dXNlcm5hbWU="
+            "Basic dXNlcm5hbWU6"
         );
     }
 

src/app.rs

@@ -23,16 +23,17 @@ use crate::service::{
 };
 
 type HttpNewService = BoxedNewService<(), ServiceRequest, ServiceResponse, Error, ()>;
-type FnDataFactory = Box<Fn() -> Box<dyn Future<Item = Box<DataFactory>, Error = ()>>>;
+type FnDataFactory =
+    Box<dyn Fn() -> Box<dyn Future<Item = Box<dyn DataFactory>, Error = ()>>>;
 
 /// Application builder - structure that follows the builder pattern
 /// for building application instances.
 pub struct App<T, B> {
     endpoint: T,
-    services: Vec<Box<ServiceFactory>>,
+    services: Vec<Box<dyn ServiceFactory>>,
     default: Option<Rc<HttpNewService>>,
     factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
-    data: Vec<Box<DataFactory>>,
+    data: Vec<Box<dyn DataFactory>>,
     data_factories: Vec<FnDataFactory>,
     config: AppConfigInner,
     external: Vec<ResourceDef>,

src/app_service.rs

@@ -18,14 +18,15 @@ use crate::request::{HttpRequest, HttpRequestPool};
 use crate::rmap::ResourceMap;
 use crate::service::{ServiceFactory, ServiceRequest, ServiceResponse};
 
-type Guards = Vec<Box<Guard>>;
+type Guards = Vec<Box<dyn Guard>>;
 type HttpService = BoxedService<ServiceRequest, ServiceResponse, Error>;
 type HttpNewService = BoxedNewService<(), ServiceRequest, ServiceResponse, Error, ()>;
 type BoxedResponse = Either<
     FutureResult<ServiceResponse, Error>,
-    Box<Future<Item = ServiceResponse, Error = Error>>,
+    Box<dyn Future<Item = ServiceResponse, Error = Error>>,
 >;
-type FnDataFactory = Box<Fn() -> Box<dyn Future<Item = Box<DataFactory>, Error = ()>>>;
+type FnDataFactory =
+    Box<dyn Fn() -> Box<dyn Future<Item = Box<dyn DataFactory>, Error = ()>>>;
 
 /// Service factory to convert `Request` to a `ServiceRequest<S>`.
 /// It also executes data factories.
@@ -40,10 +41,10 @@ where
     >,
 {
     pub(crate) endpoint: T,
-    pub(crate) data: Rc<Vec<Box<DataFactory>>>,
+    pub(crate) data: Rc<Vec<Box<dyn DataFactory>>>,
     pub(crate) data_factories: Rc<Vec<FnDataFactory>>,
     pub(crate) config: RefCell<AppConfig>,
-    pub(crate) services: Rc<RefCell<Vec<Box<ServiceFactory>>>>,
+    pub(crate) services: Rc<RefCell<Vec<Box<dyn ServiceFactory>>>>,
     pub(crate) default: Option<Rc<HttpNewService>>,
     pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
     pub(crate) external: RefCell<Vec<ResourceDef>>,
@@ -142,9 +143,9 @@ where
     endpoint_fut: T::Future,
     rmap: Rc<ResourceMap>,
     config: AppConfig,
-    data: Rc<Vec<Box<DataFactory>>>,
+    data: Rc<Vec<Box<dyn DataFactory>>>,
-    data_factories: Vec<Box<DataFactory>>,
+    data_factories: Vec<Box<dyn DataFactory>>,
-    data_factories_fut: Vec<Box<dyn Future<Item = Box<DataFactory>, Error = ()>>>,
+    data_factories_fut: Vec<Box<dyn Future<Item = Box<dyn DataFactory>, Error = ()>>>,
     _t: PhantomData<B>,
 }
 
@@ -297,14 +298,14 @@ impl NewService for AppRoutingFactory {
     }
 }
 
-type HttpServiceFut = Box<Future<Item = HttpService, Error = ()>>;
+type HttpServiceFut = Box<dyn Future<Item = HttpService, Error = ()>>;
 
 /// Create app service
 #[doc(hidden)]
 pub struct AppRoutingFactoryResponse {
     fut: Vec<CreateAppRoutingItem>,
     default: Option<HttpService>,
-    default_fut: Option<Box<Future<Item = HttpService, Error = ()>>>,
+    default_fut: Option<Box<dyn Future<Item = HttpService, Error = ()>>>,
 }
 
 enum CreateAppRoutingItem {

src/config.rs

@@ -16,7 +16,7 @@ use crate::service::{
     ServiceResponse,
 };
 
-type Guards = Vec<Box<Guard>>;
+type Guards = Vec<Box<dyn Guard>>;
 type HttpNewService =
     boxed::BoxedNewService<(), ServiceRequest, ServiceResponse, Error, ()>;
 
@@ -31,7 +31,7 @@ pub struct AppService {
         Option<Guards>,
         Option<Rc<ResourceMap>>,
     )>,
-    service_data: Rc<Vec<Box<DataFactory>>>,
+    service_data: Rc<Vec<Box<dyn DataFactory>>>,
 }
 
 impl AppService {
@@ -39,7 +39,7 @@ impl AppService {
     pub(crate) fn new(
         config: AppConfig,
         default: Rc<HttpNewService>,
-        service_data: Rc<Vec<Box<DataFactory>>>,
+        service_data: Rc<Vec<Box<dyn DataFactory>>>,
     ) -> Self {
         AppService {
             config,
@@ -101,7 +101,7 @@ impl AppService {
     pub fn register_service<F, S>(
         &mut self,
         rdef: ResourceDef,
-        guards: Option<Vec<Box<Guard>>>,
+        guards: Option<Vec<Box<dyn Guard>>>,
         service: F,
         nested: Option<Rc<ResourceMap>>,
     ) where
@@ -174,8 +174,8 @@ impl Default for AppConfigInner {
 /// to set of external methods. This could help with
 /// modularization of big application configuration.
 pub struct ServiceConfig {
-    pub(crate) services: Vec<Box<ServiceFactory>>,
+    pub(crate) services: Vec<Box<dyn ServiceFactory>>,
-    pub(crate) data: Vec<Box<DataFactory>>,
+    pub(crate) data: Vec<Box<dyn DataFactory>>,
     pub(crate) external: Vec<ResourceDef>,
 }
 

src/data.rs

@@ -118,7 +118,7 @@ impl<T: 'static> FromRequest for Data<T> {
 impl<T: 'static> DataFactory for Data<T> {
     fn create(&self, extensions: &mut Extensions) -> bool {
         if !extensions.contains::<Data<T>>() {
-            let _ = extensions.insert(Data(self.0.clone()));
+            extensions.insert(Data(self.0.clone()));
             true
         } else {
             false

src/extract.rs

@@ -94,7 +94,7 @@ where
 {
     type Config = T::Config;
     type Error = Error;
-    type Future = Box<Future<Item = Option<T>, Error = Error>>;
+    type Future = Box<dyn Future<Item = Option<T>, Error = Error>>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
@@ -165,7 +165,7 @@ where
 {
     type Config = T::Config;
     type Error = Error;
-    type Future = Box<Future<Item = Result<T, T::Error>, Error = Error>>;
+    type Future = Box<dyn Future<Item = Result<T, T::Error>, Error = Error>>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {

src/guard.rs

@@ -100,7 +100,7 @@ pub fn Any<F: Guard + 'static>(guard: F) -> AnyGuard {
 }
 
 /// Matches if any of supplied guards matche.
-pub struct AnyGuard(Vec<Box<Guard>>);
+pub struct AnyGuard(Vec<Box<dyn Guard>>);
 
 impl AnyGuard {
     /// Add guard to a list of guards to check
@@ -140,7 +140,7 @@ pub fn All<F: Guard + 'static>(guard: F) -> AllGuard {
 }
 
 /// Matches if all of supplied guards.
-pub struct AllGuard(Vec<Box<Guard>>);
+pub struct AllGuard(Vec<Box<dyn Guard>>);
 
 impl AllGuard {
     /// Add new guard to the list of guards to check
@@ -167,7 +167,7 @@ pub fn Not<F: Guard + 'static>(guard: F) -> NotGuard {
 }
 
 #[doc(hidden)]
-pub struct NotGuard(Box<Guard>);
+pub struct NotGuard(Box<dyn Guard>);
 
 impl Guard for NotGuard {
     fn check(&self, request: &RequestHead) -> bool {

src/handler.rs

@@ -250,7 +250,7 @@ where
             Ok(Async::Ready(res)) => {
                 self.fut2 =
                     Some(res.respond_to(self.req.as_ref().unwrap()).into_future());
-                return self.poll();
+                self.poll()
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
             Err(e) => {

src/info.rs

@@ -25,7 +25,7 @@ impl ConnectionInfo {
         Ref::map(req.extensions(), |e| e.get().unwrap())
     }
 
-    #[allow(clippy::cyclomatic_complexity)]
+    #[allow(clippy::cognitive_complexity)]
     fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {
         let mut host = None;
         let mut scheme = None;

src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::borrow_interior_mutable_const)]
 //! Actix web is a small, pragmatic, and extremely fast web framework
 //! for Rust.
 //!
@@ -134,6 +135,8 @@ pub mod dev {
     //! ```
 
     pub use crate::config::{AppConfig, AppService};
+    #[doc(hidden)]
+    pub use crate::handler::{AsyncFactory, Factory};
     pub use crate::info::ConnectionInfo;
     pub use crate::rmap::ResourceMap;
     pub use crate::service::{

src/middleware/defaultheaders.rs

@@ -119,7 +119,7 @@ where
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()

src/middleware/errhandlers.rs

@@ -15,10 +15,10 @@ pub enum ErrorHandlerResponse<B> {
     /// New http response got generated
     Response(ServiceResponse<B>),
     /// Result is a future that resolves to a new http response
-    Future(Box<Future<Item = ServiceResponse<B>, Error = Error>>),
+    Future(Box<dyn Future<Item = ServiceResponse<B>, Error = Error>>),
 }
 
-type ErrorHandler<B> = Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>>;
+type ErrorHandler<B> = dyn Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>>;
 
 /// `Middleware` for allowing custom handlers for responses.
 ///
@@ -117,7 +117,7 @@ where
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()

src/middleware/logger.rs

@@ -415,9 +415,9 @@ impl FormatText {
                     ))
                 };
             }
-            FormatText::UrlPath => *self = FormatText::Str(format!("{}", req.path())),
+            FormatText::UrlPath => *self = FormatText::Str(req.path().to_string()),
             FormatText::RequestTime => {
-                *self = FormatText::Str(format!("{}", now.rfc3339()))
+                *self = FormatText::Str(now.rfc3339().to_string())
             }
             FormatText::RequestHeader(ref name) => {
                 let s = if let Some(val) = req.headers().get(name) {
@@ -444,7 +444,9 @@ impl FormatText {
     }
 }
 
-pub(crate) struct FormatDisplay<'a>(&'a Fn(&mut Formatter) -> Result<(), fmt::Error>);
+pub(crate) struct FormatDisplay<'a>(
+    &'a dyn Fn(&mut Formatter) -> Result<(), fmt::Error>,
+);
 
 impl<'a> fmt::Display for FormatDisplay<'a> {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {

src/request.rs

@@ -174,6 +174,12 @@ impl HttpRequest {
         self.url_for(name, &NO_PARAMS)
     }
 
+    #[inline]
+    /// Get a reference to a `ResourceMap` of current application.
+    pub fn resource_map(&self) -> &ResourceMap {
+        &self.0.rmap
+    }
+
     /// Peer socket address
     ///
     /// Peer address is actual socket address, if proxy is used in front of
@@ -186,6 +192,9 @@ impl HttpRequest {
     }
 
     /// Get *ConnectionInfo* for the current request.
+    ///
+    /// This method panics if request's extensions container is already
+    /// borrowed.
     #[inline]
     pub fn connection_info(&self) -> Ref<ConnectionInfo> {
         ConnectionInfo::get(self.head(), &*self.app_config())

src/resource.rs

@@ -50,7 +50,7 @@ pub struct Resource<T = ResourceEndpoint> {
     name: Option<String>,
     routes: Vec<Route>,
     data: Option<Extensions>,
-    guards: Vec<Box<Guard>>,
+    guards: Vec<Box<dyn Guard>>,
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
     factory_ref: Rc<RefCell<Option<ResourceFactory>>>,
 }
@@ -118,7 +118,7 @@ where
         self
     }
 
-    pub(crate) fn add_guards(mut self, guards: Vec<Box<Guard>>) -> Self {
+    pub(crate) fn add_guards(mut self, guards: Vec<Box<dyn Guard>>) -> Self {
         self.guards.extend(guards);
         self
     }
@@ -245,7 +245,7 @@ where
     /// ```rust
     /// # use actix_web::*;
     /// # use futures::future::Future;
-    /// # fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    /// # fn index(req: HttpRequest) -> Box<dyn Future<Item=HttpResponse, Error=Error>> {
     /// #     unimplemented!()
     /// # }
     /// App::new().service(web::resource("/").route(web::route().to_async(index)));
@@ -426,7 +426,7 @@ where
     fn into_new_service(self) -> T {
         *self.factory_ref.borrow_mut() = Some(ResourceFactory {
             routes: self.routes,
-            data: self.data.map(|data| Rc::new(data)),
+            data: self.data.map(Rc::new),
             default: self.default,
         });
 
@@ -478,7 +478,7 @@ pub struct CreateResourceService {
     fut: Vec<CreateRouteServiceItem>,
     data: Option<Rc<Extensions>>,
     default: Option<HttpService>,
-    default_fut: Option<Box<Future<Item = HttpService, Error = ()>>>,
+    default_fut: Option<Box<dyn Future<Item = HttpService, Error = ()>>>,
 }
 
 impl Future for CreateResourceService {
@@ -542,7 +542,7 @@ impl Service for ResourceService {
     type Error = Error;
     type Future = Either<
         FutureResult<ServiceResponse, Error>,
-        Box<Future<Item = ServiceResponse, Error = Error>>,
+        Box<dyn Future<Item = ServiceResponse, Error = Error>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {

src/responder.rs

@@ -137,6 +137,22 @@ impl Responder for () {
     }
 }
 
+impl<T> Responder for (T, StatusCode)
+where
+    T: Responder,
+{
+    type Error = T::Error;
+    type Future = CustomResponderFut<T>;
+
+    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+        CustomResponderFut {
+            fut: self.0.respond_to(req).into_future(),
+            status: Some(self.1),
+            headers: None,
+        }
+    }
+}
+
 impl Responder for &'static str {
     type Error = Error;
     type Future = FutureResult<Response, Error>;
@@ -321,7 +337,7 @@ impl<T: Responder> Future for CustomResponderFut<T> {
 /// use actix_web::{Either, Error, HttpResponse};
 ///
 /// type RegisterResult =
-///     Either<HttpResponse, Box<Future<Item = HttpResponse, Error = Error>>>;
+///     Either<HttpResponse, Box<dyn Future<Item = HttpResponse, Error = Error>>>;
 ///
 /// fn index() -> RegisterResult {
 ///     if is_a_variant() {
@@ -395,13 +411,13 @@ where
     }
 }
 
-impl<I, E> Responder for Box<Future<Item = I, Error = E>>
+impl<I, E> Responder for Box<dyn Future<Item = I, Error = E>>
 where
     I: Responder + 'static,
     E: Into<Error> + 'static,
 {
     type Error = Error;
-    type Future = Box<Future<Item = Response, Error = Error>>;
+    type Future = Box<dyn Future<Item = Response, Error = Error>>;
 
     #[inline]
     fn respond_to(self, req: &HttpRequest) -> Self::Future {
@@ -624,4 +640,28 @@ pub(crate) mod tests {
             HeaderValue::from_static("json")
         );
     }
+
+    #[test]
+    fn test_tuple_responder_with_status_code() {
+        let req = TestRequest::default().to_http_request();
+        let res =
+            block_on(("test".to_string(), StatusCode::BAD_REQUEST).respond_to(&req))
+                .unwrap();
+        assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+        assert_eq!(res.body().bin_ref(), b"test");
+
+        let req = TestRequest::default().to_http_request();
+        let res = block_on(
+            ("test".to_string(), StatusCode::OK)
+                .with_header("content-type", "json")
+                .respond_to(&req),
+        )
+        .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        assert_eq!(res.body().bin_ref(), b"test");
+        assert_eq!(
+            res.headers().get(CONTENT_TYPE).unwrap(),
+            HeaderValue::from_static("json")
+        );
+    }
 }

src/rmap.rs

@@ -123,7 +123,7 @@ impl ResourceMap {
         I: AsRef<str>,
     {
         if let Some(pattern) = self.named.get(name) {
-            if pattern.pattern().starts_with("/") {
+            if pattern.pattern().starts_with('/') {
                 self.fill_root(path, elements)?;
             }
             if pattern.resource_path(path, elements) {

src/route.rs

@@ -13,26 +13,26 @@ use crate::service::{ServiceRequest, ServiceResponse};
 use crate::HttpResponse;
 
 type BoxedRouteService<Req, Res> = Box<
-    Service<
+    dyn Service<
         Request = Req,
         Response = Res,
         Error = Error,
         Future = Either<
             FutureResult<Res, Error>,
-            Box<Future<Item = Res, Error = Error>>,
+            Box<dyn Future<Item = Res, Error = Error>>,
         >,
     >,
 >;
 
 type BoxedRouteNewService<Req, Res> = Box<
-    NewService<
+    dyn NewService<
         Config = (),
         Request = Req,
         Response = Res,
         Error = Error,
         InitError = (),
         Service = BoxedRouteService<Req, Res>,
-        Future = Box<Future<Item = BoxedRouteService<Req, Res>, Error = ()>>,
+        Future = Box<dyn Future<Item = BoxedRouteService<Req, Res>, Error = ()>>,
     >,
 >;
 
@@ -42,7 +42,7 @@ type BoxedRouteNewService<Req, Res> = Box<
 /// If handler is not explicitly set, default *404 Not Found* handler is used.
 pub struct Route {
     service: BoxedRouteNewService<ServiceRequest, ServiceResponse>,
-    guards: Rc<Vec<Box<Guard>>>,
+    guards: Rc<Vec<Box<dyn Guard>>>,
 }
 
 impl Route {
@@ -56,7 +56,7 @@ impl Route {
         }
     }
 
-    pub(crate) fn take_guards(&mut self) -> Vec<Box<Guard>> {
+    pub(crate) fn take_guards(&mut self) -> Vec<Box<dyn Guard>> {
         std::mem::replace(Rc::get_mut(&mut self.guards).unwrap(), Vec::new())
     }
 }
@@ -78,12 +78,13 @@ impl NewService for Route {
     }
 }
 
-type RouteFuture =
+type RouteFuture = Box<
-    Box<Future<Item = BoxedRouteService<ServiceRequest, ServiceResponse>, Error = ()>>;
+    dyn Future<Item = BoxedRouteService<ServiceRequest, ServiceResponse>, Error = ()>,
+>;
 
 pub struct CreateRouteService {
     fut: RouteFuture,
-    guards: Rc<Vec<Box<Guard>>>,
+    guards: Rc<Vec<Box<dyn Guard>>>,
 }
 
 impl Future for CreateRouteService {
@@ -103,7 +104,7 @@ impl Future for CreateRouteService {
 
 pub struct RouteService {
     service: BoxedRouteService<ServiceRequest, ServiceResponse>,
-    guards: Rc<Vec<Box<Guard>>>,
+    guards: Rc<Vec<Box<dyn Guard>>>,
 }
 
 impl RouteService {
@@ -123,7 +124,7 @@ impl Service for RouteService {
     type Error = Error;
     type Future = Either<
         FutureResult<Self::Response, Self::Error>,
-        Box<Future<Item = Self::Response, Error = Self::Error>>,
+        Box<dyn Future<Item = Self::Response, Error = Self::Error>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -317,7 +318,7 @@ where
     type Error = Error;
     type InitError = ();
     type Service = BoxedRouteService<ServiceRequest, Self::Response>;
-    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
 
     fn new_service(&self, _: &()) -> Self::Future {
         Box::new(
@@ -351,7 +352,7 @@ where
     type Error = Error;
     type Future = Either<
         FutureResult<Self::Response, Self::Error>,
-        Box<Future<Item = Self::Response, Error = Self::Error>>,
+        Box<dyn Future<Item = Self::Response, Error = Self::Error>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {

src/scope.rs

@@ -23,12 +23,12 @@ use crate::service::{
     ServiceFactory, ServiceFactoryWrapper, ServiceRequest, ServiceResponse,
 };
 
-type Guards = Vec<Box<Guard>>;
+type Guards = Vec<Box<dyn Guard>>;
 type HttpService = BoxedService<ServiceRequest, ServiceResponse, Error>;
 type HttpNewService = BoxedNewService<(), ServiceRequest, ServiceResponse, Error, ()>;
 type BoxedResponse = Either<
     FutureResult<ServiceResponse, Error>,
-    Box<Future<Item = ServiceResponse, Error = Error>>,
+    Box<dyn Future<Item = ServiceResponse, Error = Error>>,
 >;
 
 /// Resources scope.
@@ -64,8 +64,8 @@ pub struct Scope<T = ScopeEndpoint> {
     endpoint: T,
     rdef: String,
     data: Option<Extensions>,
-    services: Vec<Box<ServiceFactory>>,
+    services: Vec<Box<dyn ServiceFactory>>,
-    guards: Vec<Box<Guard>>,
+    guards: Vec<Box<dyn Guard>>,
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
     external: Vec<ResourceDef>,
     factory_ref: Rc<RefCell<Option<ScopeFactory>>>,
@@ -195,7 +195,7 @@ where
         self.external.extend(cfg.external);
 
         if !cfg.data.is_empty() {
-            let mut data = self.data.unwrap_or_else(|| Extensions::new());
+            let mut data = self.data.unwrap_or_else(Extensions::new);
 
             for value in cfg.data.iter() {
                 value.create(&mut data);
@@ -425,7 +425,7 @@ where
 
         // complete scope pipeline creation
         *self.factory_ref.borrow_mut() = Some(ScopeFactory {
-            data: self.data.take().map(|data| Rc::new(data)),
+            data: self.data.take().map(Rc::new),
             default: self.default.clone(),
             services: Rc::new(
                 cfg.into_services()
@@ -503,10 +503,10 @@ pub struct ScopeFactoryResponse {
     fut: Vec<CreateScopeServiceItem>,
     data: Option<Rc<Extensions>>,
     default: Option<HttpService>,
-    default_fut: Option<Box<Future<Item = HttpService, Error = ()>>>,
+    default_fut: Option<Box<dyn Future<Item = HttpService, Error = ()>>>,
 }
 
-type HttpServiceFut = Box<Future<Item = HttpService, Error = ()>>;
+type HttpServiceFut = Box<dyn Future<Item = HttpService, Error = ()>>;
 
 enum CreateScopeServiceItem {
     Future(Option<ResourceDef>, Option<Guards>, HttpServiceFut),
@@ -578,7 +578,7 @@ impl Future for ScopeFactoryResponse {
 
 pub struct ScopeService {
     data: Option<Rc<Extensions>>,
-    router: Router<HttpService, Vec<Box<Guard>>>,
+    router: Router<HttpService, Vec<Box<dyn Guard>>>,
     default: Option<HttpService>,
     _ready: Option<(ServiceRequest, ResourceInfo)>,
 }

src/server.rs

@@ -288,13 +288,13 @@ where
             lst,
             move || {
                 let c = cfg.lock();
-                acceptor.clone().map_err(|e| SslError::Ssl(e)).and_then(
+                acceptor.clone().map_err(SslError::Ssl).and_then(
                     HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_timeout(c.client_timeout)
                         .client_disconnect(c.client_shutdown)
                         .finish(factory())
-                        .map_err(|e| SslError::Service(e))
+                        .map_err(SslError::Service)
                         .map_init_err(|_| ()),
                 )
             },
@@ -339,13 +339,13 @@ where
             lst,
             move || {
                 let c = cfg.lock();
-                acceptor.clone().map_err(|e| SslError::Ssl(e)).and_then(
+                acceptor.clone().map_err(SslError::Ssl).and_then(
                     HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_timeout(c.client_timeout)
                         .client_disconnect(c.client_shutdown)
                         .finish(factory())
-                        .map_err(|e| SslError::Service(e))
+                        .map_err(SslError::Service)
                         .map_init_err(|_| ()),
                 )
             },

src/service.rs

@@ -18,6 +18,7 @@ use crate::dev::insert_slash;
 use crate::guard::Guard;
 use crate::info::ConnectionInfo;
 use crate::request::HttpRequest;
+use crate::rmap::ResourceMap;
 
 pub trait HttpServiceFactory {
     fn register(self, config: &mut AppService);
@@ -169,10 +170,17 @@ impl ServiceRequest {
     }
 
     #[inline]
+    /// Get a mutable reference to the Path parameters.
     pub fn match_info_mut(&mut self) -> &mut Path<Url> {
         self.0.match_info_mut()
     }
 
+    #[inline]
+    /// Get a reference to a `ResourceMap` of current application.
+    pub fn resource_map(&self) -> &ResourceMap {
+        self.0.resource_map()
+    }
+
     /// Service configuration
     #[inline]
     pub fn app_config(&self) -> &AppConfig {
@@ -399,7 +407,7 @@ impl<B: MessageBody> fmt::Debug for ServiceResponse<B> {
 pub struct WebService {
     rdef: String,
     name: Option<String>,
-    guards: Vec<Box<Guard>>,
+    guards: Vec<Box<dyn Guard>>,
 }
 
 impl WebService {
@@ -468,7 +476,7 @@ struct WebServiceImpl<T> {
     srv: T,
     rdef: String,
     name: Option<String>,
-    guards: Vec<Box<Guard>>,
+    guards: Vec<Box<dyn Guard>>,
 }
 
 impl<T> HttpServiceFactory for WebServiceImpl<T>

src/test.rs

@@ -64,7 +64,7 @@ where
     RT.with(move |rt| rt.borrow_mut().get_mut().block_on(f.into_future()))
 }
 
-/// Runs the provided function, blocking the current thread until the resul
+/// Runs the provided function, blocking the current thread until the result
 /// future completes.
 ///
 /// This function can be used to synchronously block the current thread
@@ -79,7 +79,7 @@ where
     F: FnOnce() -> R,
     R: IntoFuture,
 {
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(|| f())))
+    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(f)))
 }
 
 #[doc(hidden)]

src/types/form.rs

@@ -73,7 +73,7 @@ where
 {
     type Config = FormConfig;
     type Error = Error;
-    type Future = Box<Future<Item = Self, Error = Error>>;
+    type Future = Box<dyn Future<Item = Self, Error = Error>>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
@@ -141,7 +141,7 @@ impl<T: fmt::Display> fmt::Display for Form<T> {
 #[derive(Clone)]
 pub struct FormConfig {
     limit: usize,
-    ehandler: Option<Rc<Fn(UrlencodedError, &HttpRequest) -> Error>>,
+    ehandler: Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) -> Error>>,
 }
 
 impl FormConfig {
@@ -187,7 +187,7 @@ pub struct UrlEncoded<U> {
     length: Option<usize>,
     encoding: &'static Encoding,
     err: Option<UrlencodedError>,
-    fut: Option<Box<Future<Item = U, Error = UrlencodedError>>>,
+    fut: Option<Box<dyn Future<Item = U, Error = UrlencodedError>>>,
 }
 
 impl<U> UrlEncoded<U> {

src/types/json.rs

@@ -169,7 +169,7 @@ where
     T: DeserializeOwned + 'static,
 {
     type Error = Error;
-    type Future = Box<Future<Item = Self, Error = Error>>;
+    type Future = Box<dyn Future<Item = Self, Error = Error>>;
     type Config = JsonConfig;
 
     #[inline]
@@ -290,7 +290,7 @@ pub struct JsonBody<U> {
     length: Option<usize>,
     stream: Option<Decompress<Payload>>,
     err: Option<JsonPayloadError>,
-    fut: Option<Box<Future<Item = U, Error = JsonPayloadError>>>,
+    fut: Option<Box<dyn Future<Item = U, Error = JsonPayloadError>>>,
 }
 
 impl<U> JsonBody<U>

src/types/path.rs

@@ -224,7 +224,7 @@ where
 /// ```
 #[derive(Clone)]
 pub struct PathConfig {
-    ehandler: Option<Arc<Fn(PathError, &HttpRequest) -> Error + Send + Sync>>,
+    ehandler: Option<Arc<dyn Fn(PathError, &HttpRequest) -> Error + Send + Sync>>,
 }
 
 impl PathConfig {

src/types/payload.rs

@@ -124,11 +124,11 @@ impl FromRequest for Bytes {
     type Config = PayloadConfig;
     type Error = Error;
     type Future =
-        Either<Box<Future<Item = Bytes, Error = Error>>, FutureResult<Bytes, Error>>;
+        Either<Box<dyn Future<Item = Bytes, Error = Error>>, FutureResult<Bytes, Error>>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
-        let mut tmp;
+        let tmp;
         let cfg = if let Some(cfg) = req.app_data::<PayloadConfig>() {
             cfg
         } else {
@@ -177,12 +177,14 @@ impl FromRequest for Bytes {
 impl FromRequest for String {
     type Config = PayloadConfig;
     type Error = Error;
-    type Future =
+    type Future = Either<
-        Either<Box<Future<Item = String, Error = Error>>, FutureResult<String, Error>>;
+        Box<dyn Future<Item = String, Error = Error>>,
+        FutureResult<String, Error>,
+    >;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
-        let mut tmp;
+        let tmp;
         let cfg = if let Some(cfg) = req.app_data::<PayloadConfig>() {
             cfg
         } else {
@@ -291,7 +293,7 @@ pub struct HttpMessageBody {
     length: Option<usize>,
     stream: Option<dev::Decompress<dev::Payload>>,
     err: Option<PayloadError>,
-    fut: Option<Box<Future<Item = Bytes, Error = PayloadError>>>,
+    fut: Option<Box<dyn Future<Item = Bytes, Error = PayloadError>>>,
 }
 
 impl HttpMessageBody {

src/types/query.rs

@@ -13,7 +13,7 @@ use crate::extract::FromRequest;
 use crate::request::HttpRequest;
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
-/// Extract typed information from from the request's query.
+/// Extract typed information from the request's query.
 ///
 /// ## Example
 ///
@@ -90,7 +90,7 @@ impl<T: fmt::Display> fmt::Display for Query<T> {
     }
 }
 
-/// Extract typed information from from the request's query.
+/// Extract typed information from the request's query.
 ///
 /// ## Example
 ///
@@ -192,7 +192,8 @@ where
 /// ```
 #[derive(Clone)]
 pub struct QueryConfig {
-    ehandler: Option<Arc<Fn(QueryPayloadError, &HttpRequest) -> Error + Send + Sync>>,
+    ehandler:
+        Option<Arc<dyn Fn(QueryPayloadError, &HttpRequest) -> Error + Send + Sync>>,
 }
 
 impl QueryConfig {

test-server/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.2.3] - 2019-07-16
+
+* Add `delete`, `options`, `patch` methods to `TestServerRunner`
+
 ## [0.2.2] - 2019-06-16
 
 * Add .put() and .sput() methods

test-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "0.2.2"
+version = "0.2.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http test server"
 readme = "README.md"
@@ -35,7 +35,7 @@ actix-rt = "0.2.2"
 actix-service = "0.4.1"
 actix-server = "0.5.1"
 actix-utils = "0.4.1"
-awc = "0.2.1"
+awc = "0.2.2"
 
 base64 = "0.10"
 bytes = "0.4"

test-server/src/lib.rs

@@ -65,7 +65,7 @@ where
     F: FnOnce() -> R,
     R: IntoFuture,
 {
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(|| f())))
+    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(f)))
 }
 
 /// The `TestServer` type.
@@ -107,6 +107,7 @@ pub struct TestServerRuntime {
 }
 
 impl TestServer {
+    #[allow(clippy::new_ret_no_self)]
     /// Start new test server with application factory
     pub fn new<F: StreamServiceFactory>(factory: F) -> TestServerRuntime {
         let (tx, rx) = mpsc::channel();
@@ -191,7 +192,7 @@ impl TestServerRuntime {
         F: FnOnce() -> R,
         R: Future,
     {
-        self.rt.block_on(lazy(|| f()))
+        self.rt.block_on(lazy(f))
     }
 
     /// Execute function on current core
@@ -265,6 +266,36 @@ impl TestServerRuntime {
         self.client.put(self.surl(path.as_ref()).as_str())
     }
 
+    /// Create `PATCH` request
+    pub fn patch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.patch(self.url(path.as_ref()).as_str())
+    }
+
+    /// Create https `PATCH` request
+    pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.patch(self.surl(path.as_ref()).as_str())
+    }
+
+    /// Create `DELETE` request
+    pub fn delete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.delete(self.url(path.as_ref()).as_str())
+    }
+
+    /// Create https `DELETE` request
+    pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.delete(self.surl(path.as_ref()).as_str())
+    }
+
+    /// Create `OPTIONS` request
+    pub fn options<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.options(self.url(path.as_ref()).as_str())
+    }
+
+    /// Create https `OPTIONS` request
+    pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.options(self.surl(path.as_ref()).as_str())
+    }
+
     /// Connect to test http server
     pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
         self.client.request(method, path.as_ref())