Prepare actix-connect release (#53)

* Update rustls, tokio-rustls and webpki across the board

* bump minimum rust version to 1.37

* updated readme and changelogs to reflect changes and minimum required rust version

.travis.yml

@@ -10,9 +10,10 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly
+    - rust: 1.37.0
+    - rust: nightly-2019-06-15
   allow_failures:
-    - rust: nightly
+    - rust: nightly-2019-06-15
 
 env:
   global:
@@ -24,33 +25,26 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
+before_cache: |
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
+  fi
+
 # Add clippy
 before_script:
   - export PATH=$PATH:~/.cargo/bin
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-06-15" ]]; then
     cargo clean
-    cargo test --features="ssl,tls,rust-tls" -- --nocapture
-    cd actix-service && cargo test
-    fi
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
-    cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
-    bash <(curl -s https://codecov.io/bash)
-    echo "Uploaded code coverage"
-    cd actix-service && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash)
+    cargo test --all --all-features -- --nocapture
     fi
 
-# Upload docs
 after_success:
   - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then
-      cargo doc --features "ssl,tls,rust-tls" --no-deps &&
-      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
-      git clone https://github.com/davisp/ghp-import.git &&
-      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
-      echo "Uploaded documentation"
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
+    taskset -c 0 cargo tarpaulin --all --all-features --out Xml
+    echo "Uploaded code coverage"
+    bash <(curl -s https://codecov.io/bash)
     fi

CHANGES.md

@@ -1,68 +0,0 @@
-# Changes
-
-## [0.3.0] - xxx
-
-* Split `Service` trait to separate crate
-
-* Use new `Service<Request>` trait
-
-
-## [0.2.4] - 2018-11-21
-
-### Added
-
-* Allow to skip name resolution stage in Connector
-
-
-## [0.2.3] - 2018-11-17
-
-### Added
-
-* Framed::is_write_buf_empty() checks if write buffer is flushed
-
-## [0.2.2] - 2018-11-14
-
-### Added
-
-* Add low/high caps to Framed
-
-### Changed
-
-* Refactor Connector and Resolver services
-
-
-### Fixed
-
-* Fix wrong service to socket binding
-
-
-## [0.2.0] - 2018-11-08
-
-### Added
-
-* Timeout service
-
-* Added ServiceConfig and ServiceRuntime for server service configuration
-
-
-### Changed
-
-* Connector has been refactored
-
-* timer and LowResTimer renamed to time and LowResTime
-
-* Refactored `Server::configure()` method
-
-
-## [0.1.1] - 2018-10-10
-
-### Changed
-
-- Set actix min version - 0.7.5
-
-- Set trust-dns min version
-
-
-## [0.1.0] - 2018-10-08
-
-* Initial impl

Cargo.toml

@@ -2,7 +2,7 @@
 name = "actix-net"
 version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix net - framework for the compisible network services for Rust (experimental)"
+description = "Actix net - framework for the composable network services for Rust"
 readme = "README.md"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
@@ -15,76 +15,39 @@ edition = "2018"
 
 [workspace]
 members = [
-  "./",
+  "actix-codec",
+  "actix-connect",
+  "actix-ioframe",
+  "actix-rt",
   "actix-service",
+  "actix-server",
+  "actix-server-config",
+  "actix-testing",
+  "actix-threadpool",
+  "actix-utils",
+  "router",
 ]
 
-[package.metadata.docs.rs]
-features = ["ssl", "tls", "rust-tls"]
-
-[badges]
-travis-ci = { repository = "actix/actix-net", branch = "master" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
-codecov = { repository = "actix/actix-net", branch = "master", service = "github" }
-
-[lib]
-name = "actix_net"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# tls
-tls = ["native-tls"]
-
-# openssl
-ssl = ["openssl", "tokio-openssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
-
-cell = []
-
-[dependencies]
-actix = "0.7.6"
-actix-service = "0.1.1"
-
-log = "0.4"
-num_cpus = "1.0"
-
-# io
-mio = "^0.6.13"
-net2 = "0.2"
-bytes = "0.4"
-futures = "0.1"
-slab = "0.4"
-tokio = "0.1"
-tokio-codec = "0.1"
-tokio-io = "0.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2"
-tokio-reactor = "0.1"
-tokio-current-thread = "0.1"
-trust-dns-proto = "^0.5.0"
-trust-dns-resolver = "^0.10.0"
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.2", optional = true }
-
-#rustls
-rustls = { version = "^0.14", optional = true }
-tokio-rustls = { version = "^0.8", optional = true }
-webpki = { version = "0.18", optional = true }
-webpki-roots = { version = "0.15", optional = true }
-
 [dev-dependencies]
-env_logger = "0.5"
+actix-service = "0.4.0"
+actix-codec = "0.1.1"
+actix-rt = "0.2.0"
+actix-server = { version="0.5.0", features=["ssl"] }
+env_logger = "0.6"
+futures = "0.1.25"
+openssl = "0.10"
+tokio-tcp = "0.1"
+tokio-openssl = "0.3"
 
-[profile.release]
-lto = true
-opt-level = 3
-codegen-units = 1
+[patch.crates-io]
+actix-codec = { path = "actix-codec" }
+actix-connect = { path = "actix-connect" }
+actix-ioframe = { path = "actix-ioframe" }
+actix-rt = { path = "actix-rt" }
+actix-server = { path = "actix-server" }
+actix-server-config = { path = "actix-server-config" }
+actix-service = { path = "actix-service" }
+actix-testing = { path = "actix-testing" }
+actix-threadpool = { path = "actix-threadpool" }
+actix-utils = { path = "actix-utils" }
+actix-router = { path = "router" }

README.md

@@ -1,20 +1,18 @@
-# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![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)
+# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![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)
 
-Actix net - framework for composable network services (experimental)
+Actix net - framework for composable network services
 
 ## Documentation & community resources
 
 * [API Documentation (Development)](https://actix.rs/actix-net/actix_net/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-net](https://crates.io/crates/actix-net)
-* Minimum supported Rust version: 1.26 or later
+* Minimum supported Rust version: 1.37 or later
 
 ## Example
 
 ```rust
-fn main() {
-    let sys = actix::System::new("test");
-
+fn main() -> io::Result<()> {
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
     builder.set_private_key_file("./examples/key.pem", SslFiletype::PEM).unwrap();
@@ -26,7 +24,7 @@ fn main() {
     // bind socket address and start workers. By default server uses number of
     // available logical cpu as threads count. actix net start separate
     // instances of service pipeline in each worker.
-    Server::default()
+    Server::build()
         .bind(
             // configure service pipeline
             "basic", "0.0.0.0:8443",
@@ -35,28 +33,23 @@ fn main() {
                 let acceptor = acceptor.clone();
 
                 // service for converting incoming TcpStream to a SslStream<TcpStream>
-                (move |stream| {
-                SslAcceptorExt::accept_async(&acceptor, stream)
-                    .map_err(|e| println!("Openssl error: {}", e))
-            })
-            // convert closure to a `NewService`
-            .into_new_service()
-
-            // .and_then() combinator uses other service to convert incoming `Request` to a `Response`
-            // and then uses that response as an input for next service.
-            // in this case, on success we use `logger` service
-            .and_then(logger)
-
-            // Next service counts number of connections
-            .and_then(move |req| {
-                let num = num.fetch_add(1, Ordering::Relaxed);
-                println!("processed {:?} connections", num);
-                future::ok(())
-            })
-        }).unwrap()
-        .start();
-
-    sys.run();
+                fn_service(move |stream: Io<tokio_tcp::TcpStream>| {
+                    SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0)
+                        .map_err(|e| println!("Openssl error: {}", e))
+                })
+                // .and_then() combinator uses other service to convert incoming `Request` to a
+                // `Response` and then uses that response as an input for next
+                // service. in this case, on success we use `logger` service
+                .and_then(fn_service(logger))
+                // Next service counts number of connections
+                .and_then(move |_| {
+                    let num = num.fetch_add(1, Ordering::Relaxed);
+                    println!("got ssl connection {:?}", num);
+                    future::ok(())
+                })
+            },
+        )?
+        .run()
 }
 ```
 

actix-codec/CHANGES.md

@@ -0,0 +1,15 @@
+# Changes
+
+## [0.1.2] - 2019-03-27
+
+* Added `Framed::map_io()` method.
+
+
+## [0.1.1] - 2019-03-06
+
+* Added `FramedParts::with_read_buffer()` method.
+
+
+## [0.1.0] - 2018-12-09
+
+* Move codec to separate crate

actix-codec/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "actix-codec"
+version = "0.1.2"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Utilities for encoding and decoding frames"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-codec/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_codec"
+path = "src/lib.rs"
+
+[dependencies]
+bytes = "0.4.12"
+futures = "0.1.24"
+tokio-io = "0.1.12"
+tokio-codec = "0.1.1"
+log = "0.4"

actix-codec/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-codec/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-codec/src/framed.rs

@@ -167,6 +167,22 @@ impl<T, U> Framed<T, U> {
         }
     }
 
+    /// Consume the `Frame`, returning `Frame` with different io.
+    pub fn map_io<F, T2>(self, f: F) -> Framed<T2, U>
+    where
+        F: Fn(T) -> T2,
+    {
+        let (inner, read_buf) = self.inner.into_parts();
+        let (inner, write_buf, lw, hw) = inner.into_parts();
+
+        Framed {
+            inner: framed_read2_with_buffer(
+                framed_write2_with_buffer(Fuse(f(inner.0), inner.1), write_buf, lw, hw),
+                read_buf,
+            ),
+        }
+    }
+
     /// Consume the `Frame`, returning `Frame` with different codec.
     pub fn map_codec<F, U2>(self, f: F) -> Framed<T, U2>
     where
@@ -349,4 +365,17 @@ impl<T, U> FramedParts<T, U> {
             _priv: (),
         }
     }
+
+    /// Create a new `FramedParts` with read buffer
+    pub fn with_read_buf(io: T, codec: U, read_buf: BytesMut) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            read_buf,
+            write_buf: BytesMut::new(),
+            write_buf_lw: LW,
+            write_buf_hw: HW,
+            _priv: (),
+        }
+    }
 }

actix-codec/src/lib.rs

@@ -10,16 +10,15 @@
 //! [`Stream`]: #
 //! [transports]: #
 
-#![deny(missing_docs, missing_debug_implementations, warnings)]
-
 mod bcodec;
 mod framed;
-// mod framed2;
 mod framed_read;
 mod framed_write;
 
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
-// pub use self::framed2::{Framed2, FramedParts2};
 pub use self::framed_read::FramedRead;
 pub use self::framed_write::FramedWrite;
+
+pub use tokio_codec::{Decoder, Encoder};
+pub use tokio_io::{AsyncRead, AsyncWrite};

actix-connect/CHANGES.md

@@ -0,0 +1,90 @@
+# Changes
+
+## [0.3.0] - 2019-10-03
+
+### Changed
+
+* Update `rustls` to 0.16
+* Minimum required Rust version upped to 1.37.0
+
+## [0.2.5] - 2019-09-05
+
+* Add `TcpConnectService`
+
+## [0.2.4] - 2019-09-02
+
+* Use arbiter's storage for default async resolver
+
+## [0.2.3] - 2019-08-05
+
+* Add `ConnectService` and `OpensslConnectService`
+
+## [0.2.2] - 2019-07-24
+
+* Add `rustls` support
+
+## [0.2.1] - 2019-07-17
+
+### Added
+
+* Expose Connect addrs #30
+
+### Changed
+
+* Update `derive_more` to 0.15
+
+
+## [0.2.0] - 2019-05-12
+
+### Changed
+
+* Upgrade to actix-service 0.4
+
+
+## [0.1.5] - 2019-04-19
+
+### Added
+
+* `Connect::set_addr()`
+
+### Changed
+
+* Use trust-dns-resolver 0.11.0
+
+
+## [0.1.4] - 2019-04-12
+
+### Changed
+
+* Do not start default resolver immediately for default connector.
+
+
+## [0.1.3] - 2019-04-11
+
+### Changed
+
+* Start trust-dns default resolver on first use
+
+## [0.1.2] - 2019-04-04
+
+### Added
+
+* Log error if dns system config could not be loaded.
+
+### Changed
+
+* Rename connect Connector to TcpConnector #10
+
+
+## [0.1.1] - 2019-03-15
+
+### Fixed
+
+* Fix error handling for single address
+
+
+## [0.1.0] - 2019-03-14
+
+* Refactor resolver and connector services
+
+* Rename crate

actix-connect/Cargo.toml

@@ -0,0 +1,61 @@
+[package]
+name = "actix-connect"
+version = "0.3.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix Connector - tcp connector service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-connect/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[package.metadata.docs.rs]
+features = ["ssl", "uri"]
+
+[lib]
+name = "actix_connect"
+path = "src/lib.rs"
+
+[features]
+default = ["uri"]
+
+# openssl
+ssl = ["openssl", "tokio-openssl"]
+
+#rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki"]
+
+# support http::Uri as connect address
+uri = ["http"]
+
+[dependencies]
+actix-service = "0.4.0"
+actix-codec = "0.1.2"
+actix-utils = "0.4.0"
+actix-rt = "0.2.5"
+derive_more = "0.15"
+either = "1.5.2"
+futures = "0.1.25"
+http = { version = "0.1.17", optional = true }
+log = "0.4"
+tokio-tcp = "0.1.3"
+tokio-current-thread = "0.1.5"
+trust-dns-resolver = { version="0.11.0", default-features = false }
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.3", optional = true }
+
+#rustls
+rustls = { version = "0.16.0", optional = true }
+tokio-rustls = { version = "0.10.0", optional = true }
+webpki = { version = "0.21", optional = true }
+
+[dev-dependencies]
+bytes = "0.4"
+actix-testing = { version="0.1.0" }
+actix-server-config = "0.1.0"

actix-connect/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-connect/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-connect/src/connect.rs

@@ -0,0 +1,281 @@
+use std::collections::{vec_deque, VecDeque};
+use std::fmt;
+use std::iter::{FromIterator, FusedIterator};
+use std::net::SocketAddr;
+
+use either::Either;
+
+/// Connect request
+pub trait Address {
+    /// Host name of the request
+    fn host(&self) -> &str;
+
+    /// Port of the request
+    fn port(&self) -> Option<u16>;
+}
+
+impl Address for String {
+    fn host(&self) -> &str {
+        &self
+    }
+
+    fn port(&self) -> Option<u16> {
+        None
+    }
+}
+
+impl Address for &'static str {
+    fn host(&self) -> &str {
+        self
+    }
+
+    fn port(&self) -> Option<u16> {
+        None
+    }
+}
+
+/// Connect request
+#[derive(Eq, PartialEq, Debug, Hash)]
+pub struct Connect<T> {
+    pub(crate) req: T,
+    pub(crate) port: u16,
+    pub(crate) addr: Option<Either<SocketAddr, VecDeque<SocketAddr>>>,
+}
+
+impl<T: Address> Connect<T> {
+    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
+    pub fn new(req: T) -> Connect<T> {
+        let (_, port) = parse(req.host());
+        Connect {
+            req,
+            port: port.unwrap_or(0),
+            addr: None,
+        }
+    }
+
+    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
+    pub fn with(req: T, addr: SocketAddr) -> Connect<T> {
+        Connect {
+            req,
+            port: 0,
+            addr: Some(Either::Left(addr)),
+        }
+    }
+
+    /// Use port if address does not provide one.
+    ///
+    /// By default it set to 0
+    pub fn set_port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    /// Use address.
+    pub fn set_addr(mut self, addr: Option<SocketAddr>) -> Self {
+        if let Some(addr) = addr {
+            self.addr = Some(Either::Left(addr));
+        }
+        self
+    }
+
+    /// Use addresses.
+    pub fn set_addrs<I>(mut self, addrs: I) -> Self
+    where
+        I: IntoIterator<Item = SocketAddr>,
+    {
+        let mut addrs = VecDeque::from_iter(addrs);
+        self.addr = if addrs.len() < 2 {
+            addrs.pop_front().map(Either::Left)
+        } else {
+            Some(Either::Right(addrs))
+        };
+        self
+    }
+
+    /// Host name
+    pub fn host(&self) -> &str {
+        self.req.host()
+    }
+
+    /// Port of the request
+    pub fn port(&self) -> u16 {
+        self.req.port().unwrap_or(self.port)
+    }
+
+    /// Preresolved addresses of the request.
+    pub fn addrs(&self) -> ConnectAddrsIter<'_> {
+        let inner = match self.addr {
+            None => Either::Left(None),
+            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()),
+        };
+
+        ConnectAddrsIter { inner }
+    }
+
+    /// Takes preresolved addresses of the request.
+    pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter {
+        let inner = match self.addr.take() {
+            None => Either::Left(None),
+            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()),
+        };
+
+        ConnectTakeAddrsIter { inner }
+    }
+}
+
+impl<T: Address> From<T> for Connect<T> {
+    fn from(addr: T) -> Self {
+        Connect::new(addr)
+    }
+}
+
+impl<T: Address> fmt::Display for Connect<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}:{}", self.host(), self.port())
+    }
+}
+
+/// Iterator over addresses in a [`Connect`](struct.Connect.html) request.
+#[derive(Clone)]
+pub struct ConnectAddrsIter<'a> {
+    inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
+}
+
+impl Iterator for ConnectAddrsIter<'_> {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.inner {
+            Either::Left(ref mut opt) => opt.take(),
+            Either::Right(ref mut iter) => iter.next().copied(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.inner {
+            Either::Left(Some(_)) => (1, Some(1)),
+            Either::Left(None) => (0, Some(0)),
+            Either::Right(ref iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl fmt::Debug for ConnectAddrsIter<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl ExactSizeIterator for ConnectAddrsIter<'_> {}
+
+impl FusedIterator for ConnectAddrsIter<'_> {}
+
+/// Owned iterator over addresses in a [`Connect`](struct.Connect.html) request.
+#[derive(Debug)]
+pub struct ConnectTakeAddrsIter {
+    inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,
+}
+
+impl Iterator for ConnectTakeAddrsIter {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.inner {
+            Either::Left(ref mut opt) => opt.take(),
+            Either::Right(ref mut iter) => iter.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.inner {
+            Either::Left(Some(_)) => (1, Some(1)),
+            Either::Left(None) => (0, Some(0)),
+            Either::Right(ref iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl ExactSizeIterator for ConnectTakeAddrsIter {}
+
+impl FusedIterator for ConnectTakeAddrsIter {}
+
+fn parse(host: &str) -> (&str, Option<u16>) {
+    let mut parts_iter = host.splitn(2, ':');
+    if let Some(host) = parts_iter.next() {
+        let port_str = parts_iter.next().unwrap_or("");
+        if let Ok(port) = port_str.parse::<u16>() {
+            (host, Some(port))
+        } else {
+            (host, None)
+        }
+    } else {
+        (host, None)
+    }
+}
+
+pub struct Connection<T, U> {
+    io: U,
+    req: T,
+}
+
+impl<T, U> Connection<T, U> {
+    pub fn new(io: U, req: T) -> Self {
+        Self { io, req }
+    }
+}
+
+impl<T, U> Connection<T, U> {
+    /// Reconstruct from a parts.
+    pub fn from_parts(io: U, req: T) -> Self {
+        Self { io, req }
+    }
+
+    /// Deconstruct into a parts.
+    pub fn into_parts(self) -> (U, T) {
+        (self.io, self.req)
+    }
+
+    /// Replace inclosed object, return new Stream and old object
+    pub fn replace<Y>(self, io: Y) -> (U, Connection<T, Y>) {
+        (self.io, Connection { io, req: self.req })
+    }
+
+    /// Returns a shared reference to the underlying stream.
+    pub fn get_ref(&self) -> &U {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying stream.
+    pub fn get_mut(&mut self) -> &mut U {
+        &mut self.io
+    }
+}
+
+impl<T: Address, U> Connection<T, U> {
+    /// Get request
+    pub fn host(&self) -> &str {
+        &self.req.host()
+    }
+}
+
+impl<T, U> std::ops::Deref for Connection<T, U> {
+    type Target = U;
+
+    fn deref(&self) -> &U {
+        &self.io
+    }
+}
+
+impl<T, U> std::ops::DerefMut for Connection<T, U> {
+    fn deref_mut(&mut self) -> &mut U {
+        &mut self.io
+    }
+}
+
+impl<T, U: fmt::Debug> fmt::Debug for Connection<T, U> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Stream {{{:?}}}", self.io)
+    }
+}

actix-connect/src/connector.rs

@@ -0,0 +1,168 @@
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::net::SocketAddr;
+
+use actix_service::{NewService, Service};
+use futures::future::{err, ok, Either, FutureResult};
+use futures::{Async, Future, Poll};
+use tokio_tcp::{ConnectFuture, TcpStream};
+
+use super::connect::{Address, Connect, Connection};
+use super::error::ConnectError;
+
+/// Tcp connector service factory
+#[derive(Debug)]
+pub struct TcpConnectorFactory<T>(PhantomData<T>);
+
+impl<T> TcpConnectorFactory<T> {
+    pub fn new() -> Self {
+        TcpConnectorFactory(PhantomData)
+    }
+
+    /// Create tcp connector service
+    pub fn service(&self) -> TcpConnector<T> {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T> Default for TcpConnectorFactory<T> {
+    fn default() -> Self {
+        TcpConnectorFactory(PhantomData)
+    }
+}
+
+impl<T> Clone for TcpConnectorFactory<T> {
+    fn clone(&self) -> Self {
+        TcpConnectorFactory(PhantomData)
+    }
+}
+
+impl<T: Address> NewService for TcpConnectorFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = TcpConnector<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+/// Tcp connector service
+#[derive(Default, Debug)]
+pub struct TcpConnector<T>(PhantomData<T>);
+
+impl<T> TcpConnector<T> {
+    pub fn new() -> Self {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T> Clone for TcpConnector<T> {
+    fn clone(&self) -> Self {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T: Address> Service for TcpConnector<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = Either<TcpConnectorResponse<T>, FutureResult<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        let port = req.port();
+        let Connect { req, addr, .. } = req;
+
+        if let Some(addr) = addr {
+            Either::A(TcpConnectorResponse::new(req, port, addr))
+        } else {
+            error!("TCP connector: got unresolved address");
+            Either::B(err(ConnectError::Unresolverd))
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Tcp stream connector response future
+pub struct TcpConnectorResponse<T> {
+    req: Option<T>,
+    port: u16,
+    addrs: Option<VecDeque<SocketAddr>>,
+    stream: Option<ConnectFuture>,
+}
+
+impl<T: Address> TcpConnectorResponse<T> {
+    pub fn new(
+        req: T,
+        port: u16,
+        addr: either::Either<SocketAddr, VecDeque<SocketAddr>>,
+    ) -> TcpConnectorResponse<T> {
+        trace!(
+            "TCP connector - connecting to {:?} port:{}",
+            req.host(),
+            port
+        );
+
+        match addr {
+            either::Either::Left(addr) => TcpConnectorResponse {
+                req: Some(req),
+                port,
+                addrs: None,
+                stream: Some(TcpStream::connect(&addr)),
+            },
+            either::Either::Right(addrs) => TcpConnectorResponse {
+                req: Some(req),
+                port,
+                addrs: Some(addrs),
+                stream: None,
+            },
+        }
+    }
+}
+
+impl<T: Address> Future for TcpConnectorResponse<T> {
+    type Item = Connection<T, TcpStream>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        // connect
+        loop {
+            if let Some(new) = self.stream.as_mut() {
+                match new.poll() {
+                    Ok(Async::Ready(sock)) => {
+                        let req = self.req.take().unwrap();
+                        trace!(
+                            "TCP connector - successfully connected to connecting to {:?} - {:?}",
+                            req.host(), sock.peer_addr()
+                        );
+                        return Ok(Async::Ready(Connection::new(sock, req)));
+                    }
+                    Ok(Async::NotReady) => return Ok(Async::NotReady),
+                    Err(err) => {
+                        trace!(
+                            "TCP connector - failed to connect to connecting to {:?} port: {}",
+                            self.req.as_ref().unwrap().host(),
+                            self.port,
+                        );
+                        if self.addrs.is_none() || self.addrs.as_ref().unwrap().is_empty() {
+                            return Err(err.into());
+                        }
+                    }
+                }
+            }
+
+            // try to connect
+            self.stream = Some(TcpStream::connect(
+                &self.addrs.as_mut().unwrap().pop_front().unwrap(),
+            ));
+        }
+    }
+}

actix-connect/src/error.rs

@@ -0,0 +1,26 @@
+use std::io;
+
+use derive_more::{Display, From};
+use trust_dns_resolver::error::ResolveError;
+
+#[derive(Debug, From, Display)]
+pub enum ConnectError {
+    /// Failed to resolve the hostname
+    #[display(fmt = "Failed resolving hostname: {}", _0)]
+    Resolver(ResolveError),
+
+    /// No dns records
+    #[display(fmt = "No dns records found for the input")]
+    NoRecords,
+
+    /// Invalid input
+    InvalidInput,
+
+    /// Unresolved host name
+    #[display(fmt = "Connector received `Connect` method with unresolved host")]
+    Unresolverd,
+
+    /// Connection io error
+    #[display(fmt = "{}", _0)]
+    Io(io::Error),
+}

actix-connect/src/lib.rs

@@ -0,0 +1,106 @@
+//! Actix connect - tcp connector service
+//!
+//! ## Package feature
+//!
+//! * `ssl` - enables ssl support via `openssl` crate
+//! * `rust-tls` - enables ssl support via `rustls` crate
+
+#![recursion_limit = "128"]
+
+#[macro_use]
+extern crate log;
+
+mod connect;
+mod connector;
+mod error;
+mod resolver;
+mod service;
+pub mod ssl;
+
+#[cfg(feature = "uri")]
+mod uri;
+
+pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+pub use trust_dns_resolver::system_conf::read_system_conf;
+pub use trust_dns_resolver::{error::ResolveError, AsyncResolver};
+
+pub use self::connect::{Address, Connect, Connection};
+pub use self::connector::{TcpConnector, TcpConnectorFactory};
+pub use self::error::ConnectError;
+pub use self::resolver::{Resolver, ResolverFactory};
+pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
+
+use actix_rt::Arbiter;
+use actix_service::{NewService, Service, ServiceExt};
+use tokio_tcp::TcpStream;
+
+pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
+    let (resolver, bg) = AsyncResolver::new(cfg, opts);
+    tokio_current_thread::spawn(bg);
+    resolver
+}
+
+struct DefaultResolver(AsyncResolver);
+
+pub(crate) fn get_default_resolver() -> AsyncResolver {
+    if Arbiter::contains_item::<DefaultResolver>() {
+        return Arbiter::get_item(|item: &DefaultResolver| item.0.clone());
+    } else {
+        let (cfg, opts) = match read_system_conf() {
+            Ok((cfg, opts)) => (cfg, opts),
+            Err(e) => {
+                log::error!("TRust-DNS can not load system config: {}", e);
+                (ResolverConfig::default(), ResolverOpts::default())
+            }
+        };
+
+        let (resolver, bg) = AsyncResolver::new(cfg, opts);
+        tokio_current_thread::spawn(bg);
+
+        Arbiter::set_item(DefaultResolver(resolver.clone()));
+        resolver
+    }
+}
+
+pub fn start_default_resolver() -> AsyncResolver {
+    get_default_resolver()
+}
+
+/// Create tcp connector service
+pub fn new_connector<T: Address>(
+    resolver: AsyncResolver,
+) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+         + Clone {
+    Resolver::new(resolver).and_then(TcpConnector::new())
+}
+
+/// Create tcp connector service
+pub fn new_connector_factory<T: Address>(
+    resolver: AsyncResolver,
+) -> impl NewService<
+    Config = (),
+    Request = Connect<T>,
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    ResolverFactory::new(resolver).and_then(TcpConnectorFactory::new())
+}
+
+/// Create connector service with default parameters
+pub fn default_connector<T: Address>(
+) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+         + Clone {
+    Resolver::default().and_then(TcpConnector::new())
+}
+
+/// Create connector service factory with default parameters
+pub fn default_connector_factory<T: Address>() -> impl NewService<
+    Config = (),
+    Request = Connect<T>,
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    ResolverFactory::default().and_then(TcpConnectorFactory::new())
+}

actix-connect/src/resolver.rs

@@ -0,0 +1,185 @@
+use std::marker::PhantomData;
+use std::net::SocketAddr;
+
+use actix_service::{NewService, Service};
+use futures::future::{ok, Either, FutureResult};
+use futures::{Async, Future, Poll};
+use trust_dns_resolver::lookup_ip::LookupIpFuture;
+use trust_dns_resolver::{AsyncResolver, Background};
+
+use crate::connect::{Address, Connect};
+use crate::error::ConnectError;
+use crate::get_default_resolver;
+
+/// DNS Resolver Service factory
+pub struct ResolverFactory<T> {
+    resolver: Option<AsyncResolver>,
+    _t: PhantomData<T>,
+}
+
+impl<T> ResolverFactory<T> {
+    /// Create new resolver instance with custom configuration and options.
+    pub fn new(resolver: AsyncResolver) -> Self {
+        ResolverFactory {
+            resolver: Some(resolver),
+            _t: PhantomData,
+        }
+    }
+
+    pub fn service(&self) -> Resolver<T> {
+        Resolver {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Default for ResolverFactory<T> {
+    fn default() -> Self {
+        ResolverFactory {
+            resolver: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Clone for ResolverFactory<T> {
+    fn clone(&self) -> Self {
+        ResolverFactory {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address> NewService for ResolverFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = Resolver<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+/// DNS Resolver Service
+pub struct Resolver<T> {
+    resolver: Option<AsyncResolver>,
+    _t: PhantomData<T>,
+}
+
+impl<T> Resolver<T> {
+    /// Create new resolver instance with custom configuration and options.
+    pub fn new(resolver: AsyncResolver) -> Self {
+        Resolver {
+            resolver: Some(resolver),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Default for Resolver<T> {
+    fn default() -> Self {
+        Resolver {
+            resolver: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Clone for Resolver<T> {
+    fn clone(&self) -> Self {
+        Resolver {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address> Service for Resolver<T> {
+    type Request = Connect<T>;
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Future = Either<ResolverFuture<T>, FutureResult<Connect<T>, Self::Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, mut req: Connect<T>) -> Self::Future {
+        if req.addr.is_some() {
+            Either::B(ok(req))
+        } else if let Ok(ip) = req.host().parse() {
+            req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
+            Either::B(ok(req))
+        } else {
+            trace!("DNS resolver: resolving host {:?}", req.host());
+            if self.resolver.is_none() {
+                self.resolver = Some(get_default_resolver());
+            }
+            Either::A(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Resolver future
+pub struct ResolverFuture<T: Address> {
+    req: Option<Connect<T>>,
+    lookup: Background<LookupIpFuture>,
+}
+
+impl<T: Address> ResolverFuture<T> {
+    pub fn new(req: Connect<T>, resolver: &AsyncResolver) -> Self {
+        let lookup = if let Some(host) = req.host().splitn(2, ':').next() {
+            resolver.lookup_ip(host)
+        } else {
+            resolver.lookup_ip(req.host())
+        };
+
+        ResolverFuture {
+            lookup,
+            req: Some(req),
+        }
+    }
+}
+
+impl<T: Address> Future for ResolverFuture<T> {
+    type Item = Connect<T>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.lookup.poll().map_err(|e| {
+            trace!(
+                "DNS resolver: failed to resolve host {:?} err: {}",
+                self.req.as_ref().unwrap().host(),
+                e
+            );
+            e
+        })? {
+            Async::NotReady => Ok(Async::NotReady),
+            Async::Ready(ips) => {
+                let req = self.req.take().unwrap();
+
+                let port = req.port();
+                let req = req.set_addrs(ips.iter().map(|ip| SocketAddr::new(ip, port)));
+
+                trace!(
+                    "DNS resolver: host {:?} resolved to {:?}",
+                    req.host(),
+                    req.addrs()
+                );
+
+                if req.addr.is_none() {
+                    Err(ConnectError::NoRecords)
+                } else {
+                    Ok(Async::Ready(req))
+                }
+            }
+        }
+    }
+}

actix-connect/src/service.rs

@@ -0,0 +1,183 @@
+use actix_service::{NewService, Service};
+use futures::future::{ok, FutureResult};
+use futures::{try_ready, Async, Future, Poll};
+use tokio_tcp::TcpStream;
+use trust_dns_resolver::AsyncResolver;
+
+use crate::connect::{Address, Connect, Connection};
+use crate::connector::{TcpConnector, TcpConnectorFactory};
+use crate::error::ConnectError;
+use crate::resolver::{Resolver, ResolverFactory};
+
+pub struct ConnectServiceFactory<T> {
+    tcp: TcpConnectorFactory<T>,
+    resolver: ResolverFactory<T>,
+}
+
+impl<T> ConnectServiceFactory<T> {
+    /// Construct new ConnectService factory
+    pub fn new() -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::default(),
+        }
+    }
+
+    /// Construct new connect service with custom dns resolver
+    pub fn with_resolver(resolver: AsyncResolver) -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::new(resolver),
+        }
+    }
+
+    /// Construct new service
+    pub fn service(&self) -> ConnectService<T> {
+        ConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+
+    /// Construct new tcp stream service
+    pub fn tcp_service(&self) -> TcpConnectService<T> {
+        TcpConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+}
+
+impl<T> Default for ConnectServiceFactory<T> {
+    fn default() -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::default(),
+        }
+    }
+}
+
+impl<T> Clone for ConnectServiceFactory<T> {
+    fn clone(&self) -> Self {
+        ConnectServiceFactory {
+            tcp: self.tcp.clone(),
+            resolver: self.resolver.clone(),
+        }
+    }
+}
+
+impl<T: Address> NewService for ConnectServiceFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = ConnectService<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+#[derive(Clone)]
+pub struct ConnectService<T> {
+    tcp: TcpConnector<T>,
+    resolver: Resolver<T>,
+}
+
+impl<T: Address> Service for ConnectService<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = ConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        ConnectServiceResponse {
+            fut1: Some(self.resolver.call(req)),
+            fut2: None,
+            tcp: self.tcp.clone(),
+        }
+    }
+}
+
+pub struct ConnectServiceResponse<T: Address> {
+    fut1: Option<<Resolver<T> as Service>::Future>,
+    fut2: Option<<TcpConnector<T> as Service>::Future>,
+    tcp: TcpConnector<T>,
+}
+
+impl<T: Address> Future for ConnectServiceResponse<T> {
+    type Item = Connection<T, TcpStream>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut1 {
+            let res = try_ready!(fut.poll());
+            let _ = self.fut1.take();
+            self.fut2 = Some(self.tcp.call(res));
+        }
+
+        if let Some(ref mut fut) = self.fut2 {
+            return fut.poll();
+        }
+
+        Ok(Async::NotReady)
+    }
+}
+
+#[derive(Clone)]
+pub struct TcpConnectService<T> {
+    tcp: TcpConnector<T>,
+    resolver: Resolver<T>,
+}
+
+impl<T: Address> Service for TcpConnectService<T> {
+    type Request = Connect<T>;
+    type Response = TcpStream;
+    type Error = ConnectError;
+    type Future = TcpConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        TcpConnectServiceResponse {
+            fut1: Some(self.resolver.call(req)),
+            fut2: None,
+            tcp: self.tcp.clone(),
+        }
+    }
+}
+
+pub struct TcpConnectServiceResponse<T: Address> {
+    fut1: Option<<Resolver<T> as Service>::Future>,
+    fut2: Option<<TcpConnector<T> as Service>::Future>,
+    tcp: TcpConnector<T>,
+}
+
+impl<T: Address> Future for TcpConnectServiceResponse<T> {
+    type Item = TcpStream;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut1 {
+            let res = try_ready!(fut.poll());
+            let _ = self.fut1.take();
+            self.fut2 = Some(self.tcp.call(res));
+        }
+
+        if let Some(ref mut fut) = self.fut2 {
+            if let Async::Ready(conn) = fut.poll()? {
+                return Ok(Async::Ready(conn.into_parts().0));
+            }
+        }
+
+        Ok(Async::NotReady)
+    }
+}

actix-connect/src/ssl/mod.rs

@@ -0,0 +1,12 @@
+//! SSL Services
+
+#[cfg(feature = "ssl")]
+mod openssl;
+#[cfg(feature = "ssl")]
+pub use self::openssl::{
+    OpensslConnectService, OpensslConnectServiceFactory, OpensslConnector,
+};
+#[cfg(feature = "rust-tls")]
+mod rustls;
+#[cfg(feature = "rust-tls")]
+pub use self::rustls::RustlsConnector;

actix-connect/src/ssl/openssl.rs

@@ -0,0 +1,251 @@
+use std::marker::PhantomData;
+use std::{fmt, io};
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{NewService, Service};
+use futures::{future::ok, future::FutureResult, try_ready, Async, Future, Poll};
+use openssl::ssl::{HandshakeError, SslConnector};
+use tokio_openssl::{ConnectAsync, SslConnectorExt, SslStream};
+use tokio_tcp::TcpStream;
+use trust_dns_resolver::AsyncResolver;
+
+use crate::{
+    Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection,
+};
+
+/// Openssl connector factory
+pub struct OpensslConnector<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> OpensslConnector<T, U> {
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> OpensslConnector<T, U>
+where
+    T: Address,
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    pub fn service(
+        connector: SslConnector,
+    ) -> impl Service<
+        Request = Connection<T, U>,
+        Response = Connection<T, SslStream<U>>,
+        Error = HandshakeError<U>,
+    > {
+        OpensslConnectorService {
+            connector: connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Clone for OpensslConnector<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> NewService for OpensslConnector<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+    type Config = ();
+    type Service = OpensslConnectorService<T, U>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(OpensslConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct OpensslConnectorService<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> Clone for OpensslConnectorService<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> Service for OpensslConnectorService<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+    type Future = ConnectAsyncExt<T, U>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+        trace!("SSL Handshake start for: {:?}", stream.host());
+        let (io, stream) = stream.replace(());
+        ConnectAsyncExt {
+            fut: SslConnectorExt::connect_async(&self.connector, stream.host(), io),
+            stream: Some(stream),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<T, U> {
+    fut: ConnectAsync<U>,
+    stream: Option<Connection<T, ()>>,
+}
+
+impl<T: Address, U> Future for ConnectAsyncExt<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Item = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll().map_err(|e| {
+            trace!("SSL Handshake error: {:?}", e);
+            e
+        })? {
+            Async::Ready(stream) => {
+                let s = self.stream.take().unwrap();
+                trace!("SSL Handshake success: {:?}", s.host());
+                Ok(Async::Ready(s.replace(stream).1))
+            }
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}
+
+pub struct OpensslConnectServiceFactory<T> {
+    tcp: ConnectServiceFactory<T>,
+    openssl: OpensslConnector<T, TcpStream>,
+}
+
+impl<T> OpensslConnectServiceFactory<T> {
+    /// Construct new OpensslConnectService factory
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: ConnectServiceFactory::default(),
+            openssl: OpensslConnector::new(connector),
+        }
+    }
+
+    /// Construct new connect service with custom dns resolver
+    pub fn with_resolver(connector: SslConnector, resolver: AsyncResolver) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: ConnectServiceFactory::with_resolver(resolver),
+            openssl: OpensslConnector::new(connector),
+        }
+    }
+
+    /// Construct openssl connect service
+    pub fn service(&self) -> OpensslConnectService<T> {
+        OpensslConnectService {
+            tcp: self.tcp.service(),
+            openssl: OpensslConnectorService {
+                connector: self.openssl.connector.clone(),
+                _t: PhantomData,
+            },
+        }
+    }
+}
+
+impl<T> Clone for OpensslConnectServiceFactory<T> {
+    fn clone(&self) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: self.tcp.clone(),
+            openssl: self.openssl.clone(),
+        }
+    }
+}
+
+impl<T: Address> NewService for OpensslConnectServiceFactory<T> {
+    type Request = Connect<T>;
+    type Response = SslStream<TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = OpensslConnectService<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+#[derive(Clone)]
+pub struct OpensslConnectService<T> {
+    tcp: ConnectService<T>,
+    openssl: OpensslConnectorService<T, TcpStream>,
+}
+
+impl<T: Address> Service for OpensslConnectService<T> {
+    type Request = Connect<T>;
+    type Response = SslStream<TcpStream>;
+    type Error = ConnectError;
+    type Future = OpensslConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        OpensslConnectServiceResponse {
+            fut1: Some(self.tcp.call(req)),
+            fut2: None,
+            openssl: self.openssl.clone(),
+        }
+    }
+}
+
+pub struct OpensslConnectServiceResponse<T: Address> {
+    fut1: Option<<ConnectService<T> as Service>::Future>,
+    fut2: Option<<OpensslConnectorService<T, TcpStream> as Service>::Future>,
+    openssl: OpensslConnectorService<T, TcpStream>,
+}
+
+impl<T: Address> Future for OpensslConnectServiceResponse<T> {
+    type Item = SslStream<TcpStream>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut1 {
+            let res = try_ready!(fut.poll());
+            let _ = self.fut1.take();
+            self.fut2 = Some(self.openssl.call(res));
+        }
+
+        if let Some(ref mut fut) = self.fut2 {
+            let connect = try_ready!(fut
+                .poll()
+                .map_err(|e| ConnectError::Io(io::Error::new(io::ErrorKind::Other, e))));
+            Ok(Async::Ready(connect.into_parts().0))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-connect/src/ssl/rustls.rs

@@ -0,0 +1,130 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{NewService, Service};
+use futures::{future::ok, future::FutureResult, Async, Future, Poll};
+use std::sync::Arc;
+use tokio_rustls::{client::TlsStream, rustls::ClientConfig, Connect, TlsConnector};
+use webpki::DNSNameRef;
+
+use crate::{Address, Connection};
+
+/// Rustls connector factory
+pub struct RustlsConnector<T, U> {
+    connector: Arc<ClientConfig>,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> RustlsConnector<T, U> {
+    pub fn new(connector: Arc<ClientConfig>) -> Self {
+        RustlsConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> RustlsConnector<T, U>
+where
+    T: Address,
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    pub fn service(
+        connector: Arc<ClientConfig>,
+    ) -> impl Service<
+        Request = Connection<T, U>,
+        Response = Connection<T, TlsStream<U>>,
+        Error = std::io::Error,
+    > {
+        RustlsConnectorService {
+            connector: connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Clone for RustlsConnector<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> NewService for RustlsConnector<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, TlsStream<U>>;
+    type Error = std::io::Error;
+    type Config = ();
+    type Service = RustlsConnectorService<T, U>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(RustlsConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct RustlsConnectorService<T, U> {
+    connector: Arc<ClientConfig>,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T: Address, U> Service for RustlsConnectorService<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, TlsStream<U>>;
+    type Error = std::io::Error;
+    type Future = ConnectAsyncExt<T, U>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+        trace!("SSL Handshake start for: {:?}", stream.host());
+        let (io, stream) = stream.replace(());
+        let host = DNSNameRef::try_from_ascii_str(stream.host()).unwrap();
+        ConnectAsyncExt {
+            fut: TlsConnector::from(self.connector.clone()).connect(host, io),
+            stream: Some(stream),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<T, U> {
+    fut: Connect<U>,
+    stream: Option<Connection<T, ()>>,
+}
+
+impl<T: Address, U> Future for ConnectAsyncExt<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Item = Connection<T, TlsStream<U>>;
+    type Error = std::io::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll().map_err(|e| {
+            trace!("SSL Handshake error: {:?}", e);
+            e
+        })? {
+            Async::Ready(stream) => {
+                let s = self.stream.take().unwrap();
+                trace!("SSL Handshake success: {:?}", s.host());
+                Ok(Async::Ready(s.replace(stream).1))
+            }
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}

actix-connect/src/uri.rs

@@ -0,0 +1,37 @@
+use http::Uri;
+
+use crate::Address;
+
+impl Address for Uri {
+    fn host(&self) -> &str {
+        self.host().unwrap_or("")
+    }
+
+    fn port(&self) -> Option<u16> {
+        if let Some(port) = self.port_u16() {
+            Some(port)
+        } else {
+            port(self.scheme_str())
+        }
+    }
+}
+
+// TODO: load data from file
+fn port(scheme: Option<&str>) -> Option<u16> {
+    if let Some(scheme) = scheme {
+        match scheme {
+            "http" => Some(80),
+            "https" => Some(443),
+            "ws" => Some(80),
+            "wss" => Some(443),
+            "amqp" => Some(5672),
+            "amqps" => Some(5671),
+            "sb" => Some(5671),
+            "mqtt" => Some(1883),
+            "mqtts" => Some(8883),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}

actix-connect/tests/test_connect.rs

@@ -0,0 +1,134 @@
+use actix_codec::{BytesCodec, Framed};
+use actix_server_config::Io;
+use actix_service::{service_fn, NewService, Service};
+use actix_testing::{self as test, TestServer};
+use bytes::Bytes;
+use futures::{future::lazy, Future, Sink};
+use http::{HttpTryFrom, Uri};
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+
+use actix_connect::{default_connector, Connect};
+
+#[cfg(feature = "ssl")]
+#[test]
+fn test_string() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = test::call_service(&mut conn, addr.into());
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "rust-tls")]
+#[test]
+fn test_rustls_string() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = test::call_service(&mut conn, addr.into());
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+#[test]
+fn test_static_str() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let resolver = test::block_on(lazy(
+        || Ok::<_, ()>(actix_connect::start_default_resolver()),
+    ))
+    .unwrap();
+
+    let mut conn = test::block_on(lazy(|| {
+        Ok::<_, ()>(actix_connect::new_connector(resolver.clone()))
+    }))
+    .unwrap();
+
+    let con = test::block_on(conn.call(Connect::with("10", srv.addr()))).unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+
+    let connect = Connect::new(srv.host().to_owned());
+    let mut conn =
+        test::block_on(lazy(|| Ok::<_, ()>(actix_connect::new_connector(resolver)))).unwrap();
+    let con = test::block_on(conn.call(connect));
+    assert!(con.is_err());
+}
+
+#[test]
+fn test_new_service() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let resolver = test::block_on(lazy(|| {
+        Ok::<_, ()>(actix_connect::start_resolver(
+            ResolverConfig::default(),
+            ResolverOpts::default(),
+        ))
+    }))
+    .unwrap();
+    let factory = test::block_on(lazy(|| {
+        Ok::<_, ()>(actix_connect::new_connector_factory(resolver))
+    }))
+    .unwrap();
+
+    let mut conn = test::block_on(factory.new_service(&())).unwrap();
+    let con = test::block_on(conn.call(Connect::with("10", srv.addr()))).unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "ssl")]
+#[test]
+fn test_uri() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = default_connector();
+    let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = test::call_service(&mut conn, addr.into());
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "rust-tls")]
+#[test]
+fn test_rustls_uri() {
+    let srv = TestServer::with(|| {
+        service_fn(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = default_connector();
+    let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = test::call_service(&mut conn, addr.into());
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}

actix-ioframe/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## [0.1.0] - 2019-09-25
+
+* Initial release

actix-ioframe/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "actix-ioframe"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix framed service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-ioframe/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_ioframe"
+path = "src/lib.rs"
+
+[dependencies]
+actix-service = "0.4.1"
+actix-codec = "0.1.2"
+bytes = "0.4"
+either = "1.5.2"
+futures = "0.1.25"
+tokio-current-thread = "0.1.4"
+log = "0.4"
+
+[dev-dependencies]
+actix-rt = "0.2.2"
+actix-connect = "0.2.0"
+actix-testing = "0.1.0"
+actix-server-config = "0.1.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2"

actix-ioframe/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-ioframe/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-ioframe/src/cell.rs

@@ -0,0 +1,35 @@
+//! Custom cell impl
+
+use std::cell::UnsafeCell;
+use std::fmt;
+use std::rc::Rc;
+
+pub(crate) struct Cell<T> {
+    inner: Rc<UnsafeCell<T>>,
+}
+
+impl<T> Clone for Cell<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Cell<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl<T> Cell<T> {
+    pub fn new(inner: T) -> Self {
+        Self {
+            inner: Rc::new(UnsafeCell::new(inner)),
+        }
+    }
+
+    pub(crate) unsafe fn get_mut(&mut self) -> &mut T {
+        &mut *self.inner.as_ref().get()
+    }
+}

actix-ioframe/src/connect.rs

@@ -0,0 +1,110 @@
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use futures::unsync::mpsc;
+
+use crate::dispatcher::FramedMessage;
+use crate::sink::Sink;
+
+pub struct Connect<Io, St = (), Codec = ()> {
+    io: Io,
+    _t: PhantomData<(St, Codec)>,
+}
+
+impl<Io> Connect<Io>
+where
+    Io: AsyncRead + AsyncWrite,
+{
+    pub(crate) fn new(io: Io) -> Self {
+        Self {
+            io,
+            _t: PhantomData,
+        }
+    }
+
+    pub fn codec<Codec>(self, codec: Codec) -> ConnectResult<Io, (), Codec>
+    where
+        Codec: Encoder + Decoder,
+    {
+        let (tx, rx) = mpsc::unbounded();
+        let sink = Sink::new(tx);
+
+        ConnectResult {
+            state: (),
+            framed: Framed::new(self.io, codec),
+            rx,
+            sink,
+        }
+    }
+}
+
+pub struct ConnectResult<Io, St, Codec: Encoder + Decoder> {
+    pub(crate) state: St,
+    pub(crate) framed: Framed<Io, Codec>,
+    pub(crate) rx: mpsc::UnboundedReceiver<FramedMessage<<Codec as Encoder>::Item>>,
+    pub(crate) sink: Sink<<Codec as Encoder>::Item>,
+}
+
+impl<Io, St, Codec: Encoder + Decoder> ConnectResult<Io, St, Codec> {
+    #[inline]
+    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
+        &self.sink
+    }
+
+    #[inline]
+    pub fn get_ref(&self) -> &Io {
+        self.framed.get_ref()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut Io {
+        self.framed.get_mut()
+    }
+
+    #[inline]
+    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec> {
+        ConnectResult {
+            state,
+            framed: self.framed,
+            rx: self.rx,
+            sink: self.sink,
+        }
+    }
+}
+
+impl<Io, St, Codec> futures::Stream for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type Item = <Codec as Decoder>::Item;
+    type Error = <Codec as Decoder>::Error;
+
+    fn poll(&mut self) -> futures::Poll<Option<Self::Item>, Self::Error> {
+        self.framed.poll()
+    }
+}
+
+impl<Io, St, Codec> futures::Sink for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type SinkItem = <Codec as Encoder>::Item;
+    type SinkError = <Codec as Encoder>::Error;
+
+    fn start_send(
+        &mut self,
+        item: Self::SinkItem,
+    ) -> futures::StartSend<Self::SinkItem, Self::SinkError> {
+        self.framed.start_send(item)
+    }
+
+    fn poll_complete(&mut self) -> futures::Poll<(), Self::SinkError> {
+        self.framed.poll_complete()
+    }
+
+    fn close(&mut self) -> futures::Poll<(), Self::SinkError> {
+        self.framed.close()
+    }
+}

actix-ioframe/src/dispatcher.rs

@@ -0,0 +1,325 @@
+//! Framed dispatcher service and related utilities
+use std::collections::VecDeque;
+use std::mem;
+use std::rc::Rc;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use actix_service::{IntoService, Service};
+use futures::task::AtomicTask;
+use futures::unsync::{mpsc, oneshot};
+use futures::{Async, Future, Poll, Sink as FutureSink, Stream};
+use log::debug;
+
+use crate::cell::Cell;
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::sink::Sink;
+use crate::state::State;
+
+type Request<S, U> = Item<S, U>;
+type Response<U> = <U as Encoder>::Item;
+
+pub(crate) enum FramedMessage<T> {
+    Message(T),
+    Close,
+    WaitClose(oneshot::Sender<()>),
+}
+
+/// FramedTransport - is a future that reads frames from Framed object
+/// and pass then to the service.
+pub(crate) struct FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Encoder + Decoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    service: S,
+    sink: Sink<<U as Encoder>::Item>,
+    state: State<St>,
+    dispatch_state: FramedState<S, U>,
+    framed: Framed<T, U>,
+    rx: Option<mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>>,
+    inner: Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+}
+
+impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    pub(crate) fn new<F: IntoService<S>>(
+        framed: Framed<T, U>,
+        state: State<St>,
+        service: F,
+        rx: mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>,
+        sink: Sink<<U as Encoder>::Item>,
+        disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    ) -> Self {
+        FramedDispatcher {
+            framed,
+            state,
+            sink,
+            disconnect,
+            rx: Some(rx),
+            service: service.into_service(),
+            dispatch_state: FramedState::Processing,
+            inner: Cell::new(FramedDispatcherInner {
+                buf: VecDeque::new(),
+                task: AtomicTask::new(),
+            }),
+        }
+    }
+}
+
+enum FramedState<S: Service, U: Encoder + Decoder> {
+    Processing,
+    Error(ServiceError<S::Error, U>),
+    FramedError(ServiceError<S::Error, U>),
+    FlushAndStop(Vec<oneshot::Sender<()>>),
+    Stopping,
+}
+
+impl<S: Service, U: Encoder + Decoder> FramedState<S, U> {
+    fn stop(&mut self, tx: Option<oneshot::Sender<()>>) {
+        match self {
+            FramedState::FlushAndStop(ref mut vec) => {
+                if let Some(tx) = tx {
+                    vec.push(tx)
+                }
+            }
+            FramedState::Processing => {
+                *self = FramedState::FlushAndStop(if let Some(tx) = tx {
+                    vec![tx]
+                } else {
+                    Vec::new()
+                })
+            }
+            FramedState::Error(_) | FramedState::FramedError(_) | FramedState::Stopping => {
+                if let Some(tx) = tx {
+                    let _ = tx.send(());
+                }
+            }
+        }
+    }
+}
+
+struct FramedDispatcherInner<I, E> {
+    buf: VecDeque<Result<I, E>>,
+    task: AtomicTask,
+}
+
+impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    fn disconnect(&mut self, error: bool) {
+        if let Some(ref disconnect) = self.disconnect {
+            (&*disconnect)(&mut *self.state.get_mut(), error);
+        }
+    }
+
+    fn poll_read(&mut self) -> bool {
+        loop {
+            match self.service.poll_ready() {
+                Ok(Async::Ready(_)) => {
+                    let item = match self.framed.poll() {
+                        Ok(Async::Ready(Some(el))) => el,
+                        Err(err) => {
+                            self.dispatch_state =
+                                FramedState::FramedError(ServiceError::Decoder(err));
+                            return true;
+                        }
+                        Ok(Async::NotReady) => return false,
+                        Ok(Async::Ready(None)) => {
+                            self.dispatch_state = FramedState::Stopping;
+                            return true;
+                        }
+                    };
+
+                    let mut cell = self.inner.clone();
+                    unsafe { cell.get_mut().task.register() };
+                    tokio_current_thread::spawn(
+                        self.service
+                            .call(Item::new(self.state.clone(), self.sink.clone(), item))
+                            .then(move |item| {
+                                let item = match item {
+                                    Ok(Some(item)) => Ok(item),
+                                    Ok(None) => return Ok(()),
+                                    Err(err) => Err(err),
+                                };
+                                unsafe {
+                                    let inner = cell.get_mut();
+                                    inner.buf.push_back(item);
+                                    inner.task.notify();
+                                }
+                                Ok(())
+                            }),
+                    );
+                }
+                Ok(Async::NotReady) => return false,
+                Err(err) => {
+                    self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                    return true;
+                }
+            }
+        }
+    }
+
+    /// write to framed object
+    fn poll_write(&mut self) -> bool {
+        let inner = unsafe { self.inner.get_mut() };
+        let mut rx_done = self.rx.is_none();
+        let mut buf_empty = inner.buf.is_empty();
+        loop {
+            while !self.framed.is_write_buf_full() {
+                if !buf_empty {
+                    match inner.buf.pop_front().unwrap() {
+                        Ok(msg) => {
+                            if let Err(err) = self.framed.force_send(msg) {
+                                self.dispatch_state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                            buf_empty = inner.buf.is_empty();
+                        }
+                        Err(err) => {
+                            self.dispatch_state =
+                                FramedState::Error(ServiceError::Service(err));
+                            return true;
+                        }
+                    }
+                }
+
+                if !rx_done && self.rx.is_some() {
+                    match self.rx.as_mut().unwrap().poll() {
+                        Ok(Async::Ready(Some(FramedMessage::Message(msg)))) => {
+                            if let Err(err) = self.framed.force_send(msg) {
+                                self.dispatch_state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                        }
+                        Ok(Async::Ready(Some(FramedMessage::Close))) => {
+                            self.dispatch_state.stop(None);
+                            return true;
+                        }
+                        Ok(Async::Ready(Some(FramedMessage::WaitClose(tx)))) => {
+                            self.dispatch_state.stop(Some(tx));
+                            return true;
+                        }
+                        Ok(Async::Ready(None)) => {
+                            rx_done = true;
+                            let _ = self.rx.take();
+                        }
+                        Ok(Async::NotReady) => rx_done = true,
+                        Err(_e) => {
+                            rx_done = true;
+                            let _ = self.rx.take();
+                        }
+                    }
+                }
+
+                if rx_done && buf_empty {
+                    break;
+                }
+            }
+
+            if !self.framed.is_write_buf_empty() {
+                match self.framed.poll_complete() {
+                    Ok(Async::NotReady) => break,
+                    Err(err) => {
+                        debug!("Error sending data: {:?}", err);
+                        self.dispatch_state =
+                            FramedState::FramedError(ServiceError::Encoder(err));
+                        return true;
+                    }
+                    Ok(Async::Ready(_)) => (),
+                }
+            } else {
+                break;
+            }
+        }
+
+        false
+    }
+}
+
+impl<St, S, T, U> Future for FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    type Item = ();
+    type Error = ServiceError<S::Error, U>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match mem::replace(&mut self.dispatch_state, FramedState::Processing) {
+            FramedState::Processing => {
+                if self.poll_read() || self.poll_write() {
+                    self.poll()
+                } else {
+                    Ok(Async::NotReady)
+                }
+            }
+            FramedState::Error(err) => {
+                if self.framed.is_write_buf_empty()
+                    || (self.poll_write() || self.framed.is_write_buf_empty())
+                {
+                    self.disconnect(true);
+                    Err(err)
+                } else {
+                    self.dispatch_state = FramedState::Error(err);
+                    Ok(Async::NotReady)
+                }
+            }
+            FramedState::FlushAndStop(mut vec) => {
+                if !self.framed.is_write_buf_empty() {
+                    match self.framed.poll_complete() {
+                        Err(err) => {
+                            debug!("Error sending data: {:?}", err);
+                        }
+                        Ok(Async::NotReady) => {
+                            self.dispatch_state = FramedState::FlushAndStop(vec);
+                            return Ok(Async::NotReady);
+                        }
+                        Ok(Async::Ready(_)) => (),
+                    }
+                };
+                for tx in vec.drain(..) {
+                    let _ = tx.send(());
+                }
+                self.disconnect(false);
+                Ok(Async::Ready(()))
+            }
+            FramedState::FramedError(err) => {
+                self.disconnect(true);
+                Err(err)
+            }
+            FramedState::Stopping => {
+                self.disconnect(false);
+                Ok(Async::Ready(()))
+            }
+        }
+    }
+}

actix-ioframe/src/error.rs

@@ -0,0 +1,49 @@
+use std::fmt;
+
+use actix_codec::{Decoder, Encoder};
+
+/// Framed service errors
+pub enum ServiceError<E, U: Encoder + Decoder> {
+    /// Inner service error
+    Service(E),
+    /// Encoder parse error
+    Encoder(<U as Encoder>::Error),
+    /// Decoder parse error
+    Decoder(<U as Decoder>::Error),
+}
+
+impl<E, U: Encoder + Decoder> From<E> for ServiceError<E, U> {
+    fn from(err: E) -> Self {
+        ServiceError::Service(err)
+    }
+}
+
+impl<E, U: Encoder + Decoder> fmt::Debug for ServiceError<E, U>
+where
+    E: fmt::Debug,
+    <U as Encoder>::Error: fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ServiceError::Service(ref e) => write!(fmt, "ServiceError::Service({:?})", e),
+            ServiceError::Encoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
+            ServiceError::Decoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
+        }
+    }
+}
+
+impl<E, U: Encoder + Decoder> fmt::Display for ServiceError<E, U>
+where
+    E: fmt::Display,
+    <U as Encoder>::Error: fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ServiceError::Service(ref e) => write!(fmt, "{}", e),
+            ServiceError::Encoder(ref e) => write!(fmt, "{:?}", e),
+            ServiceError::Decoder(ref e) => write!(fmt, "{:?}", e),
+        }
+    }
+}

actix-ioframe/src/item.rs

@@ -0,0 +1,90 @@
+use std::cell::{Ref, RefMut};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+
+use actix_codec::{Decoder, Encoder};
+
+use crate::sink::Sink;
+use crate::state::State;
+
+pub struct Item<St, Codec: Encoder + Decoder> {
+    state: State<St>,
+    sink: Sink<<Codec as Encoder>::Item>,
+    item: <Codec as Decoder>::Item,
+}
+
+impl<St, Codec> Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    pub(crate) fn new(
+        state: State<St>,
+        sink: Sink<<Codec as Encoder>::Item>,
+        item: <Codec as Decoder>::Item,
+    ) -> Self {
+        Item { state, sink, item }
+    }
+
+    #[inline]
+    pub fn state(&self) -> Ref<St> {
+        self.state.get_ref()
+    }
+
+    #[inline]
+    pub fn state_mut(&mut self) -> RefMut<St> {
+        self.state.get_mut()
+    }
+
+    #[inline]
+    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
+        &self.sink
+    }
+
+    #[inline]
+    pub fn into_inner(self) -> <Codec as Decoder>::Item {
+        self.item
+    }
+
+    #[inline]
+    pub fn into_parts(
+        self,
+    ) -> (
+        State<St>,
+        Sink<<Codec as Encoder>::Item>,
+        <Codec as Decoder>::Item,
+    ) {
+        (self.state, self.sink, self.item)
+    }
+}
+
+impl<St, Codec> Deref for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    type Target = <Codec as Decoder>::Item;
+
+    #[inline]
+    fn deref(&self) -> &<Codec as Decoder>::Item {
+        &self.item
+    }
+}
+
+impl<St, Codec> DerefMut for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut <Codec as Decoder>::Item {
+        &mut self.item
+    }
+}
+
+impl<St, Codec> fmt::Debug for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+    <Codec as Decoder>::Item: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("FramedItem").field(&self.item).finish()
+    }
+}

actix-ioframe/src/lib.rs

@@ -0,0 +1,15 @@
+mod cell;
+mod connect;
+mod dispatcher;
+mod error;
+mod item;
+mod service;
+mod sink;
+mod state;
+
+pub use self::connect::{Connect, ConnectResult};
+pub use self::error::ServiceError;
+pub use self::item::Item;
+pub use self::service::{Builder, NewServiceBuilder, ServiceBuilder};
+pub use self::sink::Sink;
+pub use self::state::State;

actix-ioframe/src/service.rs

@@ -0,0 +1,363 @@
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
+use actix_service::{IntoNewService, IntoService, NewService, Service};
+use futures::{Async, Future, Poll};
+
+use crate::connect::{Connect, ConnectResult};
+use crate::dispatcher::FramedDispatcher;
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::state::State;
+
+type RequestItem<S, U> = Item<S, U>;
+type ResponseItem<U> = Option<<U as Encoder>::Item>;
+
+/// Service builder - structure that follows the builder pattern
+/// for building instances for framed services.
+pub struct Builder<St, Codec>(PhantomData<(St, Codec)>);
+
+impl<St, Codec> Builder<St, Codec> {
+    pub fn new() -> Builder<St, Codec> {
+        Builder(PhantomData)
+    }
+
+    /// Construct framed handler service with specified connect service
+    pub fn service<Io, C, F>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+        Codec: Decoder + Encoder,
+    {
+        ServiceBuilder {
+            connect: connect.into_service(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+
+    /// Construct framed handler new service with specified connect service
+    pub fn factory<Io, C, F>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoNewService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: NewService<
+            Config = (),
+            Request = Connect<Io>,
+            Response = ConnectResult<Io, St, Codec>,
+        >,
+        C::Error: 'static,
+        C::Future: 'static,
+        Codec: Decoder + Encoder,
+    {
+        NewServiceBuilder {
+            connect: connect.into_new_service(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct ServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> ServiceBuilder<St, C, Io, Codec>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F, Out>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(&mut St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    /// Provide stream items handler service and construct service factory.
+    pub fn finish<F, T>(
+        self,
+        service: F,
+    ) -> impl Service<Request = Io, Response = (), Error = ServiceError<C::Error, Codec>>
+    where
+        F: IntoNewService<T>,
+        T: NewService<
+                Config = St,
+                Request = RequestItem<St, Codec>,
+                Response = ResponseItem<Codec>,
+                Error = C::Error,
+                InitError = C::Error,
+            > + 'static,
+    {
+        FramedServiceImpl {
+            connect: self.connect,
+            handler: Rc::new(service.into_new_service()),
+            disconnect: self.disconnect.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct NewServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> NewServiceBuilder<St, C, Io, Codec>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: NewService<Config = (), Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    C::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(&mut St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    pub fn finish<F, T, Cfg>(
+        self,
+        service: F,
+    ) -> impl NewService<
+        Config = Cfg,
+        Request = Io,
+        Response = (),
+        Error = ServiceError<C::Error, Codec>,
+    >
+    where
+        F: IntoNewService<T>,
+        T: NewService<
+                Config = St,
+                Request = RequestItem<St, Codec>,
+                Response = ResponseItem<Codec>,
+                Error = C::Error,
+                InitError = C::Error,
+            > + 'static,
+    {
+        FramedService {
+            connect: self.connect,
+            handler: Rc::new(service.into_new_service()),
+            disconnect: self.disconnect,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub(crate) struct FramedService<St, C, T, Io, Codec, Cfg> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec, Cfg)>,
+}
+
+impl<St, C, T, Io, Codec, Cfg> NewService for FramedService<St, C, T, Io, Codec, Cfg>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: NewService<Config = (), Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    C::Future: 'static,
+    T: NewService<
+            Config = St,
+            Request = RequestItem<St, Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        > + 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Config = Cfg;
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type InitError = C::InitError;
+    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, _: &Cfg) -> Self::Future {
+        let handler = self.handler.clone();
+        let disconnect = self.disconnect.clone();
+
+        // create connect service and then create service impl
+        Box::new(
+            self.connect
+                .new_service(&())
+                .map(move |connect| FramedServiceImpl {
+                    connect,
+                    handler,
+                    disconnect,
+                    _t: PhantomData,
+                }),
+        )
+    }
+}
+
+pub struct FramedServiceImpl<St, C, T, Io, Codec> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, T, Io, Codec> Service for FramedServiceImpl<St, C, T, Io, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type Future = FramedServiceImplResponse<St, Io, Codec, C, T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.connect.poll_ready().map_err(|e| e.into())
+    }
+
+    fn call(&mut self, req: Io) -> Self::Future {
+        FramedServiceImplResponse {
+            inner: FramedServiceImplResponseInner::Connect(
+                self.connect.call(Connect::new(req)),
+                self.handler.clone(),
+            ),
+            disconnect: self.disconnect.clone(),
+        }
+    }
+}
+
+pub struct FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+}
+
+enum FramedServiceImplResponseInner<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    Connect(C::Future, Rc<T>),
+    Handler(T::Future, Option<ConnectResult<Io, St, Codec>>),
+    Dispatcher(FramedDispatcher<St, T::Service, Io, Codec>),
+}
+
+impl<St, Io, Codec, C, T> Future for FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Item = ();
+    type Error = ServiceError<C::Error, Codec>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.inner {
+            FramedServiceImplResponseInner::Connect(ref mut fut, ref handler) => {
+                match fut.poll()? {
+                    Async::Ready(res) => {
+                        self.inner = FramedServiceImplResponseInner::Handler(
+                            handler.new_service(&res.state),
+                            Some(res),
+                        );
+                        self.poll()
+                    }
+                    Async::NotReady => Ok(Async::NotReady),
+                }
+            }
+            FramedServiceImplResponseInner::Handler(ref mut fut, ref mut res) => {
+                match fut.poll()? {
+                    Async::Ready(handler) => {
+                        let res = res.take().unwrap();
+                        self.inner =
+                            FramedServiceImplResponseInner::Dispatcher(FramedDispatcher::new(
+                                res.framed,
+                                State::new(res.state),
+                                handler,
+                                res.rx,
+                                res.sink,
+                                self.disconnect.clone(),
+                            ));
+                        self.poll()
+                    }
+                    Async::NotReady => Ok(Async::NotReady),
+                }
+            }
+            FramedServiceImplResponseInner::Dispatcher(ref mut fut) => fut.poll(),
+        }
+    }
+}

actix-ioframe/src/sink.rs

@@ -0,0 +1,44 @@
+use std::fmt;
+
+use futures::unsync::{mpsc, oneshot};
+use futures::Future;
+
+use crate::dispatcher::FramedMessage;
+
+pub struct Sink<T>(mpsc::UnboundedSender<FramedMessage<T>>);
+
+impl<T> Clone for Sink<T> {
+    fn clone(&self) -> Self {
+        Sink(self.0.clone())
+    }
+}
+
+impl<T> Sink<T> {
+    pub(crate) fn new(tx: mpsc::UnboundedSender<FramedMessage<T>>) -> Self {
+        Sink(tx)
+    }
+
+    /// Close connection
+    pub fn close(&self) {
+        let _ = self.0.unbounded_send(FramedMessage::Close);
+    }
+
+    /// Close connection
+    pub fn wait_close(&self) -> impl Future<Item = (), Error = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(FramedMessage::WaitClose(tx));
+
+        rx.map_err(|_| ())
+    }
+
+    /// Send item
+    pub fn send(&self, item: T) {
+        let _ = self.0.unbounded_send(FramedMessage::Message(item));
+    }
+}
+
+impl<T> fmt::Debug for Sink<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Sink").finish()
+    }
+}

actix-ioframe/src/state.rs

@@ -0,0 +1,30 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::rc::Rc;
+
+/// Connection state
+///
+/// Connection state is an arbitrary data attached to the each incoming message.
+#[derive(Debug)]
+pub struct State<T>(Rc<RefCell<T>>);
+
+impl<T> State<T> {
+    pub(crate) fn new(st: T) -> Self {
+        State(Rc::new(RefCell::new(st)))
+    }
+
+    #[inline]
+    pub fn get_ref(&self) -> Ref<T> {
+        self.0.borrow()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> RefMut<T> {
+        self.0.borrow_mut()
+    }
+}
+
+impl<T> Clone for State<T> {
+    fn clone(&self) -> Self {
+        State(self.0.clone())
+    }
+}

actix-ioframe/tests/test_server.rs

@@ -0,0 +1,59 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use actix_codec::BytesCodec;
+use actix_server_config::Io;
+use actix_service::{new_apply_fn, Service};
+use actix_testing::{self as test, TestServer};
+use futures::Future;
+use tokio_tcp::TcpStream;
+use tokio_timer::sleep;
+
+use actix_ioframe::{Builder, Connect};
+
+struct State;
+
+#[test]
+fn test_disconnect() -> std::io::Result<()> {
+    let disconnect = Arc::new(AtomicBool::new(false));
+    let disconnect1 = disconnect.clone();
+
+    let srv = TestServer::with(move || {
+        let disconnect1 = disconnect1.clone();
+
+        new_apply_fn(
+            Builder::new()
+                .factory(|conn: Connect<_>| Ok(conn.codec(BytesCodec).state(State)))
+                .disconnect(move |_, _| {
+                    disconnect1.store(true, Ordering::Relaxed);
+                })
+                .finish(|_t| Ok(None)),
+            |io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
+        )
+    });
+
+    let mut client = Builder::new()
+        .service(|conn: Connect<_>| {
+            let conn = conn.codec(BytesCodec).state(State);
+            conn.sink().close();
+            Ok(conn)
+        })
+        .finish(|_t| Ok(None));
+
+    let conn = test::block_on(
+        actix_connect::default_connector()
+            .call(actix_connect::Connect::with(String::new(), srv.addr())),
+    )
+    .unwrap();
+
+    test::block_on(client.call(conn.into_parts().0)).unwrap();
+    let _ = test::block_on(
+        sleep(Duration::from_millis(100))
+            .map(|_| ())
+            .map_err(|_| ()),
+    );
+    assert!(disconnect.load(Ordering::Relaxed));
+
+    Ok(())
+}

actix-rt/CHANGES.md

@@ -0,0 +1,51 @@
+# Changes
+
+## [0.2.5] - 2019-09-02
+
+### Added
+
+* Add arbiter specific storage
+
+
+## [0.2.4] - 2019-07-17
+
+### Changed
+
+* Avoid a copy of the Future when initializing the Box. #29
+
+
+## [0.2.3] - 2019-06-22
+
+### Added
+
+* Allow to start System using exsiting CurrentThread Handle #22
+
+
+## [0.2.2] - 2019-03-28
+
+### Changed
+
+* Moved `blocking` module to `actix-threadpool` crate
+
+
+## [0.2.1] - 2019-03-11
+
+### Added
+
+* Added `blocking` module
+
+* Arbiter::exec_fn - execute fn on the arbiter's thread
+
+* Arbiter::exec - execute fn on the arbiter's thread and wait result
+
+
+## [0.2.0] - 2019-03-06
+
+* `run` method returns `io::Result<()>`
+
+* Removed `Handle`
+
+
+## [0.1.0] - 2018-12-09
+
+* Initial release

actix-rt/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "actix-rt"
+version = "0.2.5"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix runtime"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-rt/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_rt"
+path = "src/lib.rs"
+
+[dependencies]
+actix-threadpool = "0.1.1"
+futures = "0.1.25"
+tokio-current-thread = "0.1"
+tokio-executor = "0.1.5"
+tokio-reactor = "0.1.7"
+tokio-timer = "0.2.8"
+copyless = "0.1.4"

actix-rt/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-rt/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-rt/src/arbiter.rs

@@ -0,0 +1,367 @@
+use std::any::{Any, TypeId};
+use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{fmt, thread};
+
+use futures::sync::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures::sync::oneshot::{channel, Canceled, Sender};
+use futures::{future, Async, Future, IntoFuture, Poll, Stream};
+use tokio_current_thread::spawn;
+
+use crate::builder::Builder;
+use crate::system::System;
+
+use copyless::BoxHelper;
+
+thread_local!(
+    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
+    static RUNNING: Cell<bool> = Cell::new(false);
+    static Q: RefCell<Vec<Box<dyn Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
+    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
+);
+
+pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
+
+pub(crate) enum ArbiterCommand {
+    Stop,
+    Execute(Box<dyn Future<Item = (), Error = ()> + Send>),
+    ExecuteFn(Box<dyn FnExec>),
+}
+
+impl fmt::Debug for ArbiterCommand {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
+            ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+/// Arbiters provide an asynchronous execution environment for actors, functions
+/// and futures. When an Arbiter is created, they spawn a new OS thread, and
+/// host an event loop. Some Arbiter functions execute on the current thread.
+pub struct Arbiter(UnboundedSender<ArbiterCommand>);
+
+impl Default for Arbiter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Arbiter {
+    pub(crate) fn new_system() -> Self {
+        let (tx, rx) = unbounded();
+
+        let arb = Arbiter(tx);
+        ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+        RUNNING.with(|cell| cell.set(false));
+        STORAGE.with(|cell| cell.borrow_mut().clear());
+        Arbiter::spawn(ArbiterController { stop: None, rx });
+
+        arb
+    }
+
+    /// Returns the current thread's arbiter's address. If no Arbiter is present, then this
+    /// function will panic!
+    pub fn current() -> Arbiter {
+        ADDR.with(|cell| match *cell.borrow() {
+            Some(ref addr) => addr.clone(),
+            None => panic!("Arbiter is not running"),
+        })
+    }
+
+    /// Stop arbiter from continuing it's event loop.
+    pub fn stop(&self) {
+        let _ = self.0.unbounded_send(ArbiterCommand::Stop);
+    }
+
+    /// Spawn new thread and run event loop in spawned thread.
+    /// Returns address of newly created arbiter.
+    pub fn new() -> Arbiter {
+        let id = COUNT.fetch_add(1, Ordering::Relaxed);
+        let name = format!("actix-rt:worker:{}", id);
+        let sys = System::current();
+        let (arb_tx, arb_rx) = unbounded();
+        let arb_tx2 = arb_tx.clone();
+
+        let _ = thread::Builder::new().name(name.clone()).spawn(move || {
+            let mut rt = Builder::new().build_rt().expect("Can not create Runtime");
+            let arb = Arbiter(arb_tx);
+
+            let (stop, stop_rx) = channel();
+            RUNNING.with(|cell| cell.set(true));
+            STORAGE.with(|cell| cell.borrow_mut().clear());
+
+            System::set_current(sys);
+
+            // start arbiter controller
+            rt.spawn(ArbiterController {
+                stop: Some(stop),
+                rx: arb_rx,
+            });
+            ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+
+            // register arbiter
+            let _ = System::current()
+                .sys()
+                .unbounded_send(SystemCommand::RegisterArbiter(id, arb.clone()));
+
+            // run loop
+            let _ = match rt.block_on(stop_rx) {
+                Ok(code) => code,
+                Err(_) => 1,
+            };
+
+            // unregister arbiter
+            let _ = System::current()
+                .sys()
+                .unbounded_send(SystemCommand::UnregisterArbiter(id));
+        });
+
+        Arbiter(arb_tx2)
+    }
+
+    pub(crate) fn run_system() {
+        RUNNING.with(|cell| cell.set(true));
+        Q.with(|cell| {
+            let mut v = cell.borrow_mut();
+            for fut in v.drain(..) {
+                spawn(fut);
+            }
+        });
+    }
+
+    pub(crate) fn stop_system() {
+        RUNNING.with(|cell| cell.set(false));
+    }
+
+    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    /// thread.
+    pub fn spawn<F>(future: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        RUNNING.with(move |cell| {
+            if cell.get() {
+                spawn(Box::alloc().init(future));
+            } else {
+                Q.with(move |cell| cell.borrow_mut().push(Box::alloc().init(future)));
+            }
+        });
+    }
+
+    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for executing futures on the current
+    /// thread.
+    pub fn spawn_fn<F, R>(f: F)
+    where
+        F: FnOnce() -> R + 'static,
+        R: IntoFuture<Item = (), Error = ()> + 'static,
+    {
+        Arbiter::spawn(future::lazy(f))
+    }
+
+    /// Send a future to the Arbiter's thread, and spawn it.
+    pub fn send<F>(&self, future: F)
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
+    }
+
+    /// Send a function to the Arbiter's thread, and execute it. Any result from the function
+    /// is discarded.
+    pub fn exec_fn<F>(&self, f: F)
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                f();
+            })));
+    }
+
+    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
+    /// A future is created, and when resolved will contain the result of the function sent
+    /// to the Arbiters thread.
+    pub fn exec<F, R>(&self, f: F) -> impl Future<Item = R, Error = Canceled>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let (tx, rx) = channel();
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                if !tx.is_canceled() {
+                    let _ = tx.send(f());
+                }
+            })));
+        rx
+    }
+
+    /// Set item to arbiter storage
+    pub fn set_item<T: 'static>(item: T) {
+        STORAGE.with(move |cell| cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item)));
+    }
+
+    /// Check if arbiter storage contains item
+    pub fn contains_item<T: 'static>() -> bool {
+        STORAGE.with(move |cell| cell.borrow().get(&TypeId::of::<T>()).is_some())
+    }
+
+    /// Get a reference to a type previously inserted on this arbiter's storage.
+    ///
+    /// Panics is item is not inserted
+    pub fn get_item<T: 'static, F, R>(mut f: F) -> R
+    where
+        F: FnMut(&T) -> R,
+    {
+        STORAGE.with(move |cell| {
+            let st = cell.borrow();
+            let item = st
+                .get(&TypeId::of::<T>())
+                .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
+                .unwrap();
+            f(item)
+        })
+    }
+
+    /// Get a mutable reference to a type previously inserted on this arbiter's storage.
+    ///
+    /// Panics is item is not inserted
+    pub fn get_mut_item<T: 'static, F, R>(mut f: F) -> R
+    where
+        F: FnMut(&mut T) -> R,
+    {
+        STORAGE.with(move |cell| {
+            let mut st = cell.borrow_mut();
+            let item = st
+                .get_mut(&TypeId::of::<T>())
+                .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
+                .unwrap();
+            f(item)
+        })
+    }
+}
+
+struct ArbiterController {
+    stop: Option<Sender<i32>>,
+    rx: UnboundedReceiver<ArbiterCommand>,
+}
+
+impl Drop for ArbiterController {
+    fn drop(&mut self) {
+        if thread::panicking() {
+            eprintln!("Panic in Arbiter thread, shutting down system.");
+            if System::current().stop_on_panic() {
+                System::current().stop_with_code(1)
+            }
+        }
+    }
+}
+
+impl Future for ArbiterController {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            match self.rx.poll() {
+                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                Ok(Async::Ready(Some(item))) => match item {
+                    ArbiterCommand::Stop => {
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(0);
+                        };
+                        return Ok(Async::Ready(()));
+                    }
+                    ArbiterCommand::Execute(fut) => {
+                        spawn(fut);
+                    }
+                    ArbiterCommand::ExecuteFn(f) => {
+                        f.call_box();
+                    }
+                },
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum SystemCommand {
+    Exit(i32),
+    RegisterArbiter(usize, Arbiter),
+    UnregisterArbiter(usize),
+}
+
+#[derive(Debug)]
+pub(crate) struct SystemArbiter {
+    stop: Option<Sender<i32>>,
+    commands: UnboundedReceiver<SystemCommand>,
+    arbiters: HashMap<usize, Arbiter>,
+}
+
+impl SystemArbiter {
+    pub(crate) fn new(stop: Sender<i32>, commands: UnboundedReceiver<SystemCommand>) -> Self {
+        SystemArbiter {
+            commands,
+            stop: Some(stop),
+            arbiters: HashMap::new(),
+        }
+    }
+}
+
+impl Future for SystemArbiter {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            match self.commands.poll() {
+                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                Ok(Async::Ready(Some(cmd))) => match cmd {
+                    SystemCommand::Exit(code) => {
+                        // stop arbiters
+                        for arb in self.arbiters.values() {
+                            arb.stop();
+                        }
+                        // stop event loop
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(code);
+                        }
+                    }
+                    SystemCommand::RegisterArbiter(name, hnd) => {
+                        self.arbiters.insert(name, hnd);
+                    }
+                    SystemCommand::UnregisterArbiter(name) => {
+                        self.arbiters.remove(&name);
+                    }
+                },
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+            }
+        }
+    }
+}
+
+pub trait FnExec: Send + 'static {
+    fn call_box(self: Box<Self>);
+}
+
+impl<F> FnExec for F
+where
+    F: FnOnce() + Send + 'static,
+{
+    #[allow(clippy::boxed_local)]
+    fn call_box(self: Box<Self>) {
+        (*self)()
+    }
+}

actix-rt/src/builder.rs

@@ -0,0 +1,242 @@
+use std::borrow::Cow;
+use std::io;
+
+use futures::future;
+use futures::future::{lazy, Future};
+use futures::sync::mpsc::unbounded;
+use futures::sync::oneshot::{channel, Receiver};
+
+use tokio_current_thread::{CurrentThread, Handle};
+use tokio_reactor::Reactor;
+use tokio_timer::clock::Clock;
+use tokio_timer::timer::Timer;
+
+use crate::arbiter::{Arbiter, SystemArbiter};
+use crate::runtime::Runtime;
+use crate::system::System;
+
+/// Builder struct for a actix runtime.
+///
+/// Either use `Builder::build` to create a system and start actors.
+/// Alternatively, use `Builder::run` to start the tokio runtime and
+/// run a function in its context.
+pub struct Builder {
+    /// Name of the System. Defaults to "actix" if unset.
+    name: Cow<'static, str>,
+
+    /// The clock to use
+    clock: Clock,
+
+    /// Whether the Arbiter will stop the whole System on uncaught panic. Defaults to false.
+    stop_on_panic: bool,
+}
+
+impl Builder {
+    pub(crate) fn new() -> Self {
+        Builder {
+            name: Cow::Borrowed("actix"),
+            clock: Clock::new(),
+            stop_on_panic: false,
+        }
+    }
+
+    /// Sets the name of the System.
+    pub fn name<T: Into<String>>(mut self, name: T) -> Self {
+        self.name = Cow::Owned(name.into());
+        self
+    }
+
+    /// Set the Clock instance that will be used by this System.
+    ///
+    /// Defaults to the system clock.
+    pub fn clock(mut self, clock: Clock) -> Self {
+        self.clock = clock;
+        self
+    }
+
+    /// Sets the option 'stop_on_panic' which controls whether the System is stopped when an
+    /// uncaught panic is thrown from a worker thread.
+    ///
+    /// Defaults to false.
+    pub fn stop_on_panic(mut self, stop_on_panic: bool) -> Self {
+        self.stop_on_panic = stop_on_panic;
+        self
+    }
+
+    /// Create new System.
+    ///
+    /// This method panics if it can not create tokio runtime
+    pub fn build(self) -> SystemRunner {
+        self.create_runtime(|| {})
+    }
+
+    /// Create new System that can run asynchronously.
+    ///
+    /// This method panics if it cannot start the system arbiter
+    pub(crate) fn build_async(self, executor: Handle) -> AsyncSystemRunner {
+        self.create_async_runtime(executor)
+    }
+
+    /// This function will start tokio runtime and will finish once the
+    /// `System::stop()` message get called.
+    /// Function `f` get called within tokio runtime context.
+    pub fn run<F>(self, f: F) -> io::Result<()>
+    where
+        F: FnOnce() + 'static,
+    {
+        self.create_runtime(f).run()
+    }
+
+    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+
+        // system arbiter
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);
+
+        // start the system arbiter
+        executor.spawn(arb).expect("could not start system arbiter");
+
+        AsyncSystemRunner { stop, system }
+    }
+
+    fn create_runtime<F>(self, f: F) -> SystemRunner
+    where
+        F: FnOnce() + 'static,
+    {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+
+        // system arbiter
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);
+
+        let mut rt = self.build_rt().unwrap();
+        rt.spawn(arb);
+
+        // init system arbiter and run configuration method
+        let _ = rt.block_on(lazy(move || {
+            f();
+            Ok::<_, ()>(())
+        }));
+
+        SystemRunner { rt, stop, system }
+    }
+
+    pub(crate) fn build_rt(&self) -> io::Result<Runtime> {
+        // We need a reactor to receive events about IO objects from kernel
+        let reactor = Reactor::new()?;
+        let reactor_handle = reactor.handle();
+
+        // Place a timer wheel on top of the reactor. If there are no timeouts to fire, it'll let the
+        // reactor pick up some new external events.
+        let timer = Timer::new_with_now(reactor, self.clock.clone());
+        let timer_handle = timer.handle();
+
+        // And now put a single-threaded executor on top of the timer. When there are no futures ready
+        // to do something, it'll let the timer or the reactor to generate some new stimuli for the
+        // futures to continue in their life.
+        let executor = CurrentThread::new_with_park(timer);
+
+        Ok(Runtime::new2(
+            reactor_handle,
+            timer_handle,
+            self.clock.clone(),
+            executor,
+        ))
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct AsyncSystemRunner {
+    stop: Receiver<i32>,
+    system: System,
+}
+
+impl AsyncSystemRunner {
+    /// This function will start event loop and returns a future that
+    /// resolves once the `System::stop()` function is called.
+    pub(crate) fn run_nonblocking(self) -> impl Future<Item = (), Error = io::Error> + Send {
+        let AsyncSystemRunner { stop, .. } = self;
+
+        // run loop
+        future::lazy(|| {
+            Arbiter::run_system();
+            stop.then(|res| match res {
+                Ok(code) => {
+                    if code != 0 {
+                        Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!("Non-zero exit code: {}", code),
+                        ))
+                    } else {
+                        Ok(())
+                    }
+                }
+                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+            })
+            .then(|result| {
+                Arbiter::stop_system();
+                result
+            })
+        })
+    }
+}
+
+/// Helper object that runs System's event loop
+#[must_use = "SystemRunner must be run"]
+#[derive(Debug)]
+pub struct SystemRunner {
+    rt: Runtime,
+    stop: Receiver<i32>,
+    system: System,
+}
+
+impl SystemRunner {
+    /// This function will start event loop and will finish once the
+    /// `System::stop()` function is called.
+    pub fn run(self) -> io::Result<()> {
+        let SystemRunner { mut rt, stop, .. } = self;
+
+        // run loop
+        let _ = rt.block_on(lazy(move || {
+            Arbiter::run_system();
+            Ok::<_, ()>(())
+        }));
+        let result = match rt.block_on(stop) {
+            Ok(code) => {
+                if code != 0 {
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Non-zero exit code: {}", code),
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+        };
+        Arbiter::stop_system();
+        result
+    }
+
+    /// Execute a future and wait for result.
+    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
+    where
+        F: Future<Item = I, Error = E>,
+    {
+        let _ = self.rt.block_on(lazy(move || {
+            Arbiter::run_system();
+            Ok::<_, ()>(())
+        }));
+        let res = self.rt.block_on(fut);
+        let _ = self.rt.block_on(lazy(move || {
+            Arbiter::stop_system();
+            Ok::<_, ()>(())
+        }));
+        res
+    }
+}

actix-rt/src/lib.rs

@@ -0,0 +1,30 @@
+//! A runtime implementation that runs everything on the current thread.
+
+mod arbiter;
+mod builder;
+mod runtime;
+mod system;
+
+pub use self::arbiter::Arbiter;
+pub use self::builder::{Builder, SystemRunner};
+pub use self::runtime::Runtime;
+pub use self::system::System;
+
+#[doc(hidden)]
+pub use actix_threadpool as blocking;
+
+/// Spawns a future on the current arbiter.
+///
+/// # Panics
+///
+/// This function panics if actix system is not running.
+pub fn spawn<F>(f: F)
+where
+    F: futures::Future<Item = (), Error = ()> + 'static,
+{
+    if !System::is_set() {
+        panic!("System is not running");
+    }
+
+    Arbiter::spawn(f);
+}

actix-rt/src/mod.rs

@@ -0,0 +1,92 @@
+//! A runtime implementation that runs everything on the current thread.
+//!
+//! [`current_thread::Runtime`][rt] is similar to the primary
+//! [`Runtime`][concurrent-rt] except that it runs all components on the current
+//! thread instead of using a thread pool. This means that it is able to spawn
+//! futures that do not implement `Send`.
+//!
+//! Same as the default [`Runtime`][concurrent-rt], the
+//! [`current_thread::Runtime`][rt] includes:
+//!
+//! * A [reactor] to drive I/O resources.
+//! * An [executor] to execute tasks that use these I/O resources.
+//! * A [timer] for scheduling work to run after a set period of time.
+//!
+//! Note that [`current_thread::Runtime`][rt] does not implement `Send` itself
+//! and cannot be safely moved to other threads.
+//!
+//! # Spawning from other threads
+//!
+//! While [`current_thread::Runtime`][rt] does not implement `Send` and cannot
+//! safely be moved to other threads, it provides a `Handle` that can be sent
+//! to other threads and allows to spawn new tasks from there.
+//!
+//! For example:
+//!
+//! ```
+//! # extern crate tokio;
+//! # extern crate futures;
+//! use tokio::runtime::current_thread::Runtime;
+//! use tokio::prelude::*;
+//! use std::thread;
+//!
+//! # fn main() {
+//! let mut runtime = Runtime::new().unwrap();
+//! let handle = runtime.handle();
+//!
+//! thread::spawn(move || {
+//!     handle.spawn(future::ok(()));
+//! }).join().unwrap();
+//!
+//! # /*
+//! runtime.run().unwrap();
+//! # */
+//! # }
+//! ```
+//!
+//! # Examples
+//!
+//! Creating a new `Runtime` and running a future `f` until its completion and
+//! returning its result.
+//!
+//! ```
+//! use tokio::runtime::current_thread::Runtime;
+//! use tokio::prelude::*;
+//!
+//! let mut runtime = Runtime::new().unwrap();
+//!
+//! // Use the runtime...
+//! // runtime.block_on(f); // where f is a future
+//! ```
+//!
+//! [rt]: struct.Runtime.html
+//! [concurrent-rt]: ../struct.Runtime.html
+//! [chan]: https://docs.rs/futures/0.1/futures/sync/mpsc/fn.channel.html
+//! [reactor]: ../../reactor/struct.Reactor.html
+//! [executor]: https://tokio.rs/docs/getting-started/runtime-model/#executors
+//! [timer]: ../../timer/index.html
+
+mod builder;
+mod runtime;
+
+pub use self::builder::Builder;
+pub use self::runtime::{Runtime, Handle};
+pub use tokio_current_thread::spawn;
+pub use tokio_current_thread::TaskExecutor;
+
+use futures::Future;
+
+/// Run the provided future to completion using a runtime running on the current thread.
+///
+/// This first creates a new [`Runtime`], and calls [`Runtime::block_on`] with the provided future,
+/// which blocks the current thread until the provided future completes. It then calls
+/// [`Runtime::run`] to wait for any other spawned futures to resolve.
+pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
+where
+    F: Future,
+{
+    let mut r = Runtime::new().expect("failed to start runtime on current thread");
+    let v = r.block_on(future)?;
+    r.run().expect("failed to resolve remaining futures");
+    Ok(v)
+}

actix-rt/src/runtime.rs

@@ -0,0 +1,174 @@
+use std::error::Error;
+use std::{fmt, io};
+
+use futures::Future;
+use tokio_current_thread::{self as current_thread, CurrentThread};
+use tokio_executor;
+use tokio_reactor::{self, Reactor};
+use tokio_timer::clock::{self, Clock};
+use tokio_timer::timer::{self, Timer};
+
+use crate::builder::Builder;
+
+/// Single-threaded runtime provides a way to start reactor
+/// and executor on the current thread.
+///
+/// See [module level][mod] documentation for more details.
+///
+/// [mod]: index.html
+#[derive(Debug)]
+pub struct Runtime {
+    reactor_handle: tokio_reactor::Handle,
+    timer_handle: timer::Handle,
+    clock: Clock,
+    executor: CurrentThread<Timer<Reactor>>,
+}
+
+/// Error returned by the `run` function.
+#[derive(Debug)]
+pub struct RunError {
+    inner: current_thread::RunError,
+}
+
+impl fmt::Display for RunError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.inner)
+    }
+}
+
+impl Error for RunError {
+    fn description(&self) -> &str {
+        self.inner.description()
+    }
+    fn cause(&self) -> Option<&dyn Error> {
+        self.inner.source()
+    }
+}
+
+impl Runtime {
+    #[allow(clippy::new_ret_no_self)]
+    /// Returns a new runtime initialized with default configuration values.
+    pub fn new() -> io::Result<Runtime> {
+        Builder::new().build_rt()
+    }
+
+    pub(super) fn new2(
+        reactor_handle: tokio_reactor::Handle,
+        timer_handle: timer::Handle,
+        clock: Clock,
+        executor: CurrentThread<Timer<Reactor>>,
+    ) -> Runtime {
+        Runtime {
+            reactor_handle,
+            timer_handle,
+            clock,
+            executor,
+        }
+    }
+
+    /// Spawn a future onto the single-threaded Tokio runtime.
+    ///
+    /// See [module level][mod] documentation for more details.
+    ///
+    /// [mod]: index.html
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use futures::{future, Future, Stream};
+    /// use actix_rt::Runtime;
+    ///
+    /// # fn dox() {
+    /// // Create the runtime
+    /// let mut rt = Runtime::new().unwrap();
+    ///
+    /// // Spawn a future onto the runtime
+    /// rt.spawn(future::lazy(|| {
+    ///     println!("running on the runtime");
+    ///     Ok(())
+    /// }));
+    /// # }
+    /// # pub fn main() {}
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the spawn fails. Failure occurs if the executor
+    /// is currently at capacity and is unable to spawn a new future.
+    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.executor.spawn(future);
+        self
+    }
+
+    /// 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 will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed. Once the function returns, any uncompleted futures
+    /// remain pending in the `Runtime` instance. These futures will not run
+    /// until `block_on` or `run` is called again.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution by calling `block_on` or `run`.
+    pub fn block_on<F>(&mut self, f: F) -> Result<F::Item, F::Error>
+    where
+        F: Future,
+    {
+        self.enter(|executor| {
+            // Run the provided future
+            let ret = executor.block_on(f);
+            ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
+        })
+    }
+
+    /// Run the executor to completion, blocking the thread until **all**
+    /// spawned futures have completed.
+    pub fn run(&mut self) -> Result<(), RunError> {
+        self.enter(|executor| executor.run())
+            .map_err(|e| RunError { inner: e })
+    }
+
+    fn enter<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce(&mut current_thread::Entered<Timer<Reactor>>) -> R,
+    {
+        let Runtime {
+            ref reactor_handle,
+            ref timer_handle,
+            ref clock,
+            ref mut executor,
+            ..
+        } = *self;
+
+        // Binds an executor to this thread
+        let mut enter = tokio_executor::enter().expect("Multiple executors at once");
+
+        // This will set the default handle and timer to use inside the closure
+        // and run the future.
+        tokio_reactor::with_default(&reactor_handle, &mut enter, |enter| {
+            clock::with_default(clock, enter, |enter| {
+                timer::with_default(&timer_handle, enter, |enter| {
+                    // The TaskExecutor is a fake executor that looks into the
+                    // current single-threaded executor when used. This is a trick,
+                    // because we need two mutable references to the executor (one
+                    // to run the provided future, another to install as the default
+                    // one). We use the fake one here as the default one.
+                    let mut default_executor = current_thread::TaskExecutor::current();
+                    tokio_executor::with_default(&mut default_executor, enter, |enter| {
+                        let mut executor = executor.enter(enter);
+                        f(&mut executor)
+                    })
+                })
+            })
+        })
+    }
+}

actix-rt/src/system.rs

@@ -0,0 +1,145 @@
+use std::cell::RefCell;
+use std::io;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use futures::sync::mpsc::UnboundedSender;
+use futures::Future;
+use tokio_current_thread::Handle;
+
+use crate::arbiter::{Arbiter, SystemCommand};
+use crate::builder::{Builder, SystemRunner};
+
+static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+/// System is a runtime manager.
+#[derive(Clone, Debug)]
+pub struct System {
+    id: usize,
+    sys: UnboundedSender<SystemCommand>,
+    arbiter: Arbiter,
+    stop_on_panic: bool,
+}
+
+thread_local!(
+    static CURRENT: RefCell<Option<System>> = RefCell::new(None);
+);
+
+impl System {
+    /// Constructs new system and sets it as current
+    pub(crate) fn construct(
+        sys: UnboundedSender<SystemCommand>,
+        arbiter: Arbiter,
+        stop_on_panic: bool,
+    ) -> Self {
+        let sys = System {
+            sys,
+            arbiter,
+            stop_on_panic,
+            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
+        };
+        System::set_current(sys.clone());
+        sys
+    }
+
+    /// Build a new system with a customized tokio runtime.
+    ///
+    /// This allows to customize the runtime. See struct level docs on
+    /// `Builder` for more information.
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
+    #[allow(clippy::new_ret_no_self)]
+    /// Create new system.
+    ///
+    /// This method panics if it can not create tokio runtime
+    pub fn new<T: Into<String>>(name: T) -> SystemRunner {
+        Self::builder().name(name).build()
+    }
+
+    #[allow(clippy::new_ret_no_self)]
+    /// Create new system using provided CurrentThread Handle.
+    ///
+    /// This method panics if it can not spawn system arbiter
+    pub fn run_in_executor<T: Into<String>>(
+        name: T,
+        executor: Handle,
+    ) -> impl Future<Item = (), Error = io::Error> + Send {
+        Self::builder()
+            .name(name)
+            .build_async(executor)
+            .run_nonblocking()
+    }
+
+    /// Get current running system.
+    pub fn current() -> System {
+        CURRENT.with(|cell| match *cell.borrow() {
+            Some(ref sys) => sys.clone(),
+            None => panic!("System is not running"),
+        })
+    }
+
+    /// Set current running system.
+    pub(crate) fn is_set() -> bool {
+        CURRENT.with(|cell| cell.borrow().is_some())
+    }
+
+    /// Set current running system.
+    #[doc(hidden)]
+    pub fn set_current(sys: System) {
+        CURRENT.with(|s| {
+            *s.borrow_mut() = Some(sys);
+        })
+    }
+
+    /// Execute function with system reference.
+    pub fn with_current<F, R>(f: F) -> R
+    where
+        F: FnOnce(&System) -> R,
+    {
+        CURRENT.with(|cell| match *cell.borrow() {
+            Some(ref sys) => f(sys),
+            None => panic!("System is not running"),
+        })
+    }
+
+    /// System id
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
+    /// Stop the system
+    pub fn stop(&self) {
+        self.stop_with_code(0)
+    }
+
+    /// Stop the system with a particular exit code.
+    pub fn stop_with_code(&self, code: i32) {
+        let _ = self.sys.unbounded_send(SystemCommand::Exit(code));
+    }
+
+    pub(crate) fn sys(&self) -> &UnboundedSender<SystemCommand> {
+        &self.sys
+    }
+
+    /// Return status of 'stop_on_panic' option which controls whether the System is stopped when an
+    /// uncaught panic is thrown from a worker thread.
+    pub fn stop_on_panic(&self) -> bool {
+        self.stop_on_panic
+    }
+
+    /// System arbiter
+    pub fn arbiter(&self) -> &Arbiter {
+        &self.arbiter
+    }
+
+    /// This function will start tokio runtime and will finish once the
+    /// `System::stop()` message get called.
+    /// Function `f` get called within tokio runtime context.
+    pub fn run<F>(f: F) -> io::Result<()>
+    where
+        F: FnOnce() + 'static,
+    {
+        Self::builder().run(f)
+    }
+}

actix-server-config/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "actix-server-config"
+version = "0.1.2"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix server config utils"
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_server_config"
+path = "src/lib.rs"
+
+[package.metadata.docs.rs]
+features = ["ssl", "rust-tls", "uds"]
+
+[features]
+default = []
+
+# openssl
+ssl = ["tokio-openssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls"]
+
+# unix domain sockets
+uds = ["tokio-uds"]
+
+[dependencies]
+futures = "0.1.25"
+tokio-io = "0.1.12"
+tokio-tcp = "0.1"
+tokio-openssl = { version="0.3.0", optional = true }
+rustls = { version = "0.16.0", optional = true }
+tokio-rustls = { version = "0.10.0", optional = true }
+tokio-uds = { version="0.2.5", optional = true }

actix-server-config/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-server-config/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-server-config/changes.md

@@ -0,0 +1,21 @@
+# Changes
+
+## Next
+
+### Changed
+
+* Update `rustls` to 0.16
+* Minimum required Rust version upped to 1.37.0
+
+## [0.1.2] - 2019-07-18
+
+### Added
+
+* Add unix domnain sockets support
+
+
+## [0.1.1] - 2019-04-16
+
+### Added
+
+* `IoStream` trait and impls for TcpStream, SslStream and TlsStream

actix-server-config/src/lib.rs

@@ -0,0 +1,241 @@
+use std::cell::Cell;
+use std::net::SocketAddr;
+use std::rc::Rc;
+use std::{fmt, io, net, time};
+
+use tokio_io::{AsyncRead, AsyncWrite};
+use tokio_tcp::TcpStream;
+
+#[derive(Debug, Clone)]
+pub struct ServerConfig {
+    addr: SocketAddr,
+    secure: Rc<Cell<bool>>,
+}
+
+impl ServerConfig {
+    pub fn new(addr: SocketAddr) -> Self {
+        ServerConfig {
+            addr,
+            secure: Rc::new(Cell::new(false)),
+        }
+    }
+
+    /// Returns the address of the local half of this TCP server socket
+    pub fn local_addr(&self) -> SocketAddr {
+        self.addr
+    }
+
+    /// Returns true if connection is secure (tls enabled)
+    pub fn secure(&self) -> bool {
+        self.secure.as_ref().get()
+    }
+
+    /// Set secure flag
+    pub fn set_secure(&self) {
+        self.secure.as_ref().set(true)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Protocol {
+    Unknown,
+    Http10,
+    Http11,
+    Http2,
+    Proto1,
+    Proto2,
+    Proto3,
+    Proto4,
+    Proto5,
+    Proto6,
+}
+
+pub struct Io<T, P = ()> {
+    io: T,
+    proto: Protocol,
+    params: P,
+}
+
+impl<T> Io<T, ()> {
+    pub fn new(io: T) -> Self {
+        Self {
+            io,
+            proto: Protocol::Unknown,
+            params: (),
+        }
+    }
+}
+
+impl<T, P> Io<T, P> {
+    /// Reconstruct from a parts.
+    pub fn from_parts(io: T, params: P, proto: Protocol) -> Self {
+        Self { io, params, proto }
+    }
+
+    /// Deconstruct into a parts.
+    pub fn into_parts(self) -> (T, P, Protocol) {
+        (self.io, self.params, self.proto)
+    }
+
+    /// Returns a shared reference to the underlying stream.
+    pub fn get_ref(&self) -> &T {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying stream.
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.io
+    }
+
+    /// Get selected protocol
+    pub fn protocol(&self) -> Protocol {
+        self.proto
+    }
+
+    /// Return new Io object with new parameter.
+    pub fn set<U>(self, params: U) -> Io<T, U> {
+        Io {
+            params,
+            io: self.io,
+            proto: self.proto,
+        }
+    }
+
+    /// Maps an Io<_, P> to Io<_, U> by applying a function to a contained value.
+    pub fn map<U, F>(self, op: F) -> Io<T, U>
+    where
+        F: FnOnce(P) -> U,
+    {
+        Io {
+            io: self.io,
+            proto: self.proto,
+            params: op(self.params),
+        }
+    }
+}
+
+impl<T, P> std::ops::Deref for Io<T, P> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.io
+    }
+}
+
+impl<T, P> std::ops::DerefMut for Io<T, P> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.io
+    }
+}
+
+impl<T: fmt::Debug, P> fmt::Debug for Io<T, P> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Io {{{:?}}}", self.io)
+    }
+}
+
+/// Low-level io stream operations
+pub trait IoStream: AsyncRead + AsyncWrite {
+    /// Returns the socket address of the remote peer of this TCP connection.
+    fn peer_addr(&self) -> Option<SocketAddr> {
+        None
+    }
+
+    /// Sets the value of the TCP_NODELAY option on this socket.
+    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()>;
+
+    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()>;
+
+    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()>;
+}
+
+impl IoStream for TcpStream {
+    #[inline]
+    fn peer_addr(&self) -> Option<net::SocketAddr> {
+        TcpStream::peer_addr(self).ok()
+    }
+
+    #[inline]
+    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
+        TcpStream::set_nodelay(self, nodelay)
+    }
+
+    #[inline]
+    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        TcpStream::set_linger(self, dur)
+    }
+
+    #[inline]
+    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        TcpStream::set_keepalive(self, dur)
+    }
+}
+
+#[cfg(any(feature = "ssl"))]
+impl<T: IoStream> IoStream for tokio_openssl::SslStream<T> {
+    #[inline]
+    fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.get_ref().get_ref().peer_addr()
+    }
+
+    #[inline]
+    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
+        self.get_mut().get_mut().set_nodelay(nodelay)
+    }
+
+    #[inline]
+    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        self.get_mut().get_mut().set_linger(dur)
+    }
+
+    #[inline]
+    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        self.get_mut().get_mut().set_keepalive(dur)
+    }
+}
+
+#[cfg(any(feature = "rust-tls"))]
+impl<T: IoStream> IoStream for tokio_rustls::server::TlsStream<T> {
+    #[inline]
+    fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.get_ref().0.peer_addr()
+    }
+
+    #[inline]
+    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
+        self.get_mut().0.set_nodelay(nodelay)
+    }
+
+    #[inline]
+    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        self.get_mut().0.set_linger(dur)
+    }
+
+    #[inline]
+    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
+        self.get_mut().0.set_keepalive(dur)
+    }
+}
+
+#[cfg(all(unix, feature = "uds"))]
+impl IoStream for tokio_uds::UnixStream {
+    #[inline]
+    fn peer_addr(&self) -> Option<net::SocketAddr> {
+        None
+    }
+
+    #[inline]
+    fn set_nodelay(&mut self, _: bool) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn set_linger(&mut self, _: Option<time::Duration>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn set_keepalive(&mut self, _: Option<time::Duration>) -> io::Result<()> {
+        Ok(())
+    }
+}

actix-server/CHANGES.md

@@ -0,0 +1,145 @@
+# Changes
+
+## Next
+
+### Changed
+
+* Update `rustls` to 0.16
+* Minimum required Rust version upped to 1.37.0
+
+## [0.6.1] - 2019-09-25
+
+### Added
+
+* Add UDS listening support to `ServerBuilder`
+
+
+## [0.6.0] - 2019-07-18
+
+### Added
+
+* Support Unix domain sockets #3
+
+
+## [0.5.1] - 2019-05-18
+
+### Changed
+
+* ServerBuilder::shutdown_timeout() accepts u64
+
+
+## [0.5.0] - 2019-05-12
+
+### Added
+
+* Add `Debug` impl for `SslError`
+
+* Derive debug for `Server` and `ServerCommand`
+
+### Changed
+
+* Upgrade to actix-service 0.4
+
+
+## [0.4.3] - 2019-04-16
+
+### Added
+
+* Re-export `IoStream` trait
+
+### Changed
+
+* Deppend on `ssl` and `rust-tls` features from actix-server-config
+
+
+## [0.4.2] - 2019-03-30
+
+### Fixed
+
+* Fix SIGINT force shutdown
+
+
+## [0.4.1] - 2019-03-14
+
+### Added
+
+* `SystemRuntime::on_start()` - allow to run future before server service initialization
+
+
+## [0.4.0] - 2019-03-12
+
+### Changed
+
+* Use `ServerConfig` for service factory
+
+* Wrap tcp socket to `Io` type
+
+* Upgrade actix-service
+
+
+## [0.3.1] - 2019-03-04
+
+### Added
+
+* Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
+
+* Add helper ssl error `SslError`
+
+
+### Changed
+
+* Rename `StreamServiceFactory` to `ServiceFactory`
+
+* Deprecate `StreamServiceFactory`
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+
+## [0.2.1] - 2019-02-09
+
+### Changed
+
+* Drop service response
+
+
+## [0.2.0] - 2019-02-01
+
+### Changed
+
+* Migrate to actix-service 0.2
+
+* Updated rustls dependency
+
+
+## [0.1.3] - 2018-12-21
+
+### Fixed
+
+* Fix max concurrent connections handling
+
+
+## [0.1.2] - 2018-12-12
+
+### Changed
+
+* rename ServiceConfig::rt() to ServiceConfig::apply()
+
+
+### Fixed
+
+* Fix back-pressure for concurrent ssl handshakes
+
+
+## [0.1.1] - 2018-12-11
+
+* Fix signal handling on windows
+
+
+## [0.1.0] - 2018-12-09
+
+* Move server to separate crate

actix-server/Cargo.toml

@@ -0,0 +1,76 @@
+[package]
+name = "actix-server"
+version = "0.6.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix server - General purpose tcp server"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-server/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[package.metadata.docs.rs]
+features = ["ssl", "tls", "rust-tls", "uds"]
+
+[lib]
+name = "actix_server"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# tls
+tls = ["native-tls"]
+
+# openssl
+ssl = ["openssl", "tokio-openssl", "actix-server-config/ssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots", "actix-server-config/rust-tls"]
+
+# uds
+uds = ["mio-uds", "tokio-uds", "actix-server-config/uds"]
+
+[dependencies]
+actix-rt = "0.2.2"
+actix-service = "0.4.1"
+actix-server-config = "0.1.2"
+
+log = "0.4"
+num_cpus = "1.0"
+
+mio = "0.6.19"
+net2 = "0.2"
+futures = "0.1"
+slab = "0.4"
+tokio-io = "0.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2.8"
+tokio-reactor = "0.1"
+tokio-signal = "0.2"
+
+# unix domain sockets
+mio-uds = { version="0.6.7", optional = true }
+tokio-uds = { version="0.2.5", optional = true }
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.3", optional = true }
+
+# rustls
+rustls = { version = "0.16.0", optional = true }
+tokio-rustls = { version = "0.10.0", optional = true }
+webpki = { version = "0.21", optional = true }
+webpki-roots = { version = "0.17", optional = true }
+
+[dev-dependencies]
+bytes = "0.4"
+actix-codec = "0.1.2"
+env_logger = "0.6"

actix-server/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-server/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-server/src/accept.rs

@@ -1,18 +1,17 @@
 use std::sync::mpsc as sync_mpsc;
 use std::time::{Duration, Instant};
-use std::{io, net, thread};
+use std::{io, thread};
 
-use futures::{sync::mpsc, Future};
+use actix_rt::System;
+use futures::future::{lazy, Future};
 use log::{error, info};
-use mio;
 use slab::Slab;
 use tokio_timer::Delay;
 
-use actix::{msgs::Execute, Arbiter, System};
-
-use super::server::ServerCommand;
-use super::worker::{Conn, WorkerClient};
-use super::Token;
+use crate::server::Server;
+use crate::socket::{SocketAddr, SocketListener, StdListener};
+use crate::worker::{Conn, WorkerClient};
+use crate::Token;
 
 pub(crate) enum Command {
     Pause,
@@ -22,9 +21,9 @@ pub(crate) enum Command {
 }
 
 struct ServerSocketInfo {
-    addr: net::SocketAddr,
+    addr: SocketAddr,
     token: Token,
-    sock: mio::net::TcpListener,
+    sock: SocketListener,
     timeout: Option<Instant>,
 }
 
@@ -54,14 +53,11 @@ pub(crate) struct AcceptLoop {
     notify_ready: mio::SetReadiness,
     tx: sync_mpsc::Sender<Command>,
     rx: Option<sync_mpsc::Receiver<Command>>,
-    srv: Option<(
-        mpsc::UnboundedSender<ServerCommand>,
-        mpsc::UnboundedReceiver<ServerCommand>,
-    )>,
+    srv: Option<Server>,
 }
 
 impl AcceptLoop {
-    pub fn new() -> AcceptLoop {
+    pub fn new(srv: Server) -> AcceptLoop {
         let (tx, rx) = sync_mpsc::channel();
         let (cmd_reg, cmd_ready) = mio::Registration::new2();
         let (notify_reg, notify_ready) = mio::Registration::new2();
@@ -73,7 +69,7 @@ impl AcceptLoop {
             notify_ready,
             notify_reg: Some(notify_reg),
             rx: Some(rx),
-            srv: Some(mpsc::unbounded()),
+            srv: Some(srv),
         }
     }
 
@@ -88,20 +84,19 @@ impl AcceptLoop {
 
     pub(crate) fn start(
         &mut self,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
-    ) -> mpsc::UnboundedReceiver<ServerCommand> {
-        let (tx, rx) = self.srv.take().expect("Can not re-use AcceptInfo");
+    ) {
+        let srv = self.srv.take().expect("Can not re-use AcceptInfo");
 
         Accept::start(
             self.rx.take().expect("Can not re-use AcceptInfo"),
             self.cmd_reg.take().expect("Can not re-use AcceptInfo"),
             self.notify_reg.take().expect("Can not re-use AcceptInfo"),
             socks,
-            tx,
+            srv,
             workers,
         );
-        rx
     }
 }
 
@@ -110,7 +105,7 @@ struct Accept {
     rx: sync_mpsc::Receiver<Command>,
     sockets: Slab<ServerSocketInfo>,
     workers: Vec<WorkerClient>,
-    srv: mpsc::UnboundedSender<ServerCommand>,
+    srv: Server,
     timer: (mio::Registration, mio::SetReadiness),
     next: usize,
     backpressure: bool,
@@ -140,15 +135,15 @@ impl Accept {
         rx: sync_mpsc::Receiver<Command>,
         cmd_reg: mio::Registration,
         notify_reg: mio::Registration,
-        socks: Vec<(Token, net::TcpListener)>,
-        srv: mpsc::UnboundedSender<ServerCommand>,
+        socks: Vec<(Token, StdListener)>,
+        srv: Server,
         workers: Vec<WorkerClient>,
     ) {
         let sys = System::current();
 
         // start accept thread
         let _ = thread::Builder::new()
-            .name("actix-web accept loop".to_owned())
+            .name("actix-server accept loop".to_owned())
             .spawn(move || {
                 System::set_current(sys);
                 let mut accept = Accept::new(rx, socks, workers, srv);
@@ -179,9 +174,9 @@ impl Accept {
 
     fn new(
         rx: sync_mpsc::Receiver<Command>,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
-        srv: mpsc::UnboundedSender<ServerCommand>,
+        srv: Server,
     ) -> Accept {
         // Create a poll instance
         let poll = match mio::Poll::new() {
@@ -192,10 +187,9 @@ impl Accept {
         // Start accept
         let mut sockets = Slab::new();
         for (hnd_token, lst) in socks.into_iter() {
-            let addr = lst.local_addr().unwrap();
-            let server = mio::net::TcpListener::from_std(lst)
-                .expect("Can not create mio::net::TcpListener");
+            let addr = lst.local_addr();
 
+            let server = lst.into_listener();
             let entry = sockets.vacant_entry();
             let token = entry.key();
 
@@ -376,9 +370,7 @@ impl Accept {
                 match self.workers[self.next].send(msg) {
                     Ok(_) => (),
                     Err(tmp) => {
-                        let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
-                            self.workers[self.next].idx,
-                        ));
+                        self.srv.worker_died(self.workers[self.next].idx);
                         msg = tmp;
                         self.workers.swap_remove(self.next);
                         if self.workers.is_empty() {
@@ -404,9 +396,7 @@ impl Accept {
                             return;
                         }
                         Err(tmp) => {
-                            let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
-                                self.workers[self.next].idx,
-                            ));
+                            self.srv.worker_died(self.workers[self.next].idx);
                             msg = tmp;
                             self.workers.swap_remove(self.next);
                             if self.workers.is_empty() {
@@ -431,12 +421,13 @@ impl Accept {
     fn accept(&mut self, token: usize) {
         loop {
             let msg = if let Some(info) = self.sockets.get_mut(token) {
-                match info.sock.accept_std() {
-                    Ok((io, addr)) => Conn {
+                match info.sock.accept() {
+                    Ok(Some((io, addr))) => Conn {
                         io,
                         token: info.token,
                         peer: Some(addr),
                     },
+                    Ok(None) => return,
                     Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
                     Err(ref e) if connection_error(e) => continue,
                     Err(e) => {
@@ -449,19 +440,14 @@ impl Accept {
                         info.timeout = Some(Instant::now() + Duration::from_millis(500));
 
                         let r = self.timer.1.clone();
-                        System::current().arbiter().do_send(Execute::new(
-                            move || -> Result<(), ()> {
-                                Arbiter::spawn(
-                                    Delay::new(Instant::now() + Duration::from_millis(510))
-                                        .map_err(|_| ())
-                                        .and_then(move |_| {
-                                            let _ = r.set_readiness(mio::Ready::readable());
-                                            Ok(())
-                                        }),
-                                );
-                                Ok(())
-                            },
-                        ));
+                        System::current().arbiter().send(lazy(move || {
+                            Delay::new(Instant::now() + Duration::from_millis(510))
+                                .map_err(|_| ())
+                                .and_then(move |_| {
+                                    let _ = r.set_readiness(mio::Ready::readable());
+                                    Ok(())
+                                })
+                        }));
                         return;
                     }
                 }

actix-server/src/builder.rs

@@ -0,0 +1,503 @@
+use std::time::Duration;
+use std::{io, mem, net};
+
+use actix_rt::{spawn, Arbiter, System};
+use futures::future::{lazy, ok};
+use futures::stream::futures_unordered;
+use futures::sync::mpsc::{unbounded, UnboundedReceiver};
+use futures::{Async, Future, Poll, Stream};
+use log::{error, info};
+use net2::TcpBuilder;
+use num_cpus;
+use tokio_tcp::TcpStream;
+use tokio_timer::sleep;
+
+use crate::accept::{AcceptLoop, AcceptNotify, Command};
+use crate::config::{ConfiguredService, ServiceConfig};
+use crate::server::{Server, ServerCommand};
+use crate::services::{InternalServiceFactory, ServiceFactory, StreamNewService};
+use crate::signals::{Signal, Signals};
+use crate::socket::StdListener;
+use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
+use crate::{ssl, Token};
+
+/// Server builder
+pub struct ServerBuilder {
+    threads: usize,
+    token: Token,
+    backlog: i32,
+    workers: Vec<(usize, WorkerClient)>,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    sockets: Vec<(Token, StdListener)>,
+    accept: AcceptLoop,
+    exit: bool,
+    shutdown_timeout: Duration,
+    no_signals: bool,
+    cmd: UnboundedReceiver<ServerCommand>,
+    server: Server,
+}
+
+impl Default for ServerBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ServerBuilder {
+    /// Create new Server builder instance
+    pub fn new() -> ServerBuilder {
+        let (tx, rx) = unbounded();
+        let server = Server::new(tx);
+
+        ServerBuilder {
+            threads: num_cpus::get(),
+            token: Token(0),
+            workers: Vec::new(),
+            services: Vec::new(),
+            sockets: Vec::new(),
+            accept: AcceptLoop::new(server.clone()),
+            backlog: 2048,
+            exit: false,
+            shutdown_timeout: Duration::from_secs(30),
+            no_signals: false,
+            cmd: rx,
+            server,
+        }
+    }
+
+    /// Set number of workers to start.
+    ///
+    /// By default server uses number of available logical cpu as workers
+    /// count.
+    pub fn workers(mut self, num: usize) -> Self {
+        self.threads = num;
+        self
+    }
+
+    /// Set the maximum number of pending connections.
+    ///
+    /// This refers to the number of clients that can be waiting to be served.
+    /// Exceeding this number results in the client getting an error when
+    /// attempting to connect. It should only affect servers under significant
+    /// load.
+    ///
+    /// Generally set in the 64-2048 range. Default value is 2048.
+    ///
+    /// This method should be called before `bind()` method call.
+    pub fn backlog(mut self, num: i32) -> Self {
+        self.backlog = num;
+        self
+    }
+
+    /// Sets the maximum per-worker number of concurrent connections.
+    ///
+    /// All socket listeners will stop accepting connections when this limit is
+    /// reached for each worker.
+    ///
+    /// By default max connections is set to a 25k per worker.
+    pub fn maxconn(self, num: usize) -> Self {
+        worker::max_concurrent_connections(num);
+        self
+    }
+
+    /// Sets the maximum per-worker concurrent connection establish process.
+    ///
+    /// All listeners will stop accepting connections when this limit is reached. It
+    /// can be used to limit the global SSL CPU usage.
+    ///
+    /// By default max connections is set to a 256.
+    pub fn maxconnrate(self, num: usize) -> Self {
+        ssl::max_concurrent_ssl_connect(num);
+        self
+    }
+
+    /// Stop actix system.
+    pub fn system_exit(mut self) -> Self {
+        self.exit = true;
+        self
+    }
+
+    /// Disable signal handling
+    pub fn disable_signals(mut self) -> Self {
+        self.no_signals = true;
+        self
+    }
+
+    /// Timeout for graceful workers shutdown in seconds.
+    ///
+    /// After receiving a stop signal, workers have this much time to finish
+    /// serving requests. Workers still alive after the timeout are force
+    /// dropped.
+    ///
+    /// By default shutdown timeout sets to 30 seconds.
+    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
+        self.shutdown_timeout = Duration::from_secs(sec);
+        self
+    }
+
+    /// Execute external configuration as part of the server building
+    /// process.
+    ///
+    /// This function is useful for moving parts of configuration to a
+    /// different module or even library.
+    pub fn configure<F>(mut self, f: F) -> io::Result<ServerBuilder>
+    where
+        F: Fn(&mut ServiceConfig) -> io::Result<()>,
+    {
+        let mut cfg = ServiceConfig::new(self.threads, self.backlog);
+
+        f(&mut cfg)?;
+
+        if let Some(apply) = cfg.apply {
+            let mut srv = ConfiguredService::new(apply);
+            for (name, lst) in cfg.services {
+                let token = self.token.next();
+                srv.stream(token, name, lst.local_addr()?);
+                self.sockets.push((token, StdListener::Tcp(lst)));
+            }
+            self.services.push(Box::new(srv));
+        }
+        self.threads = cfg.threads;
+
+        Ok(self)
+    }
+
+    /// Add new service to the server.
+    pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
+    where
+        F: ServiceFactory<TcpStream>,
+        U: net::ToSocketAddrs,
+    {
+        let sockets = bind_addr(addr, self.backlog)?;
+
+        for lst in sockets {
+            let token = self.token.next();
+            self.services.push(StreamNewService::create(
+                name.as_ref().to_string(),
+                token,
+                factory.clone(),
+                lst.local_addr()?,
+            ));
+            self.sockets.push((token, StdListener::Tcp(lst)));
+        }
+        Ok(self)
+    }
+
+    #[cfg(all(unix, feature = "uds"))]
+    /// Add new unix domain service to the server.
+    pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
+    where
+        F: ServiceFactory<tokio_uds::UnixStream>,
+        N: AsRef<str>,
+        U: AsRef<std::path::Path>,
+    {
+        use std::os::unix::net::UnixListener;
+
+        // The path must not exist when we try to bind.
+        // Try to remove it to avoid bind error.
+        if let Err(e) = std::fs::remove_file(addr.as_ref()) {
+            // NotFound is expected and not an issue. Anything else is.
+            if e.kind() != std::io::ErrorKind::NotFound {
+                return Err(e);
+            }
+        }
+
+        let lst = UnixListener::bind(addr)?;
+        self.listen_uds(name, lst, factory)
+    }
+
+    #[cfg(all(unix, feature = "uds"))]
+    /// Add new unix domain service to the server.
+    /// Useful when running as a systemd service and
+    /// a socket FD can be acquired using the systemd crate.
+    pub fn listen_uds<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: std::os::unix::net::UnixListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServiceFactory<tokio_uds::UnixStream>,
+    {
+        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+        let token = self.token.next();
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        self.services.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory.clone(),
+            addr,
+        ));
+        self.sockets.push((token, StdListener::Uds(lst)));
+        Ok(self)
+    }
+
+    /// Add new service to the server.
+    pub fn listen<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: net::TcpListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServiceFactory<TcpStream>,
+    {
+        let token = self.token.next();
+        self.services.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+            lst.local_addr()?,
+        ));
+        self.sockets.push((token, StdListener::Tcp(lst)));
+        Ok(self)
+    }
+
+    /// Spawn new thread and start listening for incoming connections.
+    ///
+    /// This method spawns new thread and starts new actix system. Other than
+    /// that it is similar to `start()` method. This method blocks.
+    ///
+    /// This methods panics if no socket addresses get bound.
+    ///
+    /// ```rust,ignore
+    /// use actix_web::*;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     Server::new().
+    ///         .service(
+    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
+    ///                .bind("127.0.0.1:0")
+    ///         .run()
+    /// }
+    /// ```
+    pub fn run(self) -> io::Result<()> {
+        let sys = System::new("http-server");
+        self.start();
+        sys.run()
+    }
+
+    /// Starts processing incoming connections and return server controller.
+    pub fn start(mut self) -> Server {
+        if self.sockets.is_empty() {
+            panic!("Server should have at least one bound socket");
+        } else {
+            info!("Starting {} workers", self.threads);
+
+            // start workers
+            let mut workers = Vec::new();
+            for idx in 0..self.threads {
+                let worker = self.start_worker(idx, self.accept.get_notify());
+                workers.push(worker.clone());
+                self.workers.push((idx, worker));
+            }
+
+            // start accept thread
+            for sock in &self.sockets {
+                info!("Starting server on {}", sock.1);
+            }
+            self.accept
+                .start(mem::replace(&mut self.sockets, Vec::new()), workers);
+
+            // handle signals
+            if !self.no_signals {
+                Signals::start(self.server.clone());
+            }
+
+            // start http server actor
+            let server = self.server.clone();
+            spawn(self);
+            server
+        }
+    }
+
+    fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
+        let (tx1, rx1) = unbounded();
+        let (tx2, rx2) = unbounded();
+        let timeout = self.shutdown_timeout;
+        let avail = WorkerAvailability::new(notify);
+        let worker = WorkerClient::new(idx, tx1, tx2, avail.clone());
+        let services: Vec<Box<dyn InternalServiceFactory>> =
+            self.services.iter().map(|v| v.clone_factory()).collect();
+
+        Arbiter::new().send(lazy(move || {
+            Worker::start(rx1, rx2, services, avail, timeout);
+            Ok::<_, ()>(())
+        }));
+
+        worker
+    }
+
+    fn handle_cmd(&mut self, item: ServerCommand) {
+        match item {
+            ServerCommand::Pause(tx) => {
+                self.accept.send(Command::Pause);
+                let _ = tx.send(());
+            }
+            ServerCommand::Resume(tx) => {
+                self.accept.send(Command::Resume);
+                let _ = tx.send(());
+            }
+            ServerCommand::Signal(sig) => {
+                // Signals support
+                // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
+                match sig {
+                    Signal::Int => {
+                        info!("SIGINT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    Signal::Term => {
+                        info!("SIGTERM received, stopping");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: true,
+                            completion: None,
+                        })
+                    }
+                    Signal::Quit => {
+                        info!("SIGQUIT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    _ => (),
+                }
+            }
+            ServerCommand::Stop {
+                graceful,
+                completion,
+            } => {
+                let exit = self.exit;
+
+                // stop accept thread
+                self.accept.send(Command::Stop);
+
+                // stop workers
+                if !self.workers.is_empty() && graceful {
+                    spawn(
+                        futures_unordered(
+                            self.workers
+                                .iter()
+                                .map(move |worker| worker.1.stop(graceful)),
+                        )
+                        .collect()
+                        .then(move |_| {
+                            if let Some(tx) = completion {
+                                let _ = tx.send(());
+                            }
+                            if exit {
+                                spawn(sleep(Duration::from_millis(300)).then(|_| {
+                                    System::current().stop();
+                                    ok(())
+                                }));
+                            }
+                            ok(())
+                        }),
+                    )
+                } else {
+                    // we need to stop system if server was spawned
+                    if self.exit {
+                        spawn(sleep(Duration::from_millis(300)).then(|_| {
+                            System::current().stop();
+                            ok(())
+                        }));
+                    }
+                    if let Some(tx) = completion {
+                        let _ = tx.send(());
+                    }
+                }
+            }
+            ServerCommand::WorkerDied(idx) => {
+                let mut found = false;
+                for i in 0..self.workers.len() {
+                    if self.workers[i].0 == idx {
+                        self.workers.swap_remove(i);
+                        found = true;
+                        break;
+                    }
+                }
+
+                if found {
+                    error!("Worker has died {:?}, restarting", idx);
+
+                    let mut new_idx = self.workers.len();
+                    'found: loop {
+                        for i in 0..self.workers.len() {
+                            if self.workers[i].0 == new_idx {
+                                new_idx += 1;
+                                continue 'found;
+                            }
+                        }
+                        break;
+                    }
+
+                    let worker = self.start_worker(new_idx, self.accept.get_notify());
+                    self.workers.push((new_idx, worker.clone()));
+                    self.accept.send(Command::Worker(worker));
+                }
+            }
+        }
+    }
+}
+
+impl Future for ServerBuilder {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            match self.cmd.poll() {
+                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+                Ok(Async::Ready(Some(item))) => self.handle_cmd(item),
+            }
+        }
+    }
+}
+
+pub(super) fn bind_addr<S: net::ToSocketAddrs>(
+    addr: S,
+    backlog: i32,
+) -> io::Result<Vec<net::TcpListener>> {
+    let mut err = None;
+    let mut succ = false;
+    let mut sockets = Vec::new();
+    for addr in addr.to_socket_addrs()? {
+        match create_tcp_listener(addr, backlog) {
+            Ok(lst) => {
+                succ = true;
+                sockets.push(lst);
+            }
+            Err(e) => err = Some(e),
+        }
+    }
+
+    if !succ {
+        if let Some(e) = err.take() {
+            Err(e)
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Can not bind to address.",
+            ))
+        }
+    } else {
+        Ok(sockets)
+    }
+}
+
+fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
+    let builder = match addr {
+        net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
+        net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
+    };
+    builder.reuse_address(true)?;
+    builder.bind(addr)?;
+    Ok(builder.listen(backlog)?)
+}

actix-server/src/config.rs

@@ -0,0 +1,276 @@
+use std::collections::HashMap;
+use std::{fmt, io, net};
+
+use actix_server_config::{Io, ServerConfig};
+use actix_service::{IntoNewService, NewService};
+use futures::future::{join_all, Future};
+use log::error;
+use tokio_tcp::TcpStream;
+
+use crate::counter::CounterGuard;
+
+use super::builder::bind_addr;
+use super::services::{
+    BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
+};
+use super::Token;
+
+pub struct ServiceConfig {
+    pub(crate) services: Vec<(String, net::TcpListener)>,
+    pub(crate) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
+    pub(crate) threads: usize,
+    pub(crate) backlog: i32,
+}
+
+impl ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
+        ServiceConfig {
+            threads,
+            backlog,
+            services: Vec::new(),
+            apply: None,
+        }
+    }
+
+    /// Set number of workers to start.
+    ///
+    /// By default server uses number of available logical cpu as workers
+    /// count.
+    pub fn workers(&mut self, num: usize) {
+        self.threads = num;
+    }
+
+    /// Add new service to server
+    pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
+    where
+        U: net::ToSocketAddrs,
+    {
+        let sockets = bind_addr(addr, self.backlog)?;
+
+        for lst in sockets {
+            self.listen(name.as_ref(), lst);
+        }
+
+        Ok(self)
+    }
+
+    /// Add new service to server
+    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
+        if self.apply.is_none() {
+            self.apply = Some(Box::new(not_configured));
+        }
+        self.services.push((name.as_ref().to_string(), lst));
+        self
+    }
+
+    /// Register service configuration function. This function get called
+    /// during worker runtime configuration. It get executed in worker thread.
+    pub fn apply<F>(&mut self, f: F) -> io::Result<()>
+    where
+        F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
+    {
+        self.apply = Some(Box::new(f));
+        Ok(())
+    }
+}
+
+pub(super) struct ConfiguredService {
+    rt: Box<dyn ServiceRuntimeConfiguration>,
+    names: HashMap<Token, (String, net::SocketAddr)>,
+    services: HashMap<String, Token>,
+}
+
+impl ConfiguredService {
+    pub(super) fn new(rt: Box<dyn ServiceRuntimeConfiguration>) -> Self {
+        ConfiguredService {
+            rt,
+            names: HashMap::new(),
+            services: HashMap::new(),
+        }
+    }
+
+    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
+        self.names.insert(token, (name.clone(), addr));
+        self.services.insert(name, token);
+    }
+}
+
+impl InternalServiceFactory for ConfiguredService {
+    fn name(&self, token: Token) -> &str {
+        &self.names[&token].0
+    }
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            rt: self.rt.clone(),
+            names: self.names.clone(),
+            services: self.services.clone(),
+        })
+    }
+
+    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        // configure services
+        let mut rt = ServiceRuntime::new(self.services.clone());
+        self.rt.configure(&mut rt);
+        rt.validate();
+
+        let services = rt.services;
+
+        // on start futures
+        if rt.onstart.is_empty() {
+            // construct services
+            let mut fut = Vec::new();
+            for (token, ns) in services {
+                let config = ServerConfig::new(self.names[&token].1);
+                fut.push(ns.new_service(&config).map(move |service| (token, service)));
+            }
+
+            Box::new(join_all(fut).map_err(|e| {
+                error!("Can not construct service: {:?}", e);
+            }))
+        } else {
+            let names = self.names.clone();
+
+            // run onstart future and then construct services
+            Box::new(
+                join_all(rt.onstart)
+                    .map_err(|e| {
+                        error!("Can not construct service: {:?}", e);
+                    })
+                    .and_then(move |_| {
+                        // construct services
+                        let mut fut = Vec::new();
+                        for (token, ns) in services {
+                            let config = ServerConfig::new(names[&token].1);
+                            fut.push(
+                                ns.new_service(&config).map(move |service| (token, service)),
+                            );
+                        }
+                        join_all(fut).map_err(|e| {
+                            error!("Can not construct service: {:?}", e);
+                        })
+                    }),
+            )
+        }
+    }
+}
+
+pub(super) trait ServiceRuntimeConfiguration: Send {
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration>;
+
+    fn configure(&self, rt: &mut ServiceRuntime);
+}
+
+impl<F> ServiceRuntimeConfiguration for F
+where
+    F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
+{
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration> {
+        Box::new(self.clone())
+    }
+
+    fn configure(&self, rt: &mut ServiceRuntime) {
+        (self)(rt)
+    }
+}
+
+fn not_configured(_: &mut ServiceRuntime) {
+    error!("Service is not configured");
+}
+
+pub struct ServiceRuntime {
+    names: HashMap<String, Token>,
+    services: HashMap<Token, BoxedNewService>,
+    onstart: Vec<Box<dyn Future<Item = (), Error = ()>>>,
+}
+
+impl ServiceRuntime {
+    fn new(names: HashMap<String, Token>) -> Self {
+        ServiceRuntime {
+            names,
+            services: HashMap::new(),
+            onstart: Vec::new(),
+        }
+    }
+
+    fn validate(&self) {
+        for (name, token) in &self.names {
+            if !self.services.contains_key(&token) {
+                error!("Service {:?} is not configured", name);
+            }
+        }
+    }
+
+    /// Register service.
+    ///
+    /// Name of the service must be registered during configuration stage with
+    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
+    pub fn service<T, F>(&mut self, name: &str, service: F)
+    where
+        F: IntoNewService<T>,
+        T: NewService<Config = ServerConfig, Request = Io<TcpStream>> + 'static,
+        T::Future: 'static,
+        T::Service: 'static,
+        T::InitError: fmt::Debug,
+    {
+        // let name = name.to_owned();
+        if let Some(token) = self.names.get(name) {
+            self.services.insert(
+                token.clone(),
+                Box::new(ServiceFactory {
+                    inner: service.into_new_service(),
+                }),
+            );
+        } else {
+            panic!("Unknown service: {:?}", name);
+        }
+    }
+
+    /// Execute future before services initialization.
+    pub fn on_start<F>(&mut self, fut: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.onstart.push(Box::new(fut))
+    }
+}
+
+type BoxedNewService = Box<
+    dyn NewService<
+        Request = (Option<CounterGuard>, ServerMessage),
+        Response = (),
+        Error = (),
+        InitError = (),
+        Config = ServerConfig,
+        Service = BoxedServerService,
+        Future = Box<dyn Future<Item = BoxedServerService, Error = ()>>,
+    >,
+>;
+
+struct ServiceFactory<T> {
+    inner: T,
+}
+
+impl<T> NewService for ServiceFactory<T>
+where
+    T: NewService<Config = ServerConfig, Request = Io<TcpStream>>,
+    T::Future: 'static,
+    T::Service: 'static,
+    T::Error: 'static,
+    T::InitError: fmt::Debug + 'static,
+{
+    type Request = (Option<CounterGuard>, ServerMessage);
+    type Response = ();
+    type Error = ();
+    type InitError = ();
+    type Config = ServerConfig;
+    type Service = BoxedServerService;
+    type Future = Box<dyn Future<Item = BoxedServerService, Error = ()>>;
+
+    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
+        Box::new(self.inner.new_service(cfg).map_err(|_| ()).map(|s| {
+            let service: BoxedServerService = Box::new(StreamService::new(s));
+            service
+        }))
+    }
+}

actix-server/src/counter.rs

@@ -0,0 +1,80 @@
+use std::cell::Cell;
+use std::rc::Rc;
+
+use futures::task::AtomicTask;
+
+#[derive(Clone)]
+/// Simple counter with ability to notify task on reaching specific number
+///
+/// Counter could be cloned, total ncount is shared across all clones.
+pub struct Counter(Rc<CounterInner>);
+
+#[derive(Debug)]
+struct CounterInner {
+    count: Cell<usize>,
+    capacity: usize,
+    task: AtomicTask,
+}
+
+impl Counter {
+    /// Create `Counter` instance and set max value.
+    pub fn new(capacity: usize) -> Self {
+        Counter(Rc::new(CounterInner {
+            capacity,
+            count: Cell::new(0),
+            task: AtomicTask::new(),
+        }))
+    }
+
+    pub fn get(&self) -> CounterGuard {
+        CounterGuard::new(self.0.clone())
+    }
+
+    /// Check if counter is not at capacity
+    pub fn available(&self) -> bool {
+        self.0.available()
+    }
+
+    /// Get total number of acquired counts
+    pub fn total(&self) -> usize {
+        self.0.count.get()
+    }
+}
+
+#[derive(Debug)]
+pub struct CounterGuard(Rc<CounterInner>);
+
+impl CounterGuard {
+    fn new(inner: Rc<CounterInner>) -> Self {
+        inner.inc();
+        CounterGuard(inner)
+    }
+}
+
+impl Drop for CounterGuard {
+    fn drop(&mut self) {
+        self.0.dec();
+    }
+}
+
+impl CounterInner {
+    fn inc(&self) {
+        self.count.set(self.count.get() + 1);
+    }
+
+    fn dec(&self) {
+        let num = self.count.get();
+        self.count.set(num - 1);
+        if num == self.capacity {
+            self.task.notify();
+        }
+    }
+
+    fn available(&self) -> bool {
+        let avail = self.count.get() < self.capacity;
+        if !avail {
+            self.task.register();
+        }
+        avail
+    }
+}

actix-server/src/lib.rs

@@ -0,0 +1,42 @@
+//! General purpose tcp server
+
+mod accept;
+mod builder;
+mod config;
+mod counter;
+mod server;
+mod services;
+mod signals;
+mod socket;
+pub mod ssl;
+mod worker;
+
+pub use actix_server_config::{Io, IoStream, Protocol, ServerConfig};
+
+pub use self::builder::ServerBuilder;
+pub use self::config::{ServiceConfig, ServiceRuntime};
+pub use self::server::Server;
+pub use self::services::ServiceFactory;
+
+#[doc(hidden)]
+pub use self::socket::FromStream;
+
+#[doc(hidden)]
+pub use self::services::ServiceFactory as StreamServiceFactory;
+
+/// Socket id token
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct Token(usize);
+
+impl Token {
+    pub(crate) fn next(&mut self) -> Token {
+        let token = Token(self.0 + 1);
+        self.0 += 1;
+        token
+    }
+}
+
+/// Start server building process
+pub fn new() -> ServerBuilder {
+    ServerBuilder::default()
+}

actix-server/src/server.rs

@@ -0,0 +1,70 @@
+use futures::sync::mpsc::UnboundedSender;
+use futures::sync::oneshot;
+use futures::Future;
+
+use crate::builder::ServerBuilder;
+use crate::signals::Signal;
+
+#[derive(Debug)]
+pub(crate) enum ServerCommand {
+    WorkerDied(usize),
+    Pause(oneshot::Sender<()>),
+    Resume(oneshot::Sender<()>),
+    Signal(Signal),
+    /// Whether to try and shut down gracefully
+    Stop {
+        graceful: bool,
+        completion: Option<oneshot::Sender<()>>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct Server(UnboundedSender<ServerCommand>);
+
+impl Server {
+    pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
+        Server(tx)
+    }
+
+    /// Start server building process
+    pub fn build() -> ServerBuilder {
+        ServerBuilder::default()
+    }
+
+    pub(crate) fn signal(&self, sig: Signal) {
+        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+    }
+
+    pub(crate) fn worker_died(&self, idx: usize) {
+        let _ = self.0.unbounded_send(ServerCommand::WorkerDied(idx));
+    }
+
+    /// Pause accepting incoming connections
+    ///
+    /// If socket contains some pending connection, they might be dropped.
+    /// All opened connection remains active.
+    pub fn pause(&self) -> impl Future<Item = (), Error = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
+        rx.map_err(|_| ())
+    }
+
+    /// Resume accepting incoming connections
+    pub fn resume(&self) -> impl Future<Item = (), Error = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
+        rx.map_err(|_| ())
+    }
+
+    /// Stop incoming connection processing, stop all workers and exit.
+    ///
+    /// If server starts with `spawn()` method, then spawned thread get terminated.
+    pub fn stop(&self, graceful: bool) -> impl Future<Item = (), Error = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Stop {
+            graceful,
+            completion: Some(tx),
+        });
+        rx.map_err(|_| ())
+    }
+}

actix-server/src/services.rs

@@ -0,0 +1,186 @@
+use std::marker::PhantomData;
+use std::net::SocketAddr;
+use std::time::Duration;
+
+use actix_rt::spawn;
+use actix_server_config::{Io, ServerConfig};
+use actix_service::{NewService, Service};
+use futures::future::{err, ok, FutureResult};
+use futures::{Future, Poll};
+use log::error;
+
+use super::Token;
+use crate::counter::CounterGuard;
+use crate::socket::{FromStream, StdStream};
+
+/// Server message
+pub(crate) enum ServerMessage {
+    /// New stream
+    Connect(StdStream),
+    /// Gracefull shutdown
+    Shutdown(Duration),
+    /// Force shutdown
+    ForceShutdown,
+}
+
+pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
+    type NewService: NewService<Config = ServerConfig, Request = Io<Stream>>;
+
+    fn create(&self) -> Self::NewService;
+}
+
+pub(crate) trait InternalServiceFactory: Send {
+    fn name(&self, token: Token) -> &str;
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
+
+    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>;
+}
+
+pub(crate) type BoxedServerService = Box<
+    dyn Service<
+        Request = (Option<CounterGuard>, ServerMessage),
+        Response = (),
+        Error = (),
+        Future = FutureResult<(), ()>,
+    >,
+>;
+
+pub(crate) struct StreamService<T> {
+    service: T,
+}
+
+impl<T> StreamService<T> {
+    pub(crate) fn new(service: T) -> Self {
+        StreamService { service }
+    }
+}
+
+impl<T, I> Service for StreamService<T>
+where
+    T: Service<Request = Io<I>>,
+    T::Future: 'static,
+    T::Error: 'static,
+    I: FromStream,
+{
+    type Request = (Option<CounterGuard>, ServerMessage);
+    type Response = ();
+    type Error = ();
+    type Future = FutureResult<(), ()>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.poll_ready().map_err(|_| ())
+    }
+
+    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
+        match req {
+            ServerMessage::Connect(stream) => {
+                let stream = FromStream::from_stdstream(stream).map_err(|e| {
+                    error!("Can not convert to an async tcp stream: {}", e);
+                });
+
+                if let Ok(stream) = stream {
+                    spawn(self.service.call(Io::new(stream)).then(move |res| {
+                        drop(guard);
+                        res.map_err(|_| ()).map(|_| ())
+                    }));
+                    ok(())
+                } else {
+                    err(())
+                }
+            }
+            _ => ok(()),
+        }
+    }
+}
+
+pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
+    name: String,
+    inner: F,
+    token: Token,
+    addr: SocketAddr,
+    _t: PhantomData<Io>,
+}
+
+impl<F, Io> StreamNewService<F, Io>
+where
+    F: ServiceFactory<Io>,
+    Io: FromStream + Send + 'static,
+{
+    pub(crate) fn create(
+        name: String,
+        token: Token,
+        inner: F,
+        addr: SocketAddr,
+    ) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            name,
+            token,
+            inner,
+            addr,
+            _t: PhantomData,
+        })
+    }
+}
+
+impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
+where
+    F: ServiceFactory<Io>,
+    Io: FromStream + Send + 'static,
+{
+    fn name(&self, _: Token) -> &str {
+        &self.name
+    }
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            name: self.name.clone(),
+            inner: self.inner.clone(),
+            token: self.token,
+            addr: self.addr,
+            _t: PhantomData,
+        })
+    }
+
+    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        let token = self.token;
+        let config = ServerConfig::new(self.addr);
+        Box::new(
+            self.inner
+                .create()
+                .new_service(&config)
+                .map_err(|_| ())
+                .map(move |inner| {
+                    let service: BoxedServerService = Box::new(StreamService::new(inner));
+                    vec![(token, service)]
+                }),
+        )
+    }
+}
+
+impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
+    fn name(&self, token: Token) -> &str {
+        self.as_ref().name(token)
+    }
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
+        self.as_ref().clone_factory()
+    }
+
+    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        self.as_ref().create()
+    }
+}
+
+impl<F, T, I> ServiceFactory<I> for F
+where
+    F: Fn() -> T + Send + Clone + 'static,
+    T: NewService<Config = ServerConfig, Request = Io<I>>,
+    I: FromStream,
+{
+    type NewService = T;
+
+    fn create(&self) -> T {
+        (self)()
+    }
+}

actix-server/src/signals.rs

@@ -0,0 +1,118 @@
+use std::io;
+
+use actix_rt::spawn;
+use futures::stream::futures_unordered;
+use futures::{Async, Future, Poll, Stream};
+
+use crate::server::Server;
+
+/// Different types of process signals
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub(crate) enum Signal {
+    /// SIGHUP
+    Hup,
+    /// SIGINT
+    Int,
+    /// SIGTERM
+    Term,
+    /// SIGQUIT
+    Quit,
+}
+
+pub(crate) struct Signals {
+    srv: Server,
+    #[cfg(not(unix))]
+    stream: SigStream,
+    #[cfg(unix)]
+    streams: Vec<SigStream>,
+}
+
+type SigStream = Box<dyn Stream<Item = Signal, Error = io::Error>>;
+
+impl Signals {
+    pub(crate) fn start(srv: Server) {
+        let fut = {
+            #[cfg(not(unix))]
+            {
+                tokio_signal::ctrl_c()
+                    .map_err(|_| ())
+                    .and_then(move |stream| Signals {
+                        srv,
+                        stream: Box::new(stream.map(|_| Signal::Int)),
+                    })
+            }
+
+            #[cfg(unix)]
+            {
+                use tokio_signal::unix;
+
+                let mut sigs: Vec<Box<dyn Future<Item = SigStream, Error = io::Error>>> =
+                    Vec::new();
+                sigs.push(Box::new(
+                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGINT).map(|stream| {
+                        let s: SigStream = Box::new(stream.map(|_| Signal::Int));
+                        s
+                    }),
+                ));
+                sigs.push(Box::new(
+                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGHUP).map(
+                        |stream: unix::Signal| {
+                            let s: SigStream = Box::new(stream.map(|_| Signal::Hup));
+                            s
+                        },
+                    ),
+                ));
+                sigs.push(Box::new(
+                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGTERM).map(
+                        |stream| {
+                            let s: SigStream = Box::new(stream.map(|_| Signal::Term));
+                            s
+                        },
+                    ),
+                ));
+                sigs.push(Box::new(
+                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGQUIT).map(
+                        |stream| {
+                            let s: SigStream = Box::new(stream.map(|_| Signal::Quit));
+                            s
+                        },
+                    ),
+                ));
+                futures_unordered(sigs)
+                    .collect()
+                    .map_err(|_| ())
+                    .and_then(move |streams| Signals { srv, streams })
+            }
+        };
+        spawn(fut);
+    }
+}
+
+impl Future for Signals {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        #[cfg(not(unix))]
+        loop {
+            match self.stream.poll() {
+                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                Ok(Async::Ready(Some(sig))) => self.srv.signal(sig),
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+            }
+        }
+        #[cfg(unix)]
+        {
+            for s in &mut self.streams {
+                loop {
+                    match s.poll() {
+                        Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                        Ok(Async::NotReady) => break,
+                        Ok(Async::Ready(Some(sig))) => self.srv.signal(sig),
+                    }
+                }
+            }
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-server/src/socket.rs

@@ -0,0 +1,173 @@
+use std::{fmt, io, net};
+
+use tokio_io::{AsyncRead, AsyncWrite};
+use tokio_reactor::Handle;
+use tokio_tcp::TcpStream;
+
+pub(crate) enum StdListener {
+    Tcp(net::TcpListener),
+    #[cfg(all(unix, feature = "uds"))]
+    Uds(std::os::unix::net::UnixListener),
+}
+
+pub(crate) enum SocketAddr {
+    Tcp(net::SocketAddr),
+    #[cfg(all(unix, feature = "uds"))]
+    Uds(std::os::unix::net::SocketAddr),
+}
+
+impl fmt::Display for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            SocketAddr::Tcp(ref addr) => write!(f, "{}", addr),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+impl fmt::Debug for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            SocketAddr::Tcp(ref addr) => write!(f, "{:?}", addr),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+impl fmt::Display for StdListener {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            StdListener::Tcp(ref lst) => write!(f, "{}", lst.local_addr().ok().unwrap()),
+            #[cfg(all(unix, feature = "uds"))]
+            StdListener::Uds(ref lst) => write!(f, "{:?}", lst.local_addr().ok().unwrap()),
+        }
+    }
+}
+
+impl StdListener {
+    pub(crate) fn local_addr(&self) -> SocketAddr {
+        match self {
+            StdListener::Tcp(lst) => SocketAddr::Tcp(lst.local_addr().unwrap()),
+            #[cfg(all(unix, feature = "uds"))]
+            StdListener::Uds(lst) => SocketAddr::Uds(lst.local_addr().unwrap()),
+        }
+    }
+
+    pub(crate) fn into_listener(self) -> SocketListener {
+        match self {
+            StdListener::Tcp(lst) => SocketListener::Tcp(
+                mio::net::TcpListener::from_std(lst)
+                    .expect("Can not create mio::net::TcpListener"),
+            ),
+            #[cfg(all(unix, feature = "uds"))]
+            StdListener::Uds(lst) => SocketListener::Uds(
+                mio_uds::UnixListener::from_listener(lst)
+                    .expect("Can not create mio_uds::UnixListener"),
+            ),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum StdStream {
+    Tcp(std::net::TcpStream),
+    #[cfg(all(unix, feature = "uds"))]
+    Uds(std::os::unix::net::UnixStream),
+}
+
+pub(crate) enum SocketListener {
+    Tcp(mio::net::TcpListener),
+    #[cfg(all(unix, feature = "uds"))]
+    Uds(mio_uds::UnixListener),
+}
+
+impl SocketListener {
+    pub(crate) fn accept(&self) -> io::Result<Option<(StdStream, SocketAddr)>> {
+        match *self {
+            SocketListener::Tcp(ref lst) => lst
+                .accept_std()
+                .map(|(stream, addr)| Some((StdStream::Tcp(stream), SocketAddr::Tcp(addr)))),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketListener::Uds(ref lst) => lst.accept_std().map(|res| {
+                res.map(|(stream, addr)| (StdStream::Uds(stream), SocketAddr::Uds(addr)))
+            }),
+        }
+    }
+}
+
+impl mio::Evented for SocketListener {
+    fn register(
+        &self,
+        poll: &mio::Poll,
+        token: mio::Token,
+        interest: mio::Ready,
+        opts: mio::PollOpt,
+    ) -> io::Result<()> {
+        match *self {
+            SocketListener::Tcp(ref lst) => lst.register(poll, token, interest, opts),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketListener::Uds(ref lst) => lst.register(poll, token, interest, opts),
+        }
+    }
+
+    fn reregister(
+        &self,
+        poll: &mio::Poll,
+        token: mio::Token,
+        interest: mio::Ready,
+        opts: mio::PollOpt,
+    ) -> io::Result<()> {
+        match *self {
+            SocketListener::Tcp(ref lst) => lst.reregister(poll, token, interest, opts),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketListener::Uds(ref lst) => lst.reregister(poll, token, interest, opts),
+        }
+    }
+    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
+        match *self {
+            SocketListener::Tcp(ref lst) => lst.deregister(poll),
+            #[cfg(all(unix, feature = "uds"))]
+            SocketListener::Uds(ref lst) => {
+                let res = lst.deregister(poll);
+
+                // cleanup file path
+                if let Ok(addr) = lst.local_addr() {
+                    if let Some(path) = addr.as_pathname() {
+                        let _ = std::fs::remove_file(path);
+                    }
+                }
+                res
+            }
+        }
+    }
+}
+
+pub trait FromStream: AsyncRead + AsyncWrite + Sized {
+    fn from_stdstream(sock: StdStream) -> io::Result<Self>;
+}
+
+impl FromStream for TcpStream {
+    fn from_stdstream(sock: StdStream) -> io::Result<Self> {
+        match sock {
+            StdStream::Tcp(stream) => TcpStream::from_std(stream, &Handle::default()),
+            #[cfg(all(unix, feature = "uds"))]
+            StdStream::Uds(_) => {
+                panic!("Should not happen, bug in server impl");
+            }
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "uds"))]
+impl FromStream for tokio_uds::UnixStream {
+    fn from_stdstream(sock: StdStream) -> io::Result<Self> {
+        match sock {
+            StdStream::Tcp(_) => panic!("Should not happen, bug in server impl"),
+            StdStream::Uds(stream) => {
+                tokio_uds::UnixStream::from_std(stream, &Handle::default())
+            }
+        }
+    }
+}

actix-server/src/ssl/mod.rs

@@ -1,12 +1,12 @@
 //! SSL Services
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use super::counter::Counter;
+use crate::counter::Counter;
 
 #[cfg(feature = "ssl")]
 mod openssl;
 #[cfg(feature = "ssl")]
-pub use self::openssl::{OpensslAcceptor, OpensslConnector};
+pub use self::openssl::OpensslAcceptor;
 
 #[cfg(feature = "tls")]
 mod nativetls;
@@ -28,8 +28,15 @@ pub fn max_concurrent_ssl_connect(num: usize) {
     MAX_CONN.store(num, Ordering::Relaxed);
 }
 
-pub(crate) const MAX_CONN: AtomicUsize = AtomicUsize::new(256);
+pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256);
 
 thread_local! {
     static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed));
 }
+
+/// Ssl error combinded with service error.
+#[derive(Debug)]
+pub enum SslError<E1, E2> {
+    Ssl(E1),
+    Service(E2),
+}

actix-server/src/ssl/nativetls.rs

@@ -6,28 +6,29 @@ use futures::{future::ok, future::FutureResult, Async, Future, Poll};
 use native_tls::{self, Error, HandshakeError, TlsAcceptor};
 use tokio_io::{AsyncRead, AsyncWrite};
 
-use super::MAX_CONN_COUNTER;
 use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig};
 
 /// Support `SSL` connections via native-tls package
 ///
 /// `tls` feature enables `NativeTlsAcceptor` type
-pub struct NativeTlsAcceptor<T> {
+pub struct NativeTlsAcceptor<T, P = ()> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> NativeTlsAcceptor<T, P> {
     /// Create `NativeTlsAcceptor` instance
     pub fn new(acceptor: TlsAcceptor) -> Self {
         NativeTlsAcceptor {
-            acceptor: acceptor.into(),
+            acceptor,
             io: PhantomData,
         }
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> Clone for NativeTlsAcceptor<T, P> {
     fn clone(&self) -> Self {
         Self {
             acceptor: self.acceptor.clone(),
@@ -36,14 +37,19 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
-    type Response = TlsStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> NewService for NativeTlsAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = Error;
-    type Service = NativeTlsAcceptorService<T>;
+
+    type Config = ServerConfig;
+    type Service = NativeTlsAcceptorService<T, P>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
+        cfg.set_secure();
+
         MAX_CONN_COUNTER.with(|conns| {
             ok(NativeTlsAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -54,16 +60,17 @@ impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
     }
 }
 
-pub struct NativeTlsAcceptorService<T> {
+pub struct NativeTlsAcceptorService<T, P> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
-    type Response = TlsStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> Service for NativeTlsAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = Error;
-    type Future = Accept<T>;
+    type Future = Accept<T, P>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         if self.conns.available() {
@@ -73,10 +80,12 @@ impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
         Accept {
             _guard: self.conns.get(),
-            inner: Some(self.acceptor.accept(req)),
+            inner: Some(self.acceptor.accept(io)),
+            params: Some(params),
         }
     }
 }
@@ -95,21 +104,30 @@ pub struct TlsStream<S> {
 
 /// Future returned from `NativeTlsAcceptor::accept` which will resolve
 /// once the accept handshake has finished.
-pub struct Accept<S> {
+pub struct Accept<S, P> {
     inner: Option<Result<native_tls::TlsStream<S>, HandshakeError<S>>>,
+    params: Option<P>,
     _guard: CounterGuard,
 }
 
-impl<Io: AsyncRead + AsyncWrite> Future for Accept<Io> {
-    type Item = TlsStream<Io>;
+impl<T: AsyncRead + AsyncWrite, P> Future for Accept<T, P> {
+    type Item = Io<TlsStream<T>, P>;
     type Error = Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         match self.inner.take().expect("cannot poll MidHandshake twice") {
-            Ok(stream) => Ok(TlsStream { inner: stream }.into()),
+            Ok(stream) => Ok(Async::Ready(Io::from_parts(
+                TlsStream { inner: stream },
+                self.params.take().unwrap(),
+                Protocol::Unknown,
+            ))),
             Err(HandshakeError::Failure(e)) => Err(e),
             Err(HandshakeError::WouldBlock(s)) => match s.handshake() {
-                Ok(stream) => Ok(TlsStream { inner: stream }.into()),
+                Ok(stream) => Ok(Async::Ready(Io::from_parts(
+                    TlsStream { inner: stream },
+                    self.params.take().unwrap(),
+                    Protocol::Unknown,
+                ))),
                 Err(HandshakeError::Failure(e)) => Err(e),
                 Err(HandshakeError::WouldBlock(s)) => {
                     self.inner = Some(Err(HandshakeError::WouldBlock(s)));

actix-server/src/ssl/openssl.rs

@@ -0,0 +1,130 @@
+use std::marker::PhantomData;
+
+use actix_service::{NewService, Service};
+use futures::{future::ok, future::FutureResult, Async, Future, Poll};
+use openssl::ssl::{HandshakeError, SslAcceptor};
+use tokio_io::{AsyncRead, AsyncWrite};
+use tokio_openssl::{AcceptAsync, SslAcceptorExt, SslStream};
+
+use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig};
+
+/// Support `SSL` connections via openssl package
+///
+/// `ssl` feature enables `OpensslAcceptor` type
+pub struct OpensslAcceptor<T: AsyncRead + AsyncWrite, P = ()> {
+    acceptor: SslAcceptor,
+    io: PhantomData<(T, P)>,
+}
+
+impl<T: AsyncRead + AsyncWrite, P> OpensslAcceptor<T, P> {
+    /// Create default `OpensslAcceptor`
+    pub fn new(acceptor: SslAcceptor) -> Self {
+        OpensslAcceptor {
+            acceptor,
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite, P> Clone for OpensslAcceptor<T, P> {
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite, P> NewService for OpensslAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<SslStream<T>, P>;
+    type Error = HandshakeError<T>;
+    type Config = ServerConfig;
+    type Service = OpensslAcceptorService<T, P>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
+        cfg.set_secure();
+
+        MAX_CONN_COUNTER.with(|conns| {
+            ok(OpensslAcceptorService {
+                acceptor: self.acceptor.clone(),
+                conns: conns.clone(),
+                io: PhantomData,
+            })
+        })
+    }
+}
+
+pub struct OpensslAcceptorService<T, P> {
+    acceptor: SslAcceptor,
+    conns: Counter,
+    io: PhantomData<(T, P)>,
+}
+
+impl<T: AsyncRead + AsyncWrite, P> Service for OpensslAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<SslStream<T>, P>;
+    type Error = HandshakeError<T>;
+    type Future = OpensslAcceptorServiceFut<T, P>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        if self.conns.available() {
+            Ok(Async::Ready(()))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
+        OpensslAcceptorServiceFut {
+            _guard: self.conns.get(),
+            fut: SslAcceptorExt::accept_async(&self.acceptor, io),
+            params: Some(params),
+        }
+    }
+}
+
+pub struct OpensslAcceptorServiceFut<T, P>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    fut: AcceptAsync<T>,
+    params: Option<P>,
+    _guard: CounterGuard,
+}
+
+impl<T: AsyncRead + AsyncWrite, P> Future for OpensslAcceptorServiceFut<T, P> {
+    type Item = Io<SslStream<T>, P>;
+    type Error = HandshakeError<T>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let io = futures::try_ready!(self.fut.poll());
+        let proto = if let Some(protos) = io.get_ref().ssl().selected_alpn_protocol() {
+            const H2: &[u8] = b"\x02h2";
+            const HTTP10: &[u8] = b"\x08http/1.0";
+            const HTTP11: &[u8] = b"\x08http/1.1";
+
+            if protos.windows(3).any(|window| window == H2) {
+                Protocol::Http2
+            } else if protos.windows(9).any(|window| window == HTTP11) {
+                Protocol::Http11
+            } else if protos.windows(9).any(|window| window == HTTP10) {
+                Protocol::Http10
+            } else {
+                Protocol::Unknown
+            }
+        } else {
+            Protocol::Unknown
+        };
+        Ok(Async::Ready(Io::from_parts(
+            io,
+            self.params.take().unwrap(),
+            proto,
+        )))
+    }
+}

actix-server/src/ssl/rustls.rs

@@ -4,22 +4,23 @@ use std::sync::Arc;
 
 use actix_service::{NewService, Service};
 use futures::{future::ok, future::FutureResult, Async, Future, Poll};
-use rustls::{ServerConfig, ServerSession};
+use rustls::ServerConfig;
 use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_rustls::{Accept, TlsAcceptor, TlsStream};
+use tokio_rustls::{server::TlsStream, Accept, TlsAcceptor};
 
-use super::MAX_CONN_COUNTER;
 use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig as SrvConfig};
 
 /// Support `SSL` connections via rustls package
 ///
 /// `rust-tls` feature enables `RustlsAcceptor` type
-pub struct RustlsAcceptor<T> {
+pub struct RustlsAcceptor<T, P = ()> {
     config: Arc<ServerConfig>,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> RustlsAcceptor<T, P> {
     /// Create `RustlsAcceptor` new service
     pub fn new(config: ServerConfig) -> Self {
         RustlsAcceptor {
@@ -29,7 +30,7 @@ impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
     }
 }
 
-impl<T> Clone for RustlsAcceptor<T> {
+impl<T, P> Clone for RustlsAcceptor<T, P> {
     fn clone(&self) -> Self {
         Self {
             config: self.config.clone(),
@@ -38,14 +39,19 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
-    type Response = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> NewService for RustlsAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = io::Error;
-    type Service = RustlsAcceptorService<T>;
+
+    type Config = SrvConfig;
+    type Service = RustlsAcceptorService<T, P>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
+        cfg.set_secure();
+
         MAX_CONN_COUNTER.with(|conns| {
             ok(RustlsAcceptorService {
                 acceptor: self.config.clone().into(),
@@ -56,16 +62,17 @@ impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
     }
 }
 
-pub struct RustlsAcceptorService<T> {
+pub struct RustlsAcceptorService<T, P> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
-    type Response = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> Service for RustlsAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = io::Error;
-    type Future = RustlsAcceptorServiceFut<T>;
+    type Future = RustlsAcceptorServiceFut<T, P>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         if self.conns.available() {
@@ -75,27 +82,35 @@ impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
         RustlsAcceptorServiceFut {
             _guard: self.conns.get(),
-            fut: self.acceptor.accept(req),
+            fut: self.acceptor.accept(io),
+            params: Some(params),
         }
     }
 }
 
-pub struct RustlsAcceptorServiceFut<T>
+pub struct RustlsAcceptorServiceFut<T, P>
 where
     T: AsyncRead + AsyncWrite,
 {
     fut: Accept<T>,
+    params: Option<P>,
     _guard: CounterGuard,
 }
 
-impl<T: AsyncRead + AsyncWrite> Future for RustlsAcceptorServiceFut<T> {
-    type Item = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> Future for RustlsAcceptorServiceFut<T, P> {
+    type Item = Io<TlsStream<T>, P>;
     type Error = io::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll()
+        let io = futures::try_ready!(self.fut.poll());
+        Ok(Async::Ready(Io::from_parts(
+            io,
+            self.params.take().unwrap(),
+            Protocol::Unknown,
+        )))
     }
 }

actix-server/src/worker.rs

@@ -1,21 +1,19 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
-use std::{mem, net, time};
+use std::{mem, time};
 
+use actix_rt::{spawn, Arbiter};
 use futures::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures::sync::oneshot;
 use futures::{future, Async, Future, Poll, Stream};
 use log::{error, info, trace};
-use tokio_current_thread::spawn;
 use tokio_timer::{sleep, Delay};
 
-use actix::msgs::StopArbiter;
-use actix::{Arbiter, Message};
-
-use super::accept::AcceptNotify;
-use super::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
-use super::Token;
+use crate::accept::AcceptNotify;
 use crate::counter::Counter;
+use crate::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::socket::{SocketAddr, StdStream};
+use crate::Token;
 
 pub(crate) struct WorkerCommand(Conn);
 
@@ -26,14 +24,14 @@ pub(crate) struct StopCommand {
     result: oneshot::Sender<bool>,
 }
 
-#[derive(Debug, Message)]
+#[derive(Debug)]
 pub(crate) struct Conn {
-    pub io: net::TcpStream,
+    pub io: StdStream,
     pub token: Token,
-    pub peer: Option<net::SocketAddr>,
+    pub peer: Option<SocketAddr>,
 }
 
-const MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
+static MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
 
 /// Sets the maximum per-worker number of concurrent connections.
 ///
@@ -130,7 +128,7 @@ pub(crate) struct Worker {
     services: Vec<Option<(usize, BoxedServerService)>>,
     availability: WorkerAvailability,
     conns: Counter,
-    factories: Vec<Box<InternalServiceFactory>>,
+    factories: Vec<Box<dyn InternalServiceFactory>>,
     state: WorkerState,
     shutdown_timeout: time::Duration,
 }
@@ -139,7 +137,7 @@ impl Worker {
     pub(crate) fn start(
         rx: UnboundedReceiver<WorkerCommand>,
         rx2: UnboundedReceiver<StopCommand>,
-        factories: Vec<Box<InternalServiceFactory>>,
+        factories: Vec<Box<dyn InternalServiceFactory>>,
         availability: WorkerAvailability,
         shutdown_timeout: time::Duration,
     ) {
@@ -167,7 +165,7 @@ impl Worker {
             future::join_all(fut)
                 .map_err(|e| {
                     error!("Can not start worker: {:?}", e);
-                    Arbiter::current().do_send(StopArbiter(0));
+                    Arbiter::current().stop();
                 })
                 .and_then(move |services| {
                     for item in services {
@@ -240,7 +238,7 @@ enum WorkerState {
     Restarting(
         usize,
         Token,
-        Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>,
+        Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>,
     ),
     Shutdown(Delay, Delay, oneshot::Sender<bool>),
 }
@@ -365,7 +363,7 @@ impl Future for Worker {
                 let num = num_connections();
                 if num == 0 {
                     let _ = tx.send(true);
-                    Arbiter::current().do_send(StopArbiter(0));
+                    Arbiter::current().stop();
                     return Ok(Async::Ready(()));
                 }
 
@@ -375,7 +373,7 @@ impl Future for Worker {
                     Async::Ready(_) => {
                         self.shutdown(true);
                         let _ = tx.send(false);
-                        Arbiter::current().do_send(StopArbiter(0));
+                        Arbiter::current().stop();
                         return Ok(Async::Ready(()));
                     }
                 }
@@ -401,7 +399,7 @@ impl Future for Worker {
                                     let guard = self.conns.get();
                                     let _ = self.services[msg.token.0]
                                         .as_mut()
-                                        .expect("actix net bug")
+                                        .expect("actix-server bug")
                                         .1
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                     continue;

actix-server/tests/test_server.rs

@@ -0,0 +1,162 @@
+use std::io::Read;
+use std::sync::mpsc;
+use std::{net, thread, time};
+
+use actix_codec::{BytesCodec, Framed};
+use actix_server::{Io, Server, ServerConfig};
+use actix_service::{new_service_cfg, service_fn, IntoService};
+use bytes::Bytes;
+use futures::{Future, Sink};
+use net2::TcpBuilder;
+use tokio_tcp::TcpStream;
+
+fn unused_addr() -> net::SocketAddr {
+    let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+    let socket = TcpBuilder::new_v4().unwrap();
+    socket.bind(&addr).unwrap();
+    socket.reuse_address(true).unwrap();
+    let tcp = socket.to_tcp_listener().unwrap();
+    tcp.local_addr().unwrap()
+}
+
+#[test]
+fn test_bind() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .bind("test", addr, move || {
+                new_service_cfg(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>((|_| Ok::<_, ()>(())).into_service())
+                })
+            })
+            .unwrap()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+fn test_bind_no_config() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .bind("test", addr, move || service_fn(|_| Ok::<_, ()>(())))
+            .unwrap()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+fn test_listen() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let lst = net::TcpListener::bind(addr).unwrap();
+        let srv = Server::build()
+            .listen("test", lst, move || {
+                new_service_cfg(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>((|_| Ok::<_, ()>(())).into_service())
+                })
+            })
+            .unwrap()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_start() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .backlog(100)
+            .bind("test", addr, move || {
+                new_service_cfg(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>(
+                        (|io: Io<TcpStream>| {
+                            Framed::new(io.into_parts().0, BytesCodec)
+                                .send(Bytes::from_static(b"test"))
+                                .then(|_| Ok::<_, ()>(()))
+                        })
+                        .into_service(),
+                    )
+                })
+            })
+            .unwrap()
+            .start();
+
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (srv, sys) = rx.recv().unwrap();
+
+    let mut buf = [0u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // pause
+    let _ = srv.pause();
+    thread::sleep(time::Duration::from_millis(200));
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    conn.set_read_timeout(Some(time::Duration::from_millis(100)))
+        .unwrap();
+    let res = conn.read_exact(&mut buf);
+    assert!(res.is_err());
+
+    // resume
+    let _ = srv.resume();
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+
+    let mut buf = [0u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // stop
+    let _ = srv.stop(false);
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_err());
+
+    thread::sleep(time::Duration::from_millis(100));
+    let _ = sys.stop();
+    let _ = h.join();
+}

actix-service/CHANGES.md

@@ -1,5 +1,183 @@
 # Changes
 
+## [0.4.2] - 2019-08-27
+
+### Fixed
+
+* Check service readiness for `new_apply_cfg` combinator
+
+
+## [0.4.1] - 2019-06-06
+
+### Added
+
+* Add `new_apply_cfg` function
+
+## [0.4.0] - 2019-05-12
+
+### Changed
+
+* Use associated type for `NewService` config
+
+* Change `apply_cfg` function
+
+* Renamed helper functions
+
+### Added
+
+* Add `NewService::map_config` and `NewService::unit_config` combinators
+
+
+## [0.3.6] - 2019-04-07
+
+### Changed
+
+* Poll boxed service call result immediately
+
+
+## [0.3.5] - 2019-03-29
+
+### Added
+
+* Add `impl<S: Service> Service for Rc<RefCell<S>>`
+
+
+## [0.3.4] - 2019-03-12
+
+### Added
+
+* Add `Transform::from_err()` combinator
+
+* Add `apply_fn` helper
+
+* Add `apply_fn_factory` helper
+
+* Add `apply_transform` helper
+
+* Add `apply_cfg` helper
+
+
+## [0.3.3] - 2019-03-09
+
+### Added
+
+* Add `ApplyTransform` new service for transform and new service.
+
+* Add `NewService::apply_cfg()` combinator, allows to use
+  nested `NewService` with different config parameter.
+
+### Changed
+
+* Revert IntoFuture change
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+
+* Export `AndThenTransform` type
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Simplify Transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+## Added
+
+* Added boxed NewService and Service.
+
+## Changed
+
+* Added `Config` parameter to `NewService` trait.
+
+* Added `Config` parameter to `NewTransform` trait.
+
+
+## [0.2.2] - 2019-02-19
+
+### Added
+
+* Added `NewService` impl for `Rc<S> where S: NewService`
+
+* Added `NewService` impl for `Arc<S> where S: NewService`
+
+
+## [0.2.1] - 2019-02-03
+
+### Changed
+
+* Generalize `.apply` combinator with Transform trait
+
+
+## [0.2.0] - 2019-02-01
+
+### Changed
+
+* Use associated type instead of generic for Service definition.
+
+  * Before:
+
+    ```rust
+    impl Service<Request> for Client {
+        type Response = Response;
+        // ...
+    }
+    ```
+  * After:
+
+    ```rust
+    impl Service for Client {
+        type Request = Request;
+        type Response = Response;
+        // ...
+    }
+    ```
+
+
+## [0.1.6] - 2019-01-24
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
+
+* Change `.apply()` error semantic, new service's error is `From<Self::Error>`
+
+
+## [0.1.5] - 2019-01-13
+
+### Changed
+
+* Make `Out::Error` convertable from `T::Error` for apply combinator
+
+
+## [0.1.4] - 2019-01-11
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for `FnService`
+
+
+## [0.1.3] - 2018-12-12
+
+### Changed
+
+* Split service combinators to separate trait
+
+
+## [0.1.2] - 2018-12-12
+
+### Fixed
+
+* Release future early for `.and_then()` and `.then()` combinators
+
+
 ## [0.1.1] - 2018-12-09
 
 ### Added

actix-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-service"
-version = "0.1.1"
+version = "0.4.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Service"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,11 +11,11 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [badges]
 travis-ci = { repository = "actix/actix-service", branch = "master" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+appveyor = { repository = "actix/actix-net" }
 codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
 
 [lib]
@@ -23,4 +23,7 @@ name = "actix_service"
 path = "src/lib.rs"
 
 [dependencies]
-futures = "0.1.24"
+futures = "0.1.25"
+
+[dev-dependencies]
+actix-rt = "0.2"

actix-service/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-service/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-service/src/and_then.rs

@@ -1,4 +1,4 @@
-use futures::{try_ready, Async, Future, Poll};
+use futures::{Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
 use crate::cell::Cell;
@@ -14,10 +14,10 @@ pub struct AndThen<A, B> {
 
 impl<A, B> AndThen<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<Request>(a: A, b: B) -> Self
+    pub fn new(a: A, b: B) -> Self
     where
-        A: Service<Request>,
-        B: Service<A::Response, Error = A::Error>,
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
     {
         Self { a, b: Cell::new(b) }
     }
@@ -35,53 +35,58 @@ where
     }
 }
 
-impl<A, B, Request> Service<Request> for AndThen<A, B>
+impl<A, B> Service for AndThen<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
+    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B, Request>;
+    type Future = AndThenFuture<A, B>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.a.poll_ready());
-        self.b.get_mut().poll_ready()
+        let not_ready = self.a.poll_ready()?.is_not_ready();
+        if self.b.get_mut().poll_ready()?.is_not_ready() || not_ready {
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
+        }
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         AndThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct AndThenFuture<A, B, Request>
+pub struct AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
-impl<A, B, Request> AndThenFuture<A, B, Request>
+impl<A, B> AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         AndThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
 }
 
-impl<A, B, Request> Future for AndThenFuture<A, B, Request>
+impl<A, B> Future for AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     type Item = B::Response;
     type Error = A::Error;
@@ -91,8 +96,9 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
             Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.get_mut().call(resp));
                 self.poll()
             }
@@ -103,18 +109,27 @@ where
 }
 
 /// `AndThenNewService` new service combinator
-pub struct AndThenNewService<A, B> {
+pub struct AndThenNewService<A, B>
+where
+    A: NewService,
+    B: NewService,
+{
     a: A,
     b: B,
 }
 
-impl<A, B> AndThenNewService<A, B> {
+impl<A, B> AndThenNewService<A, B>
+where
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
     /// Create new `AndThen` combinator
-    pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
-    where
-        A: NewService<Request>,
-        B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
-    {
+    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
         Self {
             a,
             b: f.into_new_service(),
@@ -122,27 +137,34 @@ impl<A, B> AndThenNewService<A, B> {
     }
 }
 
-impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
+impl<A, B> NewService for AndThenNewService<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
+    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
+
+    type Config = A::Config;
     type Service = AndThen<A::Service, B::Service>;
-
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B, Request>;
+    type Future = AndThenNewServiceFuture<A, B>;
 
-    fn new_service(&self) -> Self::Future {
-        AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        AndThenNewServiceFuture::new(self.a.new_service(cfg), self.b.new_service(cfg))
     }
 }
 
 impl<A, B> Clone for AndThenNewService<A, B>
 where
-    A: Clone,
-    B: Clone,
+    A: NewService + Clone,
+    B: NewService + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -152,10 +174,10 @@ where
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B, Request>
+pub struct AndThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
+    A: NewService,
+    B: NewService<Request = A::Response>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -163,10 +185,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
+impl<A, B> AndThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
+    A: NewService,
+    B: NewService<Request = A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -178,10 +200,10 @@ where
     }
 }
 
-impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
+impl<A, B> Future for AndThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
 {
     type Item = AndThen<A::Service, B::Service>;
     type Error = A::InitError;
@@ -218,10 +240,11 @@ mod tests {
     use std::rc::Rc;
 
     use super::*;
-    use crate::{NewService, Service};
+    use crate::{NewService, Service, ServiceExt};
 
     struct Srv1(Rc<Cell<usize>>);
-    impl Service<&'static str> for Srv1 {
+    impl Service for Srv1 {
+        type Request = &'static str;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -239,7 +262,8 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service<&'static str> for Srv2 {
+    impl Service for Srv2 {
+        type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -281,7 +305,7 @@ mod tests {
         let new_srv = blank
             .into_new_service()
             .and_then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call("srv1").poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));

actix-service/src/and_then_apply.rs

@@ -0,0 +1,186 @@
+use std::rc::Rc;
+
+use futures::{Async, Future, Poll};
+
+use crate::and_then::AndThen;
+use crate::from_err::FromErr;
+use crate::{NewService, Transform};
+
+/// `Apply` new service combinator
+pub struct AndThenTransform<T, A, B> {
+    a: A,
+    b: B,
+    t: Rc<T>,
+}
+
+impl<T, A, B> AndThenTransform<T, A, B>
+where
+    A: NewService,
+    B: NewService<Config = A::Config, InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new(t: T, a: A, b: B) -> Self {
+        Self {
+            a,
+            b,
+            t: Rc::new(t),
+        }
+    }
+}
+
+impl<T, A, B> Clone for AndThenTransform<T, A, B>
+where
+    A: Clone,
+    B: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            t: self.t.clone(),
+        }
+    }
+}
+
+impl<T, A, B> NewService for AndThenTransform<T, A, B>
+where
+    A: NewService,
+    B: NewService<Config = A::Config, InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    type Request = A::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type Config = A::Config;
+    type InitError = T::InitError;
+    type Service = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
+    type Future = AndThenTransformFuture<T, A, B>;
+
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        AndThenTransformFuture {
+            a: None,
+            t: None,
+            t_cell: self.t.clone(),
+            fut_a: self.a.new_service(cfg),
+            fut_b: self.b.new_service(cfg),
+            fut_t: None,
+        }
+    }
+}
+
+pub struct AndThenTransformFuture<T, A, B>
+where
+    A: NewService,
+    B: NewService<InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    fut_a: A::Future,
+    fut_b: B::Future,
+    fut_t: Option<T::Future>,
+    a: Option<A::Service>,
+    t: Option<T::Transform>,
+    t_cell: Rc<T>,
+}
+
+impl<T, A, B> Future for AndThenTransformFuture<T, A, B>
+where
+    A: NewService,
+    B: NewService<InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    type Item = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_b.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service));
+            }
+        }
+
+        if self.a.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.a = Some(service);
+            }
+        }
+
+        if let Some(ref mut fut) = self.fut_t {
+            if let Async::Ready(transform) = fut.poll()? {
+                self.t = Some(transform);
+            }
+        }
+
+        if self.a.is_some() && self.t.is_some() {
+            Ok(Async::Ready(AndThen::new(
+                FromErr::new(self.a.take().unwrap()),
+                self.t.take().unwrap(),
+            )))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{ok, FutureResult};
+    use futures::{Async, Future, Poll};
+
+    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
+
+    #[derive(Clone)]
+    struct Srv;
+    impl Service for Srv {
+        type Request = ();
+        type Response = ();
+        type Error = ();
+        type Future = FutureResult<(), ()>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            ok(())
+        }
+    }
+
+    #[test]
+    fn test_apply() {
+        let blank = |req| Ok(req);
+
+        let mut srv = blank
+            .into_service()
+            .apply_fn(Srv, |req: &'static str, srv: &mut Srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
+        assert!(srv.poll_ready().is_ok());
+        let res = srv.call("srv").poll();
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+    }
+
+    #[test]
+    fn test_new_service() {
+        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
+
+        let new_srv = blank.into_new_service().apply(
+            |req: &'static str, srv: &mut Srv| srv.call(()).map(move |res| (req, res)),
+            || Ok(Srv),
+        );
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
+            assert!(srv.poll_ready().is_ok());
+            let res = srv.call("srv").poll();
+            assert!(res.is_ok());
+            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+        } else {
+            panic!()
+        }
+    }
+}

actix-service/src/and_then_apply_fn.rs

@@ -0,0 +1,307 @@
+use std::marker::PhantomData;
+
+use futures::{Async, Future, IntoFuture, Poll};
+
+use super::{IntoNewService, IntoService, NewService, Service};
+use crate::cell::Cell;
+
+/// `Apply` service combinator
+pub struct AndThenApply<A, B, F, Out>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    a: A,
+    b: Cell<B>,
+    f: Cell<F>,
+    r: PhantomData<(Out,)>,
+}
+
+impl<A, B, F, Out> AndThenApply<A, B, F, Out>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    /// Create new `Apply` combinator
+    pub fn new<A1: IntoService<A>, B1: IntoService<B>>(a: A1, b: B1, f: F) -> Self {
+        Self {
+            f: Cell::new(f),
+            a: a.into_service(),
+            b: Cell::new(b.into_service()),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out> Clone for AndThenApply<A, B, F, Out>
+where
+    A: Service + Clone,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    fn clone(&self) -> Self {
+        AndThenApply {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out> Service for AndThenApply<A, B, F, Out>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Request = A::Request;
+    type Response = Out::Item;
+    type Error = A::Error;
+    type Future = AndThenApplyFuture<A, B, F, Out>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        let not_ready = self.a.poll_ready()?.is_not_ready();
+        if self.b.get_mut().poll_ready()?.is_not_ready() || not_ready {
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
+        }
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        AndThenApplyFuture {
+            b: self.b.clone(),
+            f: self.f.clone(),
+            fut_b: None,
+            fut_a: Some(self.a.call(req)),
+        }
+    }
+}
+
+pub struct AndThenApplyFuture<A, B, F, Out>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    b: Cell<B>,
+    f: Cell<F>,
+    fut_a: Option<A::Future>,
+    fut_b: Option<Out::Future>,
+}
+
+impl<A, B, F, Out> Future for AndThenApplyFuture<A, B, F, Out>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Item = Out::Item;
+    type Error = A::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut_b {
+            return fut.poll().map_err(|e| e.into());
+        }
+
+        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
+            Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
+                self.fut_b =
+                    Some((&mut *self.f.get_mut())(resp, self.b.get_mut()).into_future());
+                self.poll()
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+/// `ApplyNewService` new service combinator
+pub struct AndThenApplyNewService<A, B, F, Out> {
+    a: A,
+    b: B,
+    f: Cell<F>,
+    r: PhantomData<Out>,
+}
+
+impl<A, B, F, Out> AndThenApplyNewService<A, B, F, Out>
+where
+    A: NewService,
+    B: NewService<Config = A::Config, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new<A1: IntoNewService<A>, B1: IntoNewService<B>>(a: A1, b: B1, f: F) -> Self {
+        Self {
+            f: Cell::new(f),
+            a: a.into_new_service(),
+            b: b.into_new_service(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out> Clone for AndThenApplyNewService<A, B, F, Out>
+where
+    A: Clone,
+    B: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out> NewService for AndThenApplyNewService<A, B, F, Out>
+where
+    A: NewService,
+    B: NewService<Config = A::Config, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Request = A::Request;
+    type Response = Out::Item;
+    type Error = A::Error;
+    type Service = AndThenApply<A::Service, B::Service, F, Out>;
+    type Config = A::Config;
+    type InitError = A::InitError;
+    type Future = AndThenApplyNewServiceFuture<A, B, F, Out>;
+
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        AndThenApplyNewServiceFuture {
+            a: None,
+            b: None,
+            f: self.f.clone(),
+            fut_a: self.a.new_service(cfg).into_future(),
+            fut_b: self.b.new_service(cfg).into_future(),
+        }
+    }
+}
+
+pub struct AndThenApplyNewServiceFuture<A, B, F, Out>
+where
+    A: NewService,
+    B: NewService<Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    fut_b: B::Future,
+    fut_a: A::Future,
+    f: Cell<F>,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B, F, Out> Future for AndThenApplyNewServiceFuture<A, B, F, Out>
+where
+    A: NewService,
+    B: NewService<Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Item = AndThenApply<A::Service, B::Service, F, Out>;
+    type Error = A::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.a.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.a = Some(service);
+            }
+        }
+
+        if self.b.is_none() {
+            if let Async::Ready(service) = self.fut_b.poll()? {
+                self.b = Some(service);
+            }
+        }
+
+        if self.a.is_some() && self.b.is_some() {
+            Ok(Async::Ready(AndThenApply {
+                f: self.f.clone(),
+                a: self.a.take().unwrap(),
+                b: Cell::new(self.b.take().unwrap()),
+                r: PhantomData,
+            }))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{ok, FutureResult};
+    use futures::{Async, Future, Poll};
+
+    use crate::blank::{Blank, BlankNewService};
+    use crate::{NewService, Service, ServiceExt};
+
+    #[derive(Clone)]
+    struct Srv;
+    impl Service for Srv {
+        type Request = ();
+        type Response = ();
+        type Error = ();
+        type Future = FutureResult<(), ()>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            ok(())
+        }
+    }
+
+    #[test]
+    fn test_call() {
+        let mut srv = Blank::new().apply_fn(Srv, |req: &'static str, srv| {
+            srv.call(()).map(move |res| (req, res))
+        });
+        assert!(srv.poll_ready().is_ok());
+        let res = srv.call("srv").poll();
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+    }
+
+    #[test]
+    fn test_new_service() {
+        let new_srv = BlankNewService::new_unit().apply_fn(
+            || Ok(Srv),
+            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
+        );
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
+            assert!(srv.poll_ready().is_ok());
+            let res = srv.call("srv").poll();
+            assert!(res.is_ok());
+            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+        } else {
+            panic!()
+        }
+    }
+}

actix-service/src/apply.rs

@@ -4,24 +4,50 @@ use futures::{Async, Future, IntoFuture, Poll};
 
 use super::{IntoNewService, IntoService, NewService, Service};
 
-/// `Apply` service combinator
-pub struct Apply<T, F, In, Out, Request>
+/// Apply tranform function to a service
+pub fn apply_fn<T, F, In, Out, U>(service: U, f: F) -> Apply<T, F, In, Out>
 where
-    T: Service<Request>,
+    T: Service,
+    F: FnMut(In, &mut T) -> Out,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
+    U: IntoService<T>,
+{
+    Apply::new(service.into_service(), f)
+}
+
+/// Create factory for `apply` service.
+pub fn new_apply_fn<T, F, In, Out, U>(service: U, f: F) -> ApplyNewService<T, F, In, Out>
+where
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
+    U: IntoNewService<T>,
+{
+    ApplyNewService::new(service.into_new_service(), f)
+}
+
+#[doc(hidden)]
+/// `Apply` service combinator
+pub struct Apply<T, F, In, Out>
+where
+    T: Service,
 {
     service: T,
     f: F,
-    r: PhantomData<(In, Out, Request)>,
+    r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
+impl<T, F, In, Out> Apply<T, F, In, Out>
 where
-    T: Service<Request>,
-    F: Fn(In, &mut T) -> Out,
+    T: Service,
+    F: FnMut(In, &mut T) -> Out,
     Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
+    pub(crate) fn new<I: IntoService<T>>(service: I, f: F) -> Self {
         Self {
             service: service.into_service(),
             f,
@@ -30,9 +56,9 @@ where
     }
 }
 
-impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
+impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
 where
-    T: Service<Request> + Clone,
+    T: Service + Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -44,18 +70,20 @@ where
     }
 }
 
-impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
+impl<T, F, In, Out> Service for Apply<T, F, In, Out>
 where
-    T: Service<Request, Error = Out::Error>,
-    F: Fn(In, &mut T) -> Out,
+    T: Service,
+    F: FnMut(In, &mut T) -> Out,
     Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
+    type Request = In;
     type Response = Out::Item;
     type Error = Out::Error;
     type Future = Out::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
+        self.service.poll_ready().map_err(|e| e.into())
     }
 
     fn call(&mut self, req: In) -> Self::Future {
@@ -64,23 +92,24 @@ where
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out, Request>
+pub struct ApplyNewService<T, F, In, Out>
 where
-    T: NewService<Request>,
+    T: NewService,
 {
     service: T,
     f: F,
-    r: PhantomData<(In, Out, Request)>,
+    r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
+impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
+    pub(crate) fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
         Self {
             f,
             service: service.into_new_service(),
@@ -89,10 +118,10 @@ where
     }
 }
 
-impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
+impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
 where
-    T: NewService<Request> + Clone,
-    F: Fn(Out, &mut T::Service) -> Out + Clone,
+    T: NewService + Clone,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
 {
     fn clone(&self) -> Self {
@@ -104,28 +133,31 @@ where
     }
 }
 
-impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
+impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out>
 where
-    T: NewService<Request, Error = Out::Error>,
-    F: Fn(In, &mut T::Service) -> Out + Clone,
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
+    type Request = In;
     type Response = Out::Item;
     type Error = Out::Error;
-    type Service = Apply<T::Service, F, In, Out, Request>;
 
+    type Config = T::Config;
+    type Service = Apply<T::Service, F, In, Out>;
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
+    type Future = ApplyNewServiceFuture<T, F, In, Out>;
 
-    fn new_service(&self) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &T::Config) -> Self::Future {
+        ApplyNewServiceFuture::new(self.service.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
+pub struct ApplyNewServiceFuture<T, F, In, Out>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
 {
     fut: T::Future,
@@ -133,10 +165,10 @@ where
     r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
+impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
 {
     fn new(fut: T::Future, f: F) -> Self {
@@ -148,13 +180,14 @@ where
     }
 }
 
-impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
+impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
+    T: NewService,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
-    type Item = Apply<T::Service, F, In, Out, Request>;
+    type Item = Apply<T::Service, F, In, Out>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -171,11 +204,13 @@ mod tests {
     use futures::future::{ok, FutureResult};
     use futures::{Async, Future, Poll};
 
-    use crate::{IntoNewService, IntoService, NewService, Service};
+    use super::*;
+    use crate::{IntoService, NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv;
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -193,9 +228,11 @@ mod tests {
     fn test_call() {
         let blank = |req| Ok(req);
 
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
-            srv.call(()).map(move |res| (req, res))
-        });
+        let mut srv = blank
+            .into_service()
+            .apply_fn(Srv, |req: &'static str, srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
         assert!(srv.poll_ready().is_ok());
         let res = srv.call("srv").poll();
         assert!(res.is_ok());
@@ -204,13 +241,11 @@ mod tests {
 
     #[test]
     fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
-
-        let new_srv = blank.into_new_service().apply(
-            || Ok(Srv),
+        let new_srv = ApplyNewService::new(
+            || Ok::<_, ()>(Srv),
             |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
         );
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             assert!(srv.poll_ready().is_ok());
             let res = srv.call("srv").poll();
             assert!(res.is_ok());

actix-service/src/apply_cfg.rs

@@ -0,0 +1,266 @@
+use std::marker::PhantomData;
+
+use futures::future::Future;
+use futures::{try_ready, Async, IntoFuture, Poll};
+
+use crate::cell::Cell;
+use crate::{IntoService, NewService, Service};
+
+/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
+pub fn apply_cfg<F, C, T, R, S>(
+    srv: T,
+    f: F,
+) -> impl NewService<
+    Config = C,
+    Request = S::Request,
+    Response = S::Response,
+    Error = S::Error,
+    Service = S,
+    InitError = R::Error,
+> + Clone
+where
+    F: FnMut(&C, &mut T) -> R,
+    T: Service,
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    ApplyConfigService {
+        f: Cell::new(f),
+        srv: Cell::new(srv.into_service()),
+        _t: PhantomData,
+    }
+}
+
+/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
+/// Service get constructor from NewService.
+pub fn new_apply_cfg<F, C, T, R, S>(
+    srv: T,
+    f: F,
+) -> impl NewService<
+    Config = C,
+    Request = S::Request,
+    Response = S::Response,
+    Error = S::Error,
+    Service = S,
+    InitError = T::InitError,
+> + Clone
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    ApplyConfigNewService {
+        f: Cell::new(f),
+        srv: Cell::new(srv),
+        _t: PhantomData,
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+struct ApplyConfigService<F, C, T, R, S>
+where
+    F: FnMut(&C, &mut T) -> R,
+    T: Service,
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    f: Cell<F>,
+    srv: Cell<T>,
+    _t: PhantomData<(C, R, S)>,
+}
+
+impl<F, C, T, R, S> Clone for ApplyConfigService<F, C, T, R, S>
+where
+    F: FnMut(&C, &mut T) -> R,
+    T: Service,
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        ApplyConfigService {
+            f: self.f.clone(),
+            srv: self.srv.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, C, T, R, S> NewService for ApplyConfigService<F, C, T, R, S>
+where
+    F: FnMut(&C, &mut T) -> R,
+    T: Service,
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Config = C;
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = R::Error;
+    type Future = FnNewServiceConfigFut<R, S>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        FnNewServiceConfigFut {
+            fut: unsafe { (self.f.get_mut_unsafe())(cfg, self.srv.get_mut_unsafe()) }
+                .into_future(),
+            _t: PhantomData,
+        }
+    }
+}
+
+struct FnNewServiceConfigFut<R, S>
+where
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    fut: R::Future,
+    _t: PhantomData<(S,)>,
+}
+
+impl<R, S> Future for FnNewServiceConfigFut<R, S>
+where
+    R: IntoFuture,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Item = S;
+    type Error = R::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        Ok(Async::Ready(try_ready!(self.fut.poll()).into_service()))
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+struct ApplyConfigNewService<F, C, T, R, S>
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    f: Cell<F>,
+    srv: Cell<T>,
+    _t: PhantomData<(C, R, S)>,
+}
+
+impl<F, C, T, R, S> Clone for ApplyConfigNewService<F, C, T, R, S>
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        ApplyConfigNewService {
+            f: self.f.clone(),
+            srv: self.srv.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, C, T, R, S> NewService for ApplyConfigNewService<F, C, T, R, S>
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Config = C;
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = R::Error;
+    type Future = ApplyConfigNewServiceFut<F, C, T, R, S>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        ApplyConfigNewServiceFut {
+            f: self.f.clone(),
+            cfg: cfg.clone(),
+            fut: None,
+            srv: None,
+            srv_fut: Some(self.srv.get_ref().new_service(&())),
+            _t: PhantomData,
+        }
+    }
+}
+
+struct ApplyConfigNewServiceFut<F, C, T, R, S>
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    cfg: C,
+    f: Cell<F>,
+    srv: Option<T::Service>,
+    srv_fut: Option<T::Future>,
+    fut: Option<R::Future>,
+    _t: PhantomData<(S,)>,
+}
+
+impl<F, C, T, R, S> Future for ApplyConfigNewServiceFut<F, C, T, R, S>
+where
+    C: Clone,
+    F: FnMut(&C, &mut T::Service) -> R,
+    T: NewService<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: IntoFuture<Error = T::InitError>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Item = S;
+    type Error = R::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.srv_fut {
+            match fut.poll()? {
+                Async::NotReady => return Ok(Async::NotReady),
+                Async::Ready(srv) => {
+                    let _ = self.srv_fut.take();
+                    self.srv = Some(srv);
+                    return self.poll();
+                }
+            }
+        }
+
+        if let Some(ref mut fut) = self.fut {
+            Ok(Async::Ready(try_ready!(fut.poll()).into_service()))
+        } else if let Some(ref mut srv) = self.srv {
+            match srv.poll_ready()? {
+                Async::NotReady => Ok(Async::NotReady),
+                Async::Ready(_) => {
+                    self.fut = Some(self.f.get_mut()(&self.cfg, srv).into_future());
+                    return self.poll();
+                }
+            }
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-service/src/blank.rs

@@ -0,0 +1,84 @@
+use std::marker::PhantomData;
+
+use futures::future::{ok, FutureResult};
+use futures::{Async, Poll};
+
+use super::{NewService, Service};
+
+/// Empty service
+#[derive(Clone)]
+pub struct Blank<R, E> {
+    _t: PhantomData<(R, E)>,
+}
+
+impl<R, E> Blank<R, E> {
+    pub fn err<E1>(self) -> Blank<R, E1> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R> Blank<R, ()> {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new<E>() -> Blank<R, E> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R, E> Default for Blank<R, E> {
+    fn default() -> Blank<R, E> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R, E> Service for Blank<R, E> {
+    type Request = R;
+    type Response = R;
+    type Error = E;
+    type Future = FutureResult<R, E>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: R) -> Self::Future {
+        ok(req)
+    }
+}
+
+/// Empty service factory
+pub struct BlankNewService<R, E1, E2 = ()> {
+    _t: PhantomData<(R, E1, E2)>,
+}
+
+impl<R, E1, E2> BlankNewService<R, E1, E2> {
+    pub fn new() -> BlankNewService<R, E1, E2> {
+        BlankNewService { _t: PhantomData }
+    }
+}
+
+impl<R, E1> BlankNewService<R, E1, ()> {
+    pub fn new_unit() -> BlankNewService<R, E1, ()> {
+        BlankNewService { _t: PhantomData }
+    }
+}
+
+impl<R, E1, E2> Default for BlankNewService<R, E1, E2> {
+    fn default() -> BlankNewService<R, E1, E2> {
+        Self::new()
+    }
+}
+
+impl<R, E1, E2> NewService for BlankNewService<R, E1, E2> {
+    type Request = R;
+    type Response = R;
+    type Error = E1;
+
+    type Config = ();
+    type Service = Blank<R, E1>;
+    type InitError = E2;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(Blank::default())
+    }
+}

actix-service/src/boxed.rs

@@ -0,0 +1,151 @@
+use futures::future::{err, ok, Either, FutureResult};
+use futures::{Async, Future, IntoFuture, Poll};
+
+use crate::{NewService, Service};
+
+pub type BoxedService<Req, Res, Err> = Box<
+    dyn Service<
+        Request = Req,
+        Response = Res,
+        Error = Err,
+        Future = BoxedServiceResponse<Res, Err>,
+    >,
+>;
+
+pub type BoxedServiceResponse<Res, Err> =
+    Either<FutureResult<Res, Err>, Box<dyn Future<Item = Res, Error = Err>>>;
+
+pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+
+/// Create boxed new service
+pub fn new_service<T>(
+    service: T,
+) -> BoxedNewService<T::Config, T::Request, T::Response, T::Error, T::InitError>
+where
+    T: NewService + 'static,
+    T::Request: 'static,
+    T::Response: 'static,
+    T::Service: 'static,
+    T::Future: 'static,
+    T::Error: 'static,
+    T::InitError: 'static,
+{
+    BoxedNewService(Box::new(NewServiceWrapper {
+        service,
+        _t: std::marker::PhantomData,
+    }))
+}
+
+/// Create boxed service
+pub fn service<T>(service: T) -> BoxedService<T::Request, T::Response, T::Error>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    Box::new(ServiceWrapper(service))
+}
+
+type Inner<C, Req, Res, Err, InitErr> = Box<
+    dyn NewService<
+        Config = C,
+        Request = Req,
+        Response = Res,
+        Error = Err,
+        InitError = InitErr,
+        Service = BoxedService<Req, Res, Err>,
+        Future = Box<dyn Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
+    >,
+>;
+
+impl<C, Req, Res, Err, InitErr> NewService for BoxedNewService<C, Req, Res, Err, InitErr>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Config = C;
+    type Service = BoxedService<Req, Res, Err>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        self.0.new_service(cfg)
+    }
+}
+
+struct NewServiceWrapper<C, T: NewService> {
+    service: T,
+    _t: std::marker::PhantomData<C>,
+}
+
+impl<C, T, Req, Res, Err, InitErr> NewService for NewServiceWrapper<C, T>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+    T: NewService<Config = C, Request = Req, Response = Res, Error = Err, InitError = InitErr>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Config = C;
+    type Service = BoxedService<Req, Res, Err>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        Box::new(
+            self.service
+                .new_service(cfg)
+                .into_future()
+                .map(ServiceWrapper::boxed),
+        )
+    }
+}
+
+struct ServiceWrapper<T: Service>(T);
+
+impl<T> ServiceWrapper<T>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    fn boxed(service: T) -> BoxedService<T::Request, T::Response, T::Error> {
+        Box::new(ServiceWrapper(service))
+    }
+}
+
+impl<T, Req, Res, Err> Service for ServiceWrapper<T>
+where
+    T: Service<Request = Req, Response = Res, Error = Err>,
+    T::Future: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type Future = Either<
+        FutureResult<Self::Response, Self::Error>,
+        Box<dyn Future<Item = Self::Response, Error = Self::Error>>,
+    >;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.0.poll_ready()
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let mut fut = self.0.call(req);
+        match fut.poll() {
+            Ok(Async::Ready(res)) => Either::A(ok(res)),
+            Err(e) => Either::A(err(e)),
+            Ok(Async::NotReady) => Either::B(Box::new(fut)),
+        }
+    }
+}

actix-service/src/cell.rs

@@ -26,7 +26,16 @@ impl<T> Cell<T> {
         }
     }
 
+    pub(crate) fn get_ref(&self) -> &T {
+        unsafe { &*self.inner.as_ref().get() }
+    }
+
     pub(crate) fn get_mut(&mut self) -> &mut T {
         unsafe { &mut *self.inner.as_ref().get() }
     }
+
+    #[allow(clippy::mut_from_ref)]
+    pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
+        &mut *self.inner.as_ref().get()
+    }
 }

actix-service/src/fn_service.rs

@@ -1,55 +1,79 @@
-use std::marker;
+use std::marker::PhantomData;
 
-use futures::{
-    future::{ok, FutureResult},
-    Async, IntoFuture, Poll,
-};
+use futures::future::{ok, Future, FutureResult};
+use futures::{try_ready, Async, IntoFuture, Poll};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use crate::{IntoNewService, IntoService, NewService, Service};
 
-pub struct FnService<F, Req, Resp, E, Fut>
+/// Create `NewService` for function that can act as a Service
+pub fn service_fn<F, Req, Out, Cfg>(f: F) -> NewServiceFn<F, Req, Out, Cfg>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    NewServiceFn::new(f)
+}
+
+/// Create `NewService` for function that can produce services
+pub fn new_service_fn<F, C, R, S, E>(f: F) -> FnNewServiceNoConfig<F, C, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    FnNewServiceNoConfig::new(f)
+}
+
+/// Create `NewService` for function that can produce services with configuration
+pub fn new_service_cfg<F, C, R, S, E>(f: F) -> FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    FnNewServiceConfig::new(f)
+}
+
+pub struct ServiceFn<F, Req, Out>
+where
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
     f: F,
-    _t: marker::PhantomData<(Req, Resp, E)>,
+    _t: PhantomData<Req>,
 }
 
-impl<F, Req, Resp, E, Fut> FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> ServiceFn<F, Req, Out>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
-    pub fn new(f: F) -> Self {
-        FnService {
-            f,
-            _t: marker::PhantomData,
-        }
+    pub(crate) fn new(f: F) -> Self {
+        ServiceFn { f, _t: PhantomData }
     }
 }
 
-impl<F, Req, Resp, E, Fut> Clone for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> Clone for ServiceFn<F, Req, Out>
 where
-    F: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
-        FnService {
-            f: self.f.clone(),
-            _t: marker::PhantomData,
-        }
+        ServiceFn::new(self.f.clone())
     }
 }
 
-impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> Service for ServiceFn<F, Req, Out>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
-    type Response = Resp;
-    type Error = E;
-    type Future = Fut::Future;
+    type Request = Req;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Future = Out::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -60,70 +84,227 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
+impl<F, Req, Out> IntoService<ServiceFn<F, Req, Out>> for F
 where
-    F: Fn(Req) -> Fut + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
-    fn into_service(self) -> FnService<F, Req, Resp, Err, Fut> {
-        FnService::new(self)
+    fn into_service(self) -> ServiceFn<F, Req, Out> {
+        ServiceFn::new(self)
     }
 }
 
-pub struct FnNewService<F, Req, Resp, Err, Fut>
+pub struct NewServiceFn<F, Req, Out, Cfg>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
     f: F,
-    _t: marker::PhantomData<(Req, Resp, Err)>,
+    _t: PhantomData<(Req, Cfg)>,
 }
 
-impl<F, Req, Resp, Err, Fut> FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Out, Cfg> NewServiceFn<F, Req, Out, Cfg>
 where
-    F: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    pub(crate) fn new(f: F) -> Self {
+        NewServiceFn { f, _t: PhantomData }
+    }
+}
+
+impl<F, Req, Out, Cfg> Clone for NewServiceFn<F, Req, Out, Cfg>
+where
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn clone(&self) -> Self {
+        NewServiceFn::new(self.f.clone())
+    }
+}
+
+impl<F, Req, Out, Cfg> NewService for NewServiceFn<F, Req, Out, Cfg>
+where
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    type Request = Req;
+    type Response = Out::Item;
+    type Error = Out::Error;
+
+    type Config = Cfg;
+    type Service = ServiceFn<F, Req, Out>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &Cfg) -> Self::Future {
+        ok(ServiceFn::new(self.f.clone()))
+    }
+}
+
+impl<F, Req, Out, Cfg> IntoService<ServiceFn<F, Req, Out>> for NewServiceFn<F, Req, Out, Cfg>
+where
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn into_service(self) -> ServiceFn<F, Req, Out> {
+        ServiceFn::new(self.f.clone())
+    }
+}
+
+impl<F, Req, Out, Cfg> IntoNewService<NewServiceFn<F, Req, Out, Cfg>> for F
+where
+    F: Fn(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn into_new_service(self) -> NewServiceFn<F, Req, Out, Cfg> {
+        NewServiceFn::new(self)
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+pub struct FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    f: F,
+    _t: PhantomData<(C, R, S, E)>,
+}
+
+impl<F, C, R, S, E> FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
 {
     pub fn new(f: F) -> Self {
-        FnNewService {
-            f,
-            _t: marker::PhantomData,
+        FnNewServiceConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, C, R, S, E> NewService for FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+
+    type Config = C;
+    type Service = S;
+    type InitError = E;
+    type Future = FnNewServiceConfigFut<R, S, E>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        FnNewServiceConfigFut {
+            fut: (self.f)(cfg).into_future(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
+pub struct FnNewServiceConfigFut<R, S, E>
 where
-    F: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
 {
-    type Response = Resp;
-    type Error = Err;
-    type Service = FnService<F, Req, Resp, Err, Fut>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
+    fut: R::Future,
+    _t: PhantomData<(S,)>,
+}
 
-    fn new_service(&self) -> Self::Future {
-        ok(FnService::new(self.f.clone()))
+impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E>
+where
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Item = S;
+    type Error = R::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        Ok(Async::Ready(try_ready!(self.fut.poll()).into_service()))
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>, Req> for F
+impl<F, C, R, S, E> Clone for FnNewServiceConfig<F, C, R, S, E>
 where
-    F: Fn(Req) -> Fut + Clone + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    fn into_new_service(self) -> FnNewService<F, Req, Resp, Err, Fut> {
-        FnNewService::new(self)
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> Clone for FnNewService<F, Req, Resp, Err, Fut>
-where
-    F: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: Fn(&C) -> R + Clone,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
+
+/// Converter for `Fn() -> Future<Service>` fn
+pub struct FnNewServiceNoConfig<F, C, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    f: F,
+    _t: PhantomData<C>,
+}
+
+impl<F, C, R, S, E> FnNewServiceNoConfig<F, C, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    pub fn new(f: F) -> Self {
+        FnNewServiceNoConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, C, R, S, E> NewService for FnNewServiceNoConfig<F, C, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+    type Config = C;
+    type InitError = E;
+    type Future = R::Future;
+
+    fn new_service(&self, _: &C) -> Self::Future {
+        (self.f)().into_future()
+    }
+}
+
+impl<F, C, R, S, E> Clone for FnNewServiceNoConfig<F, C, R, S, E>
+where
+    F: Fn() -> R + Clone,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, C, R, S, E> IntoNewService<FnNewServiceNoConfig<F, C, R, S, E>> for F
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn into_new_service(self) -> FnNewServiceNoConfig<F, C, R, S, E> {
+        FnNewServiceNoConfig::new(self)
+    }
+}

actix-service/src/fn_transform.rs

@@ -0,0 +1,80 @@
+use std::marker::PhantomData;
+
+use futures::future::{ok, FutureResult};
+use futures::IntoFuture;
+
+use crate::apply::Apply;
+use crate::{IntoTransform, Service, Transform};
+
+/// Use function as transform service
+pub fn transform_fn<F, S, In, Out, Err>(
+    f: F,
+) -> impl Transform<S, Request = In, Response = Out::Item, Error = Out::Error, InitError = Err>
+where
+    S: Service,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+{
+    FnTransform::new(f)
+}
+
+pub struct FnTransform<F, S, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    f: F,
+    _t: PhantomData<(S, In, Out, Err)>,
+}
+
+impl<F, S, In, Out, Err> FnTransform<F, S, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    pub fn new(f: F) -> Self {
+        FnTransform { f, _t: PhantomData }
+    }
+}
+
+impl<F, S, In, Out, Err> Transform<S> for FnTransform<F, S, In, Out, Err>
+where
+    S: Service,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+{
+    type Request = In;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Transform = Apply<S, F, In, Out>;
+    type InitError = Err;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(Apply::new(service, self.f.clone()))
+    }
+}
+
+impl<F, S, In, Out, Err> IntoTransform<FnTransform<F, S, In, Out, Err>, S> for F
+where
+    S: Service,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+{
+    fn into_transform(self) -> FnTransform<F, S, In, Out, Err> {
+        FnTransform::new(self)
+    }
+}
+
+impl<F, S, In, Out, Err> Clone for FnTransform<F, S, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}

actix-service/src/from_err.rs

@@ -13,9 +13,9 @@ pub struct FromErr<A, E> {
 }
 
 impl<A, E> FromErr<A, E> {
-    pub(crate) fn new<Request>(service: A) -> Self
+    pub(crate) fn new(service: A) -> Self
     where
-        A: Service<Request>,
+        A: Service,
         E: From<A::Error>,
     {
         FromErr {
@@ -37,20 +37,21 @@ where
     }
 }
 
-impl<A, E, Request> Service<Request> for FromErr<A, E>
+impl<A, E> Service for FromErr<A, E>
 where
-    A: Service<Request>,
+    A: Service,
     E: From<A::Error>,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = FromErrFuture<A, E, Request>;
+    type Future = FromErrFuture<A, E>;
 
     fn poll_ready(&mut self) -> Poll<(), E> {
-        Ok(self.service.poll_ready().map_err(E::from)?)
+        self.service.poll_ready().map_err(E::from)
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         FromErrFuture {
             fut: self.service.call(req),
             f: PhantomData,
@@ -58,14 +59,14 @@ where
     }
 }
 
-pub struct FromErrFuture<A: Service<Request>, E, Request> {
+pub struct FromErrFuture<A: Service, E> {
     fut: A::Future,
     f: PhantomData<E>,
 }
 
-impl<A, E, Request> Future for FromErrFuture<A, E, Request>
+impl<A, E> Future for FromErrFuture<A, E>
 where
-    A: Service<Request>,
+    A: Service,
     E: From<A::Error>,
 {
     type Item = A::Response;
@@ -87,9 +88,9 @@ pub struct FromErrNewService<A, E> {
 
 impl<A, E> FromErrNewService<A, E> {
     /// Create new `FromErr` new service instance
-    pub fn new<Request>(a: A) -> Self
+    pub fn new(a: A) -> Self
     where
-        A: NewService<Request>,
+        A: NewService,
         E: From<A::Error>,
     {
         Self { a, e: PhantomData }
@@ -108,38 +109,40 @@ where
     }
 }
 
-impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
+impl<A, E> NewService for FromErrNewService<A, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     E: From<A::Error>,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
+
+    type Config = A::Config;
     type Service = FromErr<A::Service, E>;
-
     type InitError = A::InitError;
-    type Future = FromErrNewServiceFuture<A, E, Request>;
+    type Future = FromErrNewServiceFuture<A, E>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
         FromErrNewServiceFuture {
-            fut: self.a.new_service(),
+            fut: self.a.new_service(cfg),
             e: PhantomData,
         }
     }
 }
 
-pub struct FromErrNewServiceFuture<A, E, Request>
+pub struct FromErrNewServiceFuture<A, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
+impl<A, E> Future for FromErrNewServiceFuture<A, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
@@ -159,10 +162,11 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, NewService, Service};
+    use crate::{IntoNewService, NewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -205,7 +209,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().from_err::<Error>();
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_err());
             assert_eq!(res.err().unwrap(), Error);

actix-service/src/lib.rs

@@ -1,25 +1,49 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
 use futures::{Future, IntoFuture, Poll};
+
 mod and_then;
+mod and_then_apply;
+mod and_then_apply_fn;
 mod apply;
+mod apply_cfg;
+pub mod blank;
+pub mod boxed;
 mod cell;
 mod fn_service;
+mod fn_transform;
 mod from_err;
 mod map;
+mod map_config;
 mod map_err;
 mod map_init_err;
 mod then;
+mod transform;
+mod transform_err;
 
 pub use self::and_then::{AndThen, AndThenNewService};
-pub use self::apply::{Apply, ApplyNewService};
-pub use self::fn_service::{FnNewService, FnService};
+pub use self::apply::{apply_fn, new_apply_fn, Apply, ApplyNewService};
+pub use self::apply_cfg::{apply_cfg, new_apply_cfg};
+pub use self::fn_service::{new_service_cfg, new_service_fn, service_fn, ServiceFn};
+pub use self::fn_transform::transform_fn;
 pub use self::from_err::{FromErr, FromErrNewService};
 pub use self::map::{Map, MapNewService};
+pub use self::map_config::{MapConfig, MappedConfig, UnitConfig};
 pub use self::map_err::{MapErr, MapErrNewService};
 pub use self::map_init_err::MapInitErr;
 pub use self::then::{Then, ThenNewService};
+pub use self::transform::{apply_transform, IntoTransform, Transform};
+
+use self::and_then_apply::AndThenTransform;
+use self::and_then_apply_fn::{AndThenApply, AndThenApplyNewService};
 
 /// An asynchronous function from `Request` to a `Response`.
-pub trait Service<Request> {
+pub trait Service {
+    /// Requests handled by the service.
+    type Request;
+
     /// Responses given by the service.
     type Response;
 
@@ -49,23 +73,24 @@ pub trait Service<Request> {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Request) -> Self::Future;
+    fn call(&mut self, req: Self::Request) -> Self::Future;
+}
 
+/// An extension trait for `Service`s that provides a variety of convenient
+/// adapters
+pub trait ServiceExt: Service {
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<T, I, F, Out, Req>(
-        self,
-        service: I,
-        f: F,
-    ) -> AndThen<Self, Apply<T, F, Self::Response, Out, Req>>
+    fn apply_fn<F, B, B1, Out>(self, service: B1, f: F) -> AndThenApply<Self, B, F, Out>
     where
         Self: Sized,
-        T: Service<Req, Error = Self::Error>,
-        I: IntoService<T, Req>,
-        F: Fn(Self::Response, &mut T) -> Out,
-        Out: IntoFuture<Error = Self::Error>,
+        F: FnMut(Self::Response, &mut B) -> Out,
+        Out: IntoFuture,
+        Out::Error: Into<Self::Error>,
+        B: Service<Error = Self::Error>,
+        B1: IntoService<B>,
     {
-        self.and_then(Apply::new(service.into_service(), f))
+        AndThenApply::new(self, service, f)
     }
 
     /// Call another service after call to this one has resolved successfully.
@@ -80,8 +105,8 @@ pub trait Service<Request> {
     fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
     where
         Self: Sized,
-        F: IntoService<B, Self::Response>,
-        B: Service<Self::Response, Error = Self::Error>,
+        F: IntoService<B>,
+        B: Service<Request = Self::Response, Error = Self::Error>,
     {
         AndThen::new(self, service.into_service())
     }
@@ -107,7 +132,7 @@ pub trait Service<Request> {
     fn then<B>(self, service: B) -> Then<Self, B>
     where
         Self: Sized,
-        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
+        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
     {
         Then::new(self, service)
     }
@@ -124,7 +149,7 @@ pub trait Service<Request> {
     fn map<F, R>(self, f: F) -> Map<Self, F, R>
     where
         Self: Sized,
-        F: Fn(Self::Response) -> R,
+        F: FnMut(Self::Response) -> R,
     {
         Map::new(self, f)
     }
@@ -146,24 +171,36 @@ pub trait Service<Request> {
     }
 }
 
+impl<T: ?Sized> ServiceExt for T where T: Service {}
+
 /// Creates new `Service` values.
 ///
 /// Acts as a service factory. This is useful for cases where new `Service`
-/// values must be produced. One case is a TCP servier listener. The listner
+/// values must be produced. One case is a TCP server listener. The listener
 /// accepts new TCP streams, obtains a new `Service` value using the
 /// `NewService` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
 ///
-/// Request - request handled by the service
-pub trait NewService<Request> {
+/// `Config` is a service factory configuration type.
+pub trait NewService {
+    /// Requests handled by the service.
+    type Request;
+
     /// Responses given by the service
     type Response;
 
     /// Errors produced by the service
     type Error;
 
+    /// Service factory configuration
+    type Config;
+
     /// The `Service` value created by this factory
-    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
+    type Service: Service<
+        Request = Self::Request,
+        Response = Self::Response,
+        Error = Self::Error,
+    >;
 
     /// Errors produced while building a service.
     type InitError;
@@ -172,31 +209,47 @@ pub trait NewService<Request> {
     type Future: Future<Item = Self::Service, Error = Self::InitError>;
 
     /// Create and return a new service value asynchronously.
-    fn new_service(&self) -> Self::Future;
+    fn new_service(&self, cfg: &Self::Config) -> Self::Future;
+
+    /// Apply transform service to specified service and use it as a next service in
+    /// chain.
+    fn apply<T, T1, B, B1>(self, transform: T1, service: B1) -> AndThenTransform<T, Self, B>
+    where
+        Self: Sized,
+        T: Transform<B::Service, Request = Self::Response, InitError = Self::InitError>,
+        T::Error: From<Self::Error>,
+        T1: IntoTransform<T, B::Service>,
+        B: NewService<Config = Self::Config, InitError = Self::InitError>,
+        B1: IntoNewService<B>,
+    {
+        AndThenTransform::new(transform.into_transform(), self, service.into_new_service())
+    }
 
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<T, I, F, Out, Req>(
-        self,
-        service: I,
-        f: F,
-    ) -> AndThenNewService<Self, ApplyNewService<T, F, Self::Response, Out, Req>>
+    fn apply_fn<B, I, F, Out>(self, service: I, f: F) -> AndThenApplyNewService<Self, B, F, Out>
     where
         Self: Sized,
-        T: NewService<Req, InitError = Self::InitError, Error = Self::Error>,
-        I: IntoNewService<T, Req>,
-        F: Fn(Self::Response, &mut T::Service) -> Out + Clone,
-        Out: IntoFuture<Error = Self::Error>,
+        B: NewService<Config = Self::Config, Error = Self::Error, InitError = Self::InitError>,
+        I: IntoNewService<B>,
+        F: FnMut(Self::Response, &mut B::Service) -> Out,
+        Out: IntoFuture,
+        Out::Error: Into<Self::Error>,
     {
-        self.and_then(ApplyNewService::new(service, f))
+        AndThenApplyNewService::new(self, service, f)
     }
 
     /// Call another service after call to this one has resolved successfully.
     fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B, Self::Response>,
-        B: NewService<Self::Response, Error = Self::Error, InitError = Self::InitError>,
+        F: IntoNewService<B>,
+        B: NewService<
+            Config = Self::Config,
+            Request = Self::Response,
+            Error = Self::Error,
+            InitError = Self::InitError,
+        >,
     {
         AndThenNewService::new(self, new_service)
     }
@@ -224,9 +277,10 @@ pub trait NewService<Request> {
     fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B, Result<Self::Response, Self::Error>>,
+        F: IntoNewService<B>,
         B: NewService<
-            Result<Self::Response, Self::Error>,
+            Config = Self::Config,
+            Request = Result<Self::Response, Self::Error>,
             Error = Self::Error,
             InitError = Self::InitError,
         >,
@@ -239,7 +293,7 @@ pub trait NewService<Request> {
     fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
     where
         Self: Sized,
-        F: Fn(Self::Response) -> R,
+        F: FnMut(Self::Response) -> R,
     {
         MapNewService::new(self, f)
     }
@@ -248,12 +302,12 @@ pub trait NewService<Request> {
     fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
     where
         Self: Sized,
-        F: Fn(Self::Error) -> E,
+        F: Fn(Self::Error) -> E + Clone,
     {
         MapErrNewService::new(self, f)
     }
 
-    /// Map this service's init error to a different error, returning a new service.
+    /// Map this factory's init error to a different error, returning a new service.
     fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
     where
         Self: Sized,
@@ -261,12 +315,30 @@ pub trait NewService<Request> {
     {
         MapInitErr::new(self, f)
     }
+
+    /// Map config to a different error, returning a new service.
+    fn map_config<F, C>(self, f: F) -> MapConfig<Self, F, C>
+    where
+        Self: Sized,
+        F: Fn(&C) -> MappedConfig<Self::Config>,
+    {
+        MapConfig::new(self, f)
+    }
+
+    /// Replace config with unit
+    fn unit_config<C>(self) -> UnitConfig<Self, C>
+    where
+        Self: NewService<Config = ()> + Sized,
+    {
+        UnitConfig::new(self)
+    }
 }
 
-impl<'a, S, Request> Service<Request> for &'a mut S
+impl<'a, S> Service for &'a mut S
 where
-    S: Service<Request> + 'a,
+    S: Service + 'a,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -275,15 +347,16 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Request) -> S::Future {
+    fn call(&mut self, request: Self::Request) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S, Request> Service<Request> for Box<S>
+impl<S> Service for Box<S>
 where
-    S: Service<Request> + ?Sized,
+    S: Service + ?Sized,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -292,58 +365,93 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Request) -> S::Future {
+    fn call(&mut self, request: Self::Request) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<F, R, E, S, Request> NewService<Request> for F
+impl<S> Service for Rc<RefCell<S>>
 where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service<Request>,
+    S: Service,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
-    type Service = S;
-    type InitError = E;
-    type Future = R::Future;
+    type Future = S::Future;
 
-    fn new_service(&self) -> Self::Future {
-        (*self)().into_future()
+    fn poll_ready(&mut self) -> Poll<(), S::Error> {
+        self.borrow_mut().poll_ready()
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        self.borrow_mut().call(request)
+    }
+}
+
+impl<S> NewService for Rc<S>
+where
+    S: NewService,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Config = S::Config;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
+
+    fn new_service(&self, cfg: &S::Config) -> S::Future {
+        self.as_ref().new_service(cfg)
+    }
+}
+
+impl<S> NewService for Arc<S>
+where
+    S: NewService,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Config = S::Config;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
+
+    fn new_service(&self, cfg: &S::Config) -> S::Future {
+        self.as_ref().new_service(cfg)
     }
 }
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T, Request>
+pub trait IntoService<T>
 where
-    T: Service<Request>,
+    T: Service,
 {
     /// Convert to a `Service`
     fn into_service(self) -> T;
 }
 
-/// Trait for types that can be converted to a Service
-pub trait IntoNewService<T, Request>
+/// Trait for types that can be converted to a `NewService`
+pub trait IntoNewService<T>
 where
-    T: NewService<Request>,
+    T: NewService,
 {
     /// Convert to an `NewService`
     fn into_new_service(self) -> T;
 }
 
-impl<T, Request> IntoService<T, Request> for T
+impl<T> IntoService<T> for T
 where
-    T: Service<Request>,
+    T: Service,
 {
     fn into_service(self) -> T {
         self
     }
 }
 
-impl<T, Request> IntoNewService<T, Request> for T
+impl<T> IntoNewService<T> for T
 where
-    T: NewService<Request>,
+    T: NewService,
 {
     fn into_new_service(self) -> T {
         self

actix-service/src/map.rs

@@ -15,10 +15,10 @@ pub struct Map<A, F, Response> {
 
 impl<A, F, Response> Map<A, F, Response> {
     /// Create new `Map` combinator
-    pub fn new<Request>(service: A, f: F) -> Self
+    pub fn new(service: A, f: F) -> Self
     where
-        A: Service<Request>,
-        F: Fn(A::Response) -> Response,
+        A: Service,
+        F: FnMut(A::Response) -> Response,
     {
         Self {
             service,
@@ -42,47 +42,48 @@ where
     }
 }
 
-impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
+impl<A, F, Response> Service for Map<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response + Clone,
+    A: Service,
+    F: FnMut(A::Response) -> Response + Clone,
 {
+    type Request = A::Request;
     type Response = Response;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Request, Response>;
+    type Future = MapFuture<A, F, Response>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapFuture<A, F, Request, Response>
+pub struct MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
+impl<A, F, Response> MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
+impl<A, F, Response> Future for MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     type Item = Response;
     type Error = A::Error;
@@ -96,18 +97,18 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapNewService<A, F, Response> {
+pub struct MapNewService<A, F, Res> {
     a: A,
     f: F,
-    r: PhantomData<Response>,
+    r: PhantomData<Res>,
 }
 
-impl<A, F, Response> MapNewService<A, F, Response> {
+impl<A, F, Res> MapNewService<A, F, Res> {
     /// Create new `Map` new service instance
-    pub fn new<Request>(a: A, f: F) -> Self
+    pub fn new(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
-        F: Fn(A::Response) -> Response,
+        A: NewService,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             a,
@@ -117,7 +118,7 @@ impl<A, F, Response> MapNewService<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for MapNewService<A, F, Response>
+impl<A, F, Res> Clone for MapNewService<A, F, Res>
 where
     A: Clone,
     F: Clone,
@@ -131,48 +132,50 @@ where
     }
 }
 
-impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
+impl<A, F, Res> NewService for MapNewService<A, F, Res>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response + Clone,
+    A: NewService,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Response = Response;
+    type Request = A::Request;
+    type Response = Res;
     type Error = A::Error;
-    type Service = Map<A::Service, F, Response>;
 
+    type Config = A::Config;
+    type Service = Map<A::Service, F, Res>;
     type InitError = A::InitError;
-    type Future = MapNewServiceFuture<A, F, Request, Response>;
+    type Future = MapNewServiceFuture<A, F, Res>;
 
-    fn new_service(&self) -> Self::Future {
-        MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        MapNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, Request, Response>
+pub struct MapNewServiceFuture<A, F, Res>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService,
+    F: FnMut(A::Response) -> Res,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
+impl<A, F, Res> MapNewServiceFuture<A, F, Res>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapNewServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
+impl<A, F, Res> Future for MapNewServiceFuture<A, F, Res>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService,
+    F: FnMut(A::Response) -> Res,
 {
-    type Item = Map<A::Service, F, Response>;
+    type Item = Map<A::Service, F, Res>;
     type Error = A::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -189,10 +192,11 @@ mod tests {
     use futures::future::{ok, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, Service};
+    use crate::{IntoNewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -226,7 +230,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().map(|_| "ok");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready("ok"));

actix-service/src/map_config.rs

@@ -0,0 +1,112 @@
+use std::marker::PhantomData;
+
+use super::NewService;
+
+pub enum MappedConfig<'a, T> {
+    Ref(&'a T),
+    Owned(T),
+}
+
+/// `MapInitErr` service combinator
+pub struct MapConfig<A, F, C> {
+    a: A,
+    f: F,
+    e: PhantomData<C>,
+}
+
+impl<A, F, C> MapConfig<A, F, C> {
+    /// Create new `MapConfig` combinator
+    pub fn new(a: A, f: F) -> Self
+    where
+        A: NewService,
+        F: Fn(&C) -> MappedConfig<A::Config>,
+    {
+        Self {
+            a,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, C> Clone for MapConfig<A, F, C>
+where
+    A: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, C> NewService for MapConfig<A, F, C>
+where
+    A: NewService,
+    F: Fn(&C) -> MappedConfig<A::Config>,
+{
+    type Request = A::Request;
+    type Response = A::Response;
+    type Error = A::Error;
+
+    type Config = C;
+    type Service = A::Service;
+    type InitError = A::InitError;
+    type Future = A::Future;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        match (self.f)(cfg) {
+            MappedConfig::Ref(cfg) => self.a.new_service(cfg),
+            MappedConfig::Owned(cfg) => self.a.new_service(&cfg),
+        }
+    }
+}
+
+/// `MapInitErr` service combinator
+pub struct UnitConfig<A, C> {
+    a: A,
+    e: PhantomData<C>,
+}
+
+impl<A, C> UnitConfig<A, C> {
+    /// Create new `UnitConfig` combinator
+    pub fn new(a: A) -> Self
+    where
+        A: NewService<Config = ()>,
+    {
+        Self { a, e: PhantomData }
+    }
+}
+
+impl<A, C> Clone for UnitConfig<A, C>
+where
+    A: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, C> NewService for UnitConfig<A, C>
+where
+    A: NewService<Config = ()>,
+{
+    type Request = A::Request;
+    type Response = A::Response;
+    type Error = A::Error;
+
+    type Config = C;
+    type Service = A::Service;
+    type InitError = A::InitError;
+    type Future = A::Future;
+
+    fn new_service(&self, _: &C) -> Self::Future {
+        self.a.new_service(&())
+    }
+}

actix-service/src/map_err.rs

@@ -16,9 +16,9 @@ pub struct MapErr<A, F, E> {
 
 impl<A, F, E> MapErr<A, F, E> {
     /// Create new `MapErr` combinator
-    pub fn new<Request>(service: A, f: F) -> Self
+    pub fn new(service: A, f: F) -> Self
     where
-        A: Service<Request>,
+        A: Service,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -43,36 +43,37 @@ where
     }
 }
 
-impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
+impl<A, F, E> Service for MapErr<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E + Clone,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E, Request>;
+    type Future = MapErrFuture<A, F, E>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(&self.f)
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapErrFuture<A, F, E, Request>
+pub struct MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
+impl<A, F, E> MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -80,9 +81,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
+impl<A, F, E> Future for MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     type Item = A::Response;
@@ -97,19 +98,23 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrNewService<A, F, E> {
+pub struct MapErrNewService<A, F, E>
+where
+    A: NewService,
+    F: Fn(A::Error) -> E + Clone,
+{
     a: A,
     f: F,
     e: PhantomData<E>,
 }
 
-impl<A, F, E> MapErrNewService<A, F, E> {
+impl<A, F, E> MapErrNewService<A, F, E>
+where
+    A: NewService,
+    F: Fn(A::Error) -> E + Clone,
+{
     /// Create new `MapErr` new service instance
-    pub fn new<Request>(a: A, f: F) -> Self
-    where
-        A: NewService<Request>,
-        F: Fn(A::Error) -> E,
-    {
+    pub fn new(a: A, f: F) -> Self {
         Self {
             a,
             f,
@@ -120,8 +125,8 @@ impl<A, F, E> MapErrNewService<A, F, E> {
 
 impl<A, F, E> Clone for MapErrNewService<A, F, E>
 where
-    A: Clone,
-    F: Clone,
+    A: NewService + Clone,
+    F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -132,35 +137,37 @@ where
     }
 }
 
-impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
+impl<A, F, E> NewService for MapErrNewService<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::Error) -> E + Clone,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
+
+    type Config = A::Config;
     type Service = MapErr<A::Service, F, E>;
-
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E, Request>;
+    type Future = MapErrNewServiceFuture<A, F, E>;
 
-    fn new_service(&self) -> Self::Future {
-        MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        MapErrNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E, Request>
+pub struct MapErrNewServiceFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
+impl<A, F, E> MapErrNewServiceFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -168,9 +175,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
+impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
@@ -190,11 +197,12 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, NewService, Service};
+    use crate::{IntoNewService, NewService, Service, ServiceExt};
 
     struct Srv;
 
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -228,7 +236,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().map_err(|_| "error");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_err());
             assert_eq!(res.err().unwrap(), "error");

actix-service/src/map_init_err.rs

@@ -13,9 +13,9 @@ pub struct MapInitErr<A, F, E> {
 
 impl<A, F, E> MapInitErr<A, F, E> {
     /// Create new `MapInitErr` combinator
-    pub fn new<Request>(a: A, f: F) -> Self
+    pub fn new(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
+        A: NewService,
         F: Fn(A::InitError) -> E,
     {
         Self {
@@ -40,35 +40,37 @@ where
     }
 }
 
-impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
+impl<A, F, E> NewService for MapInitErr<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::InitError) -> E + Clone,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
+
+    type Config = A::Config;
     type Service = A::Service;
-
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E, Request>;
+    type Future = MapInitErrFuture<A, F, E>;
 
-    fn new_service(&self) -> Self::Future {
-        MapInitErrFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapInitErrFuture<A, F, E, Request>
+pub struct MapInitErrFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
+impl<A, F, E> MapInitErrFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -76,9 +78,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
+impl<A, F, E> Future for MapInitErrFuture<A, F, E>
 where
-    A: NewService<Request>,
+    A: NewService,
     F: Fn(A::InitError) -> E,
 {
     type Item = A::Service;

actix-service/src/then.rs

@@ -1,4 +1,4 @@
-use futures::{try_ready, Async, Future, Poll};
+use futures::{Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
 use crate::cell::Cell;
@@ -14,10 +14,10 @@ pub struct Then<A, B> {
 
 impl<A, B> Then<A, B> {
     /// Create new `Then` combinator
-    pub fn new<Request>(a: A, b: B) -> Then<A, B>
+    pub fn new(a: A, b: B) -> Then<A, B>
     where
-        A: Service<Request>,
-        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+        A: Service,
+        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
     {
         Then { a, b: Cell::new(b) }
     }
@@ -35,53 +35,58 @@ where
     }
 }
 
-impl<A, B, Request> Service<Request> for Then<A, B>
+impl<A, B> Service for Then<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
 {
+    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenFuture<A, B, Request>;
+    type Future = ThenFuture<A, B>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.a.poll_ready());
-        self.b.get_mut().poll_ready()
+        let not_ready = self.a.poll_ready()?.is_not_ready();
+        if self.b.get_mut().poll_ready()?.is_not_ready() || not_ready {
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
+        }
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         ThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct ThenFuture<A, B, Request>
+pub struct ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
-impl<A, B, Request> ThenFuture<A, B, Request>
+impl<A, B> ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         ThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
 }
 
-impl<A, B, Request> Future for ThenFuture<A, B, Request>
+impl<A, B> Future for ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
     type Item = B::Response;
     type Error = B::Error;
@@ -91,12 +96,14 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        match self.fut_a.as_mut().expect("bug in actix-service").poll() {
             Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.get_mut().call(Ok(resp)));
                 self.poll()
             }
             Err(err) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.get_mut().call(Err(err)));
                 self.poll()
             }
@@ -113,15 +120,16 @@ pub struct ThenNewService<A, B> {
 
 impl<A, B> ThenNewService<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<F, Request>(a: A, f: F) -> Self
+    pub fn new<F>(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
+        A: NewService,
         B: NewService<
-            Result<A::Response, A::Error>,
+            Config = A::Config,
+            Request = Result<A::Response, A::Error>,
             Error = A::Error,
             InitError = A::InitError,
         >,
-        F: IntoNewService<B, Result<A::Response, A::Error>>,
+        F: IntoNewService<B>,
     {
         Self {
             a,
@@ -130,20 +138,27 @@ impl<A, B> ThenNewService<A, B> {
     }
 }
 
-impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
+impl<A, B> NewService for ThenNewService<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
+    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
+
+    type Config = A::Config;
     type Service = Then<A::Service, B::Service>;
-
     type InitError = A::InitError;
-    type Future = ThenNewServiceFuture<A, B, Request>;
+    type Future = ThenNewServiceFuture<A, B>;
 
-    fn new_service(&self) -> Self::Future {
-        ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+        ThenNewServiceFuture::new(self.a.new_service(cfg), self.b.new_service(cfg))
     }
 }
 
@@ -160,10 +175,15 @@ where
     }
 }
 
-pub struct ThenNewServiceFuture<A, B, Request>
+pub struct ThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -171,10 +191,15 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
+impl<A, B> ThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         ThenNewServiceFuture {
@@ -186,10 +211,15 @@ where
     }
 }
 
-impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
+impl<A, B> Future for ThenNewServiceFuture<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService,
+    B: NewService<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     type Item = Then<A::Service, B::Service>;
     type Error = A::InitError;
@@ -221,15 +251,16 @@ where
 #[cfg(test)]
 mod tests {
     use futures::future::{err, ok, FutureResult};
-    use futures::{Async, Poll};
+    use futures::{Async, Future, Poll};
     use std::cell::Cell;
     use std::rc::Rc;
 
-    use super::*;
+    use crate::{IntoNewService, NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
-    impl Service<Result<&'static str, &'static str>> for Srv1 {
+    impl Service for Srv1 {
+        type Request = Result<&'static str, &'static str>;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, Self::Error>;
@@ -249,7 +280,8 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service<Result<&'static str, ()>> for Srv2 {
+    impl Service for Srv2 {
+        type Request = Result<&'static str, ()>;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -297,7 +329,7 @@ mod tests {
         let cnt2 = cnt.clone();
         let blank = move || Ok::<_, ()>(Srv1(cnt2.clone()));
         let new_srv = blank.into_new_service().then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.clone().new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.clone().new_service(&()).poll().unwrap() {
             let res = srv.call(Ok("srv1")).poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready(("srv1", "ok")));

actix-service/src/transform.rs

@@ -0,0 +1,232 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
+use futures::{Async, Future, IntoFuture, Poll};
+
+use crate::transform_err::{TransformFromErr, TransformMapInitErr};
+use crate::{IntoNewService, NewService, Service};
+
+/// The `Transform` trait defines the interface of a Service factory. `Transform`
+/// is often implemented for middleware, defining how to construct a
+/// middleware Service. A Service that is constructed by the factory takes
+/// the Service that follows it during execution as a parameter, assuming
+/// ownership of the next Service.
+pub trait Transform<S> {
+    /// Requests handled by the service.
+    type Request;
+
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The `TransformService` value created by this factory
+    type Transform: Service<
+        Request = Self::Request,
+        Response = Self::Response,
+        Error = Self::Error,
+    >;
+
+    /// Errors produced while building a service.
+    type InitError;
+
+    /// The future response value.
+    type Future: Future<Item = Self::Transform, Error = Self::InitError>;
+
+    /// Creates and returns a new Service component, asynchronously
+    fn new_transform(&self, service: S) -> Self::Future;
+
+    /// Map this service's factory error to a different error,
+    /// returning a new transform service factory.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E,
+    {
+        TransformMapInitErr::new(self, f)
+    }
+
+    /// Map this service's init error to any error implementing `From` for
+    /// this service`s `Error`.
+    ///
+    /// Note that this function consumes the receiving transform and returns a
+    /// wrapped version of it.
+    fn from_err<E>(self) -> TransformFromErr<Self, S, E>
+    where
+        Self: Sized,
+        E: From<Self::InitError>,
+    {
+        TransformFromErr::new(self)
+    }
+
+    // /// Map this service's init error to service's init error
+    // /// if it is implementing `Into` to this service`s `InitError`.
+    // ///
+    // /// Note that this function consumes the receiving transform and returns a
+    // /// wrapped version of it.
+    // fn into_err<E>(self) -> TransformIntoErr<Self, S>
+    // where
+    //     Self: Sized,
+    //     Self::InitError: From<Self::InitError>,
+    // {
+    //     TransformFromErr::new(self)
+    // }
+}
+
+impl<T, S> Transform<S> for Rc<T>
+where
+    T: Transform<S>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+impl<T, S> Transform<S> for Arc<T>
+where
+    T: Transform<S>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+/// Trait for types that can be converted to a *transform service*
+pub trait IntoTransform<T, S>
+where
+    T: Transform<S>,
+{
+    /// Convert to a `TransformService`
+    fn into_transform(self) -> T;
+}
+
+impl<T, S> IntoTransform<T, S> for T
+where
+    T: Transform<S>,
+{
+    fn into_transform(self) -> T {
+        self
+    }
+}
+
+/// Apply transform to service factory. Function returns
+/// services factory that in initialization creates
+/// service and applies transform to this service.
+pub fn apply_transform<T, S, F, U>(
+    t: F,
+    service: U,
+) -> impl NewService<
+    Config = S::Config,
+    Request = T::Request,
+    Response = T::Response,
+    Error = T::Error,
+    Service = T::Transform,
+    InitError = S::InitError,
+> + Clone
+where
+    S: NewService,
+    T: Transform<S::Service, InitError = S::InitError>,
+    F: IntoTransform<T, S::Service>,
+    U: IntoNewService<S>,
+{
+    ApplyTransform::new(t.into_transform(), service.into_new_service())
+}
+
+/// `Apply` transform to new service
+pub struct ApplyTransform<T, S> {
+    s: Rc<S>,
+    t: Rc<T>,
+}
+
+impl<T, S> ApplyTransform<T, S>
+where
+    S: NewService,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    /// Create new `ApplyTransform` new service instance
+    pub fn new<F: IntoTransform<T, S::Service>>(t: F, service: S) -> Self {
+        Self {
+            s: Rc::new(service),
+            t: Rc::new(t.into_transform()),
+        }
+    }
+}
+
+impl<T, S> Clone for ApplyTransform<T, S> {
+    fn clone(&self) -> Self {
+        ApplyTransform {
+            s: self.s.clone(),
+            t: self.t.clone(),
+        }
+    }
+}
+
+impl<T, S> NewService for ApplyTransform<T, S>
+where
+    S: NewService,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type Config = S::Config;
+    type Service = T::Transform;
+    type InitError = T::InitError;
+    type Future = ApplyTransformFuture<T, S>;
+
+    fn new_service(&self, cfg: &S::Config) -> Self::Future {
+        ApplyTransformFuture {
+            t_cell: self.t.clone(),
+            fut_a: self.s.new_service(cfg).into_future(),
+            fut_t: None,
+        }
+    }
+}
+
+pub struct ApplyTransformFuture<T, S>
+where
+    S: NewService,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    fut_a: S::Future,
+    fut_t: Option<<T::Future as IntoFuture>::Future>,
+    t_cell: Rc<T>,
+}
+
+impl<T, S> Future for ApplyTransformFuture<T, S>
+where
+    S: NewService,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    type Item = T::Transform;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service).into_future());
+            }
+        }
+        if let Some(ref mut fut) = self.fut_t {
+            fut.poll()
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-service/src/transform_err.rs

@@ -0,0 +1,162 @@
+use std::marker::PhantomData;
+
+use futures::{Future, Poll};
+
+use super::Transform;
+
+/// Transform for the `map_err` combinator, changing the type of a new
+/// transform's init error.
+///
+/// This is created by the `Transform::map_err` method.
+pub struct TransformMapInitErr<T, S, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, E)>,
+}
+
+impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+    /// Create new `TransformMapErr` new transform instance
+    pub fn new(t: T, f: F) -> Self
+    where
+        T: Transform<S>,
+        F: Fn(T::InitError) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformMapInitErrFuture<T, S, F, E>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        TransformMapInitErrFuture {
+            fut: self.t.new_transform(service),
+            f: self.f.clone(),
+        }
+    }
+}
+
+pub struct TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E,
+{
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Item = T::Transform;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll().map_err(&self.f)
+    }
+}
+
+/// Transform for the `from_err` combinator, changing the type of a new
+/// transform's init error.
+///
+/// This is created by the `Transform::from_err` method.
+pub struct TransformFromErr<T, S, E> {
+    t: T,
+    e: PhantomData<(S, E)>,
+}
+
+impl<T, S, E> TransformFromErr<T, S, E>
+where
+    T: Transform<S>,
+    E: From<T::InitError>,
+{
+    /// Create new `TransformFromErr` new transform instance
+    pub fn new(t: T) -> Self {
+        Self { t, e: PhantomData }
+    }
+}
+
+impl<T, S, E> Clone for TransformFromErr<T, S, E>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, E> Transform<S> for TransformFromErr<T, S, E>
+where
+    T: Transform<S>,
+    E: From<T::InitError>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformFromErrFuture<T, S, E>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        TransformFromErrFuture {
+            fut: self.t.new_transform(service),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct TransformFromErrFuture<T, S, E>
+where
+    T: Transform<S>,
+    E: From<T::InitError>,
+{
+    fut: T::Future,
+    _t: PhantomData<E>,
+}
+
+impl<T, S, E> Future for TransformFromErrFuture<T, S, E>
+where
+    T: Transform<S>,
+    E: From<T::InitError>,
+{
+    type Item = T::Transform;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll().map_err(E::from)
+    }
+}

actix-test-server/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "actix-test-server"
+version = "0.2.3"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix test server"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-test-server/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+
+[lib]
+name = "actix_test_server"
+path = "src/lib.rs"
+
+[dependencies]
+actix-rt = "0.2.1"
+actix-server = "0.5.0"
+actix-server-config = "0.1.0"
+actix-testing = "0.1.0"
+
+log = "0.4"
+net2 = "0.2"
+futures = "0.1"
+tokio-tcp = "0.1"
+tokio-reactor = "0.1"
+
+[dev-dependencies]
+actix-service = "0.4.0"