prepare release

This allows to verify time of login or last visit and therfore limiting
the danger of leaked cookies.

CHANGES.md

@@ -1,6 +1,25 @@
 # Changes
 
-## [1.0.0-beta.1] - 2019-04-xx
+### Added
+
+* Extend `Responder` trait, allow to override status code and headers.
+
+* Add helper functions for reading response body `test::read_body()`
+
+* Added support for `remainder match` (i.e "/path/{tail}*")
+
+
+### Changed
+
+* `.to_async()` handler can return `Responder` type #792
+
+
+### Fixed
+
+* Fix async web::Data factory handling
+
+
+## [1.0.0-beta.1] - 2019-04-20
 
 ### Added
 
@@ -9,12 +28,18 @@
 
 * Add `.peer_addr()` #744
 
+* Add `NormalizePath` middleware
+
 ### Changed
 
 * Rename `RouterConfig` to `ServiceConfig`
 
 * Rename `test::call_success` to `test::call_service`
 
+* Removed `ServiceRequest::from_parts()` as it is unsafe to create from parts.
+
+* `CookieIdentityPolicy::max_age()` accepts value in seconds
+
 ### Fixed
 
 * Fixed `TestRequest::app_data()`

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "1.0.0-alpha.6"
+version = "1.0.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@@ -15,6 +15,9 @@ license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 
+[package.metadata.docs.rs]
+features = ["ssl", "brotli", "flate2-zlib", "secure-cookies", "client", "rust-tls"]
+
 [badges]
 travis-ci = { repository = "actix/actix-web", branch = "master" }
 codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
@@ -37,9 +40,6 @@ members = [
   "test-server",
 ]
 
-[package.metadata.docs.rs]
-features = ["ssl", "brotli", "flate2-zlib", "secure-cookies", "client", "rust-tls"]
-
 [features]
 default = ["brotli", "flate2-zlib", "secure-cookies", "client"]
 
@@ -68,14 +68,14 @@ rust-tls = ["rustls", "actix-server/rust-tls"]
 actix-codec = "0.1.2"
 actix-service = "0.3.6"
 actix-utils = "0.3.4"
-actix-router = "0.1.2"
+actix-router = "0.1.3"
 actix-rt = "0.2.2"
-actix-web-codegen = "0.1.0-alpha.6"
-actix-http = { version = "0.1.0-alpha.5", features=["fail"] }
+actix-web-codegen = "0.1.0-beta.1"
+actix-http = { version = "0.1.2", features=["fail"] }
 actix-server = "0.4.3"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"
-awc = { version = "0.1.0-alpha.6", optional = true }
+awc = { version = "0.1.1", optional = true }
 
 bytes = "0.4"
 derive_more = "0.14"
@@ -90,7 +90,7 @@ regex = "1.0"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.5.3"
-time = "0.1"
+time = "0.1.42"
 url = { version="1.7", features=["query_encoding"] }
 
 # ssl support
@@ -98,9 +98,9 @@ openssl = { version="0.10", optional = true }
 rustls = { version = "^0.15", optional = true }
 
 [dev-dependencies]
-actix-http = { version = "0.1.0-alpha.5", features=["ssl", "brotli", "flate2-zlib"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
-actix-files = { version = "0.1.0-alpha.6" }
+actix-http = { version = "0.1.2", features=["ssl", "brotli", "flate2-zlib"] }
+actix-http-test = { version = "0.1.1", features=["ssl"] }
+actix-files = { version = "0.1.0-beta.1" }
 rand = "0.6"
 env_logger = "0.6"
 serde_derive = "1.0"

MIGRATION.md

@@ -128,7 +128,7 @@
   ```
 
 
-* AsyncResponder is removed.
+* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
 
   instead of
 

actix-files/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.0-beta.1] - 2019-04-20
+
+* Update actix-web to beta.1
+
 ## [0.1.0-alpha.6] - 2019-04-14
 
 * Update actix-web to alpha6

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.1.0-alpha.6"
+version = "0.1.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@@ -18,7 +18,7 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = "1.0.0-alpha.6"
+actix-web = "1.0.0-beta.1"
 actix-service = "0.3.4"
 bitflags = "1"
 bytes = "0.4"
@@ -31,4 +31,4 @@ percent-encoding = "1.0"
 v_htmlescape = "0.4"
 
 [dev-dependencies]
-actix-web = { version = "1.0.0-alpha.6", features=["ssl"] }
+actix-web = { version = "1.0.0-beta.1", features=["ssl"] }

actix-files/src/lib.rs

@@ -411,17 +411,16 @@ impl FilesService {
     fn handle_err(
         &mut self,
         e: io::Error,
-        req: HttpRequest,
-        payload: Payload,
+        req: ServiceRequest,
     ) -> Either<
         FutureResult<ServiceResponse, Error>,
         Box<Future<Item = ServiceResponse, Error = Error>>,
     > {
         log::debug!("Files: Failed to handle {}: {}", req.path(), e);
         if let Some(ref mut default) = self.default {
-            default.call(ServiceRequest::from_parts(req, payload))
+            default.call(req)
         } else {
-            Either::A(ok(ServiceResponse::from_err(e, req.clone())))
+            Either::A(ok(req.error_response(e)))
         }
     }
 }
@@ -440,17 +439,17 @@ impl Service for FilesService {
     }
 
     fn call(&mut self, req: ServiceRequest) -> Self::Future {
-        let (req, pl) = req.into_parts();
+        // let (req, pl) = req.into_parts();
 
         let real_path = match PathBufWrp::get_pathbuf(req.match_info().path()) {
             Ok(item) => item,
-            Err(e) => return Either::A(ok(ServiceResponse::from_err(e, req.clone()))),
+            Err(e) => return Either::A(ok(req.error_response(e))),
         };
 
         // full filepath
         let path = match self.directory.join(&real_path.0).canonicalize() {
             Ok(path) => path,
-            Err(e) => return self.handle_err(e, req, pl),
+            Err(e) => return self.handle_err(e, req),
         };
 
         if path.is_dir() {
@@ -466,24 +465,26 @@ impl Service for FilesService {
                         }
 
                         named_file.flags = self.file_flags;
+                        let (req, _) = req.into_parts();
                         Either::A(ok(match named_file.respond_to(&req) {
-                            Ok(item) => ServiceResponse::new(req.clone(), item),
-                            Err(e) => ServiceResponse::from_err(e, req.clone()),
+                            Ok(item) => ServiceResponse::new(req, item),
+                            Err(e) => ServiceResponse::from_err(e, req),
                         }))
                     }
-                    Err(e) => return self.handle_err(e, req, pl),
+                    Err(e) => return self.handle_err(e, req),
                 }
             } else if self.show_index {
                 let dir = Directory::new(self.directory.clone(), path);
+                let (req, _) = req.into_parts();
                 let x = (self.renderer)(&dir, &req);
                 match x {
                     Ok(resp) => Either::A(ok(resp)),
-                    Err(e) => return self.handle_err(e, req, pl),
+                    Err(e) => return Either::A(ok(ServiceResponse::from_err(e, req))),
                 }
             } else {
                 Either::A(ok(ServiceResponse::from_err(
                     FilesError::IsDirectory,
-                    req.clone(),
+                    req.into_parts().0,
                 )))
             }
         } else {
@@ -496,16 +497,15 @@ impl Service for FilesService {
                     }
 
                     named_file.flags = self.file_flags;
+                    let (req, _) = req.into_parts();
                     match named_file.respond_to(&req) {
                         Ok(item) => {
                             Either::A(ok(ServiceResponse::new(req.clone(), item)))
                         }
-                        Err(e) => {
-                            Either::A(ok(ServiceResponse::from_err(e, req.clone())))
-                        }
+                        Err(e) => Either::A(ok(ServiceResponse::from_err(e, req))),
                     }
                 }
-                Err(e) => self.handle_err(e, req, pl),
+                Err(e) => self.handle_err(e, req),
             }
         }
     }

actix-framed/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-framed"
-version = "0.1.0-alpha.1"
+version = "0.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix framed app server"
 readme = "README.md"
@@ -25,13 +25,13 @@ actix-service = "0.3.6"
 actix-utils = "0.3.4"
 actix-router = "0.1.2"
 actix-rt = "0.2.2"
-actix-http = "0.1.0-alpha.5"
+actix-http = "0.1.0"
 
 bytes = "0.4"
 futures = "0.1.25"
 log = "0.4"
 
 [dev-dependencies]
-actix-server = { version = "0.4.1", features=["ssl"] }
+actix-server = { version = "0.4.3", features=["ssl"] }
 actix-connect = { version = "0.1.4", features=["ssl"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-http-test = { version = "0.1.0", features=["ssl"] }

actix-framed/changes.md

@@ -1,5 +1,10 @@
 # Changes
 
+## [0.1.0] - 2019-04-16
+
+* Update tests
+
+
 ## [0.1.0-alpha.1] - 2019-04-12
 
 * Initial release

actix-framed/tests/test_server.rs

@@ -1,5 +1,5 @@
 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::{body, ws, Error, HttpService, Response};
+use actix_http::{body, http::StatusCode, ws, Error, HttpService, Response};
 use actix_http_test::TestServer;
 use actix_service::{IntoNewService, NewService};
 use actix_utils::framed::FramedTransport;
@@ -99,6 +99,11 @@ fn test_service() {
         )
     });
 
+    // non ws request
+    let res = srv.block_on(srv.get("/index.html").send()).unwrap();
+    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+
+    // not found
     assert!(srv.ws_at("/test").is_err());
 
     // client service

actix-http/CHANGES.md

@@ -1,5 +1,43 @@
 # Changes
 
+## [0.1.4] - 2019-04-24
+
+### Added
+
+* Allow to render h1 request headers in `Camel-Case`
+
+### Fixed
+
+* Read until eof for http/1.0 responses #771
+
+
+## [0.1.3] - 2019-04-23
+
+### Fixed
+
+* Fix http client pool management
+
+* Fix http client wait queue management #794
+
+
+## [0.1.2] - 2019-04-23
+
+### Fixed
+
+* Fix BorrowMutError panic in client connector #793
+
+
+## [0.1.1] - 2019-04-19
+
+### Changes
+
+* Cookie::max_age() accepts value in seconds
+
+* Cookie::max_age_time() accepts value in time::Duration
+
+* Allow to specify server address for client connector
+
+
 ## [0.1.0] - 2019-04-16
 
 ### Added

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "0.1.0"
+version = "0.1.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@@ -46,7 +46,7 @@ secure-cookies = ["ring"]
 [dependencies]
 actix-service = "0.3.6"
 actix-codec = "0.1.2"
-actix-connect = "0.1.4"
+actix-connect = "0.1.5"
 actix-utils = "0.3.5"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"
@@ -77,7 +77,7 @@ serde_json = "1.0"
 sha1 = "0.6"
 slab = "0.4"
 serde_urlencoded = "0.5.5"
-time = "0.1"
+time = "0.1.42"
 tokio-tcp = "0.1.3"
 tokio-timer = "0.2.8"
 tokio-current-thread = "0.1"
@@ -93,12 +93,13 @@ flate2 = { version="1.0.7", optional = true, default-features = false }
 # optional deps
 failure = { version = "0.1.5", optional = true }
 openssl = { version="0.10", optional = true }
+chrono = "0.4.6"
 
 [dev-dependencies]
 actix-rt = "0.2.2"
 actix-server = { version = "0.4.3", features=["ssl"] }
 actix-connect = { version = "0.1.4", features=["ssl"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-http-test = { version = "0.1.0", features=["ssl"] }
 env_logger = "0.6"
 serde_derive = "1.0"
 openssl = { version="0.10" }

actix-http/src/client/connector.rs

@@ -14,6 +14,7 @@ use tokio_tcp::TcpStream;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
+use super::Connect;
 
 #[cfg(feature = "ssl")]
 use openssl::ssl::SslConnector;
@@ -113,7 +114,8 @@ where
             Request = TcpConnect<Uri>,
             Response = TcpConnection<Uri, U>,
             Error = actix_connect::ConnectError,
-        > + Clone,
+        > + Clone
+        + 'static,
 {
     /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
     /// Set to 1 second by default.
@@ -177,15 +179,17 @@ where
     /// its combinator chain.
     pub fn finish(
         self,
-    ) -> impl Service<Request = Uri, Response = impl Connection, Error = ConnectError> + Clone
-    {
+    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
+                 + Clone {
         #[cfg(not(feature = "ssl"))]
         {
             let connector = TimeoutService::new(
                 self.timeout,
-                apply_fn(self.connector, |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+                apply_fn(self.connector, |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
             )
             .map_err(|e| match e {
                 TimeoutError::Service(e) => e,
@@ -209,26 +213,28 @@ where
 
             let ssl_service = TimeoutService::new(
                 self.timeout,
-                apply_fn(self.connector.clone(), |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .and_then(
-                        OpensslConnector::service(self.ssl)
-                            .map_err(ConnectError::from)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .get_ref()
-                                    .ssl()
-                                    .selected_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (sock, Protocol::Http2)
-                                } else {
-                                    (sock, Protocol::Http1)
-                                }
-                            }),
-                    ),
+                apply_fn(self.connector.clone(), |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .and_then(
+                    OpensslConnector::service(self.ssl)
+                        .map_err(ConnectError::from)
+                        .map(|stream| {
+                            let sock = stream.into_parts().0;
+                            let h2 = sock
+                                .get_ref()
+                                .ssl()
+                                .selected_alpn_protocol()
+                                .map(|protos| protos.windows(2).any(|w| w == H2))
+                                .unwrap_or(false);
+                            if h2 {
+                                (sock, Protocol::Http2)
+                            } else {
+                                (sock, Protocol::Http1)
+                            }
+                        }),
+                ),
             )
             .map_err(|e| match e {
                 TimeoutError::Service(e) => e,
@@ -237,9 +243,11 @@ where
 
             let tcp_service = TimeoutService::new(
                 self.timeout,
-                apply_fn(self.connector.clone(), |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+                apply_fn(self.connector.clone(), |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
             )
             .map_err(|e| match e {
                 TimeoutError::Service(e) => e,
@@ -264,15 +272,6 @@ where
             }
         }
     }
-
-    #[doc(hidden)]
-    #[deprecated(since = "0.1.0-alpha4", note = "please use `.finish()` method")]
-    pub fn service(
-        self,
-    ) -> impl Service<Request = Uri, Response = impl Connection, Error = ConnectError> + Clone
-    {
-        self.finish()
-    }
 }
 
 #[cfg(not(feature = "ssl"))]
@@ -286,7 +285,9 @@ mod connect_impl {
     pub(crate) struct InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
         pub(crate) tcp_pool: ConnectionPool<T, Io>,
     }
@@ -294,8 +295,9 @@ mod connect_impl {
     impl<T, Io> Clone for InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>
-            + Clone,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
         fn clone(&self) -> Self {
             InnerConnector {
@@ -307,9 +309,11 @@ mod connect_impl {
     impl<T, Io> Service for InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
-        type Request = Uri;
+        type Request = Connect;
         type Response = IoConnection<Io>;
         type Error = ConnectError;
         type Future = Either<
@@ -321,8 +325,8 @@ mod connect_impl {
             self.tcp_pool.poll_ready()
         }
 
-        fn call(&mut self, req: Uri) -> Self::Future {
-            match req.scheme_str() {
+        fn call(&mut self, req: Connect) -> Self::Future {
+            match req.uri.scheme_str() {
                 Some("https") | Some("wss") => {
                     Either::B(err(ConnectError::SslIsNotSupported))
                 }
@@ -346,8 +350,8 @@ mod connect_impl {
     where
         Io1: AsyncRead + AsyncWrite + 'static,
         Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>,
     {
         pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
         pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
@@ -357,10 +361,12 @@ mod connect_impl {
     where
         Io1: AsyncRead + AsyncWrite + 'static,
         Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
         fn clone(&self) -> Self {
             InnerConnector {
@@ -374,10 +380,14 @@ mod connect_impl {
     where
         Io1: AsyncRead + AsyncWrite + 'static,
         Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
-        type Request = Uri;
+        type Request = Connect;
         type Response = EitherConnection<Io1, Io2>;
         type Error = ConnectError;
         type Future = Either<
@@ -392,8 +402,8 @@ mod connect_impl {
             self.tcp_pool.poll_ready()
         }
 
-        fn call(&mut self, req: Uri) -> Self::Future {
-            match req.scheme_str() {
+        fn call(&mut self, req: Connect) -> Self::Future {
+            match req.uri.scheme_str() {
                 Some("https") | Some("wss") => {
                     Either::B(Either::B(InnerConnectorResponseB {
                         fut: self.ssl_pool.call(req),
@@ -411,7 +421,9 @@ mod connect_impl {
     pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
     where
         Io1: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
         fut: <ConnectionPool<T, Io1> as Service>::Future,
         _t: PhantomData<Io2>,
@@ -419,7 +431,9 @@ mod connect_impl {
 
     impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
     where
-        T: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
         Io1: AsyncRead + AsyncWrite + 'static,
         Io2: AsyncRead + AsyncWrite + 'static,
     {
@@ -437,7 +451,9 @@ mod connect_impl {
     pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
     where
         Io2: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
     {
         fut: <ConnectionPool<T, Io2> as Service>::Future,
         _t: PhantomData<Io1>,
@@ -445,7 +461,9 @@ mod connect_impl {
 
     impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
     where
-        T: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
         Io1: AsyncRead + AsyncWrite + 'static,
         Io2: AsyncRead + AsyncWrite + 'static,
     {

actix-http/src/client/h1proto.rs

@@ -274,7 +274,7 @@ impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
                     Ok(Async::Ready(Some(chunk)))
                 } else {
                     let framed = self.framed.take().unwrap();
-                    let force_close = framed.get_codec().keepalive();
+                    let force_close = !framed.get_codec().keepalive();
                     release_connection(framed, force_close);
                     Ok(Async::Ready(None))
                 }

actix-http/src/client/mod.rs

@@ -1,4 +1,6 @@
 //! Http client api
+use http::Uri;
+
 mod connection;
 mod connector;
 mod error;
@@ -10,3 +12,9 @@ pub use self::connection::Connection;
 pub use self::connector::Connector;
 pub use self::error::{ConnectError, InvalidUrl, SendRequestError};
 pub use self::pool::Protocol;
+
+#[derive(Clone)]
+pub struct Connect {
+    pub uri: Uri,
+    pub addr: Option<std::net::SocketAddr>,
+}

actix-http/src/client/pool.rs

@@ -13,13 +13,14 @@ use futures::unsync::oneshot;
 use futures::{Async, Future, Poll};
 use h2::client::{handshake, Handshake};
 use hashbrown::HashMap;
-use http::uri::{Authority, Uri};
+use http::uri::Authority;
 use indexmap::IndexSet;
 use slab::Slab;
 use tokio_timer::{sleep, Delay};
 
 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
+use super::Connect;
 
 #[derive(Clone, Copy, PartialEq)]
 /// Protocol version
@@ -48,7 +49,9 @@ pub(crate) struct ConnectionPool<T, Io: AsyncRead + AsyncWrite + 'static>(
 impl<T, Io> ConnectionPool<T, Io>
 where
     Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+        + Clone
+        + 'static,
 {
     pub(crate) fn new(
         connector: T,
@@ -68,7 +71,7 @@ where
                 waiters: Slab::new(),
                 waiters_queue: IndexSet::new(),
                 available: HashMap::new(),
-                task: AtomicTask::new(),
+                task: None,
             })),
         )
     }
@@ -87,9 +90,11 @@ where
 impl<T, Io> Service for ConnectionPool<T, Io>
 where
     Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+        + Clone
+        + 'static,
 {
-    type Request = Uri;
+    type Request = Connect;
     type Response = IoConnection<Io>;
     type Error = ConnectError;
     type Future = Either<
@@ -101,8 +106,8 @@ where
         self.0.poll_ready()
     }
 
-    fn call(&mut self, req: Uri) -> Self::Future {
-        let key = if let Some(authority) = req.authority_part() {
+    fn call(&mut self, req: Connect) -> Self::Future {
+        let key = if let Some(authority) = req.uri.authority_part() {
             authority.clone().into()
         } else {
             return Either::A(err(ConnectError::Unresolverd));
@@ -112,31 +117,41 @@ where
         match self.1.as_ref().borrow_mut().acquire(&key) {
             Acquire::Acquired(io, created) => {
                 // use existing connection
-                Either::A(ok(IoConnection::new(
+                return Either::A(ok(IoConnection::new(
                     io,
                     created,
                     Some(Acquired(key, Some(self.1.clone()))),
-                )))
-            }
-            Acquire::NotAvailable => {
-                // connection is not available, wait
-                let (rx, token) = self.1.as_ref().borrow_mut().wait_for(req);
-                Either::B(Either::A(WaitForConnection {
-                    rx,
-                    key,
-                    token,
-                    inner: Some(self.1.clone()),
-                }))
+                )));
             }
             Acquire::Available => {
                 // open new connection
-                Either::B(Either::B(OpenConnection::new(
+                return Either::B(Either::B(OpenConnection::new(
                     key,
                     self.1.clone(),
                     self.0.call(req),
-                )))
+                )));
             }
+            _ => (),
         }
+
+        // connection is not available, wait
+        let (rx, token, support) = self.1.as_ref().borrow_mut().wait_for(req);
+
+        // start support future
+        if !support {
+            self.1.as_ref().borrow_mut().task = Some(AtomicTask::new());
+            tokio_current_thread::spawn(ConnectorPoolSupport {
+                connector: self.0.clone(),
+                inner: self.1.clone(),
+            })
+        }
+
+        Either::B(Either::A(WaitForConnection {
+            rx,
+            key,
+            token,
+            inner: Some(self.1.clone()),
+        }))
     }
 }
 
@@ -244,7 +259,7 @@ where
                     Ok(Async::Ready(IoConnection::new(
                         ConnectionType::H2(snd),
                         Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.clone())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                     )))
                 }
                 Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -255,12 +270,11 @@ where
         match self.fut.poll() {
             Err(err) => Err(err),
             Ok(Async::Ready((io, proto))) => {
-                let _ = self.inner.take();
                 if proto == Protocol::Http1 {
                     Ok(Async::Ready(IoConnection::new(
                         ConnectionType::H1(io),
                         Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.clone())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                     )))
                 } else {
                     self.h2 = Some(handshake(io));
@@ -278,7 +292,6 @@ enum Acquire<T> {
     NotAvailable,
 }
 
-// #[derive(Debug)]
 struct AvailableConnection<Io> {
     io: ConnectionType<Io>,
     used: Instant,
@@ -292,9 +305,12 @@ pub(crate) struct Inner<Io> {
     limit: usize,
     acquired: usize,
     available: HashMap<Key, VecDeque<AvailableConnection<Io>>>,
-    waiters: Slab<(Uri, oneshot::Sender<Result<IoConnection<Io>, ConnectError>>)>,
+    waiters: Slab<(
+        Connect,
+        oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
+    )>,
     waiters_queue: IndexSet<(Key, usize)>,
-    task: AtomicTask,
+    task: Option<AtomicTask>,
 }
 
 impl<Io> Inner<Io> {
@@ -310,18 +326,6 @@ impl<Io> Inner<Io> {
         self.waiters.remove(token);
         self.waiters_queue.remove(&(key.clone(), token));
     }
-
-    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
-        self.acquired -= 1;
-        self.available
-            .entry(key.clone())
-            .or_insert_with(VecDeque::new)
-            .push_back(AvailableConnection {
-                io,
-                created,
-                used: Instant::now(),
-            });
-    }
 }
 
 impl<Io> Inner<Io>
@@ -331,19 +335,21 @@ where
     /// connection is not available, wait
     fn wait_for(
         &mut self,
-        connect: Uri,
+        connect: Connect,
     ) -> (
         oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
         usize,
+        bool,
     ) {
         let (tx, rx) = oneshot::channel();
 
-        let key: Key = connect.authority_part().unwrap().clone().into();
+        let key: Key = connect.uri.authority_part().unwrap().clone().into();
         let entry = self.waiters.vacant_entry();
         let token = entry.key();
         entry.insert((connect, tx));
-        assert!(!self.waiters_queue.insert((key, token)));
-        (rx, token)
+        assert!(self.waiters_queue.insert((key, token)));
+
+        (rx, token, self.task.is_some())
     }
 
     fn acquire(&mut self, key: &Key) -> Acquire<Io> {
@@ -396,6 +402,19 @@ where
         Acquire::Available
     }
 
+    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
+        self.acquired -= 1;
+        self.available
+            .entry(key.clone())
+            .or_insert_with(VecDeque::new)
+            .push_back(AvailableConnection {
+                io,
+                created,
+                used: Instant::now(),
+            });
+        self.check_availibility();
+    }
+
     fn release_close(&mut self, io: ConnectionType<Io>) {
         self.acquired -= 1;
         if let Some(timeout) = self.disconnect_timeout {
@@ -403,11 +422,12 @@ where
                 tokio_current_thread::spawn(CloseConnection::new(io, timeout))
             }
         }
+        self.check_availibility();
     }
 
     fn check_availibility(&self) {
         if !self.waiters_queue.is_empty() && self.acquired < self.limit {
-            self.task.notify()
+            self.task.as_ref().map(|t| t.notify());
         }
     }
 }
@@ -447,6 +467,147 @@ where
     }
 }
 
+struct ConnectorPoolSupport<T, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    connector: T,
+    inner: Rc<RefCell<Inner<Io>>>,
+}
+
+impl<T, Io> Future for ConnectorPoolSupport<T, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
+    T::Future: 'static,
+{
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let mut inner = self.inner.as_ref().borrow_mut();
+        inner.task.as_ref().unwrap().register();
+
+        // check waiters
+        loop {
+            let (key, token) = {
+                if let Some((key, token)) = inner.waiters_queue.get_index(0) {
+                    (key.clone(), *token)
+                } else {
+                    break;
+                }
+            };
+            match inner.acquire(&key) {
+                Acquire::NotAvailable => break,
+                Acquire::Acquired(io, created) => {
+                    let (_, tx) = inner.waiters.remove(token);
+                    if let Err(conn) = tx.send(Ok(IoConnection::new(
+                        io,
+                        created,
+                        Some(Acquired(key.clone(), Some(self.inner.clone()))),
+                    ))) {
+                        let (io, created) = conn.unwrap().into_inner();
+                        inner.release_conn(&key, io, created);
+                    }
+                }
+                Acquire::Available => {
+                    let (connect, tx) = inner.waiters.remove(token);
+                    OpenWaitingConnection::spawn(
+                        key.clone(),
+                        tx,
+                        self.inner.clone(),
+                        self.connector.call(connect),
+                    );
+                }
+            }
+            let _ = inner.waiters_queue.swap_remove_index(0);
+        }
+
+        Ok(Async::NotReady)
+    }
+}
+
+struct OpenWaitingConnection<F, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fut: F,
+    key: Key,
+    h2: Option<Handshake<Io, Bytes>>,
+    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
+    inner: Option<Rc<RefCell<Inner<Io>>>>,
+}
+
+impl<F, Io> OpenWaitingConnection<F, Io>
+where
+    F: Future<Item = (Io, Protocol), Error = ConnectError> + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fn spawn(
+        key: Key,
+        rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
+        inner: Rc<RefCell<Inner<Io>>>,
+        fut: F,
+    ) {
+        tokio_current_thread::spawn(OpenWaitingConnection {
+            key,
+            fut,
+            h2: None,
+            rx: Some(rx),
+            inner: Some(inner),
+        })
+    }
+}
+
+impl<F, Io> Drop for OpenWaitingConnection<F, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
+            let mut inner = inner.as_ref().borrow_mut();
+            inner.release();
+            inner.check_availibility();
+        }
+    }
+}
+
+impl<F, Io> Future for OpenWaitingConnection<F, Io>
+where
+    F: Future<Item = (Io, Protocol), Error = ConnectError>,
+    Io: AsyncRead + AsyncWrite,
+{
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll() {
+            Err(err) => {
+                let _ = self.inner.take();
+                if let Some(rx) = self.rx.take() {
+                    let _ = rx.send(Err(err));
+                }
+                Err(())
+            }
+            Ok(Async::Ready((io, proto))) => {
+                if proto == Protocol::Http1 {
+                    let rx = self.rx.take().unwrap();
+                    let _ = rx.send(Ok(IoConnection::new(
+                        ConnectionType::H1(io),
+                        Instant::now(),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
+                    )));
+                    Ok(Async::Ready(()))
+                } else {
+                    self.h2 = Some(handshake(io));
+                    self.poll()
+                }
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+        }
+    }
+}
+
 pub(crate) struct Acquired<T>(Key, Option<Rc<RefCell<Inner<T>>>>);
 
 impl<T> Acquired<T>

actix-http/src/cookie/builder.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 
-use time::{Duration, Tm};
+use chrono::Duration;
+use time::Tm;
 
 use super::{Cookie, SameSite};
 
@@ -16,7 +17,6 @@ use super::{Cookie, SameSite};
 ///
 /// ```rust
 /// use actix_http::cookie::Cookie;
-/// use time::Duration;
 ///
 /// # fn main() {
 /// let cookie: Cookie = Cookie::build("name", "value")
@@ -24,7 +24,7 @@ use super::{Cookie, SameSite};
 ///     .path("/")
 ///     .secure(true)
 ///     .http_only(true)
-///     .max_age(Duration::days(1))
+///     .max_age(84600)
 ///     .finish();
 /// # }
 /// ```
@@ -79,6 +79,26 @@ impl CookieBuilder {
         self
     }
 
+    /// Sets the `max_age` field in seconds in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age(1800)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
+    /// # }
+    /// ```
+    #[inline]
+    pub fn max_age(self, seconds: i64) -> CookieBuilder {
+        self.max_age_time(Duration::seconds(seconds))
+    }
+
     /// Sets the `max_age` field in the cookie being built.
     ///
     /// # Example
@@ -88,14 +108,14 @@ impl CookieBuilder {
     ///
     /// # fn main() {
     /// let c = Cookie::build("foo", "bar")
-    ///     .max_age(time::Duration::minutes(30))
+    ///     .max_age_time(time::Duration::minutes(30))
     ///     .finish();
     ///
     /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
     /// # }
     /// ```
     #[inline]
-    pub fn max_age(mut self, value: Duration) -> CookieBuilder {
+    pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
         self.cookie.set_max_age(value);
         self
     }
@@ -200,7 +220,7 @@ impl CookieBuilder {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// use chrono::Duration;
     ///
     /// # fn main() {
     /// let c = Cookie::build("foo", "bar")

actix-http/src/cookie/jar.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use std::mem::replace;
 
-use time::{self, Duration};
+use chrono::Duration;
 
 use super::delta::DeltaCookie;
 use super::Cookie;
@@ -188,7 +188,7 @@ impl CookieJar {
     ///
     /// ```rust
     /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use time::Duration;
+    /// use chrono::Duration;
     ///
     /// # fn main() {
     /// let mut jar = CookieJar::new();
@@ -241,7 +241,7 @@ impl CookieJar {
     ///
     /// ```rust
     /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use time::Duration;
+    /// use chrono::Duration;
     ///
     /// # fn main() {
     /// let mut jar = CookieJar::new();
@@ -537,8 +537,8 @@ mod test {
     #[test]
     #[cfg(feature = "secure-cookies")]
     fn delta() {
+        use chrono::Duration;
         use std::collections::HashMap;
-        use time::Duration;
 
         let mut c = CookieJar::new();
 

actix-http/src/cookie/mod.rs

@@ -65,8 +65,9 @@ use std::borrow::Cow;
 use std::fmt;
 use std::str::FromStr;
 
+use chrono::Duration;
 use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
-use time::{Duration, Tm};
+use time::Tm;
 
 pub use self::builder::CookieBuilder;
 pub use self::draft::*;
@@ -624,7 +625,7 @@ impl<'c> Cookie<'c> {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// use chrono::Duration;
     ///
     /// # fn main() {
     /// let mut c = Cookie::new("name", "value");
@@ -703,7 +704,7 @@ impl<'c> Cookie<'c> {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// use chrono::Duration;
     ///
     /// # fn main() {
     /// let mut c = Cookie::new("foo", "bar");
@@ -977,7 +978,7 @@ impl<'a, 'b> PartialEq<Cookie<'b>> for Cookie<'a> {
 #[cfg(test)]
 mod tests {
     use super::{Cookie, SameSite};
-    use time::{strptime, Duration};
+    use time::strptime;
 
     #[test]
     fn format() {
@@ -987,9 +988,7 @@ mod tests {
         let cookie = Cookie::build("foo", "bar").http_only(true).finish();
         assert_eq!(&cookie.to_string(), "foo=bar; HttpOnly");
 
-        let cookie = Cookie::build("foo", "bar")
-            .max_age(Duration::seconds(10))
-            .finish();
+        let cookie = Cookie::build("foo", "bar").max_age(10).finish();
         assert_eq!(&cookie.to_string(), "foo=bar; Max-Age=10");
 
         let cookie = Cookie::build("foo", "bar").secure(true).finish();

actix-http/src/cookie/parse.rs

@@ -5,8 +5,8 @@ use std::error::Error;
 use std::fmt;
 use std::str::Utf8Error;
 
+use chrono::Duration;
 use percent_encoding::percent_decode;
-use time::{self, Duration};
 
 use super::{Cookie, CookieStr, SameSite};
 
@@ -220,7 +220,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::{Cookie, SameSite};
-    use time::{strptime, Duration};
+    use chrono::Duration;
+    use time::strptime;
 
     macro_rules! assert_eq_parse {
         ($string:expr, $expected:expr) => {
@@ -418,9 +419,7 @@ mod tests {
     #[test]
     fn do_not_panic_on_large_max_ages() {
         let max_seconds = Duration::max_value().num_seconds();
-        let expected = Cookie::build("foo", "bar")
-            .max_age(Duration::seconds(max_seconds))
-            .finish();
+        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
         assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
     }
 }

actix-http/src/h1/decoder.rs

@@ -300,7 +300,13 @@ impl MessageType for ResponseHead {
             error!("MAX_BUFFER_SIZE unprocessed data reached, closing");
             return Err(ParseError::TooLarge);
         } else {
-            PayloadType::None
+            // for HTTP/1.0 read to eof and close connection
+            if msg.version == Version::HTTP_10 {
+                msg.set_connection_type(ConnectionType::Close);
+                PayloadType::Payload(PayloadDecoder::eof())
+            } else {
+                PayloadType::None
+            }
         };
 
         Ok(Some((msg, decoder)))
@@ -331,7 +337,7 @@ impl HeaderIndex {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 /// Http payload item
 pub enum PayloadItem {
     Chunk(Bytes),
@@ -1191,4 +1197,16 @@ mod tests {
         let msg = pl.decode(&mut buf).unwrap().unwrap();
         assert!(msg.eof());
     }
+
+    #[test]
+    fn test_response_http10_read_until_eof() {
+        let mut buf = BytesMut::from(&"HTTP/1.0 200 Ok\r\n\r\ntest data"[..]);
+
+        let mut reader = MessageDecoder::<ResponseHead>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let chunk = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"test data")));
+    }
 }

actix-http/src/h1/encoder.rs

@@ -43,6 +43,10 @@ pub(crate) trait MessageType: Sized {
 
     fn headers(&self) -> &HeaderMap;
 
+    fn camel_case(&self) -> bool {
+        false
+    }
+
     fn chunked(&self) -> bool;
 
     fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
@@ -57,6 +61,7 @@ pub(crate) trait MessageType: Sized {
     ) -> io::Result<()> {
         let chunked = self.chunked();
         let mut skip_len = length != BodySize::Stream;
+        let camel_case = self.camel_case();
 
         // Content length
         if let Some(status) = self.status() {
@@ -74,18 +79,30 @@ pub(crate) trait MessageType: Sized {
         match length {
             BodySize::Stream => {
                 if chunked {
-                    dst.put_slice(b"\r\ntransfer-encoding: chunked\r\n")
+                    if camel_case {
+                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
+                    } else {
+                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
+                    }
                 } else {
                     skip_len = false;
                     dst.put_slice(b"\r\n");
                 }
             }
             BodySize::Empty => {
-                dst.put_slice(b"\r\ncontent-length: 0\r\n");
+                if camel_case {
+                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
+                } else {
+                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
+                }
             }
             BodySize::Sized(len) => helpers::write_content_length(len, dst),
             BodySize::Sized64(len) => {
-                dst.put_slice(b"\r\ncontent-length: ");
+                if camel_case {
+                    dst.put_slice(b"\r\nContent-Length: ");
+                } else {
+                    dst.put_slice(b"\r\ncontent-length: ");
+                }
                 write!(dst.writer(), "{}\r\n", len)?;
             }
             BodySize::None => dst.put_slice(b"\r\n"),
@@ -95,10 +112,18 @@ pub(crate) trait MessageType: Sized {
         match ctype {
             ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
             ConnectionType::KeepAlive if version < Version::HTTP_11 => {
-                dst.put_slice(b"connection: keep-alive\r\n")
+                if camel_case {
+                    dst.put_slice(b"Connection: keep-alive\r\n")
+                } else {
+                    dst.put_slice(b"connection: keep-alive\r\n")
+                }
             }
             ConnectionType::Close if version >= Version::HTTP_11 => {
-                dst.put_slice(b"connection: close\r\n")
+                if camel_case {
+                    dst.put_slice(b"Connection: close\r\n")
+                } else {
+                    dst.put_slice(b"connection: close\r\n")
+                }
             }
             _ => (),
         }
@@ -133,7 +158,12 @@ pub(crate) trait MessageType: Sized {
                             buf = &mut *(dst.bytes_mut() as *mut _);
                         }
                     }
-                    buf[pos..pos + k.len()].copy_from_slice(k);
+                    // use upper Camel-Case
+                    if camel_case {
+                        write_camel_case(k, &mut buf[pos..pos + k.len()]);
+                    } else {
+                        buf[pos..pos + k.len()].copy_from_slice(k);
+                    }
                     pos += k.len();
                     buf[pos..pos + 2].copy_from_slice(b": ");
                     pos += 2;
@@ -158,7 +188,12 @@ pub(crate) trait MessageType: Sized {
                                 buf = &mut *(dst.bytes_mut() as *mut _);
                             }
                         }
-                        buf[pos..pos + k.len()].copy_from_slice(k);
+                        // use upper Camel-Case
+                        if camel_case {
+                            write_camel_case(k, &mut buf[pos..pos + k.len()]);
+                        } else {
+                            buf[pos..pos + k.len()].copy_from_slice(k);
+                        }
                         pos += k.len();
                         buf[pos..pos + 2].copy_from_slice(b": ");
                         pos += 2;
@@ -221,6 +256,10 @@ impl MessageType for RequestHead {
         self.chunked()
     }
 
+    fn camel_case(&self) -> bool {
+        RequestHead::camel_case_headers(self)
+    }
+
     fn headers(&self) -> &HeaderMap {
         &self.headers
     }
@@ -418,11 +457,41 @@ impl<'a> io::Write for Writer<'a> {
     }
 }
 
+fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+    let mut index = 0;
+    let key = value;
+    let mut key_iter = key.iter();
+
+    if let Some(c) = key_iter.next() {
+        if *c >= b'a' && *c <= b'z' {
+            buffer[index] = *c ^ b' ';
+            index += 1;
+        }
+    } else {
+        return;
+    }
+
+    while let Some(c) = key_iter.next() {
+        buffer[index] = *c;
+        index += 1;
+        if *c == b'-' {
+            if let Some(c) = key_iter.next() {
+                if *c >= b'a' && *c <= b'z' {
+                    buffer[index] = *c ^ b' ';
+                    index += 1;
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::*;
     use bytes::Bytes;
 
+    use super::*;
+    use crate::http::header::{HeaderValue, CONTENT_TYPE};
+
     #[test]
     fn test_chunked_te() {
         let mut bytes = BytesMut::new();
@@ -436,4 +505,64 @@ mod tests {
             Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
         );
     }
+
+    #[test]
+    fn test_camel_case() {
+        let mut bytes = BytesMut::with_capacity(2048);
+        let mut head = RequestHead::default();
+        head.set_camel_case_headers(true);
+        head.headers.insert(DATE, HeaderValue::from_static("date"));
+        head.headers
+            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Empty,
+            ConnectionType::Close,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nContent-Length: 0\r\nConnection: close\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Stream,
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nTransfer-Encoding: chunked\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Sized64(100),
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nContent-Length: 100\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        head.headers
+            .append(CONTENT_TYPE, HeaderValue::from_static("xml"));
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Stream,
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nTransfer-Encoding: chunked\r\nDate: date\r\nContent-Type: xml\r\nContent-Type: plain/text\r\n\r\n")
+        );
+    }
 }

actix-http/src/message.rs

@@ -27,6 +27,7 @@ bitflags! {
         const UPGRADE     = 0b0000_0100;
         const EXPECT      = 0b0000_1000;
         const NO_CHUNKING = 0b0001_0000;
+        const CAMEL_CASE  = 0b0010_0000;
     }
 }
 
@@ -97,6 +98,23 @@ impl RequestHead {
         &mut self.headers
     }
 
+    /// Is to uppercase headers with Camel-Case.
+    /// Befault is `false`
+    #[inline]
+    pub fn camel_case_headers(&self) -> bool {
+        self.flags.contains(Flags::CAMEL_CASE)
+    }
+
+    /// Set `true` to send headers which are uppercased with Camel-Case.
+    #[inline]
+    pub fn set_camel_case_headers(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::CAMEL_CASE);
+        } else {
+            self.flags.remove(Flags::CAMEL_CASE);
+        }
+    }
+
     #[inline]
     /// Set connection type of the message
     pub fn set_connection_type(&mut self, ctype: ConnectionType) {

actix-http/src/request.rs

@@ -178,3 +178,28 @@ impl<P> fmt::Debug for Request<P> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::HttpTryFrom;
+
+    #[test]
+    fn test_basics() {
+        let msg = Message::new();
+        let mut req = Request::from(msg);
+        req.headers_mut().insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain"),
+        );
+        assert!(req.headers().contains_key(header::CONTENT_TYPE));
+
+        *req.uri_mut() = Uri::try_from("/index.html?q=1").unwrap();
+        assert_eq!(req.uri().path(), "/index.html");
+        assert_eq!(req.uri().query(), Some("q=1"));
+
+        let s = format!("{:?}", req);
+        println!("T: {:?}", s);
+        assert!(s.contains("Request HTTP/1.1 GET:/index.html"));
+    }
+}

actix-http/src/response.rs

@@ -860,7 +860,7 @@ mod tests {
                     .domain("www.rust-lang.org")
                     .path("/test")
                     .http_only(true)
-                    .max_age(time::Duration::days(1))
+                    .max_age_time(time::Duration::days(1))
                     .finish(),
             )
             .del_cookie(&cookies[1])

actix-http/tests/test_client.rs

@@ -59,9 +59,7 @@ fn test_connection_close() {
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .map(|_| ())
     });
-    println!("REQ: {:?}", srv.get("/").force_close());
     let response = srv.block_on(srv.get("/").force_close().send()).unwrap();
-    println!("RES: {:?}", response);
     assert!(response.status().is_success());
 }
 

actix-multipart/CHANGES.md

@@ -1,7 +1,9 @@
 # Changes
 
-## [0.1.0-alpha.1] - 2019-04-xx
+## [0.1.0-beta.1] - 2019-04-21
 
 * Do not support nested multipart
 
 * Split multipart support to separate crate
+
+* Optimize multipart handling #634, #769

actix-multipart/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.1.0-alpha.1"
+version = "0.1.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart support for actix web framework."
 readme = "README.md"
@@ -18,8 +18,8 @@ name = "actix_multipart"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = "1.0.0-alpha.3"
-actix-service = "0.3.4"
+actix-web = "1.0.0-beta.1"
+actix-service = "0.3.6"
 bytes = "0.4"
 derive_more = "0.14"
 httparse = "1.3"
@@ -31,4 +31,4 @@ twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "0.2.2"
-actix-http = "0.1.0-alpha.3"
+actix-http = "0.1.1"

actix-multipart/src/server.rs

@@ -168,7 +168,7 @@ impl InnerMultipart {
         match payload.readline() {
             None => {
                 if payload.eof {
-                    Err(MultipartError::Incomplete)
+                    Ok(Some(true))
                 } else {
                     Ok(None)
                 }
@@ -201,8 +201,7 @@ impl InnerMultipart {
             match payload.readline() {
                 Some(chunk) => {
                     if chunk.is_empty() {
-                        //ValueError("Could not find starting boundary %r"
-                        //% (self._boundary))
+                        return Err(MultipartError::Boundary);
                     }
                     if chunk.len() < boundary.len() {
                         continue;
@@ -505,47 +504,72 @@ impl InnerField {
         payload: &mut PayloadBuffer,
         boundary: &str,
     ) -> Poll<Option<Bytes>, MultipartError> {
-        match payload.read_until(b"\r") {
-            None => {
-                if payload.eof {
-                    Err(MultipartError::Incomplete)
+        let mut pos = 0;
+
+        let len = payload.buf.len();
+        if len == 0 {
+            return Ok(Async::NotReady);
+        }
+
+        // check boundary
+        if len > 4 && payload.buf[0] == b'\r' {
+            let b_len = if &payload.buf[..2] == b"\r\n" && &payload.buf[2..4] == b"--" {
+                Some(4)
+            } else if &payload.buf[1..3] == b"--" {
+                Some(3)
+            } else {
+                None
+            };
+
+            if let Some(b_len) = b_len {
+                let b_size = boundary.len() + b_len;
+                if len < b_size {
+                    return Ok(Async::NotReady);
                 } else {
-                    Ok(Async::NotReady)
+                    if &payload.buf[b_len..b_size] == boundary.as_bytes() {
+                        // found boundary
+                        return Ok(Async::Ready(None));
+                    } else {
+                        pos = b_size;
+                    }
                 }
             }
-            Some(mut chunk) => {
-                if chunk.len() == 1 {
-                    payload.unprocessed(chunk);
-                    match payload.read_exact(boundary.len() + 4) {
-                        None => {
-                            if payload.eof {
-                                Err(MultipartError::Incomplete)
-                            } else {
-                                Ok(Async::NotReady)
-                            }
-                        }
-                        Some(mut chunk) => {
-                            if &chunk[..2] == b"\r\n"
-                                && &chunk[2..4] == b"--"
-                                && &chunk[4..] == boundary.as_bytes()
-                            {
-                                payload.unprocessed(chunk);
-                                Ok(Async::Ready(None))
-                            } else {
-                                // \r might be part of data stream
-                                let ch = chunk.split_to(1);
-                                payload.unprocessed(chunk);
-                                Ok(Async::Ready(Some(ch)))
-                            }
-                        }
+        }
+
+        loop {
+            return if let Some(idx) = twoway::find_bytes(&payload.buf[pos..], b"\r") {
+                let cur = pos + idx;
+
+                // check if we have enough data for boundary detection
+                if cur + 4 > len {
+                    if cur > 0 {
+                        Ok(Async::Ready(Some(payload.buf.split_to(cur).freeze())))
+                    } else {
+                        Ok(Async::NotReady)
                     }
                 } else {
-                    let to = chunk.len() - 1;
-                    let ch = chunk.split_to(to);
-                    payload.unprocessed(chunk);
-                    Ok(Async::Ready(Some(ch)))
+                    // 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 + 1..cur + 3] == b"--")
+                    {
+                        if cur != 0 {
+                            // return buffer
+                            Ok(Async::Ready(Some(payload.buf.split_to(cur).freeze())))
+                        } else {
+                            pos = cur + 1;
+                            continue;
+                        }
+                    } else {
+                        // not boundary
+                        pos = cur + 1;
+                        continue;
+                    }
                 }
-            }
+            } else {
+                return Ok(Async::Ready(Some(payload.buf.take().freeze())));
+            };
         }
     }
 
@@ -555,26 +579,27 @@ impl InnerField {
         }
 
         let result = if let Some(payload) = self.payload.as_ref().unwrap().get_mut(s) {
-            let res = if let Some(ref mut len) = self.length {
-                InnerField::read_len(payload, len)?
-            } else {
-                InnerField::read_stream(payload, &self.boundary)?
-            };
+            if !self.eof {
+                let res = if let Some(ref mut len) = self.length {
+                    InnerField::read_len(payload, len)?
+                } else {
+                    InnerField::read_stream(payload, &self.boundary)?
+                };
 
-            match res {
-                Async::NotReady => Async::NotReady,
-                Async::Ready(Some(bytes)) => Async::Ready(Some(bytes)),
-                Async::Ready(None) => {
-                    self.eof = true;
-                    match payload.readline() {
-                        None => Async::Ready(None),
-                        Some(line) => {
-                            if line.as_ref() != b"\r\n" {
-                                log::warn!("multipart field did not read all the data or it is malformed");
-                            }
-                            Async::Ready(None)
-                        }
+                match res {
+                    Async::NotReady => return Ok(Async::NotReady),
+                    Async::Ready(Some(bytes)) => return Ok(Async::Ready(Some(bytes))),
+                    Async::Ready(None) => self.eof = true,
+                }
+            }
+
+            match payload.readline() {
+                None => Async::Ready(None),
+                Some(line) => {
+                    if line.as_ref() != b"\r\n" {
+                        log::warn!("multipart field did not read all the data or it is malformed");
                     }
+                    Async::Ready(None)
                 }
             }
         } else {
@@ -704,7 +729,7 @@ impl PayloadBuffer {
     }
 
     /// Read exact number of bytes
-    #[inline]
+    #[cfg(test)]
     fn read_exact(&mut self, size: usize) -> Option<Bytes> {
         if size <= self.buf.len() {
             Some(self.buf.split_to(size).freeze())
@@ -875,6 +900,78 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_stream() {
+        run_on(|| {
+            let (sender, payload) = create_stream();
+
+            let bytes = Bytes::from(
+                "testasdadsad\r\n\
+                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+                 Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+                 Content-Type: text/plain; charset=utf-8\r\n\r\n\
+                 test\r\n\
+                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+                 Content-Type: text/plain; charset=utf-8\r\n\r\n\
+                 data\r\n\
+                 --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
+            );
+            sender.unbounded_send(Ok(bytes)).unwrap();
+
+            let mut headers = HeaderMap::new();
+            headers.insert(
+                header::CONTENT_TYPE,
+                header::HeaderValue::from_static(
+                    "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+                ),
+            );
+
+            let mut multipart = Multipart::new(&headers, payload);
+            match multipart.poll().unwrap() {
+                Async::Ready(Some(mut field)) => {
+                    let cd = field.content_disposition().unwrap();
+                    assert_eq!(cd.disposition, DispositionType::FormData);
+                    assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
+
+                    assert_eq!(field.content_type().type_(), mime::TEXT);
+                    assert_eq!(field.content_type().subtype(), mime::PLAIN);
+
+                    match field.poll().unwrap() {
+                        Async::Ready(Some(chunk)) => assert_eq!(chunk, "test"),
+                        _ => unreachable!(),
+                    }
+                    match field.poll().unwrap() {
+                        Async::Ready(None) => (),
+                        _ => unreachable!(),
+                    }
+                }
+                _ => unreachable!(),
+            }
+
+            match multipart.poll().unwrap() {
+                Async::Ready(Some(mut field)) => {
+                    assert_eq!(field.content_type().type_(), mime::TEXT);
+                    assert_eq!(field.content_type().subtype(), mime::PLAIN);
+
+                    match field.poll() {
+                        Ok(Async::Ready(Some(chunk))) => assert_eq!(chunk, "data"),
+                        _ => unreachable!(),
+                    }
+                    match field.poll() {
+                        Ok(Async::Ready(None)) => (),
+                        _ => unreachable!(),
+                    }
+                }
+                _ => unreachable!(),
+            }
+
+            match multipart.poll().unwrap() {
+                Async::Ready(None) => (),
+                _ => unreachable!(),
+            }
+        });
+    }
+
     #[test]
     fn test_basic() {
         run_on(|| {

actix-session/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.1.0-beta.1] - 2019-04-20
+
+* Update actix-web to beta.1
+
+* `CookieSession::max_age()` accepts value in seconds
+
 ## [0.1.0-alpha.6] - 2019-04-14
 
 * Update actix-web alpha.6

actix-session/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-session"
-version = "0.1.0-alpha.6"
+version = "0.1.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Session for actix web framework."
 readme = "README.md"
@@ -24,15 +24,15 @@ default = ["cookie-session"]
 cookie-session = ["actix-web/secure-cookies"]
 
 [dependencies]
-actix-web = "1.0.0-alpha.6"
+actix-web = "1.0.0-beta.1"
 actix-service = "0.3.4"
 bytes = "0.4"
 derive_more = "0.14"
 futures = "0.1.25"
-hashbrown = "0.2.0"
+hashbrown = "0.2.2"
 serde = "1.0"
 serde_json = "1.0"
-time = "0.1"
+time = "0.1.42"
 
 [dev-dependencies]
 actix-rt = "0.2.2"

actix-session/src/cookie.rs

@@ -27,7 +27,6 @@ use derive_more::{Display, From};
 use futures::future::{ok, Future, FutureResult};
 use futures::Poll;
 use serde_json::error::Error as JsonError;
-use time::Duration;
 
 use crate::Session;
 
@@ -57,7 +56,7 @@ struct CookieSessionInner {
     domain: Option<String>,
     secure: bool,
     http_only: bool,
-    max_age: Option<Duration>,
+    max_age: Option<time::Duration>,
     same_site: Option<SameSite>,
 }
 
@@ -250,7 +249,12 @@ impl CookieSession {
     }
 
     /// Sets the `max-age` field in the session cookie being built.
-    pub fn max_age(mut self, value: Duration) -> CookieSession {
+    pub fn max_age(self, seconds: i64) -> CookieSession {
+        self.max_age_time(time::Duration::seconds(seconds))
+    }
+
+    /// Sets the `max-age` field in the session cookie being built.
+    pub fn max_age_time(mut self, value: time::Duration) -> CookieSession {
         Rc::get_mut(&mut self.0).unwrap().max_age = Some(value);
         self
     }
@@ -317,6 +321,7 @@ where
 mod tests {
     use super::*;
     use actix_web::{test, web, App};
+    use bytes::Bytes;
 
     #[test]
     fn cookie_session() {
@@ -338,6 +343,26 @@ mod tests {
             .is_some());
     }
 
+    #[test]
+    fn private_cookie() {
+        let mut app = test::init_service(
+            App::new()
+                .wrap(CookieSession::private(&[0; 32]).secure(false))
+                .service(web::resource("/").to(|ses: Session| {
+                    let _ = ses.set("counter", 100);
+                    "test"
+                })),
+        );
+
+        let request = test::TestRequest::get().to_request();
+        let response = test::block_on(app.call(request)).unwrap();
+        assert!(response
+            .response()
+            .cookies()
+            .find(|c| c.name() == "actix-session")
+            .is_some());
+    }
+
     #[test]
     fn cookie_session_extractor() {
         let mut app = test::init_service(
@@ -357,4 +382,44 @@ mod tests {
             .find(|c| c.name() == "actix-session")
             .is_some());
     }
+
+    #[test]
+    fn basics() {
+        let mut app = test::init_service(
+            App::new()
+                .wrap(
+                    CookieSession::signed(&[0; 32])
+                        .path("/test/")
+                        .name("actix-test")
+                        .domain("localhost")
+                        .http_only(true)
+                        .same_site(SameSite::Lax)
+                        .max_age(100),
+                )
+                .service(web::resource("/").to(|ses: Session| {
+                    let _ = ses.set("counter", 100);
+                    "test"
+                }))
+                .service(web::resource("/test/").to(|ses: Session| {
+                    let val: usize = ses.get("counter").unwrap().unwrap();
+                    format!("counter: {}", val)
+                })),
+        );
+
+        let request = test::TestRequest::get().to_request();
+        let response = test::block_on(app.call(request)).unwrap();
+        let cookie = response
+            .response()
+            .cookies()
+            .find(|c| c.name() == "actix-test")
+            .unwrap()
+            .clone();
+        assert_eq!(cookie.path().unwrap(), "/test/");
+
+        let request = test::TestRequest::with_uri("/test/")
+            .cookie(cookie)
+            .to_request();
+        let body = test::read_response(&mut app, request);
+        assert_eq!(body, Bytes::from_static(b"counter: 100"));
+    }
 }

actix-web-actors/Cargo.toml

@@ -19,12 +19,12 @@ path = "src/lib.rs"
 
 [dependencies]
 actix = "0.8.0"
-actix-web = "1.0.0-alpha.5"
-actix-http = "0.1.0-alpha.5"
+actix-web = "1.0.0-beta.1"
+actix-http = "0.1.1"
 actix-codec = "0.1.2"
 bytes = "0.4"
 futures = "0.1.25"
 
 [dev-dependencies]
 env_logger = "0.6"
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-http-test = { version = "0.1.0", features=["ssl"] }

actix-web-codegen/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.0-beta.1] - 2019-04-20
+
+* Gen code for actix-web 1.0.0-beta.1
+
 ## [0.1.0-alpha.6] - 2019-04-14
 
 * Gen code for actix-web 1.0.0-alpha.6

actix-web-codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.1.0-alpha.6"
+version = "0.1.0-beta.1"
 description = "Actix web proc macros"
 readme = "README.md"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
@@ -17,6 +17,6 @@ syn = { version = "0.15", features = ["full", "parsing"] }
 
 [dev-dependencies]
 actix-web = { version = "1.0.0-alpha.6" }
-actix-http = { version = "0.1.0-alpha.5", features=["ssl"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-http = { version = "0.1.1", features=["ssl"] }
+actix-http-test = { version = "0.1.0", features=["ssl"] }
 futures = { version = "0.1" }

awc/CHANGES.md

@@ -1,5 +1,25 @@
 # Changes
 
+### Added
+
+* Allow to send headers in `Camel-Case` form.
+
+## [0.1.1] - 2019-04-19
+
+### Added
+
+* Allow to specify server address for http and ws requests.
+
+### Changed
+
+* `ClientRequest::if_true()` and `ClientRequest::if_some()` use instance instead of ref
+
+
+## [0.1.0] - 2019-04-16
+
+* No changes
+
+
 ## [0.1.0-alpha.6] - 2019-04-14
 
 ### Changed

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "0.1.0-alpha.6"
+version = "0.1.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http client."
 readme = "README.md"
@@ -38,7 +38,7 @@ flate2-rust = ["actix-http/flate2-rust"]
 [dependencies]
 actix-codec = "0.1.2"
 actix-service = "0.3.6"
-actix-http = "0.1.0-alpha.5"
+actix-http = "0.1.2"
 base64 = "0.10.1"
 bytes = "0.4"
 derive_more = "0.14"
@@ -55,11 +55,11 @@ openssl = { version="0.10", optional = true }
 
 [dev-dependencies]
 actix-rt = "0.2.2"
-actix-web = { version = "1.0.0-alpha.6", features=["ssl"] }
-actix-http = { version = "0.1.0-alpha.5", features=["ssl"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-web = { version = "1.0.0-beta.1", features=["ssl"] }
+actix-http = { version = "0.1.2", features=["ssl"] }
+actix-http-test = { version = "0.1.0", features=["ssl"] }
 actix-utils = "0.3.4"
-actix-server = { version = "0.4.1", features=["ssl"] }
+actix-server = { version = "0.4.3", features=["ssl"] }
 brotli2 = { version="0.3.2" }
 flate2 = { version="1.0.2" }
 env_logger = "0.6"

awc/README.md

@@ -1 +1,33 @@
 # Actix http client [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/awc)](https://crates.io/crates/awc) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+An HTTP Client
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/awc/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [awc](https://crates.io/crates/awc)
+* Minimum supported Rust version: 1.33 or later
+
+## Example
+
+```rust
+use actix_rt::System;
+use awc::Client;
+use futures::future::{Future, lazy};
+
+fn main() {
+    System::new("test").block_on(lazy(|| {
+       let mut client = Client::default();
+
+       client.get("http://www.rust-lang.org") // <- Create request builder
+          .header("User-Agent", "Actix-web")
+          .send()                             // <- Send http request
+          .and_then(|response| {              // <- server http response
+               println!("Response: {:?}", response);
+               Ok(())
+          })
+    }));
+}
+```

awc/src/builder.rs

@@ -3,8 +3,8 @@ use std::fmt;
 use std::rc::Rc;
 use std::time::Duration;
 
-use actix_http::client::{ConnectError, Connection, Connector};
-use actix_http::http::{header, HeaderMap, HeaderName, HttpTryFrom, Uri};
+use actix_http::client::{Connect, ConnectError, Connection, Connector};
+use actix_http::http::{header, HeaderMap, HeaderName, HttpTryFrom};
 use actix_service::Service;
 
 use crate::connect::ConnectorWrapper;
@@ -40,7 +40,7 @@ impl ClientBuilder {
     /// Use custom connector service.
     pub fn connector<T>(mut self, connector: T) -> Self
     where
-        T: Service<Request = Uri, Error = ConnectError> + 'static,
+        T: Service<Request = Connect, Error = ConnectError> + 'static,
         T::Response: Connection,
         <T::Response as Connection>::Future: 'static,
         T::Future: 'static,

awc/src/connect.rs

@@ -1,10 +1,12 @@
-use std::{fmt, io};
+use std::{fmt, io, net};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_http::body::Body;
-use actix_http::client::{ConnectError, Connection, SendRequestError};
+use actix_http::client::{
+    Connect as ClientConnect, ConnectError, Connection, SendRequestError,
+};
 use actix_http::h1::ClientCodec;
-use actix_http::{http, RequestHead, ResponseHead};
+use actix_http::{RequestHead, ResponseHead};
 use actix_service::Service;
 use futures::{Future, Poll};
 
@@ -17,12 +19,14 @@ pub(crate) trait Connect {
         &mut self,
         head: RequestHead,
         body: Body,
+        addr: Option<net::SocketAddr>,
     ) -> Box<Future<Item = ClientResponse, Error = SendRequestError>>;
 
     /// Send request, returns Response and Framed
     fn open_tunnel(
         &mut self,
         head: RequestHead,
+        addr: Option<net::SocketAddr>,
     ) -> Box<
         Future<
             Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
@@ -33,7 +37,7 @@ pub(crate) trait Connect {
 
 impl<T> Connect for ConnectorWrapper<T>
 where
-    T: Service<Request = http::Uri, Error = ConnectError>,
+    T: Service<Request = ClientConnect, Error = ConnectError>,
     T::Response: Connection,
     <T::Response as Connection>::Io: 'static,
     <T::Response as Connection>::Future: 'static,
@@ -44,11 +48,15 @@ where
         &mut self,
         head: RequestHead,
         body: Body,
+        addr: Option<net::SocketAddr>,
     ) -> Box<Future<Item = ClientResponse, Error = SendRequestError>> {
         Box::new(
             self.0
                 // connect to the host
-                .call(head.uri.clone())
+                .call(ClientConnect {
+                    uri: head.uri.clone(),
+                    addr,
+                })
                 .from_err()
                 // send request
                 .and_then(move |connection| connection.send_request(head, body))
@@ -59,6 +67,7 @@ where
     fn open_tunnel(
         &mut self,
         head: RequestHead,
+        addr: Option<net::SocketAddr>,
     ) -> Box<
         Future<
             Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
@@ -68,7 +77,10 @@ where
         Box::new(
             self.0
                 // connect to the host
-                .call(head.uri.clone())
+                .call(ClientConnect {
+                    uri: head.uri.clone(),
+                    addr,
+                })
                 .from_err()
                 // send request
                 .and_then(move |connection| connection.open_tunnel(head))

awc/src/request.rs

@@ -1,8 +1,8 @@
-use std::fmt;
 use std::fmt::Write as FmtWrite;
 use std::io::Write;
 use std::rc::Rc;
 use std::time::Duration;
+use std::{fmt, net};
 
 use bytes::{BufMut, Bytes, BytesMut};
 use futures::future::{err, Either};
@@ -60,6 +60,7 @@ const HTTPS_ENCODING: &str = "gzip, deflate";
 pub struct ClientRequest {
     pub(crate) head: RequestHead,
     err: Option<HttpError>,
+    addr: Option<net::SocketAddr>,
     cookies: Option<CookieJar>,
     response_decompress: bool,
     timeout: Option<Duration>,
@@ -76,6 +77,7 @@ impl ClientRequest {
             config,
             head: RequestHead::default(),
             err: None,
+            addr: None,
             cookies: None,
             timeout: None,
             response_decompress: true,
@@ -97,6 +99,15 @@ impl ClientRequest {
         self
     }
 
+    /// Set socket address of the server.
+    ///
+    /// This address is used for connection. If address is not
+    /// provided url's host name get resolved.
+    pub fn address(mut self, addr: net::SocketAddr) -> Self {
+        self.addr = Some(addr);
+        self
+    }
+
     /// Set HTTP method of this request.
     #[inline]
     pub fn method(mut self, method: Method) -> Self {
@@ -224,6 +235,13 @@ impl ClientRequest {
         self
     }
 
+    /// Send headers in `Camel-Case` form.
+    #[inline]
+    pub fn camel_case(mut self) -> Self {
+        self.head.set_camel_case_headers(true);
+        self
+    }
+
     /// Force close connection instead of returning it back to connections pool.
     /// This setting affect only http/1 connections.
     #[inline]
@@ -331,26 +349,28 @@ impl ClientRequest {
 
     /// This method calls provided closure with builder reference if
     /// value is `true`.
-    pub fn if_true<F>(mut self, value: bool, f: F) -> Self
+    pub fn if_true<F>(self, value: bool, f: F) -> Self
     where
-        F: FnOnce(&mut ClientRequest),
+        F: FnOnce(ClientRequest) -> ClientRequest,
     {
         if value {
-            f(&mut self);
+            f(self)
+        } else {
+            self
         }
-        self
     }
 
     /// This method calls provided closure with builder reference if
     /// value is `Some`.
-    pub fn if_some<T, F>(mut self, value: Option<T>, f: F) -> Self
+    pub fn if_some<T, F>(self, value: Option<T>, f: F) -> Self
     where
-        F: FnOnce(T, &mut ClientRequest),
+        F: FnOnce(T, ClientRequest) -> ClientRequest,
     {
         if let Some(val) = value {
-            f(val, &mut self);
+            f(val, self)
+        } else {
+            self
         }
-        self
     }
 
     /// Complete request construction and send body.
@@ -433,7 +453,7 @@ impl ClientRequest {
         let fut = config
             .connector
             .borrow_mut()
-            .send_request(head, body.into())
+            .send_request(head, body.into(), slf.addr)
             .map(move |res| {
                 res.map_body(|head, payload| {
                     if response_decompress {
@@ -564,9 +584,21 @@ mod tests {
             .version(Version::HTTP_2)
             .set(header::Date(SystemTime::now().into()))
             .content_type("plain/text")
+            .if_true(true, |req| req.header(header::SERVER, "awc"))
+            .if_true(false, |req| req.header(header::EXPECT, "awc"))
+            .if_some(Some("server"), |val, req| {
+                req.header(header::USER_AGENT, val)
+            })
+            .if_some(Option::<&str>::None, |_, req| {
+                req.header(header::ALLOW, "1")
+            })
             .content_length(100);
         assert!(req.headers().contains_key(header::CONTENT_TYPE));
         assert!(req.headers().contains_key(header::DATE));
+        assert!(req.headers().contains_key(header::SERVER));
+        assert!(req.headers().contains_key(header::USER_AGENT));
+        assert!(!req.headers().contains_key(header::ALLOW));
+        assert!(!req.headers().contains_key(header::EXPECT));
         assert_eq!(req.head.version, Version::HTTP_2);
         let _ = req.headers_mut();
         let _ = req.send_body("");

awc/src/ws.rs

@@ -1,5 +1,6 @@
 //! Websockets client
 use std::fmt::Write as FmtWrite;
+use std::net::SocketAddr;
 use std::rc::Rc;
 use std::{fmt, str};
 
@@ -29,6 +30,7 @@ pub struct WebsocketsRequest {
     err: Option<HttpError>,
     origin: Option<HeaderValue>,
     protocols: Option<String>,
+    addr: Option<SocketAddr>,
     max_size: usize,
     server_mode: bool,
     cookies: Option<CookieJar>,
@@ -55,6 +57,7 @@ impl WebsocketsRequest {
             head,
             err,
             config,
+            addr: None,
             origin: None,
             protocols: None,
             max_size: 65_536,
@@ -63,6 +66,15 @@ impl WebsocketsRequest {
         }
     }
 
+    /// Set socket address of the server.
+    ///
+    /// This address is used for connection. If address is not
+    /// provided url's host name get resolved.
+    pub fn address(mut self, addr: SocketAddr) -> Self {
+        self.addr = Some(addr);
+        self
+    }
+
     /// Set supported websocket protocols
     pub fn protocols<U, V>(mut self, protos: U) -> Self
     where
@@ -274,7 +286,7 @@ impl WebsocketsRequest {
             .config
             .connector
             .borrow_mut()
-            .open_tunnel(head)
+            .open_tunnel(head, self.addr)
             .from_err()
             .and_then(move |(head, framed)| {
                 // verify response
@@ -445,30 +457,41 @@ mod tests {
                 .unwrap(),
             "Bearer someS3cr3tAutht0k3n"
         );
+        let _ = req.connect();
     }
 
     #[test]
     fn basics() {
-        let req = Client::new()
-            .ws("/")
-            .origin("test-origin")
-            .max_frame_size(100)
-            .server_mode()
-            .protocols(&["v1", "v2"])
-            .set_header_if_none(header::CONTENT_TYPE, "json")
-            .set_header_if_none(header::CONTENT_TYPE, "text")
-            .cookie(Cookie::build("cookie1", "value1").finish());
-        assert_eq!(
-            req.origin.as_ref().unwrap().to_str().unwrap(),
-            "test-origin"
-        );
-        assert_eq!(req.max_size, 100);
-        assert_eq!(req.server_mode, true);
-        assert_eq!(req.protocols, Some("v1,v2".to_string()));
-        assert_eq!(
-            req.head.headers.get(header::CONTENT_TYPE).unwrap(),
-            header::HeaderValue::from_static("json")
-        );
-        let _ = req.connect();
+        actix_http_test::run_on(|| {
+            let req = Client::new()
+                .ws("http://localhost/")
+                .origin("test-origin")
+                .max_frame_size(100)
+                .server_mode()
+                .protocols(&["v1", "v2"])
+                .set_header_if_none(header::CONTENT_TYPE, "json")
+                .set_header_if_none(header::CONTENT_TYPE, "text")
+                .cookie(Cookie::build("cookie1", "value1").finish());
+            assert_eq!(
+                req.origin.as_ref().unwrap().to_str().unwrap(),
+                "test-origin"
+            );
+            assert_eq!(req.max_size, 100);
+            assert_eq!(req.server_mode, true);
+            assert_eq!(req.protocols, Some("v1,v2".to_string()));
+            assert_eq!(
+                req.head.headers.get(header::CONTENT_TYPE).unwrap(),
+                header::HeaderValue::from_static("json")
+            );
+            let _ = req.connect();
+        });
+
+        assert!(Client::new().ws("/").connect().poll().is_err());
+        assert!(Client::new().ws("http:///test").connect().poll().is_err());
+        assert!(Client::new()
+            .ws("hmm://test.com/")
+            .connect()
+            .poll()
+            .is_err());
     }
 }

awc/tests/test_client.rs

@@ -1,4 +1,7 @@
+use std::collections::HashMap;
 use std::io::{Read, Write};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
 use std::time::Duration;
 
 use brotli2::write::BrotliEncoder;
@@ -6,12 +9,14 @@ use bytes::Bytes;
 use flate2::read::GzDecoder;
 use flate2::write::GzEncoder;
 use flate2::Compression;
-use futures::future::Future;
+use futures::Future;
 use rand::Rng;
 
+use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http::HttpService;
 use actix_http_test::TestServer;
-use actix_web::http::Cookie;
+use actix_service::{fn_service, NewService};
+use actix_web::http::{Cookie, Version};
 use actix_web::middleware::{BodyEncoding, Compress};
 use actix_web::{http::header, web, App, Error, HttpMessage, HttpRequest, HttpResponse};
 use awc::error::SendRequestError;
@@ -38,6 +43,30 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World";
 
+#[cfg(feature = "ssl")]
+fn ssl_acceptor<T: AsyncRead + AsyncWrite>(
+) -> std::io::Result<actix_server::ssl::OpensslAcceptor<T, ()>> {
+    use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
+    // load ssl keys
+    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
+    builder
+        .set_private_key_file("../tests/key.pem", SslFiletype::PEM)
+        .unwrap();
+    builder
+        .set_certificate_chain_file("../tests/cert.pem")
+        .unwrap();
+    builder.set_alpn_select_callback(|_, protos| {
+        const H2: &[u8] = b"\x02h2";
+        if protos.windows(3).any(|window| window == H2) {
+            Ok(b"h2")
+        } else {
+            Err(openssl::ssl::AlpnError::NOACK)
+        }
+    });
+    builder.set_alpn_protos(b"\x02h2")?;
+    Ok(actix_server::ssl::OpensslAcceptor::new(builder.build()))
+}
+
 #[test]
 fn test_simple() {
     let mut srv =
@@ -61,6 +90,42 @@ fn test_simple() {
     // read response
     let bytes = srv.block_on(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
+
+    // camel case
+    let response = srv.block_on(srv.post("/").camel_case().send()).unwrap();
+    assert!(response.status().is_success());
+}
+
+#[test]
+fn test_json() {
+    let mut srv = TestServer::new(|| {
+        HttpService::new(App::new().service(
+            web::resource("/").route(web::to(|_: web::Json<String>| HttpResponse::Ok())),
+        ))
+    });
+
+    let request = srv
+        .get("/")
+        .header("x-test", "111")
+        .send_json(&"TEST".to_string());
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+}
+
+#[test]
+fn test_form() {
+    let mut srv = TestServer::new(|| {
+        HttpService::new(App::new().service(web::resource("/").route(web::to(
+            |_: web::Form<HashMap<String, String>>| HttpResponse::Ok(),
+        ))))
+    });
+
+    let mut data = HashMap::new();
+    let _ = data.insert("key".to_string(), "TEST".to_string());
+
+    let request = srv.get("/").header("x-test", "111").send_form(&data);
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
 }
 
 #[test]
@@ -111,17 +176,249 @@ fn test_timeout_override() {
 }
 
 #[test]
-fn test_connection_close() {
-    let mut srv = TestServer::new(|| {
-        HttpService::new(
-            App::new().service(web::resource("/").to(|| HttpResponse::Ok())),
+fn test_connection_reuse() {
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(HttpService::new(
+            App::new().service(web::resource("/").route(web::to(|| HttpResponse::Ok()))),
+        ))
+    });
+
+    let client = awc::Client::default();
+
+    // req 1
+    let request = client.get(srv.url("/")).send();
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req = client.post(srv.url("/"));
+    let response = srv.block_on_fn(move || req.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // one connection
+    assert_eq!(num.load(Ordering::Relaxed), 1);
+}
+
+#[cfg(feature = "ssl")]
+#[test]
+fn test_connection_reuse_h2() {
+    let openssl = ssl_acceptor().unwrap();
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(
+            openssl
+                .clone()
+                .map_err(|e| println!("Openssl error: {}", e)),
+        )
+        .and_then(
+            HttpService::build()
+                .h2(App::new()
+                    .service(web::resource("/").route(web::to(|| HttpResponse::Ok()))))
+                .map_err(|_| ()),
         )
     });
 
-    let res = srv
-        .block_on(awc::Client::new().get(srv.url("/")).force_close().send())
-        .unwrap();
-    assert!(res.status().is_success());
+    // disable ssl verification
+    use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
+
+    let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
+    builder.set_verify(SslVerifyMode::NONE);
+    let _ = builder
+        .set_alpn_protos(b"\x02h2\x08http/1.1")
+        .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+
+    let client = awc::Client::build()
+        .connector(awc::Connector::new().ssl(builder.build()).finish())
+        .finish();
+
+    // req 1
+    let request = client.get(srv.surl("/")).send();
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req = client.post(srv.surl("/"));
+    let response = srv.block_on_fn(move || req.send()).unwrap();
+    assert!(response.status().is_success());
+    assert_eq!(response.version(), Version::HTTP_2);
+
+    // one connection
+    assert_eq!(num.load(Ordering::Relaxed), 1);
+}
+
+#[test]
+fn test_connection_force_close() {
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(HttpService::new(
+            App::new().service(web::resource("/").route(web::to(|| HttpResponse::Ok()))),
+        ))
+    });
+
+    let client = awc::Client::default();
+
+    // req 1
+    let request = client.get(srv.url("/")).force_close().send();
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req = client.post(srv.url("/")).force_close();
+    let response = srv.block_on_fn(move || req.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // two connection
+    assert_eq!(num.load(Ordering::Relaxed), 2);
+}
+
+#[test]
+fn test_connection_server_close() {
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(HttpService::new(
+            App::new().service(
+                web::resource("/")
+                    .route(web::to(|| HttpResponse::Ok().force_close().finish())),
+            ),
+        ))
+    });
+
+    let client = awc::Client::default();
+
+    // req 1
+    let request = client.get(srv.url("/")).send();
+    let response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req = client.post(srv.url("/"));
+    let response = srv.block_on_fn(move || req.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // two connection
+    assert_eq!(num.load(Ordering::Relaxed), 2);
+}
+
+#[test]
+fn test_connection_wait_queue() {
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(HttpService::new(App::new().service(
+            web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))),
+        )))
+    });
+
+    let client = awc::Client::build()
+        .connector(awc::Connector::new().limit(1).finish())
+        .finish();
+
+    // req 1
+    let request = client.get(srv.url("/")).send();
+    let mut response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req2 = client.post(srv.url("/"));
+    let req2_fut = srv.execute(move || {
+        let mut fut = req2.send();
+        assert!(fut.poll().unwrap().is_not_ready());
+        fut
+    });
+
+    // read response 1
+    let bytes = srv.block_on(response.body()).unwrap();
+    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
+
+    // req 2
+    let response = srv.block_on(req2_fut).unwrap();
+    assert!(response.status().is_success());
+
+    // two connection
+    assert_eq!(num.load(Ordering::Relaxed), 1);
+}
+
+#[test]
+fn test_connection_wait_queue_force_close() {
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let mut srv = TestServer::new(move || {
+        let num2 = num2.clone();
+        fn_service(move |io| {
+            num2.fetch_add(1, Ordering::Relaxed);
+            Ok(io)
+        })
+        .and_then(HttpService::new(
+            App::new().service(
+                web::resource("/")
+                    .route(web::to(|| HttpResponse::Ok().force_close().body(STR))),
+            ),
+        ))
+    });
+
+    let client = awc::Client::build()
+        .connector(awc::Connector::new().limit(1).finish())
+        .finish();
+
+    // req 1
+    let request = client.get(srv.url("/")).send();
+    let mut response = srv.block_on(request).unwrap();
+    assert!(response.status().is_success());
+
+    // req 2
+    let req2 = client.post(srv.url("/"));
+    let req2_fut = srv.execute(move || {
+        let mut fut = req2.send();
+        assert!(fut.poll().unwrap().is_not_ready());
+        fut
+    });
+
+    // read response 1
+    let bytes = srv.block_on(response.body()).unwrap();
+    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
+
+    // req 2
+    let response = srv.block_on(req2_fut).unwrap();
+    assert!(response.status().is_success());
+
+    // two connection
+    assert_eq!(num.load(Ordering::Relaxed), 2);
 }
 
 #[test]

src/app.rs

@@ -431,13 +431,14 @@ where
 #[cfg(test)]
 mod tests {
     use actix_service::Service;
+    use bytes::Bytes;
     use futures::{Future, IntoFuture};
 
     use super::*;
     use crate::http::{header, HeaderValue, Method, StatusCode};
     use crate::service::{ServiceRequest, ServiceResponse};
-    use crate::test::{block_on, call_service, init_service, TestRequest};
-    use crate::{web, Error, HttpResponse};
+    use crate::test::{block_on, call_service, init_service, read_body, TestRequest};
+    use crate::{web, Error, HttpRequest, HttpResponse};
 
     #[test]
     fn test_default_resource() {
@@ -598,4 +599,26 @@ mod tests {
             HeaderValue::from_static("0001")
         );
     }
+
+    #[test]
+    fn test_external_resource() {
+        let mut srv = init_service(
+            App::new()
+                .external_resource("youtube", "https://youtube.com/watch/{video_id}")
+                .route(
+                    "/test",
+                    web::get().to(|req: HttpRequest| {
+                        HttpResponse::Ok().body(format!(
+                            "{}",
+                            req.url_for("youtube", &["12345"]).unwrap()
+                        ))
+                    }),
+                ),
+        );
+        let req = TestRequest::with_uri("/test").to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+        let body = read_body(resp);
+        assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));
+    }
 }

src/app_service.rs

@@ -162,7 +162,7 @@ where
             }
         }
 
-        if self.endpoint.is_some() {
+        if self.endpoint.is_some() && self.data.is_empty() {
             Ok(Async::Ready(AppInitService {
                 service: self.endpoint.take().unwrap(),
                 rmap: self.rmap.clone(),

src/config.rs

@@ -253,11 +253,14 @@ impl ServiceConfig {
 #[cfg(test)]
 mod tests {
     use actix_service::Service;
+    use bytes::Bytes;
+    use futures::Future;
+    use tokio_timer::sleep;
 
     use super::*;
     use crate::http::{Method, StatusCode};
-    use crate::test::{block_on, call_service, init_service, TestRequest};
-    use crate::{web, App, HttpResponse};
+    use crate::test::{block_on, call_service, init_service, read_body, TestRequest};
+    use crate::{web, App, HttpRequest, HttpResponse};
 
     #[test]
     fn test_data() {
@@ -277,7 +280,12 @@ mod tests {
     #[test]
     fn test_data_factory() {
         let cfg = |cfg: &mut ServiceConfig| {
-            cfg.data_factory(|| Ok::<_, ()>(10usize));
+            cfg.data_factory(|| {
+                sleep(std::time::Duration::from_millis(50)).then(|_| {
+                    println!("READY");
+                    Ok::<_, ()>(10usize)
+                })
+            });
         };
 
         let mut srv =
@@ -301,6 +309,33 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
+    #[test]
+    fn test_external_resource() {
+        let mut srv = init_service(
+            App::new()
+                .configure(|cfg| {
+                    cfg.external_resource(
+                        "youtube",
+                        "https://youtube.com/watch/{video_id}",
+                    );
+                })
+                .route(
+                    "/test",
+                    web::get().to(|req: HttpRequest| {
+                        HttpResponse::Ok().body(format!(
+                            "{}",
+                            req.url_for("youtube", &["12345"]).unwrap()
+                        ))
+                    }),
+                ),
+        );
+        let req = TestRequest::with_uri("/test").to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+        let body = read_body(resp);
+        assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));
+    }
+
     #[test]
     fn test_service() {
         let mut srv = init_service(App::new().configure(|cfg| {

src/extract.rs

@@ -265,13 +265,12 @@ tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5,
 #[cfg(test)]
 mod tests {
     use actix_http::http::header;
-    use actix_router::ResourceDef;
     use bytes::Bytes;
     use serde_derive::Deserialize;
 
     use super::*;
     use crate::test::{block_on, TestRequest};
-    use crate::types::{Form, FormConfig, Path, Query};
+    use crate::types::{Form, FormConfig};
 
     #[derive(Deserialize, Debug, PartialEq)]
     struct Info {
@@ -350,58 +349,4 @@ mod tests {
             block_on(Result::<Form<Info>, Error>::from_request(&req, &mut pl)).unwrap();
         assert!(r.is_err());
     }
-
-    #[derive(Deserialize)]
-    struct MyStruct {
-        key: String,
-        value: String,
-    }
-
-    #[derive(Deserialize)]
-    struct Id {
-        id: String,
-    }
-
-    #[derive(Deserialize)]
-    struct Test2 {
-        key: String,
-        value: u32,
-    }
-
-    #[test]
-    fn test_request_extract() {
-        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-
-        let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
-
-        let (req, mut pl) = req.into_parts();
-        let s = Path::<MyStruct>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.key, "name");
-        assert_eq!(s.value, "user1");
-
-        let s = Path::<(String, String)>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.0, "name");
-        assert_eq!(s.1, "user1");
-
-        let s = Query::<Id>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.id, "test");
-
-        let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
-        let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
-
-        let (req, mut pl) = req.into_parts();
-        let s = Path::<Test2>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.as_ref().key, "name");
-        assert_eq!(s.value, 32);
-
-        let s = Path::<(String, u8)>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.0, "name");
-        assert_eq!(s.1, 32);
-
-        let res = Path::<Vec<String>>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(res[0], "name".to_owned());
-        assert_eq!(res[1], "32".to_owned());
-    }
 }

src/handler.rs

@@ -124,7 +124,7 @@ where
 pub trait AsyncFactory<T, R>: Clone + 'static
 where
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     fn call(&self, param: T) -> R;
@@ -134,7 +134,7 @@ impl<F, R> AsyncFactory<(), R> for F
 where
     F: Fn() -> R + Clone + 'static,
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     fn call(&self, _: ()) -> R {
@@ -147,7 +147,7 @@ pub struct AsyncHandler<F, T, R>
 where
     F: AsyncFactory<T, R>,
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     hnd: F,
@@ -158,7 +158,7 @@ impl<F, T, R> AsyncHandler<F, T, R>
 where
     F: AsyncFactory<T, R>,
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     pub fn new(hnd: F) -> Self {
@@ -173,7 +173,7 @@ impl<F, T, R> Clone for AsyncHandler<F, T, R>
 where
     F: AsyncFactory<T, R>,
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     fn clone(&self) -> Self {
@@ -188,7 +188,7 @@ impl<F, T, R> Service for AsyncHandler<F, T, R>
 where
     F: AsyncFactory<T, R>,
     R: IntoFuture,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     type Request = (T, HttpRequest);
@@ -203,32 +203,56 @@ where
     fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
         AsyncHandlerServiceResponse {
             fut: self.hnd.call(param).into_future(),
+            fut2: None,
             req: Some(req),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct AsyncHandlerServiceResponse<T> {
+pub struct AsyncHandlerServiceResponse<T>
+where
+    T: Future,
+    T::Item: Responder,
+{
     fut: T,
+    fut2: Option<<<T::Item as Responder>::Future as IntoFuture>::Future>,
     req: Option<HttpRequest>,
 }
 
 impl<T> Future for AsyncHandlerServiceResponse<T>
 where
     T: Future,
-    T::Item: Into<Response>,
+    T::Item: Responder,
     T::Error: Into<Error>,
 {
     type Item = ServiceResponse;
     type Error = Void;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut2 {
+            return match fut.poll() {
+                Ok(Async::Ready(res)) => Ok(Async::Ready(ServiceResponse::new(
+                    self.req.take().unwrap(),
+                    res,
+                ))),
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(e) => {
+                    let res: Response = e.into().into();
+                    Ok(Async::Ready(ServiceResponse::new(
+                        self.req.take().unwrap(),
+                        res,
+                    )))
+                }
+            };
+        }
+
         match self.fut.poll() {
-            Ok(Async::Ready(res)) => Ok(Async::Ready(ServiceResponse::new(
-                self.req.take().unwrap(),
-                res.into(),
-            ))),
+            Ok(Async::Ready(res)) => {
+                self.fut2 =
+                    Some(res.respond_to(self.req.as_ref().unwrap()).into_future());
+                return self.poll();
+            }
             Ok(Async::NotReady) => Ok(Async::NotReady),
             Err(e) => {
                 let res: Response = e.into().into();
@@ -357,7 +381,7 @@ macro_rules! factory_tuple ({ $(($n:tt, $T:ident)),+} => {
     impl<Func, $($T,)+ Res> AsyncFactory<($($T,)+), Res> for Func
     where Func: Fn($($T,)+) -> Res + Clone + 'static,
           Res: IntoFuture,
-          Res::Item: Into<Response>,
+          Res::Item: Responder,
           Res::Error: Into<Error>,
     {
         fn call(&self, param: ($($T,)+)) -> Res {

src/middleware/identity.rs

@@ -49,10 +49,12 @@
 //! ```
 use std::cell::RefCell;
 use std::rc::Rc;
+use std::time::SystemTime;
 
 use actix_service::{Service, Transform};
 use futures::future::{ok, Either, FutureResult};
 use futures::{Future, IntoFuture, Poll};
+use serde::{Deserialize, Serialize};
 use time::Duration;
 
 use crate::cookie::{Cookie, CookieJar, Key, SameSite};
@@ -284,84 +286,133 @@ where
 
 struct CookieIdentityInner {
     key: Key,
+    key_v2: Key,
     name: String,
     path: String,
     domain: Option<String>,
     secure: bool,
     max_age: Option<Duration>,
     same_site: Option<SameSite>,
+    visit_deadline: Option<Duration>,
+    login_deadline: Option<Duration>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct CookieValue {
+    identity: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    login_timestamp: Option<SystemTime>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    visit_timestamp: Option<SystemTime>,
+}
+
+#[derive(Debug)]
+struct CookieIdentityExtention {
+    login_timestamp: Option<SystemTime>
 }
 
 impl CookieIdentityInner {
     fn new(key: &[u8]) -> CookieIdentityInner {
+        let key_v2: Vec<u8> = 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),
             name: "actix-identity".to_owned(),
             path: "/".to_owned(),
             domain: None,
             secure: true,
             max_age: None,
             same_site: None,
+            visit_deadline: None,
+            login_deadline: None,
         }
     }
 
     fn set_cookie<B>(
         &self,
         resp: &mut ServiceResponse<B>,
-        id: Option<String>,
+        value: Option<CookieValue>,
     ) -> Result<()> {
-        let some = id.is_some();
-        {
-            let id = id.unwrap_or_else(String::new);
-            let mut cookie = Cookie::new(self.name.clone(), id);
-            cookie.set_path(self.path.clone());
-            cookie.set_secure(self.secure);
-            cookie.set_http_only(true);
+        let add_cookie = value.is_some();
+        let val = value.map(|val| if !self.legacy_supported() {
+            serde_json::to_string(&val)
+        } else {
+            Ok(val.identity)
+        });
+        let mut cookie = Cookie::new(self.name.clone(), val.unwrap_or_else(|| Ok(String::new()))?);
+        cookie.set_path(self.path.clone());
+        cookie.set_secure(self.secure);
+        cookie.set_http_only(true);
 
-            if let Some(ref domain) = self.domain {
-                cookie.set_domain(domain.clone());
-            }
-
-            if let Some(max_age) = self.max_age {
-                cookie.set_max_age(max_age);
-            }
-
-            if let Some(same_site) = self.same_site {
-                cookie.set_same_site(same_site);
-            }
-
-            let mut jar = CookieJar::new();
-            if some {
-                jar.private(&self.key).add(cookie);
-            } else {
-                jar.add_original(cookie.clone());
-                jar.private(&self.key).remove(cookie);
-            }
-
-            for cookie in jar.delta() {
-                let val = HeaderValue::from_str(&cookie.to_string())?;
-                resp.headers_mut().append(header::SET_COOKIE, val);
-            }
+        if let Some(ref domain) = self.domain {
+            cookie.set_domain(domain.clone());
         }
 
+        if let Some(max_age) = self.max_age {
+            cookie.set_max_age(max_age);
+        }
+
+        if let Some(same_site) = self.same_site {
+            cookie.set_same_site(same_site);
+        }
+
+        let mut jar = CookieJar::new();
+        let key = if self.legacy_supported() {&self.key} else {&self.key_v2};
+        if add_cookie {
+            jar.private(&key).add(cookie);
+        } else {
+            jar.add_original(cookie.clone());
+            jar.private(&key).remove(cookie);
+        }
+        for cookie in jar.delta() {
+            let val = HeaderValue::from_str(&cookie.to_string())?;
+            resp.headers_mut().append(header::SET_COOKIE, val);
+        }
         Ok(())
     }
 
-    fn load(&self, req: &ServiceRequest) -> Option<String> {
-        if let Ok(cookies) = req.cookies() {
-            for cookie in cookies.iter() {
-                if cookie.name() == self.name {
-                    let mut jar = CookieJar::new();
-                    jar.add_original(cookie.clone());
+    fn load(&self, req: &ServiceRequest) -> Option<CookieValue> {
+        let cookie = req.cookie(&self.name)?;
+        let mut jar = CookieJar::new();
+        jar.add_original(cookie.clone());
+        let res = if self.legacy_supported() {
+            jar.private(&self.key).get(&self.name).map(|n| CookieValue {
+                identity: n.value().to_string(),
+                login_timestamp: None,
+                visit_timestamp: None
+            })
+        } else {
+            None
+        };
+        res.or_else(|| jar.private(&self.key_v2).get(&self.name).and_then(|c| self.parse(c)))
+    }
 
-                    let cookie_opt = jar.private(&self.key).get(&self.name);
-                    if let Some(cookie) = cookie_opt {
-                        return Some(cookie.value().into());
-                    }
-                }
+    fn parse(&self, cookie: Cookie) -> Option<CookieValue> {
+        let value: CookieValue = serde_json::from_str(cookie.value()).ok()?;
+        let now = SystemTime::now();
+        if let Some(visit_deadline) = self.visit_deadline {
+            if now.duration_since(value.visit_timestamp?).ok()? > visit_deadline.to_std().ok()? {
+                return None;
             }
         }
-        None
+        if let Some(login_deadline) = self.login_deadline {
+            if now.duration_since(value.login_timestamp?).ok()? > login_deadline.to_std().ok()? {
+                return None;
+            }
+        }
+        Some(value)
+    }
+
+    fn legacy_supported(&self) -> bool {
+        self.visit_deadline.is_none() && self.login_deadline.is_none()
+    }
+
+    fn always_update_cookie(&self) -> bool {
+        self.visit_deadline.is_some()
+    }
+
+    fn requires_oob_data(&self) -> bool {
+        self.login_deadline.is_some()
     }
 }
 
@@ -427,8 +478,13 @@ impl CookieIdentityPolicy {
         self
     }
 
-    /// Sets the `max-age` field in the session cookie being built.
-    pub fn max_age(mut self, value: Duration) -> CookieIdentityPolicy {
+    /// Sets the `max-age` field in the session cookie being built with given number of seconds.
+    pub fn max_age(self, seconds: i64) -> CookieIdentityPolicy {
+        self.max_age_time(Duration::seconds(seconds))
+    }
+
+    /// Sets the `max-age` field in the session cookie being built with `chrono::Duration`.
+    pub fn max_age_time(mut self, value: Duration) -> CookieIdentityPolicy {
         Rc::get_mut(&mut self.0).unwrap().max_age = Some(value);
         self
     }
@@ -438,6 +494,18 @@ impl CookieIdentityPolicy {
         Rc::get_mut(&mut self.0).unwrap().same_site = Some(same_site);
         self
     }
+
+    /// Accepts only users whose cookie has been seen before the given deadline
+    pub fn visit_deadline(mut self, value: Duration) -> CookieIdentityPolicy {
+        Rc::get_mut(&mut self.0).unwrap().visit_deadline = Some(value);
+        self
+    }
+
+    /// Accepts only users which has been authenticated before the given deadline
+    pub fn login_deadline(mut self, value: Duration) -> CookieIdentityPolicy {
+        Rc::get_mut(&mut self.0).unwrap().login_deadline = Some(value);
+        self
+    }
 }
 
 impl IdentityPolicy for CookieIdentityPolicy {
@@ -445,7 +513,12 @@ impl IdentityPolicy for CookieIdentityPolicy {
     type ResponseFuture = Result<(), Error>;
 
     fn from_request(&self, req: &mut ServiceRequest) -> Self::Future {
-        Ok(self.0.load(req))
+        Ok(self.0.load(req).map(|CookieValue {identity, login_timestamp, ..}| {
+            if self.0.requires_oob_data() {
+               req.extensions_mut().insert(CookieIdentityExtention { login_timestamp });
+            }
+            identity
+        }))
     }
 
     fn to_response<B>(
@@ -454,9 +527,28 @@ impl IdentityPolicy for CookieIdentityPolicy {
         changed: bool,
         res: &mut ServiceResponse<B>,
     ) -> Self::ResponseFuture {
-        if changed {
-            let _ = self.0.set_cookie(res, id);
-        }
+        let _ = if changed {
+            let login_timestamp = SystemTime::now();
+            self.0.set_cookie(res, id.map(|identity| CookieValue {
+                identity,
+                login_timestamp: self.0.login_deadline.map(|_| login_timestamp),
+                visit_timestamp: self.0.visit_deadline.map(|_| login_timestamp)
+            }))
+        } else if self.0.always_update_cookie() && id.is_some() {
+            let visit_timestamp = SystemTime::now();
+            let mut login_timestamp = None;
+            if self.0.requires_oob_data() {
+                let CookieIdentityExtention { login_timestamp: lt } = res.request().extensions_mut().remove().unwrap();
+                login_timestamp = lt;
+            }
+            self.0.set_cookie(res, Some(CookieValue {
+                identity: id.unwrap(),
+                login_timestamp,
+                visit_timestamp: self.0.visit_deadline.map(|_| visit_timestamp)
+            }))
+        } else {
+            Ok(())
+        };
         Ok(())
     }
 }
@@ -468,14 +560,20 @@ mod tests {
     use crate::test::{self, TestRequest};
     use crate::{web, App, HttpResponse};
 
+    use std::borrow::Borrow;
+
+    const COOKIE_KEY_MASTER: [u8; 32] = [0; 32];
+    const COOKIE_NAME: &'static str = "actix_auth";
+    const COOKIE_LOGIN: &'static str = "test";
+
     #[test]
     fn test_identity() {
         let mut srv = test::init_service(
             App::new()
                 .wrap(IdentityService::new(
-                    CookieIdentityPolicy::new(&[0; 32])
+                    CookieIdentityPolicy::new(&COOKIE_KEY_MASTER)
                         .domain("www.rust-lang.org")
-                        .name("actix_auth")
+                        .name(COOKIE_NAME)
                         .path("/")
                         .secure(true),
                 ))
@@ -487,7 +585,7 @@ mod tests {
                     }
                 }))
                 .service(web::resource("/login").to(|id: Identity| {
-                    id.remember("test".to_string());
+                    id.remember(COOKIE_LOGIN.to_string());
                     HttpResponse::Ok()
                 }))
                 .service(web::resource("/logout").to(|id: Identity| {
@@ -525,4 +623,289 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
         assert!(resp.headers().contains_key(header::SET_COOKIE))
     }
+
+    #[test]
+    fn test_identity_max_age_time() {
+        let duration = Duration::days(1);
+        let mut srv = test::init_service(
+            App::new()
+                .wrap(IdentityService::new(
+                    CookieIdentityPolicy::new(&COOKIE_KEY_MASTER)
+                        .domain("www.rust-lang.org")
+                        .name(COOKIE_NAME)
+                        .path("/")
+                        .max_age_time(duration)
+                        .secure(true),
+                ))
+                .service(web::resource("/login").to(|id: Identity| {
+                    id.remember("test".to_string());
+                    HttpResponse::Ok()
+                })),
+        );
+        let resp =
+            test::call_service(&mut srv, TestRequest::with_uri("/login").to_request());
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert!(resp.headers().contains_key(header::SET_COOKIE));
+        let c = resp.response().cookies().next().unwrap().to_owned();
+        assert_eq!(duration, c.max_age().unwrap());
+    }
+
+    #[test]
+    fn test_identity_max_age() {
+        let seconds = 60;
+        let mut srv = test::init_service(
+            App::new()
+                .wrap(IdentityService::new(
+                    CookieIdentityPolicy::new(&COOKIE_KEY_MASTER)
+                        .domain("www.rust-lang.org")
+                        .name(COOKIE_NAME)
+                        .path("/")
+                        .max_age(seconds)
+                        .secure(true),
+                ))
+                .service(web::resource("/login").to(|id: Identity| {
+                    id.remember("test".to_string());
+                    HttpResponse::Ok()
+                })),
+        );
+        let resp =
+            test::call_service(&mut srv, TestRequest::with_uri("/login").to_request());
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert!(resp.headers().contains_key(header::SET_COOKIE));
+        let c = resp.response().cookies().next().unwrap().to_owned();
+        assert_eq!(Duration::seconds(seconds as i64), c.max_age().unwrap());
+    }
+
+    fn create_identity_server<F: Fn(CookieIdentityPolicy) -> CookieIdentityPolicy + Sync + Send + Clone + 'static>(f: F) -> impl actix_service::Service<Request = actix_http::Request, Response = ServiceResponse<actix_http::body::Body>, Error = actix_http::Error> {
+        test::init_service(
+            App::new()
+                .wrap(IdentityService::new(f(CookieIdentityPolicy::new(&COOKIE_KEY_MASTER).secure(false).name(COOKIE_NAME))))
+                .service(web::resource("/").to(|id: Identity| {
+                    let identity = id.identity();
+                    if identity.is_none() {
+                        id.remember(COOKIE_LOGIN.to_string())
+                    }
+                    web::Json(identity)
+                }))
+        )
+    }
+
+    fn legacy_login_cookie(identity: &'static str) -> Cookie<'static> {
+        let mut jar = CookieJar::new();
+        jar.private(&Key::from_master(&COOKIE_KEY_MASTER)).add(Cookie::new(COOKIE_NAME, identity));
+        jar.get(COOKIE_NAME).unwrap().clone()
+    }
+
+    fn login_cookie(identity: &'static str, login_timestamp: Option<SystemTime>, visit_timestamp: Option<SystemTime>) -> Cookie<'static> {
+        let mut jar = CookieJar::new();
+        let key: Vec<u8> = COOKIE_KEY_MASTER.iter().chain([1, 0, 0, 0].iter()).map(|e| *e).collect();
+        jar.private(&Key::from_master(&key)).add(Cookie::new(COOKIE_NAME, serde_json::to_string(&CookieValue {
+            identity: identity.to_string(),
+            login_timestamp,
+            visit_timestamp
+        }).unwrap()));
+        jar.get(COOKIE_NAME).unwrap().clone()
+    }
+
+    fn assert_logged_in(response: &mut ServiceResponse, identity: Option<&str>) {
+        use bytes::BytesMut;
+        use futures::Stream;
+        let bytes =
+            test::block_on(response.take_body().fold(BytesMut::new(), |mut b, c| {
+                b.extend(c);
+                Ok::<_, Error>(b)
+            }))
+            .unwrap();
+        let resp: Option<String> = serde_json::from_slice(&bytes[..]).unwrap();
+        assert_eq!(resp.as_ref().map(|s| s.borrow()), identity);
+    }
+
+    fn assert_legacy_login_cookie(response: &mut ServiceResponse, identity: &str) {
+        let mut cookies = CookieJar::new();
+        for cookie in response.headers().get_all(header::SET_COOKIE) {
+            cookies.add(Cookie::parse(cookie.to_str().unwrap().to_string()).unwrap());
+        }
+        let cookie = cookies.private(&Key::from_master(&COOKIE_KEY_MASTER)).get(COOKIE_NAME).unwrap();
+        assert_eq!(cookie.value(), identity);
+    }
+
+    enum LoginTimestampCheck {
+        NoTimestamp,
+        NewTimestamp,
+        OldTimestamp(SystemTime)
+    }
+
+    enum VisitTimeStampCheck {
+        NoTimestamp,
+        NewTimestamp
+    }
+
+    fn assert_login_cookie(response: &mut ServiceResponse, identity: &str, login_timestamp: LoginTimestampCheck, visit_timestamp: VisitTimeStampCheck) {
+        let mut cookies = CookieJar::new();
+        for cookie in response.headers().get_all(header::SET_COOKIE) {
+            cookies.add(Cookie::parse(cookie.to_str().unwrap().to_string()).unwrap());
+        }
+        let key: Vec<u8> = COOKIE_KEY_MASTER.iter().chain([1, 0, 0, 0].iter()).map(|e| *e).collect();
+        let cookie = cookies.private(&Key::from_master(&key)).get(COOKIE_NAME).unwrap();
+        let cv: CookieValue = serde_json::from_str(cookie.value()).unwrap();
+        assert_eq!(cv.identity, identity);
+        let now = SystemTime::now();
+        let t30sec_ago = now - Duration::seconds(30).to_std().unwrap();
+        match login_timestamp {
+            LoginTimestampCheck::NoTimestamp => assert_eq!(cv.login_timestamp, None),
+            LoginTimestampCheck::NewTimestamp => assert!(t30sec_ago <= cv.login_timestamp.unwrap() && cv.login_timestamp.unwrap() <= now),
+            LoginTimestampCheck::OldTimestamp(old_timestamp) => assert_eq!(cv.login_timestamp, Some(old_timestamp))
+        }
+        match visit_timestamp {
+            VisitTimeStampCheck::NoTimestamp => assert_eq!(cv.visit_timestamp, None),
+            VisitTimeStampCheck::NewTimestamp => assert!(t30sec_ago <= cv.visit_timestamp.unwrap() && cv.visit_timestamp.unwrap() <= now)
+        }
+    }
+
+    fn assert_no_login_cookie(response: &mut ServiceResponse) {
+        let mut cookies = CookieJar::new();
+        for cookie in response.headers().get_all(header::SET_COOKIE) {
+            cookies.add(Cookie::parse(cookie.to_str().unwrap().to_string()).unwrap());
+        }
+        assert!(cookies.get(COOKIE_NAME).is_none());
+    }
+
+    #[test]
+    fn test_identity_legacy_cookie_is_set() {
+        let mut srv = create_identity_server(|c| c);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_legacy_login_cookie(&mut resp, COOKIE_LOGIN);
+    }
+
+    #[test]
+    fn test_identity_legacy_cookie_works() {
+        let mut srv = create_identity_server(|c| c);
+        let cookie = legacy_login_cookie(COOKIE_LOGIN);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, Some(COOKIE_LOGIN));
+        assert_no_login_cookie(&mut resp);
+    }
+
+    #[test]
+    fn test_identity_legacy_cookie_rejected_if_visit_timestamp_needed() {
+        let mut srv = create_identity_server(|c| c.visit_deadline(Duration::days(90)));
+        let cookie = legacy_login_cookie(COOKIE_LOGIN);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NoTimestamp, VisitTimeStampCheck::NewTimestamp);
+    }
+
+    #[test]
+    fn test_identity_legacy_cookie_rejected_if_login_timestamp_needed() {
+        let mut srv = create_identity_server(|c| c.login_deadline(Duration::days(90)));
+        let cookie = legacy_login_cookie(COOKIE_LOGIN);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NewTimestamp, VisitTimeStampCheck::NoTimestamp);
+    }
+
+    #[test]
+    fn test_identity_cookie_rejected_if_login_timestamp_needed() {
+        let mut srv = create_identity_server(|c| c.login_deadline(Duration::days(90)));
+        let cookie = login_cookie(COOKIE_LOGIN, None, Some(SystemTime::now()));
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NewTimestamp, VisitTimeStampCheck::NoTimestamp);
+    }
+
+    #[test]
+    fn test_identity_cookie_rejected_if_visit_timestamp_needed() {
+        let mut srv = create_identity_server(|c| c.visit_deadline(Duration::days(90)));
+        let cookie = login_cookie(COOKIE_LOGIN, Some(SystemTime::now()), None);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NoTimestamp, VisitTimeStampCheck::NewTimestamp);
+    }
+
+    #[test]
+    fn test_identity_cookie_rejected_if_login_timestamp_too_old() {
+        let mut srv = create_identity_server(|c| c.login_deadline(Duration::days(90)));
+        let cookie = login_cookie(COOKIE_LOGIN, Some(SystemTime::now() - Duration::days(180).to_std().unwrap()), None);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NewTimestamp, VisitTimeStampCheck::NoTimestamp);
+    }
+
+    #[test]
+    fn test_identity_cookie_rejected_if_visit_timestamp_too_old() {
+        let mut srv = create_identity_server(|c| c.visit_deadline(Duration::days(90)));
+        let cookie = login_cookie(COOKIE_LOGIN, None, Some(SystemTime::now() - Duration::days(180).to_std().unwrap()));
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, None);
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::NoTimestamp, VisitTimeStampCheck::NewTimestamp);
+    }
+
+    #[test]
+    fn test_identity_cookie_not_updated_on_login_deadline() {
+        let mut srv = create_identity_server(|c| c.login_deadline(Duration::days(90)));
+        let cookie = login_cookie(COOKIE_LOGIN, Some(SystemTime::now()), None);
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, Some(COOKIE_LOGIN));
+        assert_no_login_cookie(&mut resp);
+    }
+
+    #[test]
+    fn test_identity_cookie_updated_on_visit_deadline() {
+        let mut srv = create_identity_server(|c| c.visit_deadline(Duration::days(90)).login_deadline(Duration::days(90)));
+        let timestamp = SystemTime::now() - Duration::days(1).to_std().unwrap();
+        let cookie = login_cookie(COOKIE_LOGIN, Some(timestamp), Some(timestamp));
+        let mut resp = test::call_service(
+            &mut srv,
+            TestRequest::with_uri("/")
+                .cookie(cookie.clone())
+                .to_request()
+        );
+        assert_logged_in(&mut resp, Some(COOKIE_LOGIN));
+        assert_login_cookie(&mut resp, COOKIE_LOGIN, LoginTimestampCheck::OldTimestamp(timestamp), VisitTimeStampCheck::NewTimestamp);
+    }
 }

src/middleware/mod.rs

@@ -6,9 +6,11 @@ pub mod cors;
 mod defaultheaders;
 pub mod errhandlers;
 mod logger;
+mod normalize;
 
 pub use self::defaultheaders::DefaultHeaders;
 pub use self::logger::Logger;
+pub use self::normalize::NormalizePath;
 
 #[cfg(feature = "secure-cookies")]
 pub mod identity;

src/middleware/normalize.rs

@@ -0,0 +1,108 @@
+//! `Middleware` to normalize request's URI
+
+use actix_service::{Service, Transform};
+use futures::future::{self, FutureResult};
+use regex::Regex;
+
+use crate::service::{ServiceRequest, ServiceResponse};
+
+#[derive(Default, Clone, Copy)]
+/// `Middleware` to normalize request's URI in place
+///
+/// Performs following:
+///
+/// - Merges multiple slashes into one.
+pub struct NormalizePath;
+
+impl<S> Transform<S> for NormalizePath
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse>,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse;
+    type Error = S::Error;
+    type InitError = ();
+    type Transform = NormalizePathNormalization<S>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        future::ok(NormalizePathNormalization {
+            service,
+            merge_slash: Regex::new("//+").unwrap(),
+        })
+    }
+}
+
+pub struct NormalizePathNormalization<S> {
+    service: S,
+    merge_slash: Regex,
+}
+
+impl<S> Service for NormalizePathNormalization<S>
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse>,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
+        self.service.poll_ready()
+    }
+
+    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
+        let head = req.head_mut();
+
+        let path = head.uri.path();
+        let original_len = path.len();
+        let path = self.merge_slash.replace_all(path, "/");
+
+        if original_len != path.len() {
+            head.uri = path.parse().unwrap();
+        }
+
+        self.service.call(req)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_service::FnService;
+
+    use super::*;
+    use crate::dev::ServiceRequest;
+    use crate::test::{block_on, TestRequest};
+    use crate::HttpResponse;
+
+    #[test]
+    fn test_in_place_normalization() {
+        let srv = FnService::new(|req: ServiceRequest| {
+            assert_eq!("/v1/something/", req.path());
+            req.into_response(HttpResponse::Ok().finish())
+        });
+
+        let mut normalize = block_on(NormalizePath.new_transform(srv)).unwrap();
+
+        let req = TestRequest::with_uri("/v1//something////").to_srv_request();
+        let res = block_on(normalize.call(req)).unwrap();
+        assert!(res.status().is_success());
+    }
+
+    #[test]
+    fn should_normalize_nothing() {
+        const URI: &str = "/v1/something/";
+
+        let srv = FnService::new(|req: ServiceRequest| {
+            assert_eq!(URI, req.path());
+            req.into_response(HttpResponse::Ok().finish())
+        });
+
+        let mut normalize = block_on(NormalizePath.new_transform(srv)).unwrap();
+
+        let req = TestRequest::with_uri(URI).to_srv_request();
+        let res = block_on(normalize.call(req)).unwrap();
+        assert!(res.status().is_success());
+    }
+
+}

src/resource.rs

@@ -217,7 +217,7 @@ where
         F: AsyncFactory<I, R>,
         I: FromRequest + 'static,
         R: IntoFuture + 'static,
-        R::Item: Into<Response>,
+        R::Item: Responder,
         R::Error: Into<Error>,
     {
         self.routes.push(Route::new().to_async(handler));

src/responder.rs

@@ -1,8 +1,12 @@
 use actix_http::error::InternalError;
-use actix_http::{http::StatusCode, Error, Response, ResponseBuilder};
+use actix_http::http::{
+    header::IntoHeaderValue, Error as HttpError, HeaderMap, HeaderName, HttpTryFrom,
+    StatusCode,
+};
+use actix_http::{Error, Response, ResponseBuilder};
 use bytes::{Bytes, BytesMut};
 use futures::future::{err, ok, Either as EitherFuture, FutureResult};
-use futures::{Future, IntoFuture, Poll};
+use futures::{try_ready, Async, Future, IntoFuture, Poll};
 
 use crate::request::HttpRequest;
 
@@ -18,6 +22,51 @@ pub trait Responder {
 
     /// Convert itself to `AsyncResult` or `Error`.
     fn respond_to(self, req: &HttpRequest) -> Self::Future;
+
+    /// Override a status code for a responder.
+    ///
+    /// ```rust
+    /// use actix_web::{HttpRequest, Responder, http::StatusCode};
+    ///
+    /// fn index(req: HttpRequest) -> impl Responder {
+    ///     "Welcome!".with_status(StatusCode::OK)
+    /// }
+    /// # fn main() {}
+    /// ```
+    fn with_status(self, status: StatusCode) -> CustomResponder<Self>
+    where
+        Self: Sized,
+    {
+        CustomResponder::new(self).with_status(status)
+    }
+
+    /// Add extra header to the responder's response.
+    ///
+    /// ```rust
+    /// use actix_web::{web, HttpRequest, Responder};
+    /// use serde::Serialize;
+    ///
+    /// #[derive(Serialize)]
+    /// struct MyObj {
+    ///     name: String,
+    /// }
+    ///
+    /// fn index(req: HttpRequest) -> impl Responder {
+    ///     web::Json(
+    ///         MyObj{name: "Name".to_string()}
+    ///     )
+    ///     .with_header("x-version", "1.2.3")
+    /// }
+    /// # fn main() {}
+    /// ```
+    fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self>
+    where
+        Self: Sized,
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        CustomResponder::new(self).with_header(key, value)
+    }
 }
 
 impl Responder for Response {
@@ -154,6 +203,117 @@ impl Responder for BytesMut {
     }
 }
 
+/// Allows to override status code and headers for a responder.
+pub struct CustomResponder<T> {
+    responder: T,
+    status: Option<StatusCode>,
+    headers: Option<HeaderMap>,
+    error: Option<HttpError>,
+}
+
+impl<T: Responder> CustomResponder<T> {
+    fn new(responder: T) -> Self {
+        CustomResponder {
+            responder,
+            status: None,
+            headers: None,
+            error: None,
+        }
+    }
+
+    /// Override a status code for the responder's response.
+    ///
+    /// ```rust
+    /// use actix_web::{HttpRequest, Responder, http::StatusCode};
+    ///
+    /// fn index(req: HttpRequest) -> impl Responder {
+    ///     "Welcome!".with_status(StatusCode::OK)
+    /// }
+    /// # fn main() {}
+    /// ```
+    pub fn with_status(mut self, status: StatusCode) -> Self {
+        self.status = Some(status);
+        self
+    }
+
+    /// Add extra header to the responder's response.
+    ///
+    /// ```rust
+    /// use actix_web::{web, HttpRequest, Responder};
+    /// use serde::Serialize;
+    ///
+    /// #[derive(Serialize)]
+    /// struct MyObj {
+    ///     name: String,
+    /// }
+    ///
+    /// fn index(req: HttpRequest) -> impl Responder {
+    ///     web::Json(
+    ///         MyObj{name: "Name".to_string()}
+    ///     )
+    ///     .with_header("x-version", "1.2.3")
+    /// }
+    /// # fn main() {}
+    /// ```
+    pub fn with_header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        if self.headers.is_none() {
+            self.headers = Some(HeaderMap::new());
+        }
+
+        match HeaderName::try_from(key) {
+            Ok(key) => match value.try_into() {
+                Ok(value) => {
+                    self.headers.as_mut().unwrap().append(key, value);
+                }
+                Err(e) => self.error = Some(e.into()),
+            },
+            Err(e) => self.error = Some(e.into()),
+        };
+        self
+    }
+}
+
+impl<T: Responder> Responder for CustomResponder<T> {
+    type Error = T::Error;
+    type Future = CustomResponderFut<T>;
+
+    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+        CustomResponderFut {
+            fut: self.responder.respond_to(req).into_future(),
+            status: self.status,
+            headers: self.headers,
+        }
+    }
+}
+
+pub struct CustomResponderFut<T: Responder> {
+    fut: <T::Future as IntoFuture>::Future,
+    status: Option<StatusCode>,
+    headers: Option<HeaderMap>,
+}
+
+impl<T: Responder> Future for CustomResponderFut<T> {
+    type Item = Response;
+    type Error = T::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let mut res = try_ready!(self.fut.poll());
+        if let Some(status) = self.status {
+            *res.status_mut() = status;
+        }
+        if let Some(ref headers) = self.headers {
+            for (k, v) in headers {
+                res.headers_mut().insert(k.clone(), v.clone());
+            }
+        }
+        Ok(Async::Ready(res))
+    }
+}
+
 /// Combines two different responder types into a single type
 ///
 /// ```rust
@@ -307,11 +467,11 @@ pub(crate) mod tests {
         );
 
         let req = TestRequest::with_uri("/none").to_request();
-        let resp = TestRequest::block_on(srv.call(req)).unwrap();
+        let resp = block_on(srv.call(req)).unwrap();
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
         let req = TestRequest::with_uri("/some").to_request();
-        let resp = TestRequest::block_on(srv.call(req)).unwrap();
+        let resp = block_on(srv.call(req)).unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
         match resp.response().body() {
             ResponseBody::Body(Body::Bytes(ref b)) => {
@@ -435,4 +595,33 @@ pub(crate) mod tests {
         );
         assert!(res.is_err());
     }
+
+    #[test]
+    fn test_custom_responder() {
+        let req = TestRequest::default().to_http_request();
+        let res = block_on(
+            "test"
+                .to_string()
+                .with_status(StatusCode::BAD_REQUEST)
+                .respond_to(&req),
+        )
+        .unwrap();
+        assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+        assert_eq!(res.body().bin_ref(), b"test");
+
+        let res = block_on(
+            "test"
+                .to_string()
+                .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/route.rs

@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use actix_http::{http::Method, Error, Extensions, Response};
+use actix_http::{http::Method, Error, Extensions};
 use actix_service::{NewService, Service};
 use futures::future::{ok, Either, FutureResult};
 use futures::{Async, Future, IntoFuture, Poll};
@@ -278,7 +278,7 @@ impl Route {
         F: AsyncFactory<T, R>,
         T: FromRequest + 'static,
         R: IntoFuture + 'static,
-        R::Item: Into<Response>,
+        R::Item: Responder,
         R::Error: Into<Error>,
     {
         self.service = Box::new(RouteNewService::new(Extract::new(
@@ -418,18 +418,25 @@ where
 mod tests {
     use std::time::Duration;
 
+    use bytes::Bytes;
     use futures::Future;
+    use serde_derive::Serialize;
     use tokio_timer::sleep;
 
     use crate::http::{Method, StatusCode};
-    use crate::test::{call_service, init_service, TestRequest};
+    use crate::test::{call_service, init_service, read_body, TestRequest};
     use crate::{error, web, App, HttpResponse};
 
+    #[derive(Serialize, PartialEq, Debug)]
+    struct MyObject {
+        name: String,
+    }
+
     #[test]
     fn test_route() {
-        let mut srv =
-            init_service(
-                App::new().service(
+        let mut srv = init_service(
+            App::new()
+                .service(
                     web::resource("/test")
                         .route(web::get().to(|| HttpResponse::Ok()))
                         .route(web::put().to(|| {
@@ -444,8 +451,15 @@ mod tests {
                                 Err::<HttpResponse, _>(error::ErrorBadRequest("err"))
                             })
                         })),
-                ),
-            );
+                )
+                .service(web::resource("/json").route(web::get().to_async(|| {
+                    sleep(Duration::from_millis(25)).then(|_| {
+                        Ok::<_, crate::Error>(web::Json(MyObject {
+                            name: "test".to_string(),
+                        }))
+                    })
+                }))),
+        );
 
         let req = TestRequest::with_uri("/test")
             .method(Method::GET)
@@ -476,5 +490,12 @@ mod tests {
             .to_request();
         let resp = call_service(&mut srv, req);
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+
+        let req = TestRequest::with_uri("/json").to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let body = read_body(resp);
+        assert_eq!(body, Bytes::from_static(b"{\"name\":\"test\"}"));
     }
 }

src/service.rs

@@ -53,7 +53,7 @@ pub struct ServiceRequest {
 
 impl ServiceRequest {
     /// Construct service request from parts
-    pub fn from_parts(req: HttpRequest, payload: Payload) -> Self {
+    pub(crate) fn from_parts(req: HttpRequest, payload: Payload) -> Self {
         ServiceRequest { req, payload }
     }
 

src/test.rs

@@ -58,7 +58,7 @@ where
 /// This function panics on nested call.
 pub fn run_on<F, R>(f: F) -> R
 where
-    F: Fn() -> R,
+    F: FnOnce() -> R,
 {
     RT.with(move |rt| rt.borrow_mut().block_on(lazy(|| Ok::<_, ()>(f()))))
         .unwrap()
@@ -117,7 +117,9 @@ where
     S::InitError: std::fmt::Debug,
 {
     let cfg = ServerConfig::new("127.0.0.1:8080".parse().unwrap());
-    block_on(app.into_new_service().new_service(&cfg)).unwrap()
+    let srv = app.into_new_service();
+    let fut = run_on(move || srv.new_service(&cfg));
+    block_on(fut).unwrap()
 }
 
 /// Calls service and waits for response future completion.
@@ -146,7 +148,7 @@ where
     S: Service<Request = R, Response = ServiceResponse<B>, Error = E>,
     E: std::fmt::Debug,
 {
-    block_on(app.call(req)).unwrap()
+    block_on(run_on(move || app.call(req))).unwrap()
 }
 
 /// Helper function that returns a response body of a TestRequest
@@ -178,8 +180,50 @@ where
     S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody,
 {
-    block_on(app.call(req).and_then(|mut resp: ServiceResponse<B>| {
-        resp.take_body()
+    block_on(run_on(move || {
+        app.call(req).and_then(|mut resp: ServiceResponse<B>| {
+            resp.take_body()
+                .fold(BytesMut::new(), move |mut body, chunk| {
+                    body.extend_from_slice(&chunk);
+                    Ok::<_, Error>(body)
+                })
+                .map(|body: BytesMut| body.freeze())
+        })
+    }))
+    .unwrap_or_else(|_| panic!("read_response failed at block_on unwrap"))
+}
+
+/// Helper function that returns a response body of a ServiceResponse.
+/// This function blocks the current thread until futures complete.
+///
+/// ```rust
+/// use actix_web::{test, web, App, HttpResponse, http::header};
+/// use bytes::Bytes;
+///
+/// #[test]
+/// fn test_index() {
+///     let mut app = test::init_service(
+///         App::new().service(
+///             web::resource("/index.html")
+///                 .route(web::post().to(
+///                     || HttpResponse::Ok().body("welcome!")))));
+///
+///     let req = test::TestRequest::post()
+///         .uri("/index.html")
+///         .header(header::CONTENT_TYPE, "application/json")
+///         .to_request();
+///
+///     let resp = call_service(&mut srv, req);
+///     let result = test::read_body(resp);
+///     assert_eq!(result, Bytes::from_static(b"welcome!"));
+/// }
+/// ```
+pub fn read_body<B>(mut res: ServiceResponse<B>) -> Bytes
+where
+    B: MessageBody,
+{
+    block_on(run_on(move || {
+        res.take_body()
             .fold(BytesMut::new(), move |mut body, chunk| {
                 body.extend_from_slice(&chunk);
                 Ok::<_, Error>(body)
@@ -229,17 +273,19 @@ where
     B: MessageBody,
     T: DeserializeOwned,
 {
-    block_on(app.call(req).and_then(|mut resp: ServiceResponse<B>| {
-        resp.take_body()
-            .fold(BytesMut::new(), move |mut body, chunk| {
-                body.extend_from_slice(&chunk);
-                Ok::<_, Error>(body)
-            })
-            .and_then(|body: BytesMut| {
-                ok(serde_json::from_slice(&body).unwrap_or_else(|_| {
-                    panic!("read_response_json failed during deserialization")
-                }))
-            })
+    block_on(run_on(move || {
+        app.call(req).and_then(|mut resp: ServiceResponse<B>| {
+            resp.take_body()
+                .fold(BytesMut::new(), move |mut body, chunk| {
+                    body.extend_from_slice(&chunk);
+                    Ok::<_, Error>(body)
+                })
+                .and_then(|body: BytesMut| {
+                    ok(serde_json::from_slice(&body).unwrap_or_else(|_| {
+                        panic!("read_response_json failed during deserialization")
+                    }))
+                })
+        })
     }))
     .unwrap_or_else(|_| panic!("read_response_json failed at block_on unwrap"))
 }
@@ -330,6 +376,16 @@ impl TestRequest {
         TestRequest::default().method(Method::POST)
     }
 
+    /// Create TestRequest and set method to `Method::PUT`
+    pub fn put() -> TestRequest {
+        TestRequest::default().method(Method::PUT)
+    }
+
+    /// Create TestRequest and set method to `Method::PATCH`
+    pub fn patch() -> TestRequest {
+        TestRequest::default().method(Method::PATCH)
+    }
+
     /// Set HTTP version of this request
     pub fn version(mut self, ver: Version) -> Self {
         self.req.version(ver);
@@ -460,23 +516,6 @@ impl TestRequest {
         req.set_route_data(Some(Rc::new(self.route_data)));
         (req, payload)
     }
-
-    /// Runs the provided future, blocking the current thread until the future
-    /// completes.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function is intended to be used only for testing purpose.
-    /// This function panics on nested call.
-    pub fn block_on<F>(f: F) -> Result<F::Item, F::Error>
-    where
-        F: Future,
-    {
-        block_on(f)
-    }
 }
 
 #[cfg(test)]
@@ -504,6 +543,33 @@ mod tests {
         assert_eq!(*data.get_ref(), 10);
     }
 
+    #[test]
+    fn test_request_methods() {
+        let mut app = init_service(
+            App::new().service(
+                web::resource("/index.html")
+                    .route(web::put().to(|| HttpResponse::Ok().body("put!")))
+                    .route(web::patch().to(|| HttpResponse::Ok().body("patch!"))),
+            ),
+        );
+
+        let put_req = TestRequest::put()
+            .uri("/index.html")
+            .header(header::CONTENT_TYPE, "application/json")
+            .to_request();
+
+        let result = read_response(&mut app, put_req);
+        assert_eq!(result, Bytes::from_static(b"put!"));
+
+        let patch_req = TestRequest::patch()
+            .uri("/index.html")
+            .header(header::CONTENT_TYPE, "application/json")
+            .to_request();
+
+        let result = read_response(&mut app, patch_req);
+        assert_eq!(result, Bytes::from_static(b"patch!"));
+    }
+
     #[test]
     fn test_response() {
         let mut app = init_service(

src/types/form.rs

@@ -331,10 +331,6 @@ mod tests {
 
     fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
         match err {
-            UrlencodedError::Chunked => match other {
-                UrlencodedError::Chunked => true,
-                _ => false,
-            },
             UrlencodedError::Overflow => match other {
                 UrlencodedError::Overflow => true,
                 _ => false,

src/types/path.rs

@@ -171,10 +171,25 @@ where
 #[cfg(test)]
 mod tests {
     use actix_router::ResourceDef;
+    use derive_more::Display;
+    use serde_derive::Deserialize;
 
     use super::*;
     use crate::test::{block_on, TestRequest};
 
+    #[derive(Deserialize, Debug, Display)]
+    #[display(fmt = "MyStruct({}, {})", key, value)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
     #[test]
     fn test_extract_path_single() {
         let resource = ResourceDef::new("/{value}/");
@@ -184,6 +199,7 @@ mod tests {
 
         let (req, mut pl) = req.into_parts();
         assert_eq!(*Path::<i8>::from_request(&req, &mut pl).unwrap(), 32);
+        assert!(Path::<MyStruct>::from_request(&req, &mut pl).is_err());
     }
 
     #[test]
@@ -213,4 +229,46 @@ mod tests {
         let () = <()>::from_request(&req, &mut pl).unwrap();
     }
 
+    #[test]
+    fn test_request_extract() {
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+
+        let resource = ResourceDef::new("/{key}/{value}/");
+        resource.match_path(req.match_info_mut());
+
+        let (req, mut pl) = req.into_parts();
+        let mut s = Path::<MyStruct>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+        s.value = "user2".to_string();
+        assert_eq!(s.value, "user2");
+        assert_eq!(
+            format!("{}, {:?}", s, s),
+            "MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
+        );
+        let s = s.into_inner();
+        assert_eq!(s.value, "user2");
+
+        let s = Path::<(String, String)>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
+        let resource = ResourceDef::new("/{key}/{value}/");
+        resource.match_path(req.match_info_mut());
+
+        let (req, mut pl) = req.into_parts();
+        let s = Path::<Test2>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.as_ref().key, "name");
+        assert_eq!(s.value, 32);
+
+        let s = Path::<(String, u8)>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res = Path::<Vec<String>>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
 }

src/types/query.rs

@@ -133,3 +133,35 @@ where
             })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use derive_more::Display;
+    use serde_derive::Deserialize;
+
+    use super::*;
+    use crate::test::TestRequest;
+
+    #[derive(Deserialize, Debug, Display)]
+    struct Id {
+        id: String,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let req = TestRequest::with_uri("/name/user1/").to_srv_request();
+        let (req, mut pl) = req.into_parts();
+        assert!(Query::<Id>::from_request(&req, &mut pl).is_err());
+
+        let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let (req, mut pl) = req.into_parts();
+
+        let mut s = Query::<Id>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.id, "test");
+        assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
+
+        s.id = "test1".to_string();
+        let s = s.into_inner();
+        assert_eq!(s.id, "test1");
+    }
+}

src/web.rs

@@ -1,5 +1,5 @@
 //! Essentials helper functions and types for application registration.
-use actix_http::{http::Method, Response};
+use actix_http::http::Method;
 use futures::{Future, IntoFuture};
 
 pub use actix_http::Response as HttpResponse;
@@ -268,7 +268,7 @@ where
     F: AsyncFactory<I, R>,
     I: FromRequest + 'static,
     R: IntoFuture + 'static,
-    R::Item: Into<Response>,
+    R::Item: Responder,
     R::Error: Into<Error>,
 {
     Route::new().to_async(handler)

test-server/CHANGES.md

@@ -1,5 +1,15 @@
 # Changes
 
+## [0.1.1] - 2019-04-24
+
+* Always make new connection for http client
+
+
+## [0.1.0] - 2019-04-16
+
+* No changes
+
+
 ## [0.1.0-alpha.3] - 2019-04-02
 
 * Request functions accept path #743

test-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "0.1.0-alpha.3"
+version = "0.1.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http test server"
 readme = "README.md"
@@ -33,9 +33,9 @@ ssl = ["openssl", "actix-server/ssl", "awc/ssl"]
 actix-codec = "0.1.2"
 actix-rt = "0.2.2"
 actix-service = "0.3.6"
-actix-server = "0.4.1"
+actix-server = "0.4.3"
 actix-utils = "0.3.5"
-awc = "0.1.0-alpha.5"
+awc = "0.1.1"
 
 base64 = "0.10"
 bytes = "0.4"
@@ -55,5 +55,5 @@ tokio-timer = "0.2"
 openssl = { version="0.10", optional = true }
 
 [dev-dependencies]
-actix-web = "1.0.0-alpha.5"
-actix-http = "0.1.0-alpha.5"
+actix-web = "1.0.0-beta.1"
+actix-http = "0.1.2"

test-server/src/lib.rs

@@ -124,6 +124,7 @@ impl TestServer {
                             |e| log::error!("Can not set alpn protocol: {:?}", e),
                         );
                         Connector::new()
+                            .conn_lifetime(time::Duration::from_secs(0))
                             .timeout(time::Duration::from_millis(500))
                             .ssl(builder.build())
                             .finish()
@@ -131,6 +132,7 @@ impl TestServer {
                     #[cfg(not(feature = "ssl"))]
                     {
                         Connector::new()
+                            .conn_lifetime(time::Duration::from_secs(0))
                             .timeout(time::Duration::from_millis(500))
                             .finish()
                     }
@@ -163,6 +165,15 @@ impl TestServerRuntime {
         self.rt.block_on(fut)
     }
 
+    /// Execute future on current core
+    pub fn block_on_fn<F, R>(&mut self, f: F) -> Result<R::Item, R::Error>
+    where
+        F: FnOnce() -> R,
+        R: Future,
+    {
+        self.rt.block_on(lazy(|| f()))
+    }
+
     /// Execute function on current core
     pub fn execute<F, R>(&mut self, fut: F) -> R
     where

tests/test_server.rs

@@ -17,7 +17,7 @@ use futures::stream::once;
 use rand::{distributions::Alphanumeric, Rng};
 
 use actix_web::middleware::{BodyEncoding, Compress};
-use actix_web::{http, test, web, App, HttpResponse, HttpServer};
+use actix_web::{dev, http, test, web, App, HttpResponse, HttpServer};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \
@@ -89,6 +89,39 @@ fn test_body_gzip() {
     assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
 }
 
+#[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
+#[test]
+fn test_body_gzip2() {
+    let mut srv = TestServer::new(|| {
+        h1::H1Service::new(
+            App::new()
+                .wrap(Compress::new(ContentEncoding::Gzip))
+                .service(web::resource("/").route(web::to(|| {
+                    Response::Ok().body(STR).into_body::<dev::Body>()
+                }))),
+        )
+    });
+
+    let mut response = srv
+        .block_on(
+            srv.get("/")
+                .no_decompress()
+                .header(ACCEPT_ENCODING, "gzip")
+                .send(),
+        )
+        .unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = srv.block_on(response.body()).unwrap();
+
+    // decode
+    let mut e = GzDecoder::new(&bytes[..]);
+    let mut dec = Vec::new();
+    e.read_to_end(&mut dec).unwrap();
+    assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
+}
+
 #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
 #[test]
 fn test_body_encoding_override() {