Upgrade trust-dns-proto

.travis.yml

@@ -16,7 +16,7 @@ matrix:
 
 env:
   global:
-    # - RUSTFLAGS="-C link-dead-code"
+    - RUSTFLAGS="-C link-dead-code"
     - OPENSSL_VERSION=openssl-1.0.2
 
 before_install:
@@ -33,6 +33,13 @@ script:
     if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
     cargo clean
     cargo test --features="ssl,tls,rust-tls" -- --nocapture
+    cd actix-codec && cargo test && cd ..
+    cd actix-service && cargo test && cd ..
+    cd actix-server && cargo test --features="ssl,tls,rust-tls" -- --nocapture && cd ..
+    cd actix-rt && cargo test && cd ..
+    cd actix-connector && cargo test && cd ..
+    cd actix-utils && cargo test && cd ..
+    cd router && cargo test && cd ..
     fi
   - |
     if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
@@ -40,15 +47,11 @@ script:
     cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
     bash <(curl -s https://codecov.io/bash)
     echo "Uploaded code coverage"
-    fi
+    cd actix-service && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-
+    cd actix-rt && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-# Upload docs
+    cd actix-connector && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-after_success:
+    cd actix-codec && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-  - |
+    cd actix-server && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then
+    cd actix-utils && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-      cargo doc --features "ssl,tls,rust-tls" --no-deps &&
+    cd router && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-      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"
     fi

CHANGES.md

@@ -1,5 +1,68 @@
 # 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

@@ -1,82 +1,36 @@
 [package]
 name = "actix-net"
-version = "0.1.0"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix net - framework for the compisible network services for Rust (experimental)"
 readme = "README.md"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://actix.rs/api/actix-net/stable/actix_net/"
+documentation = "https://docs.rs/actix-net/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
 
-[package.metadata.docs.rs]
+[workspace]
-features = ["ssl", "tls", "rust-tls"]
+members = [
-
+  "actix-codec",
-[badges]
+  "actix-connector",
-travis-ci = { repository = "actix/actix-net", branch = "master" }
+  "actix-rt",
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+  "actix-service",
-codecov = { repository = "actix/actix-net", branch = "master", service = "github" }
+  "actix-server",
-
+  "actix-test-server",
-[lib]
+  "actix-utils",
-name = "actix_net"
+  "router",
-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.0"
-
-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"
-tower-service = "0.1"
-trust-dns-resolver = "0.10.0-alpha.2"
-
-# 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]
+actix-service = "0.1.1"
+actix-codec = "0.1.0"
+actix-rt = { path="actix-rt" }
+actix-server = { path="actix-server", features=["ssl"] }
 env_logger = "0.5"
-
+futures = "0.1.24"
-[profile.release]
+openssl = { version="0.10" }
-lto = true
+tokio-openssl = { version="0.3" }
-opt-level = 3
-codegen-units = 1

README.md

@@ -13,7 +13,7 @@ Actix net - framework for composable network services (experimental)
 
 ```rust
 fn main() {
-    let sys = actix::System::new("test");
+    let sys = actix_rt::System::new("test");
 
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@@ -26,7 +26,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()
+    actix_server::build()
         .bind(
             // configure service pipeline
             "basic", "0.0.0.0:8443",

actix-codec/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## [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.0"
+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"
+futures = "0.1.24"
+tokio-io = "0.1"
+tokio-codec = "0.1"
+log = "0.4"

actix-codec/src/bcodec.rs

@@ -0,0 +1,33 @@
+use std::io;
+
+use bytes::{Bytes, BytesMut};
+use tokio_codec::{Decoder, Encoder};
+
+/// Bytes codec.
+///
+/// Reads/Writes chunks of bytes from a stream.
+#[derive(Debug, Copy, Clone)]
+pub struct BytesCodec;
+
+impl Encoder for BytesCodec {
+    type Item = Bytes;
+    type Error = io::Error;
+
+    fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        dst.extend_from_slice(&item[..]);
+        Ok(())
+    }
+}
+
+impl Decoder for BytesCodec {
+    type Item = BytesMut;
+    type Error = io::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some(src.take()))
+        }
+    }
+}

actix-codec/src/framed.rs

@@ -11,6 +11,9 @@ use tokio_io::{AsyncRead, AsyncWrite};
 use super::framed_read::{framed_read2, framed_read2_with_buffer, FramedRead2};
 use super::framed_write::{framed_write2, framed_write2_with_buffer, FramedWrite2};
 
+const LW: usize = 1024;
+const HW: usize = 8 * 1024;
+
 /// A unified `Stream` and `Sink` interface to an underlying I/O object, using
 /// the `Encoder` and `Decoder` traits to encode and decode frames.
 ///
@@ -45,9 +48,25 @@ where
     /// break them into separate objects, allowing them to interact more easily.
     pub fn new(inner: T, codec: U) -> Framed<T, U> {
         Framed {
-            inner: framed_read2(framed_write2(Fuse(inner, codec))),
+            inner: framed_read2(framed_write2(Fuse(inner, codec), LW, HW)),
         }
     }
+
+    /// Same as `Framed::new()` with ability to specify write buffer low/high capacity watermarks.
+    pub fn new_with_caps(inner: T, codec: U, lw: usize, hw: usize) -> Framed<T, U> {
+        debug_assert!((lw < hw) && hw != 0);
+        Framed {
+            inner: framed_read2(framed_write2(Fuse(inner, codec), lw, hw)),
+        }
+    }
+
+    /// Force send item
+    pub fn force_send(
+        &mut self,
+        item: <U as Encoder>::Item,
+    ) -> Result<(), <U as Encoder>::Error> {
+        self.inner.get_mut().force_send(item)
+    }
 }
 
 impl<T, U> Framed<T, U> {
@@ -75,7 +94,12 @@ impl<T, U> Framed<T, U> {
     pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
         Framed {
             inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse(parts.io, parts.codec), parts.write_buf),
+                framed_write2_with_buffer(
+                    Fuse(parts.io, parts.codec),
+                    parts.write_buf,
+                    parts.write_buf_lw,
+                    parts.write_buf_hw,
+                ),
                 parts.read_buf,
             ),
         }
@@ -111,6 +135,16 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.get_mut().get_mut().0
     }
 
+    /// Check if write buffer is empty.
+    pub fn is_write_buf_empty(&self) -> bool {
+        self.inner.get_ref().is_empty()
+    }
+
+    /// Check if write buffer is full.
+    pub fn is_write_buf_full(&self) -> bool {
+        self.inner.get_ref().is_full()
+    }
+
     /// Consumes the `Frame`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream
@@ -123,11 +157,27 @@ impl<T, U> Framed<T, U> {
     /// Consume the `Frame`, returning `Frame` with different codec.
     pub fn into_framed<U2>(self, codec: U2) -> Framed<T, U2> {
         let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
+        let (inner, write_buf, lw, hw) = inner.into_parts();
 
         Framed {
             inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse(inner.0, codec), write_buf),
+                framed_write2_with_buffer(Fuse(inner.0, codec), 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
+        F: Fn(U) -> U2,
+    {
+        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(inner.0, f(inner.1)), write_buf, lw, hw),
                 read_buf,
             ),
         }
@@ -141,13 +191,15 @@ impl<T, U> Framed<T, U> {
     /// being worked with.
     pub fn into_parts(self) -> FramedParts<T, U> {
         let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
+        let (inner, write_buf, write_buf_lw, write_buf_hw) = inner.into_parts();
 
         FramedParts {
             io: inner.0,
             codec: inner.1,
-            read_buf: read_buf,
+            read_buf,
-            write_buf: write_buf,
+            write_buf,
+            write_buf_lw,
+            write_buf_hw,
             _priv: (),
         }
     }
@@ -176,7 +228,8 @@ where
     type SinkError = U::Error;
 
     fn start_send(
-        &mut self, item: Self::SinkItem,
+        &mut self,
+        item: Self::SinkItem,
     ) -> StartSend<Self::SinkItem, Self::SinkError> {
         self.inner.get_mut().start_send(item)
     }
@@ -272,6 +325,12 @@ pub struct FramedParts<T, U> {
     /// A buffer with unprocessed data which are not written yet.
     pub write_buf: BytesMut,
 
+    /// A buffer low watermark capacity
+    pub write_buf_lw: usize,
+
+    /// A buffer high watermark capacity
+    pub write_buf_hw: usize,
+
     /// This private field allows us to add additional fields in the future in a
     /// backwards compatible way.
     _priv: (),
@@ -285,6 +344,8 @@ impl<T, U> FramedParts<T, U> {
             codec,
             read_buf: BytesMut::new(),
             write_buf: BytesMut::new(),
+            write_buf_lw: LW,
+            write_buf_hw: HW,
             _priv: (),
         }
     }

actix-codec/src/framed_read.rs

@@ -1,7 +1,8 @@
 use std::fmt;
 
 use bytes::BytesMut;
-use futures::{Async, Poll, Sink, StartSend, Stream};
+use futures::{try_ready, Async, Poll, Sink, StartSend, Stream};
+use log::trace;
 use tokio_codec::Decoder;
 use tokio_io::AsyncRead;
 
@@ -98,7 +99,8 @@ where
     type SinkError = T::SinkError;
 
     fn start_send(
-        &mut self, item: Self::SinkItem,
+        &mut self,
+        item: Self::SinkItem,
     ) -> StartSend<Self::SinkItem, Self::SinkError> {
         self.inner.inner.0.start_send(item)
     }
@@ -132,7 +134,7 @@ where
 
 pub fn framed_read2<T>(inner: T) -> FramedRead2<T> {
     FramedRead2 {
-        inner: inner,
+        inner,
         eof: false,
         is_readable: false,
         buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
@@ -145,9 +147,9 @@ pub fn framed_read2_with_buffer<T>(inner: T, mut buf: BytesMut) -> FramedRead2<T
         buf.reserve(bytes_to_reserve);
     }
     FramedRead2 {
-        inner: inner,
+        inner,
         eof: false,
-        is_readable: buf.len() > 0,
+        is_readable: !buf.is_empty(),
         buffer: buf,
     }
 }
@@ -186,13 +188,13 @@ where
             // readable again, at which point the stream is terminated.
             if self.is_readable {
                 if self.eof {
-                    let frame = try!(self.inner.decode_eof(&mut self.buffer));
+                    let frame = self.inner.decode_eof(&mut self.buffer)?;
                     return Ok(Async::Ready(frame));
                 }
 
                 trace!("attempting to decode a frame");
 
-                if let Some(frame) = try!(self.inner.decode(&mut self.buffer)) {
+                if let Some(frame) = self.inner.decode(&mut self.buffer)? {
                     trace!("frame decoded from buffer");
                     return Ok(Async::Ready(Some(frame)));
                 }

actix-codec/src/framed_write.rs

@@ -2,7 +2,8 @@ use std::fmt;
 use std::io::{self, Read};
 
 use bytes::BytesMut;
-use futures::{Async, AsyncSink, Poll, Sink, StartSend, Stream};
+use futures::{try_ready, Async, AsyncSink, Poll, Sink, StartSend, Stream};
+use log::trace;
 use tokio_codec::{Decoder, Encoder};
 use tokio_io::{AsyncRead, AsyncWrite};
 
@@ -16,20 +17,19 @@ pub struct FramedWrite<T, E> {
 pub struct FramedWrite2<T> {
     inner: T,
     buffer: BytesMut,
+    low_watermark: usize,
+    high_watermark: usize,
 }
 
-const INITIAL_CAPACITY: usize = 8 * 1024;
-const BACKPRESSURE_BOUNDARY: usize = INITIAL_CAPACITY;
-
 impl<T, E> FramedWrite<T, E>
 where
     T: AsyncWrite,
     E: Encoder,
 {
     /// Creates a new `FramedWrite` with the given `encoder`.
-    pub fn new(inner: T, encoder: E) -> FramedWrite<T, E> {
+    pub fn new(inner: T, encoder: E, lw: usize, hw: usize) -> FramedWrite<T, E> {
         FramedWrite {
-            inner: framed_write2(Fuse(inner, encoder)),
+            inner: framed_write2(Fuse(inner, encoder), lw, hw),
         }
     }
 }
@@ -73,6 +73,26 @@ impl<T, E> FramedWrite<T, E> {
     pub fn encoder_mut(&mut self) -> &mut E {
         &mut self.inner.inner.1
     }
+
+    /// Check if write buffer is full
+    pub fn is_full(&self) -> bool {
+        self.inner.is_full()
+    }
+
+    /// Check if write buffer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
+impl<T, E> FramedWrite<T, E>
+where
+    E: Encoder,
+{
+    /// Force send item
+    pub fn force_send(&mut self, item: E::Item) -> Result<(), E::Error> {
+        self.inner.force_send(item)
+    }
 }
 
 impl<T, E> Sink for FramedWrite<T, E>
@@ -92,7 +112,7 @@ where
     }
 
     fn close(&mut self) -> Poll<(), Self::SinkError> {
-        Ok(try!(self.inner.close()))
+        Ok(self.inner.close()?)
     }
 }
 
@@ -124,21 +144,34 @@ where
 
 // ===== impl FramedWrite2 =====
 
-pub fn framed_write2<T>(inner: T) -> FramedWrite2<T> {
+pub fn framed_write2<T>(
+    inner: T,
+    low_watermark: usize,
+    high_watermark: usize,
+) -> FramedWrite2<T> {
     FramedWrite2 {
-        inner: inner,
+        inner,
-        buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
+        low_watermark,
+        high_watermark,
+        buffer: BytesMut::with_capacity(high_watermark),
     }
 }
 
-pub fn framed_write2_with_buffer<T>(inner: T, mut buf: BytesMut) -> FramedWrite2<T> {
+pub fn framed_write2_with_buffer<T>(
-    if buf.capacity() < INITIAL_CAPACITY {
+    inner: T,
-        let bytes_to_reserve = INITIAL_CAPACITY - buf.capacity();
+    mut buffer: BytesMut,
-        buf.reserve(bytes_to_reserve);
+    low_watermark: usize,
+    high_watermark: usize,
+) -> FramedWrite2<T> {
+    if buffer.capacity() < high_watermark {
+        let bytes_to_reserve = high_watermark - buffer.capacity();
+        buffer.reserve(bytes_to_reserve);
     }
     FramedWrite2 {
-        inner: inner,
+        inner,
-        buffer: buf,
+        buffer,
+        low_watermark,
+        high_watermark,
     }
 }
 
@@ -151,13 +184,40 @@ impl<T> FramedWrite2<T> {
         self.inner
     }
 
-    pub fn into_parts(self) -> (T, BytesMut) {
+    pub fn into_parts(self) -> (T, BytesMut, usize, usize) {
-        (self.inner, self.buffer)
+        (
+            self.inner,
+            self.buffer,
+            self.low_watermark,
+            self.high_watermark,
+        )
     }
 
     pub fn get_mut(&mut self) -> &mut T {
         &mut self.inner
     }
+
+    pub fn is_full(&self) -> bool {
+        self.buffer.len() >= self.high_watermark
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+}
+
+impl<T> FramedWrite2<T>
+where
+    T: Encoder,
+{
+    pub fn force_send(&mut self, item: T::Item) -> Result<(), T::Error> {
+        let len = self.buffer.len();
+        if len < self.low_watermark {
+            self.buffer.reserve(self.high_watermark - len)
+        }
+        self.inner.encode(item, &mut self.buffer)?;
+        Ok(())
+    }
 }
 
 impl<T> Sink for FramedWrite2<T>
@@ -168,18 +228,16 @@ where
     type SinkError = T::Error;
 
     fn start_send(&mut self, item: T::Item) -> StartSend<T::Item, T::Error> {
-        // If the buffer is already over 8KiB, then attempt to flush it. If after
+        // Check the buffer capacity
-        // flushing it's *still* over 8KiB, then apply backpressure (reject the
+        let len = self.buffer.len();
-        // send).
+        if len >= self.high_watermark {
-        if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
+            return Ok(AsyncSink::NotReady(item));
-            try!(self.poll_complete());
+        }
-
+        if len < self.low_watermark {
-            if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
+            self.buffer.reserve(self.high_watermark - len)
-                return Ok(AsyncSink::NotReady(item));
-            }
         }
 
-        try!(self.inner.encode(item, &mut self.buffer));
+        self.inner.encode(item, &mut self.buffer)?;
 
         Ok(AsyncSink::Ready)
     }
@@ -197,7 +255,8 @@ where
                     io::ErrorKind::WriteZero,
                     "failed to \
                      write frame to transport",
-                ).into());
+                )
+                .into());
             }
 
             // TODO: Add a way to `bytes` to do this w/o returning the drained
@@ -209,12 +268,12 @@ where
         try_ready!(self.inner.poll_flush());
 
         trace!("framed transport flushed");
-        return Ok(Async::Ready(()));
+        Ok(Async::Ready(()))
     }
 
     fn close(&mut self) -> Poll<(), Self::SinkError> {
         try_ready!(self.poll_complete());
-        Ok(try!(self.inner.shutdown()))
+        Ok(self.inner.shutdown()?)
     }
 }
 

actix-codec/src/lib.rs

@@ -10,14 +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-connector/CHANGES.md

@@ -0,0 +1,10 @@
+# Changes
+
+## [0.1.1] - 2019-01-13
+
+* Upgrade trust-dns-proto
+
+
+## [0.1.0] - 2018-12-09
+
+* Move server to separate crate

actix-connector/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "actix-connector"
+version = "0.1.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-net/"
+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"]
+
+[lib]
+name = "actix_connector"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# openssl
+ssl = ["openssl", "tokio-openssl"]
+
+[dependencies]
+actix-service = "0.1.1"
+actix-codec = "0.1.0"
+actix-rt = "0.1.0"
+futures = "0.1"
+tokio-tcp = "0.1"
+trust-dns-proto = "0.6.2"
+trust-dns-resolver = "0.10.2"
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.3", optional = true }

actix-connector/src/connector.rs

@@ -0,0 +1,382 @@
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::net::{IpAddr, SocketAddr};
+use std::time::Duration;
+use std::{fmt, io};
+
+use actix_service::{NewService, Service};
+use futures::future::{ok, Either, FutureResult};
+use futures::{try_ready, Async, Future, Poll};
+use tokio_tcp::{ConnectFuture, TcpStream};
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+use trust_dns_resolver::system_conf::read_system_conf;
+
+use super::resolver::{RequestHost, ResolveError, Resolver, ResolverFuture};
+
+/// Port of the request
+pub trait RequestPort {
+    fn port(&self) -> u16;
+}
+
+// #[derive(Fail, Debug)]
+#[derive(Debug)]
+pub enum ConnectorError {
+    /// Failed to resolve the hostname
+    // #[fail(display = "Failed resolving hostname: {}", _0)]
+    Resolver(ResolveError),
+
+    /// No dns records
+    // #[fail(display = "No dns records found for the input")]
+    NoRecords,
+
+    /// Connecting took too long
+    // #[fail(display = "Timeout out while establishing connection")]
+    Timeout,
+
+    /// Invalid input
+    InvalidInput,
+
+    /// Connection io error
+    // #[fail(display = "{}", _0)]
+    IoError(io::Error),
+}
+
+impl From<ResolveError> for ConnectorError {
+    fn from(err: ResolveError) -> Self {
+        ConnectorError::Resolver(err)
+    }
+}
+
+impl From<io::Error> for ConnectorError {
+    fn from(err: io::Error) -> Self {
+        ConnectorError::IoError(err)
+    }
+}
+
+/// Connect request
+#[derive(Eq, PartialEq, Debug, Hash)]
+pub struct Connect {
+    pub kind: ConnectKind,
+    pub timeout: Duration,
+}
+
+#[derive(Eq, PartialEq, Debug, Hash)]
+pub enum ConnectKind {
+    Host { host: String, port: u16 },
+    Addr { host: String, addr: SocketAddr },
+}
+
+impl Connect {
+    /// Create new `Connect` instance.
+    pub fn new<T: AsRef<str>>(host: T, port: u16) -> Connect {
+        Connect {
+            kind: ConnectKind::Host {
+                host: host.as_ref().to_owned(),
+                port,
+            },
+            timeout: Duration::from_secs(1),
+        }
+    }
+
+    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
+    pub fn with<T: AsRef<str>>(host: T) -> Result<Connect, ConnectorError> {
+        let mut parts_iter = host.as_ref().splitn(2, ':');
+        let host = parts_iter.next().ok_or(ConnectorError::InvalidInput)?;
+        let port_str = parts_iter.next().unwrap_or("");
+        let port = port_str
+            .parse::<u16>()
+            .map_err(|_| ConnectorError::InvalidInput)?;
+        Ok(Connect {
+            kind: ConnectKind::Host {
+                host: host.to_owned(),
+                port,
+            },
+            timeout: Duration::from_secs(1),
+        })
+    }
+
+    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
+    pub fn with_address<T: Into<String>>(host: T, addr: SocketAddr) -> Connect {
+        Connect {
+            kind: ConnectKind::Addr {
+                addr,
+                host: host.into(),
+            },
+            timeout: Duration::from_secs(1),
+        }
+    }
+
+    /// Set connect timeout
+    ///
+    /// By default timeout is set to a 1 second.
+    pub fn timeout(mut self, timeout: Duration) -> Connect {
+        self.timeout = timeout;
+        self
+    }
+}
+
+impl RequestHost for Connect {
+    fn host(&self) -> &str {
+        match self.kind {
+            ConnectKind::Host { ref host, .. } => host,
+            ConnectKind::Addr { ref host, .. } => host,
+        }
+    }
+}
+
+impl RequestPort for Connect {
+    fn port(&self) -> u16 {
+        match self.kind {
+            ConnectKind::Host { port, .. } => port,
+            ConnectKind::Addr { addr, .. } => addr.port(),
+        }
+    }
+}
+
+impl fmt::Display for Connect {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}:{}", self.host(), self.port())
+    }
+}
+
+/// Tcp connector
+pub struct Connector {
+    resolver: Resolver<Connect>,
+}
+
+impl Default for Connector {
+    fn default() -> Self {
+        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
+            (cfg, opts)
+        } else {
+            (ResolverConfig::default(), ResolverOpts::default())
+        };
+
+        Connector::new(cfg, opts)
+    }
+}
+
+impl Connector {
+    /// Create new connector with resolver configuration
+    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
+        Connector {
+            resolver: Resolver::new(cfg, opts),
+        }
+    }
+
+    /// Create new connector with custom resolver
+    pub fn with_resolver(
+        resolver: Resolver<Connect>,
+    ) -> impl Service<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone
+    {
+        Connector { resolver }
+    }
+
+    /// Create new default connector service
+    pub fn new_service_with_config<E>(
+        cfg: ResolverConfig,
+        opts: ResolverOpts,
+    ) -> impl NewService<
+        Connect,
+        Response = (Connect, TcpStream),
+        Error = ConnectorError,
+        InitError = E,
+    > + Clone {
+        move || -> FutureResult<Connector, E> { ok(Connector::new(cfg.clone(), opts)) }
+    }
+}
+
+impl Clone for Connector {
+    fn clone(&self) -> Self {
+        Connector {
+            resolver: self.resolver.clone(),
+        }
+    }
+}
+
+impl Service<Connect> for Connector {
+    type Response = (Connect, TcpStream);
+    type Error = ConnectorError;
+    type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect) -> Self::Future {
+        match req.kind {
+            ConnectKind::Host { .. } => Either::A(ConnectorFuture {
+                fut: self.resolver.call(req),
+                fut2: None,
+            }),
+            ConnectKind::Addr { addr, .. } => {
+                let mut addrs = VecDeque::new();
+                addrs.push_back(addr.ip());
+                Either::B(ConnectorTcpFuture {
+                    fut: TcpConnectorResponse::new(req, addrs),
+                })
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct ConnectorFuture {
+    fut: ResolverFuture<Connect>,
+    fut2: Option<TcpConnectorResponse<Connect>>,
+}
+
+impl Future for ConnectorFuture {
+    type Item = (Connect, TcpStream);
+    type Error = ConnectorError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut2 {
+            return fut.poll().map_err(ConnectorError::from);
+        }
+        match self.fut.poll().map_err(ConnectorError::from)? {
+            Async::Ready((req, addrs)) => {
+                if addrs.is_empty() {
+                    Err(ConnectorError::NoRecords)
+                } else {
+                    self.fut2 = Some(TcpConnectorResponse::new(req, addrs));
+                    self.poll()
+                }
+            }
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct ConnectorTcpFuture {
+    fut: TcpConnectorResponse<Connect>,
+}
+
+impl Future for ConnectorTcpFuture {
+    type Item = (Connect, TcpStream);
+    type Error = ConnectorError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll().map_err(ConnectorError::IoError)
+    }
+}
+
+/// Tcp stream connector service
+pub struct TcpConnector<T: RequestPort>(PhantomData<T>);
+
+impl<T: RequestPort> Default for TcpConnector<T> {
+    fn default() -> TcpConnector<T> {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T: RequestPort> Service<(T, VecDeque<IpAddr>)> for TcpConnector<T> {
+    type Response = (T, TcpStream);
+    type Error = io::Error;
+    type Future = TcpConnectorResponse<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, (req, addrs): (T, VecDeque<IpAddr>)) -> Self::Future {
+        TcpConnectorResponse::new(req, addrs)
+    }
+}
+
+#[doc(hidden)]
+/// Tcp stream connector response future
+pub struct TcpConnectorResponse<T: RequestPort> {
+    port: u16,
+    req: Option<T>,
+    addr: Option<SocketAddr>,
+    addrs: VecDeque<IpAddr>,
+    stream: Option<ConnectFuture>,
+}
+
+impl<T: RequestPort> TcpConnectorResponse<T> {
+    pub fn new(req: T, addrs: VecDeque<IpAddr>) -> TcpConnectorResponse<T> {
+        TcpConnectorResponse {
+            addrs,
+            port: req.port(),
+            req: Some(req),
+            addr: None,
+            stream: None,
+        }
+    }
+}
+
+impl<T: RequestPort> Future for TcpConnectorResponse<T> {
+    type Item = (T, TcpStream);
+    type Error = io::Error;
+
+    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)) => {
+                        return Ok(Async::Ready((self.req.take().unwrap(), sock)))
+                    }
+                    Ok(Async::NotReady) => return Ok(Async::NotReady),
+                    Err(err) => {
+                        if self.addrs.is_empty() {
+                            return Err(err);
+                        }
+                    }
+                }
+            }
+
+            // try to connect
+            let addr = SocketAddr::new(self.addrs.pop_front().unwrap(), self.port);
+            self.stream = Some(TcpStream::connect(&addr));
+            self.addr = Some(addr)
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct DefaultConnector(Connector);
+
+impl Default for DefaultConnector {
+    fn default() -> Self {
+        DefaultConnector(Connector::default())
+    }
+}
+
+impl DefaultConnector {
+    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
+        DefaultConnector(Connector::new(cfg, opts))
+    }
+}
+
+impl Service<Connect> for DefaultConnector {
+    type Response = TcpStream;
+    type Error = ConnectorError;
+    type Future = DefaultConnectorFuture;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.0.poll_ready()
+    }
+
+    fn call(&mut self, req: Connect) -> Self::Future {
+        DefaultConnectorFuture {
+            fut: self.0.call(req),
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct DefaultConnectorFuture {
+    fut: Either<ConnectorFuture, ConnectorTcpFuture>,
+}
+
+impl Future for DefaultConnectorFuture {
+    type Item = TcpStream;
+    type Error = ConnectorError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        Ok(Async::Ready(try_ready!(self.fut.poll()).1))
+    }
+}

actix-connector/src/lib.rs

@@ -0,0 +1,16 @@
+//! Actix Connector - tcp connector service
+//!
+//! ## Package feature
+//!
+//! * `tls` - enables ssl support via `native-tls` crate
+//! * `ssl` - enables ssl support via `openssl` crate
+//! * `rust-tls` - enables ssl support via `rustls` crate
+
+mod connector;
+mod resolver;
+pub mod ssl;
+
+pub use self::connector::{
+    Connect, Connector, ConnectorError, DefaultConnector, RequestPort, TcpConnector,
+};
+pub use self::resolver::{RequestHost, Resolver};

actix-connector/src/resolver.rs

@@ -0,0 +1,128 @@
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::net::IpAddr;
+
+use actix_service::Service;
+use futures::{Async, Future, Poll};
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+pub use trust_dns_resolver::error::ResolveError;
+use trust_dns_resolver::lookup_ip::LookupIpFuture;
+use trust_dns_resolver::system_conf::read_system_conf;
+use trust_dns_resolver::{AsyncResolver, Background};
+
+/// Host name of the request
+pub trait RequestHost {
+    fn host(&self) -> &str;
+}
+
+impl RequestHost for String {
+    fn host(&self) -> &str {
+        self.as_ref()
+    }
+}
+
+pub struct Resolver<T = String> {
+    resolver: AsyncResolver,
+    req: PhantomData<T>,
+}
+
+impl<T: RequestHost> Default for Resolver<T> {
+    fn default() -> Self {
+        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
+            (cfg, opts)
+        } else {
+            (ResolverConfig::default(), ResolverOpts::default())
+        };
+
+        Resolver::new(cfg, opts)
+    }
+}
+
+impl<T: RequestHost> Resolver<T> {
+    /// Create new resolver instance with custom configuration and options.
+    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
+        let (resolver, bg) = AsyncResolver::new(cfg, opts);
+        actix_rt::Arbiter::spawn(bg);
+        Resolver {
+            resolver,
+            req: PhantomData,
+        }
+    }
+
+    /// Change type of resolver request.
+    pub fn into_request<T2: RequestHost>(&self) -> Resolver<T2> {
+        Resolver {
+            resolver: self.resolver.clone(),
+            req: PhantomData,
+        }
+    }
+}
+
+impl<T> Clone for Resolver<T> {
+    fn clone(&self) -> Self {
+        Resolver {
+            resolver: self.resolver.clone(),
+            req: PhantomData,
+        }
+    }
+}
+
+impl<T: RequestHost> Service<T> for Resolver<T> {
+    type Response = (T, VecDeque<IpAddr>);
+    type Error = ResolveError;
+    type Future = ResolverFuture<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: T) -> Self::Future {
+        if let Ok(ip) = req.host().parse() {
+            let mut addrs = VecDeque::new();
+            addrs.push_back(ip);
+            ResolverFuture::new(req, &self.resolver, Some(addrs))
+        } else {
+            ResolverFuture::new(req, &self.resolver, None)
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Resolver future
+pub struct ResolverFuture<T> {
+    req: Option<T>,
+    lookup: Option<Background<LookupIpFuture>>,
+    addrs: Option<VecDeque<IpAddr>>,
+}
+
+impl<T: RequestHost> ResolverFuture<T> {
+    pub fn new(addr: T, resolver: &AsyncResolver, addrs: Option<VecDeque<IpAddr>>) -> Self {
+        // we need to do dns resolution
+        let lookup = Some(resolver.lookup_ip(addr.host()));
+        ResolverFuture {
+            lookup,
+            addrs,
+            req: Some(addr),
+        }
+    }
+}
+
+impl<T: RequestHost> Future for ResolverFuture<T> {
+    type Item = (T, VecDeque<IpAddr>);
+    type Error = ResolveError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(addrs) = self.addrs.take() {
+            Ok(Async::Ready((self.req.take().unwrap(), addrs)))
+        } else {
+            match self.lookup.as_mut().unwrap().poll() {
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Ok(Async::Ready(ips)) => Ok(Async::Ready((
+                    self.req.take().unwrap(),
+                    ips.iter().collect(),
+                ))),
+                Err(err) => Err(err),
+            }
+        }
+    }
+}

actix-connector/src/ssl/mod.rs

@@ -0,0 +1,6 @@
+//! SSL Services
+
+#[cfg(feature = "ssl")]
+mod openssl;
+#[cfg(feature = "ssl")]
+pub use self::openssl::OpensslConnector;

actix-connector/src/ssl/openssl.rs

@@ -0,0 +1,106 @@
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{NewService, Service};
+use futures::{future::ok, future::FutureResult, Async, Future, Poll};
+use openssl::ssl::{HandshakeError, SslConnector};
+use tokio_openssl::{ConnectAsync, SslConnectorExt, SslStream};
+
+use crate::resolver::RequestHost;
+
+/// Openssl connector factory
+pub struct OpensslConnector<R, T, E> {
+    connector: SslConnector,
+    _t: PhantomData<(R, T, E)>,
+}
+
+impl<R, T, E> OpensslConnector<R, T, E> {
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
+    pub fn service(
+        connector: SslConnector,
+    ) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>> {
+        OpensslConnectorService {
+            connector: connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<R, T, E> Clone for OpensslConnector<R, T, E> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T)>
+    for OpensslConnector<R, T, E>
+{
+    type Response = (R, SslStream<T>);
+    type Error = HandshakeError<T>;
+    type Service = OpensslConnectorService<R, T>;
+    type InitError = E;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self) -> Self::Future {
+        ok(OpensslConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct OpensslConnectorService<R, T> {
+    connector: SslConnector,
+    _t: PhantomData<(R, T)>,
+}
+
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
+    for OpensslConnectorService<R, T>
+{
+    type Response = (R, SslStream<T>);
+    type Error = HandshakeError<T>;
+    type Future = ConnectAsyncExt<R, T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, (req, stream): (R, T)) -> Self::Future {
+        ConnectAsyncExt {
+            fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
+            req: Some(req),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<R, T> {
+    req: Option<R>,
+    fut: ConnectAsync<T>,
+}
+
+impl<R, T> Future for ConnectAsyncExt<R, T>
+where
+    R: RequestHost,
+    T: AsyncRead + AsyncWrite,
+{
+    type Item = (R, SslStream<T>);
+    type Error = HandshakeError<T>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll()? {
+            Async::Ready(stream) => Ok(Async::Ready((self.req.take().unwrap(), stream))),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}

actix-rt/CHANGES.md

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

actix-rt/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "actix-rt"
+version = "0.1.0"
+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]
+log = "0.4"
+bytes = "0.4"
+futures = "0.1.24"
+tokio-current-thread = "0.1"
+tokio-executor = "0.1.5"
+tokio-reactor = "0.1.7"
+tokio-timer = "0.2.8"

actix-rt/src/arbiter.rs

@@ -0,0 +1,267 @@
+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, Sender};
+use futures::{future, Async, Future, IntoFuture, Poll, Stream};
+use tokio_current_thread::spawn;
+
+use crate::builder::Builder;
+use crate::system::System;
+
+thread_local!(
+    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
+    static RUNNING: Cell<bool> = Cell::new(false);
+    static Q: RefCell<Vec<Box<Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
+);
+
+pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
+
+pub(crate) enum ArbiterCommand {
+    Stop,
+    Execute(Box<Future<Item = (), Error = ()> + Send>),
+}
+
+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"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+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));
+        Arbiter::spawn(ArbiterController { stop: None, rx });
+
+        arb
+    }
+
+    /// Returns current arbiter's address
+    pub fn current() -> Arbiter {
+        ADDR.with(|cell| match *cell.borrow() {
+            Some(ref addr) => addr.clone(),
+            None => panic!("Arbiter is not running"),
+        })
+    }
+
+    /// Stop arbiter
+    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));
+
+            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.
+    pub fn spawn<F>(future: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        RUNNING.with(move |cell| {
+            if cell.get() {
+                spawn(Box::new(future));
+            } else {
+                Q.with(move |cell| cell.borrow_mut().push(Box::new(future)));
+            }
+        });
+    }
+
+    /// Executes a future 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 on the arbiter's thread and spawn.
+    pub fn send<F>(&self, future: F)
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
+    }
+}
+
+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);
+                    }
+                },
+                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),
+            }
+        }
+    }
+}
+
+// /// Execute function in arbiter's thread
+// impl<I: Send, E: Send> Handler<Execute<I, E>> for SystemArbiter {
+//     type Result = Result<I, E>;
+
+//     fn handle(&mut self, msg: Execute<I, E>, _: &mut Context<Self>) -> Result<I, E> {
+//         msg.exec()
+//     }
+// }

actix-rt/src/builder.rs

@@ -0,0 +1,175 @@
+use std::borrow::Cow;
+use std::io;
+
+use futures::future::{lazy, Future};
+use futures::sync::mpsc::unbounded;
+use futures::sync::oneshot::{channel, Receiver};
+
+use tokio_current_thread::CurrentThread;
+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(|| {})
+    }
+
+    /// 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) -> i32
+    where
+        F: FnOnce() + 'static,
+    {
+        self.create_runtime(f).run()
+    }
+
+    fn create_runtime<F>(self, f: F) -> SystemRunner
+    where
+        F: FnOnce() + 'static,
+    {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let arbiter = Arbiter::new_system();
+        let system = System::construct(sys_sender, arbiter.clone(), 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,
+        ))
+    }
+}
+
+/// 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) -> i32 {
+        let SystemRunner { mut rt, stop, .. } = self;
+
+        // run loop
+        let _ = rt.block_on(lazy(move || {
+            Arbiter::run_system();
+            Ok::<_, ()>(())
+        }));
+        let code = match rt.block_on(stop) {
+            Ok(code) => code,
+            Err(_) => 1,
+        };
+        Arbiter::stop_system();
+        code
+    }
+
+    /// 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,27 @@
+//! 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::{Handle, Runtime};
+pub use self::system::System;
+
+/// 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,236 @@
+use std::error::Error;
+use std::fmt;
+use std::io;
+
+use futures::{future, Future};
+use tokio_current_thread::Handle as ExecutorHandle;
+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>>,
+}
+
+/// Handle to spawn a future on the corresponding `CurrentThread` runtime instance
+#[derive(Debug, Clone)]
+pub struct Handle(ExecutorHandle);
+
+impl Handle {
+    /// Spawn a future onto the `CurrentThread` runtime instance corresponding to this handle
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the spawn fails. Failure occurs if the `CurrentThread`
+    /// instance of the `Handle` does not exist anymore.
+    pub fn spawn<F>(&self, future: F) -> Result<(), tokio_executor::SpawnError>
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        self.0.spawn(future)
+    }
+
+    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
+    ///
+    /// This function may return both false positives **and** false negatives.
+    /// If `status` returns `Ok`, then a call to `spawn` will *probably*
+    /// succeed, but may fail. If `status` returns `Err`, a call to `spawn` will
+    /// *probably* fail, but may succeed.
+    ///
+    /// This allows a caller to avoid creating the task if the call to `spawn`
+    /// has a high likelihood of failing.
+    pub fn status(&self) -> Result<(), tokio_executor::SpawnError> {
+        self.0.status()
+    }
+}
+
+impl<T> future::Executor<T> for Handle
+where
+    T: Future<Item = (), Error = ()> + Send + 'static,
+{
+    fn execute(&self, future: T) -> Result<(), future::ExecuteError<T>> {
+        if let Err(e) = self.status() {
+            let kind = if e.is_at_capacity() {
+                future::ExecuteErrorKind::NoCapacity
+            } else {
+                future::ExecuteErrorKind::Shutdown
+            };
+
+            return Err(future::ExecuteError::new(kind, future));
+        }
+
+        let _ = self.spawn(future);
+        Ok(())
+    }
+}
+
+/// 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<&Error> {
+        self.inner.cause()
+    }
+}
+
+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,
+        }
+    }
+
+    /// Get a new handle to spawn futures on the single-threaded Tokio runtime
+    ///
+    /// Different to the runtime itself, the handle can be sent to different
+    /// threads.
+    pub fn handle(&self) -> Handle {
+        Handle(self.executor.handle().clone())
+    }
+
+    /// 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,118 @@
+use std::cell::RefCell;
+
+use futures::sync::mpsc::UnboundedSender;
+
+use crate::arbiter::{Arbiter, SystemCommand};
+use crate::builder::{Builder, SystemRunner};
+
+/// System is a runtime manager.
+#[derive(Clone, Debug)]
+pub struct System {
+    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,
+        };
+        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()
+    }
+
+    /// 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"),
+        })
+    }
+
+    /// 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) -> i32
+    where
+        F: FnOnce() + 'static,
+    {
+        Self::builder().run(f)
+    }
+}

actix-server/CHANGES.md

@@ -0,0 +1,29 @@
+# Changes
+
+## [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,71 @@
+[package]
+name = "actix-server"
+version = "0.1.3"
+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"]
+
+[lib]
+name = "actix_server"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# tls
+tls = ["native-tls"]
+
+# openssl
+ssl = ["openssl", "tokio-openssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
+
+[dependencies]
+actix-service = "0.1.1"
+actix-rt = "0.1.0"
+
+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-io = "0.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2"
+tokio-reactor = "0.1"
+tokio-signal = "0.2"
+
+# 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.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.1.1"
+actix-codec = "0.1.0"
+actix-rt = "0.1.0"

actix-server/src/accept.rs

@@ -2,14 +2,14 @@ use std::sync::mpsc as sync_mpsc;
 use std::time::{Duration, Instant};
 use std::{io, net, 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::Server;
-
-use super::server::ServerCommand;
 use super::worker::{Conn, WorkerClient};
 use super::Token;
 
@@ -23,7 +23,6 @@ pub(crate) enum Command {
 struct ServerSocketInfo {
     addr: net::SocketAddr,
     token: Token,
-    handler: Token,
     sock: mio::net::TcpListener,
     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<(
+    srv: Option<Server>,
-        mpsc::UnboundedSender<ServerCommand>,
-        mpsc::UnboundedReceiver<ServerCommand>,
-    )>,
 }
 
 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),
         }
     }
 
@@ -87,19 +83,20 @@ impl AcceptLoop {
     }
 
     pub(crate) fn start(
-        &mut self, socks: Vec<(Token, net::TcpListener)>, workers: Vec<WorkerClient>,
+        &mut self,
-    ) -> mpsc::UnboundedReceiver<ServerCommand> {
+        socks: Vec<(Token, net::TcpListener)>,
-        let (tx, rx) = self.srv.take().expect("Can not re-use AcceptInfo");
+        workers: Vec<WorkerClient>,
+    ) {
+        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
     }
 }
 
@@ -108,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,
@@ -133,17 +130,20 @@ fn connection_error(e: &io::Error) -> bool {
 }
 
 impl Accept {
-    #![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
+    #![allow(clippy::too_many_arguments)]
     pub(crate) fn start(
-        rx: sync_mpsc::Receiver<Command>, cmd_reg: mio::Registration,
+        rx: sync_mpsc::Receiver<Command>,
-        notify_reg: mio::Registration, socks: Vec<(Token, net::TcpListener)>,
+        cmd_reg: mio::Registration,
-        srv: mpsc::UnboundedSender<ServerCommand>, workers: Vec<WorkerClient>,
+        notify_reg: mio::Registration,
+        socks: Vec<(Token, net::TcpListener)>,
+        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);
@@ -173,8 +173,10 @@ impl Accept {
     }
 
     fn new(
-        rx: sync_mpsc::Receiver<Command>, socks: Vec<(Token, net::TcpListener)>,
+        rx: sync_mpsc::Receiver<Command>,
-        workers: Vec<WorkerClient>, srv: mpsc::UnboundedSender<ServerCommand>,
+        socks: Vec<(Token, net::TcpListener)>,
+        workers: Vec<WorkerClient>,
+        srv: Server,
     ) -> Accept {
         // Create a poll instance
         let poll = match mio::Poll::new() {
@@ -184,7 +186,7 @@ impl Accept {
 
         // Start accept
         let mut sockets = Slab::new();
-        for (idx, (hnd_token, lst)) in socks.into_iter().enumerate() {
+        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");
@@ -205,7 +207,6 @@ impl Accept {
             entry.insert(ServerSocketInfo {
                 addr,
                 token: hnd_token,
-                handler: Token(idx),
                 sock: server,
                 timeout: None,
             });
@@ -243,9 +244,11 @@ impl Accept {
             for event in events.iter() {
                 let token = event.token();
                 match token {
-                    CMD => if !self.process_cmd() {
+                    CMD => {
-                        return;
+                        if !self.process_cmd() {
-                    },
+                            return;
+                        }
+                    }
                     TIMER => self.process_timer(),
                     NOTIFY => self.backpressure(false),
                     _ => {
@@ -368,9 +371,7 @@ impl Accept {
                 match self.workers[self.next].send(msg) {
                     Ok(_) => (),
                     Err(tmp) => {
-                        let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
+                        self.srv.worker_died(self.workers[self.next].idx);
-                            self.workers[self.next].idx,
-                        ));
                         msg = tmp;
                         self.workers.swap_remove(self.next);
                         if self.workers.is_empty() {
@@ -396,9 +397,7 @@ impl Accept {
                             return;
                         }
                         Err(tmp) => {
-                            let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
+                            self.srv.worker_died(self.workers[self.next].idx);
-                                self.workers[self.next].idx,
-                            ));
                             msg = tmp;
                             self.workers.swap_remove(self.next);
                             if self.workers.is_empty() {
@@ -427,7 +426,6 @@ impl Accept {
                     Ok((io, addr)) => Conn {
                         io,
                         token: info.token,
-                        handler: info.handler,
                         peer: Some(addr),
                     },
                     Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
@@ -442,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(
+                        System::current().arbiter().send(lazy(move || {
-                            move || -> Result<(), ()> {
+                            Delay::new(Instant::now() + Duration::from_millis(510))
-                                Arbiter::spawn(
+                                .map_err(|_| ())
-                                    Delay::new(Instant::now() + Duration::from_millis(510))
+                                .and_then(move |_| {
-                                        .map_err(|_| ())
+                                    let _ = r.set_readiness(mio::Ready::readable());
-                                        .and_then(move |_| {
+                                    Ok(())
-                                            let _ = r.set_readiness(mio::Ready::readable());
+                                })
-                                            Ok(())
+                        }));
-                                        }),
-                                );
-                                Ok(())
-                            },
-                        ));
                         return;
                     }
                 }

actix-server/src/builder.rs

@@ -1,64 +1,70 @@
 use std::time::Duration;
 use std::{io, mem, net};
 
-use futures::sync::{mpsc, mpsc::unbounded};
+use actix_rt::{spawn, Arbiter, System};
-use futures::{Future, Sink, Stream};
+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_timer::sleep;
 
-use actix::{
+use crate::accept::{AcceptLoop, AcceptNotify, Command};
-    actors::signal, fut, msgs::Execute, Actor, ActorFuture, Addr, Arbiter, AsyncContext,
+use crate::config::{ConfiguredService, ServiceConfig};
-    Context, Handler, Response, StreamHandler, System, WrapFuture,
+use crate::server::{Server, ServerCommand};
-};
+use crate::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
+use crate::services::{ServiceFactory, ServiceNewService};
+use crate::signals::{Signal, Signals};
+use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
+use crate::Token;
 
-use super::accept::{AcceptLoop, AcceptNotify, Command};
+/// Server builder
-use super::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
+pub struct ServerBuilder {
-use super::services::{ServiceFactory, ServiceNewService};
-use super::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use super::{PauseServer, ResumeServer, StopServer, Token};
-
-pub(crate) enum ServerCommand {
-    WorkerDied(usize),
-}
-
-/// Server
-pub struct Server {
     threads: usize,
+    token: Token,
     workers: Vec<(usize, WorkerClient)>,
     services: Vec<Box<InternalServiceFactory>>,
     sockets: Vec<(Token, net::TcpListener)>,
     accept: AcceptLoop,
     exit: bool,
     shutdown_timeout: Duration,
-    signals: Option<Addr<signal::ProcessSignals>>,
     no_signals: bool,
+    cmd: UnboundedReceiver<ServerCommand>,
+    server: Server,
 }
 
-impl Default for Server {
+impl Default for ServerBuilder {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl Server {
+impl ServerBuilder {
-    /// Create new Server instance
+    /// Create new Server builder instance
-    pub fn new() -> Server {
+    pub fn new() -> ServerBuilder {
-        Server {
+        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(),
+            accept: AcceptLoop::new(server.clone()),
             exit: false,
             shutdown_timeout: Duration::from_secs(30),
-            signals: None,
             no_signals: false,
+            cmd: rx,
+            server,
         }
     }
 
     /// Set number of workers to start.
     ///
-    /// By default server uses number of available logical cpu as threads
+    /// By default server uses number of available logical cpu as workers
     /// count.
     pub fn workers(mut self, num: usize) -> Self {
         self.threads = num;
@@ -84,13 +90,6 @@ impl Server {
         self
     }
 
-    #[doc(hidden)]
-    /// Set alternative address for `ProcessSignals` actor.
-    pub fn signals(mut self, addr: Addr<signal::ProcessSignals>) -> Self {
-        self.signals = Some(addr);
-        self
-    }
-
     /// Disable signal handling
     pub fn disable_signals(mut self) -> Self {
         self.no_signals = true;
@@ -109,19 +108,34 @@ impl Server {
         self
     }
 
-    /// Run external configuration as part of the server building
+    /// Execute external configuration as part of the server building
-    /// process
+    /// process.
     ///
     /// This function is useful for moving parts of configuration to a
-    /// different module or event library.
+    /// different module or even library.
-    pub fn configure<F>(self, cfg: F) -> Server
+    pub fn configure<F>(mut self, f: F) -> io::Result<ServerBuilder>
     where
-        F: Fn(Server) -> Server,
+        F: Fn(&mut ServiceConfig) -> io::Result<()>,
     {
-        cfg(self)
+        let mut cfg = ServiceConfig::new(self.threads);
+
+        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);
+                self.sockets.push((token, lst));
+            }
+            self.services.push(Box::new(srv));
+        }
+        self.threads = cfg.threads;
+
+        Ok(self)
     }
 
-    /// Add new service to server
+    /// 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: StreamServiceFactory,
@@ -129,36 +143,53 @@ impl Server {
     {
         let sockets = bind_addr(addr)?;
 
+        let token = self.token.next();
+        self.services.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+        ));
+
         for lst in sockets {
-            self = self.listen(name.as_ref(), lst, factory.clone())
+            self.sockets.push((token, lst));
         }
         Ok(self)
     }
 
-    /// Add new service to server
+    /// Add new service to the server.
     pub fn listen<F, N: AsRef<str>>(
-        mut self, name: N, lst: net::TcpListener, factory: F,
+        mut self,
+        name: N,
+        lst: net::TcpListener,
+        factory: F,
     ) -> Self
     where
         F: StreamServiceFactory,
     {
-        let token = Token(self.services.len());
+        let token = self.token.next();
-        self.services
+        self.services.push(StreamNewService::create(
-            .push(StreamNewService::create(name.as_ref().to_string(), factory));
+            name.as_ref().to_string(),
+            token,
+            factory,
+        ));
         self.sockets.push((token, lst));
         self
     }
 
-    /// Add new service to server
+    /// Add new service to the server.
     pub fn listen2<F, N: AsRef<str>>(
-        mut self, name: N, lst: net::TcpListener, factory: F,
+        mut self,
+        name: N,
+        lst: net::TcpListener,
+        factory: F,
     ) -> Self
     where
         F: ServiceFactory,
     {
-        let token = Token(self.services.len());
+        let token = self.token.next();
         self.services.push(ServiceNewService::create(
             name.as_ref().to_string(),
+            token,
             factory,
         ));
         self.sockets.push((token, lst));
@@ -193,10 +224,10 @@ impl Server {
         sys.run();
     }
 
-    /// Starts Server Actor and returns its address
+    /// Starts processing incoming connections and return server controller.
-    pub fn start(mut self) -> Addr<Server> {
+    pub fn start(mut self) -> Server {
         if self.sockets.is_empty() {
-            panic!("Service should have at least one bound socket");
+            panic!("Server should have at least one bound socket");
         } else {
             info!("Starting {} workers", self.threads);
 
@@ -212,156 +243,123 @@ impl Server {
             for sock in &self.sockets {
                 info!("Starting server on {}", sock.1.local_addr().ok().unwrap());
             }
-            let rx = self
+            self.accept
-                .accept
                 .start(mem::replace(&mut self.sockets, Vec::new()), workers);
 
-            // start http server actor
+            // handle signals
-            let signals = self.subscribe_to_signals();
+            if !self.no_signals {
-            let addr = Actor::create(move |ctx| {
+                Signals::start(self.server.clone());
-                ctx.add_stream(rx);
-                self
-            });
-            if let Some(signals) = signals {
-                signals.do_send(signal::Subscribe(addr.clone().recipient()))
             }
-            addr
-        }
-    }
 
-    // subscribe to os signals
+            // start http server actor
-    fn subscribe_to_signals(&self) -> Option<Addr<signal::ProcessSignals>> {
+            let server = self.server.clone();
-        if !self.no_signals {
+            spawn(self);
-            if let Some(ref signals) = self.signals {
+            server
-                Some(signals.clone())
-            } else {
-                Some(System::current().registry().get::<signal::ProcessSignals>())
-            }
-        } else {
-            None
         }
     }
 
     fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
-        let (tx, rx) = unbounded();
+        let (tx1, rx1) = unbounded();
+        let (tx2, rx2) = unbounded();
         let timeout = self.shutdown_timeout;
         let avail = WorkerAvailability::new(notify);
-        let worker = WorkerClient::new(idx, tx, avail.clone());
+        let worker = WorkerClient::new(idx, tx1, tx2, avail.clone());
         let services: Vec<Box<InternalServiceFactory>> =
             self.services.iter().map(|v| v.clone_factory()).collect();
 
-        Arbiter::new(format!("actix-net-worker-{}", idx)).do_send(Execute::new(move || {
+        Arbiter::new().send(lazy(move || {
-            Worker::start(rx, services, avail, timeout.clone());
+            Worker::start(rx1, rx2, services, avail, timeout);
             Ok::<_, ()>(())
         }));
 
         worker
     }
-}
 
-impl Actor for Server {
+    fn handle_cmd(&mut self, item: ServerCommand) {
-    type Context = Context<Self>;
+        match item {
-}
+            ServerCommand::Pause(tx) => {
-
+                self.accept.send(Command::Pause);
-/// Signals support
+                let _ = tx.send(());
-/// Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
-/// message to `System` actor.
-impl Handler<signal::Signal> for Server {
-    type Result = ();
-
-    fn handle(&mut self, msg: signal::Signal, ctx: &mut Context<Self>) {
-        match msg.0 {
-            signal::SignalType::Int => {
-                info!("SIGINT received, exiting");
-                self.exit = true;
-                Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx);
             }
-            signal::SignalType::Term => {
+            ServerCommand::Resume(tx) => {
-                info!("SIGTERM received, stopping");
+                self.accept.send(Command::Resume);
-                self.exit = true;
+                let _ = tx.send(());
-                Handler::<StopServer>::handle(self, StopServer { graceful: true }, ctx);
             }
-            signal::SignalType::Quit => {
+            ServerCommand::Signal(sig) => {
-                info!("SIGQUIT received, exiting");
+                // Signals support
-                self.exit = true;
+                // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
-                Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx);
+                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;
 
-impl Handler<PauseServer> for Server {
+                // stop accept thread
-    type Result = ();
+                self.accept.send(Command::Stop);
 
-    fn handle(&mut self, _: PauseServer, _: &mut Context<Self>) {
+                // stop workers
-        self.accept.send(Command::Pause);
+                if !self.workers.is_empty() {
-    }
+                    spawn(
-}
+                        futures_unordered(
-
+                            self.workers
-impl Handler<ResumeServer> for Server {
+                                .iter()
-    type Result = ();
+                                .map(move |worker| worker.1.stop(graceful)),
-
+                        )
-    fn handle(&mut self, _: ResumeServer, _: &mut Context<Self>) {
+                        .collect()
-        self.accept.send(Command::Resume);
+                        .then(move |_| {
-    }
+                            if let Some(tx) = completion {
-}
+                                let _ = tx.send(());
-
-impl Handler<StopServer> for Server {
-    type Result = Response<(), ()>;
-
-    fn handle(&mut self, msg: StopServer, ctx: &mut Context<Self>) -> Self::Result {
-        // stop accept thread
-        self.accept.send(Command::Stop);
-
-        // stop workers
-        let (tx, rx) = mpsc::channel(1);
-
-        for worker in &self.workers {
-            let tx2 = tx.clone();
-            ctx.spawn(
-                worker
-                    .1
-                    .stop(msg.graceful)
-                    .into_actor(self)
-                    .then(move |_, slf, ctx| {
-                        slf.workers.pop();
-                        if slf.workers.is_empty() {
-                            let _ = tx2.send(());
-
-                            // we need to stop system if server was spawned
-                            if slf.exit {
-                                ctx.run_later(Duration::from_millis(300), |_, _| {
-                                    System::current().stop();
-                                });
                             }
-                        }
+                            if exit {
-
+                                spawn(sleep(Duration::from_millis(300)).then(|_| {
-                        fut::ok(())
+                                    System::current().stop();
-                    }),
+                                    ok(())
-            );
+                                }));
-        }
+                            }
-
+                            ok(())
-        if !self.workers.is_empty() {
+                        }),
-            Response::async(rx.into_future().map(|_| ()).map_err(|_| ()))
+                    )
-        } else {
+                } else {
-            // we need to stop system if server was spawned
+                    // we need to stop system if server was spawned
-            if self.exit {
+                    if self.exit {
-                ctx.run_later(Duration::from_millis(300), |_, _| {
+                        spawn(sleep(Duration::from_millis(300)).then(|_| {
-                    System::current().stop();
+                            System::current().stop();
-                });
+                            ok(())
+                        }));
+                    }
+                    if let Some(tx) = completion {
+                        let _ = tx.send(());
+                    }
+                }
             }
-            Response::reply(Ok(()))
-        }
-    }
-}
-
-/// Commands from accept threads
-impl StreamHandler<ServerCommand, ()> for Server {
-    fn finished(&mut self, _: &mut Context<Self>) {}
-
-    fn handle(&mut self, msg: ServerCommand, _: &mut Context<Self>) {
-        match msg {
             ServerCommand::WorkerDied(idx) => {
                 let mut found = false;
                 for i in 0..self.workers.len() {
@@ -395,7 +393,22 @@ impl StreamHandler<ServerCommand, ()> for Server {
     }
 }
 
-fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::TcpListener>> {
+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) -> io::Result<Vec<net::TcpListener>> {
     let mut err = None;
     let mut succ = false;
     let mut sockets = Vec::new();

actix-server/src/config.rs

@@ -0,0 +1,227 @@
+use std::collections::HashMap;
+use std::{fmt, io, net};
+
+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<ServiceRuntimeConfiguration>>,
+    pub(crate) threads: usize,
+}
+
+impl ServiceConfig {
+    pub(super) fn new(threads: usize) -> ServiceConfig {
+        ServiceConfig {
+            threads,
+            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)?;
+
+        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<ServiceRuntimeConfiguration>,
+    names: HashMap<Token, String>,
+    services: HashMap<String, Token>,
+}
+
+impl ConfiguredService {
+    pub(super) fn new(rt: Box<ServiceRuntimeConfiguration>) -> Self {
+        ConfiguredService {
+            rt,
+            names: HashMap::new(),
+            services: HashMap::new(),
+        }
+    }
+
+    pub(super) fn stream(&mut self, token: Token, name: String) {
+        self.names.insert(token, name.clone());
+        self.services.insert(name, token);
+    }
+}
+
+impl InternalServiceFactory for ConfiguredService {
+    fn name(&self, token: Token) -> &str {
+        &self.names[&token]
+    }
+
+    fn clone_factory(&self) -> Box<InternalServiceFactory> {
+        Box::new(Self {
+            rt: self.rt.clone(),
+            names: self.names.clone(),
+            services: self.services.clone(),
+        })
+    }
+
+    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        // configure services
+        let mut rt = ServiceRuntime::new(self.services.clone());
+        self.rt.configure(&mut rt);
+        rt.validate();
+
+        // construct services
+        let mut fut = Vec::new();
+        for (token, ns) in rt.services {
+            fut.push(ns.new_service().map(move |service| (token, service)));
+        }
+
+        Box::new(join_all(fut).map_err(|e| {
+            error!("Can not construct service: {:?}", e);
+        }))
+    }
+}
+
+pub(super) trait ServiceRuntimeConfiguration: Send {
+    fn clone(&self) -> Box<ServiceRuntimeConfiguration>;
+
+    fn configure(&self, rt: &mut ServiceRuntime);
+}
+
+impl<F> ServiceRuntimeConfiguration for F
+where
+    F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
+{
+    fn clone(&self) -> Box<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>,
+}
+
+impl ServiceRuntime {
+    fn new(names: HashMap<String, Token>) -> Self {
+        ServiceRuntime {
+            names,
+            services: HashMap::new(),
+        }
+    }
+
+    fn validate(&self) {
+        for (name, token) in &self.names {
+            if !self.services.contains_key(&token) {
+                error!("Service {:?} is not configured", name);
+            }
+        }
+    }
+
+    pub fn service<T, F>(&mut self, name: &str, service: F)
+    where
+        F: IntoNewService<T, TcpStream>,
+        T: NewService<TcpStream, Response = ()> + '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);
+        }
+    }
+}
+
+type BoxedNewService = Box<
+    NewService<
+        (Option<CounterGuard>, ServerMessage),
+        Response = (),
+        Error = (),
+        InitError = (),
+        Service = BoxedServerService,
+        Future = Box<Future<Item = BoxedServerService, Error = ()>>,
+    >,
+>;
+
+struct ServiceFactory<T> {
+    inner: T,
+}
+
+impl<T> NewService<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
+where
+    T: NewService<TcpStream, Response = ()>,
+    T::Future: 'static,
+    T::Service: 'static,
+    T::Error: 'static,
+    T::InitError: fmt::Debug + 'static,
+{
+    type Response = ();
+    type Error = ();
+    type InitError = ();
+    type Service = BoxedServerService;
+    type Future = Box<Future<Item = BoxedServerService, Error = ()>>;
+
+    fn new_service(&self) -> Self::Future {
+        Box::new(self.inner.new_service().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,33 @@
+//! General purpose tcp server
+
+mod accept;
+mod builder;
+mod config;
+mod counter;
+mod server;
+mod services;
+mod signals;
+pub mod ssl;
+mod worker;
+
+pub use self::builder::ServerBuilder;
+pub use self::config::{ServiceConfig, ServiceRuntime};
+pub use self::server::Server;
+pub use self::services::{ServerMessage, ServiceFactory, 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 build() -> ServerBuilder {
+    ServerBuilder::default()
+}

actix-server/src/server.rs

@@ -0,0 +1,69 @@
+use futures::sync::mpsc::UnboundedSender;
+use futures::sync::oneshot;
+use futures::Future;
+
+use crate::builder::ServerBuilder;
+use crate::signals::Signal;
+
+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(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

@@ -1,14 +1,16 @@
 use std::net;
 use std::time::Duration;
 
+use actix_rt::spawn;
+use actix_service::{NewService, Service};
 use futures::future::{err, ok, FutureResult};
 use futures::{Future, Poll};
-use tokio_current_thread::spawn;
+use log::error;
 use tokio_reactor::Handle;
 use tokio_tcp::TcpStream;
 
-use counter::CounterGuard;
+use super::Token;
-use service::{NewService, Service};
+use crate::counter::CounterGuard;
 
 /// Server message
 pub enum ServerMessage {
@@ -21,28 +23,28 @@ pub enum ServerMessage {
 }
 
 pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = TcpStream, Response = ()>;
+    type NewService: NewService<TcpStream, Response = ()>;
 
     fn create(&self) -> Self::NewService;
 }
 
 pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = ServerMessage, Response = ()>;
+    type NewService: NewService<ServerMessage, Response = ()>;
 
     fn create(&self) -> Self::NewService;
 }
 
 pub(crate) trait InternalServiceFactory: Send {
-    fn name(&self) -> &str;
+    fn name(&self, token: Token) -> &str;
 
     fn clone_factory(&self) -> Box<InternalServiceFactory>;
 
-    fn create(&self) -> Box<Future<Item = BoxedServerService, Error = ()>>;
+    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>;
 }
 
 pub(crate) type BoxedServerService = Box<
     Service<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         Future = FutureResult<(), ()>,
@@ -54,18 +56,17 @@ pub(crate) struct StreamService<T> {
 }
 
 impl<T> StreamService<T> {
-    fn new(service: T) -> Self {
+    pub(crate) fn new(service: T) -> Self {
         StreamService { service }
     }
 }
 
-impl<T> Service for StreamService<T>
+impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
 where
-    T: Service<Request = TcpStream, Response = ()>,
+    T: Service<TcpStream, Response = ()>,
     T::Future: 'static,
     T::Error: 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -82,9 +83,9 @@ where
                 });
 
                 if let Ok(stream) = stream {
-                    spawn(self.service.call(stream).map_err(|_| ()).map(move |val| {
+                    spawn(self.service.call(stream).then(move |res| {
                         drop(guard);
-                        val
+                        res.map_err(|_| ())
                     }));
                     ok(())
                 } else {
@@ -106,13 +107,12 @@ impl<T> ServerService<T> {
     }
 }
 
-impl<T> Service for ServerService<T>
+impl<T> Service<(Option<CounterGuard>, ServerMessage)> for ServerService<T>
 where
-    T: Service<Request = ServerMessage, Response = ()>,
+    T: Service<ServerMessage, Response = ()>,
     T::Future: 'static,
     T::Error: 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -122,9 +122,9 @@ where
     }
 
     fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        spawn(self.service.call(req).map_err(|_| ()).map(move |val| {
+        spawn(self.service.call(req).then(move |res| {
             drop(guard);
-            val
+            res.map_err(|_| ())
         }));
         ok(())
     }
@@ -133,14 +133,15 @@ where
 pub(crate) struct ServiceNewService<F: ServiceFactory> {
     name: String,
     inner: F,
+    token: Token,
 }
 
 impl<F> ServiceNewService<F>
 where
     F: ServiceFactory,
 {
-    pub(crate) fn create(name: String, inner: F) -> Box<InternalServiceFactory> {
+    pub(crate) fn create(name: String, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, inner })
+        Box::new(Self { name, inner, token })
     }
 }
 
@@ -148,7 +149,7 @@ impl<F> InternalServiceFactory for ServiceNewService<F>
 where
     F: ServiceFactory,
 {
-    fn name(&self) -> &str {
+    fn name(&self, _: Token) -> &str {
         &self.name
     }
 
@@ -156,10 +157,12 @@ where
         Box::new(Self {
             name: self.name.clone(),
             inner: self.inner.clone(),
+            token: self.token,
         })
     }
 
-    fn create(&self) -> Box<Future<Item = BoxedServerService, Error = ()>> {
+    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        let token = self.token;
         Box::new(
             self.inner
                 .create()
@@ -167,7 +170,7 @@ where
                 .map_err(|_| ())
                 .map(move |inner| {
                     let service: BoxedServerService = Box::new(ServerService::new(inner));
-                    service
+                    vec![(token, service)]
                 }),
         )
     }
@@ -176,14 +179,15 @@ where
 pub(crate) struct StreamNewService<F: StreamServiceFactory> {
     name: String,
     inner: F,
+    token: Token,
 }
 
 impl<F> StreamNewService<F>
 where
     F: StreamServiceFactory,
 {
-    pub(crate) fn create(name: String, inner: F) -> Box<InternalServiceFactory> {
+    pub(crate) fn create(name: String, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, inner })
+        Box::new(Self { name, token, inner })
     }
 }
 
@@ -191,7 +195,7 @@ impl<F> InternalServiceFactory for StreamNewService<F>
 where
     F: StreamServiceFactory,
 {
-    fn name(&self) -> &str {
+    fn name(&self, _: Token) -> &str {
         &self.name
     }
 
@@ -199,10 +203,12 @@ where
         Box::new(Self {
             name: self.name.clone(),
             inner: self.inner.clone(),
+            token: self.token,
         })
     }
 
-    fn create(&self) -> Box<Future<Item = BoxedServerService, Error = ()>> {
+    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+        let token = self.token;
         Box::new(
             self.inner
                 .create()
@@ -210,22 +216,22 @@ where
                 .map_err(|_| ())
                 .map(move |inner| {
                     let service: BoxedServerService = Box::new(StreamService::new(inner));
-                    service
+                    vec![(token, service)]
                 }),
         )
     }
 }
 
 impl InternalServiceFactory for Box<InternalServiceFactory> {
-    fn name(&self) -> &str {
+    fn name(&self, token: Token) -> &str {
-        self.as_ref().name()
+        self.as_ref().name(token)
     }
 
     fn clone_factory(&self) -> Box<InternalServiceFactory> {
         self.as_ref().clone_factory()
     }
 
-    fn create(&self) -> Box<Future<Item = BoxedServerService, Error = ()>> {
+    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
         self.as_ref().create()
     }
 }
@@ -233,7 +239,7 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
 impl<F, T> ServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = ServerMessage, Response = ()>,
+    T: NewService<ServerMessage, Response = ()>,
 {
     type NewService = T;
 
@@ -245,7 +251,7 @@ where
 impl<F, T> StreamServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: NewService<TcpStream, Response = ()>,
 {
     type NewService = T;
 

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<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<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/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,7 +28,7 @@ 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));

actix-server/src/ssl/nativetls.rs

@@ -1,13 +1,13 @@
 use std::io;
 use std::marker::PhantomData;
 
+use actix_service::{NewService, Service};
 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 counter::{Counter, CounterGuard};
+use crate::counter::{Counter, CounterGuard};
-use service::{NewService, Service};
 
 /// Support `SSL` connections via native-tls package
 ///
@@ -21,7 +21,7 @@ impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
     /// Create `NativeTlsAcceptor` instance
     pub fn new(acceptor: TlsAcceptor) -> Self {
         NativeTlsAcceptor {
-            acceptor: acceptor.into(),
+            acceptor,
             io: PhantomData,
         }
     }
@@ -36,8 +36,7 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
-    type Request = T;
     type Response = TlsStream<T>;
     type Error = Error;
     type Service = NativeTlsAcceptorService<T>;
@@ -61,8 +60,7 @@ pub struct NativeTlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
-    type Request = T;
     type Response = TlsStream<T>;
     type Error = Error;
     type Future = Accept<T>;
@@ -75,7 +73,7 @@ impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         Accept {
             _guard: self.conns.get(),
             inner: Some(self.acceptor.accept(req)),

actix-server/src/ssl/openssl.rs

@@ -0,0 +1,99 @@
+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 super::MAX_CONN_COUNTER;
+use crate::counter::{Counter, CounterGuard};
+
+/// Support `SSL` connections via openssl package
+///
+/// `ssl` feature enables `OpensslAcceptor` type
+pub struct OpensslAcceptor<T> {
+    acceptor: SslAcceptor,
+    io: PhantomData<T>,
+}
+
+impl<T> OpensslAcceptor<T> {
+    /// Create default `OpensslAcceptor`
+    pub fn new(acceptor: SslAcceptor) -> Self {
+        OpensslAcceptor {
+            acceptor,
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
+    type Response = SslStream<T>;
+    type Error = HandshakeError<T>;
+    type Service = OpensslAcceptorService<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self) -> Self::Future {
+        MAX_CONN_COUNTER.with(|conns| {
+            ok(OpensslAcceptorService {
+                acceptor: self.acceptor.clone(),
+                conns: conns.clone(),
+                io: PhantomData,
+            })
+        })
+    }
+}
+
+pub struct OpensslAcceptorService<T> {
+    acceptor: SslAcceptor,
+    io: PhantomData<T>,
+    conns: Counter,
+}
+
+impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
+    type Response = SslStream<T>;
+    type Error = HandshakeError<T>;
+    type Future = OpensslAcceptorServiceFut<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        if self.conns.available() {
+            Ok(Async::Ready(()))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
+    fn call(&mut self, req: T) -> Self::Future {
+        OpensslAcceptorServiceFut {
+            _guard: self.conns.get(),
+            fut: SslAcceptorExt::accept_async(&self.acceptor, req),
+        }
+    }
+}
+
+pub struct OpensslAcceptorServiceFut<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    fut: AcceptAsync<T>,
+    _guard: CounterGuard,
+}
+
+impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
+    type Item = SslStream<T>;
+    type Error = HandshakeError<T>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll()
+    }
+}

actix-server/src/ssl/rustls.rs

@@ -2,14 +2,14 @@ use std::io;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+use actix_service::{NewService, Service};
 use futures::{future::ok, future::FutureResult, Async, Future, Poll};
 use rustls::{ServerConfig, ServerSession};
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_rustls::{Accept, TlsAcceptor, TlsStream};
 
 use super::MAX_CONN_COUNTER;
-use counter::{Counter, CounterGuard};
+use crate::counter::{Counter, CounterGuard};
-use service::{NewService, Service};
 
 /// Support `SSL` connections via rustls package
 ///
@@ -38,8 +38,7 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
-    type Request = T;
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Service = RustlsAcceptorService<T>;
@@ -63,8 +62,7 @@ pub struct RustlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
-    type Request = T;
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Future = RustlsAcceptorServiceFut<T>;
@@ -77,7 +75,7 @@ impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         RustlsAcceptorServiceFut {
             _guard: self.conns.get(),
             fut: self.acceptor.accept(req),

actix-server/src/worker.rs

@@ -2,36 +2,35 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::{mem, net, time};
 
+use actix_rt::{spawn, Arbiter};
 use futures::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures::sync::oneshot;
 use futures::{future, Async, Future, Poll, Stream};
-use tokio_current_thread::spawn;
+use log::{error, info, trace};
 use tokio_timer::{sleep, Delay};
 
-use actix::msgs::StopArbiter;
+use crate::accept::AcceptNotify;
-use actix::{Arbiter, Message};
+use crate::counter::Counter;
+use crate::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::Token;
 
-use super::accept::AcceptNotify;
+pub(crate) struct WorkerCommand(Conn);
-use super::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
-use super::Token;
-use counter::Counter;
 
-pub(crate) enum WorkerCommand {
+/// Stop worker message. Returns `true` on successful shutdown
-    Message(Conn),
+/// and `false` if some connections still alive.
-    /// Stop worker message. Returns `true` on successful shutdown
+pub(crate) struct StopCommand {
-    /// and `false` if some connections still alive.
+    graceful: bool,
-    Stop(bool, oneshot::Sender<bool>),
+    result: oneshot::Sender<bool>,
 }
 
-#[derive(Debug, Message)]
+#[derive(Debug)]
 pub(crate) struct Conn {
     pub io: net::TcpStream,
-    pub handler: Token,
     pub token: Token,
     pub peer: Option<net::SocketAddr>,
 }
 
-const MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
+static MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
 
 /// Sets the maximum per-worker number of concurrent connections.
 ///
@@ -55,24 +54,30 @@ thread_local! {
 #[derive(Clone)]
 pub(crate) struct WorkerClient {
     pub idx: usize,
-    tx: UnboundedSender<WorkerCommand>,
+    tx1: UnboundedSender<WorkerCommand>,
+    tx2: UnboundedSender<StopCommand>,
     avail: WorkerAvailability,
 }
 
 impl WorkerClient {
     pub fn new(
-        idx: usize, tx: UnboundedSender<WorkerCommand>, avail: WorkerAvailability,
+        idx: usize,
+        tx1: UnboundedSender<WorkerCommand>,
+        tx2: UnboundedSender<StopCommand>,
+        avail: WorkerAvailability,
     ) -> Self {
-        WorkerClient { idx, tx, avail }
+        WorkerClient {
+            idx,
+            tx1,
+            tx2,
+            avail,
+        }
     }
 
     pub fn send(&self, msg: Conn) -> Result<(), Conn> {
-        self.tx
+        self.tx1
-            .unbounded_send(WorkerCommand::Message(msg))
+            .unbounded_send(WorkerCommand(msg))
-            .map_err(|e| match e.into_inner() {
+            .map_err(|msg| msg.into_inner().0)
-                WorkerCommand::Message(msg) => msg,
-                _ => panic!(),
-            })
     }
 
     pub fn available(&self) -> bool {
@@ -80,8 +85,8 @@ impl WorkerClient {
     }
 
     pub fn stop(&self, graceful: bool) -> oneshot::Receiver<bool> {
-        let (tx, rx) = oneshot::channel();
+        let (result, rx) = oneshot::channel();
-        let _ = self.tx.unbounded_send(WorkerCommand::Stop(graceful, tx));
+        let _ = self.tx2.unbounded_send(StopCommand { graceful, result });
         rx
     }
 }
@@ -118,7 +123,8 @@ impl WorkerAvailability {
 /// processing.
 pub(crate) struct Worker {
     rx: UnboundedReceiver<WorkerCommand>,
-    services: Vec<BoxedServerService>,
+    rx2: UnboundedReceiver<StopCommand>,
+    services: Vec<Option<(usize, BoxedServerService)>>,
     availability: WorkerAvailability,
     conns: Counter,
     factories: Vec<Box<InternalServiceFactory>>,
@@ -128,12 +134,16 @@ pub(crate) struct Worker {
 
 impl Worker {
     pub(crate) fn start(
-        rx: UnboundedReceiver<WorkerCommand>, factories: Vec<Box<InternalServiceFactory>>,
+        rx: UnboundedReceiver<WorkerCommand>,
-        availability: WorkerAvailability, shutdown_timeout: time::Duration,
+        rx2: UnboundedReceiver<StopCommand>,
+        factories: Vec<Box<InternalServiceFactory>>,
+        availability: WorkerAvailability,
+        shutdown_timeout: time::Duration,
     ) {
         availability.set(false);
         let mut wrk = MAX_CONNS_COUNTER.with(|conns| Worker {
             rx,
+            rx2,
             availability,
             factories,
             shutdown_timeout,
@@ -143,16 +153,28 @@ impl Worker {
         });
 
         let mut fut = Vec::new();
-        for factory in &wrk.factories {
+        for (idx, factory) in wrk.factories.iter().enumerate() {
-            fut.push(factory.create());
+            fut.push(factory.create().map(move |res| {
+                res.into_iter()
+                    .map(|(t, s)| (idx, t, s))
+                    .collect::<Vec<_>>()
+            }));
         }
         spawn(
             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| {
+                })
-                    wrk.services.extend(services);
+                .and_then(move |services| {
+                    for item in services {
+                        for (idx, token, service) in item {
+                            while token.0 >= wrk.services.len() {
+                                wrk.services.push(None);
+                            }
+                            wrk.services[token.0] = Some((idx, service));
+                        }
+                    }
                     wrk
                 }),
         );
@@ -161,33 +183,42 @@ impl Worker {
     fn shutdown(&mut self, force: bool) {
         if force {
             self.services.iter_mut().for_each(|h| {
-                let _ = h.call((None, ServerMessage::ForceShutdown));
+                if let Some(h) = h {
+                    let _ = h.1.call((None, ServerMessage::ForceShutdown));
+                }
             });
         } else {
             let timeout = self.shutdown_timeout;
             self.services.iter_mut().for_each(move |h| {
-                let _ = h.call((None, ServerMessage::Shutdown(timeout.clone())));
+                if let Some(h) = h {
+                    let _ = h.1.call((None, ServerMessage::Shutdown(timeout)));
+                }
             });
         }
     }
 
-    fn check_readiness(&mut self, trace: bool) -> Result<bool, usize> {
+    fn check_readiness(&mut self, trace: bool) -> Result<bool, (Token, usize)> {
         let mut ready = self.conns.available();
         let mut failed = None;
-        for (idx, service) in self.services.iter_mut().enumerate() {
+        for (token, service) in &mut self.services.iter_mut().enumerate() {
-            match service.poll_ready() {
+            if let Some(service) = service {
-                Ok(Async::Ready(_)) => {
+                match service.1.poll_ready() {
-                    if trace {
+                    Ok(Async::Ready(_)) => {
-                        trace!("Service {:?} is available", self.factories[idx].name());
+                        if trace {
+                            trace!(
+                                "Service {:?} is available",
+                                self.factories[service.0].name(Token(token))
+                            );
+                        }
+                    }
+                    Ok(Async::NotReady) => ready = false,
+                    Err(_) => {
+                        error!(
+                            "Service {:?} readiness check returned error, restarting",
+                            self.factories[service.0].name(Token(token))
+                        );
+                        failed = Some((Token(token), service.0));
                     }
-                }
-                Ok(Async::NotReady) => ready = false,
-                Err(_) => {
-                    error!(
-                        "Service {:?} readiness check returned error, restarting",
-                        self.factories[idx].name()
-                    );
-                    failed = Some(idx);
                 }
             }
         }
@@ -203,7 +234,11 @@ enum WorkerState {
     None,
     Available,
     Unavailable(Vec<Conn>),
-    Restarting(usize, Box<Future<Item = BoxedServerService, Error = ()>>),
+    Restarting(
+        usize,
+        Token,
+        Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>,
+    ),
     Shutdown(Delay, Delay, oneshot::Sender<bool>),
 }
 
@@ -212,6 +247,36 @@ impl Future for Worker {
     type Error = ();
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        // `StopWorker` message handler
+        if let Ok(Async::Ready(Some(StopCommand { graceful, result }))) = self.rx2.poll() {
+            self.availability.set(false);
+            let num = num_connections();
+            if num == 0 {
+                info!("Shutting down worker, 0 connections");
+                let _ = result.send(true);
+                return Ok(Async::Ready(()));
+            } else if graceful {
+                self.shutdown(false);
+                let num = num_connections();
+                if num != 0 {
+                    info!("Graceful worker shutdown, {} connections", num);
+                    self.state = WorkerState::Shutdown(
+                        sleep(time::Duration::from_secs(1)),
+                        sleep(self.shutdown_timeout),
+                        result,
+                    );
+                } else {
+                    let _ = result.send(true);
+                    return Ok(Async::Ready(()));
+                }
+            } else {
+                info!("Force shutdown worker, {} connections", num);
+                self.shutdown(true);
+                let _ = result.send(false);
+                return Ok(Async::Ready(()));
+            }
+        }
+
         let state = mem::replace(&mut self.state, WorkerState::None);
 
         match state {
@@ -225,7 +290,10 @@ impl Future for Worker {
                             match self.check_readiness(false) {
                                 Ok(true) => {
                                     let guard = self.conns.get();
-                                    let _ = self.services[msg.handler.0]
+                                    let _ = self.services[msg.token.0]
+                                        .as_mut()
+                                        .expect("actix net bug")
+                                        .1
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                 }
                                 Ok(false) => {
@@ -233,13 +301,14 @@ impl Future for Worker {
                                     self.state = WorkerState::Unavailable(conns);
                                     return self.poll();
                                 }
-                                Err(idx) => {
+                                Err((token, idx)) => {
                                     trace!(
                                         "Service {:?} failed, restarting",
-                                        self.factories[idx].name()
+                                        self.factories[idx].name(token)
                                     );
                                     self.state = WorkerState::Restarting(
                                         idx,
+                                        token,
                                         self.factories[idx].create(),
                                     );
                                     return self.poll();
@@ -253,32 +322,38 @@ impl Future for Worker {
                         self.state = WorkerState::Unavailable(conns);
                         return Ok(Async::NotReady);
                     }
-                    Err(idx) => {
+                    Err((token, idx)) => {
                         trace!(
                             "Service {:?} failed, restarting",
-                            self.factories[idx].name()
+                            self.factories[idx].name(token)
                         );
-                        self.state = WorkerState::Restarting(idx, self.factories[idx].create());
+                        self.state =
+                            WorkerState::Restarting(idx, token, self.factories[idx].create());
                         return self.poll();
                     }
                 }
             }
-            WorkerState::Restarting(idx, mut fut) => {
+            WorkerState::Restarting(idx, token, mut fut) => {
                 match fut.poll() {
-                    Ok(Async::Ready(service)) => {
+                    Ok(Async::Ready(item)) => {
-                        trace!(
+                        for (token, service) in item {
-                            "Service {:?} has been restarted",
+                            trace!(
-                            self.factories[idx].name()
+                                "Service {:?} has been restarted",
-                        );
+                                self.factories[idx].name(token)
-                        self.services[idx] = service;
+                            );
-                        self.state = WorkerState::Unavailable(Vec::new());
+                            self.services[token.0] = Some((idx, service));
+                            self.state = WorkerState::Unavailable(Vec::new());
+                        }
                     }
                     Ok(Async::NotReady) => {
-                        self.state = WorkerState::Restarting(idx, fut);
+                        self.state = WorkerState::Restarting(idx, token, fut);
                         return Ok(Async::NotReady);
                     }
                     Err(_) => {
-                        panic!("Can not restart {:?} service", self.factories[idx].name());
+                        panic!(
+                            "Can not restart {:?} service",
+                            self.factories[idx].name(token)
+                        );
                     }
                 }
                 return self.poll();
@@ -287,7 +362,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(()));
                 }
 
@@ -297,7 +372,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(()));
                     }
                 }
@@ -317,11 +392,14 @@ impl Future for Worker {
                 loop {
                     match self.rx.poll() {
                         // handle incoming tcp stream
-                        Ok(Async::Ready(Some(WorkerCommand::Message(msg)))) => {
+                        Ok(Async::Ready(Some(WorkerCommand(msg)))) => {
                             match self.check_readiness(false) {
                                 Ok(true) => {
                                     let guard = self.conns.get();
-                                    let _ = self.services[msg.handler.0]
+                                    let _ = self.services[msg.token.0]
+                                        .as_mut()
+                                        .expect("actix-server bug")
+                                        .1
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                     continue;
                                 }
@@ -330,49 +408,21 @@ impl Future for Worker {
                                     self.availability.set(false);
                                     self.state = WorkerState::Unavailable(vec![msg]);
                                 }
-                                Err(idx) => {
+                                Err((token, idx)) => {
                                     trace!(
                                         "Service {:?} failed, restarting",
-                                        self.factories[idx].name()
+                                        self.factories[idx].name(token)
                                     );
                                     self.availability.set(false);
                                     self.state = WorkerState::Restarting(
                                         idx,
+                                        token,
                                         self.factories[idx].create(),
                                     );
                                 }
                             }
                             return self.poll();
                         }
-                        // `StopWorker` message handler
-                        Ok(Async::Ready(Some(WorkerCommand::Stop(graceful, tx)))) => {
-                            self.availability.set(false);
-                            let num = num_connections();
-                            if num == 0 {
-                                info!("Shutting down worker, 0 connections");
-                                let _ = tx.send(true);
-                                return Ok(Async::Ready(()));
-                            } else if graceful {
-                                self.shutdown(false);
-                                let num = num_connections();
-                                if num != 0 {
-                                    info!("Graceful worker shutdown, {} connections", num);
-                                    break Some(WorkerState::Shutdown(
-                                        sleep(time::Duration::from_secs(1)),
-                                        sleep(self.shutdown_timeout),
-                                        tx,
-                                    ));
-                                } else {
-                                    let _ = tx.send(true);
-                                    return Ok(Async::Ready(()));
-                                }
-                            } else {
-                                info!("Force shutdown worker, {} connections", num);
-                                self.shutdown(true);
-                                let _ = tx.send(false);
-                                return Ok(Async::Ready(()));
-                            }
-                        }
                         Ok(Async::NotReady) => {
                             self.state = WorkerState::Available;
                             return Ok(Async::NotReady);
@@ -383,7 +433,5 @@ impl Future for Worker {
             }
             WorkerState::None => panic!(),
         };
-
-        Ok(Async::NotReady)
     }
 }

actix-service/CHANGES.md

@@ -0,0 +1,33 @@
+# Changes
+
+## [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
+
+* Added Service impl for Box<S: Service>
+
+
+## [0.1.0] - 2018-12-09
+
+* Initial import

actix-service/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "actix-service"
+version = "0.1.4"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix Service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-service/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = "../"
+
+[badges]
+travis-ci = { repository = "actix/actix-service", branch = "master" }
+# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
+
+[lib]
+name = "actix_service"
+path = "src/lib.rs"
+
+[dependencies]
+futures = "0.1.24"

actix-service/src/and_then.rs

@@ -1,7 +1,7 @@
-use futures::{Async, Future, Poll};
+use futures::{try_ready, Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
-use cell::Cell;
+use crate::cell::Cell;
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
@@ -12,21 +12,20 @@ pub struct AndThen<A, B> {
     b: Cell<B>,
 }
 
-impl<A, B> AndThen<A, B>
+impl<A, B> AndThen<A, B> {
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
     /// Create new `AndThen` combinator
-    pub fn new(a: A, b: B) -> Self {
+    pub fn new<Request>(a: A, b: B) -> Self
+    where
+        A: Service<Request>,
+        B: Service<A::Response, Error = A::Error>,
+    {
         Self { a, b: Cell::new(b) }
     }
 }
 
 impl<A, B> Clone for AndThen<A, B>
 where
-    A: Service + Clone,
+    A: Clone,
-    B: Service<Request = A::Response, Error = A::Error>,
 {
     fn clone(&self) -> Self {
         AndThen {
@@ -36,55 +35,53 @@ where
     }
 }
 
-impl<A, B> Service for AndThen<A, B>
+impl<A, B, Request> Service<Request> for AndThen<A, B>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B>;
+    type Future = AndThenFuture<A, B, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let _ = try_ready!(self.a.poll_ready());
+        try_ready!(self.a.poll_ready());
-        self.b.borrow_mut().poll_ready()
+        self.b.get_mut().poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         AndThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct AndThenFuture<A, B>
+pub struct AndThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<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> AndThenFuture<A, B>
+impl<A, B, Request> AndThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<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> Future for AndThenFuture<A, B>
+impl<A, B, Request> Future for AndThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
-    B::Error: Into<A::Error>,
 {
     type Item = B::Response;
     type Error = A::Error;
@@ -94,9 +91,10 @@ 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)) => {
-                self.fut_b = Some(self.b.borrow_mut().call(resp));
+                let _ = self.fut_a.take();
+                self.fut_b = Some(self.b.get_mut().call(resp));
                 self.poll()
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -111,13 +109,13 @@ pub struct AndThenNewService<A, B> {
     b: B,
 }
 
-impl<A, B> AndThenNewService<A, B>
+impl<A, B> AndThenNewService<A, B> {
-where
-    A: NewService,
-    B: NewService,
-{
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
+    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>,
+    {
         Self {
             a,
             b: f.into_new_service(),
@@ -125,18 +123,17 @@ where
     }
 }
 
-impl<A, B> NewService for AndThenNewService<A, B>
+impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
     type Service = AndThen<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B>;
+    type Future = AndThenNewServiceFuture<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@@ -145,8 +142,8 @@ where
 
 impl<A, B> Clone for AndThenNewService<A, B>
 where
-    A: NewService + Clone,
+    A: Clone,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError> + Clone,
+    B: Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -156,10 +153,10 @@ where
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B>
+pub struct AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService,
+    B: NewService<A::Response>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -167,10 +164,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenNewServiceFuture<A, B>
+impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService,
+    B: NewService<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -182,10 +179,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenNewServiceFuture<A, B>
+impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
 {
     type Item = AndThen<A::Service, B::Service>;
     type Error = A::InitError;
@@ -222,11 +219,10 @@ mod tests {
     use std::rc::Rc;
 
     use super::*;
-    use service::{NewServiceExt, Service, ServiceExt};
+    use crate::{NewService, Service, ServiceExt};
 
     struct Srv1(Rc<Cell<usize>>);
-    impl Service for Srv1 {
+    impl Service<&'static str> for Srv1 {
-        type Request = &'static str;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -236,7 +232,7 @@ mod tests {
             Ok(Async::Ready(()))
         }
 
-        fn call(&mut self, req: Self::Request) -> Self::Future {
+        fn call(&mut self, req: &'static str) -> Self::Future {
             ok(req)
         }
     }
@@ -244,8 +240,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<&'static str> for Srv2 {
-        type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -255,7 +250,7 @@ mod tests {
             Ok(Async::Ready(()))
         }
 
-        fn call(&mut self, req: Self::Request) -> Self::Future {
+        fn call(&mut self, req: &'static str) -> Self::Future {
             ok((req, "srv2"))
         }
     }

actix-service/src/apply.rs

@@ -5,21 +5,23 @@ use futures::{Async, Future, IntoFuture, Poll};
 use super::{IntoNewService, IntoService, NewService, Service};
 
 /// `Apply` service combinator
-pub struct Apply<T, F, R, Req> {
+pub struct Apply<T, F, In, Out, Request>
+where
+    T: Service<Request>,
+{
     service: T,
     f: F,
-    r: PhantomData<(Req, R)>,
+    r: PhantomData<(In, Out, Request)>,
 }
 
-impl<T, F, R, Req> Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
 where
-    T: Service,
+    T: Service<Request>,
-    T::Error: Into<<R::Future as Future>::Error>,
+    F: Fn(In, &mut T) -> Out,
-    F: Fn(Req, &mut T) -> R,
+    Out: IntoFuture,
-    R: IntoFuture,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
+    pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
         Self {
             service: service.into_service(),
             f,
@@ -28,12 +30,10 @@ where
     }
 }
 
-impl<T, F, R, Req> Clone for Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
 where
-    T: Service + Clone,
+    T: Service<Request> + Clone,
-    T::Error: Into<<R::Future as Future>::Error>,
+    F: Clone,
-    F: Fn(Req, &mut T) -> R + Clone,
-    R: IntoFuture,
 {
     fn clone(&self) -> Self {
         Apply {
@@ -44,42 +44,43 @@ where
     }
 }
 
-impl<T, F, R, Req> Service for Apply<T, F, R, Req>
+impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
 where
-    T: Service,
+    T: Service<Request, Error = Out::Error>,
-    T::Error: Into<<R::Future as Future>::Error>,
+    F: Fn(In, &mut T) -> Out,
-    F: Fn(Req, &mut T) -> R,
+    Out: IntoFuture,
-    R: IntoFuture,
 {
-    type Request = Req;
+    type Response = Out::Item;
-    type Response = <R::Future as Future>::Item;
+    type Error = Out::Error;
-    type Error = <R::Future as Future>::Error;
+    type Future = Out::Future;
-    type Future = R::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|e| e.into())
+        self.service.poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: In) -> Self::Future {
         (self.f)(req, &mut self.service).into_future()
     }
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, R, Req> {
+pub struct ApplyNewService<T, F, In, Out, Request>
+where
+    T: NewService<Request>,
+{
     service: T,
     f: F,
-    r: PhantomData<Fn(Req) -> R>,
+    r: PhantomData<(In, Out, Request)>,
 }
 
-impl<T, F, R, Req> ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
-    F: Fn(Req, &mut T::Service) -> R,
+    F: Fn(In, &mut T::Service) -> Out,
-    R: IntoFuture,
+    Out: IntoFuture,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
+    pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
         Self {
             f,
             service: service.into_new_service(),
@@ -88,11 +89,11 @@ where
     }
 }
 
-impl<T, F, R, Req> Clone for ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService + Clone,
+    T: NewService<Request> + Clone,
-    F: Fn(Req, &mut T::Service) -> R + Clone,
+    F: Fn(Out, &mut T::Service) -> Out + Clone,
-    R: IntoFuture,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         Self {
@@ -103,42 +104,40 @@ where
     }
 }
 
-impl<T, F, R, Req> NewService for ApplyNewService<T, F, R, Req>
+impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
 where
-    T: NewService,
+    T: NewService<Request, Error = Out::Error>,
-    T::Error: Into<<R::Future as Future>::Error>,
+    F: Fn(In, &mut T::Service) -> Out + Clone,
-    F: Fn(Req, &mut T::Service) -> R + Clone,
+    Out: IntoFuture,
-    R: IntoFuture,
 {
-    type Request = Req;
+    type Response = Out::Item;
-    type Response = <R::Future as Future>::Item;
+    type Error = Out::Error;
-    type Error = <R::Future as Future>::Error;
+    type Service = Apply<T::Service, F, In, Out, Request>;
-    type Service = Apply<T::Service, F, R, Req>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, R, Req>;
+    type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
 
     fn new_service(&self) -> Self::Future {
         ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, R, Req>
+pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
-    F: Fn(Req, &mut T::Service) -> R,
+    F: Fn(In, &mut T::Service) -> Out,
-    R: IntoFuture,
+    Out: IntoFuture,
 {
     fut: T::Future,
     f: Option<F>,
-    r: PhantomData<Fn(Req) -> R>,
+    r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, R, Req> ApplyNewServiceFuture<T, F, R, Req>
+impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
-    F: Fn(Req, &mut T::Service) -> R,
+    F: Fn(In, &mut T::Service) -> Out,
-    R: IntoFuture,
+    Out: IntoFuture,
 {
     fn new(fut: T::Future, f: F) -> Self {
         ApplyNewServiceFuture {
@@ -149,14 +148,13 @@ where
     }
 }
 
-impl<T, F, R, Req> Future for ApplyNewServiceFuture<T, F, R, Req>
+impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
 where
-    T: NewService,
+    T: NewService<Request>,
-    T::Error: Into<<R::Future as Future>::Error>,
+    F: Fn(In, &mut T::Service) -> Out,
-    F: Fn(Req, &mut T::Service) -> R,
+    Out: IntoFuture,
-    R: IntoFuture,
 {
-    type Item = Apply<T::Service, F, R, Req>;
+    type Item = Apply<T::Service, F, In, Out, Request>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -173,14 +171,11 @@ mod tests {
     use futures::future::{ok, FutureResult};
     use futures::{Async, Future, Poll};
 
-    use service::{
+    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
-        IntoNewService, IntoService, NewService, NewServiceExt, Service, ServiceExt,
-    };
 
     #[derive(Clone)]
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;

actix-service/src/cell.rs

@@ -0,0 +1,32 @@
+//! Custom cell impl
+use std::{cell::UnsafeCell, fmt, 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(crate) fn new(inner: T) -> Self {
+        Self {
+            inner: Rc::new(UnsafeCell::new(inner)),
+        }
+    }
+
+    pub(crate) fn get_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.inner.as_ref().get() }
+    }
+}

actix-service/src/fn_service.rs

@@ -9,7 +9,7 @@ use super::{IntoNewService, IntoService, NewService, Service};
 
 pub struct FnService<F, Req, Resp, E, Fut>
 where
-    F: Fn(Req) -> Fut,
+    F: FnMut(Req) -> Fut,
     Fut: IntoFuture<Item = Resp, Error = E>,
 {
     f: F,
@@ -18,7 +18,7 @@ where
 
 impl<F, Req, Resp, E, Fut> FnService<F, Req, Resp, E, Fut>
 where
-    F: Fn(Req) -> Fut,
+    F: FnMut(Req) -> Fut,
     Fut: IntoFuture<Item = Resp, Error = E>,
 {
     pub fn new(f: F) -> Self {
@@ -31,7 +31,7 @@ where
 
 impl<F, Req, Resp, E, Fut> Clone for FnService<F, Req, Resp, E, Fut>
 where
-    F: Fn(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Fut + Clone,
     Fut: IntoFuture<Item = Resp, Error = E>,
 {
     fn clone(&self) -> Self {
@@ -42,12 +42,11 @@ where
     }
 }
 
-impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
 where
-    F: Fn(Req) -> Fut,
+    F: FnMut(Req) -> Fut,
     Fut: IntoFuture<Item = Resp, Error = E>,
 {
-    type Request = Req;
     type Response = Resp;
     type Error = E;
     type Future = Fut::Future;
@@ -61,9 +60,9 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
 where
-    F: Fn(Req) -> Fut + 'static,
+    F: FnMut(Req) -> Fut + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     fn into_service(self) -> FnService<F, Req, Resp, Err, Fut> {
@@ -73,7 +72,7 @@ where
 
 pub struct FnNewService<F, Req, Resp, Err, Fut>
 where
-    F: Fn(Req) -> Fut,
+    F: FnMut(Req) -> Fut,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     f: F,
@@ -82,7 +81,7 @@ where
 
 impl<F, Req, Resp, Err, Fut> FnNewService<F, Req, Resp, Err, Fut>
 where
-    F: Fn(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Fut + Clone,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     pub fn new(f: F) -> Self {
@@ -93,12 +92,11 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
 where
-    F: Fn(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Fut + Clone,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
-    type Request = Req;
     type Response = Resp;
     type Error = Err;
     type Service = FnService<F, Req, Resp, Err, Fut>;
@@ -110,9 +108,9 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>, Req> for F
 where
-    F: Fn(Req) -> Fut + Clone + 'static,
+    F: FnMut(Req) -> Fut + Clone + 'static,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     fn into_new_service(self) -> FnNewService<F, Req, Resp, Err, Fut> {
@@ -122,7 +120,7 @@ where
 
 impl<F, Req, Resp, Err, Fut> Clone for FnNewService<F, Req, Resp, Err, Fut>
 where
-    F: Fn(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Fut + Clone,
     Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     fn clone(&self) -> Self {

actix-service/src/from_err.rs

@@ -7,16 +7,17 @@ use super::{NewService, Service};
 /// Service for the `from_err` combinator, changing the error type of a service.
 ///
 /// This is created by the `ServiceExt::from_err` method.
-pub struct FromErr<A, E>
+pub struct FromErr<A, E> {
-where
-    A: Service,
-{
     service: A,
     f: PhantomData<E>,
 }
 
-impl<A: Service, E: From<A::Error>> FromErr<A, E> {
+impl<A, E> FromErr<A, E> {
-    pub(crate) fn new(service: A) -> Self {
+    pub(crate) fn new<Request>(service: A) -> Self
+    where
+        A: Service<Request>,
+        E: From<A::Error>,
+    {
         FromErr {
             service,
             f: PhantomData,
@@ -26,8 +27,7 @@ impl<A: Service, E: From<A::Error>> FromErr<A, E> {
 
 impl<A, E> Clone for FromErr<A, E>
 where
-    A: Service + Clone,
+    A: Clone,
-    E: From<A::Error>,
 {
     fn clone(&self) -> Self {
         FromErr {
@@ -37,21 +37,20 @@ where
     }
 }
 
-impl<A, E> Service for FromErr<A, E>
+impl<A, E, Request> Service<Request> for FromErr<A, E>
 where
-    A: Service,
+    A: Service<Request>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = FromErrFuture<A, E>;
+    type Future = FromErrFuture<A, E, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), E> {
         Ok(self.service.poll_ready().map_err(E::from)?)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         FromErrFuture {
             fut: self.service.call(req),
             f: PhantomData,
@@ -59,14 +58,14 @@ where
     }
 }
 
-pub struct FromErrFuture<A: Service, E> {
+pub struct FromErrFuture<A: Service<Request>, E, Request> {
     fut: A::Future,
     f: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrFuture<A, E>
+impl<A, E, Request> Future for FromErrFuture<A, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     E: From<A::Error>,
 {
     type Item = A::Response;
@@ -86,21 +85,20 @@ pub struct FromErrNewService<A, E> {
     e: PhantomData<E>,
 }
 
-impl<A, E> FromErrNewService<A, E>
+impl<A, E> FromErrNewService<A, E> {
-where
-    A: NewService,
-    E: From<A::Error>,
-{
     /// Create new `FromErr` new service instance
-    pub fn new(a: A) -> Self {
+    pub fn new<Request>(a: A) -> Self
+    where
+        A: NewService<Request>,
+        E: From<A::Error>,
+    {
         Self { a, e: PhantomData }
     }
 }
 
 impl<A, E> Clone for FromErrNewService<A, E>
 where
-    A: NewService + Clone,
+    A: Clone,
-    E: From<A::Error>,
 {
     fn clone(&self) -> Self {
         Self {
@@ -110,18 +108,17 @@ where
     }
 }
 
-impl<A, E> NewService for FromErrNewService<A, E>
+impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = FromErr<A::Service, E>;
 
     type InitError = A::InitError;
-    type Future = FromErrNewServiceFuture<A, E>;
+    type Future = FromErrNewServiceFuture<A, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         FromErrNewServiceFuture {
@@ -131,18 +128,18 @@ where
     }
 }
 
-pub struct FromErrNewServiceFuture<A, E>
+pub struct FromErrNewServiceFuture<A, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrNewServiceFuture<A, E>
+impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
@@ -162,11 +159,10 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use service::{IntoNewService, NewServiceExt, Service, ServiceExt};
+    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<(), ()>;

actix-service/src/lib.rs

@@ -0,0 +1,357 @@
+use futures::{Future, IntoFuture, Poll};
+mod and_then;
+mod apply;
+mod cell;
+mod fn_service;
+mod from_err;
+mod map;
+mod map_err;
+mod map_init_err;
+mod then;
+
+pub use self::and_then::{AndThen, AndThenNewService};
+pub use self::apply::{Apply, ApplyNewService};
+pub use self::fn_service::{FnNewService, FnService};
+pub use self::from_err::{FromErr, FromErrNewService};
+pub use self::map::{Map, MapNewService};
+pub use self::map_err::{MapErr, MapErrNewService};
+pub use self::map_init_err::MapInitErr;
+pub use self::then::{Then, ThenNewService};
+
+/// An asynchronous function from `Request` to a `Response`.
+pub trait Service<Request> {
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The future response value.
+    type Future: Future<Item = Self::Response, Error = Self::Error>;
+
+    /// Returns `Ready` when the service is able to process requests.
+    ///
+    /// If the service is at capacity, then `NotReady` is returned and the task
+    /// is notified when the service becomes ready again. This function is
+    /// expected to be called while on a task.
+    ///
+    /// This is a **best effort** implementation. False positives are permitted.
+    /// It is permitted for the service to return `Ready` from a `poll_ready`
+    /// call and the next invocation of `call` results in an error.
+    fn poll_ready(&mut self) -> Poll<(), Self::Error>;
+
+    /// Process the request and return the response asynchronously.
+    ///
+    /// This function is expected to be callable off task. As such,
+    /// implementations should take care to not call `poll_ready`. If the
+    /// service is at capacity and the request is unable to be handled, the
+    /// returned `Future` should resolve to an error.
+    ///
+    /// Calling `call` without calling `poll_ready` is permitted. The
+    /// implementation must be resilient to this fact.
+    fn call(&mut self, req: Request) -> Self::Future;
+}
+
+/// An extension trait for `Service`s that provides a variety of convenient
+/// adapters
+pub trait ServiceExt<Request>: Service<Request> {
+    /// 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>>
+    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>,
+    {
+        self.and_then(Apply::new(service.into_service(), f))
+    }
+
+    /// Call another service after call to this one has resolved successfully.
+    ///
+    /// This function can be used to chain two services together and ensure that
+    /// the second service isn't called until call to the fist service have
+    /// finished. Result of the call to the first service is used as an
+    /// input parameter for the second service's call.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    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>,
+    {
+        AndThen::new(self, service.into_service())
+    }
+
+    /// Map this service's error to any error implementing `From` for
+    /// this service`s `Error`.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn from_err<E>(self) -> FromErr<Self, E>
+    where
+        Self: Sized,
+        E: From<Self::Error>,
+    {
+        FromErr::new(self)
+    }
+
+    /// Chain on a computation for when a call to the service finished,
+    /// passing the result of the call to the next service `B`.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn then<B>(self, service: B) -> Then<Self, B>
+    where
+        Self: Sized,
+        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
+    {
+        Then::new(self, service)
+    }
+
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    ///
+    /// This function is similar to the `Option::map` or `Iterator::map` where
+    /// it will change the type of the underlying service.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it, similar to the existing `map` methods in the
+    /// standard library.
+    fn map<F, R>(self, f: F) -> Map<Self, F, R>
+    where
+        Self: Sized,
+        F: Fn(Self::Response) -> R,
+    {
+        Map::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying service. This is useful for example to
+    /// ensure that services have the same error type.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        MapErr::new(self, f)
+    }
+}
+
+impl<T: ?Sized, Request> ServiceExt<Request> for T where T: Service<Request> {}
+
+/// 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
+/// 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> {
+    /// Responses given by the service
+    type Response;
+
+    /// Errors produced by the service
+    type Error;
+
+    /// The `Service` value created by this factory
+    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
+
+    /// Errors produced while building a service.
+    type InitError;
+
+    /// The future of the `Service` instance.
+    type Future: Future<Item = Self::Service, Error = Self::InitError>;
+
+    /// Create and return a new service value asynchronously.
+    fn new_service(&self) -> Self::Future;
+
+    /// 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>>
+    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>,
+    {
+        self.and_then(ApplyNewService::new(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>,
+    {
+        AndThenNewService::new(self, new_service)
+    }
+
+    /// `NewService` that create service to map this service's error
+    /// and new service's init error to any error
+    /// implementing `From` for this service`s `Error`.
+    ///
+    /// Note that this function consumes the receiving new service and returns a
+    /// wrapped version of it.
+    fn from_err<E>(self) -> FromErrNewService<Self, E>
+    where
+        Self: Sized,
+        E: From<Self::Error>,
+    {
+        FromErrNewService::new(self)
+    }
+
+    /// Create `NewService` to chain on a computation for when a call to the
+    /// service finished, passing the result of the call to the next
+    /// service `B`.
+    ///
+    /// Note that this function consumes the receiving future and returns a
+    /// wrapped version of it.
+    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
+    where
+        Self: Sized,
+        F: IntoNewService<B, Result<Self::Response, Self::Error>>,
+        B: NewService<
+            Result<Self::Response, Self::Error>,
+            Error = Self::Error,
+            InitError = Self::InitError,
+        >,
+    {
+        ThenNewService::new(self, new_service)
+    }
+
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
+    where
+        Self: Sized,
+        F: Fn(Self::Response) -> R,
+    {
+        MapNewService::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        MapErrNewService::new(self, f)
+    }
+
+    /// Map this service'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,
+        F: Fn(Self::InitError) -> E,
+    {
+        MapInitErr::new(self, f)
+    }
+}
+
+impl<'a, S, Request> Service<Request> for &'a mut S
+where
+    S: Service<Request> + 'a,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), S::Error> {
+        (**self).poll_ready()
+    }
+
+    fn call(&mut self, request: Request) -> S::Future {
+        (**self).call(request)
+    }
+}
+
+impl<S, Request> Service<Request> for Box<S>
+where
+    S: Service<Request> + ?Sized,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), S::Error> {
+        (**self).poll_ready()
+    }
+
+    fn call(&mut self, request: Request) -> S::Future {
+        (**self).call(request)
+    }
+}
+
+impl<F, R, E, S, Request> NewService<Request> for F
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Request>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+    type InitError = E;
+    type Future = R::Future;
+
+    fn new_service(&self) -> Self::Future {
+        (*self)().into_future()
+    }
+}
+
+/// Trait for types that can be converted to a `Service`
+pub trait IntoService<T, Request>
+where
+    T: Service<Request>,
+{
+    /// Convert to a `Service`
+    fn into_service(self) -> T;
+}
+
+/// Trait for types that can be converted to a Service
+pub trait IntoNewService<T, Request>
+where
+    T: NewService<Request>,
+{
+    /// Convert to an `NewService`
+    fn into_new_service(self) -> T;
+}
+
+impl<T, Request> IntoService<T, Request> for T
+where
+    T: Service<Request>,
+{
+    fn into_service(self) -> T {
+        self
+    }
+}
+
+impl<T, Request> IntoNewService<T, Request> for T
+where
+    T: NewService<Request>,
+{
+    fn into_new_service(self) -> T {
+        self
+    }
+}

actix-service/src/map.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Async, Future, Poll};
 
@@ -7,83 +7,84 @@ use super::{NewService, Service};
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
 /// This is created by the `ServiceExt::map` method.
-pub struct Map<A, F, R>
+pub struct Map<A, F, Response> {
-where
-    A: Service,
-    F: Fn(A::Response) -> R,
-{
     service: A,
     f: F,
+    _t: PhantomData<Response>,
 }
 
-impl<A, F, R> Map<A, F, R>
+impl<A, F, Response> Map<A, F, Response> {
-where
-    A: Service,
-    F: Fn(A::Response) -> R,
-{
     /// Create new `Map` combinator
-    pub fn new(service: A, f: F) -> Self {
+    pub fn new<Request>(service: A, f: F) -> Self
-        Self { service, f }
+    where
+        A: Service<Request>,
+        F: Fn(A::Response) -> Response,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
     }
 }
 
-impl<A, F, R> Clone for Map<A, F, R>
+impl<A, F, Response> Clone for Map<A, F, Response>
 where
-    A: Service + Clone,
+    A: Clone,
-    F: Fn(A::Response) -> R + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Map {
             service: self.service.clone(),
             f: self.f.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, F, R> Service for Map<A, F, R>
+impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
 where
-    A: Service,
+    A: Service<Request>,
-    F: Fn(A::Response) -> R + Clone,
+    F: Fn(A::Response) -> Response + Clone,
 {
-    type Request = A::Request;
+    type Response = Response;
-    type Response = R;
     type Error = A::Error;
-    type Future = MapFuture<A, F, R>;
+    type Future = MapFuture<A, F, Request, Response>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapFuture<A, F, R>
+pub struct MapFuture<A, F, Request, Response>
 where
-    A: Service,
+    A: Service<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, R> MapFuture<A, F, R>
+impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
 where
-    A: Service,
+    A: Service<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, R> Future for MapFuture<A, F, R>
+impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
 where
-    A: Service,
+    A: Service<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
-    type Item = R;
+    type Item = Response;
     type Error = A::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -95,84 +96,83 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapNewService<A, F, R> {
+pub struct MapNewService<A, F, Response> {
     a: A,
     f: F,
-    r: marker::PhantomData<R>,
+    r: PhantomData<Response>,
 }
 
-impl<A, F, R> MapNewService<A, F, R>
+impl<A, F, Response> MapNewService<A, F, Response> {
-where
-    A: NewService,
-    F: Fn(A::Response) -> R,
-{
     /// Create new `Map` new service instance
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::Response) -> Response,
+    {
         Self {
             a,
             f,
-            r: marker::PhantomData,
+            r: PhantomData,
         }
     }
 }
 
-impl<A, F, R> Clone for MapNewService<A, F, R>
+impl<A, F, Response> Clone for MapNewService<A, F, Response>
 where
-    A: NewService + Clone,
+    A: Clone,
-    F: Fn(A::Response) -> R + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            r: marker::PhantomData,
+            r: PhantomData,
         }
     }
 }
 
-impl<A, F, R> NewService for MapNewService<A, F, R>
+impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
 where
-    A: NewService,
+    A: NewService<Request>,
-    F: Fn(A::Response) -> R + Clone,
+    F: Fn(A::Response) -> Response + Clone,
 {
-    type Request = A::Request;
+    type Response = Response;
-    type Response = R;
     type Error = A::Error;
-    type Service = Map<A::Service, F, R>;
+    type Service = Map<A::Service, F, Response>;
 
     type InitError = A::InitError;
-    type Future = MapNewServiceFuture<A, F, R>;
+    type Future = MapNewServiceFuture<A, F, Request, Response>;
 
     fn new_service(&self) -> Self::Future {
         MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, R>
+pub struct MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
+    A: NewService<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, R> MapNewServiceFuture<A, F, R>
+impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
+    A: NewService<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapNewServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, R> Future for MapNewServiceFuture<A, F, R>
+impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
 where
-    A: NewService,
+    A: NewService<Request>,
-    F: Fn(A::Response) -> R,
+    F: Fn(A::Response) -> Response,
 {
-    type Item = Map<A::Service, F, R>;
+    type Item = Map<A::Service, F, Response>;
     type Error = A::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -189,11 +189,10 @@ mod tests {
     use futures::future::{ok, FutureResult};
 
     use super::*;
-    use service::{IntoNewService, NewServiceExt, Service, ServiceExt};
+    use crate::{IntoNewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;

actix-service/src/map_err.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Async, Future, Poll};
 
@@ -8,71 +8,71 @@ use super::{NewService, Service};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E>
+pub struct MapErr<A, F, E> {
-where
-    A: Service,
-    F: Fn(A::Error) -> E,
-{
     service: A,
     f: F,
+    _t: PhantomData<E>,
 }
 
-impl<A, F, E> MapErr<A, F, E>
+impl<A, F, E> MapErr<A, F, E> {
-where
-    A: Service,
-    F: Fn(A::Error) -> E,
-{
     /// Create new `MapErr` combinator
-    pub fn new(service: A, f: F) -> Self {
+    pub fn new<Request>(service: A, f: F) -> Self
-        Self { service, f }
+    where
+        A: Service<Request>,
+        F: Fn(A::Error) -> E,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
     }
 }
 
 impl<A, F, E> Clone for MapErr<A, F, E>
 where
-    A: Service + Clone,
+    A: Clone,
-    F: Fn(A::Error) -> E + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         MapErr {
             service: self.service.clone(),
             f: self.f.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
 where
-    A: Service,
+    A: Service<Request>,
-    F: Fn(A::Error) -> E,
+    F: Fn(A::Error) -> E + Clone,
-    F: Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E>;
+    type Future = MapErrFuture<A, F, E, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(&self.f)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapErrFuture<A, F, E>
+pub struct MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -80,9 +80,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrFuture<A, F, E>
+impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
 where
-    A: Service,
+    A: Service<Request>,
     F: Fn(A::Error) -> E,
 {
     type Item = A::Response;
@@ -100,68 +100,67 @@ where
 pub struct MapErrNewService<A, F, E> {
     a: A,
     f: F,
-    e: marker::PhantomData<E>,
+    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,
-{
     /// Create new `MapErr` new service instance
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::Error) -> E,
+    {
         Self {
             a,
             f,
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
 impl<A, F, E> Clone for MapErrNewService<A, F, E>
 where
-    A: NewService + Clone,
+    A: Clone,
-    F: Fn(A::Error) -> E + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
-impl<A, F, E> NewService for MapErrNewService<A, F, E>
+impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = MapErr<A::Service, F, E>;
 
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E>;
+    type Future = MapErrNewServiceFuture<A, F, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E>
+pub struct MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E> MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -169,9 +168,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
@@ -191,12 +190,11 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use service::{IntoNewService, NewServiceExt, Service, ServiceExt};
+    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<(), ()>;

actix-service/src/map_init_err.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use std::marker::PhantomData;
 
 use futures::{Future, Poll};
 
@@ -8,68 +8,67 @@ use super::NewService;
 pub struct MapInitErr<A, F, E> {
     a: A,
     f: F,
-    e: marker::PhantomData<E>,
+    e: PhantomData<E>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E>
+impl<A, F, E> MapInitErr<A, F, E> {
-where
-    A: NewService,
-    F: Fn(A::InitError) -> E,
-{
     /// Create new `MapInitErr` combinator
-    pub fn new(a: A, f: F) -> Self {
+    pub fn new<Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        F: Fn(A::InitError) -> E,
+    {
         Self {
             a,
             f,
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
 impl<A, F, E> Clone for MapInitErr<A, F, E>
 where
-    A: NewService + Clone,
+    A: Clone,
-    F: Fn(A::InitError) -> E + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Service = A::Service;
 
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, F, E, Request>;
 
     fn new_service(&self) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(), self.f.clone())
     }
 }
 
-pub struct MapInitErrFuture<A, F, E>
+pub struct MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -77,9 +76,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
     F: Fn(A::InitError) -> E,
 {
     type Item = A::Service;

actix-service/src/then.rs

@@ -1,7 +1,7 @@
-use futures::{Async, Future, Poll};
+use futures::{try_ready, Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
-use cell::Cell;
+use crate::cell::Cell;
 
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
@@ -12,21 +12,20 @@ pub struct Then<A, B> {
     b: Cell<B>,
 }
 
-impl<A, B> Then<A, B>
+impl<A, B> Then<A, B> {
-where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
-{
     /// Create new `Then` combinator
-    pub fn new(a: A, b: B) -> Then<A, B> {
+    pub fn new<Request>(a: A, b: B) -> Then<A, B>
+    where
+        A: Service<Request>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+    {
         Then { a, b: Cell::new(b) }
     }
 }
 
 impl<A, B> Clone for Then<A, B>
 where
-    A: Service + Clone,
+    A: Clone,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
 {
     fn clone(&self) -> Self {
         Then {
@@ -36,54 +35,53 @@ where
     }
 }
 
-impl<A, B> Service for Then<A, B>
+impl<A, B, Request> Service<Request> for Then<A, B>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    B: Service<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>;
+    type Future = ThenFuture<A, B, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let _ = try_ready!(self.a.poll_ready());
+        try_ready!(self.a.poll_ready());
-        self.b.borrow_mut().poll_ready()
+        self.b.get_mut().poll_ready()
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         ThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct ThenFuture<A, B>
+pub struct ThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<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> ThenFuture<A, B>
+impl<A, B, Request> ThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<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> Future for ThenFuture<A, B>
+impl<A, B, Request> Future for ThenFuture<A, B, Request>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Item = B::Response;
     type Error = B::Error;
@@ -93,13 +91,15 @@ 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)) => {
-                self.fut_b = Some(self.b.borrow_mut().call(Ok(resp)));
+                let _ = self.fut_a.take();
+                self.fut_b = Some(self.b.get_mut().call(Ok(resp)));
                 self.poll()
             }
             Err(err) => {
-                self.fut_b = Some(self.b.borrow_mut().call(Err(err)));
+                let _ = self.fut_a.take();
+                self.fut_b = Some(self.b.get_mut().call(Err(err)));
                 self.poll()
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -113,13 +113,18 @@ pub struct ThenNewService<A, B> {
     b: B,
 }
 
-impl<A, B> ThenNewService<A, B>
+impl<A, B> ThenNewService<A, B> {
-where
-    A: NewService,
-    B: NewService,
-{
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self {
+    pub fn new<F, Request>(a: A, f: F) -> Self
+    where
+        A: NewService<Request>,
+        B: NewService<
+            Result<A::Response, A::Error>,
+            Error = A::Error,
+            InitError = A::InitError,
+        >,
+        F: IntoNewService<B, Result<A::Response, A::Error>>,
+    {
         Self {
             a,
             b: f.into_new_service(),
@@ -127,22 +132,17 @@ where
     }
 }
 
-impl<A, B> NewService for ThenNewService<A, B>
+impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
-        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 Service = Then<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = ThenNewServiceFuture<A, B>;
+    type Future = ThenNewServiceFuture<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@@ -151,12 +151,8 @@ where
 
 impl<A, B> Clone for ThenNewService<A, B>
 where
-    A: NewService + Clone,
+    A: Clone,
-    B: NewService<
+    B: Clone,
-            Request = Result<A::Response, A::Error>,
-            Error = A::Error,
-            InitError = A::InitError,
-        > + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -166,10 +162,10 @@ where
     }
 }
 
-pub struct ThenNewServiceFuture<A, B>
+pub struct ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -177,10 +173,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> ThenNewServiceFuture<A, B>
+impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService,
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         ThenNewServiceFuture {
@@ -192,14 +188,10 @@ where
     }
 }
 
-impl<A, B> Future for ThenNewServiceFuture<A, B>
+impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     type Item = Then<A::Service, B::Service>;
     type Error = A::InitError;
@@ -231,17 +223,15 @@ 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};
-    use service::{NewServiceExt, ServiceExt};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
-    impl Service for Srv1 {
+    impl Service<Result<&'static str, &'static str>> for Srv1 {
-        type Request = Result<&'static str, &'static str>;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, Self::Error>;
@@ -251,7 +241,7 @@ mod tests {
             Ok(Async::Ready(()))
         }
 
-        fn call(&mut self, req: Self::Request) -> Self::Future {
+        fn call(&mut self, req: Result<&'static str, &'static str>) -> Self::Future {
             match req {
                 Ok(msg) => ok(msg),
                 Err(_) => err(()),
@@ -261,8 +251,7 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<Result<&'static str, ()>> for Srv2 {
-        type Request = Result<&'static str, ()>;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -272,7 +261,7 @@ mod tests {
             Ok(Async::Ready(()))
         }
 
-        fn call(&mut self, req: Self::Request) -> Self::Future {
+        fn call(&mut self, req: Result<&'static str, ()>) -> Self::Future {
             match req {
                 Ok(msg) => ok((msg, "ok")),
                 Err(()) => ok(("srv2", "err")),

actix-test-server/Cargo.toml

@@ -0,0 +1,57 @@
+[package]
+name = "actix-test-server"
+version = "0.1.0"
+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"
+workspace = "../"
+
+[package.metadata.docs.rs]
+features = ["ssl", "tls", "rust-tls"]
+
+[lib]
+name = "actix_test_server"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# tls
+tls = ["native-tls", "actix-server/tls"]
+
+# openssl
+ssl = ["openssl", "actix-server/ssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
+
+[dependencies]
+actix-rt = "0.1.0"
+actix-server = "0.1.0"
+
+log = "0.4"
+
+# io
+net2 = "0.2"
+futures = "0.1"
+tokio-tcp = "0.1"
+tokio-reactor = "0.1"
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", 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 }

actix-test-server/src/lib.rs

@@ -0,0 +1,142 @@
+//! Various helpers for Actix applications to use during testing.
+use std::sync::mpsc;
+use std::{net, thread};
+
+use actix_rt::{Runtime, System};
+use actix_server::{Server, StreamServiceFactory};
+
+use futures::Future;
+use net2::TcpBuilder;
+use tokio_reactor::Handle;
+use tokio_tcp::TcpStream;
+
+/// The `TestServer` type.
+///
+/// `TestServer` is very simple test server that simplify process of writing
+/// integration tests cases for actix applications.
+///
+/// # Examples
+///
+/// ```rust
+/// # extern crate actix_test_server;
+/// # use actix_web::*;
+/// #
+/// # fn my_handler(req: &HttpRequest) -> HttpResponse {
+/// #     HttpResponse::Ok().into()
+/// # }
+/// #
+/// # fn main() {
+/// use actix_test_server::TestServer;
+///
+/// let mut srv = TestServer::new(|app| app.handler(my_handler));
+///
+/// let req = srv.get().finish().unwrap();
+/// let response = srv.execute(req.send()).unwrap();
+/// assert!(response.status().is_success());
+/// # }
+/// ```
+pub struct TestServer;
+
+/// Test server runstime
+pub struct TestServerRuntime {
+    addr: net::SocketAddr,
+    host: String,
+    port: u16,
+    rt: Runtime,
+}
+
+impl TestServer {
+    /// Start new test server with application factory
+    pub fn with<F: StreamServiceFactory>(factory: F) -> TestServerRuntime {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        thread::spawn(move || {
+            let sys = System::new("actix-test-server");
+            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let local_addr = tcp.local_addr().unwrap();
+
+            Server::build()
+                .listen("test", tcp, factory)
+                .workers(1)
+                .disable_signals()
+                .start();
+
+            tx.send((System::current(), local_addr)).unwrap();
+            sys.run();
+        });
+
+        let (system, addr) = rx.recv().unwrap();
+        System::set_current(system);
+
+        let rt = Runtime::new().unwrap();
+        let host = format!("{}", addr.ip());
+        let port = addr.port();
+
+        TestServerRuntime {
+            addr,
+            rt,
+            host,
+            port,
+        }
+    }
+
+    /// Get firat available unused local address
+    pub 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()
+    }
+}
+
+impl TestServerRuntime {
+    /// Execute future on current runtime
+    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
+    where
+        F: Future<Item = I, Error = E>,
+    {
+        self.rt.block_on(fut)
+    }
+
+    /// Spawn future to the current runtime
+    pub fn spawn<F>(&mut self, fut: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.rt.spawn(fut);
+    }
+
+    /// Test server host
+    pub fn host(&self) -> &str {
+        &self.host
+    }
+
+    /// Test server port
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    /// Get test server address
+    pub fn addr(&self) -> net::SocketAddr {
+        self.addr
+    }
+
+    /// Stop http server
+    fn stop(&mut self) {
+        System::current().stop();
+    }
+
+    /// Connect to server, return tokio TcpStream
+    pub fn connect(&self) -> std::io::Result<TcpStream> {
+        TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default())
+    }
+}
+
+impl Drop for TestServerRuntime {
+    fn drop(&mut self) {
+        self.stop()
+    }
+}

actix-utils/CHANGES.md

@@ -0,0 +1,10 @@
+# Changes
+
+## [0.1.1] - 2018-xx-xx
+
+* Fix framed transport error handling
+
+
+## [0.1.0] - 2018-12-09
+
+* Move utils services to separate crate

actix-utils/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "actix-utils"
+version = "0.1.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix utils - various actix net related services"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-utils/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = "../"
+
+[lib]
+name = "actix_utils"
+path = "src/lib.rs"
+
+[dependencies]
+actix-service = "0.1.2"
+actix-codec = "0.1.0"
+actix-rt = "0.1.0"
+bytes = "0.4"
+futures = "0.1"
+tokio-timer = "0.2.8"
+log = "0.4"

actix-utils/src/cell.rs

@@ -30,33 +30,34 @@ impl<T: fmt::Debug> fmt::Debug for Cell<T> {
 
 #[cfg(feature = "cell")]
 impl<T> Cell<T> {
-    pub(crate) fn new(inner: T) -> Self {
+    pub fn new(inner: T) -> Self {
         Self {
             inner: Rc::new(UnsafeCell::new(inner)),
         }
     }
 
-    pub(crate) fn borrow(&self) -> &T {
+    pub fn borrow(&self) -> &T {
         unsafe { &*self.inner.as_ref().get() }
     }
 
-    pub(crate) fn borrow_mut(&self) -> &mut T {
+    pub fn borrow_mut(&self) -> &mut T {
         unsafe { &mut *self.inner.as_ref().get() }
     }
 }
 
 #[cfg(not(feature = "cell"))]
 impl<T> Cell<T> {
-    pub(crate) fn new(inner: T) -> Self {
+    pub fn new(inner: T) -> Self {
         Self {
             inner: Rc::new(RefCell::new(inner)),
         }
     }
 
-    pub(crate) fn borrow(&self) -> Ref<T> {
+    pub fn borrow(&self) -> Ref<T> {
         self.inner.borrow()
     }
-    pub(crate) fn borrow_mut(&self) -> RefMut<T> {
+
+    pub fn borrow_mut(&self) -> RefMut<T> {
         self.inner.borrow_mut()
     }
 }

actix-utils/src/cloneable.rs

@@ -0,0 +1,51 @@
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use actix_service::Service;
+use futures::Poll;
+
+use super::cell::Cell;
+
+/// Service that allows to turn non-clone service to a service with `Clone` impl
+pub struct CloneableService<T: 'static> {
+    service: Cell<T>,
+    _t: PhantomData<Rc<()>>,
+}
+
+impl<T: 'static> CloneableService<T> {
+    pub fn new<Request>(service: T) -> Self
+    where
+        T: Service<Request>,
+    {
+        Self {
+            service: Cell::new(service),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: 'static> Clone for CloneableService<T> {
+    fn clone(&self) -> Self {
+        Self {
+            service: self.service.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: 'static, Request> Service<Request> for CloneableService<T>
+where
+    T: Service<Request>,
+{
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.borrow_mut().poll_ready()
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        self.service.borrow_mut().call(req)
+    }
+}

actix-utils/src/either.rs

@@ -1,7 +1,6 @@
 //! Contains `Either` service and related types and functions.
-use futures::{future, Async, Future, Poll};
+use actix_service::{NewService, Service};
-
+use futures::{future, try_ready, Async, Future, Poll};
-use super::service::{NewService, Service};
 
 /// Combine two different service types into a single type.
 ///
@@ -13,12 +12,11 @@ pub enum EitherService<A, B> {
     B(B),
 }
 
-impl<A, B> Service for EitherService<A, B>
+impl<A, B, Request> Service<Request> for EitherService<A, B>
 where
-    A: Service,
+    A: Service<Request>,
-    B: Service<Request = A::Request, Response = A::Response, Error = A::Error>,
+    B: Service<Request, Response = A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Future = future::Either<A::Future, B::Future>;
@@ -30,7 +28,7 @@ where
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         match self {
             EitherService::A(ref mut inner) => future::Either::A(inner.call(req)),
             EitherService::B(ref mut inner) => future::Either::B(inner.call(req)),
@@ -44,22 +42,16 @@ pub enum Either<A, B> {
     B(B),
 }
 
-impl<A, B> NewService for Either<A, B>
+impl<A, B, Request> NewService<Request> for Either<A, B>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<
+    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type InitError = A::InitError;
     type Service = EitherService<A::Service, B::Service>;
-    type Future = EitherNewService<A, B>;
+    type Future = EitherNewService<A, B, Request>;
 
     fn new_service(&self) -> Self::Future {
         match self {
@@ -70,20 +62,15 @@ where
 }
 
 #[doc(hidden)]
-pub enum EitherNewService<A: NewService, B: NewService> {
+pub enum EitherNewService<A: NewService<R>, B: NewService<R>, R> {
     A(A::Future),
     B(B::Future),
 }
 
-impl<A, B> Future for EitherNewService<A, B>
+impl<A, B, Request> Future for EitherNewService<A, B, Request>
 where
-    A: NewService,
+    A: NewService<Request>,
-    B: NewService<
+    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     type Item = EitherService<A::Service, B::Service>;
     type Error = A::InitError;

actix-utils/src/framed.rs

@@ -2,15 +2,13 @@
 use std::marker::PhantomData;
 use std::mem;
 
-use actix;
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use actix_rt::Arbiter;
+use actix_service::{IntoNewService, IntoService, NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::unsync::mpsc;
-use futures::{Async, AsyncSink, Future, Poll, Sink, Stream};
+use futures::{Async, Future, Poll, Sink, Stream};
-use tokio_codec::{Decoder, Encoder};
+use log::debug;
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use codec::Framed;
-use service::{IntoNewService, IntoService, NewService, Service};
 
 type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
@@ -24,13 +22,13 @@ impl<S, T, U> FramedNewService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
+    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    pub fn new<F1: IntoNewService<S>>(factory: F1) -> Self {
+    pub fn new<F1: IntoNewService<S, Request<U>>>(factory: F1) -> Self {
         Self {
             factory: factory.into_new_service(),
             _t: PhantomData,
@@ -50,17 +48,16 @@ where
     }
 }
 
-impl<S, T, U> NewService for FramedNewService<S, T, U>
+impl<S, T, U> NewService<Framed<T, U>> for FramedNewService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
+    S: NewService<Request<U>, Response = Response<U>> + Clone,
-    <<S as NewService>::Service as Service>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type InitError = S::InitError;
@@ -92,17 +89,16 @@ where
     }
 }
 
-impl<S, T, U> Service for FramedService<S, T, U>
+impl<S, T, U> Service<Framed<T, U>> for FramedService<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type Future = FramedServiceResponseFuture<S, T, U>;
@@ -111,7 +107,7 @@ where
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Framed<T, U>) -> Self::Future {
         FramedServiceResponseFuture {
             fut: self.factory.new_service(),
 
@@ -125,9 +121,9 @@ pub struct FramedServiceResponseFuture<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
@@ -139,9 +135,9 @@ impl<S, T, U> Future for FramedServiceResponseFuture<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService>::Service as Service>::Future: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService>::Service as Service>::Error: 'static,
+    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: 'static,
 {
@@ -176,7 +172,7 @@ impl<E, U: Encoder + Decoder> From<E> for FramedTransportError<E, U> {
 /// and pass then to the service.
 pub struct FramedTransport<S, T, U>
 where
-    S: Service,
+    S: Service<Request<U>, Response = Response<U>>,
     T: AsyncRead + AsyncWrite,
     U: Encoder + Decoder,
 {
@@ -184,16 +180,14 @@ where
     state: TransportState<S, U>,
     framed: Framed<T, U>,
     request: Option<Request<U>>,
-    response: Option<Response<U>>,
     write_rx: mpsc::Receiver<Result<Response<U>, S::Error>>,
     write_tx: mpsc::Sender<Result<Response<U>, S::Error>>,
-    flushed: bool,
 }
 
-enum TransportState<S: Service, U: Encoder + Decoder> {
+enum TransportState<S: Service<Request<U>>, U: Encoder + Decoder> {
     Processing,
     Error(FramedTransportError<S::Error, U>),
-    EncoderError(FramedTransportError<S::Error, U>),
+    FramedError(FramedTransportError<S::Error, U>),
     Stopping,
 }
 
@@ -201,12 +195,12 @@ impl<S, T, U> FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Error: 'static,
 {
-    pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self {
+    pub fn new<F: IntoService<S, Request<U>>>(framed: Framed<T, U>, service: F) -> Self {
         let (write_tx, write_rx) = mpsc::channel(16);
         FramedTransport {
             framed,
@@ -215,8 +209,6 @@ where
             service: service.into_service(),
             state: TransportState::Processing,
             request: None,
-            response: None,
-            flushed: true,
         }
     }
 
@@ -248,18 +240,18 @@ impl<S, T, U> FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug + 'static,
 {
     fn poll_service(&mut self) -> bool {
         match self.service.poll_ready() {
             Ok(Async::Ready(_)) => {
                 if let Some(item) = self.request.take() {
                     let sender = self.write_tx.clone();
-                    actix::Arbiter::spawn(
+                    Arbiter::spawn(
                         self.service
                             .call(item)
                             .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
@@ -271,7 +263,7 @@ where
                         Ok(Async::Ready(Some(el))) => el,
                         Err(err) => {
                             self.state =
-                                TransportState::Error(FramedTransportError::Decoder(err));
+                                TransportState::FramedError(FramedTransportError::Decoder(err));
                             return true;
                         }
                         Ok(Async::NotReady) => return false,
@@ -284,7 +276,7 @@ where
                     match self.service.poll_ready() {
                         Ok(Async::Ready(_)) => {
                             let sender = self.write_tx.clone();
-                            actix::Arbiter::spawn(
+                            Arbiter::spawn(
                                 self.service
                                     .call(item)
                                     .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
@@ -302,69 +294,52 @@ where
                     }
                 }
             }
-            Ok(Async::NotReady) => return false,
+            Ok(Async::NotReady) => false,
             Err(err) => {
                 self.state = TransportState::Error(FramedTransportError::Service(err));
-                return true;
+                true
             }
         }
     }
 
     /// write to sink
     fn poll_response(&mut self) -> bool {
-        let mut item = self.response.take();
         loop {
-            item = if let Some(msg) = item {
+            while !self.framed.is_write_buf_full() {
-                self.flushed = false;
+                match self.write_rx.poll() {
-                match self.framed.start_send(msg) {
+                    Ok(Async::Ready(Some(msg))) => match msg {
-                    Ok(AsyncSink::Ready) => None,
+                        Ok(msg) => {
-                    Ok(AsyncSink::NotReady(item)) => Some(item),
+                            if let Err(err) = self.framed.force_send(msg) {
-                    Err(err) => {
+                                self.state = TransportState::FramedError(
-                        self.state =
+                                    FramedTransportError::Encoder(err),
-                            TransportState::EncoderError(FramedTransportError::Encoder(err));
+                                );
-                        return true;
+                                return true;
-                    }
+                            }
-                }
+                        }
-            } else {
+                        Err(err) => {
-                None
+                            self.state =
-            };
+                                TransportState::Error(FramedTransportError::Service(err));
-
+                            return true;
-            // flush sink
+                        }
-            if !self.flushed {
+                    },
-                match self.framed.poll_complete() {
-                    Ok(Async::Ready(_)) => {
-                        self.flushed = true;
-                    }
                     Ok(Async::NotReady) => break,
-                    Err(err) => {
+                    Err(_) => panic!("Bug in actix-net code"),
-                        self.state =
+                    Ok(Async::Ready(None)) => panic!("Bug in actix-net code"),
-                            TransportState::EncoderError(FramedTransportError::Encoder(err));
-                        return true;
-                    }
                 }
             }
 
-            // check channel
+            if !self.framed.is_write_buf_empty() {
-            if self.flushed {
+                match self.framed.poll_complete() {
-                if item.is_none() {
+                    Ok(Async::NotReady) => break,
-                    match self.write_rx.poll() {
+                    Err(err) => {
-                        Ok(Async::Ready(Some(msg))) => match msg {
+                        debug!("Error sending data: {:?}", err);
-                            Ok(msg) => item = Some(msg),
+                        self.state =
-                            Err(err) => {
+                            TransportState::FramedError(FramedTransportError::Encoder(err));
-                                self.state =
+                        return true;
-                                    TransportState::Error(FramedTransportError::Service(err));
-                                return true;
-                            }
-                        },
-                        Ok(Async::NotReady) => break,
-                        Err(_) => panic!("Bug in gw code"),
-                        Ok(Async::Ready(None)) => panic!("Bug in gw code"),
                     }
-                } else {
+                    Ok(Async::Ready(_)) => (),
-                    continue;
                 }
             } else {
-                self.response = item;
                 break;
             }
         }
@@ -377,11 +352,11 @@ impl<S, T, U> Future for FramedTransport<S, T, U>
 where
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Future: 'static,
     S::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug + 'static,
 {
     type Item = ();
     type Error = FramedTransportError<S::Error, U>;
@@ -389,26 +364,24 @@ where
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         match mem::replace(&mut self.state, TransportState::Processing) {
             TransportState::Processing => {
-                if self.poll_service() {
+                if self.poll_service() || self.poll_response() {
-                    return self.poll();
+                    self.poll()
+                } else {
+                    Ok(Async::NotReady)
                 }
-                if self.poll_response() {
-                    return self.poll();
-                }
-                return Ok(Async::NotReady);
             }
             TransportState::Error(err) => {
-                if self.poll_response() {
+                if self.framed.is_write_buf_empty()
-                    return Err(err);
+                    || (self.poll_response() || self.framed.is_write_buf_empty())
+                {
+                    Err(err)
+                } else {
+                    self.state = TransportState::Error(err);
+                    Ok(Async::NotReady)
                 }
-                if self.flushed {
-                    return Err(err);
-                }
-                self.state = TransportState::Error(err);
-                return Ok(Async::NotReady);
             }
-            TransportState::EncoderError(err) => return Err(err),
+            TransportState::FramedError(err) => Err(err),
-            TransportState::Stopping => return Ok(Async::Ready(())),
+            TransportState::Stopping => Ok(Async::Ready(())),
         }
     }
 }
@@ -437,13 +410,12 @@ where
     }
 }
 
-impl<T, U, F> NewService for IntoFramed<T, U, F>
+impl<T, U, F> NewService<T> for IntoFramed<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type InitError = ();
@@ -468,13 +440,12 @@ where
     _t: PhantomData<(T,)>,
 }
 
-impl<T, U, F> Service for IntoFramedService<T, U, F>
+impl<T, U, F> Service<T> for IntoFramedService<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type Future = FutureResult<Self::Response, Self::Error>;
@@ -483,7 +454,7 @@ where
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         ok(Framed::new(req, (self.factory)()))
     }
 }

actix-utils/src/inflight.rs

@@ -1,7 +1,7 @@
-use futures::{Async, Future, Poll};
+use actix_service::{IntoNewService, IntoService, NewService, Service};
+use futures::{try_ready, Async, Future, Poll};
 
 use super::counter::{Counter, CounterGuard};
-use super::service::{IntoNewService, IntoService, NewService, Service};
 
 /// InFlight - new service for service that can limit number of in-flight
 /// async requests.
@@ -12,11 +12,12 @@ pub struct InFlight<T> {
     max_inflight: usize,
 }
 
-impl<T> InFlight<T>
+impl<T> InFlight<T> {
-where
+    pub fn new<F, Request>(factory: F) -> Self
-    T: NewService,
+    where
-{
+        T: NewService<Request>,
-    pub fn new<F: IntoNewService<T>>(factory: F) -> Self {
+        F: IntoNewService<T, Request>,
+    {
         Self {
             factory: factory.into_new_service(),
             max_inflight: 15,
@@ -32,16 +33,15 @@ where
     }
 }
 
-impl<T> NewService for InFlight<T>
+impl<T, Request> NewService<Request> for InFlight<T>
 where
-    T: NewService,
+    T: NewService<Request>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
     type Service = InFlightService<T::Service>;
-    type Future = InFlightResponseFuture<T>;
+    type Future = InFlightResponseFuture<T, Request>;
 
     fn new_service(&self) -> Self::Future {
         InFlightResponseFuture {
@@ -51,12 +51,12 @@ where
     }
 }
 
-pub struct InFlightResponseFuture<T: NewService> {
+pub struct InFlightResponseFuture<T: NewService<Request>, Request> {
     fut: T::Future,
     max_inflight: usize,
 }
 
-impl<T: NewService> Future for InFlightResponseFuture<T> {
+impl<T: NewService<Request>, Request> Future for InFlightResponseFuture<T, Request> {
     type Item = InFlightService<T::Service>;
     type Error = T::InitError;
 
@@ -73,15 +73,23 @@ pub struct InFlightService<T> {
     count: Counter,
 }
 
-impl<T: Service> InFlightService<T> {
+impl<T> InFlightService<T> {
-    pub fn new<F: IntoService<T>>(service: F) -> Self {
+    pub fn new<F, Request>(service: F) -> Self
+    where
+        T: Service<Request>,
+        F: IntoService<T, Request>,
+    {
         Self {
             service: service.into_service(),
             count: Counter::new(15),
         }
     }
 
-    pub fn with_max_inflight<F: IntoService<T>>(max: usize, service: F) -> Self {
+    pub fn with_max_inflight<F, Request>(max: usize, service: F) -> Self
+    where
+        T: Service<Request>,
+        F: IntoService<T, Request>,
+    {
         Self {
             service: service.into_service(),
             count: Counter::new(max),
@@ -89,11 +97,13 @@ impl<T: Service> InFlightService<T> {
     }
 }
 
-impl<T: Service> Service for InFlightService<T> {
+impl<T, Request> Service<Request> for InFlightService<T>
-    type Request = T::Request;
+where
+    T: Service<Request>,
+{
     type Response = T::Response;
     type Error = T::Error;
-    type Future = InFlightServiceResponse<T>;
+    type Future = InFlightServiceResponse<T, Request>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         let res = self.service.poll_ready();
@@ -103,22 +113,21 @@ impl<T: Service> Service for InFlightService<T> {
         res
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Request) -> Self::Future {
         InFlightServiceResponse {
             fut: self.service.call(req),
-            guard: self.count.get(),
+            _guard: self.count.get(),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct InFlightServiceResponse<T: Service> {
+pub struct InFlightServiceResponse<T: Service<Request>, Request> {
     fut: T::Future,
-    #[allow(dead_code)]
+    _guard: CounterGuard,
-    guard: CounterGuard,
 }
 
-impl<T: Service> Future for InFlightServiceResponse<T> {
+impl<T: Service<Request>, Request> Future for InFlightServiceResponse<T, Request> {
     type Item = T::Response;
     type Error = T::Error;
 

actix-utils/src/keepalive.rs

@@ -1,18 +1,18 @@
 use std::marker::PhantomData;
 use std::time::{Duration, Instant};
 
+use actix_service::{NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::Delay;
 
-use super::service::{NewService, Service};
+use super::time::{LowResTime, LowResTimeService};
-use super::timer::{LowResTimer, LowResTimerService};
 use super::Never;
 
 pub struct KeepAlive<R, E, F> {
     f: F,
     ka: Duration,
-    timer: LowResTimer,
+    time: LowResTime,
     _t: PhantomData<(R, E)>,
 }
 
@@ -20,11 +20,11 @@ impl<R, E, F> KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
-    pub fn new(ka: Duration, timer: LowResTimer, f: F) -> Self {
+    pub fn new(ka: Duration, time: LowResTime, f: F) -> Self {
         KeepAlive {
             f,
             ka,
-            timer,
+            time,
             _t: PhantomData,
         }
     }
@@ -32,23 +32,22 @@ where
 
 impl<R, E, F> Clone for KeepAlive<R, E, F>
 where
-    F: Fn() -> E + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         KeepAlive {
             f: self.f.clone(),
             ka: self.ka,
-            timer: self.timer.clone(),
+            time: self.time.clone(),
             _t: PhantomData,
         }
     }
 }
 
-impl<R, E, F> NewService for KeepAlive<R, E, F>
+impl<R, E, F> NewService<R> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
     type InitError = Never;
@@ -58,7 +57,7 @@ where
     fn new_service(&self) -> Self::Future {
         ok(KeepAliveService::new(
             self.ka,
-            self.timer.timer(),
+            self.time.timer(),
             self.f.clone(),
         ))
     }
@@ -67,7 +66,7 @@ where
 pub struct KeepAliveService<R, E, F> {
     f: F,
     ka: Duration,
-    timer: LowResTimerService,
+    time: LowResTimeService,
     delay: Delay,
     expire: Instant,
     _t: PhantomData<(R, E)>,
@@ -77,24 +76,23 @@ impl<R, E, F> KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
-    pub fn new(ka: Duration, mut timer: LowResTimerService, f: F) -> Self {
+    pub fn new(ka: Duration, time: LowResTimeService, f: F) -> Self {
-        let expire = timer.now() + ka;
+        let expire = time.now() + ka;
         KeepAliveService {
             f,
             ka,
-            timer,
+            time,
-            delay: Delay::new(expire),
             expire,
+            delay: Delay::new(expire),
             _t: PhantomData,
         }
     }
 }
 
-impl<R, E, F> Service for KeepAliveService<R, E, F>
+impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
     type Future = FutureResult<R, E>;
@@ -102,11 +100,11 @@ where
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         match self.delay.poll() {
             Ok(Async::Ready(_)) => {
-                let now = self.timer.now();
+                let now = self.time.now();
                 if self.expire <= now {
                     Err((self.f)())
                 } else {
-                    self.delay = Delay::new(self.expire);
+                    self.delay.reset(self.expire);
                     let _ = self.delay.poll();
                     Ok(Async::Ready(()))
                 }
@@ -116,8 +114,8 @@ where
         }
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
-        self.expire = self.timer.now() + self.ka;
+        self.expire = self.time.now() + self.ka;
         ok(req)
     }
 }

actix-utils/src/lib.rs

@@ -0,0 +1,14 @@
+//! Actix utils - various helper services
+mod cell;
+pub mod cloneable;
+pub mod counter;
+pub mod either;
+pub mod framed;
+pub mod inflight;
+pub mod keepalive;
+pub mod stream;
+pub mod time;
+pub mod timeout;
+
+#[derive(Copy, Clone, Debug)]
+pub enum Never {}

actix-utils/src/stream.rs

@@ -1,26 +1,32 @@
 use std::marker::PhantomData;
 
+use actix_rt::spawn;
+use actix_service::{IntoService, NewService, Service};
 use futures::unsync::mpsc;
 use futures::{future, Async, Future, Poll, Stream};
-use tokio::executor::current_thread::spawn;
 
-use super::service::{IntoService, NewService, Service};
+pub struct StreamDispatcher<S, T>
-
+where
-pub struct StreamDispatcher<S: Stream, T> {
+    S: Stream,
+    T: Service<Result<S::Item, S::Error>>,
+{
     stream: S,
     service: T,
     item: Option<Result<S::Item, S::Error>>,
-    stop_rx: mpsc::UnboundedReceiver<()>,
+    stop_rx: mpsc::UnboundedReceiver<T::Error>,
-    stop_tx: mpsc::UnboundedSender<()>,
+    stop_tx: mpsc::UnboundedSender<T::Error>,
 }
 
 impl<S, T> StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Result<S::Item, S::Error>, Response = ()>,
     T::Future: 'static,
 {
-    pub fn new<F: IntoService<T>>(stream: S, service: F) -> Self {
+    pub fn new<F>(stream: S, service: F) -> Self
+    where
+        F: IntoService<T, Result<S::Item, S::Error>>,
+    {
         let (stop_tx, stop_rx) = mpsc::unbounded();
         StreamDispatcher {
             stream,
@@ -35,15 +41,15 @@ where
 impl<S, T> Future for StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Result<S::Item, S::Error>, Response = ()>,
     T::Future: 'static,
 {
     type Item = ();
-    type Error = ();
+    type Error = T::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Ok(Async::Ready(Some(_))) = self.stop_rx.poll() {
+        if let Ok(Async::Ready(Some(e))) = self.stop_rx.poll() {
-            return Ok(Async::Ready(()));
+            return Err(e);
         }
 
         let mut item = self.item.take();
@@ -72,7 +78,7 @@ where
 
 struct StreamDispatcherService<F: Future> {
     fut: F,
-    stop: mpsc::UnboundedSender<()>,
+    stop: mpsc::UnboundedSender<F::Error>,
 }
 
 impl<F: Future> Future for StreamDispatcherService<F> {
@@ -83,8 +89,8 @@ impl<F: Future> Future for StreamDispatcherService<F> {
         match self.fut.poll() {
             Ok(Async::Ready(_)) => Ok(Async::Ready(())),
             Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => {
+            Err(e) => {
-                let _ = self.stop.unbounded_send(());
+                let _ = self.stop.unbounded_send(e);
                 Ok(Async::Ready(()))
             }
         }
@@ -103,8 +109,19 @@ impl<T> TakeItem<T> {
     }
 }
 
-impl<T: Stream> NewService for TakeItem<T> {
+impl<T> Default for TakeItem<T> {
-    type Request = T;
+    fn default() -> Self {
+        TakeItem { _t: PhantomData }
+    }
+}
+
+impl<T> Clone for TakeItem<T> {
+    fn clone(&self) -> TakeItem<T> {
+        TakeItem { _t: PhantomData }
+    }
+}
+
+impl<T: Stream> NewService<T> for TakeItem<T> {
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type InitError = ();
@@ -121,8 +138,13 @@ pub struct TakeItemService<T> {
     _t: PhantomData<T>,
 }
 
-impl<T: Stream> Service for TakeItemService<T> {
+impl<T> Clone for TakeItemService<T> {
-    type Request = T;
+    fn clone(&self) -> TakeItemService<T> {
+        TakeItemService { _t: PhantomData }
+    }
+}
+
+impl<T: Stream> Service<T> for TakeItemService<T> {
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type Future = TakeItemServiceResponse<T>;
@@ -131,7 +153,7 @@ impl<T: Stream> Service for TakeItemService<T> {
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: T) -> Self::Future {
         TakeItemServiceResponse { stream: Some(req) }
     }
 }

actix-utils/src/time.rs

@@ -1,16 +1,16 @@
 use std::time::{Duration, Instant};
 
+use actix_rt::spawn;
+use actix_service::{NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
-use tokio_current_thread::spawn;
 use tokio_timer::sleep;
 
 use super::cell::Cell;
-use super::service::{NewService, Service};
 use super::Never;
 
 #[derive(Clone, Debug)]
-pub struct LowResTimer(Cell<Inner>);
+pub struct LowResTime(Cell<Inner>);
 
 #[derive(Debug)]
 struct Inner {
@@ -27,28 +27,27 @@ impl Inner {
     }
 }
 
-impl LowResTimer {
+impl LowResTime {
-    pub fn with(resolution: Duration) -> LowResTimer {
+    pub fn with(resolution: Duration) -> LowResTime {
-        LowResTimer(Cell::new(Inner::new(resolution)))
+        LowResTime(Cell::new(Inner::new(resolution)))
     }
 
-    pub fn timer(&self) -> LowResTimerService {
+    pub fn timer(&self) -> LowResTimeService {
-        LowResTimerService(self.0.clone())
+        LowResTimeService(self.0.clone())
     }
 }
 
-impl Default for LowResTimer {
+impl Default for LowResTime {
     fn default() -> Self {
-        LowResTimer(Cell::new(Inner::new(Duration::from_secs(1))))
+        LowResTime(Cell::new(Inner::new(Duration::from_secs(1))))
     }
 }
 
-impl NewService for LowResTimer {
+impl NewService<()> for LowResTime {
-    type Request = ();
     type Response = Instant;
     type Error = Never;
     type InitError = Never;
-    type Service = LowResTimerService;
+    type Service = LowResTimeService;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
     fn new_service(&self) -> Self::Future {
@@ -57,17 +56,17 @@ impl NewService for LowResTimer {
 }
 
 #[derive(Clone, Debug)]
-pub struct LowResTimerService(Cell<Inner>);
+pub struct LowResTimeService(Cell<Inner>);
 
-impl LowResTimerService {
+impl LowResTimeService {
-    pub fn with(resolution: Duration) -> LowResTimerService {
+    pub fn with(resolution: Duration) -> LowResTimeService {
-        LowResTimerService(Cell::new(Inner::new(resolution)))
+        LowResTimeService(Cell::new(Inner::new(resolution)))
     }
 
     /// Get current time. This function has to be called from
     /// future's poll method, otherwise it panics.
-    pub fn now(&mut self) -> Instant {
+    pub fn now(&self) -> Instant {
-        let cur = self.0.borrow().current.clone();
+        let cur = self.0.borrow().current;
         if let Some(cur) = cur {
             cur
         } else {
@@ -88,8 +87,7 @@ impl LowResTimerService {
     }
 }
 
-impl Service for LowResTimerService {
+impl Service<()> for LowResTimeService {
-    type Request = ();
     type Response = Instant;
     type Error = Never;
     type Future = FutureResult<Self::Response, Self::Error>;

actix-utils/src/timeout.rs

@@ -0,0 +1,158 @@
+//! Service that applies a timeout to requests.
+//!
+//! If the response does not complete within the specified timeout, the response
+//! will be aborted.
+use std::fmt;
+use std::time::Duration;
+
+use actix_service::{NewService, Service};
+use futures::try_ready;
+use futures::{Async, Future, Poll};
+use tokio_timer::{clock, Delay};
+
+/// Applies a timeout to requests.
+#[derive(Debug)]
+pub struct Timeout<T> {
+    inner: T,
+    timeout: Duration,
+}
+
+/// Timeout error
+pub enum TimeoutError<E> {
+    /// Service error
+    Service(E),
+    /// Service call timeout
+    Timeout,
+}
+
+impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TimeoutError::Service(e) => write!(f, "TimeoutError::Service({:?})", e),
+            TimeoutError::Timeout => write!(f, "TimeoutError::Timeout"),
+        }
+    }
+}
+
+impl<T> Timeout<T> {
+    pub fn new<Request>(timeout: Duration, inner: T) -> Self
+    where
+        T: NewService<Request> + Clone,
+    {
+        Timeout { inner, timeout }
+    }
+}
+
+impl<T, Request> NewService<Request> for Timeout<T>
+where
+    T: NewService<Request> + Clone,
+{
+    type Response = T::Response;
+    type Error = TimeoutError<T::Error>;
+    type InitError = T::InitError;
+    type Service = TimeoutService<T::Service>;
+    type Future = TimeoutFut<T, Request>;
+
+    fn new_service(&self) -> Self::Future {
+        TimeoutFut {
+            fut: self.inner.new_service(),
+            timeout: self.timeout,
+        }
+    }
+}
+
+/// `Timeout` response future
+#[derive(Debug)]
+pub struct TimeoutFut<T: NewService<Request>, Request> {
+    fut: T::Future,
+    timeout: Duration,
+}
+
+impl<T, Request> Future for TimeoutFut<T, Request>
+where
+    T: NewService<Request>,
+{
+    type Item = TimeoutService<T::Service>;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let service = try_ready!(self.fut.poll());
+        Ok(Async::Ready(TimeoutService::new(self.timeout, service)))
+    }
+}
+
+/// Applies a timeout to requests.
+#[derive(Debug)]
+pub struct TimeoutService<T> {
+    inner: T,
+    timeout: Duration,
+}
+
+impl<T> TimeoutService<T> {
+    pub fn new<Request>(timeout: Duration, inner: T) -> Self
+    where
+        T: Service<Request>,
+    {
+        TimeoutService { inner, timeout }
+    }
+}
+
+impl<T: Clone> Clone for TimeoutService<T> {
+    fn clone(&self) -> Self {
+        TimeoutService {
+            inner: self.inner.clone(),
+            timeout: self.timeout,
+        }
+    }
+}
+
+impl<T, Request> Service<Request> for TimeoutService<T>
+where
+    T: Service<Request>,
+{
+    type Response = T::Response;
+    type Error = TimeoutError<T::Error>;
+    type Future = TimeoutServiceResponse<T, Request>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.inner.poll_ready().map_err(TimeoutError::Service)
+    }
+
+    fn call(&mut self, request: Request) -> Self::Future {
+        TimeoutServiceResponse {
+            fut: self.inner.call(request),
+            sleep: Delay::new(clock::now() + self.timeout),
+        }
+    }
+}
+
+/// `TimeoutService` response future
+#[derive(Debug)]
+pub struct TimeoutServiceResponse<T: Service<Request>, Request> {
+    fut: T::Future,
+    sleep: Delay,
+}
+
+impl<T, Request> Future for TimeoutServiceResponse<T, Request>
+where
+    T: Service<Request>,
+{
+    type Item = T::Response;
+    type Error = TimeoutError<T::Error>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        // First, try polling the future
+        match self.fut.poll() {
+            Ok(Async::Ready(v)) => return Ok(Async::Ready(v)),
+            Ok(Async::NotReady) => {}
+            Err(e) => return Err(TimeoutError::Service(e)),
+        }
+
+        // Now check the sleep
+        match self.sleep.poll() {
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Ok(Async::Ready(_)) => Err(TimeoutError::Timeout),
+            Err(_) => Err(TimeoutError::Timeout),
+        }
+    }
+}

examples/basic.rs

@@ -1,29 +1,20 @@
 //! simple composite service
 //! build: cargo run --example basic --features "ssl"
 //! to test: curl https://127.0.0.1:8443/ -k
-extern crate actix;
-extern crate actix_net;
-extern crate env_logger;
-extern crate futures;
-extern crate openssl;
-extern crate tokio_io;
-extern crate tokio_openssl;
-extern crate tokio_tcp;
-
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
 };
 use std::{env, fmt};
 
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::System;
+use actix_server::Server;
+use actix_service::{IntoNewService, NewService};
 use futures::{future, Future};
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
-use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_openssl::SslAcceptorExt;
 
-use actix_net::server::Server;
-use actix_net::service::{IntoNewService, NewServiceExt};
-
 /// Simple logger service, it just prints fact of the new connections
 fn logger<T: AsyncRead + AsyncWrite + fmt::Debug>(
     stream: T,
@@ -36,7 +27,7 @@ fn main() {
     env::set_var("RUST_LOG", "actix_net=trace");
     env_logger::init();
 
-    let sys = actix::System::new("test");
+    let sys = System::new("test");
 
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@@ -53,7 +44,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",
@@ -80,7 +71,8 @@ fn main() {
                     future::ok(())
                 })
             },
-        ).unwrap()
+        )
+        .unwrap()
         .start();
 
     sys.run();

examples/ssl.rs

@@ -1,22 +1,14 @@
-extern crate actix;
-extern crate actix_net;
-extern crate futures;
-extern crate openssl;
-extern crate tokio_io;
-extern crate tokio_tcp;
-
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
 };
 
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::System;
+use actix_server::{ssl, Server};
+use actix_service::NewService;
 use futures::{future, Future};
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use actix_net::server::Server;
-use actix_net::service::NewServiceExt;
-use actix_net::ssl;
 
 #[derive(Debug)]
 struct ServiceState {
@@ -24,7 +16,8 @@ struct ServiceState {
 }
 
 fn service<T: AsyncRead + AsyncWrite>(
-    st: &mut ServiceState, _: T,
+    st: &mut ServiceState,
+    _: T,
 ) -> impl Future<Item = (), Error = ()> {
     let num = st.num.fetch_add(1, Ordering::Relaxed);
     println!("got ssl connection {:?}", num);
@@ -32,7 +25,7 @@ fn service<T: AsyncRead + AsyncWrite>(
 }
 
 fn main() {
-    let sys = actix::System::new("test");
+    let sys = System::new("test");
 
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@@ -47,7 +40,7 @@ fn main() {
     let openssl = ssl::OpensslAcceptor::new(builder.build());
 
     // server start mutiple workers, it runs supplied `Fn` in each worker.
-    Server::default()
+    Server::build()
         .bind("test-ssl", "0.0.0.0:8443", move || {
             let num = num.clone();
 
@@ -60,7 +53,8 @@ fn main() {
                     println!("got ssl connection {:?}", num);
                     future::ok(())
                 })
-        }).unwrap()
+        })
+        .unwrap()
         .start();
 
     sys.run();

router/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "actix-router"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Path router"
+keywords = ["actix"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://actix.rs/api/actix-net/stable/actix_router/"
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = "../"
+
+[lib]
+name = "actix_router"
+path = "src/lib.rs"
+
+[features]
+default = ["http"]
+
+[dependencies]
+bytes = "0.4"
+regex = "1.0"
+serde = "1.0.80"
+string = "0.1.3"
+http = { version="0.1.14", optional=true }
+
+[dev-dependencies]
+serde_derive = "1.0"

router/src/de.rs

@@ -0,0 +1,709 @@
+use serde::de::{self, Deserializer, Error as DeError, Visitor};
+use serde::forward_to_deserialize_any;
+
+use crate::path::{Path, PathIter};
+use crate::RequestPath;
+
+macro_rules! unsupported_type {
+    ($trait_fn:ident, $name:expr) => {
+        fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            Err(de::value::Error::custom(concat!("unsupported type: ", $name)))
+        }
+    };
+}
+
+macro_rules! parse_single_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            if self.path.len() != 1 {
+                Err(de::value::Error::custom(
+                    format!("wrong number of parameters: {} expected 1",
+                            self.path.len()).as_str()))
+            } else {
+                let v = self.path[0].parse().map_err(
+                    |_| de::value::Error::custom(
+                        format!("can not parse {:?} to a {}", &self.path[0], $tp)))?;
+                visitor.$visit_fn(v)
+            }
+        }
+    }
+}
+
+pub struct PathDeserializer<'de, T: RequestPath + 'de> {
+    path: &'de Path<T>,
+}
+
+impl<'de, T: RequestPath + 'de> PathDeserializer<'de, T> {
+    pub fn new(path: &'de Path<T>) -> Self {
+        PathDeserializer { path }
+    }
+}
+
+impl<'de, T: RequestPath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
+    type Error = de::value::Error;
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(ParamsDeserializer {
+            params: self.path.iter(),
+            current: None,
+        })
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.len(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.len(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < 1 {
+            Err(de::value::Error::custom(
+                "expeceted at least one parameters",
+            ))
+        } else {
+            visitor.visit_enum(ValueEnum {
+                value: &self.path[0],
+            })
+        }
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() != 1 {
+            Err(de::value::Error::custom(
+                format!("wrong number of parameters: {} expected 1", self.path.len()).as_str(),
+            ))
+        } else {
+            visitor.visit_str(&self.path[0])
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_seq(ParamsSeq {
+            params: self.path.iter(),
+        })
+    }
+
+    unsupported_type!(deserialize_any, "'any'");
+    unsupported_type!(deserialize_bytes, "bytes");
+    unsupported_type!(deserialize_option, "Option<T>");
+    unsupported_type!(deserialize_identifier, "identifier");
+    unsupported_type!(deserialize_ignored_any, "ignored_any");
+
+    parse_single_value!(deserialize_bool, visit_bool, "bool");
+    parse_single_value!(deserialize_i8, visit_i8, "i8");
+    parse_single_value!(deserialize_i16, visit_i16, "i16");
+    parse_single_value!(deserialize_i32, visit_i32, "i32");
+    parse_single_value!(deserialize_i64, visit_i64, "i64");
+    parse_single_value!(deserialize_u8, visit_u8, "u8");
+    parse_single_value!(deserialize_u16, visit_u16, "u16");
+    parse_single_value!(deserialize_u32, visit_u32, "u32");
+    parse_single_value!(deserialize_u64, visit_u64, "u64");
+    parse_single_value!(deserialize_f32, visit_f32, "f32");
+    parse_single_value!(deserialize_f64, visit_f64, "f64");
+    parse_single_value!(deserialize_string, visit_string, "String");
+    parse_single_value!(deserialize_byte_buf, visit_string, "String");
+    parse_single_value!(deserialize_char, visit_char, "char");
+}
+
+struct ParamsDeserializer<'de, T: RequestPath> {
+    params: PathIter<'de, T>,
+    current: Option<(&'de str, &'de str)>,
+}
+
+impl<'de, T: RequestPath> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
+    type Error = de::value::Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        self.current = self.params.next().map(|ref item| (item.0, item.1));
+        match self.current {
+            Some((key, _)) => Ok(Some(seed.deserialize(Key { key })?)),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        if let Some((_, value)) = self.current.take() {
+            seed.deserialize(Value { value })
+        } else {
+            Err(de::value::Error::custom("unexpected item"))
+        }
+    }
+}
+
+struct Key<'de> {
+    key: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Key<'de> {
+    type Error = de::value::Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_str(self.key)
+    }
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("Unexpected"))
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+            byte_buf option unit unit_struct newtype_struct seq tuple
+            tuple_struct map struct enum ignored_any
+    }
+}
+
+macro_rules! parse_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            let v = self.value.parse().map_err(
+                |_| de::value::Error::custom(
+                    format!("can not parse {:?} to a {}", self.value, $tp)))?;
+            visitor.$visit_fn(v)
+        }
+    }
+}
+
+struct Value<'de> {
+    value: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Value<'de> {
+    type Error = de::value::Error;
+
+    parse_value!(deserialize_bool, visit_bool, "bool");
+    parse_value!(deserialize_i8, visit_i8, "i8");
+    parse_value!(deserialize_i16, visit_i16, "i16");
+    parse_value!(deserialize_i32, visit_i32, "i16");
+    parse_value!(deserialize_i64, visit_i64, "i64");
+    parse_value!(deserialize_u8, visit_u8, "u8");
+    parse_value!(deserialize_u16, visit_u16, "u16");
+    parse_value!(deserialize_u32, visit_u32, "u32");
+    parse_value!(deserialize_u64, visit_u64, "u64");
+    parse_value!(deserialize_f32, visit_f32, "f32");
+    parse_value!(deserialize_f64, visit_f64, "f64");
+    parse_value!(deserialize_string, visit_string, "String");
+    parse_value!(deserialize_byte_buf, visit_string, "String");
+    parse_value!(deserialize_char, visit_char, "char");
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value.as_bytes())
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(ValueEnum { value: self.value })
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple"))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: struct"))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        _: usize,
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple struct"))
+    }
+
+    unsupported_type!(deserialize_any, "any");
+    unsupported_type!(deserialize_seq, "seq");
+    unsupported_type!(deserialize_map, "map");
+    unsupported_type!(deserialize_identifier, "identifier");
+}
+
+struct ParamsSeq<'de, T: RequestPath> {
+    params: PathIter<'de, T>,
+}
+
+impl<'de, T: RequestPath> de::SeqAccess<'de> for ParamsSeq<'de, T> {
+    type Error = de::value::Error;
+
+    fn next_element_seed<U>(&mut self, seed: U) -> Result<Option<U::Value>, Self::Error>
+    where
+        U: de::DeserializeSeed<'de>,
+    {
+        match self.params.next() {
+            Some(item) => Ok(Some(seed.deserialize(Value { value: item.1 })?)),
+            None => Ok(None),
+        }
+    }
+}
+
+struct ValueEnum<'de> {
+    value: &'de str,
+}
+
+impl<'de> de::EnumAccess<'de> for ValueEnum<'de> {
+    type Error = de::value::Error;
+    type Variant = UnitVariant;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(Key { key: self.value })?, UnitVariant))
+    }
+}
+
+struct UnitVariant;
+
+impl<'de> de::VariantAccess<'de> for UnitVariant {
+    type Error = de::value::Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn struct_variant<V>(
+        self,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde::de;
+    use serde_derive::Deserialize;
+
+    use super::*;
+    use crate::path::Path;
+    use crate::router::Router;
+
+    #[derive(Deserialize)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Id {
+        id: String,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test1(String, u32);
+
+    #[derive(Debug, Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
+    #[derive(Debug, Deserialize, PartialEq)]
+    #[serde(rename_all = "lowercase")]
+    enum TestEnum {
+        Val1,
+        Val2,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test3 {
+        val: TestEnum,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/user1/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: MyStruct = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+
+        let s: (String, String) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/32/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Test1 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let s: Test2 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, 32);
+
+        let s: (String, u8) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res: Vec<String> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
+    #[test]
+    fn test_extract_path_single() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/32/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: i8 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, 32);
+    }
+
+    #[test]
+    fn test_extract_enum() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: TestEnum = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, TestEnum::Val1);
+
+        let mut router = Router::<()>::build();
+        router.path("/{val1}/{val2}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/val2/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: (TestEnum, TestEnum) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, (TestEnum::Val1, TestEnum::Val2));
+    }
+
+    #[test]
+    fn test_extract_enum_value() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Test3 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i.val, TestEnum::Val1);
+
+        let mut path = Path::new("/val3/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Result<Test3, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(i.is_err());
+        assert!(format!("{:?}", i).contains("unknown variant"));
+    }
+
+    #[test]
+    fn test_extract_errors() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Result<Test1, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<Test2, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+
+        let s: Result<(String, String), de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<u32, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+    }
+
+    // #[test]
+    // fn test_extract_path_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     macro_rules! test_single_value {
+    //         ($value:expr, $expected:expr) => {{
+    //             let req = TestRequest::with_uri($value).finish();
+    //             let info = router.recognize(&req, &(), 0);
+    //             let req = req.with_route_info(info);
+    //             assert_eq!(
+    //                 *Path::<String>::from_request(&req, &PathConfig::default()).unwrap(),
+    //                 $expected
+    //             );
+    //         }};
+    //     }
+
+    //     test_single_value!("/%25/", "%");
+    //     test_single_value!("/%40%C2%A3%24%25%5E%26%2B%3D/", "@£$%^&+=");
+    //     test_single_value!("/%2B/", "+");
+    //     test_single_value!("/%252B/", "%2B");
+    //     test_single_value!("/%2F/", "/");
+    //     test_single_value!("/%252F/", "%2F");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffoo/",
+    //         "http://localhost:80/foo"
+    //     );
+    //     test_single_value!("/%2Fvar%2Flog%2Fsyslog/", "/var/log/syslog");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffile%2F%252Fvar%252Flog%252Fsyslog/",
+    //         "http://localhost:80/file/%2Fvar%2Flog%2Fsyslog"
+    //     );
+
+    //     let req = TestRequest::with_uri("/%25/7/?id=test").finish();
+
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+
+    //     let s = Path::<Test2>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.key, "%");
+    //     assert_eq!(s.value, 7);
+
+    //     let s = Path::<(String, String)>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.0, "%");
+    //     assert_eq!(s.1, "7");
+    // }
+
+    // #[test]
+    // fn test_extract_path_no_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     let req = TestRequest::with_uri("/%25/").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+    //     assert_eq!(
+    //         *Path::<String>::from_request(&req, &&PathConfig::default().disable_decoding())
+    //             .unwrap(),
+    //         "%25"
+    //     );
+    // }
+}

router/src/lib.rs

@@ -0,0 +1,44 @@
+//! Resource path matching library.
+mod de;
+mod path;
+mod pattern;
+mod router;
+
+pub use self::de::PathDeserializer;
+pub use self::path::Path;
+pub use self::pattern::Pattern;
+pub use self::router::{ResourceInfo, Router, RouterBuilder};
+
+pub trait RequestPath {
+    fn path(&self) -> &str;
+}
+
+impl RequestPath for String {
+    fn path(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'a> RequestPath for &'a str {
+    fn path(&self) -> &str {
+        self
+    }
+}
+
+impl<T: AsRef<[u8]>> RequestPath for string::String<T> {
+    fn path(&self) -> &str {
+        &*self
+    }
+}
+
+#[cfg(feature = "http")]
+mod http_support {
+    use super::RequestPath;
+    use http::Uri;
+
+    impl RequestPath for Uri {
+        fn path(&self) -> &str {
+            self.path()
+        }
+    }
+}

router/src/path.rs

@@ -0,0 +1,196 @@
+use std::ops::Index;
+use std::rc::Rc;
+
+use crate::RequestPath;
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum PathItem {
+    Static(&'static str),
+    Segment(u16, u16),
+}
+
+/// Resource path match information
+///
+/// If resource path contains variable patterns, `Path` stores them.
+#[derive(Debug)]
+pub struct Path<T> {
+    path: T,
+    pub(crate) skip: u16,
+    pub(crate) segments: Vec<(Rc<String>, PathItem)>,
+}
+
+impl<T: Default> Default for Path<T> {
+    fn default() -> Self {
+        Path {
+            path: T::default(),
+            skip: 0,
+            segments: Vec::new(),
+        }
+    }
+}
+
+impl<T: Clone> Clone for Path<T> {
+    fn clone(&self) -> Self {
+        Path {
+            path: self.path.clone(),
+            skip: self.skip,
+            segments: self.segments.clone(),
+        }
+    }
+}
+
+impl<T: RequestPath> Path<T> {
+    pub fn new(path: T) -> Path<T> {
+        Path {
+            path,
+            skip: 0,
+            segments: Vec::new(),
+        }
+    }
+
+    /// Get reference to inner path instance
+    pub fn get_ref(&self) -> &T {
+        &self.path
+    }
+
+    /// Get mutable reference to inner path instance
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.path
+    }
+
+    /// Path
+    pub fn path(&self) -> &str {
+        let skip = self.skip as usize;
+        let path = self.path.path();
+        if skip <= path.len() {
+            &path[skip..]
+        } else {
+            ""
+        }
+    }
+
+    /// Reset inner path
+    pub fn set(&mut self, path: T) {
+        self.skip = 0;
+        self.path = path;
+        self.segments.clear();
+    }
+
+    /// Skip first `n` chars in path
+    pub fn skip(&mut self, n: u16) {
+        self.skip = self.skip + n;
+    }
+
+    pub(crate) fn add(&mut self, name: Rc<String>, value: PathItem) {
+        match value {
+            PathItem::Static(s) => self.segments.push((name, PathItem::Static(s))),
+            PathItem::Segment(begin, end) => self
+                .segments
+                .push((name, PathItem::Segment(self.skip + begin, self.skip + end))),
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn add_static(&mut self, name: &str, value: &'static str) {
+        self.segments
+            .push((Rc::new(name.to_string()), PathItem::Static(value)));
+    }
+
+    /// Check if there are any matched patterns
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty()
+    }
+
+    /// Check number of extracted parameters
+    pub fn len(&self) -> usize {
+        self.segments.len()
+    }
+
+    /// Get matched parameter by name without type conversion
+    pub fn get(&self, key: &str) -> Option<&str> {
+        for item in self.segments.iter() {
+            if key == item.0.as_str() {
+                return match item.1 {
+                    PathItem::Static(ref s) => Some(&s),
+                    PathItem::Segment(s, e) => {
+                        Some(&self.path.path()[(s as usize)..(e as usize)])
+                    }
+                };
+            }
+        }
+        if key == "tail" {
+            Some(&self.path.path()[(self.skip as usize)..])
+        } else {
+            None
+        }
+    }
+
+    /// Get unprocessed part of the path
+    pub fn unprocessed(&self) -> &str {
+        &self.path.path()[(self.skip as usize)..]
+    }
+
+    /// Get matched parameter by name.
+    ///
+    /// If keyed parameter is not available empty string is used as default
+    /// value.
+    pub fn query(&self, key: &str) -> &str {
+        if let Some(s) = self.get(key) {
+            s
+        } else {
+            ""
+        }
+    }
+
+    /// Return iterator to items in parameter container
+    pub fn iter(&self) -> PathIter<T> {
+        PathIter {
+            idx: 0,
+            params: self,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PathIter<'a, T> {
+    idx: usize,
+    params: &'a Path<T>,
+}
+
+impl<'a, T: RequestPath> Iterator for PathIter<'a, T> {
+    type Item = (&'a str, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(&'a str, &'a str)> {
+        if self.idx < self.params.len() {
+            let idx = self.idx;
+            let res = match self.params.segments[idx].1 {
+                PathItem::Static(ref s) => &s,
+                PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
+            };
+            self.idx += 1;
+            return Some((&self.params.segments[idx].0, res));
+        }
+        None
+    }
+}
+
+impl<'a, T: RequestPath> Index<&'a str> for Path<T> {
+    type Output = str;
+
+    fn index(&self, name: &'a str) -> &str {
+        self.get(name)
+            .expect("Value for parameter is not available")
+    }
+}
+
+impl<T: RequestPath> Index<usize> for Path<T> {
+    type Output = str;
+
+    fn index(&self, idx: usize) -> &str {
+        match self.segments[idx].1 {
+            PathItem::Static(ref s) => &s,
+            PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
+        }
+    }
+}

router/src/pattern.rs

@@ -0,0 +1,373 @@
+use std::cmp::min;
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
+
+use regex::{escape, Regex};
+
+use crate::path::{Path, PathItem};
+use crate::RequestPath;
+
+const MAX_DYNAMIC_SEGMENTS: usize = 16;
+
+/// Resource type describes an entry in resources table
+///
+/// Resource pattern can contain only 16 dynamic segments
+#[derive(Clone, Debug)]
+pub struct Pattern {
+    tp: PatternType,
+    pattern: String,
+    elements: Vec<PatternElement>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum PatternElement {
+    Str(String),
+    Var(String),
+}
+
+#[derive(Clone, Debug)]
+enum PatternType {
+    Static(String),
+    Prefix(String),
+    Dynamic(Regex, Vec<Rc<String>>, usize),
+}
+
+impl Pattern {
+    /// Parse path pattern and create new `Pattern` instance.
+    ///
+    /// Panics if path pattern is wrong.
+    pub fn new(path: &str) -> Self {
+        Pattern::with_prefix(path, false)
+    }
+
+    /// Parse path pattern and create new `Pattern` instance.
+    ///
+    /// Use `prefix` type instead of `static`.
+    ///
+    /// Panics if path regex pattern is wrong.
+    pub fn prefix(path: &str) -> Self {
+        Pattern::with_prefix(path, true)
+    }
+
+    /// Parse path pattern and create new `Pattern` instance with custom prefix
+    fn with_prefix(path: &str, for_prefix: bool) -> Self {
+        let path = path.to_owned();
+        let (pattern, elements, is_dynamic, len) = Pattern::parse(&path, for_prefix);
+
+        let tp = if is_dynamic {
+            let re = match Regex::new(&pattern) {
+                Ok(re) => re,
+                Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err),
+            };
+            // actix creates one router per thread
+            let names = re
+                .capture_names()
+                .filter_map(|name| name.map(|name| Rc::new(name.to_owned())))
+                .collect();
+            PatternType::Dynamic(re, names, len)
+        } else if for_prefix {
+            PatternType::Prefix(pattern.clone())
+        } else {
+            PatternType::Static(pattern.clone())
+        };
+
+        Pattern {
+            tp,
+            elements,
+            pattern: path.to_owned(),
+        }
+    }
+
+    /// Path pattern of the resource
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Check if path matchs this pattern?
+    pub fn is_match(&self, path: &str) -> bool {
+        match self.tp {
+            PatternType::Static(ref s) => s == path,
+            PatternType::Dynamic(ref re, _, _) => re.is_match(path),
+            PatternType::Prefix(ref s) => path.starts_with(s),
+        }
+    }
+
+    /// Is the given path and parameters a match against this pattern?
+    pub fn match_path<T: RequestPath>(&self, path: &mut Path<T>) -> bool {
+        match self.tp {
+            PatternType::Static(ref s) => {
+                if s == path.path() {
+                    path.skip(path.len() as u16);
+                    true
+                } else {
+                    false
+                }
+            }
+            PatternType::Dynamic(ref re, ref names, len) => {
+                let mut idx = 0;
+                let mut pos = 0;
+                let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] =
+                    [PathItem::Static(""); MAX_DYNAMIC_SEGMENTS];
+
+                if let Some(captures) = re.captures(path.path()) {
+                    let mut passed = false;
+
+                    for capture in captures.iter() {
+                        if let Some(ref m) = capture {
+                            if !passed {
+                                passed = true;
+                                continue;
+                            }
+
+                            segments[idx] = PathItem::Segment(m.start() as u16, m.end() as u16);
+                            idx += 1;
+                            pos = m.end();
+                        }
+                    }
+                } else {
+                    return false;
+                }
+                for idx in 0..idx {
+                    path.add(names[idx].clone(), segments[idx]);
+                }
+                path.skip((pos + len) as u16);
+                true
+            }
+            PatternType::Prefix(ref s) => {
+                let rpath = path.path();
+                let len = if s == rpath {
+                    s.len()
+                } else if rpath.starts_with(s)
+                    && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                {
+                    if s.ends_with('/') {
+                        s.len() - 1
+                    } else {
+                        s.len()
+                    }
+                } else {
+                    return false;
+                };
+                path.skip(min(rpath.len(), len) as u16);
+                true
+            }
+        }
+    }
+
+    // /// Build resource path.
+    // pub fn resource_path<U, I>(
+    //     &self, path: &mut String, elements: &mut U,
+    // ) -> Result<(), UrlGenerationError>
+    // where
+    //     U: Iterator<Item = I>,
+    //     I: AsRef<str>,
+    // {
+    //     match self.tp {
+    //         PatternType::Prefix(ref p) => path.push_str(p),
+    //         PatternType::Static(ref p) => path.push_str(p),
+    //         PatternType::Dynamic(..) => {
+    //             for el in &self.elements {
+    //                 match *el {
+    //                     PatternElement::Str(ref s) => path.push_str(s),
+    //                     PatternElement::Var(_) => {
+    //                         if let Some(val) = elements.next() {
+    //                             path.push_str(val.as_ref())
+    //                         } else {
+    //                             return Err(UrlGenerationError::NotEnoughElements);
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //         }
+    //     };
+    //     Ok(())
+    // }
+
+    fn parse_param(pattern: &str) -> (PatternElement, String, &str) {
+        const DEFAULT_PATTERN: &str = "[^/]+";
+        let mut params_nesting = 0usize;
+        let close_idx = pattern
+            .find(|c| match c {
+                '{' => {
+                    params_nesting += 1;
+                    false
+                }
+                '}' => {
+                    params_nesting -= 1;
+                    params_nesting == 0
+                }
+                _ => false,
+            })
+            .expect("malformed dynamic segment");
+        let (mut param, rem) = pattern.split_at(close_idx + 1);
+        param = &param[1..param.len() - 1]; // Remove outer brackets
+        let (name, pattern) = match param.find(':') {
+            Some(idx) => {
+                let (name, pattern) = param.split_at(idx);
+                (name, &pattern[1..])
+            }
+            None => (param, DEFAULT_PATTERN),
+        };
+        (
+            PatternElement::Var(name.to_string()),
+            format!(r"(?P<{}>{})", &name, &pattern),
+            rem,
+        )
+    }
+
+    fn parse(
+        mut pattern: &str,
+        for_prefix: bool,
+    ) -> (String, Vec<PatternElement>, bool, usize) {
+        if pattern.find('{').is_none() {
+            return (
+                String::from(pattern),
+                vec![PatternElement::Str(String::from(pattern))],
+                false,
+                pattern.chars().count(),
+            );
+        };
+
+        let mut elems = Vec::new();
+        let mut re = String::from("^");
+        let mut dyn_elems = 0;
+
+        while let Some(idx) = pattern.find('{') {
+            let (prefix, rem) = pattern.split_at(idx);
+            elems.push(PatternElement::Str(String::from(prefix)));
+            re.push_str(&escape(prefix));
+            let (param_pattern, re_part, rem) = Self::parse_param(rem);
+            elems.push(param_pattern);
+            re.push_str(&re_part);
+            pattern = rem;
+            dyn_elems += 1;
+        }
+
+        elems.push(PatternElement::Str(String::from(pattern)));
+        re.push_str(&escape(pattern));
+
+        if dyn_elems > MAX_DYNAMIC_SEGMENTS {
+            panic!(
+                "Only {} dynanic segments are allowed, provided: {}",
+                MAX_DYNAMIC_SEGMENTS, dyn_elems
+            );
+        }
+
+        if !for_prefix {
+            re.push_str("$");
+        }
+
+        (re, elems, true, pattern.chars().count())
+    }
+}
+
+impl PartialEq for Pattern {
+    fn eq(&self, other: &Pattern) -> bool {
+        self.pattern == other.pattern
+    }
+}
+
+impl Eq for Pattern {}
+
+impl Hash for Pattern {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.pattern.hash(state);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_static() {
+        let re = Pattern::new("/");
+        assert!(re.is_match("/"));
+        assert!(!re.is_match("/a"));
+
+        let re = Pattern::new("/name");
+        assert!(re.is_match("/name"));
+        assert!(!re.is_match("/name1"));
+        assert!(!re.is_match("/name/"));
+        assert!(!re.is_match("/name~"));
+
+        let re = Pattern::new("/name/");
+        assert!(re.is_match("/name/"));
+        assert!(!re.is_match("/name"));
+        assert!(!re.is_match("/name/gs"));
+
+        let re = Pattern::new("/user/profile");
+        assert!(re.is_match("/user/profile"));
+        assert!(!re.is_match("/user/profile/profile"));
+    }
+
+    #[test]
+    fn test_parse_param() {
+        let re = Pattern::new("/user/{id}");
+        assert!(re.is_match("/user/profile"));
+        assert!(re.is_match("/user/2345"));
+        assert!(!re.is_match("/user/2345/"));
+        assert!(!re.is_match("/user/2345/sdg"));
+
+        let mut path = Path::new("/user/profile");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "profile");
+
+        let mut path = Path::new("/user/1245125");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "1245125");
+
+        let re = Pattern::new("/v{version}/resource/{id}");
+        assert!(re.is_match("/v1/resource/320120"));
+        assert!(!re.is_match("/v/resource/1"));
+        assert!(!re.is_match("/resource"));
+
+        let mut path = Path::new("/v151/resource/adahg32");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("version").unwrap(), "151");
+        assert_eq!(path.get("id").unwrap(), "adahg32");
+
+        let re = Pattern::new("/{id:[[:digit:]]{6}}");
+        assert!(re.is_match("/012345"));
+        assert!(!re.is_match("/012"));
+        assert!(!re.is_match("/01234567"));
+        assert!(!re.is_match("/XXXXXX"));
+
+        let mut path = Path::new("/012345");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "012345");
+    }
+
+    #[test]
+    fn test_resource_prefix() {
+        let re = Pattern::prefix("/name");
+        assert!(re.is_match("/name"));
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/test/test"));
+        assert!(re.is_match("/name1"));
+        assert!(re.is_match("/name~"));
+
+        let re = Pattern::prefix("/name/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
+    }
+
+    #[test]
+    fn test_reousrce_prefix_dynamic() {
+        let re = Pattern::prefix("/{name}/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
+
+        let mut path = Path::new("/test2/");
+        assert!(re.match_path(&mut path));
+        assert_eq!(&path["name"], "test2");
+        assert_eq!(&path[0], "test2");
+
+        let mut path = Path::new("/test2/subpath1/subpath2/index.html");
+        assert!(re.match_path(&mut path));
+        assert_eq!(&path["name"], "test2");
+        assert_eq!(&path[0], "test2");
+    }
+}

router/src/router.rs

@@ -0,0 +1,405 @@
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use crate::path::Path;
+use crate::pattern::Pattern;
+use crate::RequestPath;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub(crate) enum ResourceId {
+    Default,
+    Normal(u16),
+}
+
+/// Information about current resource
+#[derive(Clone, Debug)]
+pub struct ResourceInfo {
+    rmap: Rc<ResourceMap>,
+    resource: ResourceId,
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct ResourceMap {
+    root: Option<Pattern>,
+    named: HashMap<String, Pattern>,
+    patterns: Vec<Pattern>,
+}
+
+/// Resource router.
+pub struct Router<T> {
+    rmap: Rc<ResourceMap>,
+    named: HashMap<String, Pattern>,
+    resources: Vec<T>,
+}
+
+impl<T> Router<T> {
+    pub fn build() -> RouterBuilder<T> {
+        RouterBuilder {
+            rmap: ResourceMap::default(),
+            named: HashMap::new(),
+            resources: Vec::new(),
+        }
+    }
+
+    pub fn recognize<U: RequestPath>(&self, path: &mut Path<U>) -> Option<(&T, ResourceInfo)> {
+        if !path.path().is_empty() {
+            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+                if resource.match_path(path) {
+                    let info = ResourceInfo {
+                        rmap: self.rmap.clone(),
+                        resource: ResourceId::Normal(idx as u16),
+                    };
+                    return Some((&self.resources[idx], info));
+                }
+            }
+        }
+        None
+    }
+
+    pub fn recognize_mut<U: RequestPath>(
+        &mut self,
+        path: &mut Path<U>,
+    ) -> Option<(&mut T, ResourceInfo)> {
+        if !path.path().is_empty() {
+            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+                if resource.match_path(path) {
+                    let info = ResourceInfo {
+                        rmap: self.rmap.clone(),
+                        resource: ResourceId::Normal(idx as u16),
+                    };
+                    return Some((&mut self.resources[idx], info));
+                }
+            }
+        }
+        None
+    }
+}
+
+impl<'a, T> IntoIterator for &'a Router<T> {
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.resources.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut Router<T> {
+    type Item = &'a mut T;
+    type IntoIter = std::slice::IterMut<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.resources.iter_mut()
+    }
+}
+
+impl ResourceMap {
+    fn register(&mut self, pattern: Pattern) {
+        self.patterns.push(pattern);
+    }
+
+    fn register_named(&mut self, name: String, pattern: Pattern) {
+        self.patterns.push(pattern.clone());
+        self.named.insert(name, pattern);
+    }
+
+    fn has_resource(&self, path: &str) -> bool {
+        unimplemented!()
+    }
+}
+
+pub struct RouterBuilder<T> {
+    rmap: ResourceMap,
+    named: HashMap<String, Pattern>,
+    resources: Vec<T>,
+}
+
+impl<T> RouterBuilder<T> {
+    pub fn path(&mut self, path: &str, resource: T) {
+        self.rmap.register(Pattern::new(path));
+        self.resources.push(resource);
+    }
+
+    pub fn prefix(&mut self, prefix: &str, resource: T) {
+        self.rmap.register(Pattern::prefix(prefix));
+        self.resources.push(resource);
+    }
+
+    pub fn finish(self) -> Router<T> {
+        Router {
+            rmap: Rc::new(self.rmap),
+            named: self.named,
+            resources: self.resources,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::path::Path;
+    use crate::router::{ResourceId, Router};
+
+    #[test]
+    fn test_recognizer_1() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        router.path("/name/{val}/index.html", 12);
+        router.path("/file/{file}.{ext}", 13);
+        router.path("/v{val}/{val2}/index.html", 14);
+        router.path("/v/{tail:.*}", 15);
+        router.path("/test2/{test}.html", 16);
+        router.path("/{test}/index.html", 17);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/unknown");
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/name");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+        assert_eq!(info.resource, ResourceId::Normal(0));
+        assert!(path.is_empty());
+
+        let mut path = Path::new("/name/value");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(info.resource, ResourceId::Normal(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        let mut path = Path::new("/name/value2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 12);
+        assert_eq!(info.resource, ResourceId::Normal(2));
+        assert_eq!(path.get("val").unwrap(), "value2");
+
+        let mut path = Path::new("/file/file.gz");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 13);
+        assert_eq!(info.resource, ResourceId::Normal(3));
+        assert_eq!(path.get("file").unwrap(), "file");
+        assert_eq!(path.get("ext").unwrap(), "gz");
+
+        let mut path = Path::new("/vtest/ttt/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 14);
+        assert_eq!(info.resource, ResourceId::Normal(4));
+        assert_eq!(path.get("val").unwrap(), "test");
+        assert_eq!(path.get("val2").unwrap(), "ttt");
+
+        let mut path = Path::new("/v/blah-blah/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 15);
+        assert_eq!(info.resource, ResourceId::Normal(5));
+        assert_eq!(path.get("tail").unwrap(), "blah-blah/index.html");
+
+        let mut path = Path::new("/test2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 16);
+        assert_eq!(info.resource, ResourceId::Normal(6));
+        assert_eq!(path.get("test").unwrap(), "index");
+
+        let mut path = Path::new("/bbb/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 17);
+        assert_eq!(info.resource, ResourceId::Normal(7));
+        assert_eq!(path.get("test").unwrap(), "bbb");
+    }
+
+    #[test]
+    fn test_recognizer_2() {
+        let mut router = Router::<usize>::build();
+        router.path("/index.json", 10);
+        router.path("/{source}.json", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/index.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+    }
+
+    #[test]
+    fn test_recognizer_with_prefix() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(5);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test/name");
+        path.skip(5);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test/name/value");
+        path.skip(5);
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(info.resource, ResourceId::Normal(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        // same patterns
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test2/name-test");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name/ttt");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(&path["val"], "ttt");
+    }
+
+    // #[test]
+    // fn test_request_resource() {
+    //     let mut router = Router::<()>::default();
+    //     let mut resource = Resource::new(ResourcePattern::new("/index.json"));
+    //     resource.name("r1");
+    //     router.register_resource(resource);
+    //     let mut resource = Resource::new(ResourcePattern::new("/test.json"));
+    //     resource.name("r2");
+    //     router.register_resource(resource);
+
+    //     let req = TestRequest::with_uri("/index.json").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(0));
+
+    //     assert_eq!(info.name(), "r1");
+
+    //     let req = TestRequest::with_uri("/test.json").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(1));
+    //     assert_eq!(info.name(), "r2");
+    // }
+
+    // #[test]
+    // fn test_has_resource() {
+    //     let mut router = Router::<()>::default();
+    //     let scope = Scope::new("/test").resource("/name", |_| "done");
+    //     router.register_scope(scope);
+
+    //     {
+    //         let info = router.default_route_info();
+    //         assert!(!info.has_resource("/test"));
+    //         assert!(info.has_resource("/test/name"));
+    //     }
+
+    //     let scope = Scope::new("/test2").nested("/test10", |s| s.resource("/name", |_| "done"));
+    //     router.register_scope(scope);
+
+    //     let info = router.default_route_info();
+    //     assert!(info.has_resource("/test2/test10/name"));
+    // }
+
+    // #[test]
+    // fn test_url_for() {
+    //     let mut router = Router::<()>::new(ResourcePattern::prefix(""));
+
+    //     let mut resource = Resource::new(ResourcePattern::new("/tttt"));
+    //     resource.name("r0");
+    //     router.register_resource(resource);
+
+    //     let scope = Scope::new("/test").resource("/name", |r| {
+    //         r.name("r1");
+    //     });
+    //     router.register_scope(scope);
+
+    //     let scope =
+    //         Scope::new("/test2").nested("/test10", |s| s.resource("/name", |r| r.name("r2")));
+    //     router.register_scope(scope);
+    //     router.finish();
+
+    //     let req = TestRequest::with_uri("/test").request();
+    //     {
+    //         let info = router.default_route_info();
+
+    //         let res = info
+    //             .url_for(&req, "r0", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/tttt");
+
+    //         let res = info
+    //             .url_for(&req, "r1", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/test/name");
+
+    //         let res = info
+    //             .url_for(&req, "r2", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/test2/test10/name");
+    //     }
+
+    //     let req = TestRequest::with_uri("/test/name").request();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(1));
+
+    //     let res = info
+    //         .url_for(&req, "r0", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/tttt");
+
+    //     let res = info
+    //         .url_for(&req, "r1", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/test/name");
+
+    //     let res = info
+    //         .url_for(&req, "r2", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/test2/test10/name");
+    // }
+
+    // #[test]
+    // fn test_url_for_dynamic() {
+    //     let mut router = Router::<()>::new(ResourcePattern::prefix(""));
+
+    //     let mut resource = Resource::new(ResourcePattern::new("/{name}/test/index.{ext}"));
+    //     resource.name("r0");
+    //     router.register_resource(resource);
+
+    //     let scope = Scope::new("/{name1}").nested("/{name2}", |s| {
+    //         s.resource("/{name3}/test/index.{ext}", |r| r.name("r2"))
+    //     });
+    //     router.register_scope(scope);
+    //     router.finish();
+
+    //     let req = TestRequest::with_uri("/test").request();
+    //     {
+    //         let info = router.default_route_info();
+
+    //         let res = info.url_for(&req, "r0", vec!["sec1", "html"]).unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/sec1/test/index.html");
+
+    //         let res = info
+    //             .url_for(&req, "r2", vec!["sec1", "sec2", "sec3", "html"])
+    //             .unwrap();
+    //         assert_eq!(
+    //             res.as_str(),
+    //             "http://localhost:8080/sec1/sec2/sec3/test/index.html"
+    //         );
+    //     }
+    // }
+}

rustfmt.toml

@@ -1,5 +1,5 @@
 max_width = 96
 reorder_imports = true
-wrap_comments = true
+#wrap_comments = true
-fn_args_density = "Compressed"
+#fn_args_density = "Compressed"
 #use_small_heuristics = false

src/cloneable.rs

@@ -1,40 +0,0 @@
-use futures::Poll;
-
-use super::cell::Cell;
-use super::service::Service;
-
-/// Service that allows to turn non-clone service to a service with `Clone` impl
-pub struct CloneableService<S: Service + 'static> {
-    service: Cell<S>,
-}
-
-impl<S: Service + 'static> CloneableService<S> {
-    pub fn new(service: S) -> Self {
-        Self {
-            service: Cell::new(service),
-        }
-    }
-}
-
-impl<S: Service + 'static> Clone for CloneableService<S> {
-    fn clone(&self) -> Self {
-        Self {
-            service: self.service.clone(),
-        }
-    }
-}
-
-impl<S: Service + 'static> Service for CloneableService<S> {
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.borrow_mut().poll_ready()
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        self.service.borrow_mut().call(req)
-    }
-}

src/codec/framed2.rs

@@ -1,312 +0,0 @@
-#![allow(deprecated)]
-
-use std::fmt;
-use std::io::{self, Read, Write};
-
-use bytes::BytesMut;
-use futures::{Poll, Sink, StartSend, Stream};
-use tokio_codec::{Decoder, Encoder};
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use super::framed_read::{framed_read2, framed_read2_with_buffer, FramedRead2};
-use super::framed_write::{framed_write2, framed_write2_with_buffer, FramedWrite2};
-
-/// A unified `Stream` and `Sink` interface to an underlying I/O object, using
-/// the `Encoder` and `Decoder` traits to encode and decode frames.
-///
-/// You can create a `Framed` instance by using the `AsyncRead::framed` adapter.
-pub struct Framed2<T, D, E> {
-    inner: FramedRead2<FramedWrite2<Fuse2<T, D, E>>>,
-}
-
-pub struct Fuse2<T, D, E>(pub T, pub D, pub E);
-
-impl<T, D, E> Framed2<T, D, E>
-where
-    T: AsyncRead + AsyncWrite,
-    D: Decoder,
-    E: Encoder,
-{
-    /// Provides a `Stream` and `Sink` interface for reading and writing to this
-    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
-    ///
-    /// Raw I/O objects work with byte sequences, but higher-level code usually
-    /// wants to batch these into meaningful chunks, called "frames". This
-    /// method layers framing on top of an I/O object, by using the `Codec`
-    /// traits to handle encoding and decoding of messages frames. Note that
-    /// the incoming and outgoing frame types may be distinct.
-    ///
-    /// This function returns a *single* object that is both `Stream` and
-    /// `Sink`; grouping this into a single object is often useful for layering
-    /// things like gzip or TLS, which require both read and write access to the
-    /// underlying object.
-    ///
-    /// If you want to work more directly with the streams and sink, consider
-    /// calling `split` on the `Framed` returned by this method, which will
-    /// break them into separate objects, allowing them to interact more easily.
-    pub fn new(inner: T, decoder: D, encoder: E) -> Framed2<T, D, E> {
-        Framed2 {
-            inner: framed_read2(framed_write2(Fuse2(inner, decoder, encoder))),
-        }
-    }
-}
-
-impl<T, D, E> Framed2<T, D, E> {
-    /// Provides a `Stream` and `Sink` interface for reading and writing to this
-    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
-    ///
-    /// Raw I/O objects work with byte sequences, but higher-level code usually
-    /// wants to batch these into meaningful chunks, called "frames". This
-    /// method layers framing on top of an I/O object, by using the `Codec`
-    /// traits to handle encoding and decoding of messages frames. Note that
-    /// the incoming and outgoing frame types may be distinct.
-    ///
-    /// This function returns a *single* object that is both `Stream` and
-    /// `Sink`; grouping this into a single object is often useful for layering
-    /// things like gzip or TLS, which require both read and write access to the
-    /// underlying object.
-    ///
-    /// This objects takes a stream and a readbuffer and a writebuffer. These
-    /// field can be obtained from an existing `Framed` with the
-    /// `into_parts` method.
-    ///
-    /// If you want to work more directly with the streams and sink, consider
-    /// calling `split` on the `Framed` returned by this method, which will
-    /// break them into separate objects, allowing them to interact more easily.
-    pub fn from_parts(parts: FramedParts2<T, D, E>) -> Framed2<T, D, E> {
-        Framed2 {
-            inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(
-                    Fuse2(parts.io, parts.decoder, parts.encoder),
-                    parts.write_buf,
-                ),
-                parts.read_buf,
-            ),
-        }
-    }
-
-    /// Returns a reference to the underlying I/O stream wrapped by
-    /// `Frame`.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn get_ref(&self) -> &T {
-        &self.inner.get_ref().get_ref().0
-    }
-
-    /// Returns a mutable reference to the underlying I/O stream wrapped by
-    /// `Frame`.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner.get_mut().get_mut().0
-    }
-
-    /// Returns a reference to the underlying decoder.
-    pub fn decocer(&self) -> &D {
-        &self.inner.get_ref().get_ref().1
-    }
-
-    /// Returns a mutable reference to the underlying decoder.
-    pub fn decoder_mut(&mut self) -> &mut D {
-        &mut self.inner.get_mut().get_mut().1
-    }
-
-    /// Returns a reference to the underlying encoder.
-    pub fn encoder(&self) -> &E {
-        &self.inner.get_ref().get_ref().2
-    }
-
-    /// Returns a mutable reference to the underlying codec.
-    pub fn encoder_mut(&mut self) -> &mut E {
-        &mut self.inner.get_mut().get_mut().2
-    }
-
-    /// Consumes the `Frame`, returning its underlying I/O stream.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn into_inner(self) -> T {
-        self.inner.into_inner().into_inner().0
-    }
-
-    /// Consume the `Frame`, returning `Frame` with different codec.
-    pub fn switch_encoder<E2>(self, encoder: E2) -> Framed2<T, D, E2> {
-        let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
-
-        Framed2 {
-            inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse2(inner.0, inner.1, encoder), write_buf),
-                read_buf,
-            ),
-        }
-    }
-
-    /// Consumes the `Frame`, returning its underlying I/O stream, the buffer
-    /// with unprocessed data, and the codec.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn into_parts(self) -> FramedParts2<T, D, E> {
-        let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
-
-        FramedParts2 {
-            io: inner.0,
-            decoder: inner.1,
-            encoder: inner.2,
-            read_buf: read_buf,
-            write_buf: write_buf,
-            _priv: (),
-        }
-    }
-}
-
-impl<T, D, E> Stream for Framed2<T, D, E>
-where
-    T: AsyncRead,
-    D: Decoder,
-{
-    type Item = D::Item;
-    type Error = D::Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        self.inner.poll()
-    }
-}
-
-impl<T, D, E> Sink for Framed2<T, D, E>
-where
-    T: AsyncWrite,
-    E: Encoder,
-    E::Error: From<io::Error>,
-{
-    type SinkItem = E::Item;
-    type SinkError = E::Error;
-
-    fn start_send(
-        &mut self, item: Self::SinkItem,
-    ) -> StartSend<Self::SinkItem, Self::SinkError> {
-        self.inner.get_mut().start_send(item)
-    }
-
-    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.get_mut().poll_complete()
-    }
-
-    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.get_mut().close()
-    }
-}
-
-impl<T, D, E> fmt::Debug for Framed2<T, D, E>
-where
-    T: fmt::Debug,
-    D: fmt::Debug,
-    E: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Framed2")
-            .field("io", &self.inner.get_ref().get_ref().0)
-            .field("decoder", &self.inner.get_ref().get_ref().1)
-            .field("encoder", &self.inner.get_ref().get_ref().2)
-            .finish()
-    }
-}
-
-// ===== impl Fuse2 =====
-
-impl<T: Read, D, E> Read for Fuse2<T, D, E> {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        self.0.read(dst)
-    }
-}
-
-impl<T: AsyncRead, D, E> AsyncRead for Fuse2<T, D, E> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.0.prepare_uninitialized_buffer(buf)
-    }
-}
-
-impl<T: Write, D, E> Write for Fuse2<T, D, E> {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        self.0.write(src)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.0.flush()
-    }
-}
-
-impl<T: AsyncWrite, D, E> AsyncWrite for Fuse2<T, D, E> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.0.shutdown()
-    }
-}
-
-impl<T, D: Decoder, E> Decoder for Fuse2<T, D, E> {
-    type Item = D::Item;
-    type Error = D::Error;
-
-    fn decode(&mut self, buffer: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        self.1.decode(buffer)
-    }
-
-    fn decode_eof(&mut self, buffer: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        self.1.decode_eof(buffer)
-    }
-}
-
-impl<T, D, E: Encoder> Encoder for Fuse2<T, D, E> {
-    type Item = E::Item;
-    type Error = E::Error;
-
-    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        self.2.encode(item, dst)
-    }
-}
-
-/// `FramedParts` contains an export of the data of a Framed transport.
-/// It can be used to construct a new `Framed` with a different codec.
-/// It contains all current buffers and the inner transport.
-#[derive(Debug)]
-pub struct FramedParts2<T, D, E> {
-    /// The inner transport used to read bytes to and write bytes to
-    pub io: T,
-
-    /// The decoder
-    pub decoder: D,
-
-    /// The encoder
-    pub encoder: E,
-
-    /// The buffer with read but unprocessed data.
-    pub read_buf: BytesMut,
-
-    /// A buffer with unprocessed data which are not written yet.
-    pub write_buf: BytesMut,
-
-    /// This private field allows us to add additional fields in the future in a
-    /// backwards compatible way.
-    _priv: (),
-}
-
-impl<T, D, E> FramedParts2<T, D, E> {
-    /// Create a new, default, `FramedParts`
-    pub fn new(io: T, decoder: D, encoder: E) -> FramedParts2<T, D, E> {
-        FramedParts2 {
-            io,
-            decoder,
-            encoder,
-            read_buf: BytesMut::new(),
-            write_buf: BytesMut::new(),
-            _priv: (),
-        }
-    }
-}

src/connector.rs

@@ -1,259 +0,0 @@
-use std::collections::VecDeque;
-use std::io;
-use std::net::SocketAddr;
-
-use futures::{
-    future::{ok, FutureResult},
-    Async, Future, Poll,
-};
-use tokio_tcp::{ConnectFuture, TcpStream};
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-use trust_dns_resolver::system_conf::read_system_conf;
-
-use super::resolver::{HostAware, Resolver, ResolverError, ResolverFuture};
-use super::service::{NewService, Service};
-
-// #[derive(Fail, Debug)]
-#[derive(Debug)]
-pub enum ConnectorError {
-    /// Failed to resolve the hostname
-    // #[fail(display = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolverError),
-
-    /// Not dns records
-    // #[fail(display = "Invalid input: {}", _0)]
-    NoRecords,
-
-    /// Connection io error
-    // #[fail(display = "{}", _0)]
-    IoError(io::Error),
-}
-
-impl From<ResolverError> for ConnectorError {
-    fn from(err: ResolverError) -> Self {
-        ConnectorError::Resolver(err)
-    }
-}
-
-pub struct ConnectionInfo {
-    pub host: String,
-    pub addr: SocketAddr,
-}
-
-pub struct Connector<T = String> {
-    resolver: Resolver<T>,
-}
-
-impl<T: HostAware> Default for Connector<T> {
-    fn default() -> Self {
-        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
-            (cfg, opts)
-        } else {
-            (ResolverConfig::default(), ResolverOpts::default())
-        };
-
-        Connector::new(cfg, opts)
-    }
-}
-
-impl<T: HostAware> Connector<T> {
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        Connector {
-            resolver: Resolver::new(cfg, opts),
-        }
-    }
-
-    pub fn with_resolver(
-        resolver: Resolver<T>,
-    ) -> impl Service<
-        Request = T,
-        Response = (T, ConnectionInfo, TcpStream),
-        Error = ConnectorError,
-    > + Clone {
-        Connector { resolver }
-    }
-
-    pub fn new_service<E>() -> impl NewService<
-        Request = T,
-        Response = (T, ConnectionInfo, TcpStream),
-        Error = ConnectorError,
-        InitError = E,
-    > + Clone {
-        || -> FutureResult<Connector<T>, E> { ok(Connector::default()) }
-    }
-
-    pub fn new_service_with_config<E>(
-        cfg: ResolverConfig, opts: ResolverOpts,
-    ) -> impl NewService<
-        Request = T,
-        Response = (T, ConnectionInfo, TcpStream),
-        Error = ConnectorError,
-        InitError = E,
-    > + Clone {
-        move || -> FutureResult<Connector<T>, E> { ok(Connector::new(cfg.clone(), opts)) }
-    }
-
-    pub fn change_request<T2: HostAware>(&self) -> Connector<T2> {
-        Connector {
-            resolver: self.resolver.change_request(),
-        }
-    }
-}
-
-impl<T> Clone for Connector<T> {
-    fn clone(&self) -> Self {
-        Connector {
-            resolver: self.resolver.clone(),
-        }
-    }
-}
-
-impl<T: HostAware> Service for Connector<T> {
-    type Request = T;
-    type Response = (T, ConnectionInfo, TcpStream);
-    type Error = ConnectorError;
-    type Future = ConnectorFuture<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        ConnectorFuture {
-            fut: self.resolver.call(req),
-            fut2: None,
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct ConnectorFuture<T: HostAware> {
-    fut: ResolverFuture<T>,
-    fut2: Option<TcpConnector<T>>,
-}
-
-impl<T: HostAware> Future for ConnectorFuture<T> {
-    type Item = (T, ConnectionInfo, TcpStream);
-    type Error = ConnectorError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut2 {
-            return fut.poll();
-        }
-        match self.fut.poll().map_err(ConnectorError::from)? {
-            Async::Ready((req, host, addrs)) => {
-                if addrs.is_empty() {
-                    Err(ConnectorError::NoRecords)
-                } else {
-                    self.fut2 = Some(TcpConnector::new(req, host, addrs));
-                    self.poll()
-                }
-            }
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct DefaultConnector<T: HostAware>(Connector<T>);
-
-impl<T: HostAware> Default for DefaultConnector<T> {
-    fn default() -> Self {
-        DefaultConnector(Connector::default())
-    }
-}
-
-impl<T: HostAware> DefaultConnector<T> {
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        DefaultConnector(Connector::new(cfg, opts))
-    }
-}
-
-impl<T: HostAware> Service for DefaultConnector<T> {
-    type Request = T;
-    type Response = TcpStream;
-    type Error = ConnectorError;
-    type Future = DefaultConnectorFuture<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.0.poll_ready()
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        DefaultConnectorFuture {
-            fut: self.0.call(req),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct DefaultConnectorFuture<T: HostAware> {
-    fut: ConnectorFuture<T>,
-}
-
-impl<T: HostAware> Future for DefaultConnectorFuture<T> {
-    type Item = TcpStream;
-    type Error = ConnectorError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        Ok(Async::Ready(try_ready!(self.fut.poll()).2))
-    }
-}
-
-#[doc(hidden)]
-/// Tcp stream connector
-pub struct TcpConnector<T> {
-    req: Option<T>,
-    host: Option<String>,
-    addr: Option<SocketAddr>,
-    addrs: VecDeque<SocketAddr>,
-    stream: Option<ConnectFuture>,
-}
-
-impl<T> TcpConnector<T> {
-    pub fn new(req: T, host: String, addrs: VecDeque<SocketAddr>) -> TcpConnector<T> {
-        TcpConnector {
-            addrs,
-            req: Some(req),
-            host: Some(host),
-            addr: None,
-            stream: None,
-        }
-    }
-}
-
-impl<T> Future for TcpConnector<T> {
-    type Item = (T, ConnectionInfo, TcpStream);
-    type Error = ConnectorError;
-
-    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)) => {
-                        return Ok(Async::Ready((
-                            self.req.take().unwrap(),
-                            ConnectionInfo {
-                                host: self.host.take().unwrap(),
-                                addr: self.addr.take().unwrap(),
-                            },
-                            sock,
-                        )))
-                    }
-                    Ok(Async::NotReady) => return Ok(Async::NotReady),
-                    Err(err) => {
-                        if self.addrs.is_empty() {
-                            return Err(ConnectorError::IoError(err));
-                        }
-                    }
-                }
-            }
-
-            // try to connect
-            let addr = self.addrs.pop_front().unwrap();
-            self.stream = Some(TcpStream::connect(&addr));
-            self.addr = Some(addr)
-        }
-    }
-}

src/lib.rs

@@ -1,75 +0,0 @@
-//! Actix net - framework for the compisible network services for Rust.
-//!
-//! ## Package feature
-//!
-//! * `tls` - enables ssl support via `native-tls` crate
-//! * `ssl` - enables ssl support via `openssl` crate
-//! * `rust-tls` - enables ssl support via `rustls` crate
-// #![warn(missing_docs)]
-
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        declare_interior_mutable_const,
-        borrow_interior_mutable_const
-    )
-)]
-
-#[macro_use]
-extern crate log;
-extern crate bytes;
-#[macro_use]
-extern crate futures;
-extern crate mio;
-extern crate net2;
-extern crate num_cpus;
-extern crate slab;
-extern crate tokio;
-extern crate tokio_codec;
-extern crate tokio_current_thread;
-extern crate tokio_io;
-extern crate tokio_reactor;
-extern crate tokio_tcp;
-extern crate tokio_timer;
-extern crate tower_service;
-extern crate trust_dns_resolver;
-
-#[allow(unused_imports)]
-#[macro_use]
-extern crate actix;
-
-#[cfg(feature = "tls")]
-extern crate native_tls;
-
-#[cfg(feature = "ssl")]
-extern crate openssl;
-#[cfg(feature = "ssl")]
-extern crate tokio_openssl;
-
-#[cfg(feature = "rust-tls")]
-extern crate rustls;
-#[cfg(feature = "rust-tls")]
-extern crate tokio_rustls;
-#[cfg(feature = "rust-tls")]
-extern crate webpki;
-#[cfg(feature = "rust-tls")]
-extern crate webpki_roots;
-
-mod cell;
-pub mod cloneable;
-pub mod codec;
-pub mod connector;
-pub mod counter;
-pub mod either;
-pub mod framed;
-pub mod inflight;
-pub mod keepalive;
-pub mod resolver;
-pub mod server;
-pub mod service;
-pub mod ssl;
-pub mod stream;
-pub mod timer;
-
-#[derive(Copy, Clone, Debug)]
-pub enum Never {}

src/resolver.rs

@@ -1,170 +0,0 @@
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::net::SocketAddr;
-
-use futures::{Async, Future, Poll};
-
-use tokio_current_thread::spawn;
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-use trust_dns_resolver::error::ResolveError;
-use trust_dns_resolver::lookup_ip::LookupIpFuture;
-use trust_dns_resolver::system_conf::read_system_conf;
-use trust_dns_resolver::{AsyncResolver, Background};
-
-use super::service::Service;
-
-#[derive(Debug)]
-pub enum ResolverError {
-    Resolve(ResolveError),
-    InvalidInput,
-}
-
-pub trait HostAware {
-    fn host(&self) -> &str;
-}
-
-impl HostAware for String {
-    fn host(&self) -> &str {
-        self.as_ref()
-    }
-}
-
-pub struct Resolver<T = String> {
-    resolver: AsyncResolver,
-    req: PhantomData<T>,
-}
-
-impl<T: HostAware> Default for Resolver<T> {
-    fn default() -> Self {
-        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
-            (cfg, opts)
-        } else {
-            (ResolverConfig::default(), ResolverOpts::default())
-        };
-
-        Resolver::new(cfg, opts)
-    }
-}
-
-impl<T: HostAware> Resolver<T> {
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        spawn(bg);
-        Resolver {
-            resolver,
-            req: PhantomData,
-        }
-    }
-
-    pub fn change_request<T2: HostAware>(&self) -> Resolver<T2> {
-        Resolver {
-            resolver: self.resolver.clone(),
-            req: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for Resolver<T> {
-    fn clone(&self) -> Self {
-        Resolver {
-            resolver: self.resolver.clone(),
-            req: PhantomData,
-        }
-    }
-}
-
-impl<T: HostAware> Service for Resolver<T> {
-    type Request = T;
-    type Response = (T, String, VecDeque<SocketAddr>);
-    type Error = ResolverError;
-    type Future = ResolverFuture<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        ResolverFuture::new(req, 0, &self.resolver)
-    }
-}
-
-#[doc(hidden)]
-/// Resolver future
-pub struct ResolverFuture<T> {
-    req: Option<T>,
-    port: u16,
-    lookup: Option<Background<LookupIpFuture>>,
-    addrs: Option<VecDeque<SocketAddr>>,
-    error: Option<ResolverError>,
-    host: Option<String>,
-}
-
-impl<T: HostAware> ResolverFuture<T> {
-    pub fn new(addr: T, port: u16, resolver: &AsyncResolver) -> Self {
-        // we need to do dns resolution
-        match ResolverFuture::<T>::parse(addr.host(), port) {
-            Ok((host, port)) => {
-                let lookup = Some(resolver.lookup_ip(host.as_str()));
-                ResolverFuture {
-                    port,
-                    lookup,
-                    req: Some(addr),
-                    host: Some(host.to_owned()),
-                    addrs: None,
-                    error: None,
-                }
-            }
-            Err(err) => ResolverFuture {
-                port,
-                req: None,
-                host: None,
-                lookup: None,
-                addrs: None,
-                error: Some(err),
-            },
-        }
-    }
-
-    fn parse(addr: &str, port: u16) -> Result<(String, u16), ResolverError> {
-        // split the string by ':' and convert the second part to u16
-        let mut parts_iter = addr.splitn(2, ':');
-        let host = parts_iter.next().ok_or(ResolverError::InvalidInput)?;
-        let port_str = parts_iter.next().unwrap_or("");
-        let port: u16 = port_str.parse().unwrap_or(port);
-
-        Ok((host.to_owned(), port))
-    }
-}
-
-impl<T: HostAware> Future for ResolverFuture<T> {
-    type Item = (T, String, VecDeque<SocketAddr>);
-    type Error = ResolverError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(err) = self.error.take() {
-            Err(err)
-        } else if let Some(addrs) = self.addrs.take() {
-            Ok(Async::Ready((
-                self.req.take().unwrap(),
-                self.host.take().unwrap(),
-                addrs,
-            )))
-        } else {
-            match self.lookup.as_mut().unwrap().poll() {
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Ok(Async::Ready(ips)) => {
-                    let addrs: VecDeque<_> = ips
-                        .iter()
-                        .map(|ip| SocketAddr::new(ip, self.port))
-                        .collect();
-                    Ok(Async::Ready((
-                        self.req.take().unwrap(),
-                        self.host.take().unwrap(),
-                        addrs,
-                    )))
-                }
-                Err(err) => Err(ResolverError::Resolve(err)),
-            }
-        }
-    }
-}

src/server/mod.rs

@@ -1,38 +0,0 @@
-//! General purpose networking server
-
-use actix::Message;
-
-mod accept;
-mod server;
-mod services;
-mod worker;
-
-pub use self::server::Server;
-pub use self::services::{ServerMessage, ServiceFactory, StreamServiceFactory};
-
-/// Pause accepting incoming connections
-///
-/// If socket contains some pending connection, they might be dropped.
-/// All opened connection remains active.
-#[derive(Message)]
-pub struct PauseServer;
-
-/// Resume accepting incoming connections
-#[derive(Message)]
-pub struct ResumeServer;
-
-/// Stop incoming connection processing, stop all workers and exit.
-///
-/// If server starts with `spawn()` method, then spawned thread get terminated.
-pub struct StopServer {
-    /// Whether to try and shut down gracefully
-    pub graceful: bool,
-}
-
-impl Message for StopServer {
-    type Result = Result<(), ()>;
-}
-
-/// Socket id token
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Token(usize);

src/service/mod.rs

@@ -1,244 +0,0 @@
-use futures::{Future, IntoFuture};
-
-/// re-export for convinience
-pub use tower_service::{NewService, Service};
-
-mod and_then;
-mod apply;
-mod fn_service;
-mod from_err;
-mod map;
-mod map_err;
-mod map_init_err;
-mod then;
-
-pub use self::and_then::{AndThen, AndThenNewService};
-pub use self::apply::{Apply, ApplyNewService};
-pub use self::fn_service::{FnNewService, FnService};
-pub use self::from_err::{FromErr, FromErrNewService};
-pub use self::map::{Map, MapNewService};
-pub use self::map_err::{MapErr, MapErrNewService};
-pub use self::map_init_err::MapInitErr;
-pub use self::then::{Then, ThenNewService};
-
-/// 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<S, I, F, R>(
-        self, service: I, f: F,
-    ) -> AndThen<Self, Apply<S, F, R, Self::Response>>
-    where
-        Self: Sized,
-        S: Service,
-        S::Error: Into<<R::Future as Future>::Error>,
-        I: IntoService<S>,
-        F: Fn(Self::Response, &mut S) -> R,
-        R: IntoFuture<Error = Self::Error>,
-    {
-        self.and_then(Apply::new(service.into_service(), f))
-    }
-
-    /// Call another service after call to this one has resolved successfully.
-    ///
-    /// This function can be used to chain two services together and ensure that
-    /// the second service isn't called until call to the fist service have
-    /// finished. Result of the call to the first service is used as an
-    /// input parameter for the second service's call.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
-    where
-        Self: Sized,
-        F: IntoService<B>,
-        B: Service<Request = Self::Response, Error = Self::Error>,
-    {
-        AndThen::new(self, service.into_service())
-    }
-
-    /// Map this service's error to any error implementing `From` for
-    /// this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn from_err<E>(self) -> FromErr<Self, E>
-    where
-        Self: Sized,
-        E: From<Self::Error>,
-    {
-        FromErr::new(self)
-    }
-
-    /// Chain on a computation for when a call to the service finished,
-    /// passing the result of the call to the next service `B`.
-    ///
-    /// Note that this function consumes the receiving future and returns a
-    /// wrapped version of it.
-    fn then<B>(self, service: B) -> Then<Self, B>
-    where
-        Self: Sized,
-        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
-    {
-        Then::new(self, service)
-    }
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    ///
-    /// This function is similar to the `Option::map` or `Iterator::map` where
-    /// it will change the type of the underlying service.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it, similar to the existing `map` methods in the
-    /// standard library.
-    fn map<F, R>(self, f: F) -> Map<Self, F, R>
-    where
-        Self: Sized,
-        F: Fn(Self::Response) -> R,
-    {
-        Map::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    ///
-    /// This function is similar to the `Result::map_err` where it will change
-    /// the error type of the underlying service. This is useful for example to
-    /// ensure that services have the same error type.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E,
-    {
-        MapErr::new(self, f)
-    }
-}
-
-pub trait NewServiceExt: NewService {
-    fn apply<S, I, F, R>(
-        self, service: I, f: F,
-    ) -> AndThenNewService<Self, ApplyNewService<S, F, R, Self::Response>>
-    where
-        Self: Sized,
-        S: NewService<InitError = Self::InitError>,
-        S::Error: Into<<R::Future as Future>::Error>,
-        I: IntoNewService<S>,
-        F: Fn(Self::Response, &mut S::Service) -> R + Clone,
-        R: IntoFuture<Error = Self::Error>,
-    {
-        self.and_then(ApplyNewService::new(service, f))
-    }
-
-    fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
-    where
-        Self: Sized,
-        F: IntoNewService<B>,
-        B: NewService<
-            Request = Self::Response,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
-    {
-        AndThenNewService::new(self, new_service)
-    }
-
-    /// `NewService` that create service to map this service's error
-    /// and new service's init error to any error
-    /// implementing `From` for this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving new service and returns a
-    /// wrapped version of it.
-    fn from_err<E>(self) -> FromErrNewService<Self, E>
-    where
-        Self: Sized,
-        E: From<Self::Error>,
-    {
-        FromErrNewService::new(self)
-    }
-
-    /// Create `NewService` to chain on a computation for when a call to the
-    /// service finished, passing the result of the call to the next
-    /// service `B`.
-    ///
-    /// Note that this function consumes the receiving future and returns a
-    /// wrapped version of it.
-    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
-    where
-        Self: Sized,
-        F: IntoNewService<B>,
-        B: NewService<
-            Request = Result<Self::Response, Self::Error>,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
-    {
-        ThenNewService::new(self, new_service)
-    }
-
-    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
-    where
-        Self: Sized,
-        F: Fn(Self::Response) -> R,
-    {
-        MapNewService::new(self, f)
-    }
-
-    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E,
-    {
-        MapErrNewService::new(self, f)
-    }
-
-    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::InitError) -> E,
-    {
-        MapInitErr::new(self, f)
-    }
-}
-
-impl<T: ?Sized> ServiceExt for T where T: Service {}
-impl<T: ?Sized> NewServiceExt for T where T: NewService {}
-
-/// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
-where
-    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>
-where
-    T: NewService,
-{
-    /// Convert to an `NewService`
-    fn into_new_service(self) -> T;
-}
-
-impl<T> IntoService<T> for T
-where
-    T: Service,
-{
-    fn into_service(self) -> T {
-        self
-    }
-}
-
-impl<T> IntoNewService<T> for T
-where
-    T: NewService,
-{
-    fn into_new_service(self) -> T {
-        self
-    }
-}

src/ssl/openssl.rs

@@ -1,215 +0,0 @@
-use std::marker::PhantomData;
-
-use futures::{future::ok, future::FutureResult, Async, Future, Poll};
-use openssl::ssl::{Error, SslAcceptor, SslConnector};
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_openssl::{AcceptAsync, ConnectAsync, SslAcceptorExt, SslConnectorExt, SslStream};
-
-use super::MAX_CONN_COUNTER;
-use connector::ConnectionInfo;
-use counter::{Counter, CounterGuard};
-use service::{NewService, Service};
-
-/// Support `SSL` connections via openssl package
-///
-/// `ssl` feature enables `OpensslAcceptor` type
-pub struct OpensslAcceptor<T> {
-    acceptor: SslAcceptor,
-    io: PhantomData<T>,
-}
-
-impl<T> OpensslAcceptor<T> {
-    /// Create default `OpensslAcceptor`
-    pub fn new(acceptor: SslAcceptor) -> Self {
-        OpensslAcceptor {
-            acceptor,
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
-    fn clone(&self) -> Self {
-        Self {
-            acceptor: self.acceptor.clone(),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
-    type Request = T;
-    type Response = SslStream<T>;
-    type Error = Error;
-    type Service = OpensslAcceptorService<T>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
-            ok(OpensslAcceptorService {
-                acceptor: self.acceptor.clone(),
-                conns: conns.clone(),
-                io: PhantomData,
-            })
-        })
-    }
-}
-
-pub struct OpensslAcceptorService<T> {
-    acceptor: SslAcceptor,
-    io: PhantomData<T>,
-    conns: Counter,
-}
-
-impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
-    type Request = T;
-    type Response = SslStream<T>;
-    type Error = Error;
-    type Future = OpensslAcceptorServiceFut<T>;
-
-    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 {
-        OpensslAcceptorServiceFut {
-            _guard: self.conns.get(),
-            fut: SslAcceptorExt::accept_async(&self.acceptor, req),
-        }
-    }
-}
-
-pub struct OpensslAcceptorServiceFut<T>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    fut: AcceptAsync<T>,
-    _guard: CounterGuard,
-}
-
-impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
-    type Item = SslStream<T>;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll()
-    }
-}
-
-/// Openssl connector factory
-pub struct OpensslConnector<T, Io, E> {
-    connector: SslConnector,
-    t: PhantomData<T>,
-    io: PhantomData<Io>,
-    _e: PhantomData<E>,
-}
-
-impl<T, Io, E> OpensslConnector<T, Io, E> {
-    pub fn new(connector: SslConnector) -> Self {
-        OpensslConnector {
-            connector,
-            t: PhantomData,
-            io: PhantomData,
-            _e: PhantomData,
-        }
-    }
-}
-
-impl<T, Io: AsyncRead + AsyncWrite> OpensslConnector<T, Io, ()> {
-    pub fn service(
-        connector: SslConnector,
-    ) -> impl Service<
-        Request = (T, ConnectionInfo, Io),
-        Response = (T, ConnectionInfo, SslStream<Io>),
-        Error = Error,
-    > {
-        OpensslConnectorService {
-            connector: connector,
-            t: PhantomData,
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T, Io, E> Clone for OpensslConnector<T, Io, E> {
-    fn clone(&self) -> Self {
-        Self {
-            connector: self.connector.clone(),
-            t: PhantomData,
-            io: PhantomData,
-            _e: PhantomData,
-        }
-    }
-}
-
-impl<T, Io: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<T, Io, E> {
-    type Request = (T, ConnectionInfo, Io);
-    type Response = (T, ConnectionInfo, SslStream<Io>);
-    type Error = Error;
-    type Service = OpensslConnectorService<T, Io>;
-    type InitError = E;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self) -> Self::Future {
-        ok(OpensslConnectorService {
-            connector: self.connector.clone(),
-            t: PhantomData,
-            io: PhantomData,
-        })
-    }
-}
-
-pub struct OpensslConnectorService<T, Io> {
-    connector: SslConnector,
-    t: PhantomData<T>,
-    io: PhantomData<Io>,
-}
-
-impl<T, Io: AsyncRead + AsyncWrite> Service for OpensslConnectorService<T, Io> {
-    type Request = (T, ConnectionInfo, Io);
-    type Response = (T, ConnectionInfo, SslStream<Io>);
-    type Error = Error;
-    type Future = ConnectAsyncExt<T, Io>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, info, stream): Self::Request) -> Self::Future {
-        ConnectAsyncExt {
-            fut: SslConnectorExt::connect_async(&self.connector, &info.host, stream),
-            req: Some(req),
-            host: Some(info),
-        }
-    }
-}
-
-pub struct ConnectAsyncExt<T, Io> {
-    fut: ConnectAsync<Io>,
-    req: Option<T>,
-    host: Option<ConnectionInfo>,
-}
-
-impl<T, Io> Future for ConnectAsyncExt<T, Io>
-where
-    Io: AsyncRead + AsyncWrite,
-{
-    type Item = (T, ConnectionInfo, SslStream<Io>);
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.fut.poll()? {
-            Async::Ready(stream) => Ok(Async::Ready((
-                self.req.take().unwrap(),
-                self.host.take().unwrap(),
-                stream,
-            ))),
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}