From df08baf67f166d2d75118b859f1049b01944daf4 Mon Sep 17 00:00:00 2001
From: Nikolay Kim <fafhrd91@gmail.com>
Date: Sun, 12 May 2019 08:34:51 -0700
Subject: [PATCH] update actix-net dependencies

---
 Cargo.toml                       | 13 +++---
 actix-files/Cargo.toml           |  4 +-
 actix-files/src/lib.rs           |  2 +
 actix-framed/Cargo.toml          |  5 ++-
 actix-framed/src/app.rs          |  7 +++-
 actix-framed/src/helpers.rs      |  4 +-
 actix-framed/src/route.rs        |  1 +
 actix-framed/src/service.rs      | 24 ++++++-----
 actix-http/CHANGES.md            |  9 ++++
 actix-http/Cargo.toml            | 10 ++---
 actix-http/src/builder.rs        | 26 ++++++++----
 actix-http/src/h1/expect.rs      |  4 +-
 actix-http/src/h1/service.rs     | 35 +++++++++-------
 actix-http/src/h1/upgrade.rs     |  4 +-
 actix-http/src/h2/service.rs     | 18 ++++----
 actix-http/src/service.rs        | 46 +++++++++++----------
 actix-http/tests/test_server.rs  | 10 ++---
 actix-multipart/Cargo.toml       |  2 +-
 actix-session/Cargo.toml         |  2 +-
 awc/Cargo.toml                   |  4 +-
 awc/src/builder.rs               | 71 +++++++++++++++-----------------
 awc/src/response.rs              |  3 +-
 awc/src/test.rs                  | 29 -------------
 awc/src/ws.rs                    | 49 +++++++++++-----------
 awc/tests/test_client.rs         | 14 +++----
 awc/tests/test_ws.rs             | 70 +++++++------------------------
 src/app.rs                       |  8 +++-
 src/app_service.rs               | 12 ++++--
 src/config.rs                    |  1 +
 src/handler.rs                   | 32 +++++++++-----
 src/middleware/cors.rs           | 12 +++---
 src/middleware/defaultheaders.rs | 20 +++++----
 src/middleware/errhandlers.rs    | 14 +++----
 src/middleware/logger.rs         |  8 ++--
 src/middleware/normalize.rs      | 16 +++----
 src/resource.rs                  |  8 ++++
 src/route.rs                     |  5 +++
 src/scope.rs                     | 11 ++++-
 src/server.rs                    | 12 +++---
 src/service.rs                   |  2 +
 src/test.rs                      |  9 ++--
 test-server/Cargo.toml           |  6 +--
 test-server/src/lib.rs           | 40 +++++++++++++-----
 43 files changed, 361 insertions(+), 321 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a87148462..f4e2f79ea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -66,13 +66,13 @@ rust-tls = ["rustls", "actix-server/rust-tls"]
 
 [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.3"
 actix-rt = "0.2.2"
 actix-web-codegen = "0.1.0-beta.1"
 actix-http = { version = "0.1.5", features=["fail"] }
-actix-server = "0.4.3"
+actix-server = "0.5.0"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"
 actix = { version = "0.8.1", features=["http"], optional = true }
@@ -101,7 +101,7 @@ rustls = { version = "^0.15", optional = true }
 [dev-dependencies]
 actix-http = { version = "0.1.5", features=["ssl", "brotli", "flate2-zlib"] }
 actix-http-test = { version = "0.1.1", features=["ssl"] }
-actix-files = { version = "0.1.0-beta.1" }
+actix-files = { version = "0.1.0-betsa.1" }
 rand = "0.6"
 env_logger = "0.6"
 serde_derive = "1.0"
@@ -121,5 +121,8 @@ actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
 actix-web-actors = { path = "actix-web-actors" }
 actix-session = { path = "actix-session" }
-actix-files = { path = "actix-files" }
 awc = { path = "awc" }
+
+actix-files = { path = "actix-files" }
+actix-framed = { path = "actix-framed" }
+actix-multipart = { path = "actix-multipart" }
diff --git a/actix-files/Cargo.toml b/actix-files/Cargo.toml
index 5e37fc090..a0cbba366 100644
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.1.0-beta.1"
+version = "0.1.0-betsa.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@@ -19,7 +19,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = "1.0.0-beta.1"
-actix-service = "0.3.4"
+actix-service = "0.4.0"
 bitflags = "1"
 bytes = "0.4"
 futures = "0.1.25"
diff --git a/actix-files/src/lib.rs b/actix-files/src/lib.rs
index 4038a5487..301d9d81d 100644
--- 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;
diff --git a/actix-framed/Cargo.toml b/actix-framed/Cargo.toml
index f0622fd90..985515367 100644
--- a/actix-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@@ -21,11 +21,12 @@ 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"
+actix-server-config = "0.1.1"
 
 bytes = "0.4"
 futures = "0.1.25"
diff --git a/actix-framed/src/app.rs b/actix-framed/src/app.rs
index 20bc2f771..297796bd1 100644
--- 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
diff --git a/actix-framed/src/helpers.rs b/actix-framed/src/helpers.rs
index c2c7dbd8b..944b729d4 100644
--- 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;
diff --git a/actix-framed/src/route.rs b/actix-framed/src/route.rs
index c8d9d4326..c50401d6d 100644
--- 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;
diff --git a/actix-framed/src/service.rs b/actix-framed/src/service.rs
index 6e5c7a543..fbbc9fbef 100644
--- 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,
diff --git a/actix-http/CHANGES.md b/actix-http/CHANGES.md
index 872a481d8..f1c119d57 100644
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -1,5 +1,14 @@
 # Changes
 
+## [0.2.0] - 2019-xx-xx
+
+### Changed
+
+* Update actix-service to 0.4
+
+* Expect and upgrade services accept `ServerConfig` config.
+
+
 ## [0.1.5] - 2019-05-04
 
 ### Fixed
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index bcc9b456b..eaac7c090 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -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.5"
-actix-utils = "0.3.5"
+actix-connect = "0.2.0"
+actix-utils = "0.4.0"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"
 
@@ -97,8 +97,8 @@ 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-server = { version = "0.5.0", features=["ssl"] }
+actix-connect = { version = "0.2.0", features=["ssl"] }
 actix-http-test = { version = "0.1.0", features=["ssl"] }
 env_logger = "0.6"
 serde_derive = "1.0"
diff --git a/actix-http/src/builder.rs b/actix-http/src/builder.rs
index 56f144bd8..b1b193a9e 100644
--- 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>>,
diff --git a/actix-http/src/h1/expect.rs b/actix-http/src/h1/expect.rs
index 86fcb2cc3..32b6bd9c4 100644
--- 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)
     }
 }
diff --git a/actix-http/src/h1/service.rs b/actix-http/src/h1/service.rs
index ecf6c8b93..2c0a48eba 100644
--- 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;
diff --git a/actix-http/src/h1/upgrade.rs b/actix-http/src/h1/upgrade.rs
index 0d0164fe6..0278f23e5 100644
--- 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!()
     }
 }
diff --git a/actix-http/src/h2/service.rs b/actix-http/src/h2/service.rs
index 42b8d8d82..b4191f03a 100644
--- 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,
diff --git a/actix-http/src/service.rs b/actix-http/src/service.rs
index dd3af1db0..b762f3cb9 100644
--- 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>>,
diff --git a/actix-http/tests/test_server.rs b/actix-http/tests/test_server.rs
index 4b56e4b2c..d0c5e3526 100644
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@@ -5,7 +5,7 @@ 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};
@@ -163,7 +163,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 +190,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)
@@ -912,7 +912,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 +943,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::<_, ()>(
diff --git a/actix-multipart/Cargo.toml b/actix-multipart/Cargo.toml
index 8e1714e7d..5d0b6fad4 100644
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@@ -19,7 +19,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = "1.0.0-beta.1"
-actix-service = "0.3.6"
+actix-service = "0.4.0"
 bytes = "0.4"
 derive_more = "0.14"
 httparse = "1.3"
diff --git a/actix-session/Cargo.toml b/actix-session/Cargo.toml
index e13ff5c62..fe2054c91 100644
--- a/actix-session/Cargo.toml
+++ b/actix-session/Cargo.toml
@@ -25,7 +25,7 @@ cookie-session = ["actix-web/secure-cookies"]
 
 [dependencies]
 actix-web = "1.0.0-beta.2"
-actix-service = "0.3.4"
+actix-service = "0.4.0"
 bytes = "0.4"
 derive_more = "0.14"
 futures = "0.1.25"
diff --git a/awc/Cargo.toml b/awc/Cargo.toml
index f061351dd..2b51a7525 100644
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@@ -40,7 +40,7 @@ flate2-rust = ["actix-http/flate2-rust"]
 
 [dependencies]
 actix-codec = "0.1.2"
-actix-service = "0.3.6"
+actix-service = "0.4.0"
 actix-http = "0.1.4"
 base64 = "0.10.1"
 bytes = "0.4"
@@ -62,7 +62,7 @@ actix-web = { version = "1.0.0-beta.1", features=["ssl"] }
 actix-http = { version = "0.1.4", features=["ssl"] }
 actix-http-test = { version = "0.1.1", features=["ssl"] }
 actix-utils = "0.3.4"
-actix-server = { version = "0.4.3", features=["ssl"] }
+actix-server = { version = "0.5.0", features=["ssl"] }
 brotli2 = { version="0.3.2" }
 flate2 = { version="1.0.2" }
 env_logger = "0.6"
diff --git a/awc/src/builder.rs b/awc/src/builder.rs
index c460f1357..2bc52a431 100644
--- a/awc/src/builder.rs
+++ b/awc/src/builder.rs
@@ -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"
+        );
     }
 }
diff --git a/awc/src/response.rs b/awc/src/response.rs
index b9b007b87..d186526de 100644
--- 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() {
diff --git a/awc/src/test.rs b/awc/src/test.rs
index 8df21e8f9..f2c513bab 100644
--- 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,
diff --git a/awc/src/ws.rs b/awc/src/ws.rs
index 94a90535b..d3e06d3d5 100644
--- a/awc/src/ws.rs
+++ b/awc/src/ws.rs
@@ -318,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");
@@ -462,29 +464,28 @@ mod tests {
 
     #[test]
     fn basics() {
-        actix_http_test::run_on(|| {
-            let req = Client::new()
-                .ws("http://localhost/")
-                .origin("test-origin")
-                .max_frame_size(100)
-                .server_mode()
-                .protocols(&["v1", "v2"])
-                .set_header_if_none(header::CONTENT_TYPE, "json")
-                .set_header_if_none(header::CONTENT_TYPE, "text")
-                .cookie(Cookie::build("cookie1", "value1").finish());
-            assert_eq!(
-                req.origin.as_ref().unwrap().to_str().unwrap(),
-                "test-origin"
-            );
-            assert_eq!(req.max_size, 100);
-            assert_eq!(req.server_mode, true);
-            assert_eq!(req.protocols, Some("v1,v2".to_string()));
-            assert_eq!(
-                req.head.headers.get(header::CONTENT_TYPE).unwrap(),
-                header::HeaderValue::from_static("json")
-            );
-            let _ = req.connect();
-        });
+        let req = Client::new()
+            .ws("http://localhost/")
+            .origin("test-origin")
+            .max_frame_size(100)
+            .server_mode()
+            .protocols(&["v1", "v2"])
+            .set_header_if_none(header::CONTENT_TYPE, "json")
+            .set_header_if_none(header::CONTENT_TYPE, "text")
+            .cookie(Cookie::build("cookie1", "value1").finish());
+        assert_eq!(
+            req.origin.as_ref().unwrap().to_str().unwrap(),
+            "test-origin"
+        );
+        assert_eq!(req.max_size, 100);
+        assert_eq!(req.server_mode, true);
+        assert_eq!(req.protocols, Some("v1,v2".to_string()));
+        assert_eq!(
+            req.head.headers.get(header::CONTENT_TYPE).unwrap(),
+            header::HeaderValue::from_static("json")
+        );
+
+        let _ = 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());
diff --git a/awc/tests/test_client.rs b/awc/tests/test_client.rs
index 94684dd97..698481e37 100644
--- a/awc/tests/test_client.rs
+++ b/awc/tests/test_client.rs
@@ -15,7 +15,7 @@ use rand::Rng;
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http::HttpService;
 use actix_http_test::TestServer;
-use actix_service::{fn_service, NewService};
+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};
@@ -182,7 +182,7 @@ fn test_connection_reuse() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
@@ -216,7 +216,7 @@ fn test_connection_reuse_h2() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
@@ -268,7 +268,7 @@ fn test_connection_force_close() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
@@ -300,7 +300,7 @@ fn test_connection_server_close() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
@@ -335,7 +335,7 @@ fn test_connection_wait_queue() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
@@ -380,7 +380,7 @@ fn test_connection_wait_queue_force_close() {
 
     let mut srv = TestServer::new(move || {
         let num2 = num2.clone();
-        fn_service(move |io| {
+        service_fn(move |io| {
             num2.fetch_add(1, Ordering::Relaxed);
             Ok(io)
         })
diff --git a/awc/tests/test_ws.rs b/awc/tests/test_ws.rs
index 4fc9f4bdc..5abf96355 100644
--- 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
diff --git a/src/app.rs b/src/app.rs
index eb14d46fa..cc04630a3 100644
--- 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,
@@ -234,6 +234,7 @@ where
     where
         F: IntoNewService<U>,
         U: NewService<
+                Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
@@ -319,6 +320,7 @@ where
         mw: F,
     ) -> App<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse<B1>,
             Error = Error,
@@ -384,6 +386,7 @@ where
         mw: F,
     ) -> App<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse<B1>,
             Error = Error,
@@ -400,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,
diff --git a/src/app_service.rs b/src/app_service.rs
index e2f918428..f34389840 100644
--- a/src/app_service.rs
+++ b/src/app_service.rs
@@ -6,7 +6,7 @@ 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};
 
@@ -31,6 +31,7 @@ type BoxedResponse = Either<
 pub struct AppInit<T, B>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
@@ -46,15 +47,17 @@ where
     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,7 +68,7 @@ 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()))
             })))
         });
@@ -148,6 +151,7 @@ where
 impl<T, B> Future for AppInitResult<T, B>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
@@ -233,6 +237,7 @@ pub struct AppRoutingFactory {
 }
 
 impl NewService for AppRoutingFactory {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
@@ -391,6 +396,7 @@ impl AppEntry {
 }
 
 impl NewService for AppEntry {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
diff --git a/src/config.rs b/src/config.rs
index e4e390b15..62fd01be6 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -107,6 +107,7 @@ impl AppService {
     ) where
         F: IntoNewService<S>,
         S: NewService<
+                Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
diff --git a/src/handler.rs b/src/handler.rs
index 245aba9d1..b53d16389 100644
--- a/src/handler.rs
+++ b/src/handler.rs
@@ -1,7 +1,8 @@
+use std::convert::Infallible;
 use std::marker::PhantomData;
 
 use actix_http::{Error, Payload, Response};
-use actix_service::{NewService, Service, Void};
+use actix_service::{NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::{try_ready, Async, Future, IntoFuture, Poll};
 
@@ -71,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> {
@@ -98,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() {
@@ -191,7 +192,7 @@ where
 {
     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> {
@@ -225,7 +226,7 @@ where
     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 {
@@ -280,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);
@@ -305,8 +310,11 @@ pub struct ExtractService<T: FromRequest, S> {
 
 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;
@@ -339,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);
diff --git a/src/middleware/cors.rs b/src/middleware/cors.rs
index bb4fd567f..f731f49bd 100644
--- a/src/middleware/cors.rs
+++ b/src/middleware/cors.rs
@@ -805,14 +805,15 @@ 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
+            F: IntoService<S>,
             S: Service<
                     Request = ServiceRequest,
                     Response = ServiceResponse<B>,
@@ -822,7 +823,8 @@ mod tests {
             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()
         }
@@ -1063,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();
diff --git a/src/middleware/defaultheaders.rs b/src/middleware/defaultheaders.rs
index 8b92b530d..bddcdd552 100644
--- a/src/middleware/defaultheaders.rs
+++ b/src/middleware/defaultheaders.rs
@@ -150,7 +150,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use actix_service::FnService;
+    use actix_service::IntoService;
 
     use super::*;
     use crate::dev::ServiceRequest;
@@ -172,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();
@@ -187,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();
diff --git a/src/middleware/errhandlers.rs b/src/middleware/errhandlers.rs
index acc6783f8..ac166e0eb 100644
--- a/src/middleware/errhandlers.rs
+++ b/src/middleware/errhandlers.rs
@@ -142,7 +142,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use actix_service::FnService;
+    use actix_service::IntoService;
     use futures::future::ok;
 
     use super::*;
@@ -159,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();
 
@@ -185,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();
 
diff --git a/src/middleware/logger.rs b/src/middleware/logger.rs
index 3e3fb05fa..5d0b615e1 100644
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@@ -457,7 +457,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 +465,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,
diff --git a/src/middleware/normalize.rs b/src/middleware/normalize.rs
index a86e2b9c7..427f954fe 100644
--- a/src/middleware/normalize.rs
+++ b/src/middleware/normalize.rs
@@ -100,7 +100,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use actix_service::FnService;
+    use actix_service::IntoService;
 
     use super::*;
     use crate::dev::ServiceRequest;
@@ -122,12 +122,13 @@ mod tests {
 
     #[test]
     fn test_in_place_normalization() {
-        let srv = FnService::new(|req: ServiceRequest| {
+        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)).unwrap();
+        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();
@@ -138,12 +139,13 @@ mod tests {
     fn should_normalize_nothing() {
         const URI: &str = "/v1/something/";
 
-        let srv = FnService::new(|req: ServiceRequest| {
+        let srv = |req: ServiceRequest| {
             assert_eq!(URI, req.path());
             req.into_response(HttpResponse::Ok().finish())
-        });
+        };
 
-        let mut normalize = block_on(NormalizePath.new_transform(srv)).unwrap();
+        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();
diff --git a/src/resource.rs b/src/resource.rs
index 8bafc0fcd..2040a1bbe 100644
--- a/src/resource.rs
+++ b/src/resource.rs
@@ -75,6 +75,7 @@ impl Resource {
 impl<T> Resource<T>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
@@ -274,6 +275,7 @@ where
         mw: F,
     ) -> Resource<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -340,6 +342,7 @@ where
         mw: F,
     ) -> Resource<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -360,6 +363,7 @@ where
     where
         F: IntoNewService<U>,
         U: NewService<
+                Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
@@ -380,6 +384,7 @@ where
 impl<T> HttpServiceFactory for Resource<T>
 where
     T: NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -411,6 +416,7 @@ where
 impl<T> IntoNewService<T> for Resource<T>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
@@ -435,6 +441,7 @@ pub struct ResourceFactory {
 }
 
 impl NewService for ResourceFactory {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
@@ -575,6 +582,7 @@ impl ResourceEndpoint {
 }
 
 impl NewService for ResourceEndpoint {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
diff --git a/src/route.rs b/src/route.rs
index 62f030c79..660b82002 100644
--- a/src/route.rs
+++ b/src/route.rs
@@ -26,6 +26,7 @@ type BoxedRouteService<Req, Res> = Box<
 
 type BoxedRouteNewService<Req, Res> = Box<
     NewService<
+        Config = (),
         Request = Req,
         Response = Res,
         Error = Error,
@@ -61,6 +62,7 @@ impl Route {
 }
 
 impl NewService for Route {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
@@ -283,6 +285,7 @@ where
 impl<T> RouteNewService<T>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
         Error = (Error, ServiceRequest),
@@ -299,6 +302,7 @@ where
 impl<T> NewService for RouteNewService<T>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
         Error = (Error, ServiceRequest),
@@ -307,6 +311,7 @@ where
     T::Service: 'static,
     <T::Service as Service>::Future: 'static,
 {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
diff --git a/src/scope.rs b/src/scope.rs
index ada533341..59d3c6738 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -6,7 +6,7 @@ use actix_http::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};
@@ -85,6 +85,7 @@ impl Scope {
 impl<T> Scope<T>
 where
     T: NewService<
+        Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
@@ -188,6 +189,7 @@ where
     where
         F: IntoNewService<U>,
         U: NewService<
+                Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
@@ -218,6 +220,7 @@ where
         mw: F,
     ) -> Scope<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -234,7 +237,7 @@ 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,
@@ -280,6 +283,7 @@ where
         mw: F,
     ) -> Scope<
         impl NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -297,6 +301,7 @@ where
 impl<T> HttpServiceFactory for Scope<T>
 where
     T: NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
@@ -355,6 +360,7 @@ pub struct ScopeFactory {
 }
 
 impl NewService for ScopeFactory {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
@@ -515,6 +521,7 @@ impl ScopeEndpoint {
 }
 
 impl NewService for ScopeEndpoint {
+    type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
diff --git a/src/server.rs b/src/server.rs
index efc70773f..3cb139976 100644
--- 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>>,
@@ -71,8 +71,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>>,
@@ -442,8 +442,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>>,
diff --git a/src/service.rs b/src/service.rs
index f35ea89f2..eee8b0adb 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -442,6 +442,7 @@ impl WebService {
     where
         F: IntoNewService<T>,
         T: NewService<
+                Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
@@ -467,6 +468,7 @@ struct WebServiceImpl<T> {
 impl<T> HttpServiceFactory for WebServiceImpl<T>
 where
     T: NewService<
+            Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
diff --git a/src/test.rs b/src/test.rs
index 66b380e83..3b3aac67d 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -9,7 +9,7 @@ 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, IntoFuture};
 use futures::Stream;
@@ -110,9 +110,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
@@ -141,9 +142,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,
diff --git a/test-server/Cargo.toml b/test-server/Cargo.toml
index 906c9d389..cd5cc5057 100644
--- a/test-server/Cargo.toml
+++ b/test-server/Cargo.toml
@@ -32,9 +32,9 @@ ssl = ["openssl", "actix-server/ssl", "awc/ssl"]
 [dependencies]
 actix-codec = "0.1.2"
 actix-rt = "0.2.2"
-actix-service = "0.3.6"
-actix-server = "0.4.3"
-actix-utils = "0.3.5"
+actix-service = "0.4.0"
+actix-server = "0.5.0"
+actix-utils = "0.4.0"
 awc = "0.1.1"
 
 base64 = "0.10"
diff --git a/test-server/src/lib.rs b/test-server/src/lib.rs
index 42d07549d..b8f5934ae 100644
--- a/test-server/src/lib.rs
+++ b/test-server/src/lib.rs
@@ -9,16 +9,30 @@ use actix_server::{Server, StreamServiceFactory};
 use awc::{error::PayloadError, ws, Client, ClientRequest, ClientResponse, Connector};
 use bytes::Bytes;
 use futures::future::lazy;
-use futures::{Future, Stream};
+use futures::{Future, IntoFuture, Stream};
 use http::Method;
 use net2::TcpBuilder;
 
 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.
 ///
@@ -31,21 +45,27 @@ 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, with runtime enabled.
+/// 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 run_on<F, R>(f: F) -> R
+pub fn block_fn<F, R>(f: F) -> Result<R::Item, R::Error>
 where
-    F: Fn() -> R,
+    F: FnOnce() -> R,
+    R: IntoFuture,
 {
-    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(|| f())))
 }
 
 /// The `TestServer` type.