prepare actix-web-codegen release

web-codegen: Add extra-traits to syn features (#879 )
```rust error[E0277]: `syn::attr::NestedMeta` doesn't implement `std::fmt::Debug` --> src/route.rs:149:57 | 149 | attr => panic!("Unknown attribute{:?}", attr), | ^^^^ `syn::attr::NestedMeta` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` | = help: the trait `std::fmt::Debug` is not implemented for `syn::attr::NestedMeta` = note: required because of the requirements on the impl of `std::fmt::Debug` for `&syn::attr::NestedMeta` = note: required by `std::fmt::Debug::fmt` ```
2025-07-03 01:34:32 +02:00 · 2019-06-01 17:21:22 +06:00 · 2019-06-01 14:13:45 +06:00 · 2019-05-31 12:09:21 +04:00 · 2019-05-29 16:22:57 -07:00 · 2019-05-29 16:15:12 -07:00
109 changed files with 4539 additions and 1389 deletions
--- a/CHANGES.md
+++ b/CHANGES.md
@ -1,6 +1,104 @@
 # Changes

-## [1.0.0-beta.1] - 2019-04-xx
+## [1.0.0] - 2019-05-xx
+
+### Add
+
+* Add `ServiceRequest::set_payload()` method.
+
+* Add `test::TestRequest::set_json()` convenience method to automatically
+  serialize data and set header in test requests.
+
+### Changes
+
+* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
+
+### Fixed
+
+* Fix Logger request time format, and use rfc3339. #867
+
+* Clear http requests pool on app service drop #860
+
+
+## [1.0.0-rc] - 2019-05-18
+
+### Add
+
+* Add `Query<T>::from_query()` to extract parameters from a query string. #846
+* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
+
+### Changes
+
+* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
+
+### Fixed
+
+* Codegen with parameters in the path only resolves the first registered endpoint #841
+
+
+## [1.0.0-beta.4] - 2019-05-12
+
+### Add
+
+* Allow to set/override app data on scope level
+
+### Changes
+
+* `App::configure` take an `FnOnce` instead of `Fn`
+* Upgrade actix-net crates
+
+
+## [1.0.0-beta.3] - 2019-05-04
+
+### Added
+
+* Add helper function for executing futures `test::block_fn()`
+
+### Changed
+
+* Extractor configuration could be registered with `App::data()`
+  or with `Resource::data()` #775
+
+* Route data is unified with app data, `Route::data()` moved to resource
+  level to `Resource::data()`
+
+* CORS handling without headers #702
+
+* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
+
+### Fixed
+
+* Fix `NormalizePath` middleware impl #806
+
+### Deleted
+
+* `App::data_factory()` is deleted.
+
+
+## [1.0.0-beta.2] - 2019-04-24
+
+### Added
+
+* Add raw services support via `web::service()`
+
+* Add helper functions for reading response body `test::read_body()`
+
+* Add support for `remainder match` (i.e "/path/{tail}*")
+
+* Extend `Responder` trait, allow to override status code and headers.
+
+* Store visit and login timestamp in the identity cookie #502
+
+### 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 +107,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()`
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "1.0.0-alpha.6"
+version = "1.0.0"
 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,11 +40,8 @@ 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"]
+default = ["brotli", "flate2-zlib", "secure-cookies", "client", "fail"]

 # http client
 client = ["awc"]
@ -58,6 +58,8 @@ flate2-rust = ["actix-http/flate2-rust"]
 # sessions feature, session require "ring" crate and c compiler
 secure-cookies = ["actix-http/secure-cookies"]

+fail = ["actix-http/fail"]
+
 # openssl
 ssl = ["openssl", "actix-server/ssl", "awc/ssl"]

@ -66,41 +68,41 @@ rust-tls = ["rustls", "actix-server/rust-tls"]

 [dependencies]
 actix-codec = "0.1.2"
-actix-service = "0.3.6"
-actix-utils = "0.3.4"
-actix-router = "0.1.2"
+actix-service = "0.4.0"
+actix-utils = "0.4.1"
+actix-router = "0.1.5"
 actix-rt = "0.2.2"
-actix-web-codegen = "0.1.0-alpha.6"
-actix-http = { version = "0.1.0-alpha.5", features=["fail"] }
-actix-server = "0.4.3"
+actix-web-codegen = "0.1.0"
+actix-http = "0.2.2"
+actix-server = "0.5.1"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"
-awc = { version = "0.1.0-alpha.6", optional = true }
+awc = { version = "0.2.0", optional = true }

 bytes = "0.4"
 derive_more = "0.14"
 encoding = "0.2"
-futures = "0.1"
-hashbrown = "0.2.2"
+futures = "0.1.25"
+hashbrown = "0.3.0"
 log = "0.4"
 mime = "0.3"
 net2 = "0.2.33"
-parking_lot = "0.7"
+parking_lot = "0.8"
 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
 openssl = { version="0.10", optional = true }
-rustls = { version = "^0.15", 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.2.2", features=["ssl", "brotli", "flate2-zlib"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
+actix-files = { version = "0.1.0" }
 rand = "0.6"
 env_logger = "0.6"
 serde_derive = "1.0"
@ -121,4 +123,5 @@ actix-web-codegen = { path = "actix-web-codegen" }
 actix-web-actors = { path = "actix-web-actors" }
 actix-session = { path = "actix-session" }
 actix-files = { path = "actix-files" }
+actix-multipart = { path = "actix-multipart" }
 awc = { path = "awc" }
--- a/MIGRATION.md
+++ b/MIGRATION.md
@ -92,6 +92,36 @@
    App.new().service(web::resource("/welcome").to(welcome))
  ```

+* `HttpRequest` does not provide access to request's payload stream.
+
+  instead of
+
+  ```rust
+  fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    req
+       .payload()
+       .from_err()
+       .fold((), |_, chunk| {
+            ...
+        })
+       .map(|_| HttpResponse::Ok().finish())
+       .responder()
+  }
+  ```
+
+  use `Payload` extractor
+
+  ```rust
+  fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
+     stream
+       .from_err()
+       .fold((), |_, chunk| {
+            ...
+        })
+       .map(|_| HttpResponse::Ok().finish())
+  }
+  ```
+
 * `State` is now `Data`.  You register Data during the App initialization process
  and then access it from handlers either using a Data extractor or using
  HttpRequest's api.
@ -128,7 +158,7 @@
  ```


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

  instead of

@ -164,7 +194,7 @@
 * `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
  method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.

-  instead if
+  instead of

  ```rust
  fn index(req: &HttpRequest) -> Responder {
@ -173,6 +203,7 @@
          ...
       })
  }
+  ```

  use

@ -207,6 +238,17 @@

 * Actors support have been moved to `actix-web-actors` crate

+* Custom Error
+
+  Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
+
+  Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
+
+  ```rust
+  fn render_response(&self) -> HttpResponse {
+    self.error_response()
+  }
+  ```

 ## 0.7.15

--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -1,5 +1,18 @@
 # Changes

+## [0.1.0] - 2019-05-25
+
+* NamedFile last-modified check always fails due to nano-seconds
+  in file modified date #820
+
+## [0.1.0-beta.4] - 2019-05-12
+
+* Update actix-web to beta.4
+
+## [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
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.1.0-alpha.6"
+version = "0.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@ -18,8 +18,8 @@ name = "actix_files"
 path = "src/lib.rs"

 [dependencies]
-actix-web = "1.0.0-alpha.6"
-actix-service = "0.3.4"
+actix-web = "1.0.0-rc"
+actix-service = "0.4.0"
 bitflags = "1"
 bytes = "0.4"
 futures = "0.1.25"
@ -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-rc", features=["ssl"] }
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -1 +1,9 @@
 # Static files support for actix web [![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/actix-files)](https://crates.io/crates/actix-files) [![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)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/actix-files/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-files](https://crates.io/crates/actix-files)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@ -334,6 +334,7 @@ impl Files {
    where
        F: IntoNewService<U>,
        U: NewService<
+                Config = (),
                Request = ServiceRequest,
                Response = ServiceResponse,
                Error = Error,
@ -363,6 +364,7 @@ impl HttpServiceFactory for Files {
 }

 impl NewService for Files {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -411,17 +413,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 +441,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 +467,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 +499,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),
            }
        }
    }
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@ -66,6 +66,7 @@ impl NamedFile {
    ///     let mut file = File::create("foo.txt")?;
    ///     file.write_all(b"Hello, world!")?;
    ///     let named_file = NamedFile::from_file(file, "bar.txt")?;
+    ///     # std::fs::remove_file("foo.txt");
    ///     Ok(())
    /// }
    /// ```
@ -336,7 +337,12 @@ impl Responder for NamedFile {
        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
            (last_modified, req.get_header())
        {
-            m > since
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
+            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
+                (Ok(t1), Ok(t2)) => t1 > t2,
+                _ => false,
+            }
        } else {
            false
        };
@ -349,7 +355,12 @@ impl Responder for NamedFile {
        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
            (last_modified, req.get_header())
        {
-            m <= since
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
+            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
+                (Ok(t1), Ok(t2)) => t1 <= t2,
+                _ => false,
+            }
        } else {
            false
        };
--- a/actix-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-framed"
-version = "0.1.0-alpha.1"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix framed app server"
 readme = "README.md"
@ -21,17 +21,18 @@ path = "src/lib.rs"

 [dependencies]
 actix-codec = "0.1.2"
-actix-service = "0.3.6"
-actix-utils = "0.3.4"
+actix-service = "0.4.0"
+actix-utils = "0.4.0"
 actix-router = "0.1.2"
 actix-rt = "0.2.2"
-actix-http = "0.1.0-alpha.5"
+actix-http = "0.2.0"
+actix-server-config = "0.1.1"

 bytes = "0.4"
 futures = "0.1.25"
 log = "0.4"

 [dev-dependencies]
-actix-server = { version = "0.4.1", features=["ssl"] }
-actix-connect = { version = "0.1.4", features=["ssl"] }
-actix-http-test = { version = "0.1.0-alpha.3", features=["ssl"] }
+actix-server = { version = "0.5.0", features=["ssl"] }
+actix-connect = { version = "0.2.0", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
--- a/actix-framed/README.md
+++ b/actix-framed/README.md
@ -1 +1,8 @@
 # Framed app for actix web [![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/actix-framed)](https://crates.io/crates/actix-framed) [![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)
+
+## Documentation & community resources
+
+* [API Documentation](https://docs.rs/actix-framed/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-framed](https://crates.io/crates/actix-framed)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-framed/changes.md
+++ b/actix-framed/changes.md
@ -1,5 +1,15 @@
 # Changes

+## [0.2.0] - 2019-05-12
+
+* Update dependencies
+
+
+## [0.1.0] - 2019-04-16
+
+* Update tests
+
+
 ## [0.1.0-alpha.1] - 2019-04-12

 * Initial release
--- a/actix-framed/src/app.rs
+++ b/actix-framed/src/app.rs
@ -4,6 +4,7 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_http::h1::{Codec, SendResponse};
 use actix_http::{Error, Request, Response};
 use actix_router::{Path, Router, Url};
+use actix_server_config::ServerConfig;
 use actix_service::{IntoNewService, NewService, Service};
 use actix_utils::cloneable::CloneableService;
 use futures::{Async, Future, Poll};
@ -49,6 +50,7 @@ impl<T: 'static, S: 'static> FramedApp<T, S> {
    where
        U: HttpServiceFactory,
        U::Factory: NewService<
+                Config = (),
                Request = FramedRequest<T, S>,
                Response = (),
                Error = Error,
@ -88,11 +90,12 @@ pub struct FramedAppFactory<T, S> {
    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
 }

-impl<T, S, C> NewService<C> for FramedAppFactory<T, S>
+impl<T, S> NewService for FramedAppFactory<T, S>
 where
    T: AsyncRead + AsyncWrite + 'static,
    S: 'static,
 {
+    type Config = ServerConfig;
    type Request = (Request, Framed<T, Codec>);
    type Response = ();
    type Error = Error;
@ -100,7 +103,7 @@ where
    type Service = CloneableService<FramedAppService<T, S>>;
    type Future = CreateService<T, S>;

-    fn new_service(&self, _: &C) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        CreateService {
            fut: self
                .services
--- a/actix-framed/src/helpers.rs
+++ b/actix-framed/src/helpers.rs
@ -13,6 +13,7 @@ pub(crate) type BoxedHttpService<Req> = Box<

 pub(crate) type BoxedHttpNewService<Req> = Box<
    NewService<
+        Config = (),
        Request = Req,
        Response = (),
        Error = Error,
@ -39,12 +40,13 @@ where

 impl<T> NewService for HttpNewService<T>
 where
-    T: NewService<Response = (), Error = Error>,
+    T: NewService<Config = (), Response = (), Error = Error>,
    T::Request: 'static,
    T::Future: 'static,
    T::Service: Service<Future = Box<Future<Item = (), Error = Error>>> + 'static,
    <T::Service as Service>::Future: 'static,
 {
+    type Config = ();
    type Request = T::Request;
    type Response = ();
    type Error = Error;
--- a/actix-framed/src/route.rs
+++ b/actix-framed/src/route.rs
@ -106,6 +106,7 @@ where
    R::Future: 'static,
    R::Error: fmt::Display,
 {
+    type Config = ();
    type Request = FramedRequest<Io, S>;
    type Response = ();
    type Error = Error;
--- a/actix-framed/src/service.rs
+++ b/actix-framed/src/service.rs
@ -12,22 +12,23 @@ use futures::{Async, Future, IntoFuture, Poll, Sink};

 /// Service that verifies incoming request if it is valid websocket
 /// upgrade request. In case of error returns `HandshakeError`
-pub struct VerifyWebSockets<T> {
-    _t: PhantomData<T>,
+pub struct VerifyWebSockets<T, C> {
+    _t: PhantomData<(T, C)>,
 }

-impl<T> Default for VerifyWebSockets<T> {
+impl<T, C> Default for VerifyWebSockets<T, C> {
    fn default() -> Self {
        VerifyWebSockets { _t: PhantomData }
    }
 }

-impl<T, C> NewService<C> for VerifyWebSockets<T> {
+impl<T, C> NewService for VerifyWebSockets<T, C> {
+    type Config = C;
    type Request = (Request, Framed<T, Codec>);
    type Response = (Request, Framed<T, Codec>);
    type Error = (HandshakeError, Framed<T, Codec>);
    type InitError = ();
-    type Service = VerifyWebSockets<T>;
+    type Service = VerifyWebSockets<T, C>;
    type Future = FutureResult<Self::Service, Self::InitError>;

    fn new_service(&self, _: &C) -> Self::Future {
@ -35,7 +36,7 @@ impl<T, C> NewService<C> for VerifyWebSockets<T> {
    }
 }

-impl<T> Service for VerifyWebSockets<T> {
+impl<T, C> Service for VerifyWebSockets<T, C> {
    type Request = (Request, Framed<T, Codec>);
    type Response = (Request, Framed<T, Codec>);
    type Error = (HandshakeError, Framed<T, Codec>);
@ -54,9 +55,9 @@ impl<T> Service for VerifyWebSockets<T> {
 }

 /// Send http/1 error response
-pub struct SendError<T, R, E>(PhantomData<(T, R, E)>);
+pub struct SendError<T, R, E, C>(PhantomData<(T, R, E, C)>);

-impl<T, R, E> Default for SendError<T, R, E>
+impl<T, R, E, C> Default for SendError<T, R, E, C>
 where
    T: AsyncRead + AsyncWrite,
    E: ResponseError,
@ -66,17 +67,18 @@ where
    }
 }

-impl<T, R, E, C> NewService<C> for SendError<T, R, E>
+impl<T, R, E, C> NewService for SendError<T, R, E, C>
 where
    T: AsyncRead + AsyncWrite + 'static,
    R: 'static,
    E: ResponseError + 'static,
 {
+    type Config = C;
    type Request = Result<R, (E, Framed<T, Codec>)>;
    type Response = R;
    type Error = (E, Framed<T, Codec>);
    type InitError = ();
-    type Service = SendError<T, R, E>;
+    type Service = SendError<T, R, E, C>;
    type Future = FutureResult<Self::Service, Self::InitError>;

    fn new_service(&self, _: &C) -> Self::Future {
@ -84,7 +86,7 @@ where
    }
 }

-impl<T, R, E> Service for SendError<T, R, E>
+impl<T, R, E, C> Service for SendError<T, R, E, C>
 where
    T: AsyncRead + AsyncWrite + 'static,
    R: 'static,
--- a/actix-framed/tests/test_server.rs
+++ b/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
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -1,5 +1,77 @@
 # Changes

+## [0.2.2] - 2019-05-29
+
+### Fixed
+
+* Parse incoming stream before closing stream on disconnect #868
+
+
+## [0.2.1] - 2019-05-25
+
+### Fixed
+
+* Handle socket read disconnect
+
+
+## [0.2.0] - 2019-05-12
+
+### Changed
+
+* Update actix-service to 0.4
+
+* Expect and upgrade services accept `ServerConfig` config.
+
+### Deleted
+
+* `OneRequest` service
+
+
+## [0.1.5] - 2019-05-04
+
+### Fixed
+
+* Clean up response extensions in response pool #817
+
+
+## [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
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "0.1.0"
+version = "0.2.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@ -44,10 +44,10 @@ fail = ["failure"]
 secure-cookies = ["ring"]

 [dependencies]
-actix-service = "0.3.6"
+actix-service = "0.4.0"
 actix-codec = "0.1.2"
-actix-connect = "0.1.4"
-actix-utils = "0.3.5"
+actix-connect = "0.2.0"
+actix-utils = "0.4.1"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"

@ -59,8 +59,8 @@ copyless = "0.1.2"
 derive_more = "0.14"
 either = "1.5.2"
 encoding = "0.2"
-futures = "0.1"
-hashbrown = "0.2.2"
+futures = "0.1.25"
+hashbrown = "0.3.0"
 h2 = "0.1.16"
 http = "0.1.17"
 httparse = "1.3"
@ -77,11 +77,11 @@ 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"
-trust-dns-resolver = { version="0.11.0", default-features = false }
+trust-dns-resolver = { version="0.11.1", default-features = false }

 # for secure cookie
 ring = { version = "0.14.6", optional = true }
@ -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-server = { version = "0.5.0", features=["ssl"] }
+actix-connect = { version = "0.2.0", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
 env_logger = "0.6"
 serde_derive = "1.0"
 openssl = { version="0.10" }
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -29,7 +29,7 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {

 impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
 {
@ -48,13 +48,17 @@ where

 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
-    X: NewService<Request = Request, Response = Request>,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
@ -101,7 +105,7 @@ where
    pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
    where
        F: IntoNewService<X1>,
-        X1: NewService<Request = Request, Response = Request>,
+        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
        X1::Error: Into<Error>,
        X1::InitError: fmt::Debug,
    {
@ -122,7 +126,11 @@ where
    pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
    where
        F: IntoNewService<U1>,
-        U1: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+        U1: NewService<
+            Config = SrvConfig,
+            Request = (Request, Framed<T, Codec>),
+            Response = (),
+        >,
        U1::Error: fmt::Display,
        U1::InitError: fmt::Debug,
    {
@ -140,7 +148,7 @@ where
    pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B, X, U>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
@ -159,7 +167,7 @@ where
    pub fn h2<F, P, B>(self, service: F) -> H2Service<T, P, S, B>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
@ -177,7 +185,7 @@ where
    pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B, X, U>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
--- a/actix-http/src/client/connector.rs
+++ b/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,
    {
--- a/actix-http/src/client/h1proto.rs
+++ b/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))
                }
--- a/actix-http/src/client/mod.rs
+++ b/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>,
+}
--- a/actix-http/src/client/pool.rs
+++ b/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>
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@ -158,7 +158,8 @@ impl ServiceConfig {
        self.0.timer.now()
    }

-    pub(crate) fn set_date(&self, dst: &mut BytesMut) {
+    #[doc(hidden)]
+    pub fn set_date(&self, dst: &mut BytesMut) {
        let mut buf: [u8; 39] = [0; 39];
        buf[..6].copy_from_slice(b"date: ");
        buf[6..35].copy_from_slice(&self.0.timer.date().bytes);
--- a/actix-http/src/cookie/builder.rs
+++ b/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")
--- a/actix-http/src/cookie/jar.rs
+++ b/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();

--- a/actix-http/src/cookie/mod.rs
+++ b/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();
--- a/actix-http/src/cookie/parse.rs
+++ b/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);
    }
 }
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@ -137,7 +137,7 @@ impl<E: ResponseError> ResponseError for TimeoutError<E> {
 #[display(fmt = "UnknownError")]
 struct UnitError;

-/// `InternalServerError` for `JsonError`
+/// `InternalServerError` for `UnitError`
 impl ResponseError for UnitError {}

 /// `InternalServerError` for `JsonError`
@ -150,11 +150,11 @@ impl ResponseError for FormError {}
 impl ResponseError for TimerError {}

 #[cfg(feature = "ssl")]
-/// `InternalServerError` for `SslError`
+/// `InternalServerError` for `openssl::ssl::Error`
 impl ResponseError for openssl::ssl::Error {}

 #[cfg(feature = "ssl")]
-/// `InternalServerError` for `SslError`
+/// `InternalServerError` for `openssl::ssl::HandshakeError`
 impl ResponseError for openssl::ssl::HandshakeError<tokio_tcp::TcpStream> {}

 /// Return `BAD_REQUEST` for `de::value::Error`
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@ -31,7 +31,7 @@ const AVERAGE_HEADER_SIZE: usize = 30;

 /// HTTP/1 Codec
 pub struct Codec {
-    pub(crate) config: ServiceConfig,
+    config: ServiceConfig,
    decoder: decoder::MessageDecoder<Request>,
    payload: Option<PayloadDecoder>,
    version: Version,
@ -104,6 +104,11 @@ impl Codec {
            MessageType::Payload
        }
    }
+
+    #[inline]
+    pub fn config(&self) -> &ServiceConfig {
+        &self.config
+    }
 }

 impl Decoder for Codec {
--- a/actix-http/src/h1/decoder.rs
+++ b/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")));
+    }
 }
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@ -567,7 +567,7 @@ where
        }

        if updated && self.ka_timer.is_some() {
-            if let Some(expire) = self.codec.config.keep_alive_expire() {
+            if let Some(expire) = self.codec.config().keep_alive_expire() {
                self.ka_expire = expire;
            }
        }
@ -579,10 +579,13 @@ where
        if self.ka_timer.is_none() {
            // shutdown timeout
            if self.flags.contains(Flags::SHUTDOWN) {
-                if let Some(interval) = self.codec.config.client_disconnect_timer() {
+                if let Some(interval) = self.codec.config().client_disconnect_timer() {
                    self.ka_timer = Some(Delay::new(interval));
                } else {
                    self.flags.insert(Flags::READ_DISCONNECT);
+                    if let Some(mut payload) = self.payload.take() {
+                        payload.set_error(PayloadError::Incomplete(None));
+                    }
                    return Ok(());
                }
            } else {
@ -607,7 +610,7 @@ where

                            // start shutdown timer
                            if let Some(deadline) =
-                                self.codec.config.client_disconnect_timer()
+                                self.codec.config().client_disconnect_timer()
                            {
                                if let Some(timer) = self.ka_timer.as_mut() {
                                    timer.reset(deadline);
@ -632,7 +635,8 @@ where
                            self.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
                            self.state = State::None;
                        }
-                    } else if let Some(deadline) = self.codec.config.keep_alive_expire()
+                    } else if let Some(deadline) =
+                        self.codec.config().keep_alive_expire()
                    {
                        if let Some(timer) = self.ka_timer.as_mut() {
                            timer.reset(deadline);
@ -689,15 +693,20 @@ where
                    }
                } else {
                    // read socket into a buf
-                    if !inner.flags.contains(Flags::READ_DISCONNECT) {
-                        if let Some(true) =
-                            read_available(&mut inner.io, &mut inner.read_buf)?
-                        {
-                            inner.flags.insert(Flags::READ_DISCONNECT)
-                        }
-                    }
+                    let should_disconnect = if !inner.flags.contains(Flags::READ_DISCONNECT) {
+                        read_available(&mut inner.io, &mut inner.read_buf)?
+                    } else {
+                        None
+                    };

                    inner.poll_request()?;
+                    if let Some(true) = should_disconnect {
+                        inner.flags.insert(Flags::READ_DISCONNECT);
+                        if let Some(mut payload) = inner.payload.take() {
+                            payload.feed_eof();
+                        }
+                    };
+
                    loop {
                        if inner.write_buf.remaining_mut() < LW_BUFFER_SIZE {
                            inner.write_buf.reserve(HW_BUFFER_SIZE);
--- a/actix-http/src/h1/encoder.rs
+++ b/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,77 @@ 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")
+        );
+
+        head.set_camel_case_headers(false);
+        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")
+        );
+    }
 }
--- a/actix-http/src/h1/expect.rs
+++ b/actix-http/src/h1/expect.rs
@ -1,3 +1,4 @@
+use actix_server_config::ServerConfig;
 use actix_service::{NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Poll};
@ -8,6 +9,7 @@ use crate::request::Request;
 pub struct ExpectHandler;

 impl NewService for ExpectHandler {
+    type Config = ServerConfig;
    type Request = Request;
    type Response = Request;
    type Error = Error;
@ -15,7 +17,7 @@ impl NewService for ExpectHandler {
    type InitError = Error;
    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        ok(ExpectHandler)
    }
 }
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@ -29,14 +29,14 @@ pub struct H1Service<T, P, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {

 impl<T, P, S, B> H1Service<T, P, S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
    B: MessageBody,
 {
    /// Create new `HttpService` instance with default config.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);

        H1Service {
@ -49,10 +49,7 @@ where
    }

    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S, SrvConfig>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
        H1Service {
            cfg,
            srv: service.into_new_service(),
@ -65,7 +62,7 @@ where

 impl<T, P, S, B, X, U> H1Service<T, P, S, B, X, U>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
@ -102,21 +99,26 @@ where
    }
 }

-impl<T, P, S, B, X, U> NewService<SrvConfig> for H1Service<T, P, S, B, X, U>
+impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
    B: MessageBody,
-    X: NewService<Request = Request, Response = Request>,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
@ -127,8 +129,8 @@ where
    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
        H1ServiceResponse {
            fut: self.srv.new_service(cfg).into_future(),
-            fut_ex: Some(self.expect.new_service(&())),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(&())),
+            fut_ex: Some(self.expect.new_service(cfg)),
+            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
            expect: None,
            upgrade: None,
            cfg: Some(self.cfg.clone()),
@ -140,7 +142,7 @@ where
 #[doc(hidden)]
 pub struct H1ServiceResponse<T, P, S, B, X, U>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    X: NewService<Request = Request, Response = Request>,
@ -162,7 +164,7 @@ where
 impl<T, P, S, B, X, U> Future for H1ServiceResponse<T, P, S, B, X, U>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
@ -320,10 +322,11 @@ where
    }
 }

-impl<T, P> NewService<SrvConfig> for OneRequest<T, P>
+impl<T, P> NewService for OneRequest<T, P>
 where
    T: IoStream,
 {
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = (Request, Framed<T, Codec>);
    type Error = ParseError;
--- a/actix-http/src/h1/upgrade.rs
+++ b/actix-http/src/h1/upgrade.rs
@ -1,6 +1,7 @@
 use std::marker::PhantomData;

 use actix_codec::Framed;
+use actix_server_config::ServerConfig;
 use actix_service::{NewService, Service};
 use futures::future::FutureResult;
 use futures::{Async, Poll};
@ -12,6 +13,7 @@ use crate::request::Request;
 pub struct UpgradeHandler<T>(PhantomData<T>);

 impl<T> NewService for UpgradeHandler<T> {
+    type Config = ServerConfig;
    type Request = (Request, Framed<T, Codec>);
    type Response = ();
    type Error = Error;
@ -19,7 +21,7 @@ impl<T> NewService for UpgradeHandler<T> {
    type InitError = Error;
    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        unimplemented!()
    }
 }
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@ -31,14 +31,14 @@ pub struct H2Service<T, P, S, B> {

 impl<T, P, S, B> H2Service<T, P, S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
 {
    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);

        H2Service {
@ -49,10 +49,7 @@ where
    }

    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S, SrvConfig>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
        H2Service {
            cfg,
            srv: service.into_new_service(),
@ -61,15 +58,16 @@ where
    }
 }

-impl<T, P, S, B> NewService<SrvConfig> for H2Service<T, P, S, B>
+impl<T, P, S, B> NewService for H2Service<T, P, S, B>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
 {
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
@ -87,7 +85,7 @@ where
 }

 #[doc(hidden)]
-pub struct H2ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
+pub struct H2ServiceResponse<T, P, S: NewService, B> {
    fut: <S::Future as IntoFuture>::Future,
    cfg: Option<ServiceConfig>,
    _t: PhantomData<(T, P, B)>,
@ -96,7 +94,7 @@ pub struct H2ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>,
 impl<T, P, S, B> Future for H2ServiceResponse<T, P, S, B>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
--- a/actix-http/src/message.rs
+++ b/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) {
@ -431,6 +449,7 @@ impl BoxedResponsePool {
    fn release(&self, msg: Box<ResponseHead>) {
        let v = &mut self.0.borrow_mut();
        if v.len() < 128 {
+            msg.extensions.borrow_mut().clear();
            v.push(msg);
        }
    }
--- a/actix-http/src/request.rs
+++ b/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"));
+    }
+}
--- a/actix-http/src/response.rs
+++ b/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])
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -30,7 +30,7 @@ pub struct HttpService<T, P, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler

 impl<T, S, B> HttpService<T, (), S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -45,7 +45,7 @@ where

 impl<T, P, S, B> HttpService<T, P, S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -53,7 +53,7 @@ where
    B: MessageBody + 'static,
 {
    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);

        HttpService {
@ -66,7 +66,7 @@ where
    }

    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoNewService<S, SrvConfig>>(
+    pub(crate) fn with_config<F: IntoNewService<S>>(
        cfg: ServiceConfig,
        service: F,
    ) -> Self {
@ -82,7 +82,7 @@ where

 impl<T, P, S, B, X, U> HttpService<T, P, S, B, X, U>
 where
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -95,7 +95,7 @@ where
    /// request will be forwarded to main service.
    pub fn expect<X1>(self, expect: X1) -> HttpService<T, P, S, B, X1, U>
    where
-        X1: NewService<Request = Request, Response = Request>,
+        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
        X1::Error: Into<Error>,
        X1::InitError: fmt::Debug,
    {
@ -114,7 +114,11 @@ where
    /// and this service get called with original request and framed object.
    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, P, S, B, X, U1>
    where
-        U1: NewService<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+        U1: NewService<
+            Config = SrvConfig,
+            Request = (Request, Framed<T, h1::Codec>),
+            Response = (),
+        >,
        U1::Error: fmt::Display,
        U1::InitError: fmt::Debug,
    {
@ -128,22 +132,27 @@ where
    }
 }

-impl<T, P, S, B, X, U> NewService<SrvConfig> for HttpService<T, P, S, B, X, U>
+impl<T, P, S, B, X, U> NewService for HttpService<T, P, S, B, X, U>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
-    X: NewService<Request = Request, Response = Request>,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, h1::Codec>),
+        Response = (),
+    >,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
+    type Config = SrvConfig;
    type Request = ServerIo<T, P>;
    type Response = ();
    type Error = DispatchError;
@ -154,8 +163,8 @@ where
    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
        HttpServiceResponse {
            fut: self.srv.new_service(cfg).into_future(),
-            fut_ex: Some(self.expect.new_service(&())),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(&())),
+            fut_ex: Some(self.expect.new_service(cfg)),
+            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
            expect: None,
            upgrade: None,
            cfg: Some(self.cfg.clone()),
@ -165,14 +174,7 @@ where
 }

 #[doc(hidden)]
-pub struct HttpServiceResponse<
-    T,
-    P,
-    S: NewService<SrvConfig>,
-    B,
-    X: NewService,
-    U: NewService,
-> {
+pub struct HttpServiceResponse<T, P, S: NewService, B, X: NewService, U: NewService> {
    fut: S::Future,
    fut_ex: Option<X::Future>,
    fut_upg: Option<U::Future>,
@ -185,7 +187,7 @@ pub struct HttpServiceResponse<
 impl<T, P, S, B, X, U> Future for HttpServiceResponse<T, P, S, B, X, U>
 where
    T: IoStream,
-    S: NewService<SrvConfig, Request = Request>,
+    S: NewService<Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
--- a/actix-http/tests/test_client.rs
+++ b/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());
 }

--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -5,10 +5,11 @@ use std::{net, thread};
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http_test::TestServer;
 use actix_server_config::ServerConfig;
-use actix_service::{fn_cfg_factory, fn_service, NewService};
+use actix_service::{new_service_cfg, service_fn, NewService};
 use bytes::{Bytes, BytesMut};
 use futures::future::{self, ok, Future};
 use futures::stream::{once, Stream};
+use regex::Regex;
 use tokio_timer::sleep;

 use actix_http::body::Body;
@ -163,7 +164,7 @@ fn test_h2_body() -> std::io::Result<()> {
 fn test_expect_continue() {
    let srv = TestServer::new(|| {
        HttpService::build()
-            .expect(fn_service(|req: Request| {
+            .expect(service_fn(|req: Request| {
                if req.head().uri.query() == Some("yes=") {
                    Ok(req)
                } else {
@ -190,7 +191,7 @@ fn test_expect_continue() {
 fn test_expect_continue_h1() {
    let srv = TestServer::new(|| {
        HttpService::build()
-            .expect(fn_service(|req: Request| {
+            .expect(service_fn(|req: Request| {
                sleep(Duration::from_millis(20)).then(move |_| {
                    if req.head().uri.query() == Some("yes=") {
                        Ok(req)
@ -215,6 +216,56 @@ fn test_expect_continue_h1() {
    assert!(data.starts_with("HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n"));
 }

+#[test]
+fn test_chunked_payload() {
+    let chunk_sizes = vec![ 32768, 32, 32768 ];
+    let total_size: usize = chunk_sizes.iter().sum();
+
+    let srv = TestServer::new(|| {
+        HttpService::build()
+            .h1(|mut request: Request| {
+                request.take_payload()
+                    .map_err(|e| panic!(format!("Error reading payload: {}", e)))
+                    .fold(0usize, |acc, chunk| {
+                        future::ok::<_, ()>(acc + chunk.len())
+                    })
+                    .map(|req_size| {
+                        Response::Ok().body(format!("size={}", req_size))
+                    })
+            })
+    });
+
+    let returned_size = {
+        let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+        let _ = stream.write_all(b"POST /test HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n");
+
+        for chunk_size in chunk_sizes.iter() {
+            let mut bytes = Vec::new();
+            let random_bytes: Vec<u8> = (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
+
+            bytes.extend(format!("{:X}\r\n", chunk_size).as_bytes());
+            bytes.extend(&random_bytes[..]);
+            bytes.extend(b"\r\n");
+            let _ = stream.write_all(&bytes);
+        }
+
+        let _ = stream.write_all(b"0\r\n\r\n");
+        stream.shutdown(net::Shutdown::Write).unwrap();
+
+        let mut data = String::new();
+        let _ = stream.read_to_string(&mut data);
+
+        let re = Regex::new(r"size=(\d+)").unwrap();
+        let size: usize = match re.captures(&data) {
+            Some(caps) => caps.get(1).unwrap().as_str().parse().unwrap(),
+            None => panic!(format!("Failed to find size in HTTP Response: {}", data)),
+        };
+        size
+    };
+
+    assert_eq!(returned_size, total_size);
+}
+
 #[test]
 fn test_slow_request() {
    let srv = TestServer::new(|| {
@ -912,7 +963,7 @@ fn test_h1_body_chunked_implicit() {
 #[test]
 fn test_h1_response_http_error_handling() {
    let mut srv = TestServer::new(|| {
-        HttpService::build().h1(fn_cfg_factory(|_: &ServerConfig| {
+        HttpService::build().h1(new_service_cfg(|_: &ServerConfig| {
            Ok::<_, ()>(|_| {
                let broken_header = Bytes::from_static(b"\0\0\0");
                ok::<_, ()>(
@ -943,7 +994,7 @@ fn test_h2_response_http_error_handling() {
            .map_err(|e| println!("Openssl error: {}", e))
            .and_then(
                HttpService::build()
-                    .h2(fn_cfg_factory(|_: &ServerConfig| {
+                    .h2(new_service_cfg(|_: &ServerConfig| {
                        Ok::<_, ()>(|_| {
                            let broken_header = Bytes::from_static(b"\0\0\0");
                            ok::<_, ()>(
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@ -1,7 +1,23 @@
 # Changes

-## [0.1.0-alpha.1] - 2019-04-xx
+## [0.1.1] - 2019-05-25
+
+* Fix disconnect handling #834
+
+## [0.1.0] - 2019-05-18
+
+* Release
+
+## [0.1.0-beta.4] - 2019-05-12
+
+* Handle cancellation of uploads #736
+
+* Upgrade to actix-web 1.0.0-beta.4
+
+## [0.1.0-beta.1] - 2019-04-21

 * Do not support nested multipart

 * Split multipart support to separate crate
+
+* Optimize multipart handling #634, #769
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.1.0-alpha.1"
+version = "0.1.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-rc"
+actix-service = "0.4.0"
 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.2.0"
--- a/actix-multipart/README.md
+++ b/actix-multipart/README.md
@ -1 +1,8 @@
 # Multipart support for actix web framework [![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/actix-multipart)](https://crates.io/crates/actix-multipart) [![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)
+
+## Documentation & community resources
+
+* [API Documentation](https://docs.rs/actix-multipart/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-multipart](https://crates.io/crates/actix-multipart)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-multipart/src/error.rs
+++ b/actix-multipart/src/error.rs
@ -28,6 +28,9 @@ pub enum MultipartError {
    /// Payload error
    #[display(fmt = "{}", _0)]
    Payload(PayloadError),
+    /// Not consumed
+    #[display(fmt = "Multipart stream is not consumed")]
+    NotConsumed,
 }

 /// Return `BadRequest` for `MultipartError`
--- a/actix-multipart/src/server.rs
+++ b/actix-multipart/src/server.rs
@ -1,5 +1,5 @@
 //! Multipart payload support
-use std::cell::{RefCell, UnsafeCell};
+use std::cell::{Cell, RefCell, UnsafeCell};
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::{cmp, fmt};
@ -116,6 +116,8 @@ impl Stream for Multipart {
                payload.poll_stream()?;
            }
            inner.poll(&self.safety)
+        } else if !self.safety.is_clean() {
+            Err(MultipartError::NotConsumed)
        } else {
            Ok(Async::NotReady)
        }
@ -126,7 +128,7 @@ impl InnerMultipart {
    fn read_headers(
        payload: &mut PayloadBuffer,
    ) -> Result<Option<HeaderMap>, MultipartError> {
-        match payload.read_until(b"\r\n\r\n") {
+        match payload.read_until(b"\r\n\r\n")? {
            None => {
                if payload.eof {
                    Err(MultipartError::Incomplete)
@ -165,10 +167,10 @@ impl InnerMultipart {
        boundary: &str,
    ) -> Result<Option<bool>, MultipartError> {
        // TODO: need to read epilogue
-        match payload.readline() {
+        match payload.readline()? {
            None => {
                if payload.eof {
-                    Err(MultipartError::Incomplete)
+                    Ok(Some(true))
                } else {
                    Ok(None)
                }
@ -198,11 +200,10 @@ impl InnerMultipart {
    ) -> Result<Option<bool>, MultipartError> {
        let mut eof = false;
        loop {
-            match payload.readline() {
+            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;
@ -416,6 +417,8 @@ impl Stream for Field {
            }

            inner.poll(&self.safety)
+        } else if !self.safety.is_clean() {
+            return Err(MultipartError::NotConsumed);
        } else {
            Ok(Async::NotReady)
        }
@ -478,7 +481,7 @@ impl InnerField {
        if *size == 0 {
            Ok(Async::Ready(None))
        } else {
-            match payload.read_max(*size) {
+            match payload.read_max(*size)? {
                Some(mut chunk) => {
                    let len = cmp::min(chunk.len() as u64, *size);
                    *size -= len;
@ -505,47 +508,76 @@ 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 if payload.eof {
+                Err(MultipartError::Incomplete)
+            } else {
+                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 +587,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 {
@ -630,6 +663,7 @@ struct Safety {
    task: Option<Task>,
    level: usize,
    payload: Rc<PhantomData<bool>>,
+    clean: Rc<Cell<bool>>,
 }

 impl Safety {
@ -638,12 +672,17 @@ impl Safety {
        Safety {
            task: None,
            level: Rc::strong_count(&payload),
+            clean: Rc::new(Cell::new(true)),
            payload,
        }
    }

    fn current(&self) -> bool {
-        Rc::strong_count(&self.payload) == self.level
+        Rc::strong_count(&self.payload) == self.level && self.clean.get()
+    }
+
+    fn is_clean(&self) -> bool {
+        self.clean.get()
    }
 }

@ -653,6 +692,7 @@ impl Clone for Safety {
        Safety {
            task: Some(current_task()),
            level: Rc::strong_count(&payload),
+            clean: self.clean.clone(),
            payload,
        }
    }
@ -662,7 +702,7 @@ impl Drop for Safety {
    fn drop(&mut self) {
        // parent task is dead
        if Rc::strong_count(&self.payload) != self.level {
-            panic!("Safety get dropped but it is not from top-most task");
+            self.clean.set(true);
        }
        if let Some(task) = self.task.take() {
            task.notify()
@ -704,7 +744,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())
@ -713,23 +753,31 @@ impl PayloadBuffer {
        }
    }

-    fn read_max(&mut self, size: u64) -> Option<Bytes> {
+    fn read_max(&mut self, size: u64) -> Result<Option<Bytes>, MultipartError> {
        if !self.buf.is_empty() {
            let size = std::cmp::min(self.buf.len() as u64, size) as usize;
-            Some(self.buf.split_to(size).freeze())
+            Ok(Some(self.buf.split_to(size).freeze()))
+        } else if self.eof {
+            Err(MultipartError::Incomplete)
        } else {
-            None
+            Ok(None)
        }
    }

    /// Read until specified ending
-    pub fn read_until(&mut self, line: &[u8]) -> Option<Bytes> {
-        twoway::find_bytes(&self.buf, line)
-            .map(|idx| self.buf.split_to(idx + line.len()).freeze())
+    pub fn read_until(&mut self, line: &[u8]) -> Result<Option<Bytes>, MultipartError> {
+        let res = twoway::find_bytes(&self.buf, line)
+            .map(|idx| self.buf.split_to(idx + line.len()).freeze());
+
+        if res.is_none() && self.eof {
+            Err(MultipartError::Incomplete)
+        } else {
+            Ok(res)
+        }
    }

    /// Read bytes until new line delimiter
-    pub fn readline(&mut self) -> Option<Bytes> {
+    pub fn readline(&mut self) -> Result<Option<Bytes>, MultipartError> {
        self.read_until(b"\n")
    }

@ -875,6 +923,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(|| {
@ -883,7 +1003,7 @@ mod tests {

            assert_eq!(payload.buf.len(), 0);
            payload.poll_stream().unwrap();
-            assert_eq!(None, payload.read_max(1));
+            assert_eq!(None, payload.read_max(1).unwrap());
        })
    }

@ -893,14 +1013,14 @@ mod tests {
            let (mut sender, payload) = Payload::create(false);
            let mut payload = PayloadBuffer::new(payload);

-            assert_eq!(None, payload.read_max(4));
+            assert_eq!(None, payload.read_max(4).unwrap());
            sender.feed_data(Bytes::from("data"));
            sender.feed_eof();
            payload.poll_stream().unwrap();

-            assert_eq!(Some(Bytes::from("data")), payload.read_max(4));
+            assert_eq!(Some(Bytes::from("data")), payload.read_max(4).unwrap());
            assert_eq!(payload.buf.len(), 0);
-            assert_eq!(None, payload.read_max(1));
+            assert!(payload.read_max(1).is_err());
            assert!(payload.eof);
        })
    }
@ -910,7 +1030,7 @@ mod tests {
        run_on(|| {
            let (mut sender, payload) = Payload::create(false);
            let mut payload = PayloadBuffer::new(payload);
-            assert_eq!(None, payload.read_max(1));
+            assert_eq!(None, payload.read_max(1).unwrap());
            sender.set_error(PayloadError::Incomplete(None));
            payload.poll_stream().err().unwrap();
        })
@ -927,10 +1047,10 @@ mod tests {
            payload.poll_stream().unwrap();
            assert_eq!(payload.buf.len(), 10);

-            assert_eq!(Some(Bytes::from("line1")), payload.read_max(5));
+            assert_eq!(Some(Bytes::from("line1")), payload.read_max(5).unwrap());
            assert_eq!(payload.buf.len(), 5);

-            assert_eq!(Some(Bytes::from("line2")), payload.read_max(5));
+            assert_eq!(Some(Bytes::from("line2")), payload.read_max(5).unwrap());
            assert_eq!(payload.buf.len(), 0);
        })
    }
@ -961,16 +1081,22 @@ mod tests {
            let (mut sender, payload) = Payload::create(false);
            let mut payload = PayloadBuffer::new(payload);

-            assert_eq!(None, payload.read_until(b"ne"));
+            assert_eq!(None, payload.read_until(b"ne").unwrap());

            sender.feed_data(Bytes::from("line1"));
            sender.feed_data(Bytes::from("line2"));
            payload.poll_stream().unwrap();

-            assert_eq!(Some(Bytes::from("line")), payload.read_until(b"ne"));
+            assert_eq!(
+                Some(Bytes::from("line")),
+                payload.read_until(b"ne").unwrap()
+            );
            assert_eq!(payload.buf.len(), 6);

-            assert_eq!(Some(Bytes::from("1line2")), payload.read_until(b"2"));
+            assert_eq!(
+                Some(Bytes::from("1line2")),
+                payload.read_until(b"2").unwrap()
+            );
            assert_eq!(payload.buf.len(), 0);
        })
    }
--- a/actix-session/CHANGES.md
+++ b/actix-session/CHANGES.md
@ -1,5 +1,23 @@
 # Changes

+## [0.1.0] - 2019-05-18
+
+* Use actix-web 1.0.0-rc
+
+## [0.1.0-beta.4] - 2019-05-12
+
+* Use actix-web 1.0.0-beta.4
+
+## [0.1.0-beta.2] - 2019-04-28
+
+* Add helper trait `UserSession` which allows to get session for ServiceRequest and HttpRequest
+
+## [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
--- a/actix-session/Cargo.toml
+++ b/actix-session/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-session"
-version = "0.1.0-alpha.6"
+version = "0.1.0"
 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-service = "0.3.4"
+actix-web = "1.0.0-rc"
+actix-service = "0.4.0"
 bytes = "0.4"
 derive_more = "0.14"
 futures = "0.1.25"
-hashbrown = "0.2.0"
+hashbrown = "0.3.0"
 serde = "1.0"
 serde_json = "1.0"
-time = "0.1"
+time = "0.1.42"

 [dev-dependencies]
 actix-rt = "0.2.2"
--- a/actix-session/README.md
+++ b/actix-session/README.md
@ -1 +1,9 @@
 # Session for actix web framework [![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/actix-session)](https://crates.io/crates/actix-session) [![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)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/actix-session/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-session](https://crates.io/crates/actix-session)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-session/src/cookie.rs
+++ b/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"));
+    }
 }
--- a/actix-session/src/lib.rs
+++ b/actix-session/src/lib.rs
@ -79,6 +79,23 @@ pub use crate::cookie::CookieSession;
 /// ```
 pub struct Session(Rc<RefCell<SessionInner>>);

+/// Helper trait that allows to get session
+pub trait UserSession {
+    fn get_session(&mut self) -> Session;
+}
+
+impl UserSession for HttpRequest {
+    fn get_session(&mut self) -> Session {
+        Session::get_session(&mut *self.extensions_mut())
+    }
+}
+
+impl UserSession for ServiceRequest {
+    fn get_session(&mut self) -> Session {
+        Session::get_session(&mut *self.extensions_mut())
+    }
+}
+
 #[derive(Default)]
 struct SessionInner {
    state: HashMap<String, String>,
@ -208,4 +225,18 @@ mod tests {
        let changes: Vec<_> = Session::get_changes(&mut res).unwrap().collect();
        assert_eq!(changes, [("key2".to_string(), "\"value2\"".to_string())]);
    }
+
+    #[test]
+    fn get_session() {
+        let mut req = test::TestRequest::default().to_srv_request();
+
+        Session::set_session(
+            vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
+            &mut req,
+        );
+
+        let session = req.get_session();
+        let res = session.get::<String>("key").unwrap();
+        assert_eq!(res, Some("value".to_string()));
+    }
 }
--- a/actix-web-actors/CHANGES.md
+++ b/actix-web-actors/CHANGES.md
@ -1,5 +1,9 @@
 # Changes

+## [1.0.0] - 2019-05-29
+
+* Update actix-http and actix-web
+
 ## [0.1.0-alpha.3] - 2019-04-02

 * Update actix-http and actix-web
--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "1.0.0-alpha.3"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for actix web framework."
 readme = "README.md"
@ -18,13 +18,13 @@ name = "actix_web_actors"
 path = "src/lib.rs"

 [dependencies]
-actix = "0.8.0"
-actix-web = "1.0.0-alpha.5"
-actix-http = "0.1.0-alpha.5"
+actix = "0.8.3"
+actix-web = "1.0.0-rc"
+actix-http = "0.2.2"
 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.2.0", features=["ssl"] }
--- a/actix-web-actors/README.md
+++ b/actix-web-actors/README.md
@ -1 +1,8 @@
 Actix actors support for actix web framework [![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/actix-web-actors)](https://crates.io/crates/actix-web-actors) [![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)
+
+## Documentation & community resources
+
+* [API Documentation](https://docs.rs/actix-web-actors/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-web-actors](https://crates.io/crates/actix-web-actors)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@ -1,5 +1,17 @@
 # Changes

+## [0.1.1] - 2019-06-01
+
+* Add syn "extra-traits" feature
+
+## [0.1.0] - 2019-05-18
+
+* Release
+
+## [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
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.1.0-alpha.6"
+version = "0.1.1"
 description = "Actix web proc macros"
 readme = "README.md"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
@ -12,11 +12,11 @@ workspace = ".."
 proc-macro = true

 [dependencies]
-quote = "0.6"
-syn = { version = "0.15", features = ["full", "parsing"] }
+quote = "0.6.12"
+syn = { version = "0.15.34", features = ["full", "parsing", "extra-traits"] }

 [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-web = { version = "1.0.0-rc" }
+actix-http = { version = "0.2.2", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
 futures = { version = "0.1" }
--- a/actix-web-codegen/LICENSE-APACHE
+++ b/actix-web-codegen/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/actix-web-codegen/LICENSE-MIT
+++ b/actix-web-codegen/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/actix-web-codegen/tests/test_macro.rs
+++ b/actix-web-codegen/tests/test_macro.rs
@ -1,7 +1,7 @@
 use actix_http::HttpService;
 use actix_http_test::TestServer;
-use actix_web::{http, App, HttpResponse, Responder};
-use actix_web_codegen::get;
+use actix_web::{http, web::Path, App, HttpResponse, Responder};
+use actix_web_codegen::{delete, get, post, put};
 use futures::{future, Future};

 #[get("/test")]
@ -9,6 +9,16 @@ fn test() -> impl Responder {
    HttpResponse::Ok()
 }

+#[put("/test")]
+fn put_test() -> impl Responder {
+    HttpResponse::Created()
+}
+
+#[post("/test")]
+fn post_test() -> impl Responder {
+    HttpResponse::NoContent()
+}
+
 #[get("/test")]
 fn auto_async() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
    future::ok(HttpResponse::Ok().finish())
@ -19,13 +29,69 @@ fn auto_sync() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
    future::ok(HttpResponse::Ok().finish())
 }

+#[put("/test/{param}")]
+fn put_param_test(_: Path<String>) -> impl Responder {
+    HttpResponse::Created()
+}
+
+#[delete("/test/{param}")]
+fn delete_param_test(_: Path<String>) -> impl Responder {
+    HttpResponse::NoContent()
+}
+
+#[get("/test/{param}")]
+fn get_param_test(_: Path<String>) -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[test]
+fn test_params() {
+    let mut srv = TestServer::new(|| {
+        HttpService::new(
+            App::new()
+                .service(get_param_test)
+                .service(put_param_test)
+                .service(delete_param_test),
+        )
+    });
+
+    let request = srv.request(http::Method::GET, srv.url("/test/it"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert_eq!(response.status(), http::StatusCode::OK);
+
+    let request = srv.request(http::Method::PUT, srv.url("/test/it"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert_eq!(response.status(), http::StatusCode::CREATED);
+
+    let request = srv.request(http::Method::DELETE, srv.url("/test/it"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
+}
+
 #[test]
 fn test_body() {
-    let mut srv = TestServer::new(|| HttpService::new(App::new().service(test)));
+    let mut srv = TestServer::new(|| {
+        HttpService::new(
+            App::new()
+                .service(post_test)
+                .service(put_test)
+                .service(test),
+        )
+    });
    let request = srv.request(http::Method::GET, srv.url("/test"));
    let response = srv.block_on(request.send()).unwrap();
    assert!(response.status().is_success());

+    let request = srv.request(http::Method::PUT, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+    assert_eq!(response.status(), http::StatusCode::CREATED);
+
+    let request = srv.request(http::Method::POST, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+    assert_eq!(response.status(), http::StatusCode::NO_CONTENT);
+
    let mut srv = TestServer::new(|| HttpService::new(App::new().service(auto_sync)));
    let request = srv.request(http::Method::GET, srv.url("/test"));
    let response = srv.block_on(request.send()).unwrap();
--- a/awc/CHANGES.md
+++ b/awc/CHANGES.md
@ -1,5 +1,32 @@
 # Changes

+## [0.2.0] - 2019-05-12
+
+### Added
+
+* Allow to send headers in `Camel-Case` form.
+
+### Changed
+
+* Upgrade actix-http dependency.
+
+
+## [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
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "0.1.0-alpha.6"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http client."
 readme = "README.md"
@ -8,10 +8,13 @@ keywords = ["actix", "http", "framework", "async", "web"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/awc/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-client",
+              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-workspace = ".."
 edition = "2018"
+workspace = ".."

 [lib]
 name = "awc"
@ -37,8 +40,8 @@ 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-service = "0.4.0"
+actix-http = "0.2.0"
 base64 = "0.10.1"
 bytes = "0.4"
 derive_more = "0.14"
@ -55,11 +58,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-utils = "0.3.4"
-actix-server = { version = "0.4.1", features=["ssl"] }
+actix-web = { version = "1.0.0-beta.4", features=["ssl"] }
+actix-http = { version = "0.2.0", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
+actix-utils = "0.4.0"
+actix-server = { version = "0.5.0", features=["ssl"] }
 brotli2 = { version="0.3.2" }
 flate2 = { version="1.0.2" }
 env_logger = "0.6"
--- a/awc/README.md
+++ b/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(())
+          })
+    }));
+}
+```
--- a/awc/src/builder.rs
+++ b/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,
@ -140,51 +140,46 @@ impl ClientBuilder {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test;

    #[test]
    fn client_basic_auth() {
-        test::run_on(|| {
-            let client = ClientBuilder::new().basic_auth("username", Some("password"));
-            assert_eq!(
-                client
-                    .config
-                    .headers
-                    .get(header::AUTHORIZATION)
-                    .unwrap()
-                    .to_str()
-                    .unwrap(),
-                "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
-            );
+        let client = ClientBuilder::new().basic_auth("username", Some("password"));
+        assert_eq!(
+            client
+                .config
+                .headers
+                .get(header::AUTHORIZATION)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
+        );

-            let client = ClientBuilder::new().basic_auth("username", None);
-            assert_eq!(
-                client
-                    .config
-                    .headers
-                    .get(header::AUTHORIZATION)
-                    .unwrap()
-                    .to_str()
-                    .unwrap(),
-                "Basic dXNlcm5hbWU="
-            );
-        });
+        let client = ClientBuilder::new().basic_auth("username", None);
+        assert_eq!(
+            client
+                .config
+                .headers
+                .get(header::AUTHORIZATION)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "Basic dXNlcm5hbWU="
+        );
    }

    #[test]
    fn client_bearer_auth() {
-        test::run_on(|| {
-            let client = ClientBuilder::new().bearer_auth("someS3cr3tAutht0k3n");
-            assert_eq!(
-                client
-                    .config
-                    .headers
-                    .get(header::AUTHORIZATION)
-                    .unwrap()
-                    .to_str()
-                    .unwrap(),
-                "Bearer someS3cr3tAutht0k3n"
-            );
-        })
+        let client = ClientBuilder::new().bearer_auth("someS3cr3tAutht0k3n");
+        assert_eq!(
+            client
+                .config
+                .headers
+                .get(header::AUTHORIZATION)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "Bearer someS3cr3tAutht0k3n"
+        );
    }
 }
--- a/awc/src/connect.rs
+++ b/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))
--- a/awc/src/error.rs
+++ b/awc/src/error.rs
@ -65,7 +65,7 @@ pub enum JsonPayloadError {
    Payload(PayloadError),
 }

-/// Return `InternlaServerError` for `JsonPayloadError`
+/// Return `InternalServerError` for `JsonPayloadError`
 impl ResponseError for JsonPayloadError {
    fn error_response(&self) -> Response {
        Response::new(StatusCode::INTERNAL_SERVER_ERROR)
--- a/awc/src/request.rs
+++ b/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("");
--- a/awc/src/response.rs
+++ b/awc/src/response.rs
@ -347,10 +347,11 @@ where
 #[cfg(test)]
 mod tests {
    use super::*;
+    use actix_http_test::block_on;
    use futures::Async;
    use serde::{Deserialize, Serialize};

-    use crate::{http::header, test::block_on, test::TestResponse};
+    use crate::{http::header, test::TestResponse};

    #[test]
    fn test_body() {
--- a/awc/src/test.rs
+++ b/awc/src/test.rs
@ -6,39 +6,10 @@ use actix_http::http::header::{self, Header, HeaderValue, IntoHeaderValue};
 use actix_http::http::{HeaderName, HttpTryFrom, StatusCode, Version};
 use actix_http::{h1, Payload, ResponseHead};
 use bytes::Bytes;
-#[cfg(test)]
-use futures::Future;
 use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};

 use crate::ClientResponse;

-#[cfg(test)]
-thread_local! {
-    static RT: std::cell::RefCell<actix_rt::Runtime> = {
-        std::cell::RefCell::new(actix_rt::Runtime::new().unwrap())
-    };
-}
-
-#[cfg(test)]
-pub(crate) fn run_on<F, R>(f: F) -> R
-where
-    F: Fn() -> R,
-{
-    RT.with(move |rt| {
-        rt.borrow_mut()
-            .block_on(futures::future::lazy(|| Ok::<_, ()>(f())))
-    })
-    .unwrap()
-}
-
-#[cfg(test)]
-pub(crate) fn block_on<F>(f: F) -> Result<F::Item, F::Error>
-where
-    F: Future,
-{
-    RT.with(move |rt| rt.borrow_mut().block_on(f))
-}
-
 /// Test `ClientResponse` builder
 pub struct TestResponse {
    head: ResponseHead,
--- a/awc/src/ws.rs
+++ b/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
@ -306,7 +318,9 @@ impl WebsocketsRequest {
                        }
                    } else {
                        log::trace!("Invalid connection header: {:?}", conn);
-                        return Err(WsClientError::InvalidConnectionHeader(conn.clone()));
+                        return Err(WsClientError::InvalidConnectionHeader(
+                            conn.clone(),
+                        ));
                    }
                } else {
                    log::trace!("Missing connection header");
@ -445,12 +459,13 @@ mod tests {
                .unwrap(),
            "Bearer someS3cr3tAutht0k3n"
        );
+        let _ = req.connect();
    }

    #[test]
    fn basics() {
        let req = Client::new()
-            .ws("/")
+            .ws("http://localhost/")
            .origin("test-origin")
            .max_frame_size(100)
            .server_mode()
@ -469,6 +484,15 @@ mod tests {
            req.head.headers.get(header::CONTENT_TYPE).unwrap(),
            header::HeaderValue::from_static("json")
        );
-        let _ = req.connect();
+
+        let _ = actix_http_test::block_fn(move || 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());
    }
 }
--- a/awc/tests/test_client.rs
+++ b/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::{service_fn, 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();
+        service_fn(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();
+        service_fn(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();
+        service_fn(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();
+        service_fn(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();
+        service_fn(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();
+        service_fn(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]
--- a/awc/tests/test_ws.rs
+++ b/awc/tests/test_ws.rs
@ -1,17 +1,11 @@
 use std::io;

 use actix_codec::Framed;
+use actix_http::{body::BodySize, h1, ws, Error, HttpService, Request, Response};
 use actix_http_test::TestServer;
-use actix_server::Io;
-use actix_service::{fn_service, NewService};
-use actix_utils::framed::IntoFramed;
-use actix_utils::stream::TakeItem;
 use bytes::{Bytes, BytesMut};
-use futures::future::{ok, Either};
+use futures::future::ok;
 use futures::{Future, Sink, Stream};
-use tokio_tcp::TcpStream;
-
-use actix_http::{body::BodySize, h1, ws, Request, ResponseError, ServiceConfig};

 fn ws_service(req: ws::Frame) -> impl Future<Item = ws::Message, Error = io::Error> {
    match req {
@ -37,52 +31,20 @@ fn ws_service(req: ws::Frame) -> impl Future<Item = ws::Message, Error = io::Err
 #[test]
 fn test_simple() {
    let mut srv = TestServer::new(|| {
-        fn_service(|io: Io<TcpStream>| Ok(io.into_parts().0))
-            .and_then(IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())))
-            .and_then(TakeItem::new().map_err(|_| ()))
-            .and_then(
-                |(req, framed): (Option<h1::Message<Request>>, Framed<_, _>)| {
-                    // validate request
-                    if let Some(h1::Message::Item(req)) = req {
-                        match ws::verify_handshake(req.head()) {
-                            Err(e) => {
-                                // validation failed
-                                let res = e.error_response();
-                                Either::A(
-                                    framed
-                                        .send(h1::Message::Item((
-                                            res.drop_body(),
-                                            BodySize::Empty,
-                                        )))
-                                        .map_err(|_| ())
-                                        .map(|_| ()),
-                                )
-                            }
-                            Ok(_) => {
-                                let res = ws::handshake_response(req.head()).finish();
-                                Either::B(
-                                    // send handshake response
-                                    framed
-                                        .send(h1::Message::Item((
-                                            res.drop_body(),
-                                            BodySize::None,
-                                        )))
-                                        .map_err(|_| ())
-                                        .and_then(|framed| {
-                                            // start websocket service
-                                            let framed =
-                                                framed.into_framed(ws::Codec::new());
-                                            ws::Transport::with(framed, ws_service)
-                                                .map_err(|_| ())
-                                        }),
-                                )
-                            }
-                        }
-                    } else {
-                        panic!()
-                    }
-                },
-            )
+        HttpService::build()
+            .upgrade(|(req, framed): (Request, Framed<_, _>)| {
+                let res = ws::handshake_response(req.head()).finish();
+                // send handshake response
+                framed
+                    .send(h1::Message::Item((res.drop_body(), BodySize::None)))
+                    .map_err(|e: io::Error| e.into())
+                    .and_then(|framed| {
+                        // start websocket service
+                        let framed = framed.into_framed(ws::Codec::new());
+                        ws::Transport::with(framed, ws_service)
+                    })
+            })
+            .finish(|_| ok::<_, Error>(Response::NotFound()))
    });

    // client service
--- a/src/app.rs
+++ b/src/app.rs
@ -4,7 +4,6 @@ use std::marker::PhantomData;
 use std::rc::Rc;

 use actix_http::body::{Body, MessageBody};
-use actix_server_config::ServerConfig;
 use actix_service::boxed::{self, BoxedNewService};
 use actix_service::{
    apply_transform, IntoNewService, IntoTransform, NewService, Transform,
@ -59,6 +58,7 @@ impl<T, B> App<T, B>
 where
    B: MessageBody,
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse<B>,
        Error = Error,
@ -95,24 +95,11 @@ where
    ///                 web::get().to(index)));
    /// }
    /// ```
-    pub fn data<S: 'static>(mut self, data: S) -> Self {
+    pub fn data<U: 'static>(mut self, data: U) -> Self {
        self.data.push(Box::new(Data::new(data)));
        self
    }

-    /// Set application data factory. This function is
-    /// similar to `.data()` but it accepts data factory. Data object get
-    /// constructed asynchronously during application initialization.
-    pub fn data_factory<F, R>(mut self, data: F) -> Self
-    where
-        F: Fn() -> R + 'static,
-        R: IntoFuture + 'static,
-        R::Error: std::fmt::Debug,
-    {
-        self.data.push(Box::new(data));
-        self
-    }
-
    /// Run external configuration as part of the application building
    /// process
    ///
@ -141,7 +128,7 @@ where
    /// ```
    pub fn configure<F>(mut self, f: F) -> Self
    where
-        F: Fn(&mut ServiceConfig),
+        F: FnOnce(&mut ServiceConfig),
    {
        let mut cfg = ServiceConfig::new();
        f(&mut cfg);
@ -247,6 +234,7 @@ where
    where
        F: IntoNewService<U>,
        U: NewService<
+                Config = (),
                Request = ServiceRequest,
                Response = ServiceResponse,
                Error = Error,
@ -301,7 +289,15 @@ where
    /// lifecycle (request -> response), modifying request/response as
    /// necessary, across all requests managed by the *Application*.
    ///
-    /// Use middleware when you need to read or modify *every* request or response in some way.
+    /// Use middleware when you need to read or modify *every* request or
+    /// response in some way.
+    ///
+    /// Notice that the keyword for registering middleware is `wrap`. As you
+    /// register middleware using `wrap` in the App builder,  imagine wrapping
+    /// layers around an inner App.  The first middleware layer exposed to a
+    /// Request is the outermost layer-- the *last* registered in
+    /// the builder chain.  Consequently, the *first* middleware registered
+    /// in the builder chain is the *last* to execute during request processing.
    ///
    /// ```rust
    /// use actix_service::Service;
@ -324,6 +320,7 @@ where
        mw: F,
    ) -> App<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse<B1>,
            Error = Error,
@ -389,6 +386,7 @@ where
        mw: F,
    ) -> App<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse<B1>,
            Error = Error,
@ -405,10 +403,11 @@ where
    }
 }

-impl<T, B> IntoNewService<AppInit<T, B>, ServerConfig> for App<T, B>
+impl<T, B> IntoNewService<AppInit<T, B>> for App<T, B>
 where
    B: MessageBody,
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse<B>,
        Error = Error,
@ -417,9 +416,9 @@ where
 {
    fn into_new_service(self) -> AppInit<T, B> {
        AppInit {
-            data: self.data,
+            data: Rc::new(self.data),
            endpoint: self.endpoint,
-            services: RefCell::new(self.services),
+            services: Rc::new(RefCell::new(self.services)),
            external: RefCell::new(self.external),
            default: self.default,
            factory_ref: self.factory_ref,
@ -431,13 +430,16 @@ 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_fn, block_on, call_service, init_service, read_body, TestRequest,
+    };
+    use crate::{web, Error, HttpRequest, HttpResponse};

    #[test]
    fn test_default_resource() {
@ -445,7 +447,7 @@ mod tests {
            App::new().service(web::resource("/test").to(|| HttpResponse::Ok())),
        );
        let req = TestRequest::with_uri("/test").to_request();
-        let resp = block_on(srv.call(req)).unwrap();
+        let resp = block_fn(|| srv.call(req)).unwrap();
        assert_eq!(resp.status(), StatusCode::OK);

        let req = TestRequest::with_uri("/blah").to_request();
@ -482,24 +484,24 @@ mod tests {
        assert_eq!(resp.status(), StatusCode::CREATED);
    }

-    #[test]
-    fn test_data_factory() {
-        let mut srv =
-            init_service(App::new().data_factory(|| Ok::<_, ()>(10usize)).service(
-                web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
-            ));
-        let req = TestRequest::default().to_request();
-        let resp = block_on(srv.call(req)).unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
+    // #[test]
+    // fn test_data_factory() {
+    //     let mut srv =
+    //         init_service(App::new().data_factory(|| Ok::<_, ()>(10usize)).service(
+    //             web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
+    //         ));
+    //     let req = TestRequest::default().to_request();
+    //     let resp = block_on(srv.call(req)).unwrap();
+    //     assert_eq!(resp.status(), StatusCode::OK);

-        let mut srv =
-            init_service(App::new().data_factory(|| Ok::<_, ()>(10u32)).service(
-                web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
-            ));
-        let req = TestRequest::default().to_request();
-        let resp = block_on(srv.call(req)).unwrap();
-        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    }
+    //     let mut srv =
+    //         init_service(App::new().data_factory(|| Ok::<_, ()>(10u32)).service(
+    //             web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
+    //         ));
+    //     let req = TestRequest::default().to_request();
+    //     let resp = block_on(srv.call(req)).unwrap();
+    //     assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    // }

    fn md<S, B>(
        req: ServiceRequest,
@ -598,4 +600,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"));
+    }
 }
--- a/src/app_service.rs
+++ b/src/app_service.rs
@ -2,16 +2,16 @@ use std::cell::RefCell;
 use std::marker::PhantomData;
 use std::rc::Rc;

-use actix_http::{Request, Response};
+use actix_http::{Extensions, Request, Response};
 use actix_router::{Path, ResourceDef, ResourceInfo, Router, Url};
 use actix_server_config::ServerConfig;
 use actix_service::boxed::{self, BoxedNewService, BoxedService};
-use actix_service::{fn_service, NewService, Service};
+use actix_service::{service_fn, NewService, Service};
 use futures::future::{ok, Either, FutureResult};
 use futures::{Async, Future, Poll};

 use crate::config::{AppConfig, AppService};
-use crate::data::{DataFactory, DataFactoryResult};
+use crate::data::DataFactory;
 use crate::error::Error;
 use crate::guard::Guard;
 use crate::request::{HttpRequest, HttpRequestPool};
@ -31,6 +31,7 @@ type BoxedResponse = Either<
 pub struct AppInit<T, B>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse<B>,
        Error = Error,
@ -38,23 +39,25 @@ where
    >,
 {
    pub(crate) endpoint: T,
-    pub(crate) data: Vec<Box<DataFactory>>,
+    pub(crate) data: Rc<Vec<Box<DataFactory>>>,
    pub(crate) config: RefCell<AppConfig>,
-    pub(crate) services: RefCell<Vec<Box<ServiceFactory>>>,
+    pub(crate) services: Rc<RefCell<Vec<Box<ServiceFactory>>>>,
    pub(crate) default: Option<Rc<HttpNewService>>,
    pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
    pub(crate) external: RefCell<Vec<ResourceDef>>,
 }

-impl<T, B> NewService<ServerConfig> for AppInit<T, B>
+impl<T, B> NewService for AppInit<T, B>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse<B>,
        Error = Error,
        InitError = (),
    >,
 {
+    type Config = ServerConfig;
    type Request = Request;
    type Response = ServiceResponse<B>;
    type Error = T::Error;
@ -65,11 +68,12 @@ where
    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
        // update resource default service
        let default = self.default.clone().unwrap_or_else(|| {
-            Rc::new(boxed::new_service(fn_service(|req: ServiceRequest| {
+            Rc::new(boxed::new_service(service_fn(|req: ServiceRequest| {
                Ok(req.into_response(Response::NotFound().finish()))
            })))
        });

+        // App config
        {
            let mut c = self.config.borrow_mut();
            let loc_cfg = Rc::get_mut(&mut c.0).unwrap();
@ -77,7 +81,11 @@ where
            loc_cfg.addr = cfg.local_addr();
        }

-        let mut config = AppService::new(self.config.borrow().clone(), default.clone());
+        let mut config = AppService::new(
+            self.config.borrow().clone(),
+            default.clone(),
+            self.data.clone(),
+        );

        // register services
        std::mem::replace(&mut *self.services.borrow_mut(), Vec::new())
@ -86,12 +94,13 @@ where

        let mut rmap = ResourceMap::new(ResourceDef::new(""));

+        let (config, services) = config.into_services();
+
        // complete pipeline creation
        *self.factory_ref.borrow_mut() = Some(AppRoutingFactory {
            default,
            services: Rc::new(
-                config
-                    .into_services()
+                services
                    .into_iter()
                    .map(|(mut rdef, srv, guards, nested)| {
                        rmap.add(&mut rdef, nested);
@ -110,11 +119,17 @@ where
        let rmap = Rc::new(rmap);
        rmap.finish(rmap.clone());

+        // create app data container
+        let mut data = Extensions::new();
+        for f in self.data.iter() {
+            f.create(&mut data);
+        }
+
        AppInitResult {
            endpoint: None,
            endpoint_fut: self.endpoint.new_service(&()),
-            data: self.data.iter().map(|s| s.construct()).collect(),
-            config: self.config.borrow().clone(),
+            data: Rc::new(data),
+            config,
            rmap,
            _t: PhantomData,
        }
@ -128,14 +143,15 @@ where
    endpoint: Option<T::Service>,
    endpoint_fut: T::Future,
    rmap: Rc<ResourceMap>,
-    data: Vec<Box<DataFactoryResult>>,
    config: AppConfig,
+    data: Rc<Extensions>,
    _t: PhantomData<B>,
 }

 impl<T, B> Future for AppInitResult<T, B>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse<B>,
        Error = Error,
@ -146,16 +162,6 @@ where
    type Error = T::InitError;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let mut idx = 0;
-        let mut extensions = self.config.0.extensions.borrow_mut();
-        while idx < self.data.len() {
-            if let Async::Ready(_) = self.data[idx].poll_result(&mut extensions)? {
-                self.data.remove(idx);
-            } else {
-                idx += 1;
-            }
-        }
-
        if self.endpoint.is_none() {
            if let Async::Ready(srv) = self.endpoint_fut.poll()? {
                self.endpoint = Some(srv);
@ -167,6 +173,7 @@ where
                service: self.endpoint.take().unwrap(),
                rmap: self.rmap.clone(),
                config: self.config.clone(),
+                data: self.data.clone(),
                pool: HttpRequestPool::create(),
            }))
        } else {
@ -176,13 +183,14 @@ where
 }

 /// Service to convert `Request` to a `ServiceRequest<S>`
-pub struct AppInitService<T: Service, B>
+pub struct AppInitService<T, B>
 where
    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
    service: T,
    rmap: Rc<ResourceMap>,
    config: AppConfig,
+    data: Rc<Extensions>,
    pool: &'static HttpRequestPool,
 }

@ -207,17 +215,30 @@ where
            inner.path.get_mut().update(&head.uri);
            inner.path.reset();
            inner.head = head;
+            inner.payload = payload;
+            inner.app_data = self.data.clone();
            req
        } else {
            HttpRequest::new(
                Path::new(Url::new(head.uri.clone())),
                head,
+                payload,
                self.rmap.clone(),
                self.config.clone(),
+                self.data.clone(),
                self.pool,
            )
        };
-        self.service.call(ServiceRequest::from_parts(req, payload))
+        self.service.call(ServiceRequest::new(req))
+    }
+}
+
+impl<T, B> Drop for AppInitService<T, B>
+where
+    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+{
+    fn drop(&mut self) {
+        self.pool.clear();
    }
 }

@ -227,6 +248,7 @@ pub struct AppRoutingFactory {
 }

 impl NewService for AppRoutingFactory {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -385,6 +407,7 @@ impl AppEntry {
 }

 impl NewService for AppEntry {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -396,3 +419,37 @@ impl NewService for AppEntry {
        self.factory.borrow_mut().as_mut().unwrap().new_service(&())
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use actix_service::Service;
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    };
+
+    use crate::{test, web, App, HttpResponse};
+
+    struct DropData(Arc<AtomicBool>);
+
+    impl Drop for DropData {
+        fn drop(&mut self) {
+            self.0.store(true, Ordering::Relaxed);
+        }
+    }
+
+    #[test]
+    fn drop_data() {
+        let data = Arc::new(AtomicBool::new(false));
+        {
+            let mut app = test::init_service(
+                App::new()
+                    .data(DropData(data.clone()))
+                    .service(web::resource("/test").to(|| HttpResponse::Ok())),
+            );
+            let req = test::TestRequest::with_uri("/test").to_request();
+            let _ = test::block_on(app.call(req)).unwrap();
+        }
+        assert!(data.load(Ordering::Relaxed));
+    }
+}
--- a/src/config.rs
+++ b/src/config.rs
@ -1,11 +1,9 @@
-use std::cell::{Ref, RefCell};
 use std::net::SocketAddr;
 use std::rc::Rc;

 use actix_http::Extensions;
 use actix_router::ResourceDef;
 use actix_service::{boxed, IntoNewService, NewService};
-use futures::IntoFuture;

 use crate::data::{Data, DataFactory};
 use crate::error::Error;
@ -33,14 +31,20 @@ pub struct AppService {
        Option<Guards>,
        Option<Rc<ResourceMap>>,
    )>,
+    service_data: Rc<Vec<Box<DataFactory>>>,
 }

 impl AppService {
    /// Crate server settings instance
-    pub(crate) fn new(config: AppConfig, default: Rc<HttpNewService>) -> Self {
+    pub(crate) fn new(
+        config: AppConfig,
+        default: Rc<HttpNewService>,
+        service_data: Rc<Vec<Box<DataFactory>>>,
+    ) -> Self {
        AppService {
            config,
            default,
+            service_data,
            root: true,
            services: Vec::new(),
        }
@ -53,13 +57,16 @@ impl AppService {

    pub(crate) fn into_services(
        self,
-    ) -> Vec<(
-        ResourceDef,
-        HttpNewService,
-        Option<Guards>,
-        Option<Rc<ResourceMap>>,
-    )> {
-        self.services
+    ) -> (
+        AppConfig,
+        Vec<(
+            ResourceDef,
+            HttpNewService,
+            Option<Guards>,
+            Option<Rc<ResourceMap>>,
+        )>,
+    ) {
+        (self.config, self.services)
    }

    pub(crate) fn clone_config(&self) -> Self {
@ -68,6 +75,7 @@ impl AppService {
            default: self.default.clone(),
            services: Vec::new(),
            root: false,
+            service_data: self.service_data.clone(),
        }
    }

@ -81,6 +89,15 @@ impl AppService {
        self.default.clone()
    }

+    /// Set global route data
+    pub fn set_service_data(&self, extensions: &mut Extensions) -> bool {
+        for f in self.service_data.iter() {
+            f.create(extensions);
+        }
+        !self.service_data.is_empty()
+    }
+
+    /// Register http service
    pub fn register_service<F, S>(
        &mut self,
        rdef: ResourceDef,
@ -90,6 +107,7 @@ impl AppService {
    ) where
        F: IntoNewService<S>,
        S: NewService<
+                Config = (),
                Request = ServiceRequest,
                Response = ServiceResponse,
                Error = Error,
@ -133,24 +151,12 @@ impl AppConfig {
    pub fn local_addr(&self) -> SocketAddr {
        self.0.addr
    }
-
-    /// Resource map
-    pub fn rmap(&self) -> &ResourceMap {
-        &self.0.rmap
-    }
-
-    /// Application extensions
-    pub fn extensions(&self) -> Ref<Extensions> {
-        self.0.extensions.borrow()
-    }
 }

 pub(crate) struct AppConfigInner {
    pub(crate) secure: bool,
    pub(crate) host: String,
    pub(crate) addr: SocketAddr,
-    pub(crate) rmap: ResourceMap,
-    pub(crate) extensions: RefCell<Extensions>,
 }

 impl Default for AppConfigInner {
@ -159,8 +165,6 @@ impl Default for AppConfigInner {
            secure: false,
            addr: "127.0.0.1:8080".parse().unwrap(),
            host: "localhost:8080".to_owned(),
-            rmap: ResourceMap::new(ResourceDef::new("")),
-            extensions: RefCell::new(Extensions::new()),
        }
    }
 }
@ -193,21 +197,6 @@ impl ServiceConfig {
        self
    }

-    /// Set application data factory. This function is
-    /// similar to `.data()` but it accepts data factory. Data object get
-    /// constructed asynchronously during application initialization.
-    ///
-    /// This is same as `App::data_dactory()` method.
-    pub fn data_factory<F, R>(&mut self, data: F) -> &mut Self
-    where
-        F: Fn() -> R + 'static,
-        R: IntoFuture + 'static,
-        R::Error: std::fmt::Debug,
-    {
-        self.data.push(Box::new(data));
-        self
-    }
-
    /// Configure route for a specific path.
    ///
    /// This is same as `App::route()` method.
@ -253,11 +242,12 @@ impl ServiceConfig {
 #[cfg(test)]
 mod tests {
    use actix_service::Service;
+    use bytes::Bytes;

    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() {
@ -274,31 +264,63 @@ mod tests {
        assert_eq!(resp.status(), StatusCode::OK);
    }

+    // #[test]
+    // fn test_data_factory() {
+    //     let cfg = |cfg: &mut ServiceConfig| {
+    //         cfg.data_factory(|| {
+    //             sleep(std::time::Duration::from_millis(50)).then(|_| {
+    //                 println!("READY");
+    //                 Ok::<_, ()>(10usize)
+    //             })
+    //         });
+    //     };
+
+    //     let mut srv =
+    //         init_service(App::new().configure(cfg).service(
+    //             web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
+    //         ));
+    //     let req = TestRequest::default().to_request();
+    //     let resp = block_on(srv.call(req)).unwrap();
+    //     assert_eq!(resp.status(), StatusCode::OK);
+
+    //     let cfg2 = |cfg: &mut ServiceConfig| {
+    //         cfg.data_factory(|| Ok::<_, ()>(10u32));
+    //     };
+    //     let mut srv = init_service(
+    //         App::new()
+    //             .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()))
+    //             .configure(cfg2),
+    //     );
+    //     let req = TestRequest::default().to_request();
+    //     let resp = block_on(srv.call(req)).unwrap();
+    //     assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    // }
+
    #[test]
-    fn test_data_factory() {
-        let cfg = |cfg: &mut ServiceConfig| {
-            cfg.data_factory(|| Ok::<_, ()>(10usize));
-        };
-
-        let mut srv =
-            init_service(App::new().configure(cfg).service(
-                web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
-            ));
-        let req = TestRequest::default().to_request();
-        let resp = block_on(srv.call(req)).unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
-
-        let cfg2 = |cfg: &mut ServiceConfig| {
-            cfg.data_factory(|| Ok::<_, ()>(10u32));
-        };
+    fn test_external_resource() {
        let mut srv = init_service(
            App::new()
-                .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()))
-                .configure(cfg2),
+                .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::default().to_request();
-        let resp = block_on(srv.call(req)).unwrap();
-        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+        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]
--- a/src/data.rs
+++ b/src/data.rs
@ -3,7 +3,6 @@ use std::sync::Arc;

 use actix_http::error::{Error, ErrorInternalServerError};
 use actix_http::Extensions;
-use futures::{Async, Future, IntoFuture, Poll};

 use crate::dev::Payload;
 use crate::extract::FromRequest;
@ -11,11 +10,7 @@ use crate::request::HttpRequest;

 /// Application data factory
 pub(crate) trait DataFactory {
-    fn construct(&self) -> Box<DataFactoryResult>;
-}
-
-pub(crate) trait DataFactoryResult {
-    fn poll_result(&mut self, extensions: &mut Extensions) -> Poll<(), ()>;
+    fn create(&self, extensions: &mut Extensions) -> bool;
 }

 /// Application data.
@ -33,29 +28,33 @@ pub(crate) trait DataFactoryResult {
 /// instance for each thread, thus application data must be constructed
 /// multiple times. If you want to share data between different
 /// threads, a shareable object should be used, e.g. `Send + Sync`. Application
-/// data does not need to be `Send` or `Sync`. Internally `Data` instance
-/// uses `Arc`.
+/// data does not need to be `Send` or `Sync`. Internally `Data` type
+/// uses `Arc`. if your data implements `Send` + `Sync` traits you can
+/// use `web::Data::new()` and avoid double `Arc`.
 ///
 /// If route data is not set for a handler, using `Data<T>` extractor would
 /// cause *Internal Server Error* response.
 ///
 /// ```rust
-/// use std::cell::Cell;
+/// use std::sync::Mutex;
 /// use actix_web::{web, App};
 ///
 /// struct MyData {
-///     counter: Cell<usize>,
+///     counter: usize,
 /// }
 ///
 /// /// Use `Data<T>` extractor to access data in handler.
-/// fn index(data: web::Data<MyData>) {
-///     data.counter.set(data.counter.get() + 1);
+/// fn index(data: web::Data<Mutex<MyData>>) {
+///     let mut data = data.lock().unwrap();
+///     data.counter += 1;
 /// }
 ///
 /// fn main() {
+///     let data = web::Data::new(Mutex::new(MyData{ counter: 0 }));
+///
 ///     let app = App::new()
 ///         // Store `MyData` in application storage.
-///         .data(MyData{ counter: Cell::new(0) })
+///         .data(data.clone())
 ///         .service(
 ///             web::resource("/index.html").route(
 ///                 web::get().to(index)));
@ -65,7 +64,12 @@ pub(crate) trait DataFactoryResult {
 pub struct Data<T>(Arc<T>);

 impl<T> Data<T> {
-    pub(crate) fn new(state: T) -> Data<T> {
+    /// Create new `Data` instance.
+    ///
+    /// Internally `Data` type uses `Arc`. if your data implements
+    /// `Send` + `Sync` traits you can use `web::Data::new()` and
+    /// avoid double `Arc`.
+    pub fn new(state: T) -> Data<T> {
        Data(Arc::new(state))
    }

@ -96,8 +100,8 @@ impl<T: 'static> FromRequest for Data<T> {

    #[inline]
    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        if let Some(st) = req.app_config().extensions().get::<Data<T>>() {
-            Ok(st.clone())
+        if let Some(st) = req.get_app_data::<T>() {
+            Ok(st)
        } else {
            log::debug!(
                "Failed to construct App-level Data extractor. \
@ -112,142 +116,12 @@ impl<T: 'static> FromRequest for Data<T> {
 }

 impl<T: 'static> DataFactory for Data<T> {
-    fn construct(&self) -> Box<DataFactoryResult> {
-        Box::new(DataFut { st: self.clone() })
-    }
-}
-
-struct DataFut<T> {
-    st: Data<T>,
-}
-
-impl<T: 'static> DataFactoryResult for DataFut<T> {
-    fn poll_result(&mut self, extensions: &mut Extensions) -> Poll<(), ()> {
-        extensions.insert(self.st.clone());
-        Ok(Async::Ready(()))
-    }
-}
-
-impl<F, Out> DataFactory for F
-where
-    F: Fn() -> Out + 'static,
-    Out: IntoFuture + 'static,
-    Out::Error: std::fmt::Debug,
-{
-    fn construct(&self) -> Box<DataFactoryResult> {
-        Box::new(DataFactoryFut {
-            fut: (*self)().into_future(),
-        })
-    }
-}
-
-struct DataFactoryFut<T, F>
-where
-    F: Future<Item = T>,
-    F::Error: std::fmt::Debug,
-{
-    fut: F,
-}
-
-impl<T: 'static, F> DataFactoryResult for DataFactoryFut<T, F>
-where
-    F: Future<Item = T>,
-    F::Error: std::fmt::Debug,
-{
-    fn poll_result(&mut self, extensions: &mut Extensions) -> Poll<(), ()> {
-        match self.fut.poll() {
-            Ok(Async::Ready(s)) => {
-                extensions.insert(Data::new(s));
-                Ok(Async::Ready(()))
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(e) => {
-                log::error!("Can not construct application state: {:?}", e);
-                Err(())
-            }
-        }
-    }
-}
-
-/// Route data.
-///
-/// Route data is an arbitrary data attached to specific route.
-/// Route data could be added to route during route configuration process
-/// with `Route::data()` method. Route data is also used as an extractor
-/// configuration storage. Route data could be accessed in handler
-/// via `RouteData<T>` extractor.
-///
-/// If route data is not set for a handler, using `RouteData` extractor
-/// would cause *Internal Server Error* response.
-///
-/// ```rust
-/// # use std::cell::Cell;
-/// use actix_web::{web, App};
-///
-/// struct MyData {
-///     counter: Cell<usize>,
-/// }
-///
-/// /// Use `RouteData<T>` extractor to access data in handler.
-/// fn index(data: web::RouteData<MyData>) {
-///     data.counter.set(data.counter.get() + 1);
-/// }
-///
-/// fn main() {
-///     let app = App::new().service(
-///         web::resource("/index.html").route(
-///             web::get()
-///                // Store `MyData` in route storage
-///                .data(MyData{ counter: Cell::new(0) })
-///                // Route data could be used as extractor configuration storage,
-///                // limit size of the payload
-///                .data(web::PayloadConfig::new(4096))
-///                // register handler
-///                .to(index)
-///         ));
-/// }
-/// ```
-pub struct RouteData<T>(Arc<T>);
-
-impl<T> RouteData<T> {
-    pub(crate) fn new(state: T) -> RouteData<T> {
-        RouteData(Arc::new(state))
-    }
-
-    /// Get referecnce to inner data object.
-    pub fn get_ref(&self) -> &T {
-        self.0.as_ref()
-    }
-}
-
-impl<T> Deref for RouteData<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.0.as_ref()
-    }
-}
-
-impl<T> Clone for RouteData<T> {
-    fn clone(&self) -> RouteData<T> {
-        RouteData(self.0.clone())
-    }
-}
-
-impl<T: 'static> FromRequest for RouteData<T> {
-    type Config = ();
-    type Error = Error;
-    type Future = Result<Self, Error>;
-
-    #[inline]
-    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        if let Some(st) = req.route_data::<T>() {
-            Ok(st.clone())
+    fn create(&self, extensions: &mut Extensions) -> bool {
+        if !extensions.contains::<Data<T>>() {
+            let _ = extensions.insert(Data(self.0.clone()));
+            true
        } else {
-            log::debug!("Failed to construct Route-level Data extractor");
-            Err(ErrorInternalServerError(
-                "Route data is not configured, to configure use Route::data()",
-            ))
+            false
        }
    }
 }
@ -282,12 +156,13 @@ mod tests {

    #[test]
    fn test_route_data_extractor() {
-        let mut srv = init_service(App::new().service(web::resource("/").route(
-            web::get().data(10usize).to(|data: web::RouteData<usize>| {
-                let _ = data.clone();
-                HttpResponse::Ok()
-            }),
-        )));
+        let mut srv =
+            init_service(App::new().service(web::resource("/").data(10usize).route(
+                web::get().to(|data: web::Data<usize>| {
+                    let _ = data.clone();
+                    HttpResponse::Ok()
+                }),
+            )));

        let req = TestRequest::default().to_request();
        let resp = block_on(srv.call(req)).unwrap();
@ -296,15 +171,30 @@ mod tests {
        // different type
        let mut srv = init_service(
            App::new().service(
-                web::resource("/").route(
-                    web::get()
-                        .data(10u32)
-                        .to(|_: web::RouteData<usize>| HttpResponse::Ok()),
-                ),
+                web::resource("/")
+                    .data(10u32)
+                    .route(web::get().to(|_: web::Data<usize>| HttpResponse::Ok())),
            ),
        );
        let req = TestRequest::default().to_request();
        let resp = block_on(srv.call(req)).unwrap();
        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
    }
+
+    #[test]
+    fn test_override_data() {
+        let mut srv = init_service(App::new().data(1usize).service(
+            web::resource("/").data(10usize).route(web::get().to(
+                |data: web::Data<usize>| {
+                    assert_eq!(*data, 10);
+                    let _ = data.clone();
+                    HttpResponse::Ok()
+                },
+            )),
+        ));
+
+        let req = TestRequest::default().to_request();
+        let resp = block_on(srv.call(req)).unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }
--- a/src/error.rs
+++ b/src/error.rs
@ -6,6 +6,7 @@ use url::ParseError as UrlParseError;

 use crate::http::StatusCode;
 use crate::HttpResponse;
+use serde_urlencoded::de;

 /// Errors which can occur when attempting to generate resource uri.
 #[derive(Debug, PartialEq, Display, From)]
@ -91,6 +92,25 @@ impl ResponseError for JsonPayloadError {
    }
 }

+/// A set of errors that can occur during parsing query strings
+#[derive(Debug, Display, From)]
+pub enum QueryPayloadError {
+    /// Deserialize error
+    #[display(fmt = "Query deserialize error: {}", _0)]
+    Deserialize(de::Error),
+}
+
+/// Return `BadRequest` for `QueryPayloadError`
+impl ResponseError for QueryPayloadError {
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            QueryPayloadError::Deserialize(_) => {
+                HttpResponse::new(StatusCode::BAD_REQUEST)
+            }
+        }
+    }
+}
+
 /// Error type returned when reading body as lines.
 #[derive(From, Display, Debug)]
 pub enum ReadlinesError {
@ -143,6 +163,15 @@ mod tests {
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }

+    #[test]
+    fn test_query_payload_error() {
+        let resp: HttpResponse = QueryPayloadError::Deserialize(
+            serde_urlencoded::from_str::<i32>("bad query").unwrap_err(),
+        )
+        .error_response();
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
    #[test]
    fn test_readlines_error() {
        let resp: HttpResponse = ReadlinesError::LimitOverflow.error_response();
--- a/src/extract.rs
+++ b/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 {
@ -284,7 +283,7 @@ mod tests {
            header::CONTENT_TYPE,
            "application/x-www-form-urlencoded",
        )
-        .route_data(FormConfig::default().limit(4096))
+        .data(FormConfig::default().limit(4096))
        .to_http_parts();

        let r = block_on(Option::<Form<Info>>::from_request(&req, &mut pl)).unwrap();
@ -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());
-    }
 }
--- a/src/handler.rs
+++ b/src/handler.rs
@ -1,9 +1,8 @@
-use std::cell::RefCell;
+use std::convert::Infallible;
 use std::marker::PhantomData;
-use std::rc::Rc;

-use actix_http::{Error, Extensions, Payload, Response};
-use actix_service::{NewService, Service, Void};
+use actix_http::{Error, Response};
+use actix_service::{NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::{try_ready, Async, Future, IntoFuture, Poll};

@ -73,7 +72,7 @@ where
 {
    type Request = (T, HttpRequest);
    type Response = ServiceResponse;
-    type Error = Void;
+    type Error = Infallible;
    type Future = HandlerServiceResponse<<R::Future as IntoFuture>::Future>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -100,7 +99,7 @@ where
    T::Error: Into<Error>,
 {
    type Item = ServiceResponse;
-    type Error = Void;
+    type Error = Infallible;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        match self.fut.poll() {
@ -124,7 +123,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 +133,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 +146,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 +157,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 +172,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,12 +187,12 @@ 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);
    type Response = ServiceResponse;
-    type Error = Void;
+    type Error = Infallible;
    type Future = AsyncHandlerServiceResponse<R::Future>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -203,32 +202,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;
+    type Error = Infallible;

    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();
@ -243,15 +266,13 @@ where

 /// Extract arguments from request
 pub struct Extract<T: FromRequest, S> {
-    config: Rc<RefCell<Option<Rc<Extensions>>>>,
    service: S,
    _t: PhantomData<T>,
 }

 impl<T: FromRequest, S> Extract<T, S> {
-    pub fn new(config: Rc<RefCell<Option<Rc<Extensions>>>>, service: S) -> Self {
+    pub fn new(service: S) -> Self {
        Extract {
-            config,
            service,
            _t: PhantomData,
        }
@ -260,9 +281,13 @@ impl<T: FromRequest, S> Extract<T, S> {

 impl<T: FromRequest, S> NewService for Extract<T, S>
 where
-    S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>
-        + Clone,
+    S: Service<
+            Request = (T, HttpRequest),
+            Response = ServiceResponse,
+            Error = Infallible,
+        > + Clone,
 {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = (Error, ServiceRequest);
@ -273,22 +298,23 @@ where
    fn new_service(&self, _: &()) -> Self::Future {
        ok(ExtractService {
            _t: PhantomData,
-            config: self.config.borrow().clone(),
            service: self.service.clone(),
        })
    }
 }

 pub struct ExtractService<T: FromRequest, S> {
-    config: Option<Rc<Extensions>>,
    service: S,
    _t: PhantomData<T>,
 }

 impl<T: FromRequest, S> Service for ExtractService<T, S>
 where
-    S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>
-        + Clone,
+    S: Service<
+            Request = (T, HttpRequest),
+            Response = ServiceResponse,
+            Error = Infallible,
+        > + Clone,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse;
@ -300,21 +326,20 @@ where
    }

    fn call(&mut self, req: ServiceRequest) -> Self::Future {
-        let (mut req, mut payload) = req.into_parts();
-        req.set_route_data(self.config.clone());
+        let (req, mut payload) = req.into_parts();
        let fut = T::from_request(&req, &mut payload).into_future();

        ExtractResponse {
            fut,
+            req,
            fut_s: None,
-            req: Some((req, payload)),
            service: self.service.clone(),
        }
    }
 }

 pub struct ExtractResponse<T: FromRequest, S: Service> {
-    req: Option<(HttpRequest, Payload)>,
+    req: HttpRequest,
    service: S,
    fut: <T::Future as IntoFuture>::Future,
    fut_s: Option<S::Future>,
@ -322,7 +347,11 @@ pub struct ExtractResponse<T: FromRequest, S: Service> {

 impl<T: FromRequest, S> Future for ExtractResponse<T, S>
 where
-    S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>,
+    S: Service<
+        Request = (T, HttpRequest),
+        Response = ServiceResponse,
+        Error = Infallible,
+    >,
 {
    type Item = ServiceResponse;
    type Error = (Error, ServiceRequest);
@ -333,12 +362,11 @@ where
        }

        let item = try_ready!(self.fut.poll().map_err(|e| {
-            let (req, payload) = self.req.take().unwrap();
-            let req = ServiceRequest::from_parts(req, payload);
+            let req = ServiceRequest::new(self.req.clone());
            (e.into(), req)
        }));

-        self.fut_s = Some(self.service.call((item, self.req.take().unwrap().0)));
+        self.fut_s = Some(self.service.call((item, self.req.clone())));
        self.poll()
    }
 }
@ -357,7 +385,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 {
--- a/src/lib.rs
+++ b/src/lib.rs
@ -136,7 +136,9 @@ pub mod dev {
    pub use crate::config::{AppConfig, AppService};
    pub use crate::info::ConnectionInfo;
    pub use crate::rmap::ResourceMap;
-    pub use crate::service::{HttpServiceFactory, ServiceRequest, ServiceResponse};
+    pub use crate::service::{
+        HttpServiceFactory, ServiceRequest, ServiceResponse, WebService,
+    };
    pub use crate::types::form::UrlEncoded;
    pub use crate::types::json::JsonBody;
    pub use crate::types::readlines::Readlines;
@ -149,6 +151,7 @@ pub mod dev {
    };
    pub use actix_router::{Path, ResourceDef, ResourcePath, Url};
    pub use actix_server::Server;
+    pub use actix_service::{Service, Transform};

    pub(crate) fn insert_slash(path: &str) -> String {
        let mut path = path.to_owned();
--- a/src/middleware/compress.rs
+++ b/src/middleware/compress.rs
@ -6,7 +6,7 @@ use std::str::FromStr;
 use actix_http::body::MessageBody;
 use actix_http::encoding::Encoder;
 use actix_http::http::header::{ContentEncoding, ACCEPT_ENCODING};
-use actix_http::{Response, ResponseBuilder};
+use actix_http::{Error, Response, ResponseBuilder};
 use actix_service::{Service, Transform};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
@ -71,11 +71,11 @@ impl Default for Compress {
 impl<S, B> Transform<S> for Compress
 where
    B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = CompressMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -96,11 +96,11 @@ pub struct CompressMiddleware<S> {
 impl<S, B> Service for CompressMiddleware<S>
 where
    B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = CompressResponse<S, B>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -141,10 +141,10 @@ where
 impl<S, B> Future for CompressResponse<S, B>
 where
    B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
    type Item = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        let resp = futures::try_ready!(self.fut.poll());
--- a/src/middleware/cors.rs
+++ b/src/middleware/cors.rs
@ -47,7 +47,7 @@ use futures::future::{ok, Either, Future, FutureResult};
 use futures::Poll;

 use crate::dev::RequestHead;
-use crate::error::{ResponseError, Result};
+use crate::error::{Error, ResponseError, Result};
 use crate::http::header::{self, HeaderName, HeaderValue};
 use crate::http::{self, HttpTryFrom, Method, StatusCode, Uri};
 use crate::service::{ServiceRequest, ServiceResponse};
@ -81,13 +81,6 @@ pub enum CorsError {
        fmt = "The request header `Access-Control-Request-Headers`  has an invalid value"
    )]
    BadRequestHeaders,
-    /// The request header `Access-Control-Request-Headers`  is required but is
-    /// missing.
-    #[display(
-        fmt = "The request header `Access-Control-Request-Headers`  is required but is
-                     missing"
-    )]
-    MissingRequestHeaders,
    /// Origin is not allowed to make this request
    #[display(fmt = "Origin is not allowed to make this request")]
    OriginNotAllowed,
@ -477,9 +470,8 @@ fn cors<'a>(

 impl<S, B> IntoTransform<CorsFactory, S> for Cors
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
    B: 'static,
 {
    fn into_transform(self) -> CorsFactory {
@ -539,14 +531,13 @@ pub struct CorsFactory {

 impl<S, B> Transform<S> for CorsFactory
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
    B: 'static,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = CorsMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -663,15 +654,18 @@ impl Inner {
                                Err(_) => return Err(CorsError::BadRequestHeaders),
                            };
                        }
-
-                        if !hdrs.is_empty() && !hdrs.is_subset(allowed_headers) {
-                            return Err(CorsError::HeadersNotAllowed);
+                        // `Access-Control-Request-Headers` must contain 1 or more
+                        // `field-name`.
+                        if !hdrs.is_empty() {
+                            if !hdrs.is_subset(allowed_headers) {
+                                return Err(CorsError::HeadersNotAllowed);
+                            }
+                            return Ok(());
                        }
-                        return Ok(());
                    }
                    Err(CorsError::BadRequestHeaders)
                } else {
-                    Err(CorsError::MissingRequestHeaders)
+                    return Ok(());
                }
            }
        }
@ -680,17 +674,16 @@ impl Inner {

 impl<S, B> Service for CorsMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
    B: 'static,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = Either<
-        FutureResult<Self::Response, Self::Error>,
-        Either<S::Future, Box<Future<Item = Self::Response, Error = Self::Error>>>,
+        FutureResult<Self::Response, Error>,
+        Either<S::Future, Box<Future<Item = Self::Response, Error = Error>>>,
    >;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -812,22 +805,26 @@ where

 #[cfg(test)]
 mod tests {
-    use actix_service::{FnService, Transform};
+    use actix_service::{IntoService, Transform};

    use super::*;
    use crate::test::{self, block_on, TestRequest};

    impl Cors {
-        fn finish<S, B>(self, srv: S) -> CorsMiddleware<S>
+        fn finish<F, S, B>(self, srv: F) -> CorsMiddleware<S>
        where
-            S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>
-                + 'static,
+            F: IntoService<S>,
+            S: Service<
+                    Request = ServiceRequest,
+                    Response = ServiceResponse<B>,
+                    Error = Error,
+                > + 'static,
            S::Future: 'static,
-            S::Error: 'static,
            B: 'static,
        {
            block_on(
-                IntoTransform::<CorsFactory, S>::into_transform(self).new_transform(srv),
+                IntoTransform::<CorsFactory, S>::into_transform(self)
+                    .new_transform(srv.into_service()),
            )
            .unwrap()
        }
@ -875,6 +872,7 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
+            .header(header::ACCESS_CONTROL_REQUEST_HEADERS, "X-Not-Allowed")
            .to_srv_request();

        assert!(cors.inner.validate_allowed_method(req.head()).is_err());
@ -888,7 +886,7 @@ mod tests {
            .to_srv_request();

        assert!(cors.inner.validate_allowed_method(req.head()).is_err());
-        assert!(cors.inner.validate_allowed_headers(req.head()).is_err());
+        assert!(cors.inner.validate_allowed_headers(req.head()).is_ok());

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "POST")
@ -1067,11 +1065,11 @@ mod tests {
            .allowed_headers(exposed_headers.clone())
            .expose_headers(exposed_headers.clone())
            .allowed_header(header::CONTENT_TYPE)
-            .finish(FnService::new(move |req: ServiceRequest| {
+            .finish(|req: ServiceRequest| {
                req.into_response(
                    HttpResponse::Ok().header(header::VARY, "Accept").finish(),
                )
-            }));
+            });
        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
            .to_srv_request();
--- a/src/middleware/defaultheaders.rs
+++ b/src/middleware/defaultheaders.rs
@ -8,6 +8,7 @@ use futures::{Future, Poll};
 use crate::http::header::{HeaderName, HeaderValue, CONTENT_TYPE};
 use crate::http::{HeaderMap, HttpTryFrom};
 use crate::service::{ServiceRequest, ServiceResponse};
+use crate::Error;

 /// `Middleware` for setting default response headers.
 ///
@ -87,12 +88,12 @@ impl DefaultHeaders {

 impl<S, B> Transform<S> for DefaultHeaders
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = DefaultHeadersMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -112,12 +113,12 @@ pub struct DefaultHeadersMiddleware<S> {

 impl<S, B> Service for DefaultHeadersMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -149,7 +150,7 @@ where

 #[cfg(test)]
 mod tests {
-    use actix_service::FnService;
+    use actix_service::IntoService;

    use super::*;
    use crate::dev::ServiceRequest;
@ -171,13 +172,13 @@ mod tests {
        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");

        let req = TestRequest::default().to_srv_request();
-        let srv = FnService::new(|req: ServiceRequest| {
+        let srv = |req: ServiceRequest| {
            req.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish())
-        });
+        };
        let mut mw = block_on(
            DefaultHeaders::new()
                .header(CONTENT_TYPE, "0001")
-                .new_transform(srv),
+                .new_transform(srv.into_service()),
        )
        .unwrap();
        let resp = block_on(mw.call(req)).unwrap();
@ -186,11 +187,13 @@ mod tests {

    #[test]
    fn test_content_type() {
-        let srv = FnService::new(|req: ServiceRequest| {
-            req.into_response(HttpResponse::Ok().finish())
-        });
-        let mut mw =
-            block_on(DefaultHeaders::new().content_type().new_transform(srv)).unwrap();
+        let srv = |req: ServiceRequest| req.into_response(HttpResponse::Ok().finish());
+        let mut mw = block_on(
+            DefaultHeaders::new()
+                .content_type()
+                .new_transform(srv.into_service()),
+        )
+        .unwrap();

        let req = TestRequest::default().to_srv_request();
        let resp = block_on(mw.call(req)).unwrap();
--- a/src/middleware/errhandlers.rs
+++ b/src/middleware/errhandlers.rs
@ -85,7 +85,6 @@ impl<S, B> Transform<S> for ErrorHandlers<B>
 where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
    B: 'static,
 {
    type Request = ServiceRequest;
@ -113,7 +112,6 @@ impl<S, B> Service for ErrorHandlersMiddleware<S, B>
 where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
    B: 'static,
 {
    type Request = ServiceRequest;
@ -144,7 +142,7 @@ where

 #[cfg(test)]
 mod tests {
-    use actix_service::FnService;
+    use actix_service::IntoService;
    use futures::future::ok;

    use super::*;
@ -161,14 +159,14 @@ mod tests {

    #[test]
    fn test_handler() {
-        let srv = FnService::new(|req: ServiceRequest| {
+        let srv = |req: ServiceRequest| {
            req.into_response(HttpResponse::InternalServerError().finish())
-        });
+        };

        let mut mw = test::block_on(
            ErrorHandlers::new()
                .handler(StatusCode::INTERNAL_SERVER_ERROR, render_500)
-                .new_transform(srv),
+                .new_transform(srv.into_service()),
        )
        .unwrap();

@ -187,14 +185,14 @@ mod tests {

    #[test]
    fn test_handler_async() {
-        let srv = FnService::new(|req: ServiceRequest| {
+        let srv = |req: ServiceRequest| {
            req.into_response(HttpResponse::InternalServerError().finish())
-        });
+        };

        let mut mw = test::block_on(
            ErrorHandlers::new()
                .handler(StatusCode::INTERNAL_SERVER_ERROR, render_500_async)
-                .new_transform(srv),
+                .new_transform(srv.into_service()),
        )
        .unwrap();

--- a/src/middleware/identity.rs
+++ b/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};
@ -201,15 +203,15 @@ impl<T> IdentityService<T> {

 impl<S, T, B> Transform<S> for IdentityService<T>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>> + 'static,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>
+        + 'static,
    S::Future: 'static,
-    S::Error: 'static,
    T: IdentityPolicy,
    B: 'static,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = IdentityServiceMiddleware<S, T>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -231,14 +233,14 @@ pub struct IdentityServiceMiddleware<S, T> {
 impl<S, T, B> Service for IdentityServiceMiddleware<S, T>
 where
    B: 'static,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>> + 'static,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>
+        + 'static,
    S::Future: 'static,
-    S::Error: 'static,
    T: IdentityPolicy,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -284,84 +286,149 @@ 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);
-
-            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);
+        let add_cookie = value.is_some();
+        let val = value.map(|val| {
+            if !self.legacy_supported() {
+                serde_json::to_string(&val)
            } else {
-                jar.add_original(cookie.clone());
-                jar.private(&self.key).remove(cookie);
+                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);

-            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 +494,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 +510,22 @@ 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
+    ///
+    /// By default visit deadline is disabled.
+    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
+    ///
+    /// By default login deadline is disabled.
+    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 +533,19 @@ 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 +554,36 @@ 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 +595,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 +620,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 +658,380 @@ 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,
+        );
+    }
 }
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@ -53,7 +53,7 @@ use crate::HttpResponse;
 ///
 /// `%a`  Remote IP-address (IP-address of proxy if using reverse proxy)
 ///
-/// `%t`  Time when the request was started to process
+/// `%t`  Time when the request was started to process (in rfc3339 format)
 ///
 /// `%r`  First line of request
 ///
@ -116,12 +116,12 @@ impl Default for Logger {

 impl<S, B> Transform<S> for Logger
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    B: MessageBody,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = LoggerMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -142,12 +142,12 @@ pub struct LoggerMiddleware<S> {

 impl<S, B> Service for LoggerMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    B: MessageBody,
 {
    type Request = ServiceRequest;
    type Response = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = LoggerResponse<S, B>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@ -194,10 +194,10 @@ where
 impl<S, B> Future for LoggerResponse<S, B>
 where
    B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
    type Item = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        let res = futures::try_ready!(self.fut.poll());
@ -417,10 +417,7 @@ impl FormatText {
            }
            FormatText::UrlPath => *self = FormatText::Str(format!("{}", req.path())),
            FormatText::RequestTime => {
-                *self = FormatText::Str(format!(
-                    "{:?}",
-                    now.strftime("[%d/%b/%Y:%H:%M:%S %z]").unwrap()
-                ))
+                *self = FormatText::Str(format!("{}", now.rfc3339()))
            }
            FormatText::RequestHeader(ref name) => {
                let s = if let Some(val) = req.headers().get(name) {
@ -457,7 +454,7 @@ impl<'a> fmt::Display for FormatDisplay<'a> {

 #[cfg(test)]
 mod tests {
-    use actix_service::{FnService, Service, Transform};
+    use actix_service::{IntoService, Service, Transform};

    use super::*;
    use crate::http::{header, StatusCode};
@ -465,16 +462,16 @@ mod tests {

    #[test]
    fn test_logger() {
-        let srv = FnService::new(|req: ServiceRequest| {
+        let srv = |req: ServiceRequest| {
            req.into_response(
                HttpResponse::build(StatusCode::OK)
                    .header("X-Test", "ttt")
                    .finish(),
            )
-        });
+        };
        let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");

-        let mut srv = block_on(logger.new_transform(srv)).unwrap();
+        let mut srv = block_on(logger.new_transform(srv.into_service())).unwrap();

        let req = TestRequest::with_header(
            header::USER_AGENT,
@ -547,4 +544,29 @@ mod tests {
        assert!(s.contains("200 1024"));
        assert!(s.contains("ACTIX-WEB"));
    }
+
+    #[test]
+    fn test_request_time_format() {
+        let mut format = Format::new("%t");
+        let req = TestRequest::default().to_srv_request();
+
+        let now = time::now();
+        for unit in &mut format.0 {
+            unit.render_request(now, &req);
+        }
+
+        let resp = HttpResponse::build(StatusCode::OK).force_close().finish();
+        for unit in &mut format.0 {
+            unit.render_response(&resp);
+        }
+
+        let render = |fmt: &mut Formatter| {
+            for unit in &format.0 {
+                unit.render(fmt, 1024, now)?;
+            }
+            Ok(())
+        };
+        let s = format!("{}", FormatDisplay(&render));
+        assert!(s.contains(&format!("{}", now.rfc3339())));
+    }
 }
--- a/src/middleware/mod.rs
+++ b/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;
--- a/src/middleware/normalize.rs
+++ b/src/middleware/normalize.rs
@ -0,0 +1,155 @@
+//! `Middleware` to normalize request's URI
+
+use actix_http::http::{HttpTryFrom, PathAndQuery, Uri};
+use actix_service::{Service, Transform};
+use bytes::Bytes;
+use futures::future::{self, FutureResult};
+use regex::Regex;
+
+use crate::service::{ServiceRequest, ServiceResponse};
+use crate::Error;
+
+#[derive(Default, Clone, Copy)]
+/// `Middleware` to normalize request's URI in place
+///
+/// Performs following:
+///
+/// - Merges multiple slashes into one.
+///
+/// ```rust
+/// use actix_web::{web, http, middleware, App, HttpResponse};
+///
+/// fn main() {
+///     let app = App::new()
+///         .wrap(middleware::NormalizePath)
+///         .service(
+///             web::resource("/test")
+///                 .route(web::get().to(|| HttpResponse::Ok()))
+///                 .route(web::method(http::Method::HEAD).to(|| HttpResponse::MethodNotAllowed()))
+///         );
+/// }
+/// ```
+
+pub struct NormalizePath;
+
+impl<S, B> Transform<S> for NormalizePath
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = 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, B> Service for NormalizePathNormalization<S>
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = 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() {
+            let mut parts = head.uri.clone().into_parts();
+            let pq = parts.path_and_query.as_ref().unwrap();
+
+            let path = if let Some(q) = pq.query() {
+                Bytes::from(format!("{}?{}", path, q))
+            } else {
+                Bytes::from(path.as_ref())
+            };
+            parts.path_and_query = Some(PathAndQuery::try_from(path).unwrap());
+
+            let uri = Uri::from_parts(parts).unwrap();
+            req.match_info_mut().get_mut().update(&uri);
+            req.head_mut().uri = uri;
+        }
+
+        self.service.call(req)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_service::IntoService;
+
+    use super::*;
+    use crate::dev::ServiceRequest;
+    use crate::test::{block_on, call_service, init_service, TestRequest};
+    use crate::{web, App, HttpResponse};
+
+    #[test]
+    fn test_wrap() {
+        let mut app = init_service(
+            App::new()
+                .wrap(NormalizePath::default())
+                .service(web::resource("/v1/something/").to(|| HttpResponse::Ok())),
+        );
+
+        let req = TestRequest::with_uri("/v1//something////").to_request();
+        let res = call_service(&mut app, req);
+        assert!(res.status().is_success());
+    }
+
+    #[test]
+    fn test_in_place_normalization() {
+        let srv = |req: ServiceRequest| {
+            assert_eq!("/v1/something/", req.path());
+            req.into_response(HttpResponse::Ok().finish())
+        };
+
+        let mut normalize =
+            block_on(NormalizePath.new_transform(srv.into_service())).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 = |req: ServiceRequest| {
+            assert_eq!(URI, req.path());
+            req.into_response(HttpResponse::Ok().finish())
+        };
+
+        let mut normalize =
+            block_on(NormalizePath.new_transform(srv.into_service())).unwrap();
+
+        let req = TestRequest::with_uri(URI).to_srv_request();
+        let res = block_on(normalize.call(req)).unwrap();
+        assert!(res.status().is_success());
+    }
+
+}
--- a/src/request.rs
+++ b/src/request.rs
@ -7,7 +7,7 @@ use actix_http::{Error, Extensions, HttpMessage, Message, Payload, RequestHead};
 use actix_router::{Path, Url};

 use crate::config::AppConfig;
-use crate::data::{Data, RouteData};
+use crate::data::Data;
 use crate::error::UrlGenerationError;
 use crate::extract::FromRequest;
 use crate::info::ConnectionInfo;
@ -20,9 +20,10 @@ pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
 pub(crate) struct HttpRequestInner {
    pub(crate) head: Message<RequestHead>,
    pub(crate) path: Path<Url>,
+    pub(crate) payload: Payload,
+    pub(crate) app_data: Rc<Extensions>,
    rmap: Rc<ResourceMap>,
    config: AppConfig,
-    route_data: Option<Rc<Extensions>>,
    pool: &'static HttpRequestPool,
 }

@ -31,17 +32,20 @@ impl HttpRequest {
    pub(crate) fn new(
        path: Path<Url>,
        head: Message<RequestHead>,
+        payload: Payload,
        rmap: Rc<ResourceMap>,
        config: AppConfig,
+        app_data: Rc<Extensions>,
        pool: &'static HttpRequestPool,
    ) -> HttpRequest {
        HttpRequest(Rc::new(HttpRequestInner {
            head,
            path,
+            payload,
            rmap,
            config,
+            app_data,
            pool,
-            route_data: None,
        }))
    }
 }
@ -195,27 +199,23 @@ impl HttpRequest {

    /// Get an application data stored with `App::data()` method during
    /// application configuration.
-    pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
-        if let Some(st) = self.0.config.extensions().get::<Data<T>>() {
+    pub fn app_data<T: 'static>(&self) -> Option<&T> {
+        if let Some(st) = self.0.app_data.get::<Data<T>>() {
+            Some(&st)
+        } else {
+            None
+        }
+    }
+
+    /// Get an application data stored with `App::data()` method during
+    /// application configuration.
+    pub fn get_app_data<T: 'static>(&self) -> Option<Data<T>> {
+        if let Some(st) = self.0.app_data.get::<Data<T>>() {
            Some(st.clone())
        } else {
            None
        }
    }
-
-    /// Load route data. Route data could be set during
-    /// route configuration with `Route::data()` method.
-    pub fn route_data<T: 'static>(&self) -> Option<&RouteData<T>> {
-        if let Some(ref ext) = self.0.route_data {
-            ext.get::<RouteData<T>>()
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn set_route_data(&mut self, data: Option<Rc<Extensions>>) {
-        Rc::get_mut(&mut self.0).unwrap().route_data = data;
-    }
 }

 impl HttpMessage for HttpRequest {
@ -328,6 +328,10 @@ impl HttpRequestPool {
            None
        }
    }
+
+    pub(crate) fn clear(&self) {
+        self.0.borrow_mut().clear()
+    }
 }

 #[cfg(test)]
--- a/src/resource.rs
+++ b/src/resource.rs
@ -2,7 +2,7 @@ use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;

-use actix_http::{Error, Response};
+use actix_http::{Error, Extensions, Response};
 use actix_service::boxed::{self, BoxedNewService, BoxedService};
 use actix_service::{
    apply_transform, IntoNewService, IntoTransform, NewService, Service, Transform,
@ -10,6 +10,7 @@ use actix_service::{
 use futures::future::{ok, Either, FutureResult};
 use futures::{Async, Future, IntoFuture, Poll};

+use crate::data::Data;
 use crate::dev::{insert_slash, AppService, HttpServiceFactory, ResourceDef};
 use crate::extract::FromRequest;
 use crate::guard::Guard;
@ -48,6 +49,7 @@ pub struct Resource<T = ResourceEndpoint> {
    rdef: String,
    name: Option<String>,
    routes: Vec<Route>,
+    data: Option<Extensions>,
    guards: Vec<Box<Guard>>,
    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
    factory_ref: Rc<RefCell<Option<ResourceFactory>>>,
@ -64,6 +66,7 @@ impl Resource {
            endpoint: ResourceEndpoint::new(fref.clone()),
            factory_ref: fref,
            guards: Vec::new(),
+            data: None,
            default: Rc::new(RefCell::new(None)),
        }
    }
@ -72,6 +75,7 @@ impl Resource {
 impl<T> Resource<T>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse,
        Error = Error,
@ -154,7 +158,42 @@ where
    /// # fn delete_handler() {}
    /// ```
    pub fn route(mut self, route: Route) -> Self {
-        self.routes.push(route.finish());
+        self.routes.push(route);
+        self
+    }
+
+    /// Provide resource specific data. This method allows to add extractor
+    /// configuration or specific state available via `Data<T>` extractor.
+    /// Provided data is available for all routes registered for the current resource.
+    /// Resource data overrides data registered by `App::data()` method.
+    ///
+    /// ```rust
+    /// use actix_web::{web, App, FromRequest};
+    ///
+    /// /// extract text data from request
+    /// fn index(body: String) -> String {
+    ///     format!("Body {}!", body)
+    /// }
+    ///
+    /// fn main() {
+    ///     let app = App::new().service(
+    ///         web::resource("/index.html")
+    ///           // limit size of the payload
+    ///           .data(String::configure(|cfg| {
+    ///                cfg.limit(4096)
+    ///           }))
+    ///           .route(
+    ///               web::get()
+    ///                  // register handler
+    ///                  .to(index)
+    ///           ));
+    /// }
+    /// ```
+    pub fn data<U: 'static>(mut self, data: U) -> Self {
+        if self.data.is_none() {
+            self.data = Some(Extensions::new());
+        }
+        self.data.as_mut().unwrap().insert(Data::new(data));
        self
    }

@ -217,7 +256,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));
@ -236,6 +275,7 @@ where
        mw: F,
    ) -> Resource<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
@ -260,6 +300,7 @@ where
            guards: self.guards,
            routes: self.routes,
            default: self.default,
+            data: self.data,
            factory_ref: self.factory_ref,
        }
    }
@ -301,6 +342,7 @@ where
        mw: F,
    ) -> Resource<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
@ -321,6 +363,7 @@ where
    where
        F: IntoNewService<U>,
        U: NewService<
+                Config = (),
                Request = ServiceRequest,
                Response = ServiceResponse,
                Error = Error,
@ -341,6 +384,7 @@ where
 impl<T> HttpServiceFactory for Resource<T>
 where
    T: NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
@ -361,6 +405,10 @@ where
        if let Some(ref name) = self.name {
            *rdef.name_mut() = name.clone();
        }
+        // custom app data storage
+        if let Some(ref mut ext) = self.data {
+            config.set_service_data(ext);
+        }
        config.register_service(rdef, guards, self, None)
    }
 }
@ -368,6 +416,7 @@ where
 impl<T> IntoNewService<T> for Resource<T>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse,
        Error = Error,
@ -377,6 +426,7 @@ where
    fn into_new_service(self) -> T {
        *self.factory_ref.borrow_mut() = Some(ResourceFactory {
            routes: self.routes,
+            data: self.data.map(|data| Rc::new(data)),
            default: self.default,
        });

@ -386,10 +436,12 @@ where

 pub struct ResourceFactory {
    routes: Vec<Route>,
+    data: Option<Rc<Extensions>>,
    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }

 impl NewService for ResourceFactory {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -410,6 +462,7 @@ impl NewService for ResourceFactory {
                .iter()
                .map(|route| CreateRouteServiceItem::Future(route.new_service(&())))
                .collect(),
+            data: self.data.clone(),
            default: None,
            default_fut,
        }
@ -423,6 +476,7 @@ enum CreateRouteServiceItem {

 pub struct CreateResourceService {
    fut: Vec<CreateRouteServiceItem>,
+    data: Option<Rc<Extensions>>,
    default: Option<HttpService>,
    default_fut: Option<Box<Future<Item = HttpService, Error = ()>>>,
 }
@ -467,6 +521,7 @@ impl Future for CreateResourceService {
                .collect();
            Ok(Async::Ready(ResourceService {
                routes,
+                data: self.data.clone(),
                default: self.default.take(),
            }))
        } else {
@ -477,6 +532,7 @@ impl Future for CreateResourceService {

 pub struct ResourceService {
    routes: Vec<RouteService>,
+    data: Option<Rc<Extensions>>,
    default: Option<HttpService>,
 }

@ -496,6 +552,9 @@ impl Service for ResourceService {
    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
        for route in self.routes.iter_mut() {
            if route.check(&mut req) {
+                if let Some(ref data) = self.data {
+                    req.set_data_container(data.clone());
+                }
                return route.call(req);
            }
        }
@ -523,6 +582,7 @@ impl ResourceEndpoint {
 }

 impl NewService for ResourceEndpoint {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -546,7 +606,7 @@ mod tests {
    use crate::http::{header, HeaderValue, Method, StatusCode};
    use crate::service::{ServiceRequest, ServiceResponse};
    use crate::test::{call_service, init_service, TestRequest};
-    use crate::{web, App, Error, HttpResponse};
+    use crate::{guard, web, App, Error, HttpResponse};

    fn md<S, B>(
        req: ServiceRequest,
@ -663,4 +723,45 @@ mod tests {
        let resp = call_service(&mut srv, req);
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }
+
+    #[test]
+    fn test_resource_guards() {
+        let mut srv = init_service(
+            App::new()
+                .service(
+                    web::resource("/test/{p}")
+                        .guard(guard::Get())
+                        .to(|| HttpResponse::Ok()),
+                )
+                .service(
+                    web::resource("/test/{p}")
+                        .guard(guard::Put())
+                        .to(|| HttpResponse::Created()),
+                )
+                .service(
+                    web::resource("/test/{p}")
+                        .guard(guard::Delete())
+                        .to(|| HttpResponse::NoContent()),
+                ),
+        );
+
+        let req = TestRequest::with_uri("/test/it")
+            .method(Method::GET)
+            .to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test/it")
+            .method(Method::PUT)
+            .to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::CREATED);
+
+        let req = TestRequest::with_uri("/test/it")
+            .method(Method::DELETE)
+            .to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::NO_CONTENT);
+    }
+
 }
--- a/src/responder.rs
+++ b/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 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 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")
+        );
+    }
 }
--- a/src/route.rs
+++ b/src/route.rs
@ -1,12 +1,10 @@
-use std::cell::RefCell;
 use std::rc::Rc;

-use actix_http::{http::Method, Error, Extensions, Response};
+use actix_http::{http::Method, Error};
 use actix_service::{NewService, Service};
 use futures::future::{ok, Either, FutureResult};
 use futures::{Async, Future, IntoFuture, Poll};

-use crate::data::RouteData;
 use crate::extract::FromRequest;
 use crate::guard::{self, Guard};
 use crate::handler::{AsyncFactory, AsyncHandler, Extract, Factory, Handler};
@ -28,6 +26,7 @@ type BoxedRouteService<Req, Res> = Box<

 type BoxedRouteNewService<Req, Res> = Box<
    NewService<
+        Config = (),
        Request = Req,
        Response = Res,
        Error = Error,
@ -44,36 +43,26 @@ type BoxedRouteNewService<Req, Res> = Box<
 pub struct Route {
    service: BoxedRouteNewService<ServiceRequest, ServiceResponse>,
    guards: Rc<Vec<Box<Guard>>>,
-    data: Option<Extensions>,
-    data_ref: Rc<RefCell<Option<Rc<Extensions>>>>,
 }

 impl Route {
    /// Create new route which matches any request.
    pub fn new() -> Route {
-        let data_ref = Rc::new(RefCell::new(None));
        Route {
-            service: Box::new(RouteNewService::new(Extract::new(
-                data_ref.clone(),
-                Handler::new(|| HttpResponse::NotFound()),
-            ))),
+            service: Box::new(RouteNewService::new(Extract::new(Handler::new(|| {
+                HttpResponse::NotFound()
+            })))),
            guards: Rc::new(Vec::new()),
-            data: None,
-            data_ref,
        }
    }

-    pub(crate) fn finish(mut self) -> Self {
-        *self.data_ref.borrow_mut() = self.data.take().map(Rc::new);
-        self
-    }
-
    pub(crate) fn take_guards(&mut self) -> Vec<Box<Guard>> {
        std::mem::replace(Rc::get_mut(&mut self.guards).unwrap(), Vec::new())
    }
 }

 impl NewService for Route {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -239,10 +228,8 @@ impl Route {
        T: FromRequest + 'static,
        R: Responder + 'static,
    {
-        self.service = Box::new(RouteNewService::new(Extract::new(
-            self.data_ref.clone(),
-            Handler::new(handler),
-        )));
+        self.service =
+            Box::new(RouteNewService::new(Extract::new(Handler::new(handler))));
        self
    }

@ -278,45 +265,12 @@ 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(
-            self.data_ref.clone(),
-            AsyncHandler::new(handler),
-        )));
-        self
-    }
-
-    /// Provide route specific data. This method allows to add extractor
-    /// configuration or specific state available via `RouteData<T>` extractor.
-    ///
-    /// ```rust
-    /// use actix_web::{web, App, FromRequest};
-    ///
-    /// /// extract text data from request
-    /// fn index(body: String) -> String {
-    ///     format!("Body {}!", body)
-    /// }
-    ///
-    /// fn main() {
-    ///     let app = App::new().service(
-    ///         web::resource("/index.html").route(
-    ///             web::get()
-    ///                // limit size of the payload
-    ///                .data(String::configure(|cfg| {
-    ///                    cfg.limit(4096)
-    ///                }))
-    ///                // register handler
-    ///                .to(index)
-    ///         ));
-    /// }
-    /// ```
-    pub fn data<T: 'static>(mut self, data: T) -> Self {
-        if self.data.is_none() {
-            self.data = Some(Extensions::new());
-        }
-        self.data.as_mut().unwrap().insert(RouteData::new(data));
+        self.service = Box::new(RouteNewService::new(Extract::new(AsyncHandler::new(
+            handler,
+        ))));
        self
    }
 }
@ -331,6 +285,7 @@ where
 impl<T> RouteNewService<T>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse,
        Error = (Error, ServiceRequest),
@ -347,6 +302,7 @@ where
 impl<T> NewService for RouteNewService<T>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse,
        Error = (Error, ServiceRequest),
@ -355,6 +311,7 @@ where
    T::Service: 'static,
    <T::Service as Service>::Future: 'static,
 {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -418,18 +375,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 +408,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 +447,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\"}"));
    }
 }
--- a/src/scope.rs
+++ b/src/scope.rs
@ -2,15 +2,16 @@ use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;

-use actix_http::Response;
+use actix_http::{Extensions, Response};
 use actix_router::{ResourceDef, ResourceInfo, Router};
 use actix_service::boxed::{self, BoxedNewService, BoxedService};
 use actix_service::{
-    ApplyTransform, IntoNewService, IntoTransform, NewService, Service, Transform,
+    apply_transform, IntoNewService, IntoTransform, NewService, Service, Transform,
 };
 use futures::future::{ok, Either, Future, FutureResult};
 use futures::{Async, IntoFuture, Poll};

+use crate::data::Data;
 use crate::dev::{AppService, HttpServiceFactory};
 use crate::error::Error;
 use crate::guard::Guard;
@ -61,6 +62,7 @@ type BoxedResponse = Either<
 pub struct Scope<T = ScopeEndpoint> {
    endpoint: T,
    rdef: String,
+    data: Option<Extensions>,
    services: Vec<Box<ServiceFactory>>,
    guards: Vec<Box<Guard>>,
    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
@ -74,6 +76,7 @@ impl Scope {
        Scope {
            endpoint: ScopeEndpoint::new(fref.clone()),
            rdef: path.to_string(),
+            data: None,
            guards: Vec::new(),
            services: Vec::new(),
            default: Rc::new(RefCell::new(None)),
@ -85,6 +88,7 @@ impl Scope {
 impl<T> Scope<T>
 where
    T: NewService<
+        Config = (),
        Request = ServiceRequest,
        Response = ServiceResponse,
        Error = Error,
@ -116,6 +120,39 @@ where
        self
    }

+    /// Set or override application data. Application data could be accessed
+    /// by using `Data<T>` extractor where `T` is data type.
+    ///
+    /// ```rust
+    /// use std::cell::Cell;
+    /// use actix_web::{web, App};
+    ///
+    /// struct MyData {
+    ///     counter: Cell<usize>,
+    /// }
+    ///
+    /// fn index(data: web::Data<MyData>) {
+    ///     data.counter.set(data.counter.get() + 1);
+    /// }
+    ///
+    /// fn main() {
+    ///     let app = App::new().service(
+    ///         web::scope("/app")
+    ///             .data(MyData{ counter: Cell::new(0) })
+    ///             .service(
+    ///                 web::resource("/index.html").route(
+    ///                     web::get().to(index)))
+    ///     );
+    /// }
+    /// ```
+    pub fn data<U: 'static>(mut self, data: U) -> Self {
+        if self.data.is_none() {
+            self.data = Some(Extensions::new());
+        }
+        self.data.as_mut().unwrap().insert(Data::new(data));
+        self
+    }
+
    /// Register http service.
    ///
    /// This is similar to `App's` service registration.
@ -188,6 +225,7 @@ where
    where
        F: IntoNewService<U>,
        U: NewService<
+                Config = (),
                Request = ServiceRequest,
                Response = ServiceResponse,
                Error = Error,
@ -218,6 +256,7 @@ where
        mw: F,
    ) -> Scope<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
@ -234,10 +273,11 @@ where
        >,
        F: IntoTransform<M, T::Service>,
    {
-        let endpoint = ApplyTransform::new(mw, self.endpoint);
+        let endpoint = apply_transform(mw, self.endpoint);
        Scope {
            endpoint,
            rdef: self.rdef,
+            data: self.data,
            guards: self.guards,
            services: self.services,
            default: self.default,
@ -247,7 +287,7 @@ where

    /// Registers middleware, in the form of a closure, that runs during inbound
    /// processing in the request lifecycle (request -> response), modifying
-    /// request as necessary, across all requests managed by the *Scope*.  
+    /// request as necessary, across all requests managed by the *Scope*.
    /// Scope-level middleware is more limited in what it can modify, relative
    /// to Route or Application level middleware, in that Scope-level middleware
    /// can not modify ServiceResponse.
@ -280,6 +320,7 @@ where
        mw: F,
    ) -> Scope<
        impl NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
@ -297,13 +338,14 @@ where
 impl<T> HttpServiceFactory for Scope<T>
 where
    T: NewService<
+            Config = (),
            Request = ServiceRequest,
            Response = ServiceResponse,
            Error = Error,
            InitError = (),
        > + 'static,
 {
-    fn register(self, config: &mut AppService) {
+    fn register(mut self, config: &mut AppService) {
        // update default resource if needed
        if self.default.borrow().is_none() {
            *self.default.borrow_mut() = Some(config.default_service());
@ -317,11 +359,18 @@ where

        let mut rmap = ResourceMap::new(ResourceDef::root_prefix(&self.rdef));

+        // custom app data storage
+        if let Some(ref mut ext) = self.data {
+            config.set_service_data(ext);
+        }
+
        // complete scope pipeline creation
        *self.factory_ref.borrow_mut() = Some(ScopeFactory {
+            data: self.data.take().map(|data| Rc::new(data)),
            default: self.default.clone(),
            services: Rc::new(
                cfg.into_services()
+                    .1
                    .into_iter()
                    .map(|(mut rdef, srv, guards, nested)| {
                        rmap.add(&mut rdef, nested);
@ -349,11 +398,13 @@ where
 }

 pub struct ScopeFactory {
+    data: Option<Rc<Extensions>>,
    services: Rc<Vec<(ResourceDef, HttpNewService, RefCell<Option<Guards>>)>>,
    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }

 impl NewService for ScopeFactory {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -381,6 +432,7 @@ impl NewService for ScopeFactory {
                })
                .collect(),
            default: None,
+            data: self.data.clone(),
            default_fut,
        }
    }
@ -390,6 +442,7 @@ impl NewService for ScopeFactory {
 #[doc(hidden)]
 pub struct ScopeFactoryResponse {
    fut: Vec<CreateScopeServiceItem>,
+    data: Option<Rc<Extensions>>,
    default: Option<HttpService>,
    default_fut: Option<Box<Future<Item = HttpService, Error = ()>>>,
 }
@ -453,6 +506,7 @@ impl Future for ScopeFactoryResponse {
                    router
                });
            Ok(Async::Ready(ScopeService {
+                data: self.data.clone(),
                router: router.finish(),
                default: self.default.take(),
                _ready: None,
@ -464,6 +518,7 @@ impl Future for ScopeFactoryResponse {
 }

 pub struct ScopeService {
+    data: Option<Rc<Extensions>>,
    router: Router<HttpService, Vec<Box<Guard>>>,
    default: Option<HttpService>,
    _ready: Option<(ServiceRequest, ResourceInfo)>,
@ -492,6 +547,9 @@ impl Service for ScopeService {
        });

        if let Some((srv, _info)) = res {
+            if let Some(ref data) = self.data {
+                req.set_data_container(data.clone());
+            }
            Either::A(srv.call(req))
        } else if let Some(ref mut default) = self.default {
            Either::A(default.call(req))
@ -514,6 +572,7 @@ impl ScopeEndpoint {
 }

 impl NewService for ScopeEndpoint {
+    type Config = ();
    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
@ -945,4 +1004,22 @@ mod tests {
            HeaderValue::from_static("0001")
        );
    }
+
+    #[test]
+    fn test_override_data() {
+        let mut srv = init_service(App::new().data(1usize).service(
+            web::scope("app").data(10usize).route(
+                "/t",
+                web::get().to(|data: web::Data<usize>| {
+                    assert_eq!(*data, 10);
+                    let _ = data.clone();
+                    HttpResponse::Ok()
+                }),
+            ),
+        ));
+
+        let req = TestRequest::with_uri("/app/t").to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }
--- a/src/server.rs
+++ b/src/server.rs
@ -51,8 +51,8 @@ struct Config {
 pub struct HttpServer<F, I, S, B>
 where
    F: Fn() -> I + Send + Clone + 'static,
-    I: IntoNewService<S, ServerConfig>,
-    S: NewService<ServerConfig, Request = Request>,
+    I: IntoNewService<S>,
+    S: NewService<Config = ServerConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -64,15 +64,15 @@ where
    config: Arc<Mutex<Config>>,
    backlog: i32,
    sockets: Vec<Socket>,
-    builder: Option<ServerBuilder>,
+    builder: ServerBuilder,
    _t: PhantomData<(S, B)>,
 }

 impl<F, I, S, B> HttpServer<F, I, S, B>
 where
    F: Fn() -> I + Send + Clone + 'static,
-    I: IntoNewService<S, ServerConfig>,
-    S: NewService<ServerConfig, Request = Request>,
+    I: IntoNewService<S>,
+    S: NewService<Config = ServerConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -91,7 +91,7 @@ where
            })),
            backlog: 1024,
            sockets: Vec::new(),
-            builder: Some(ServerBuilder::default()),
+            builder: ServerBuilder::default(),
            _t: PhantomData,
        }
    }
@ -101,7 +101,7 @@ where
    /// By default http server uses number of available logical cpu as threads
    /// count.
    pub fn workers(mut self, num: usize) -> Self {
-        self.builder = Some(self.builder.take().unwrap().workers(num));
+        self.builder = self.builder.workers(num);
        self
    }

@ -117,7 +117,7 @@ where
    /// This method should be called before `bind()` method call.
    pub fn backlog(mut self, backlog: i32) -> Self {
        self.backlog = backlog;
-        self.builder = Some(self.builder.take().unwrap().backlog(backlog));
+        self.builder = self.builder.backlog(backlog);
        self
    }

@ -128,7 +128,7 @@ where
    ///
    /// By default max connections is set to a 25k.
    pub fn maxconn(mut self, num: usize) -> Self {
-        self.builder = Some(self.builder.take().unwrap().maxconn(num));
+        self.builder = self.builder.maxconn(num);
        self
    }

@ -139,7 +139,7 @@ where
    ///
    /// By default max connections is set to a 256.
    pub fn maxconnrate(mut self, num: usize) -> Self {
-        self.builder = Some(self.builder.take().unwrap().maxconnrate(num));
+        self.builder = self.builder.maxconnrate(num);
        self
    }

@ -190,13 +190,13 @@ where

    /// Stop actix system.
    pub fn system_exit(mut self) -> Self {
-        self.builder = Some(self.builder.take().unwrap().system_exit());
+        self.builder = self.builder.system_exit();
        self
    }

    /// Disable signal handling
    pub fn disable_signals(mut self) -> Self {
-        self.builder = Some(self.builder.take().unwrap().disable_signals());
+        self.builder = self.builder.disable_signals();
        self
    }

@ -207,8 +207,8 @@ where
    /// dropped.
    ///
    /// By default shutdown timeout sets to 30 seconds.
-    pub fn shutdown_timeout(mut self, sec: u16) -> Self {
-        self.builder = Some(self.builder.take().unwrap().shutdown_timeout(sec));
+    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
+        self.builder = self.builder.shutdown_timeout(sec);
        self
    }

@ -240,7 +240,7 @@ where
            scheme: "http",
        });

-        self.builder = Some(self.builder.take().unwrap().listen(
+        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
            lst,
            move || {
@ -250,8 +250,7 @@ where
                    .client_timeout(c.client_timeout)
                    .finish(factory())
            },
-        )?);
-
+        )?;
        Ok(self)
    }

@ -260,20 +259,19 @@ where
    ///
    /// This method sets alpn protocols to "h2" and "http/1.1"
    pub fn listen_ssl(
-        mut self,
+        self,
        lst: net::TcpListener,
        builder: SslAcceptorBuilder,
    ) -> io::Result<Self> {
-        self.listen_ssl_inner(lst, openssl_acceptor(builder)?)?;
-        Ok(self)
+        self.listen_ssl_inner(lst, openssl_acceptor(builder)?)
    }

    #[cfg(feature = "ssl")]
    fn listen_ssl_inner(
-        &mut self,
+        mut self,
        lst: net::TcpListener,
        acceptor: SslAcceptor,
-    ) -> io::Result<()> {
+    ) -> io::Result<Self> {
        use actix_server::ssl::{OpensslAcceptor, SslError};

        let acceptor = OpensslAcceptor::new(acceptor);
@ -285,7 +283,7 @@ where
            scheme: "https",
        });

-        self.builder = Some(self.builder.take().unwrap().listen(
+        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
            lst,
            move || {
@ -300,8 +298,8 @@ where
                        .map_init_err(|_| ()),
                )
            },
-        )?);
-        Ok(())
+        )?;
+        Ok(self)
    }

    #[cfg(feature = "rust-tls")]
@ -309,20 +307,19 @@ where
    ///
    /// This method sets alpn protocols to "h2" and "http/1.1"
    pub fn listen_rustls(
-        mut self,
+        self,
        lst: net::TcpListener,
        config: RustlsServerConfig,
    ) -> io::Result<Self> {
-        self.listen_rustls_inner(lst, config)?;
-        Ok(self)
+        self.listen_rustls_inner(lst, config)
    }

    #[cfg(feature = "rust-tls")]
    fn listen_rustls_inner(
-        &mut self,
+        mut self,
        lst: net::TcpListener,
        mut config: RustlsServerConfig,
-    ) -> io::Result<()> {
+    ) -> io::Result<Self> {
        use actix_server::ssl::{RustlsAcceptor, SslError};

        let protos = vec!["h2".to_string().into(), "http/1.1".to_string().into()];
@ -337,7 +334,7 @@ where
            scheme: "https",
        });

-        self.builder = Some(self.builder.take().unwrap().listen(
+        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
            lst,
            move || {
@ -352,8 +349,8 @@ where
                        .map_init_err(|_| ()),
                )
            },
-        )?);
-        Ok(())
+        )?;
+        Ok(self)
    }

    /// The socket address to bind
@ -416,7 +413,7 @@ where
        let acceptor = openssl_acceptor(builder)?;

        for lst in sockets {
-            self.listen_ssl_inner(lst, acceptor.clone())?;
+            self = self.listen_ssl_inner(lst, acceptor.clone())?;
        }

        Ok(self)
@ -433,7 +430,7 @@ where
    ) -> io::Result<Self> {
        let sockets = self.bind2(addr)?;
        for lst in sockets {
-            self.listen_rustls_inner(lst, config.clone())?;
+            self = self.listen_rustls_inner(lst, config.clone())?;
        }
        Ok(self)
    }
@ -442,8 +439,8 @@ where
 impl<F, I, S, B> HttpServer<F, I, S, B>
 where
    F: Fn() -> I + Send + Clone + 'static,
-    I: IntoNewService<S, ServerConfig>,
-    S: NewService<ServerConfig, Request = Request>,
+    I: IntoNewService<S>,
+    S: NewService<Config = ServerConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
@ -473,8 +470,8 @@ where
    ///    sys.run()  // <- Run actix system, this method starts all async processes
    /// }
    /// ```
-    pub fn start(mut self) -> Server {
-        self.builder.take().unwrap().start()
+    pub fn start(self) -> Server {
+        self.builder.start()
    }

    /// Spawn new thread and start listening for incoming connections.
--- a/src/service.rs
+++ b/src/service.rs
@ -1,4 +1,5 @@
 use std::cell::{Ref, RefMut};
+use std::rc::Rc;
 use std::{fmt, net};

 use actix_http::body::{Body, MessageBody, ResponseBody};
@ -7,11 +8,14 @@ use actix_http::{
    Error, Extensions, HttpMessage, Payload, PayloadStream, RequestHead, Response,
    ResponseHead,
 };
-use actix_router::{Path, Resource, Url};
+use actix_router::{Path, Resource, ResourceDef, Url};
+use actix_service::{IntoNewService, NewService};
 use futures::future::{ok, FutureResult, IntoFuture};

 use crate::config::{AppConfig, AppService};
 use crate::data::Data;
+use crate::dev::insert_slash;
+use crate::guard::Guard;
 use crate::info::ConnectionInfo;
 use crate::request::HttpRequest;

@ -46,45 +50,46 @@ where
    }
 }

-pub struct ServiceRequest {
-    req: HttpRequest,
-    payload: Payload,
-}
+/// An service http request
+///
+/// ServiceRequest allows mutable access to request's internal structures
+pub struct ServiceRequest(HttpRequest);

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

    /// Deconstruct request into parts
-    pub fn into_parts(self) -> (HttpRequest, Payload) {
-        (self.req, self.payload)
+    pub fn into_parts(mut self) -> (HttpRequest, Payload) {
+        let pl = Rc::get_mut(&mut (self.0).0).unwrap().payload.take();
+        (self.0, pl)
    }

    /// Create service response
    #[inline]
    pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> {
-        ServiceResponse::new(self.req, res.into())
+        ServiceResponse::new(self.0, res.into())
    }

    /// Create service response for error
    #[inline]
    pub fn error_response<B, E: Into<Error>>(self, err: E) -> ServiceResponse<B> {
        let res: Response = err.into().into();
-        ServiceResponse::new(self.req, res.into_body())
+        ServiceResponse::new(self.0, res.into_body())
    }

    /// This method returns reference to the request head
    #[inline]
    pub fn head(&self) -> &RequestHead {
-        &self.req.head()
+        &self.0.head()
    }

    /// This method returns reference to the request head
    #[inline]
    pub fn head_mut(&mut self) -> &mut RequestHead {
-        self.req.head_mut()
+        self.0.head_mut()
    }

    /// Request's uri.
@ -160,29 +165,40 @@ impl ServiceRequest {
    /// access the matched value for that segment.
    #[inline]
    pub fn match_info(&self) -> &Path<Url> {
-        self.req.match_info()
+        self.0.match_info()
    }

    #[inline]
    pub fn match_info_mut(&mut self) -> &mut Path<Url> {
-        self.req.match_info_mut()
+        self.0.match_info_mut()
    }

    /// Service configuration
    #[inline]
    pub fn app_config(&self) -> &AppConfig {
-        self.req.app_config()
+        self.0.app_config()
    }

    /// Get an application data stored with `App::data()` method during
    /// application configuration.
    pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
-        if let Some(st) = self.req.app_config().extensions().get::<Data<T>>() {
+        if let Some(st) = (self.0).0.app_data.get::<Data<T>>() {
            Some(st.clone())
        } else {
            None
        }
    }
+
+    /// Set request payload.
+    pub fn set_payload(&mut self, payload: Payload) {
+        Rc::get_mut(&mut (self.0).0).unwrap().payload = payload;
+    }
+
+    #[doc(hidden)]
+    /// Set new app data container
+    pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
+        Rc::get_mut(&mut (self.0).0).unwrap().app_data = extensions;
+    }
 }

 impl Resource<Url> for ServiceRequest {
@ -203,18 +219,18 @@ impl HttpMessage for ServiceRequest {
    /// Request extensions
    #[inline]
    fn extensions(&self) -> Ref<Extensions> {
-        self.req.extensions()
+        self.0.extensions()
    }

    /// Mutable reference to a the request's extensions
    #[inline]
    fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.req.extensions_mut()
+        self.0.extensions_mut()
    }

    #[inline]
    fn take_payload(&mut self) -> Payload<Self::Stream> {
-        std::mem::replace(&mut self.payload, Payload::None)
+        Rc::get_mut(&mut (self.0).0).unwrap().payload.take()
    }
 }

@ -380,10 +396,138 @@ impl<B: MessageBody> fmt::Debug for ServiceResponse<B> {
    }
 }

+pub struct WebService {
+    rdef: String,
+    name: Option<String>,
+    guards: Vec<Box<Guard>>,
+}
+
+impl WebService {
+    /// Create new `WebService` instance.
+    pub fn new(path: &str) -> Self {
+        WebService {
+            rdef: path.to_string(),
+            name: None,
+            guards: Vec::new(),
+        }
+    }
+
+    /// Set service name.
+    ///
+    /// Name is used for url generation.
+    pub fn name(mut self, name: &str) -> Self {
+        self.name = Some(name.to_string());
+        self
+    }
+
+    /// Add match guard to a web service.
+    ///
+    /// ```rust
+    /// use actix_web::{web, guard, dev, App, HttpResponse};
+    ///
+    /// fn index(req: dev::ServiceRequest) -> dev::ServiceResponse {
+    ///     req.into_response(HttpResponse::Ok().finish())
+    /// }
+    ///
+    /// fn main() {
+    ///     let app = App::new()
+    ///         .service(
+    ///             web::service("/app")
+    ///                 .guard(guard::Header("content-type", "text/plain"))
+    ///                 .finish(index)
+    ///         );
+    /// }
+    /// ```
+    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.guards.push(Box::new(guard));
+        self
+    }
+
+    /// Set a service factory implementation and generate web service.
+    pub fn finish<T, F>(self, service: F) -> impl HttpServiceFactory
+    where
+        F: IntoNewService<T>,
+        T: NewService<
+                Config = (),
+                Request = ServiceRequest,
+                Response = ServiceResponse,
+                Error = Error,
+                InitError = (),
+            > + 'static,
+    {
+        WebServiceImpl {
+            srv: service.into_new_service(),
+            rdef: self.rdef,
+            name: self.name,
+            guards: self.guards,
+        }
+    }
+}
+
+struct WebServiceImpl<T> {
+    srv: T,
+    rdef: String,
+    name: Option<String>,
+    guards: Vec<Box<Guard>>,
+}
+
+impl<T> HttpServiceFactory for WebServiceImpl<T>
+where
+    T: NewService<
+            Config = (),
+            Request = ServiceRequest,
+            Response = ServiceResponse,
+            Error = Error,
+            InitError = (),
+        > + 'static,
+{
+    fn register(mut self, config: &mut AppService) {
+        let guards = if self.guards.is_empty() {
+            None
+        } else {
+            Some(std::mem::replace(&mut self.guards, Vec::new()))
+        };
+
+        let mut rdef = if config.is_root() || !self.rdef.is_empty() {
+            ResourceDef::new(&insert_slash(&self.rdef))
+        } else {
+            ResourceDef::new(&self.rdef)
+        };
+        if let Some(ref name) = self.name {
+            *rdef.name_mut() = name.clone();
+        }
+        config.register_service(rdef, guards, self.srv, None)
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::test::TestRequest;
-    use crate::HttpResponse;
+    use super::*;
+    use crate::test::{call_service, init_service, TestRequest};
+    use crate::{guard, http, web, App, HttpResponse};
+
+    #[test]
+    fn test_service() {
+        let mut srv = init_service(
+            App::new().service(web::service("/test").name("test").finish(
+                |req: ServiceRequest| req.into_response(HttpResponse::Ok().finish()),
+            )),
+        );
+        let req = TestRequest::with_uri("/test").to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), http::StatusCode::OK);
+
+        let mut srv = init_service(
+            App::new().service(web::service("/test").guard(guard::Get()).finish(
+                |req: ServiceRequest| req.into_response(HttpResponse::Ok().finish()),
+            )),
+        );
+        let req = TestRequest::with_uri("/test")
+            .method(http::Method::PUT)
+            .to_request();
+        let resp = call_service(&mut srv, req);
+        assert_eq!(resp.status(), http::StatusCode::NOT_FOUND);
+    }

    #[test]
    fn test_fmt_debug() {
--- a/src/test.rs
+++ b/src/test.rs
@ -2,27 +2,25 @@
 use std::cell::RefCell;
 use std::rc::Rc;

-use actix_http::cookie::Cookie;
-use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
+use actix_http::http::header::{ContentType, Header, HeaderName, IntoHeaderValue};
 use actix_http::http::{HttpTryFrom, Method, StatusCode, Uri, Version};
 use actix_http::test::TestRequest as HttpTestRequest;
-use actix_http::{Extensions, Request};
+use actix_http::{cookie::Cookie, Extensions, Request};
 use actix_router::{Path, ResourceDef, Url};
 use actix_rt::Runtime;
 use actix_server_config::ServerConfig;
-use actix_service::{FnService, IntoNewService, NewService, Service};
+use actix_service::{IntoNewService, IntoService, NewService, Service};
 use bytes::{Bytes, BytesMut};
-use futures::{
-    future::{lazy, ok, Future},
-    stream::Stream,
-};
+use futures::future::{lazy, ok, Future, IntoFuture};
+use futures::Stream;
 use serde::de::DeserializeOwned;
+use serde::Serialize;
 use serde_json;

 pub use actix_http::test::TestBuffer;

 use crate::config::{AppConfig, AppConfigInner};
-use crate::data::{Data, RouteData};
+use crate::data::Data;
 use crate::dev::{Body, MessageBody, Payload};
 use crate::request::HttpRequestPool;
 use crate::rmap::ResourceMap;
@ -30,11 +28,25 @@ use crate::service::{ServiceRequest, ServiceResponse};
 use crate::{Error, HttpRequest, HttpResponse};

 thread_local! {
-    static RT: RefCell<Runtime> = {
-        RefCell::new(Runtime::new().unwrap())
+    static RT: RefCell<Inner> = {
+        RefCell::new(Inner(Some(Runtime::new().unwrap())))
    };
 }

+struct Inner(Option<Runtime>);
+
+impl Inner {
+    fn get_mut(&mut self) -> &mut Runtime {
+        self.0.as_mut().unwrap()
+    }
+}
+
+impl Drop for Inner {
+    fn drop(&mut self) {
+        std::mem::forget(self.0.take().unwrap())
+    }
+}
+
 /// Runs the provided future, blocking the current thread until the future
 /// completes.
 ///
@ -47,21 +59,44 @@ thread_local! {
 /// This function panics on nested call.
 pub fn block_on<F>(f: F) -> Result<F::Item, F::Error>
 where
-    F: Future,
+    F: IntoFuture,
 {
-    RT.with(move |rt| rt.borrow_mut().block_on(f))
+    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(f.into_future()))
 }

+/// Runs the provided function, blocking the current thread until the resul
+/// 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_fn<F, R>(f: F) -> Result<R::Item, R::Error>
+where
+    F: FnOnce() -> R,
+    R: IntoFuture,
+{
+    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(|| f())))
+}
+
+#[doc(hidden)]
 /// Runs the provided function, with runtime enabled.
 ///
 /// Note that this function is intended to be used only for testing purpose.
 /// 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()
+    RT.with(move |rt| {
+        rt.borrow_mut()
+            .get_mut()
+            .block_on(lazy(|| Ok::<_, ()>(f())))
+    })
+    .unwrap()
 }

 /// Create service that always responds with `HttpResponse::Ok()`
@ -76,9 +111,10 @@ pub fn default_service(
    status_code: StatusCode,
 ) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
 {
-    FnService::new(move |req: ServiceRequest| {
+    (move |req: ServiceRequest| {
        req.into_response(HttpResponse::build(status_code).finish())
    })
+    .into_service()
 }

 /// This method accepts application builder instance, and constructs
@ -107,9 +143,9 @@ pub fn init_service<R, S, B, E>(
    app: R,
 ) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>
 where
-    R: IntoNewService<S, ServerConfig>,
+    R: IntoNewService<S>,
    S: NewService<
-        ServerConfig,
+        Config = ServerConfig,
        Request = Request,
        Response = ServiceResponse<B>,
        Error = E,
@ -117,7 +153,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 +184,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 +216,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 = test::call_service(&mut app, 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 +309,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"))
 }
@ -249,12 +331,11 @@ where
 /// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern.
 /// You can generate various types of request via TestRequest's methods:
 ///  * `TestRequest::to_request` creates `actix_http::Request` instance.
-///  * `TestRequest::to_service` creates `ServiceRequest` instance, which is used for testing middlewares and chain adapters.
-///  * `TestRequest::to_from` creates `ServiceFromRequest` instance, which is used for testing extractors.
+///  * `TestRequest::to_srv_request` creates `ServiceRequest` instance, which is used for testing middlewares and chain adapters.
+///  * `TestRequest::to_srv_response` creates `ServiceResponse` instance.
 ///  * `TestRequest::to_http_request` creates `HttpRequest` instance, which is used for testing handlers.
 ///
 /// ```rust
-/// # use futures::IntoFuture;
 /// use actix_web::{test, HttpRequest, HttpResponse, HttpMessage};
 /// use actix_web::http::{header, StatusCode};
 ///
@ -271,11 +352,11 @@ where
 ///     let req = test::TestRequest::with_header("content-type", "text/plain")
 ///         .to_http_request();
 ///
-///     let resp = test::block_on(index(req).into_future()).unwrap();
+///     let resp = test::block_on(index(req)).unwrap();
 ///     assert_eq!(resp.status(), StatusCode::OK);
 ///
 ///     let req = test::TestRequest::default().to_http_request();
-///     let resp = test::block_on(index(req).into_future()).unwrap();
+///     let resp = test::block_on(index(req)).unwrap();
 ///     assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 /// }
 /// ```
@ -283,8 +364,8 @@ pub struct TestRequest {
    req: HttpTestRequest,
    rmap: ResourceMap,
    config: AppConfigInner,
-    route_data: Extensions,
    path: Path<Url>,
+    app_data: Extensions,
 }

 impl Default for TestRequest {
@ -293,8 +374,8 @@ impl Default for TestRequest {
            req: HttpTestRequest::default(),
            rmap: ResourceMap::new(ResourceDef::new("")),
            config: AppConfigInner::default(),
-            route_data: Extensions::new(),
            path: Path::new(Url::new(Uri::default())),
+            app_data: Extensions::new(),
        }
    }
 }
@ -330,6 +411,21 @@ 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)
+    }
+
+    /// Create TestRequest and set method to `Method::DELETE`
+    pub fn delete() -> TestRequest {
+        TestRequest::default().method(Method::DELETE)
+    }
+
    /// Set HTTP version of this request
    pub fn version(mut self, ver: Version) -> Self {
        self.req.version(ver);
@ -382,17 +478,20 @@ impl TestRequest {
        self
    }

-    /// Set application data. This is equivalent of `App::data()` method
-    /// for testing purpose.
-    pub fn app_data<T: 'static>(self, data: T) -> Self {
-        self.config.extensions.borrow_mut().insert(Data::new(data));
+    /// Serialize `data` to JSON and set it as the request payload. The `Content-Type` header is
+    /// set to `application/json`.
+    pub fn set_json<T: Serialize>(mut self, data: &T) -> Self {
+        let bytes =
+            serde_json::to_string(data).expect("Failed to serialize test data to json");
+        self.req.set_payload(bytes);
+        self.req.set(ContentType::json());
        self
    }

-    /// Set route data. This is equivalent of `Route::data()` method
+    /// Set application data. This is equivalent of `App::data()` method
    /// for testing purpose.
-    pub fn route_data<T: 'static>(mut self, data: T) -> Self {
-        self.route_data.insert(RouteData::new(data));
+    pub fn data<T: 'static>(mut self, data: T) -> Self {
+        self.app_data.insert(Data::new(data));
        self
    }

@ -413,15 +512,15 @@ impl TestRequest {
        let (head, payload) = self.req.finish().into_parts();
        self.path.get_mut().update(&head.uri);

-        let req = HttpRequest::new(
+        ServiceRequest::new(HttpRequest::new(
            self.path,
            head,
+            payload,
            Rc::new(self.rmap),
            AppConfig::new(self.config),
+            Rc::new(self.app_data),
            HttpRequestPool::create(),
-        );
-
-        ServiceRequest::from_parts(req, payload)
+        ))
    }

    /// Complete request creation and generate `ServiceResponse` instance
@ -431,18 +530,18 @@ impl TestRequest {

    /// Complete request creation and generate `HttpRequest` instance
    pub fn to_http_request(mut self) -> HttpRequest {
-        let (head, _) = self.req.finish().into_parts();
+        let (head, payload) = self.req.finish().into_parts();
        self.path.get_mut().update(&head.uri);

-        let mut req = HttpRequest::new(
+        HttpRequest::new(
            self.path,
            head,
+            payload,
            Rc::new(self.rmap),
            AppConfig::new(self.config),
+            Rc::new(self.app_data),
            HttpRequestPool::create(),
-        );
-        req.set_route_data(Some(Rc::new(self.route_data)));
-        req
+        )
    }

    /// Complete request creation and generate `HttpRequest` and `Payload` instances
@ -450,37 +549,23 @@ impl TestRequest {
        let (head, payload) = self.req.finish().into_parts();
        self.path.get_mut().update(&head.uri);

-        let mut req = HttpRequest::new(
+        let req = HttpRequest::new(
            self.path,
            head,
+            Payload::None,
            Rc::new(self.rmap),
            AppConfig::new(self.config),
+            Rc::new(self.app_data),
            HttpRequestPool::create(),
        );
-        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)
+        (req, payload)
    }
 }

 #[cfg(test)]
 mod tests {
+    use actix_http::httpmessage::HttpMessage;
    use serde::{Deserialize, Serialize};
    use std::time::SystemTime;

@ -493,15 +578,52 @@ mod tests {
            .version(Version::HTTP_2)
            .set(header::Date(SystemTime::now().into()))
            .param("test", "123")
-            .app_data(10u32)
+            .data(10u32)
            .to_http_request();
        assert!(req.headers().contains_key(header::CONTENT_TYPE));
        assert!(req.headers().contains_key(header::DATE));
        assert_eq!(&req.match_info()["test"], "123");
        assert_eq!(req.version(), Version::HTTP_2);
-        let data = req.app_data::<u32>().unwrap();
+        let data = req.get_app_data::<u32>().unwrap();
+        assert!(req.get_app_data::<u64>().is_none());
        assert_eq!(*data, 10);
        assert_eq!(*data.get_ref(), 10);
+
+        assert!(req.app_data::<u64>().is_none());
+        let data = req.app_data::<u32>().unwrap();
+        assert_eq!(*data, 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!")))
+                    .route(web::delete().to(|| HttpResponse::Ok().body("delete!"))),
+            ),
+        );
+
+        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!"));
+
+        let delete_req = TestRequest::delete().uri("/index.html").to_request();
+        let result = read_response(&mut app, delete_req);
+        assert_eq!(result, Bytes::from_static(b"delete!"));
    }

    #[test]
@ -547,4 +669,49 @@ mod tests {
        let result: Person = read_response_json(&mut app, req);
        assert_eq!(&result.id, "12345");
    }
+
+    #[test]
+    fn test_request_response_json() {
+        let mut app = init_service(App::new().service(web::resource("/people").route(
+            web::post().to(|person: web::Json<Person>| {
+                HttpResponse::Ok().json(person.into_inner())
+            }),
+        )));
+
+        let payload = Person {
+            id: "12345".to_string(),
+            name: "User name".to_string(),
+        };
+
+        let req = TestRequest::post()
+            .uri("/people")
+            .set_json(&payload)
+            .to_request();
+
+        assert_eq!(req.content_type(), "application/json");
+
+        let result: Person = read_response_json(&mut app, req);
+        assert_eq!(&result.id, "12345");
+        assert_eq!(&result.name, "User name");
+    }
+
+    #[test]
+    fn test_async_with_block() {
+        fn async_with_block() -> impl Future<Item = HttpResponse, Error = Error> {
+            web::block(move || Some(4).ok_or("wrong")).then(|res| match res {
+                Ok(value) => HttpResponse::Ok()
+                    .content_type("text/plain")
+                    .body(format!("Async with block value: {}", value)),
+                Err(_) => panic!("Unexpected"),
+            })
+        }
+
+        let mut app = init_service(
+            App::new().service(web::resource("/index.html").to_async(async_with_block)),
+        );
+
+        let req = TestRequest::post().uri("/index.html").to_request();
+        let res = block_fn(|| app.call(req)).unwrap();
+        assert!(res.status().is_success());
+    }
 }
--- a/src/types/form.rs
+++ b/src/types/form.rs
@ -81,7 +81,7 @@ where
    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
        let req2 = req.clone();
        let (limit, err) = req
-            .route_data::<FormConfig>()
+            .app_data::<FormConfig>()
            .map(|c| (c.limit, c.ehandler.clone()))
            .unwrap_or((16384, None));

@ -132,12 +132,11 @@ impl<T: fmt::Display> fmt::Display for Form<T> {
 /// fn main() {
 ///     let app = App::new().service(
 ///         web::resource("/index.html")
-///             .route(web::get()
-///                 // change `Form` extractor configuration
-///                 .data(
-///                     web::Form::<FormData>::configure(|cfg| cfg.limit(4097))
-///                 )
-///                 .to(index))
+///             // change `Form` extractor configuration
+///             .data(
+///                 web::Form::<FormData>::configure(|cfg| cfg.limit(4097))
+///             )
+///             .route(web::get().to(index))
 ///     );
 /// }
 /// ```
@ -331,10 +330,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,
--- a/src/types/json.rs
+++ b/src/types/json.rs
@ -1,6 +1,6 @@
 //! Json extractor/responder

-use std::rc::Rc;
+use std::sync::Arc;
 use std::{fmt, ops};

 use bytes::BytesMut;
@ -168,15 +168,15 @@ impl<T> FromRequest for Json<T>
 where
    T: DeserializeOwned + 'static,
 {
-    type Config = JsonConfig;
    type Error = Error;
    type Future = Box<Future<Item = Self, Error = Error>>;
+    type Config = JsonConfig;

    #[inline]
    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
        let req2 = req.clone();
        let (limit, err) = req
-            .route_data::<JsonConfig>()
+            .app_data::<Self::Config>()
            .map(|c| (c.limit, c.ehandler.clone()))
            .unwrap_or((32768, None));

@ -220,24 +220,23 @@ where
 ///
 /// fn main() {
 ///     let app = App::new().service(
-///         web::resource("/index.html").route(
-///             web::post().data(
-///                 // change json extractor configuration
-///                 web::Json::<Info>::configure(|cfg| {
-///                     cfg.limit(4096)
-///                        .error_handler(|err, req| {  // <- create custom error response
-///                             error::InternalError::from_response(
-///                                 err, HttpResponse::Conflict().finish()).into()
-///                        })
-///                 }))
-///                 .to(index))
+///         web::resource("/index.html").data(
+///             // change json extractor configuration
+///             web::Json::<Info>::configure(|cfg| {
+///                 cfg.limit(4096)
+///                    .error_handler(|err, req| {  // <- create custom error response
+///                         error::InternalError::from_response(
+///                             err, HttpResponse::Conflict().finish()).into()
+///                    })
+///             }))
+///             .route(web::post().to(index))
 ///     );
 /// }
 /// ```
 #[derive(Clone)]
 pub struct JsonConfig {
    limit: usize,
-    ehandler: Option<Rc<Fn(JsonPayloadError, &HttpRequest) -> Error>>,
+    ehandler: Option<Arc<dyn Fn(JsonPayloadError, &HttpRequest) -> Error + Send + Sync>>,
 }

 impl JsonConfig {
@ -250,9 +249,9 @@ impl JsonConfig {
    /// Set custom error handler
    pub fn error_handler<F>(mut self, f: F) -> Self
    where
-        F: Fn(JsonPayloadError, &HttpRequest) -> Error + 'static,
+        F: Fn(JsonPayloadError, &HttpRequest) -> Error + Send + Sync + 'static,
    {
-        self.ehandler = Some(Rc::new(f));
+        self.ehandler = Some(Arc::new(f));
        self
    }
 }
@ -431,7 +430,7 @@ mod tests {
                header::HeaderValue::from_static("16"),
            )
            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-            .route_data(JsonConfig::default().limit(10).error_handler(|err, _| {
+            .data(JsonConfig::default().limit(10).error_handler(|err, _| {
                let msg = MyObject {
                    name: "invalid request".to_string(),
                };
@ -483,7 +482,7 @@ mod tests {
                header::HeaderValue::from_static("16"),
            )
            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-            .route_data(JsonConfig::default().limit(10))
+            .data(JsonConfig::default().limit(10))
            .to_http_parts();

        let s = block_on(Json::<MyObject>::from_request(&req, &mut pl));
@ -500,7 +499,7 @@ mod tests {
                header::HeaderValue::from_static("16"),
            )
            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-            .route_data(
+            .data(
                JsonConfig::default()
                    .limit(10)
                    .error_handler(|_, _| JsonPayloadError::ContentType.into()),
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@ -11,4 +11,4 @@ pub use self::form::{Form, FormConfig};
 pub use self::json::{Json, JsonConfig};
 pub use self::path::Path;
 pub use self::payload::{Payload, PayloadConfig};
-pub use self::query::Query;
+pub use self::query::{Query, QueryConfig};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nikolay Kim	29a0fe76d5	prepare actix-web-codegen release	2019-06-01 17:21:22 +06:00
Igor Gnatenko	7753b9da6d	web-codegen: Add extra-traits to syn features (#879 ) ```rust error[E0277]: `syn::attr::NestedMeta` doesn't implement `std::fmt::Debug` --> src/route.rs:149:57 \| 149 \| attr => panic!("Unknown attribute{:?}", attr), \| ^^^^ `syn::attr::NestedMeta` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` \| = help: the trait `std::fmt::Debug` is not implemented for `syn::attr::NestedMeta` = note: required because of the requirements on the impl of `std::fmt::Debug` for `&syn::attr::NestedMeta` = note: required by `std::fmt::Debug::fmt` ```	2019-06-01 14:13:45 +06:00
Mohab Usama	f1764bba43	Fix Logger time format (use rfc3339) (#867 ) * Fix Logger time format (use rfc3339) * Update change log	2019-05-31 12:09:21 +04:00
Nikolay Kim	c2d7db7e06	prepare actix-web-actors release	2019-05-29 16:22:57 -07:00
Nikolay Kim	21418c7414	prep actix-http release	2019-05-29 16:15:12 -07:00
octave99	fe781345d5	Add Migration steps for Custom Error (#869 ) Adds migration steps for custom error in 1.0	2019-05-29 20:47:04 +04:00
Nicolas Gotchac	a614be7cb5	Don't DISCONNECT from stream when reader is empty (#870 ) * Don't DISCONNECT from stream when reader is empty * Fix chunked transfer: poll_request before closing stream + Test	2019-05-29 20:37:42 +04:00
Nikolay Kim	1eb89b8375	remove debug prints	2019-05-25 03:16:53 -07:00
Nikolay Kim	aa626a1e72	handle disconnects	2019-05-25 03:16:46 -07:00
Nikolay Kim	7f12b754e9	Handle socket read disconnect	2019-05-25 03:07:40 -07:00
Nikolay Kim	3f196f469d	update version	2019-05-25 02:13:04 -07:00
Nikolay Kim	35eb378585	prepare actix-files release	2019-05-25 02:02:28 -07:00
Miles Granger	6db625f55b	Update actix-web dep to 1.0.0-rc (#864 )	2019-05-25 01:52:23 -07:00
Vlad Frolov	801cc2ed5d	Cleaned unnecessary Option<_> around ServerBuilder in server.rs/HttpServer (#863 )	2019-05-23 05:21:02 -07:00
Nikolay Kim	ded1e86e7e	Add ServiceRequest::set_payload() method	2019-05-22 21:25:51 -07:00
Nikolay Kim	babf48c550	fix NamedFile last-modified check #820	2019-05-22 21:21:12 -07:00
Nikolay Kim	d3e807f6e9	move Payload to inner http request	2019-05-22 11:49:27 -07:00
Nikolay Kim	7746e785c1	re-export Service and Transform traits	2019-05-22 11:20:37 -07:00
Nikolay Kim	4e141d7f5d	Merge branch 'master' of github.com:actix/actix-web	2019-05-22 11:18:42 -07:00
Nikolay Kim	12842871fe	Clear http requests pool on app service drop #860	2019-05-22 11:18:33 -07:00
Aliaksandr Rahalevich	fc85ae4014	small documentation fix (#856 )	2019-05-21 10:43:18 -07:00
Harry Stern	5826f39dbe	Add `set_json` method to TestRequest (#851 ) - Takes a type which implements serde::Serialize, serializes it to JSON, and sets it as the payload. The content-type is also set to JSON.	2019-05-18 19:36:28 -07:00
Nikolay Kim	8ff56d7cd5	prepare actix-session release	2019-05-18 11:20:09 -07:00
Nikolay Kim	0843bce7ba	prepare actix-multipart	2019-05-18 11:15:58 -07:00
Nikolay Kim	dea0e0a721	update actix-server dep	2019-05-18 11:00:33 -07:00
Herbert Jones	e857ab1f81	HttpServer::shutdown_timeout u16 to u64 (#849 ) Increase maximum graceful shutdown time from 18 hours. For issue #848.	2019-05-18 10:50:35 -07:00
Nikolay Kim	0dda4b06ea	prepare release	2019-05-18 10:49:59 -07:00
Nikolay Kim	cbe0226177	update changes	2019-05-18 10:47:08 -07:00
Nikolay Kim	e8c8626878	update deps	2019-05-18 09:54:23 -07:00
Miles Granger	4b215e0839	Support Query<T>::from_query() (#846 )	2019-05-17 13:10:46 -07:00
Nikolay Kim	e1ff3bf8fa	fix resource match with params #841	2019-05-15 10:31:40 -07:00
Glade Miller	80f4ef9aac	When using codegen with paths that have parameters then only the first endpoint resolves (#842 )	2019-05-15 09:21:07 -07:00
Davide Di Carlo	bba90d7f22	Query config (#839 ) * add QueryConfig * expose QueryConfig in web module * fmt * use associated type for QueryConfig * update CHANGES.md	2019-05-14 13:54:30 -07:00
Nikolay Kim	f8af3b86e5	export set_date	2019-05-14 08:48:11 -07:00
Davide Di Carlo	6c3d8b8738	Make JsonConfig send (#830 ) * replace Rc with Arc * add Send trait requirement for Fn in JsonConfig error handler * add Sync trait requirement for Fn in JsonConfig error handler * use associated type inside JsonConfig * fix lint: members in the impl has the same order in the trait * Update CHANGES.md	2019-05-12 20:04:08 -07:00
Nikolay Kim	5a90e33bcc	update deps	2019-05-12 12:01:24 -07:00
Nikolay Kim	86b569e320	version	2019-05-12 11:56:01 -07:00
Nikolay Kim	2350a2dc68	Handle cancellation of uploads #834 #736	2019-05-12 11:43:05 -07:00
Nikolay Kim	36d017dcc6	update deps	2019-05-12 11:41:43 -07:00
Nikolay Kim	3bb081852c	prep actix-session release	2019-05-12 10:53:21 -07:00
Nikolay Kim	1ca58e876b	prepare beta4 release	2019-05-12 10:49:21 -07:00
Nikolay Kim	e9cbcbaf03	update dependencies	2019-05-12 10:18:02 -07:00
Nikolay Kim	07c9eec803	prepare awc release	2019-05-12 10:04:38 -07:00
Nikolay Kim	beae9ca0f7	update changes	2019-05-12 09:57:16 -07:00
Nikolay Kim	07b9707ca1	prepare actix-http release	2019-05-12 09:56:55 -07:00
Nikolay Kim	45c05978b0	Allow to set/override app data on scope level	2019-05-12 09:42:05 -07:00
Nikolay Kim	df08baf67f	update actix-net dependencies	2019-05-12 08:34:51 -07:00
Nikolay Kim	4066375737	Update CHANGES.md	2019-05-10 14:45:30 -07:00
Nikolai Vazquez	a77b0b054a	Make `App::configure` take an `FnOnce` (#825 )	2019-05-10 14:44:49 -07:00
Nikolay Kim	a17ff492a1	fix formatting	2019-05-04 22:18:59 -07:00
Nikolay Kim	33b4c05557	add payload stream migration entry	2019-05-04 22:18:02 -07:00
Nikolay Kim	005c055a7f	prepare actix-web release	2019-05-04 20:05:20 -07:00
Nikolay Kim	3d1af19080	prepare actix-http release	2019-05-04 19:51:13 -07:00
Nikolay Kim	fa78da8156	unify route and app data, it allows to provide global extractor config #775	2019-05-04 19:43:49 -07:00
Nikolay Kim	01cfcf3b75	update changes	2019-05-04 08:42:27 -07:00
James	7ef4f5ac0b	Make request headers optional in CORS preflight (#816 )	2019-05-04 08:41:37 -07:00
Nikolay Kim	fc19ce41c4	Clean up response extensions in response pool #817	2019-05-03 15:26:34 -07:00
Otavio Salvador	6e00eef63a	awc: Fix typo on ResponseError documentation (#815 ) * awc: Fix typo on ResponseError documentation Signed-off-by: Otavio Salvador <otavio@ossystems.com.br> * http: Fix typo on ResponseError documentation Signed-off-by: Otavio Salvador <otavio@ossystems.com.br> * http: Expand type names for openssl related errors documentation Signed-off-by: Otavio Salvador <otavio@ossystems.com.br>	2019-05-03 14:30:00 -07:00
Nikolay Kim	337c2febe3	add more tests	2019-05-02 09:49:10 -07:00
Nikolay Kim	f27beab016	fix case for transfer-encoding header name	2019-05-02 09:30:00 -07:00
Max Bo	4f1c6d1bb7	Update MIGRATION.md (#811 )	2019-05-02 09:26:51 -07:00
Nikolay Kim	6b34909537	Fix NormalizePath middleware impl #806	2019-05-01 12:40:56 -07:00
Douman	87284f0951	Add doctest to verify NormalizePath middleware (#809 )	2019-05-01 11:47:51 -07:00
Nikolay Kim	24bd5b1344	update readmes	2019-04-29 20:47:21 -07:00
Nikolay Kim	94a0d1a6bc	remove old api doc refs	2019-04-29 18:42:21 -07:00
Nikolay Kim	f4e1205cbb	fix reactor drop panic	2019-04-29 10:14:08 -07:00
Nikolay Kim	d2c1791067	add async handler test with blocking call	2019-04-29 09:45:37 -07:00
Nikolay Kim	f4b4875cb1	Add helper function for executing futures test::block_fn()	2019-04-29 09:34:14 -07:00
Nikolay Kim	29a841529f	Allow to construct Data instances to avoid double Arc for Send + Sync types.	2019-04-29 09:26:12 -07:00
Darin	b51b5b763c	added clarification to docs regarding middleware processing sequence, added delete method to TestRequest (#799 ) * added clarification to docs regarding middleware processing sequnce * added delete method to TestRequest, doc, and test	2019-04-29 09:14:36 -07:00
Nikolay Kim	8db6b48a76	update version	2019-04-28 09:09:18 -07:00
Nikolay Kim	ffd2c04cd3	Add helper trait UserSession which allows to get session for ServiceRequest and HttpRequest	2019-04-28 09:08:51 -07:00
Nikolay Kim	70a4c36496	use Error explicitly	2019-04-25 11:14:32 -07:00
Nikolay Kim	cba78e06ae	update changes	2019-04-24 15:42:34 -07:00
Nikolay Kim	3b3dbb4f40	add raw services support	2019-04-24 15:29:15 -07:00
Darin	7300002226	grammar fixes (#796 )	2019-04-24 13:21:42 -07:00
Nikolay Kim	5426413cb6	update dependencies	2019-04-24 13:00:30 -07:00
Nikolay Kim	2bc937f6c3	prepare release	2019-04-24 12:50:44 -07:00
Maciej Piechotka	60fa0d5427	Store visit and login timestamp in the identity cookie (#502 ) This allows to verify time of login or last visit and therfore limiting the danger of leaked cookies.	2019-04-24 12:49:56 -07:00
Nikolay Kim	f429d3319f	Read until eof for http/1.0 responses #771	2019-04-24 11:57:40 -07:00
Nikolay Kim	2e19f572ee	add tests for camel case headers rendering	2019-04-24 11:27:57 -07:00
Peter Ding	64f603b076	Support to set header names of `ClientRequest` as Camel-Case (#713 ) * Support to set header names of `ClientRequest` as Camel-Case This is the case for supporting to request for servers which don't perfectly implement the `RFC 7230`. It is important for an app which uses `ClientRequest` as core part. * Add field `upper_camel_case_headers` to `ClientRequest`. * Add function `set_upper_camel_case_headers` to `ClientRequest` and `ClientRequestBuilder` to set field `upper_camel_case_headers`. * Add trait `client::writer::UpperCamelCaseHeader` for `http::header::HeaderName`, let it can be converted to Camel-Case then writed to buffer. * Add test `test_client::test_upper_camel_case_headers`. * Support upper Camel-Case headers * [actix-http] Add field `upper_camel_case_headers` for `RequestHead` * [actix-http] Add code for `MessageType` to support upper camel case * [awc] Add functions for `ClientRequest` to set upper camel case * Use `Flags::CAMEL_CASE` for upper camel case of headers	2019-04-24 10:48:49 -07:00
Nikolay Kim	679d1cd513	allow to override responder's status code and headers	2019-04-24 10:25:46 -07:00
Nikolay Kim	42644dac3f	prepare actix-http-test release	2019-04-24 07:31:33 -07:00
Nikolay Kim	898ef57080	Fix async web::Data factory handling	2019-04-23 21:21:49 -07:00
Nikolay Kim	9702b2d88e	add client h2 reuse test	2019-04-23 15:06:30 -07:00
Nikolay Kim	d2b0afd859	Fix http client pool and wait queue management	2019-04-23 14:57:03 -07:00
Nikolay Kim	5f6a1a8249	update version	2019-04-23 09:45:39 -07:00
Nikolay Kim	5d531989e7	Fix BorrowMutError panic in client connector #793	2019-04-23 09:42:19 -07:00
Nikolay Kim	3532602299	Added support for remainder match (i.e /path/{tail}*)	2019-04-22 21:22:17 -07:00
Nikolay Kim	48bee55087	.to_async() handler can return Responder type #792	2019-04-22 14:22:08 -07:00
Nikolay Kim	d00c9bb844	do not consume boundary	2019-04-21 16:14:09 -07:00
Nikolay Kim	895e409d57	Optimize multipart handling #634 , #769	2019-04-21 15:41:01 -07:00
Nikolay Kim	f0789aad05	update dep versions	2019-04-21 09:03:46 -07:00
Nikolay Kim	7e480ab2f7	beta.1 release	2019-04-20 21:16:51 -07:00
Nikolay Kim	891f857547	update changes	2019-04-20 11:18:04 -07:00
Nikolay Kim	01b1350dcc	update versions	2019-04-19 18:16:01 -07:00
Nikolay Kim	5e4e95fb0a	update create version	2019-04-19 18:13:05 -07:00
Nikolay Kim	9f421b81b8	fix non-ssl connector	2019-04-19 18:10:53 -07:00
Nikolay Kim	6decfdda1f	update deps	2019-04-19 18:06:34 -07:00
Nikolay Kim	fc9b14a933	allow to specify server address for http and ws requests	2019-04-19 18:03:44 -07:00
Nikolay Kim	7292d0b696	drop chrono and use i64 for max age	2019-04-19 17:23:17 -07:00
Nikolay Kim	a3844c1bfd	update version	2019-04-19 13:55:36 -07:00
Kilerd Chan	791f22bbc8	replate `time::Duration` with `chrono::Duration` and add `max_age_time` method (#789 ) * feat: replate time::Duration with chrono::Duration * feat: rename max_age method which accepts `Duration` to max_age_time and add new max_age method accepting isize of seconds * feat: replace `time:Duration` with `chrono:Duration` in repo `actix-http`	2019-04-19 13:54:44 -07:00
Douman	1e7f97a111	Add Normalization middleware for in place (#783 )	2019-04-19 13:53:49 -07:00
Darin	bc40f5ae40	Merge pull request #788 from Dowwie/master added put and patch to TestRequest, docs, and test	2019-04-19 06:55:44 -04:00
Darin	3504a8fc0a	Merge branch 'master' into master	2019-04-19 04:38:41 -04:00
Nikolay Kim	bfe0df5ab0	update tests	2019-04-18 21:28:23 -07:00
Darin	ed94df189f	Merge branch 'master' into master	2019-04-18 19:03:48 -04:00
Nikolay Kim	aa255298ef	make ServiceRequest::from_parts private, as it is not safe to create from parts	2019-04-18 16:03:13 -07:00
dowwie	da86b6e062	added put and patch to TestRequest, docs, and test	2019-04-18 18:06:32 -04:00
Nikolay Kim	75e340137d	use local version of http-test	2019-04-18 12:23:56 -07:00
Nikolay Kim	e659e09e29	update tests	2019-04-18 11:01:04 -07:00
Nikolay Kim	163ca89cf4	more tests	2019-04-17 17:48:25 -07:00
Nikolay Kim	85b598a614	add cookie session test	2019-04-17 11:02:03 -07:00
Nikolay Kim	b64851c5ec	enable runtime for test:: methods	2019-04-17 10:28:27 -07:00
Nikolay Kim	cc8420377e	pass request ownership to closure instead of ref	2019-04-16 15:43:55 -07:00
Nikolay Kim	5740f1e63a	prepare actix-framed release	2019-04-16 11:18:47 -07:00
Nikolay Kim	c943e95812	update dependencies	2019-04-16 11:17:29 -07:00
Nikolay Kim	4c0ebd55d3	prepare actix-http-test release	2019-04-16 11:02:26 -07:00
Nikolay Kim	e7ec77aa81	update readme	2019-04-16 10:50:37 -07:00
Nikolay Kim	ddfd7523f7	prepare awc release	2019-04-16 10:49:38 -07:00