pin trsut-dns-proto

* Macro improvements.

* Fix usage in `fn main`.

.github/workflows/main.yml

@@ -0,0 +1,58 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain:
+          - x86_64-pc-windows-msvc
+          - x86_64-pc-windows-gnu
+          - i686-pc-windows-msvc
+          - x86_64-apple-darwin
+        version:
+          - stable
+          - nightly
+        include:
+        - toolchain: x86_64-pc-windows-msvc
+          os: windows-latest
+        - toolchain: x86_64-pc-windows-gnu
+          os: windows-latest
+        - toolchain: i686-pc-windows-msvc
+          os: windows-latest
+        - toolchain: x86_64-apple-darwin
+          os: macOS-latest
+
+    name: ${{ matrix.version }} - ${{ matrix.toolchain }}
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-${{ matrix.toolchain }}
+          default: true
+
+      - name: check nightly
+        if: matrix.version == 'nightly'
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --benches --bins --examples --tests
+
+      - name: check stable
+        if: matrix.version == 'stable'
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all -- --nocapture

.gitignore

@@ -12,3 +12,5 @@ guide/build/
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+.idea

.travis.yml

@@ -10,9 +10,9 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly
+    - rust: nightly-2019-11-07
   allow_failures:
-    - rust: nightly
+    - rust: nightly-2019-11-07
 
 env:
   global:
@@ -24,34 +24,26 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
+before_cache: |
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-07" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
+  fi
+
 # Add clippy
 before_script:
   - export PATH=$PATH:~/.cargo/bin
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-11-07" ]]; 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 ..
+    cargo test --all --all-features -- --nocapture
     fi
+
+after_success:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
-    cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
-    bash <(curl -s https://codecov.io/bash)
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-07" ]]; then
+    taskset -c 0 cargo tarpaulin --all --all-features --out Xml
     echo "Uploaded code coverage"
-    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 ..
-    cd actix-connector && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    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 ..
-    cd actix-utils && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd router && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
+    bash <(curl -s https://codecov.io/bash)
     fi

CHANGES.md

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

Cargo.toml

@@ -1,36 +1,31 @@
-[package]
-name = "actix-net"
-version = "0.3.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix net - framework for the compisible network services for Rust (experimental)"
-readme = "README.md"
-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]
 members = [
   "actix-codec",
-  "actix-connector",
+  "actix-connect",
+  "actix-ioframe",
   "actix-rt",
+  "actix-macros",
   "actix-service",
   "actix-server",
-  "actix-test-server",
+  "actix-testing",
+  "actix-threadpool",
+  "actix-tls",
   "actix-utils",
   "router",
+  "string",
 ]
 
-[dev-dependencies]
-actix-service = "0.2.0"
-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"
-openssl = { version="0.10" }
-tokio-openssl = { version="0.3" }
+[patch.crates-io]
+actix-codec = { path = "actix-codec" }
+actix-connect = { path = "actix-connect" }
+actix-ioframe = { path = "actix-ioframe" }
+actix-rt = { path = "actix-rt" }
+actix-macros = { path = "actix-macros" }
+actix-server = { path = "actix-server" }
+actix-service = { path = "actix-service" }
+actix-testing = { path = "actix-testing" }
+actix-threadpool = { path = "actix-threadpool" }
+actix-tls = { path = "actix-tls" }
+actix-utils = { path = "actix-utils" }
+actix-router = { path = "router" }
+bytestring = { path = "string" }

README.md

@@ -1,20 +1,16 @@
-# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Actix net - framework for composable network services (experimental)
+Actix net - framework for composable network services
 
 ## Documentation & community resources
 
-* [API Documentation (Development)](https://actix.rs/actix-net/actix_net/)
 * [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-net](https://crates.io/crates/actix-net)
-* Minimum supported Rust version: 1.26 or later
+* Minimum supported Rust version: 1.39 or later
 
 ## Example
 
 ```rust
-fn main() {
-    let sys = actix_rt::System::new("test");
-
+fn main() -> io::Result<()> {
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
     builder.set_private_key_file("./examples/key.pem", SslFiletype::PEM).unwrap();
@@ -26,7 +22,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.
-    actix_server::build()
+    Server::build()
         .bind(
             // configure service pipeline
             "basic", "0.0.0.0:8443",
@@ -34,29 +30,26 @@ fn main() {
                 let num = num.clone();
                 let acceptor = acceptor.clone();
 
-                // service for converting incoming TcpStream to a SslStream<TcpStream>
-                (move |stream| {
-                SslAcceptorExt::accept_async(&acceptor, stream)
-                    .map_err(|e| println!("Openssl error: {}", e))
-            })
-            // convert closure to a `NewService`
-            .into_new_service()
-
-            // .and_then() combinator uses other service to convert incoming `Request` to a `Response`
-            // and then uses that response as an input for next service.
-            // in this case, on success we use `logger` service
-            .and_then(logger)
-
-            // Next service counts number of connections
-            .and_then(move |req| {
-                let num = num.fetch_add(1, Ordering::Relaxed);
-                println!("processed {:?} connections", num);
-                future::ok(())
-            })
-        }).unwrap()
-        .start();
-
-    sys.run();
+                // construct transformation pipeline
+                pipeline(
+                    // service for converting incoming TcpStream to a SslStream<TcpStream>
+                    fn_service(move |stream: actix_rt::net::TcpStream| async move {
+                        SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0).await
+                            .map_err(|e| println!("Openssl error: {}", e))
+                    }))
+                // .and_then() combinator chains result of previos service call to argument
+                /// for next service calll. in this case, on success we chain
+                /// ssl stream to the `logger` service.
+                .and_then(fn_service(logger))
+                // Next service counts number of connections
+                .and_then(move |_| {
+                    let num = num.fetch_add(1, Ordering::Relaxed);
+                    println!("got ssl connection {:?}", num);
+                    future::ok(())
+                })
+            },
+        )?
+        .run()
 }
 ```
 

actix-codec/CHANGES.md

@@ -1,5 +1,31 @@
 # Changes
 
+## [0.2.0] - 2019-12-10
+
+* Use specific futures dependencies
+
+## [0.2.0-alpha.4]
+
+* Fix buffer remaining capacity calcualtion
+
+## [0.2.0-alpha.3]
+
+* Use tokio 0.2
+
+* Fix low/high watermark for write/read buffers
+
+## [0.2.0-alpha.2]
+
+* Migrated to `std::future`
+
+## [0.1.2] - 2019-03-27
+
+* Added `Framed::map_io()` method.
+
+## [0.1.1] - 2019-03-06
+
+* Added `FramedParts::with_read_buffer()` method.
+
 ## [0.1.0] - 2018-12-09
 
 * Move codec to separate crate

actix-codec/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-codec"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,17 +9,18 @@ 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 = "../"
+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"
+bitflags = "1.2.1"
+bytes = "0.5.2"
+futures-core = "0.3.1"
+futures-sink = "0.3.1"
+tokio = { version = "0.2.4", default-features=false }
+tokio-util = { version = "0.2.0", default-features=false, features=["codec"] }
 log = "0.4"

actix-codec/LICENSE-APACHE

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

actix-codec/LICENSE-MIT

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

actix-codec/src/bcodec.rs

@@ -1,7 +1,7 @@
+use bytes::{BufMut, Bytes, BytesMut};
 use std::io;
 
-use bytes::{Bytes, BytesMut};
-use tokio_codec::{Decoder, Encoder};
+use super::{Decoder, Encoder};
 
 /// Bytes codec.
 ///
@@ -14,7 +14,8 @@ impl Encoder for BytesCodec {
     type Error = io::Error;
 
     fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.extend_from_slice(&item[..]);
+        dst.reserve(item.len());
+        dst.put(item);
         Ok(())
     }
 }
@@ -27,7 +28,8 @@ impl Decoder for BytesCodec {
         if src.is_empty() {
             Ok(None)
         } else {
-            Ok(Some(src.take()))
+            let len = src.len();
+            Ok(Some(src.split_to(len)))
         }
     }
 }

actix-codec/src/framed.rs

@@ -1,28 +1,34 @@
-#![allow(deprecated)]
-
-use std::fmt;
-use std::io::{self, Read, Write};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{fmt, io};
 
 use bytes::BytesMut;
-use futures::{Poll, Sink, StartSend, Stream};
-use tokio_codec::{Decoder, Encoder};
-use tokio_io::{AsyncRead, AsyncWrite};
+use futures_core::{ready, Stream};
+use futures_sink::Sink;
 
-use super::framed_read::{framed_read2, framed_read2_with_buffer, FramedRead2};
-use super::framed_write::{framed_write2, framed_write2_with_buffer, FramedWrite2};
+use crate::{AsyncRead, AsyncWrite, Decoder, Encoder};
 
 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.
-///
-/// You can create a `Framed` instance by using the `AsyncRead::framed` adapter.
-pub struct Framed<T, U> {
-    inner: FramedRead2<FramedWrite2<Fuse<T, U>>>,
+bitflags::bitflags! {
+    struct Flags: u8 {
+        const EOF = 0b0001;
+        const READABLE = 0b0010;
+    }
 }
 
-pub struct Fuse<T, U>(pub T, pub U);
+/// A unified `Stream` and `Sink` interface to an underlying I/O object, using
+/// the `Encoder` and `Decoder` traits to encode and decode frames.
+pub struct Framed<T, U> {
+    io: T,
+    codec: U,
+    flags: Flags,
+    read_buf: BytesMut,
+    write_buf: BytesMut,
+}
+
+impl<T, U> Unpin for Framed<T, U> {}
 
 impl<T, U> Framed<T, U>
 where
@@ -42,31 +48,15 @@ where
     /// `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, codec: U) -> Framed<T, U> {
+    pub fn new(io: T, codec: U) -> Framed<T, U> {
         Framed {
-            inner: framed_read2(framed_write2(Fuse(inner, codec), LW, HW)),
+            io,
+            codec,
+            flags: Flags::empty(),
+            read_buf: BytesMut::with_capacity(HW),
+            write_buf: BytesMut::with_capacity(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> {
@@ -87,32 +77,24 @@ impl<T, U> Framed<T, U> {
     /// 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: FramedParts<T, U>) -> Framed<T, U> {
         Framed {
-            inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(
-                    Fuse(parts.io, parts.codec),
-                    parts.write_buf,
-                    parts.write_buf_lw,
-                    parts.write_buf_hw,
-                ),
-                parts.read_buf,
-            ),
+            io: parts.io,
+            codec: parts.codec,
+            flags: parts.flags,
+            write_buf: parts.write_buf,
+            read_buf: parts.read_buf,
         }
     }
 
     /// Returns a reference to the underlying codec.
     pub fn get_codec(&self) -> &U {
-        &self.inner.get_ref().get_ref().1
+        &self.codec
     }
 
     /// Returns a mutable reference to the underlying codec.
     pub fn get_codec_mut(&mut self) -> &mut U {
-        &mut self.inner.get_mut().get_mut().1
+        &mut self.codec
     }
 
     /// Returns a reference to the underlying I/O stream wrapped by
@@ -122,7 +104,7 @@ impl<T, U> Framed<T, U> {
     /// 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
+        &self.io
     }
 
     /// Returns a mutable reference to the underlying I/O stream wrapped by
@@ -132,38 +114,41 @@ impl<T, U> Framed<T, U> {
     /// 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
+        &mut self.io
     }
 
     /// Check if write buffer is empty.
     pub fn is_write_buf_empty(&self) -> bool {
-        self.inner.get_ref().is_empty()
+        self.write_buf.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
-    /// 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
+        self.write_buf.len() >= HW
     }
 
     /// 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, lw, hw) = inner.into_parts();
-
         Framed {
-            inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse(inner.0, codec), write_buf, lw, hw),
-                read_buf,
-            ),
+            codec,
+            io: self.io,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+
+    /// Consume the `Frame`, returning `Frame` with different io.
+    pub fn map_io<F, T2>(self, f: F) -> Framed<T2, U>
+    where
+        F: Fn(T) -> T2,
+    {
+        Framed {
+            io: f(self.io),
+            codec: self.codec,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
         }
     }
 
@@ -172,14 +157,12 @@ impl<T, U> Framed<T, U> {
     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,
-            ),
+            io: self.io,
+            codec: f(self.codec),
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
         }
     }
 
@@ -190,56 +173,192 @@ impl<T, U> Framed<T, U> {
     /// of data coming in as it may corrupt the stream of frames otherwise
     /// being worked with.
     pub fn into_parts(self) -> FramedParts<T, U> {
-        let (inner, read_buf) = self.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,
-            write_buf,
-            write_buf_lw,
-            write_buf_hw,
-            _priv: (),
+            io: self.io,
+            codec: self.codec,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
         }
     }
 }
 
+impl<T, U> Framed<T, U> {
+    /// Serialize item and Write to the inner buffer
+    pub fn write(&mut self, item: <U as Encoder>::Item) -> Result<(), <U as Encoder>::Error>
+    where
+        T: AsyncWrite,
+        U: Encoder,
+    {
+        let remaining = self.write_buf.capacity() - self.write_buf.len();
+        if remaining < LW {
+            self.write_buf.reserve(HW - remaining);
+        }
+
+        self.codec.encode(item, &mut self.write_buf)?;
+        Ok(())
+    }
+
+    /// Check if framed is able to write more data.
+    ///
+    /// `Framed` object considers ready if there is free space in write buffer.
+    pub fn is_write_ready(&self) -> bool {
+        self.write_buf.len() < HW
+    }
+
+    /// Try to read underlying I/O stream and decode item.
+    pub fn next_item(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<U::Item, U::Error>>>
+    where
+        T: AsyncRead,
+        U: Decoder,
+    {
+        loop {
+            // Repeatedly call `decode` or `decode_eof` as long as it is
+            // "readable". Readable is defined as not having returned `None`. If
+            // the upstream has returned EOF, and the decoder is no longer
+            // readable, it can be assumed that the decoder will never become
+            // readable again, at which point the stream is terminated.
+
+            if self.flags.contains(Flags::READABLE) {
+                if self.flags.contains(Flags::EOF) {
+                    match self.codec.decode_eof(&mut self.read_buf) {
+                        Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
+                        Ok(None) => return Poll::Ready(None),
+                        Err(e) => return Poll::Ready(Some(Err(e))),
+                    }
+                }
+
+                log::trace!("attempting to decode a frame");
+
+                match self.codec.decode(&mut self.read_buf) {
+                    Ok(Some(frame)) => {
+                        log::trace!("frame decoded from buffer");
+                        return Poll::Ready(Some(Ok(frame)));
+                    }
+                    Err(e) => return Poll::Ready(Some(Err(e))),
+                    _ => (), // Need more data
+                }
+
+                self.flags.remove(Flags::READABLE);
+            }
+
+            debug_assert!(!self.flags.contains(Flags::EOF));
+
+            // Otherwise, try to read more data and try again. Make sure we've got room
+            let remaining = self.read_buf.capacity() - self.read_buf.len();
+            if remaining < LW {
+                self.read_buf.reserve(HW - remaining)
+            }
+            let cnt = match unsafe {
+                Pin::new_unchecked(&mut self.io).poll_read_buf(cx, &mut self.read_buf)
+            } {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
+                Poll::Ready(Ok(cnt)) => cnt,
+            };
+
+            if cnt == 0 {
+                self.flags.insert(Flags::EOF);
+            }
+            self.flags.insert(Flags::READABLE);
+        }
+    }
+
+    /// Flush write buffer to underlying I/O stream.
+    pub fn flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder,
+    {
+        log::trace!("flushing framed transport");
+
+        while !self.write_buf.is_empty() {
+            log::trace!("writing; remaining={}", self.write_buf.len());
+
+            let n = ready!(unsafe {
+                Pin::new_unchecked(&mut self.io).poll_write(cx, &self.write_buf)
+            })?;
+
+            if n == 0 {
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::WriteZero,
+                    "failed to write frame to transport",
+                )
+                .into()));
+            }
+
+            // remove written data
+            let _ = self.write_buf.split_to(n);
+        }
+
+        // Try flushing the underlying IO
+        ready!(unsafe { Pin::new_unchecked(&mut self.io).poll_flush(cx) })?;
+
+        log::trace!("framed transport flushed");
+        Poll::Ready(Ok(()))
+    }
+
+    /// Flush write buffer and shutdown underlying I/O stream.
+    pub fn close(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder,
+    {
+        unsafe {
+            ready!(Pin::new_unchecked(&mut self.io).poll_flush(cx))?;
+            ready!(Pin::new_unchecked(&mut self.io).poll_shutdown(cx))?;
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+
 impl<T, U> Stream for Framed<T, U>
 where
     T: AsyncRead,
     U: Decoder,
 {
-    type Item = U::Item;
-    type Error = U::Error;
+    type Item = Result<U::Item, U::Error>;
 
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        self.inner.poll()
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.next_item(cx)
     }
 }
 
-impl<T, U> Sink for Framed<T, U>
+impl<T, U> Sink<U::Item> for Framed<T, U>
 where
     T: AsyncWrite,
     U: Encoder,
     U::Error: From<io::Error>,
 {
-    type SinkItem = U::Item;
-    type SinkError = U::Error;
+    type Error = U::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.is_write_ready() {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
 
     fn start_send(
-        &mut self,
-        item: Self::SinkItem,
-    ) -> StartSend<Self::SinkItem, Self::SinkError> {
-        self.inner.get_mut().start_send(item)
+        mut self: Pin<&mut Self>,
+        item: <U as Encoder>::Item,
+    ) -> Result<(), Self::Error> {
+        self.write(item)
     }
 
-    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.get_mut().poll_complete()
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        self.flush(cx)
     }
 
-    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.get_mut().close()
+    fn poll_close(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        self.close(cx)
     }
 }
 
@@ -248,66 +367,14 @@ where
     T: fmt::Debug,
     U: fmt::Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Framed")
-            .field("io", &self.inner.get_ref().get_ref().0)
-            .field("codec", &self.inner.get_ref().get_ref().1)
+            .field("io", &self.io)
+            .field("codec", &self.codec)
             .finish()
     }
 }
 
-// ===== impl Fuse =====
-
-impl<T: Read, U> Read for Fuse<T, U> {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        self.0.read(dst)
-    }
-}
-
-impl<T: AsyncRead, U> AsyncRead for Fuse<T, U> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.0.prepare_uninitialized_buffer(buf)
-    }
-}
-
-impl<T: Write, U> Write for Fuse<T, U> {
-    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, U> AsyncWrite for Fuse<T, U> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.0.shutdown()
-    }
-}
-
-impl<T, U: Decoder> Decoder for Fuse<T, U> {
-    type Item = U::Item;
-    type Error = U::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, U: Encoder> Encoder for Fuse<T, U> {
-    type Item = U::Item;
-    type Error = U::Error;
-
-    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        self.1.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.
@@ -325,15 +392,7 @@ 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: (),
+    flags: Flags,
 }
 
 impl<T, U> FramedParts<T, U> {
@@ -342,11 +401,20 @@ impl<T, U> FramedParts<T, U> {
         FramedParts {
             io,
             codec,
+            flags: Flags::empty(),
             read_buf: BytesMut::new(),
             write_buf: BytesMut::new(),
-            write_buf_lw: LW,
-            write_buf_hw: HW,
-            _priv: (),
+        }
+    }
+
+    /// Create a new `FramedParts` with read buffer
+    pub fn with_read_buf(io: T, codec: U, read_buf: BytesMut) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            read_buf,
+            flags: Flags::empty(),
+            write_buf: BytesMut::new(),
         }
     }
 }

actix-codec/src/framed_read.rs

@@ -1,218 +0,0 @@
-use std::fmt;
-
-use bytes::BytesMut;
-use futures::{try_ready, Async, Poll, Sink, StartSend, Stream};
-use log::trace;
-use tokio_codec::Decoder;
-use tokio_io::AsyncRead;
-
-use super::framed::Fuse;
-
-/// A `Stream` of messages decoded from an `AsyncRead`.
-pub struct FramedRead<T, D> {
-    inner: FramedRead2<Fuse<T, D>>,
-}
-
-pub struct FramedRead2<T> {
-    inner: T,
-    eof: bool,
-    is_readable: bool,
-    buffer: BytesMut,
-}
-
-const INITIAL_CAPACITY: usize = 8 * 1024;
-
-// ===== impl FramedRead =====
-
-impl<T, D> FramedRead<T, D>
-where
-    T: AsyncRead,
-    D: Decoder,
-{
-    /// Creates a new `FramedRead` with the given `decoder`.
-    pub fn new(inner: T, decoder: D) -> FramedRead<T, D> {
-        FramedRead {
-            inner: framed_read2(Fuse(inner, decoder)),
-        }
-    }
-}
-
-impl<T, D> FramedRead<T, D> {
-    /// Returns a reference to the underlying I/O stream wrapped by
-    /// `FramedRead`.
-    ///
-    /// 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.inner.0
-    }
-
-    /// Returns a mutable reference to the underlying I/O stream wrapped by
-    /// `FramedRead`.
-    ///
-    /// 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.inner.0
-    }
-
-    /// Consumes the `FramedRead`, 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.inner.0
-    }
-
-    /// Returns a reference to the underlying decoder.
-    pub fn decoder(&self) -> &D {
-        &self.inner.inner.1
-    }
-
-    /// Returns a mutable reference to the underlying decoder.
-    pub fn decoder_mut(&mut self) -> &mut D {
-        &mut self.inner.inner.1
-    }
-}
-
-impl<T, D> Stream for FramedRead<T, D>
-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> Sink for FramedRead<T, D>
-where
-    T: Sink,
-{
-    type SinkItem = T::SinkItem;
-    type SinkError = T::SinkError;
-
-    fn start_send(
-        &mut self,
-        item: Self::SinkItem,
-    ) -> StartSend<Self::SinkItem, Self::SinkError> {
-        self.inner.inner.0.start_send(item)
-    }
-
-    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.inner.0.poll_complete()
-    }
-
-    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.inner.0.close()
-    }
-}
-
-impl<T, D> fmt::Debug for FramedRead<T, D>
-where
-    T: fmt::Debug,
-    D: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("FramedRead")
-            .field("inner", &self.inner.inner.0)
-            .field("decoder", &self.inner.inner.1)
-            .field("eof", &self.inner.eof)
-            .field("is_readable", &self.inner.is_readable)
-            .field("buffer", &self.inner.buffer)
-            .finish()
-    }
-}
-
-// ===== impl FramedRead2 =====
-
-pub fn framed_read2<T>(inner: T) -> FramedRead2<T> {
-    FramedRead2 {
-        inner,
-        eof: false,
-        is_readable: false,
-        buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
-    }
-}
-
-pub fn framed_read2_with_buffer<T>(inner: T, mut buf: BytesMut) -> FramedRead2<T> {
-    if buf.capacity() < INITIAL_CAPACITY {
-        let bytes_to_reserve = INITIAL_CAPACITY - buf.capacity();
-        buf.reserve(bytes_to_reserve);
-    }
-    FramedRead2 {
-        inner,
-        eof: false,
-        is_readable: !buf.is_empty(),
-        buffer: buf,
-    }
-}
-
-impl<T> FramedRead2<T> {
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    pub fn into_parts(self) -> (T, BytesMut) {
-        (self.inner, self.buffer)
-    }
-
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-}
-
-impl<T> Stream for FramedRead2<T>
-where
-    T: AsyncRead + Decoder,
-{
-    type Item = T::Item;
-    type Error = T::Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        loop {
-            // Repeatedly call `decode` or `decode_eof` as long as it is
-            // "readable". Readable is defined as not having returned `None`. If
-            // the upstream has returned EOF, and the decoder is no longer
-            // readable, it can be assumed that the decoder will never become
-            // readable again, at which point the stream is terminated.
-            if self.is_readable {
-                if self.eof {
-                    let frame = self.inner.decode_eof(&mut self.buffer)?;
-                    return Ok(Async::Ready(frame));
-                }
-
-                trace!("attempting to decode a frame");
-
-                if let Some(frame) = self.inner.decode(&mut self.buffer)? {
-                    trace!("frame decoded from buffer");
-                    return Ok(Async::Ready(Some(frame)));
-                }
-
-                self.is_readable = false;
-            }
-
-            assert!(!self.eof);
-
-            // Otherwise, try to read more data and try again. Make sure we've
-            // got room for at least one byte to read to ensure that we don't
-            // get a spurious 0 that looks like EOF
-            self.buffer.reserve(1);
-            if 0 == try_ready!(self.inner.read_buf(&mut self.buffer)) {
-                self.eof = true;
-            }
-
-            self.is_readable = true;
-        }
-    }
-}

actix-codec/src/framed_write.rs

@@ -1,303 +0,0 @@
-use std::fmt;
-use std::io::{self, Read};
-
-use bytes::BytesMut;
-use futures::{try_ready, Async, AsyncSink, Poll, Sink, StartSend, Stream};
-use log::trace;
-use tokio_codec::{Decoder, Encoder};
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use super::framed::Fuse;
-
-/// A `Sink` of frames encoded to an `AsyncWrite`.
-pub struct FramedWrite<T, E> {
-    inner: FramedWrite2<Fuse<T, E>>,
-}
-
-pub struct FramedWrite2<T> {
-    inner: T,
-    buffer: BytesMut,
-    low_watermark: usize,
-    high_watermark: usize,
-}
-
-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, lw: usize, hw: usize) -> FramedWrite<T, E> {
-        FramedWrite {
-            inner: framed_write2(Fuse(inner, encoder), lw, hw),
-        }
-    }
-}
-
-impl<T, E> FramedWrite<T, E> {
-    /// Returns a reference to the underlying I/O stream wrapped by
-    /// `FramedWrite`.
-    ///
-    /// 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.inner.0
-    }
-
-    /// Returns a mutable reference to the underlying I/O stream wrapped by
-    /// `FramedWrite`.
-    ///
-    /// 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.inner.0
-    }
-
-    /// Consumes the `FramedWrite`, 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.inner.0
-    }
-
-    /// Returns a reference to the underlying decoder.
-    pub fn encoder(&self) -> &E {
-        &self.inner.inner.1
-    }
-
-    /// Returns a mutable reference to the underlying decoder.
-    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>
-where
-    T: AsyncWrite,
-    E: Encoder,
-{
-    type SinkItem = E::Item;
-    type SinkError = E::Error;
-
-    fn start_send(&mut self, item: E::Item) -> StartSend<E::Item, E::Error> {
-        self.inner.start_send(item)
-    }
-
-    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
-        self.inner.poll_complete()
-    }
-
-    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        Ok(self.inner.close()?)
-    }
-}
-
-impl<T, D> Stream for FramedWrite<T, D>
-where
-    T: Stream,
-{
-    type Item = T::Item;
-    type Error = T::Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        self.inner.inner.0.poll()
-    }
-}
-
-impl<T, U> fmt::Debug for FramedWrite<T, U>
-where
-    T: fmt::Debug,
-    U: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("FramedWrite")
-            .field("inner", &self.inner.get_ref().0)
-            .field("encoder", &self.inner.get_ref().1)
-            .field("buffer", &self.inner.buffer)
-            .finish()
-    }
-}
-
-// ===== impl FramedWrite2 =====
-
-pub fn framed_write2<T>(
-    inner: T,
-    low_watermark: usize,
-    high_watermark: usize,
-) -> FramedWrite2<T> {
-    FramedWrite2 {
-        inner,
-        low_watermark,
-        high_watermark,
-        buffer: BytesMut::with_capacity(high_watermark),
-    }
-}
-
-pub fn framed_write2_with_buffer<T>(
-    inner: T,
-    mut buffer: BytesMut,
-    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,
-        buffer,
-        low_watermark,
-        high_watermark,
-    }
-}
-
-impl<T> FramedWrite2<T> {
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    pub fn into_parts(self) -> (T, BytesMut, usize, usize) {
-        (
-            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>
-where
-    T: AsyncWrite + Encoder,
-{
-    type SinkItem = T::Item;
-    type SinkError = T::Error;
-
-    fn start_send(&mut self, item: T::Item) -> StartSend<T::Item, T::Error> {
-        // Check the buffer capacity
-        let len = self.buffer.len();
-        if len >= self.high_watermark {
-            return Ok(AsyncSink::NotReady(item));
-        }
-        if len < self.low_watermark {
-            self.buffer.reserve(self.high_watermark - len)
-        }
-
-        self.inner.encode(item, &mut self.buffer)?;
-
-        Ok(AsyncSink::Ready)
-    }
-
-    fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
-        trace!("flushing framed transport");
-
-        while !self.buffer.is_empty() {
-            trace!("writing; remaining={}", self.buffer.len());
-
-            let n = try_ready!(self.inner.poll_write(&self.buffer));
-
-            if n == 0 {
-                return Err(io::Error::new(
-                    io::ErrorKind::WriteZero,
-                    "failed to \
-                     write frame to transport",
-                )
-                .into());
-            }
-
-            // TODO: Add a way to `bytes` to do this w/o returning the drained
-            // data.
-            let _ = self.buffer.split_to(n);
-        }
-
-        // Try flushing the underlying IO
-        try_ready!(self.inner.poll_flush());
-
-        trace!("framed transport flushed");
-        Ok(Async::Ready(()))
-    }
-
-    fn close(&mut self) -> Poll<(), Self::SinkError> {
-        try_ready!(self.poll_complete());
-        Ok(self.inner.shutdown()?)
-    }
-}
-
-impl<T: Decoder> Decoder for FramedWrite2<T> {
-    type Item = T::Item;
-    type Error = T::Error;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<T::Item>, T::Error> {
-        self.inner.decode(src)
-    }
-
-    fn decode_eof(&mut self, src: &mut BytesMut) -> Result<Option<T::Item>, T::Error> {
-        self.inner.decode_eof(src)
-    }
-}
-
-impl<T: Read> Read for FramedWrite2<T> {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        self.inner.read(dst)
-    }
-}
-
-impl<T: AsyncRead> AsyncRead for FramedWrite2<T> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.inner.prepare_uninitialized_buffer(buf)
-    }
-}

actix-codec/src/lib.rs

@@ -6,19 +6,13 @@
 //!
 //! [`AsyncRead`]: #
 //! [`AsyncWrite`]: #
-//! [`Sink`]: #
-//! [`Stream`]: #
-//! [transports]: #
+#![deny(rust_2018_idioms, warnings)]
 
 mod bcodec;
 mod framed;
-mod framed_read;
-mod framed_write;
 
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
-pub use self::framed_read::FramedRead;
-pub use self::framed_write::FramedWrite;
 
-pub use tokio_codec::{Decoder, Encoder};
-pub use tokio_io::{AsyncRead, AsyncWrite};
+pub use tokio::io::{AsyncRead, AsyncWrite};
+pub use tokio_util::codec::{Decoder, Encoder};

actix-connect/CHANGES.md

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

actix-connect/Cargo.toml

@@ -0,0 +1,58 @@
+[package]
+name = "actix-connect"
+version = "1.0.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix connect - tcp connector service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-connect/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[package.metadata.docs.rs]
+features = ["openssl", "rustls", "uri"]
+
+[lib]
+name = "actix_connect"
+path = "src/lib.rs"
+
+[features]
+default = ["uri"]
+
+# openssl
+openssl = ["open-ssl", "tokio-openssl"]
+
+# rustls
+rustls = ["rust-tls", "tokio-rustls", "webpki"]
+
+# support http::Uri as connect address
+uri = ["http"]
+
+[dependencies]
+actix-service = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.3"
+actix-rt = "1.0.0"
+derive_more = "0.99.2"
+either = "1.5.2"
+futures = "0.3.1"
+http = { version = "0.2.0", optional = true }
+log = "0.4"
+trust-dns-proto = "=0.18.0-alpha.2"
+trust-dns-resolver = "=0.18.0-alpha.2"
+
+# openssl
+open-ssl = { version="0.10", package = "openssl", optional = true }
+tokio-openssl = { version = "0.4.0", optional = true }
+
+# rustls
+rust-tls = { version = "0.16.0", package = "rustls", optional = true }
+tokio-rustls = { version = "0.12.0", optional = true }
+webpki = { version = "0.21", optional = true }
+
+[dev-dependencies]
+bytes = "0.5.3"
+actix-testing = { version="1.0.0" }

actix-connect/LICENSE-APACHE

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

actix-connect/LICENSE-MIT

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

actix-connect/src/connect.rs

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

actix-connect/src/connector.rs

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

actix-connect/src/error.rs

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

actix-connect/src/lib.rs

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

actix-connect/src/resolve.rs

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

actix-connect/src/service.rs

@@ -0,0 +1,231 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use actix_rt::net::TcpStream;
+use actix_service::{Service, ServiceFactory};
+use either::Either;
+use futures::future::{ok, Ready};
+use trust_dns_resolver::AsyncResolver;
+
+use crate::connect::{Address, Connect, Connection};
+use crate::connector::{TcpConnector, TcpConnectorFactory};
+use crate::error::ConnectError;
+use crate::resolve::{Resolver, ResolverFactory};
+
+pub struct ConnectServiceFactory<T> {
+    tcp: TcpConnectorFactory<T>,
+    resolver: ResolverFactory<T>,
+}
+
+impl<T> ConnectServiceFactory<T> {
+    /// Construct new ConnectService factory
+    pub fn new() -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::default(),
+        }
+    }
+
+    /// Construct new connect service with custom dns resolver
+    pub fn with_resolver(resolver: AsyncResolver) -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::new(resolver),
+        }
+    }
+
+    /// Construct new service
+    pub fn service(&self) -> ConnectService<T> {
+        ConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+
+    /// Construct new tcp stream service
+    pub fn tcp_service(&self) -> TcpConnectService<T> {
+        TcpConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+}
+
+impl<T> Default for ConnectServiceFactory<T> {
+    fn default() -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory::default(),
+            resolver: ResolverFactory::default(),
+        }
+    }
+}
+
+impl<T> Clone for ConnectServiceFactory<T> {
+    fn clone(&self) -> Self {
+        ConnectServiceFactory {
+            tcp: self.tcp.clone(),
+            resolver: self.resolver.clone(),
+        }
+    }
+}
+
+impl<T: Address> ServiceFactory for ConnectServiceFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = ConnectService<T>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+#[derive(Clone)]
+pub struct ConnectService<T> {
+    tcp: TcpConnector<T>,
+    resolver: Resolver<T>,
+}
+
+impl<T: Address> Service for ConnectService<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = ConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        ConnectServiceResponse {
+            state: ConnectState::Resolve(self.resolver.call(req)),
+            tcp: self.tcp.clone(),
+        }
+    }
+}
+
+enum ConnectState<T: Address> {
+    Resolve(<Resolver<T> as Service>::Future),
+    Connect(<TcpConnector<T> as Service>::Future),
+}
+
+impl<T: Address> ConnectState<T> {
+    fn poll(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Either<Poll<Result<Connection<T, TcpStream>, ConnectError>>, Connect<T>> {
+        match self {
+            ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) {
+                Poll::Pending => Either::Left(Poll::Pending),
+                Poll::Ready(Ok(res)) => Either::Right(res),
+                Poll::Ready(Err(err)) => Either::Left(Poll::Ready(Err(err))),
+            },
+            ConnectState::Connect(ref mut fut) => Either::Left(Pin::new(fut).poll(cx)),
+        }
+    }
+}
+
+pub struct ConnectServiceResponse<T: Address> {
+    state: ConnectState<T>,
+    tcp: TcpConnector<T>,
+}
+
+impl<T: Address> Future for ConnectServiceResponse<T> {
+    type Output = Result<Connection<T, TcpStream>, ConnectError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let res = match self.state.poll(cx) {
+            Either::Right(res) => {
+                self.state = ConnectState::Connect(self.tcp.call(res));
+                self.state.poll(cx)
+            }
+            Either::Left(res) => return res,
+        };
+
+        match res {
+            Either::Left(res) => res,
+            Either::Right(_) => panic!(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct TcpConnectService<T> {
+    tcp: TcpConnector<T>,
+    resolver: Resolver<T>,
+}
+
+impl<T: Address + 'static> Service for TcpConnectService<T> {
+    type Request = Connect<T>;
+    type Response = TcpStream;
+    type Error = ConnectError;
+    type Future = TcpConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        TcpConnectServiceResponse {
+            state: TcpConnectState::Resolve(self.resolver.call(req)),
+            tcp: self.tcp.clone(),
+        }
+    }
+}
+
+enum TcpConnectState<T: Address> {
+    Resolve(<Resolver<T> as Service>::Future),
+    Connect(<TcpConnector<T> as Service>::Future),
+}
+
+impl<T: Address> TcpConnectState<T> {
+    fn poll(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Either<Poll<Result<TcpStream, ConnectError>>, Connect<T>> {
+        match self {
+            TcpConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) {
+                Poll::Pending => (),
+                Poll::Ready(Ok(res)) => return Either::Right(res),
+                Poll::Ready(Err(err)) => return Either::Left(Poll::Ready(Err(err))),
+            },
+            TcpConnectState::Connect(ref mut fut) => {
+                if let Poll::Ready(res) = Pin::new(fut).poll(cx) {
+                    return match res {
+                        Ok(conn) => Either::Left(Poll::Ready(Ok(conn.into_parts().0))),
+                        Err(err) => Either::Left(Poll::Ready(Err(err))),
+                    };
+                }
+            }
+        }
+        Either::Left(Poll::Pending)
+    }
+}
+
+pub struct TcpConnectServiceResponse<T: Address> {
+    state: TcpConnectState<T>,
+    tcp: TcpConnector<T>,
+}
+
+impl<T: Address> Future for TcpConnectServiceResponse<T> {
+    type Output = Result<TcpStream, ConnectError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let res = match self.state.poll(cx) {
+            Either::Right(res) => {
+                self.state = TcpConnectState::Connect(self.tcp.call(res));
+                self.state.poll(cx)
+            }
+            Either::Left(res) => return res,
+        };
+
+        match res {
+            Either::Left(res) => res,
+            Either::Right(_) => panic!(),
+        }
+    }
+}

actix-connect/src/ssl/mod.rs

@@ -0,0 +1,7 @@
+//! SSL Services
+
+#[cfg(feature = "openssl")]
+pub mod openssl;
+
+#[cfg(feature = "rustls")]
+pub mod rustls;

actix-connect/src/ssl/openssl.rs

@@ -0,0 +1,267 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{fmt, io};
+
+pub use open_ssl::ssl::{Error as SslError, SslConnector, SslMethod};
+pub use tokio_openssl::{HandshakeError, SslStream};
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::net::TcpStream;
+use actix_service::{Service, ServiceFactory};
+use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready};
+use trust_dns_resolver::AsyncResolver;
+
+use crate::{
+    Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection,
+};
+
+/// Openssl connector factory
+pub struct OpensslConnector<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> OpensslConnector<T, U> {
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> OpensslConnector<T, U>
+where
+    T: Address + 'static,
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
+{
+    pub fn service(connector: SslConnector) -> OpensslConnectorService<T, U> {
+        OpensslConnectorService {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Clone for OpensslConnector<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> ServiceFactory for OpensslConnector<T, U>
+where
+    T: Address + 'static,
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = io::Error;
+    type Config = ();
+    type Service = OpensslConnectorService<T, U>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(OpensslConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct OpensslConnectorService<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> Clone for OpensslConnectorService<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Service for OpensslConnectorService<T, U>
+where
+    T: Address + 'static,
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = io::Error;
+    type Future = Either<ConnectAsyncExt<T, U>, Ready<Result<Self::Response, Self::Error>>>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+        trace!("SSL Handshake start for: {:?}", stream.host());
+        let (io, stream) = stream.replace(());
+        let host = stream.host().to_string();
+
+        match self.connector.configure() {
+            Err(e) => Either::Right(err(io::Error::new(io::ErrorKind::Other, e))),
+            Ok(config) => Either::Left(ConnectAsyncExt {
+                fut: async move { tokio_openssl::connect(config, &host, io).await }
+                    .boxed_local(),
+                stream: Some(stream),
+                _t: PhantomData,
+            }),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<T, U> {
+    fut: LocalBoxFuture<'static, Result<SslStream<U>, HandshakeError<U>>>,
+    stream: Option<Connection<T, ()>>,
+    _t: PhantomData<U>,
+}
+
+impl<T: Address, U> Future for ConnectAsyncExt<T, U>
+where
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
+{
+    type Output = Result<Connection<T, SslStream<U>>, io::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        match Pin::new(&mut this.fut).poll(cx) {
+            Poll::Ready(Ok(stream)) => {
+                let s = this.stream.take().unwrap();
+                trace!("SSL Handshake success: {:?}", s.host());
+                Poll::Ready(Ok(s.replace(stream).1))
+            }
+            Poll::Ready(Err(e)) => {
+                trace!("SSL Handshake error: {:?}", e);
+                Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, format!("{}", e))))
+            }
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+pub struct OpensslConnectServiceFactory<T> {
+    tcp: ConnectServiceFactory<T>,
+    openssl: OpensslConnector<T, TcpStream>,
+}
+
+impl<T> OpensslConnectServiceFactory<T> {
+    /// Construct new OpensslConnectService factory
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: ConnectServiceFactory::default(),
+            openssl: OpensslConnector::new(connector),
+        }
+    }
+
+    /// Construct new connect service with custom dns resolver
+    pub fn with_resolver(connector: SslConnector, resolver: AsyncResolver) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: ConnectServiceFactory::with_resolver(resolver),
+            openssl: OpensslConnector::new(connector),
+        }
+    }
+
+    /// Construct openssl connect service
+    pub fn service(&self) -> OpensslConnectService<T> {
+        OpensslConnectService {
+            tcp: self.tcp.service(),
+            openssl: OpensslConnectorService {
+                connector: self.openssl.connector.clone(),
+                _t: PhantomData,
+            },
+        }
+    }
+}
+
+impl<T> Clone for OpensslConnectServiceFactory<T> {
+    fn clone(&self) -> Self {
+        OpensslConnectServiceFactory {
+            tcp: self.tcp.clone(),
+            openssl: self.openssl.clone(),
+        }
+    }
+}
+
+impl<T: Address + 'static> ServiceFactory for OpensslConnectServiceFactory<T> {
+    type Request = Connect<T>;
+    type Response = SslStream<TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = OpensslConnectService<T>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(self.service())
+    }
+}
+
+#[derive(Clone)]
+pub struct OpensslConnectService<T> {
+    tcp: ConnectService<T>,
+    openssl: OpensslConnectorService<T, TcpStream>,
+}
+
+impl<T: Address + 'static> Service for OpensslConnectService<T> {
+    type Request = Connect<T>;
+    type Response = SslStream<TcpStream>;
+    type Error = ConnectError;
+    type Future = OpensslConnectServiceResponse<T>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        OpensslConnectServiceResponse {
+            fut1: Some(self.tcp.call(req)),
+            fut2: None,
+            openssl: self.openssl.clone(),
+        }
+    }
+}
+
+pub struct OpensslConnectServiceResponse<T: Address + 'static> {
+    fut1: Option<<ConnectService<T> as Service>::Future>,
+    fut2: Option<<OpensslConnectorService<T, TcpStream> as Service>::Future>,
+    openssl: OpensslConnectorService<T, TcpStream>,
+}
+
+impl<T: Address> Future for OpensslConnectServiceResponse<T> {
+    type Output = Result<SslStream<TcpStream>, ConnectError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if let Some(ref mut fut) = self.fut1 {
+            match futures::ready!(Pin::new(fut).poll(cx)) {
+                Ok(res) => {
+                    let _ = self.fut1.take();
+                    self.fut2 = Some(self.openssl.call(res));
+                }
+                Err(e) => return Poll::Ready(Err(e)),
+            }
+        }
+
+        if let Some(ref mut fut) = self.fut2 {
+            match futures::ready!(Pin::new(fut).poll(cx)) {
+                Ok(connect) => Poll::Ready(Ok(connect.into_parts().0)),
+                Err(e) => Poll::Ready(Err(ConnectError::Io(io::Error::new(
+                    io::ErrorKind::Other,
+                    e,
+                )))),
+            }
+        } else {
+            Poll::Pending
+        }
+    }
+}

actix-connect/src/ssl/rustls.rs

@@ -0,0 +1,136 @@
+use std::fmt;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+pub use rust_tls::Session;
+pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig};
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{Service, ServiceFactory};
+use futures::future::{ok, Ready};
+use tokio_rustls::{Connect, TlsConnector};
+use webpki::DNSNameRef;
+
+use crate::{Address, Connection};
+
+/// Rustls connector factory
+pub struct RustlsConnector<T, U> {
+    connector: Arc<ClientConfig>,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> RustlsConnector<T, U> {
+    pub fn new(connector: Arc<ClientConfig>) -> Self {
+        RustlsConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> RustlsConnector<T, U>
+where
+    T: Address,
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
+{
+    pub fn service(connector: Arc<ClientConfig>) -> RustlsConnectorService<T, U> {
+        RustlsConnectorService {
+            connector: connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Clone for RustlsConnector<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> ServiceFactory for RustlsConnector<T, U>
+where
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, TlsStream<U>>;
+    type Error = std::io::Error;
+    type Config = ();
+    type Service = RustlsConnectorService<T, U>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(RustlsConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct RustlsConnectorService<T, U> {
+    connector: Arc<ClientConfig>,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> Clone for RustlsConnectorService<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> Service for RustlsConnectorService<T, U>
+where
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, TlsStream<U>>;
+    type Error = std::io::Error;
+    type Future = ConnectAsyncExt<T, U>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+        trace!("SSL Handshake start for: {:?}", stream.host());
+        let (io, stream) = stream.replace(());
+        let host = DNSNameRef::try_from_ascii_str(stream.host())
+            .expect("rustls currently only handles hostname-based connections. See https://github.com/briansmith/webpki/issues/54");
+        ConnectAsyncExt {
+            fut: TlsConnector::from(self.connector.clone()).connect(host, io),
+            stream: Some(stream),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<T, U> {
+    fut: Connect<U>,
+    stream: Option<Connection<T, ()>>,
+}
+
+impl<T: Address, U> Future for ConnectAsyncExt<T, U>
+where
+    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
+{
+    type Output = Result<Connection<T, TlsStream<U>>, std::io::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+        Poll::Ready(
+            futures::ready!(Pin::new(&mut this.fut).poll(cx)).map(|stream| {
+                let s = this.stream.take().unwrap();
+                trace!("SSL Handshake success: {:?}", s.host());
+                s.replace(stream).1
+            }),
+        )
+    }
+}

actix-connect/src/uri.rs

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

actix-connect/tests/test_connect.rs

@@ -0,0 +1,137 @@
+use std::io;
+
+use actix_codec::{BytesCodec, Framed};
+use actix_rt::net::TcpStream;
+use actix_service::{fn_service, Service, ServiceFactory};
+use actix_testing::TestServer;
+use bytes::Bytes;
+use futures::SinkExt;
+
+use actix_connect::resolver::{ResolverConfig, ResolverOpts};
+use actix_connect::Connect;
+
+#[cfg(feature = "openssl")]
+#[actix_rt::test]
+async fn test_string() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "rustls")]
+#[actix_rt::test]
+async fn test_rustls_string() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = format!("localhost:{}", srv.port());
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[actix_rt::test]
+async fn test_static_str() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let resolver = actix_connect::start_default_resolver();
+    let mut conn = actix_connect::new_connector(resolver.clone());
+
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+
+    let connect = Connect::new(srv.host().to_owned());
+    let mut conn = actix_connect::new_connector(resolver);
+    let con = conn.call(connect).await;
+    assert!(con.is_err());
+}
+
+#[actix_rt::test]
+async fn test_new_service() {
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let resolver =
+        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default());
+
+    let factory = actix_connect::new_connector_factory(resolver);
+
+    let mut conn = factory.new_service(()).await.unwrap();
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "openssl")]
+#[actix_rt::test]
+async fn test_uri() {
+    use std::convert::TryFrom;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[cfg(feature = "rustls")]
+#[actix_rt::test]
+async fn test_rustls_uri() {
+    use std::convert::TryFrom;
+
+    let srv = TestServer::with(|| {
+        fn_service(|io: TcpStream| {
+            async {
+                let mut framed = Framed::new(io, BytesCodec);
+                framed.send(Bytes::from_static(b"test")).await?;
+                Ok::<_, io::Error>(())
+            }
+        })
+    });
+
+    let mut conn = actix_connect::default_connector();
+    let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = conn.call(addr.into()).await.unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}

actix-connector/CHANGES.md

@@ -1,21 +0,0 @@
-# Changes
-
-## [0.2.0] - 2019-02-01
-
-### Changes
-
-* Migrate to actix-service 0.2
-
-* Upgrade trust-dns-resolver
-
-* Use tokio-current-thread instead of direct actix-rt dipendency
-
-
-## [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

@@ -1,39 +0,0 @@
-[package]
-name = "actix-connector"
-version = "0.2.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.2.0"
-actix-codec = "0.1.0"
-futures = "0.1"
-tokio-tcp = "0.1"
-tokio-current-thread = "0.1"
-trust-dns-resolver = { version="0.11.0-alpha.2", default-features = false }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.3", optional = true }

actix-connector/src/connector.rs

@@ -1,385 +0,0 @@
-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<Request = 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<
-        Request = 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 for Connector {
-    type Request = Connect;
-    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 for TcpConnector<T> {
-    type Request = (T, VecDeque<IpAddr>);
-    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 for DefaultConnector {
-    type Request = Connect;
-    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

@@ -1,16 +0,0 @@
-//! 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

@@ -1,129 +0,0 @@
-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);
-        tokio_current_thread::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 for Resolver<T> {
-    type Request = 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

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

actix-connector/src/ssl/openssl.rs

@@ -1,105 +0,0 @@
-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<Request = (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 for OpensslConnector<R, T, E> {
-    type Request = (R, T);
-    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 for OpensslConnectorService<R, T> {
-    type Request = (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-ioframe/CHANGES.md

@@ -0,0 +1,25 @@
+# Changes
+
+## [0.4.1] - 2019-12-11
+
+* Disconnect callback accepts owned state
+
+## [0.4.0] - 2019-12-11
+
+* Remove `E` param
+
+## [0.3.0-alpha.3] - 2019-12-07
+
+* Migrate to tokio 0.2
+
+## [0.3.0-alpha.2] - 2019-12-02
+
+* Migrate to `std::future`
+
+## [0.1.1] - 2019-10-14
+
+* Re-register task on every dispatcher poll.
+
+## [0.1.0] - 2019-09-25
+
+* Initial release

actix-ioframe/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "actix-ioframe"
+version = "0.4.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix framed service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-ioframe/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_ioframe"
+path = "src/lib.rs"
+
+[dependencies]
+actix-service = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.1"
+actix-rt = "1.0.0"
+bytes = "0.5"
+either = "1.5.2"
+futures = "0.3.1"
+pin-project = "0.4.6"
+log = "0.4"
+
+[dev-dependencies]
+actix-connect = "1.0.0"
+actix-testing = "1.0.0"

actix-ioframe/LICENSE-APACHE

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

actix-ioframe/LICENSE-MIT

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

actix-ioframe/src/connect.rs

@@ -0,0 +1,115 @@
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use futures::Stream;
+
+use crate::sink::Sink;
+
+pub struct Connect<Io, Codec, St = ()>
+where
+    Codec: Encoder + Decoder,
+{
+    io: Io,
+    sink: Sink<<Codec as Encoder>::Item>,
+    _t: PhantomData<(St, Codec)>,
+}
+
+impl<Io, Codec> Connect<Io, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    pub(crate) fn new(io: Io, sink: Sink<<Codec as Encoder>::Item>) -> Self {
+        Self {
+            io,
+            sink,
+            _t: PhantomData,
+        }
+    }
+
+    pub fn codec(self, codec: Codec) -> ConnectResult<Io, (), Codec> {
+        ConnectResult {
+            state: (),
+            sink: self.sink,
+            framed: Framed::new(self.io, codec),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct ConnectResult<Io, St, Codec: Encoder + Decoder> {
+    pub(crate) state: St,
+    pub(crate) framed: Framed<Io, Codec>,
+    pub(crate) sink: Sink<<Codec as Encoder>::Item>,
+}
+
+impl<Io, St, Codec: Encoder + Decoder> ConnectResult<Io, St, Codec> {
+    #[inline]
+    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
+        &self.sink
+    }
+
+    #[inline]
+    pub fn get_ref(&self) -> &Io {
+        self.framed.get_ref()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut Io {
+        self.framed.get_mut()
+    }
+
+    #[inline]
+    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec> {
+        ConnectResult {
+            state,
+            framed: self.framed,
+            sink: self.sink,
+        }
+    }
+}
+
+impl<Io, St, Codec> Stream for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type Item = Result<<Codec as Decoder>::Item, <Codec as Decoder>::Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.project().framed.next_item(cx)
+    }
+}
+
+impl<Io, St, Codec> futures::Sink<<Codec as Encoder>::Item> for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type Error = <Codec as Encoder>::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.framed.is_write_ready() {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn start_send(
+        self: Pin<&mut Self>,
+        item: <Codec as Encoder>::Item,
+    ) -> Result<(), Self::Error> {
+        self.project().framed.write(item)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.get_mut().framed.flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.get_mut().framed.close(cx)
+    }
+}

actix-ioframe/src/dispatcher.rs

@@ -0,0 +1,286 @@
+//! Framed dispatcher service and related utilities
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use actix_service::{IntoService, Service};
+use actix_utils::{mpsc, oneshot};
+use futures::{FutureExt, Stream};
+use log::debug;
+
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::sink::Sink;
+
+type Request<S, U> = Item<S, U>;
+type Response<U> = <U as Encoder>::Item;
+
+pub(crate) enum Message<T> {
+    Item(T),
+    WaitClose(oneshot::Sender<()>),
+    Close,
+}
+
+/// FramedTransport - is a future that reads frames from Framed object
+/// and pass then to the service.
+#[pin_project::pin_project]
+pub(crate) struct Dispatcher<St, S, T, U>
+where
+    St: Clone,
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Encoder + Decoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    service: S,
+    sink: Sink<<U as Encoder>::Item>,
+    state: St,
+    dispatch_state: FramedState<S, U>,
+    framed: Framed<T, U>,
+    rx: mpsc::Receiver<Result<Message<<U as Encoder>::Item>, S::Error>>,
+    tx: mpsc::Sender<Result<Message<<U as Encoder>::Item>, S::Error>>,
+    disconnect: Option<Rc<dyn Fn(St, bool)>>,
+}
+
+impl<St, S, T, U> Dispatcher<St, S, T, U>
+where
+    St: Clone,
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    pub(crate) fn new<F: IntoService<S>>(
+        framed: Framed<T, U>,
+        state: St,
+        service: F,
+        sink: Sink<<U as Encoder>::Item>,
+        rx: mpsc::Receiver<Result<Message<<U as Encoder>::Item>, S::Error>>,
+        disconnect: Option<Rc<dyn Fn(St, bool)>>,
+    ) -> Self {
+        let tx = rx.sender();
+
+        Dispatcher {
+            framed,
+            state,
+            sink,
+            disconnect,
+            rx,
+            tx,
+            service: service.into_service(),
+            dispatch_state: FramedState::Processing,
+        }
+    }
+}
+
+enum FramedState<S: Service, U: Encoder + Decoder> {
+    Processing,
+    Error(ServiceError<S::Error, U>),
+    FramedError(ServiceError<S::Error, U>),
+    FlushAndStop(Vec<oneshot::Sender<()>>),
+    Stopping,
+}
+
+impl<S: Service, U: Encoder + Decoder> FramedState<S, U> {
+    fn stop(&mut self, tx: Option<oneshot::Sender<()>>) {
+        match self {
+            FramedState::FlushAndStop(ref mut vec) => {
+                if let Some(tx) = tx {
+                    vec.push(tx)
+                }
+            }
+            FramedState::Processing => {
+                *self = FramedState::FlushAndStop(if let Some(tx) = tx {
+                    vec![tx]
+                } else {
+                    Vec::new()
+                })
+            }
+            FramedState::Error(_) | FramedState::FramedError(_) | FramedState::Stopping => {
+                if let Some(tx) = tx {
+                    let _ = tx.send(());
+                }
+            }
+        }
+    }
+
+    fn take_error(&mut self) -> ServiceError<S::Error, U> {
+        match std::mem::replace(self, FramedState::Processing) {
+            FramedState::Error(err) => err,
+            _ => panic!(),
+        }
+    }
+
+    fn take_framed_error(&mut self) -> ServiceError<S::Error, U> {
+        match std::mem::replace(self, FramedState::Processing) {
+            FramedState::FramedError(err) => err,
+            _ => panic!(),
+        }
+    }
+}
+
+impl<St, S, T, U> Dispatcher<St, S, T, U>
+where
+    St: Clone,
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    fn poll_read(&mut self, cx: &mut Context<'_>) -> bool {
+        loop {
+            match self.service.poll_ready(cx) {
+                Poll::Ready(Ok(_)) => {
+                    let item = match self.framed.next_item(cx) {
+                        Poll::Ready(Some(Ok(el))) => el,
+                        Poll::Ready(Some(Err(err))) => {
+                            self.dispatch_state =
+                                FramedState::FramedError(ServiceError::Decoder(err));
+                            return true;
+                        }
+                        Poll::Pending => return false,
+                        Poll::Ready(None) => {
+                            log::trace!("Client disconnected");
+                            self.dispatch_state = FramedState::Stopping;
+                            return true;
+                        }
+                    };
+
+                    let tx = self.tx.clone();
+                    actix_rt::spawn(
+                        self.service
+                            .call(Item::new(self.state.clone(), self.sink.clone(), item))
+                            .map(move |item| {
+                                let item = match item {
+                                    Ok(Some(item)) => Ok(Message::Item(item)),
+                                    Ok(None) => return,
+                                    Err(err) => Err(err),
+                                };
+                                let _ = tx.send(item);
+                            }),
+                    );
+                }
+                Poll::Pending => return false,
+                Poll::Ready(Err(err)) => {
+                    self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                    return true;
+                }
+            }
+        }
+    }
+
+    /// write to framed object
+    fn poll_write(&mut self, cx: &mut Context<'_>) -> bool {
+        loop {
+            while !self.framed.is_write_buf_full() {
+                match Pin::new(&mut self.rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(Message::Item(msg)))) => {
+                        if let Err(err) = self.framed.write(msg) {
+                            self.dispatch_state =
+                                FramedState::FramedError(ServiceError::Encoder(err));
+                            return true;
+                        }
+                    }
+                    Poll::Ready(Some(Ok(Message::Close))) => {
+                        self.dispatch_state.stop(None);
+                        return true;
+                    }
+                    Poll::Ready(Some(Ok(Message::WaitClose(tx)))) => {
+                        self.dispatch_state.stop(Some(tx));
+                        return true;
+                    }
+                    Poll::Ready(Some(Err(err))) => {
+                        self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                        return true;
+                    }
+                    Poll::Ready(None) | Poll::Pending => break,
+                }
+            }
+
+            if !self.framed.is_write_buf_empty() {
+                match self.framed.flush(cx) {
+                    Poll::Pending => break,
+                    Poll::Ready(Ok(_)) => (),
+                    Poll::Ready(Err(err)) => {
+                        debug!("Error sending data: {:?}", err);
+                        self.dispatch_state =
+                            FramedState::FramedError(ServiceError::Encoder(err));
+                        return true;
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+        false
+    }
+
+    pub(crate) fn poll(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), ServiceError<S::Error, U>>> {
+        match self.dispatch_state {
+            FramedState::Processing => {
+                if self.poll_read(cx) || self.poll_write(cx) {
+                    self.poll(cx)
+                } else {
+                    Poll::Pending
+                }
+            }
+            FramedState::Error(_) => {
+                // flush write buffer
+                if !self.framed.is_write_buf_empty() {
+                    if let Poll::Pending = self.framed.flush(cx) {
+                        return Poll::Pending;
+                    }
+                }
+                if let Some(ref disconnect) = self.disconnect {
+                    (&*disconnect)(self.state.clone(), true);
+                }
+                Poll::Ready(Err(self.dispatch_state.take_error()))
+            }
+            FramedState::FlushAndStop(ref mut vec) => {
+                if !self.framed.is_write_buf_empty() {
+                    match self.framed.flush(cx) {
+                        Poll::Ready(Err(err)) => {
+                            debug!("Error sending data: {:?}", err);
+                        }
+                        Poll::Pending => {
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(_) => (),
+                    }
+                };
+                for tx in vec.drain(..) {
+                    let _ = tx.send(());
+                }
+                if let Some(ref disconnect) = self.disconnect {
+                    (&*disconnect)(self.state.clone(), false);
+                }
+                Poll::Ready(Ok(()))
+            }
+            FramedState::FramedError(_) => {
+                if let Some(ref disconnect) = self.disconnect {
+                    (&*disconnect)(self.state.clone(), true);
+                }
+                Poll::Ready(Err(self.dispatch_state.take_framed_error()))
+            }
+            FramedState::Stopping => {
+                if let Some(ref disconnect) = self.disconnect {
+                    (&*disconnect)(self.state.clone(), false);
+                }
+                Poll::Ready(Ok(()))
+            }
+        }
+    }
+}

actix-ioframe/src/error.rs

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

actix-ioframe/src/item.rs

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

actix-ioframe/src/lib.rs

@@ -0,0 +1,15 @@
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity, clippy::too_many_arguments)]
+
+mod connect;
+mod dispatcher;
+mod error;
+mod item;
+mod service;
+mod sink;
+
+pub use self::connect::{Connect, ConnectResult};
+pub use self::error::ServiceError;
+pub use self::item::Item;
+pub use self::service::{Builder, NewServiceBuilder, ServiceBuilder};
+pub use self::sink::Sink;

actix-ioframe/src/service.rs

@@ -0,0 +1,440 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
+use actix_service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+use actix_utils::mpsc;
+use either::Either;
+use futures::future::{FutureExt, LocalBoxFuture};
+use pin_project::project;
+
+use crate::connect::{Connect, ConnectResult};
+use crate::dispatcher::{Dispatcher, Message};
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::sink::Sink;
+
+type RequestItem<S, U> = Item<S, U>;
+type ResponseItem<U> = Option<<U as Encoder>::Item>;
+type ServiceResult<U, E> = Result<Message<<U as Encoder>::Item>, E>;
+
+/// Service builder - structure that follows the builder pattern
+/// for building instances for framed services.
+pub struct Builder<St, Codec>(PhantomData<(St, Codec)>);
+
+impl<St: Clone, Codec> Default for Builder<St, Codec> {
+    fn default() -> Builder<St, Codec> {
+        Builder::new()
+    }
+}
+
+impl<St: Clone, Codec> Builder<St, Codec> {
+    pub fn new() -> Builder<St, Codec> {
+        Builder(PhantomData)
+    }
+
+    /// Construct framed handler service with specified connect service
+    pub fn service<Io, C, F>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+        Codec: Decoder + Encoder,
+    {
+        ServiceBuilder {
+            connect: connect.into_service(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+
+    /// Construct framed handler new service with specified connect service
+    pub fn factory<Io, C, F>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoServiceFactory<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: ServiceFactory<
+            Config = (),
+            Request = Connect<Io, Codec>,
+            Response = ConnectResult<Io, St, Codec>,
+        >,
+        C::Error: 'static,
+        C::Future: 'static,
+        Codec: Decoder + Encoder,
+    {
+        NewServiceBuilder {
+            connect: connect.into_factory(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct ServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<dyn Fn(St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> ServiceBuilder<St, C, Io, Codec>
+where
+    St: Clone,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F, Out>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    /// Provide stream items handler service and construct service factory.
+    pub fn finish<F, T>(self, service: F) -> FramedServiceImpl<St, C, T, Io, Codec>
+    where
+        F: IntoServiceFactory<T>,
+        T: ServiceFactory<
+            Config = St,
+            Request = RequestItem<St, Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        >,
+    {
+        FramedServiceImpl {
+            connect: self.connect,
+            handler: Rc::new(service.into_factory()),
+            disconnect: self.disconnect.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct NewServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<dyn Fn(St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> NewServiceBuilder<St, C, Io, Codec>
+where
+    St: Clone,
+    Io: AsyncRead + AsyncWrite,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec>,
+    >,
+    C::Error: 'static,
+    C::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    pub fn finish<F, T, Cfg>(self, service: F) -> FramedService<St, C, T, Io, Codec, Cfg>
+    where
+        F: IntoServiceFactory<T>,
+        T: ServiceFactory<
+                Config = St,
+                Request = RequestItem<St, Codec>,
+                Response = ResponseItem<Codec>,
+                Error = C::Error,
+                InitError = C::Error,
+            > + 'static,
+    {
+        FramedService {
+            connect: self.connect,
+            handler: Rc::new(service.into_factory()),
+            disconnect: self.disconnect,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct FramedService<St, C, T, Io, Codec, Cfg> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<dyn Fn(St, bool)>>,
+    _t: PhantomData<(St, Io, Codec, Cfg)>,
+}
+
+impl<St, C, T, Io, Codec, Cfg> ServiceFactory for FramedService<St, C, T, Io, Codec, Cfg>
+where
+    St: Clone + 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec>,
+    >,
+    C::Error: 'static,
+    C::Future: 'static,
+    T: ServiceFactory<
+            Config = St,
+            Request = RequestItem<St, Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        > + 'static,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Config = Cfg;
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type InitError = C::InitError;
+    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: Cfg) -> Self::Future {
+        let handler = self.handler.clone();
+        let disconnect = self.disconnect.clone();
+
+        // create connect service and then create service impl
+        self.connect
+            .new_service(())
+            .map(move |result| {
+                result.map(move |connect| FramedServiceImpl {
+                    connect,
+                    handler,
+                    disconnect,
+                    _t: PhantomData,
+                })
+            })
+            .boxed_local()
+    }
+}
+
+pub struct FramedServiceImpl<St, C, T, Io, Codec> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<dyn Fn(St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, T, Io, Codec> Service for FramedServiceImpl<St, C, T, Io, Codec>
+where
+    St: Clone,
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type Future = FramedServiceImplResponse<St, Io, Codec, C, T>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.connect.poll_ready(cx).map_err(|e| e.into())
+    }
+
+    fn call(&mut self, req: Io) -> Self::Future {
+        let (tx, rx) = mpsc::channel();
+        let sink = Sink::new(Rc::new(move |msg| {
+            let _ = tx.send(Ok(msg));
+        }));
+        FramedServiceImplResponse {
+            inner: FramedServiceImplResponseInner::Connect(
+                self.connect.call(Connect::new(req, sink.clone())),
+                self.handler.clone(),
+                self.disconnect.clone(),
+                Some(rx),
+            ),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    St: Clone,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    #[pin]
+    inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+}
+
+impl<St, Io, Codec, C, T> Future for FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    St: Clone,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Output = Result<(), ServiceError<C::Error, Codec>>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        loop {
+            match this.inner.poll(cx) {
+                Either::Left(new) => {
+                    this = self.as_mut().project();
+                    this.inner.set(new)
+                }
+                Either::Right(poll) => return poll,
+            };
+        }
+    }
+}
+
+#[pin_project::pin_project]
+enum FramedServiceImplResponseInner<St, Io, Codec, C, T>
+where
+    St: Clone,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    Connect(
+        #[pin] C::Future,
+        Rc<T>,
+        Option<Rc<dyn Fn(St, bool)>>,
+        Option<mpsc::Receiver<ServiceResult<Codec, C::Error>>>,
+    ),
+    Handler(
+        #[pin] T::Future,
+        Option<ConnectResult<Io, St, Codec>>,
+        Option<Rc<dyn Fn(St, bool)>>,
+        Option<mpsc::Receiver<ServiceResult<Codec, C::Error>>>,
+    ),
+    Dispatcher(Dispatcher<St, T::Service, Io, Codec>),
+}
+
+impl<St, Io, Codec, C, T> FramedServiceImplResponseInner<St, Io, Codec, C, T>
+where
+    St: Clone,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    #[project]
+    fn poll(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Either<
+        FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+        Poll<Result<(), ServiceError<C::Error, Codec>>>,
+    > {
+        #[project]
+        match self.project() {
+            FramedServiceImplResponseInner::Connect(fut, handler, disconnect, rx) => {
+                match fut.poll(cx) {
+                    Poll::Ready(Ok(res)) => {
+                        Either::Left(FramedServiceImplResponseInner::Handler(
+                            handler.new_service(res.state.clone()),
+                            Some(res),
+                            disconnect.take(),
+                            rx.take(),
+                        ))
+                    }
+                    Poll::Pending => Either::Right(Poll::Pending),
+                    Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
+                }
+            }
+            FramedServiceImplResponseInner::Handler(fut, res, disconnect, rx) => {
+                match fut.poll(cx) {
+                    Poll::Ready(Ok(handler)) => {
+                        let res = res.take().unwrap();
+                        Either::Left(FramedServiceImplResponseInner::Dispatcher(
+                            Dispatcher::new(
+                                res.framed,
+                                res.state,
+                                handler,
+                                res.sink,
+                                rx.take().unwrap(),
+                                disconnect.take(),
+                            ),
+                        ))
+                    }
+                    Poll::Pending => Either::Right(Poll::Pending),
+                    Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
+                }
+            }
+            FramedServiceImplResponseInner::Dispatcher(ref mut fut) => {
+                Either::Right(fut.poll(cx))
+            }
+        }
+    }
+}

actix-ioframe/src/sink.rs

@@ -0,0 +1,45 @@
+use std::fmt;
+use std::rc::Rc;
+
+use actix_utils::oneshot;
+use futures::future::{Future, FutureExt};
+
+use crate::dispatcher::Message;
+
+pub struct Sink<T>(Rc<dyn Fn(Message<T>)>);
+
+impl<T> Clone for Sink<T> {
+    fn clone(&self) -> Self {
+        Sink(self.0.clone())
+    }
+}
+
+impl<T> Sink<T> {
+    pub(crate) fn new(tx: Rc<dyn Fn(Message<T>)>) -> Self {
+        Sink(tx)
+    }
+
+    /// Close connection
+    pub fn close(&self) {
+        (self.0)(Message::Close);
+    }
+
+    /// Close connection
+    pub fn wait_close(&self) -> impl Future<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+        (self.0)(Message::WaitClose(tx));
+
+        rx.map(|_| ())
+    }
+
+    /// Send item
+    pub fn send(&self, item: T) {
+        (self.0)(Message::Item(item));
+    }
+}
+
+impl<T> fmt::Debug for Sink<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("Sink").finish()
+    }
+}

actix-ioframe/tests/test_server.rs

@@ -0,0 +1,52 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use actix_codec::BytesCodec;
+use actix_rt::time::delay_for;
+use actix_service::{fn_service, Service};
+use actix_testing::TestServer;
+use futures::future::ok;
+
+use actix_ioframe::{Builder, Connect};
+
+#[derive(Clone)]
+struct State;
+
+#[actix_rt::test]
+async fn test_disconnect() -> std::io::Result<()> {
+    let disconnect = Arc::new(AtomicBool::new(false));
+    let disconnect1 = disconnect.clone();
+
+    let srv = TestServer::with(move || {
+        let disconnect1 = disconnect1.clone();
+
+        Builder::new()
+            .factory(fn_service(|conn: Connect<_, _>| {
+                ok(conn.codec(BytesCodec).state(State))
+            }))
+            .disconnect(move |_, _| {
+                disconnect1.store(true, Ordering::Relaxed);
+            })
+            .finish(fn_service(|_t| ok(None)))
+    });
+
+    let mut client = Builder::new()
+        .service(|conn: Connect<_, _>| {
+            let conn = conn.codec(BytesCodec).state(State);
+            conn.sink().close();
+            ok(conn)
+        })
+        .finish(fn_service(|_t| ok(None)));
+
+    let conn = actix_connect::default_connector()
+        .call(actix_connect::Connect::with(String::new(), srv.addr()))
+        .await
+        .unwrap();
+
+    client.call(conn.into_parts().0).await.unwrap();
+    let _ = delay_for(Duration::from_millis(100)).await;
+    assert!(disconnect.load(Ordering::Relaxed));
+
+    Ok(())
+}

actix-macros/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "actix-macros"
+version = "0.1.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix runtime macros"
+repository = "https://github.com/actix/actix-net"
+documentation = "https://docs.rs/actix-macros/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "^1"
+syn = { version = "^1", features = ["full"] }
+
+[dev-dependencies]
+actix-rt = { version = "1.0.0" }

actix-macros/LICENSE-APACHE

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

actix-macros/LICENSE-MIT

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

actix-macros/src/lib.rs

@@ -0,0 +1,100 @@
+//! Macros for use with Tokio
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::quote;
+
+/// Marks async function to be executed by actix system.
+///
+/// ## Usage
+///
+/// ```rust
+/// #[actix_rt::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+#[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let name = &sig.ident;
+
+    if sig.asyncness.is_none() {
+        return syn::Error::new_spanned(sig.fn_token, "only async fn is supported")
+            .to_compile_error()
+            .into();
+    }
+
+    sig.asyncness = None;
+
+    (quote! {
+        #(#attrs)*
+        #vis #sig {
+            actix_rt::System::new(stringify!(#name))
+                .block_on(async move { #body })
+        }
+    })
+    .into()
+}
+
+/// Marks async test function to be executed by actix runtime.
+///
+/// ## Usage
+///
+/// ```no_run
+/// #[actix_rt::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+    let ret = &input.sig.output;
+    let name = &input.sig.ident;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let mut has_test_attr = false;
+
+    for attr in attrs {
+        if attr.path.is_ident("test") {
+            has_test_attr = true;
+        }
+    }
+
+    if input.sig.asyncness.is_none() {
+        return syn::Error::new_spanned(
+            input.sig.fn_token,
+            format!("only async fn is supported, {}", input.sig.ident),
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let result = if has_test_attr {
+        quote! {
+            #(#attrs)*
+            fn #name() #ret {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    } else {
+        quote! {
+            #[test]
+            #(#attrs)*
+            fn #name() #ret {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    };
+
+    result.into()
+}

actix-rt/CHANGES.md

@@ -1,5 +1,95 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+* Update dependencies
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Fixed
+
+* Fix compilation on non-unix platforms
+
+### Changed
+
+* Migrate to tokio 0.2
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+Added
+
+* Export `main` and `test` attribute macros
+
+* Export `time` module (re-export of tokio-timer)
+
+* Export `net` module (re-export of tokio-net)
+
+
+## [1.0.0-alpha.1] - 2019-11-22
+
+### Changed
+
+* Migrate to std::future and tokio 0.2
+
+
+## [0.2.6] - 2019-11-14
+
+### Fixed
+
+* Fix arbiter's thread panic message.
+
+### Added
+
+* Allow to join arbiter's thread. #60
+
+
+## [0.2.5] - 2019-09-02
+
+### Added
+
+* Add arbiter specific storage
+
+
+## [0.2.4] - 2019-07-17
+
+### Changed
+
+* Avoid a copy of the Future when initializing the Box. #29
+
+
+## [0.2.3] - 2019-06-22
+
+### Added
+
+* Allow to start System using exsiting CurrentThread Handle #22
+
+
+## [0.2.2] - 2019-03-28
+
+### Changed
+
+* Moved `blocking` module to `actix-threadpool` crate
+
+
+## [0.2.1] - 2019-03-11
+
+### Added
+
+* Added `blocking` module
+
+* Arbiter::exec_fn - execute fn on the arbiter's thread
+
+* Arbiter::exec - execute fn on the arbiter's thread and wait result
+
+
+## [0.2.0] - 2019-03-06
+
+* `run` method returns `io::Result<()>`
+
+* Removed `Handle`
+
+
 ## [0.1.0] - 2018-12-09
 
 * Initial release

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.1.0"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,19 +9,16 @@ 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 = "../"
+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-macros = "0.1.0"
+actix-threadpool = "0.3"
+futures = "0.3.1"
+copyless = "0.1.4"
+tokio = { version = "0.2.4", default-features=false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }

actix-rt/LICENSE-APACHE

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

actix-rt/LICENSE-MIT

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

actix-rt/src/arbiter.rs

@@ -1,40 +1,59 @@
+use std::any::{Any, TypeId};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
+use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::task::{Context, Poll};
 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 futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures::channel::oneshot::{channel, Canceled, Sender};
+use futures::{future, Future, FutureExt, Stream};
 
-use crate::builder::Builder;
+use crate::runtime::Runtime;
 use crate::system::System;
 
+use copyless::BoxHelper;
+
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
     static RUNNING: Cell<bool> = Cell::new(false);
-    static Q: RefCell<Vec<Box<Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
+    static Q: RefCell<Vec<Pin<Box<dyn Future<Output = ()>>>>> = RefCell::new(Vec::new());
+    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
 );
 
 pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 
 pub(crate) enum ArbiterCommand {
     Stop,
-    Execute(Box<Future<Item = (), Error = ()> + Send>),
+    Execute(Box<dyn Future<Output = ()> + Unpin + Send>),
+    ExecuteFn(Box<dyn FnExec>),
 }
 
 impl fmt::Debug for ArbiterCommand {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
             ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
         }
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct Arbiter(UnboundedSender<ArbiterCommand>);
+#[derive(Debug)]
+/// Arbiters provide an asynchronous execution environment for actors, functions
+/// and futures. When an Arbiter is created, they spawn a new OS thread, and
+/// host an event loop. Some Arbiter functions execute on the current thread.
+pub struct Arbiter {
+    sender: UnboundedSender<ArbiterCommand>,
+    thread_handle: Option<thread::JoinHandle<()>>,
+}
+
+impl Clone for Arbiter {
+    fn clone(&self) -> Self {
+        Self::with_sender(self.sender.clone())
+    }
+}
 
 impl Default for Arbiter {
     fn default() -> Self {
@@ -46,15 +65,17 @@ impl Arbiter {
     pub(crate) fn new_system() -> Self {
         let (tx, rx) = unbounded();
 
-        let arb = Arbiter(tx);
+        let arb = Arbiter::with_sender(tx);
         ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
         RUNNING.with(|cell| cell.set(false));
+        STORAGE.with(|cell| cell.borrow_mut().clear());
         Arbiter::spawn(ArbiterController { stop: None, rx });
 
         arb
     }
 
-    /// Returns current arbiter's address
+    /// Returns the current thread's arbiter's address. If no Arbiter is present, then this
+    /// function will panic!
     pub fn current() -> Arbiter {
         ADDR.with(|cell| match *cell.borrow() {
             Some(ref addr) => addr.clone(),
@@ -62,9 +83,9 @@ impl Arbiter {
         })
     }
 
-    /// Stop arbiter
+    /// Stop arbiter from continuing it's event loop.
     pub fn stop(&self) {
-        let _ = self.0.unbounded_send(ArbiterCommand::Stop);
+        let _ = self.sender.unbounded_send(ArbiterCommand::Stop);
     }
 
     /// Spawn new thread and run event loop in spawned thread.
@@ -76,48 +97,61 @@ impl Arbiter {
         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 handle = thread::Builder::new()
+            .name(name.clone())
+            .spawn(move || {
+                let mut rt = Runtime::new().expect("Can not create Runtime");
+                let arb = Arbiter::with_sender(arb_tx);
 
-            let (stop, stop_rx) = channel();
-            RUNNING.with(|cell| cell.set(true));
+                let (stop, stop_rx) = channel();
+                RUNNING.with(|cell| cell.set(true));
+                STORAGE.with(|cell| cell.borrow_mut().clear());
 
-            System::set_current(sys);
+                System::set_current(sys);
 
-            // start arbiter controller
-            rt.spawn(ArbiterController {
-                stop: Some(stop),
-                rx: arb_rx,
+                // 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));
+
+                // 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));
+            })
+            .unwrap_or_else(|err| {
+                panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
             });
-            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)
+        Arbiter {
+            sender: arb_tx2,
+            thread_handle: Some(handle),
+        }
     }
 
-    pub(crate) fn run_system() {
+    pub(crate) fn run_system(rt: Option<&Runtime>) {
         RUNNING.with(|cell| cell.set(true));
         Q.with(|cell| {
             let mut v = cell.borrow_mut();
             for fut in v.drain(..) {
-                spawn(fut);
+                if let Some(rt) = rt {
+                    rt.spawn(fut);
+                } else {
+                    tokio::task::spawn_local(fut);
+                }
             }
         });
     }
@@ -126,38 +160,140 @@ impl Arbiter {
         RUNNING.with(|cell| cell.set(false));
     }
 
-    /// Spawn a future on the current thread.
+    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    /// thread.
     pub fn spawn<F>(future: F)
     where
-        F: Future<Item = (), Error = ()> + 'static,
+        F: Future<Output = ()> + 'static,
     {
         RUNNING.with(move |cell| {
             if cell.get() {
-                spawn(Box::new(future));
+                // Spawn the future on running executor
+                tokio::task::spawn_local(future);
             } else {
-                Q.with(move |cell| cell.borrow_mut().push(Box::new(future)));
+                // Box the future and push it to the queue, this results in double boxing
+                // because the executor boxes the future again, but works for now
+                Q.with(move |cell| {
+                    cell.borrow_mut()
+                        .push(unsafe { Pin::new_unchecked(Box::alloc().init(future)) })
+                });
             }
         });
     }
 
-    /// Executes a future on the current thread.
+    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for executing futures on the current
+    /// thread.
     pub fn spawn_fn<F, R>(f: F)
     where
         F: FnOnce() -> R + 'static,
-        R: IntoFuture<Item = (), Error = ()> + 'static,
+        R: Future<Output = ()> + 'static,
     {
-        Arbiter::spawn(future::lazy(f))
+        Arbiter::spawn(future::lazy(|_| f()).flatten())
     }
 
-    /// Send a future on the arbiter's thread and spawn.
+    /// Send a future to the Arbiter's thread, and spawn it.
     pub fn send<F>(&self, future: F)
     where
-        F: Future<Item = (), Error = ()> + Send + 'static,
+        F: Future<Output = ()> + Send + Unpin + 'static,
     {
         let _ = self
-            .0
+            .sender
             .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
     }
+
+    /// Send a function to the Arbiter's thread, and execute it. Any result from the function
+    /// is discarded.
+    pub fn exec_fn<F>(&self, f: F)
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        let _ = self
+            .sender
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                f();
+            })));
+    }
+
+    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
+    /// A future is created, and when resolved will contain the result of the function sent
+    /// to the Arbiters thread.
+    pub fn exec<F, R>(&self, f: F) -> impl Future<Output = Result<R, Canceled>>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let (tx, rx) = channel();
+        let _ = self
+            .sender
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                if !tx.is_canceled() {
+                    let _ = tx.send(f());
+                }
+            })));
+        rx
+    }
+
+    /// Set item to arbiter storage
+    pub fn set_item<T: 'static>(item: T) {
+        STORAGE.with(move |cell| cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item)));
+    }
+
+    /// Check if arbiter storage contains item
+    pub fn contains_item<T: 'static>() -> bool {
+        STORAGE.with(move |cell| cell.borrow().get(&TypeId::of::<T>()).is_some())
+    }
+
+    /// Get a reference to a type previously inserted on this arbiter's storage.
+    ///
+    /// Panics is item is not inserted
+    pub fn get_item<T: 'static, F, R>(mut f: F) -> R
+    where
+        F: FnMut(&T) -> R,
+    {
+        STORAGE.with(move |cell| {
+            let st = cell.borrow();
+            let item = st
+                .get(&TypeId::of::<T>())
+                .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
+                .unwrap();
+            f(item)
+        })
+    }
+
+    /// Get a mutable reference to a type previously inserted on this arbiter's storage.
+    ///
+    /// Panics is item is not inserted
+    pub fn get_mut_item<T: 'static, F, R>(mut f: F) -> R
+    where
+        F: FnMut(&mut T) -> R,
+    {
+        STORAGE.with(move |cell| {
+            let mut st = cell.borrow_mut();
+            let item = st
+                .get_mut(&TypeId::of::<T>())
+                .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
+                .unwrap();
+            f(item)
+        })
+    }
+
+    fn with_sender(sender: UnboundedSender<ArbiterCommand>) -> Self {
+        Self {
+            sender,
+            thread_handle: None,
+        }
+    }
+
+    /// Wait for the event loop to stop by joining the underlying thread (if have Some).
+    pub fn join(&mut self) -> thread::Result<()> {
+        if let Some(thread_handle) = self.thread_handle.take() {
+            thread_handle.join()
+        } else {
+            Ok(())
+        }
+    }
 }
 
 struct ArbiterController {
@@ -168,34 +304,38 @@ struct ArbiterController {
 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() {
+                eprintln!("Panic in Arbiter thread, shutting down system.");
                 System::current().stop_with_code(1)
+            } else {
+                eprintln!("Panic in Arbiter thread.");
             }
         }
     }
 }
 
 impl Future for ArbiterController {
-    type Item = ();
-    type Error = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match self.rx.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(item))) => match item {
+            match Pin::new(&mut self.rx).poll_next(cx) {
+                Poll::Ready(None) => return Poll::Ready(()),
+                Poll::Ready(Some(item)) => match item {
                     ArbiterCommand::Stop => {
                         if let Some(stop) = self.stop.take() {
                             let _ = stop.send(0);
                         };
-                        return Ok(Async::Ready(()));
+                        return Poll::Ready(());
                     }
                     ArbiterCommand::Execute(fut) => {
-                        spawn(fut);
+                        tokio::task::spawn_local(fut);
+                    }
+                    ArbiterCommand::ExecuteFn(f) => {
+                        f.call_box();
                     }
                 },
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
+                Poll::Pending => return Poll::Pending,
             }
         }
     }
@@ -226,14 +366,13 @@ impl SystemArbiter {
 }
 
 impl Future for SystemArbiter {
-    type Item = ();
-    type Error = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match self.commands.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(cmd))) => match cmd {
+            match Pin::new(&mut self.commands).poll_next(cx) {
+                Poll::Ready(None) => return Poll::Ready(()),
+                Poll::Ready(Some(cmd)) => match cmd {
                     SystemCommand::Exit(code) => {
                         // stop arbiters
                         for arb in self.arbiters.values() {
@@ -251,17 +390,22 @@ impl Future for SystemArbiter {
                         self.arbiters.remove(&name);
                     }
                 },
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
+                Poll::Pending => return Poll::Pending,
             }
         }
     }
 }
 
-// /// Execute function in arbiter's thread
-// impl<I: Send, E: Send> Handler<Execute<I, E>> for SystemArbiter {
-//     type Result = Result<I, E>;
+pub trait FnExec: Send + 'static {
+    fn call_box(self: Box<Self>);
+}
 
-//     fn handle(&mut self, msg: Execute<I, E>, _: &mut Context<Self>) -> Result<I, E> {
-//         msg.exec()
-//     }
-// }
+impl<F> FnExec for F
+where
+    F: FnOnce() + Send + 'static,
+{
+    #[allow(clippy::boxed_local)]
+    fn call_box(self: Box<Self>) {
+        (*self)()
+    }
+}

actix-rt/src/builder.rs

@@ -1,14 +1,10 @@
 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 futures::channel::mpsc::unbounded;
+use futures::channel::oneshot::{channel, Receiver};
+use futures::future::{lazy, Future, FutureExt};
+use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemArbiter};
 use crate::runtime::Runtime;
@@ -23,9 +19,6 @@ 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,
 }
@@ -34,7 +27,6 @@ impl Builder {
     pub(crate) fn new() -> Self {
         Builder {
             name: Cow::Borrowed("actix"),
-            clock: Clock::new(),
             stop_on_panic: false,
         }
     }
@@ -45,14 +37,6 @@ impl Builder {
         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.
     ///
@@ -69,16 +53,38 @@ impl Builder {
         self.create_runtime(|| {})
     }
 
+    /// Create new System that can run asynchronously.
+    ///
+    /// This method panics if it cannot start the system arbiter
+    pub(crate) fn build_async(self, local: &LocalSet) -> AsyncSystemRunner {
+        self.create_async_runtime(local)
+    }
+
     /// 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
+    pub fn run<F>(self, f: F) -> io::Result<()>
     where
         F: FnOnce() + 'static,
     {
         self.create_runtime(f).run()
     }
 
+    fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+
+        // system arbiter
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);
+
+        // start the system arbiter
+        let _ = local.spawn_local(arb);
+
+        AsyncSystemRunner { stop, system }
+    }
+
     fn create_runtime<F>(self, f: F) -> SystemRunner
     where
         F: FnOnce() + 'static,
@@ -86,45 +92,55 @@ impl Builder {
         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);
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
 
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
 
-        let mut rt = self.build_rt().unwrap();
+        let mut rt = Runtime::new().unwrap();
         rt.spawn(arb);
 
         // init system arbiter and run configuration method
-        let _ = rt.block_on(lazy(move || {
-            f();
-            Ok::<_, ()>(())
-        }));
+        rt.block_on(lazy(move |_| f()));
 
         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();
+#[derive(Debug)]
+pub(crate) struct AsyncSystemRunner {
+    stop: Receiver<i32>,
+    system: System,
+}
 
-        // 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();
+impl AsyncSystemRunner {
+    /// This function will start event loop and returns a future that
+    /// resolves once the `System::stop()` function is called.
+    pub(crate) fn run_nonblocking(self) -> impl Future<Output = Result<(), io::Error>> + Send {
+        let AsyncSystemRunner { stop, .. } = self;
 
-        // 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,
-        ))
+        // run loop
+        lazy(|_| {
+            Arbiter::run_system(None);
+            async {
+                let res = match stop.await {
+                    Ok(code) => {
+                        if code != 0 {
+                            Err(io::Error::new(
+                                io::ErrorKind::Other,
+                                format!("Non-zero exit code: {}", code),
+                            ))
+                        } else {
+                            Ok(())
+                        }
+                    }
+                    Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+                };
+                Arbiter::stop_system();
+                return res;
+            }
+        })
+        .flatten()
     }
 }
 
@@ -140,36 +156,36 @@ pub struct SystemRunner {
 impl SystemRunner {
     /// This function will start event loop and will finish once the
     /// `System::stop()` function is called.
-    pub fn run(self) -> i32 {
+    pub fn run(self) -> io::Result<()> {
         let SystemRunner { mut rt, stop, .. } = self;
 
         // run loop
-        let _ = rt.block_on(lazy(move || {
-            Arbiter::run_system();
-            Ok::<_, ()>(())
-        }));
-        let code = match rt.block_on(stop) {
-            Ok(code) => code,
-            Err(_) => 1,
+        Arbiter::run_system(Some(&rt));
+        let result = match rt.block_on(stop) {
+            Ok(code) => {
+                if code != 0 {
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Non-zero exit code: {}", code),
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
         };
         Arbiter::stop_system();
-        code
+        result
     }
 
     /// Execute a future and wait for result.
-    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
+    pub fn block_on<F, O>(&mut self, fut: F) -> O
     where
-        F: Future<Item = I, Error = E>,
+        F: Future<Output = O> + 'static,
     {
-        let _ = self.rt.block_on(lazy(move || {
-            Arbiter::run_system();
-            Ok::<_, ()>(())
-        }));
+        Arbiter::run_system(Some(&self.rt));
         let res = self.rt.block_on(fut);
-        let _ = self.rt.block_on(lazy(move || {
-            Arbiter::stop_system();
-            Ok::<_, ()>(())
-        }));
+        Arbiter::stop_system();
         res
     }
 }

actix-rt/src/lib.rs

@@ -1,4 +1,9 @@
 //! A runtime implementation that runs everything on the current thread.
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub use actix_macros::{main, test};
 
 mod arbiter;
 mod builder;
@@ -7,9 +12,12 @@ mod system;
 
 pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
-pub use self::runtime::{Handle, Runtime};
+pub use self::runtime::Runtime;
 pub use self::system::System;
 
+#[doc(hidden)]
+pub use actix_threadpool as blocking;
+
 /// Spawns a future on the current arbiter.
 ///
 /// # Panics
@@ -17,7 +25,7 @@ pub use self::system::System;
 /// This function panics if actix system is not running.
 pub fn spawn<F>(f: F)
 where
-    F: futures::Future<Item = (), Error = ()> + 'static,
+    F: futures::Future<Output = ()> + 'static,
 {
     if !System::is_set() {
         panic!("System is not running");
@@ -25,3 +33,34 @@ where
 
     Arbiter::spawn(f);
 }
+
+/// Asynchronous signal handling
+pub mod signal {
+    #[cfg(unix)]
+    pub mod unix {
+        pub use tokio::signal::unix::*;
+    }
+    pub use tokio::signal::ctrl_c;
+}
+
+/// TCP/UDP/Unix bindings
+pub mod net {
+    pub use tokio::net::UdpSocket;
+    pub use tokio::net::{TcpListener, TcpStream};
+
+    #[cfg(unix)]
+    mod unix {
+        pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
+    }
+
+    #[cfg(unix)]
+    pub use self::unix::*;
+}
+
+/// Utilities for tracking time.
+pub mod time {
+    pub use tokio::time::Instant;
+    pub use tokio::time::{delay_for, delay_until, Delay};
+    pub use tokio::time::{interval, interval_at, Interval};
+    pub use tokio::time::{timeout, Timeout};
+}

actix-rt/src/mod.rs

@@ -1,92 +0,0 @@
-//! 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

@@ -1,134 +1,36 @@
-use std::error::Error;
-use std::fmt;
+use std::future::Future;
 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;
+use tokio::{runtime, task::LocalSet};
 
 /// Single-threaded runtime provides a way to start reactor
-/// and executor on the current thread.
+/// and runtime 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()
-    }
+    local: LocalSet,
+    rt: runtime::Runtime,
 }
 
 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()
+        let rt = runtime::Builder::new()
+            .enable_io()
+            .enable_time()
+            .basic_scheduler()
+            .build()?;
+
+        Ok(Runtime {
+            rt,
+            local: LocalSet::new(),
+        })
     }
 
-    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.
+    /// Spawn a future onto the single-threaded runtime.
     ///
     /// See [module level][mod] documentation for more details.
     ///
@@ -136,7 +38,7 @@ impl Runtime {
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// # use futures::{future, Future, Stream};
     /// use actix_rt::Runtime;
     ///
@@ -145,9 +47,8 @@ impl Runtime {
     /// let mut rt = Runtime::new().unwrap();
     ///
     /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|| {
+    /// rt.spawn(future::lazy(|_| {
     ///     println!("running on the runtime");
-    ///     Ok(())
     /// }));
     /// # }
     /// # pub fn main() {}
@@ -157,11 +58,11 @@ impl Runtime {
     ///
     /// 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
+    pub fn spawn<F>(&self, future: F) -> &Self
     where
-        F: Future<Item = (), Error = ()> + 'static,
+        F: Future<Output = ()> + 'static,
     {
-        self.executor.spawn(future);
+        self.local.spawn_local(future);
         self
     }
 
@@ -181,56 +82,11 @@ impl Runtime {
     ///
     /// 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>
+    pub fn block_on<F>(&mut self, f: F) -> F::Output
     where
-        F: Future,
+        F: Future + 'static,
     {
-        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)
-                    })
-                })
-            })
-        })
+        let res = self.local.block_on(&mut self.rt, f);
+        res
     }
 }

actix-rt/src/system.rs

@@ -1,13 +1,20 @@
 use std::cell::RefCell;
+use std::future::Future;
+use std::io;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-use futures::sync::mpsc::UnboundedSender;
+use futures::channel::mpsc::UnboundedSender;
+use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemCommand};
 use crate::builder::{Builder, SystemRunner};
 
+static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
+
 /// System is a runtime manager.
 #[derive(Clone, Debug)]
 pub struct System {
+    id: usize,
     sys: UnboundedSender<SystemCommand>,
     arbiter: Arbiter,
     stop_on_panic: bool,
@@ -28,6 +35,7 @@ impl System {
             sys,
             arbiter,
             stop_on_panic,
+            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
         };
         System::set_current(sys.clone());
         sys
@@ -49,6 +57,20 @@ impl System {
         Self::builder().name(name).build()
     }
 
+    #[allow(clippy::new_ret_no_self)]
+    /// Create new system using provided tokio Handle.
+    ///
+    /// This method panics if it can not spawn system arbiter
+    pub fn run_in_tokio<T: Into<String>>(
+        name: T,
+        local: &LocalSet,
+    ) -> impl Future<Output = io::Result<()>> {
+        Self::builder()
+            .name(name)
+            .build_async(local)
+            .run_nonblocking()
+    }
+
     /// Get current running system.
     pub fn current() -> System {
         CURRENT.with(|cell| match *cell.borrow() {
@@ -81,6 +103,11 @@ impl System {
         })
     }
 
+    /// System id
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
     /// Stop the system
     pub fn stop(&self) {
         self.stop_with_code(0)
@@ -109,7 +136,7 @@ impl System {
     /// 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
+    pub fn run<F>(f: F) -> io::Result<()>
     where
         F: FnOnce() + 'static,
     {

actix-server/CHANGES.md

@@ -1,8 +1,158 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+### Changed
+
+* Use actix-net releases
+
+
+## [1.0.0-alpha.4] - 2019-12-08
+
+### Changed
+
+* Use actix-service 1.0.0-alpha.4
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Changed
+
+* Migrate to tokio 0.2
+
+### Fixed
+
+* Fix compilation on non-unix platforms
+
+* Better handling server configuration
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+### Changed
+
+* Simplify server service (remove actix-server-config)
+
+* Allow to wait on `Server` until server stops
+
+
+## [0.8.0-alpha.1] - 2019-11-22
+
+### Changed
+
+* Migrate to `std::future`
+
+
+## [0.7.0] - 2019-10-04
+
+### Changed
+
+* Update `rustls` to 0.16
+* Minimum required Rust version upped to 1.37.0
+
+
+## [0.6.1] - 2019-09-25
+
+### Added
+
+* Add UDS listening support to `ServerBuilder`
+
+
+## [0.6.0] - 2019-07-18
+
+### Added
+
+* Support Unix domain sockets #3
+
+
+## [0.5.1] - 2019-05-18
+
+### Changed
+
+* ServerBuilder::shutdown_timeout() accepts u64
+
+
+## [0.5.0] - 2019-05-12
+
+### Added
+
+* Add `Debug` impl for `SslError`
+
+* Derive debug for `Server` and `ServerCommand`
+
+### Changed
+
+* Upgrade to actix-service 0.4
+
+
+## [0.4.3] - 2019-04-16
+
+### Added
+
+* Re-export `IoStream` trait
+
+### Changed
+
+* Deppend on `ssl` and `rust-tls` features from actix-server-config
+
+
+## [0.4.2] - 2019-03-30
+
+### Fixed
+
+* Fix SIGINT force shutdown
+
+
+## [0.4.1] - 2019-03-14
+
+### Added
+
+* `SystemRuntime::on_start()` - allow to run future before server service initialization
+
+
+## [0.4.0] - 2019-03-12
+
+### Changed
+
+* Use `ServerConfig` for service factory
+
+* Wrap tcp socket to `Io` type
+
+* Upgrade actix-service
+
+
+## [0.3.1] - 2019-03-04
+
+### Added
+
+* Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
+
+* Add helper ssl error `SslError`
+
+
+### Changed
+
+* Rename `StreamServiceFactory` to `ServiceFactory`
+
+* Deprecate `StreamServiceFactory`
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+
+## [0.2.1] - 2019-02-09
+
+### Changed
+
+* Drop service response
+
+
 ## [0.2.0] - 2019-02-01
 
-## Changes
+### Changed
 
 * Migrate to actix-service 0.2
 
@@ -11,14 +161,14 @@
 
 ## [0.1.3] - 2018-12-21
 
-## Fixed
+### Fixed
 
 * Fix max concurrent connections handling
 
 
 ## [0.1.2] - 2018-12-12
 
-## Changed
+### Changed
 
 * rename ServiceConfig::rt() to ServiceConfig::apply()
 

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.2.0"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,10 +11,7 @@ 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"]
+workspace = ".."
 
 [lib]
 name = "actix_server"
@@ -23,47 +20,23 @@ 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.2.0"
-actix-rt = "0.1.0"
+actix-service = "1.0.0"
+actix-rt = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.0"
 
 log = "0.4"
-num_cpus = "1.0"
-
-# io
-mio = "^0.6.13"
+num_cpus = "1.11"
+mio = "0.6.19"
 net2 = "0.2"
-bytes = "0.4"
-futures = "0.1"
+futures = "0.3.1"
 slab = "0.4"
-tokio-io = "0.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2.8"
-tokio-reactor = "0.1"
-tokio-signal = "0.2"
 
-# 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.15", optional = true }
-tokio-rustls = { version = "^0.9", optional = true }
-webpki = { version = "0.19", optional = true }
-webpki-roots = { version = "0.16", optional = true }
+# unix domain sockets
+mio-uds = { version = "0.6.7" }
 
 [dev-dependencies]
+bytes = "0.5"
 env_logger = "0.6"
-actix-codec = "0.1.0"
+actix-testing = "1.0.0"

actix-server/LICENSE-APACHE

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

actix-server/LICENSE-MIT

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

actix-server/src/accept.rs

@@ -1,17 +1,16 @@
 use std::sync::mpsc as sync_mpsc;
-use std::time::{Duration, Instant};
-use std::{io, net, thread};
+use std::time::Duration;
+use std::{io, thread};
 
+use actix_rt::time::{delay_until, Instant};
 use actix_rt::System;
-use futures::future::{lazy, Future};
 use log::{error, info};
-use mio;
 use slab::Slab;
-use tokio_timer::Delay;
 
-use super::server::Server;
-use super::worker::{Conn, WorkerClient};
-use super::Token;
+use crate::server::Server;
+use crate::socket::{SocketAddr, SocketListener, StdListener};
+use crate::worker::{Conn, WorkerClient};
+use crate::Token;
 
 pub(crate) enum Command {
     Pause,
@@ -21,9 +20,9 @@ pub(crate) enum Command {
 }
 
 struct ServerSocketInfo {
-    addr: net::SocketAddr,
+    addr: SocketAddr,
     token: Token,
-    sock: mio::net::TcpListener,
+    sock: SocketListener,
     timeout: Option<Instant>,
 }
 
@@ -84,7 +83,7 @@ impl AcceptLoop {
 
     pub(crate) fn start(
         &mut self,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
     ) {
         let srv = self.srv.take().expect("Can not re-use AcceptInfo");
@@ -135,7 +134,7 @@ impl Accept {
         rx: sync_mpsc::Receiver<Command>,
         cmd_reg: mio::Registration,
         notify_reg: mio::Registration,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         srv: Server,
         workers: Vec<WorkerClient>,
     ) {
@@ -174,7 +173,7 @@ impl Accept {
 
     fn new(
         rx: sync_mpsc::Receiver<Command>,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
         srv: Server,
     ) -> Accept {
@@ -187,10 +186,9 @@ impl Accept {
         // Start accept
         let mut sockets = Slab::new();
         for (hnd_token, lst) in socks.into_iter() {
-            let addr = lst.local_addr().unwrap();
-            let server = mio::net::TcpListener::from_std(lst)
-                .expect("Can not create mio::net::TcpListener");
+            let addr = lst.local_addr();
 
+            let server = lst.into_listener();
             let entry = sockets.vacant_entry();
             let token = entry.key();
 
@@ -371,7 +369,7 @@ impl Accept {
                 match self.workers[self.next].send(msg) {
                     Ok(_) => (),
                     Err(tmp) => {
-                        self.srv.worker_died(self.workers[self.next].idx);
+                        self.srv.worker_faulted(self.workers[self.next].idx);
                         msg = tmp;
                         self.workers.swap_remove(self.next);
                         if self.workers.is_empty() {
@@ -397,7 +395,7 @@ impl Accept {
                             return;
                         }
                         Err(tmp) => {
-                            self.srv.worker_died(self.workers[self.next].idx);
+                            self.srv.worker_faulted(self.workers[self.next].idx);
                             msg = tmp;
                             self.workers.swap_remove(self.next);
                             if self.workers.is_empty() {
@@ -422,12 +420,13 @@ impl Accept {
     fn accept(&mut self, token: usize) {
         loop {
             let msg = if let Some(info) = self.sockets.get_mut(token) {
-                match info.sock.accept_std() {
-                    Ok((io, addr)) => Conn {
+                match info.sock.accept() {
+                    Ok(Some((io, addr))) => Conn {
                         io,
                         token: info.token,
                         peer: Some(addr),
                     },
+                    Ok(None) => return,
                     Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
                     Err(ref e) if connection_error(e) => continue,
                     Err(e) => {
@@ -440,13 +439,9 @@ impl Accept {
                         info.timeout = Some(Instant::now() + Duration::from_millis(500));
 
                         let r = self.timer.1.clone();
-                        System::current().arbiter().send(lazy(move || {
-                            Delay::new(Instant::now() + Duration::from_millis(510))
-                                .map_err(|_| ())
-                                .and_then(move |_| {
-                                    let _ = r.set_readiness(mio::Ready::readable());
-                                    Ok(())
-                                })
+                        System::current().arbiter().send(Box::pin(async move {
+                            delay_until(Instant::now() + Duration::from_millis(510)).await;
+                            let _ = r.set_readiness(mio::Ready::readable());
                         }));
                         return;
                     }

actix-server/src/builder.rs

@@ -1,22 +1,26 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
 use std::time::Duration;
 use std::{io, mem, net};
 
-use actix_rt::{spawn, Arbiter, System};
-use futures::future::{lazy, ok};
-use futures::stream::futures_unordered;
-use futures::sync::mpsc::{unbounded, UnboundedReceiver};
-use futures::{Async, Future, Poll, Stream};
+use actix_rt::net::TcpStream;
+use actix_rt::time::{delay_until, Instant};
+use actix_rt::{spawn, System};
+use futures::channel::mpsc::{unbounded, UnboundedReceiver};
+use futures::channel::oneshot;
+use futures::future::ready;
+use futures::stream::FuturesUnordered;
+use futures::{ready, Future, FutureExt, Stream, StreamExt};
 use log::{error, info};
 use net2::TcpBuilder;
 use num_cpus;
-use tokio_timer::sleep;
 
 use crate::accept::{AcceptLoop, AcceptNotify, Command};
 use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
-use crate::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
-use crate::services::{ServiceFactory, ServiceNewService};
+use crate::service::{InternalServiceFactory, ServiceFactory, StreamNewService};
 use crate::signals::{Signal, Signals};
+use crate::socket::StdListener;
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
 use crate::Token;
 
@@ -24,15 +28,17 @@ use crate::Token;
 pub struct ServerBuilder {
     threads: usize,
     token: Token,
+    backlog: i32,
     workers: Vec<(usize, WorkerClient)>,
-    services: Vec<Box<InternalServiceFactory>>,
-    sockets: Vec<(Token, net::TcpListener)>,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    sockets: Vec<(Token, StdListener)>,
     accept: AcceptLoop,
     exit: bool,
     shutdown_timeout: Duration,
     no_signals: bool,
     cmd: UnboundedReceiver<ServerCommand>,
     server: Server,
+    notify: Vec<oneshot::Sender<()>>,
 }
 
 impl Default for ServerBuilder {
@@ -54,10 +60,12 @@ impl ServerBuilder {
             services: Vec::new(),
             sockets: Vec::new(),
             accept: AcceptLoop::new(server.clone()),
+            backlog: 2048,
             exit: false,
             shutdown_timeout: Duration::from_secs(30),
             no_signals: false,
             cmd: rx,
+            notify: Vec::new(),
             server,
         }
     }
@@ -71,6 +79,21 @@ impl ServerBuilder {
         self
     }
 
+    /// Set the maximum number of pending connections.
+    ///
+    /// This refers to the number of clients that can be waiting to be served.
+    /// Exceeding this number results in the client getting an error when
+    /// attempting to connect. It should only affect servers under significant
+    /// load.
+    ///
+    /// Generally set in the 64-2048 range. Default value is 2048.
+    ///
+    /// This method should be called before `bind()` method call.
+    pub fn backlog(mut self, num: i32) -> Self {
+        self.backlog = num;
+        self
+    }
+
     /// Sets the maximum per-worker number of concurrent connections.
     ///
     /// All socket listeners will stop accepting connections when this limit is
@@ -83,8 +106,6 @@ impl ServerBuilder {
     }
 
     /// Stop actix system.
-    ///
-    /// `SystemExit` message stops currently running system.
     pub fn system_exit(mut self) -> Self {
         self.exit = true;
         self
@@ -103,8 +124,8 @@ impl ServerBuilder {
     /// dropped.
     ///
     /// By default shutdown timeout sets to 30 seconds.
-    pub fn shutdown_timeout(mut self, sec: u16) -> Self {
-        self.shutdown_timeout = Duration::from_secs(u64::from(sec));
+    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
+        self.shutdown_timeout = Duration::from_secs(sec);
         self
     }
 
@@ -117,7 +138,7 @@ impl ServerBuilder {
     where
         F: Fn(&mut ServiceConfig) -> io::Result<()>,
     {
-        let mut cfg = ServiceConfig::new(self.threads);
+        let mut cfg = ServiceConfig::new(self.threads, self.backlog);
 
         f(&mut cfg)?;
 
@@ -125,8 +146,8 @@ impl ServerBuilder {
             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));
+                srv.stream(token, name, lst.local_addr()?);
+                self.sockets.push((token, StdListener::Tcp(lst)));
             }
             self.services.push(Box::new(srv));
         }
@@ -138,21 +159,70 @@ impl ServerBuilder {
     /// 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,
+        F: ServiceFactory<TcpStream>,
         U: net::ToSocketAddrs,
     {
-        let sockets = bind_addr(addr)?;
+        let sockets = bind_addr(addr, self.backlog)?;
 
+        for lst in sockets {
+            let token = self.token.next();
+            self.services.push(StreamNewService::create(
+                name.as_ref().to_string(),
+                token,
+                factory.clone(),
+                lst.local_addr()?,
+            ));
+            self.sockets.push((token, StdListener::Tcp(lst)));
+        }
+        Ok(self)
+    }
+
+    #[cfg(all(unix))]
+    /// Add new unix domain service to the server.
+    pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
+    where
+        F: ServiceFactory<actix_rt::net::UnixStream>,
+        N: AsRef<str>,
+        U: AsRef<std::path::Path>,
+    {
+        use std::os::unix::net::UnixListener;
+
+        // The path must not exist when we try to bind.
+        // Try to remove it to avoid bind error.
+        if let Err(e) = std::fs::remove_file(addr.as_ref()) {
+            // NotFound is expected and not an issue. Anything else is.
+            if e.kind() != std::io::ErrorKind::NotFound {
+                return Err(e);
+            }
+        }
+
+        let lst = UnixListener::bind(addr)?;
+        self.listen_uds(name, lst, factory)
+    }
+
+    #[cfg(all(unix))]
+    /// Add new unix domain service to the server.
+    /// Useful when running as a systemd service and
+    /// a socket FD can be acquired using the systemd crate.
+    pub fn listen_uds<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: std::os::unix::net::UnixListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServiceFactory<actix_rt::net::UnixStream>,
+    {
+        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
         let token = self.token.next();
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
-            factory,
+            factory.clone(),
+            addr,
         ));
-
-        for lst in sockets {
-            self.sockets.push((token, lst));
-        }
+        self.sockets.push((token, StdListener::Uds(lst)));
         Ok(self)
     }
 
@@ -162,38 +232,19 @@ impl ServerBuilder {
         name: N,
         lst: net::TcpListener,
         factory: F,
-    ) -> Self
+    ) -> io::Result<Self>
     where
-        F: StreamServiceFactory,
+        F: ServiceFactory<TcpStream>,
     {
         let token = self.token.next();
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
             factory,
+            lst.local_addr()?,
         ));
-        self.sockets.push((token, lst));
-        self
-    }
-
-    /// Add new service to the server.
-    pub fn listen2<F, N: AsRef<str>>(
-        mut self,
-        name: N,
-        lst: net::TcpListener,
-        factory: F,
-    ) -> Self
-    where
-        F: ServiceFactory,
-    {
-        let token = self.token.next();
-        self.services.push(ServiceNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory,
-        ));
-        self.sockets.push((token, lst));
-        self
+        self.sockets.push((token, StdListener::Tcp(lst)));
+        Ok(self)
     }
 
     /// Spawn new thread and start listening for incoming connections.
@@ -204,24 +255,20 @@ impl ServerBuilder {
     /// This methods panics if no socket addresses get bound.
     ///
     /// ```rust,ignore
-    /// # extern crate futures;
-    /// # extern crate actix_web;
-    /// # use futures::Future;
     /// use actix_web::*;
     ///
-    /// fn main() {
+    /// fn main() -> std::io::Result<()> {
     ///     Server::new().
     ///         .service(
-    ///            HttpServer::new(|| App::new().resource("/", |r| r.h(|_| HttpResponse::Ok())))
+    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
     ///                .bind("127.0.0.1:0")
-    ///                .expect("Can not bind to 127.0.0.1:0"))
-    ///         .run();
+    ///         .run()
     /// }
     /// ```
-    pub fn run(self) {
+    pub fn run(self) -> io::Result<()> {
         let sys = System::new("http-server");
         self.start();
-        sys.run();
+        sys.run()
     }
 
     /// Starts processing incoming connections and return server controller.
@@ -241,14 +288,14 @@ impl ServerBuilder {
 
             // start accept thread
             for sock in &self.sockets {
-                info!("Starting server on {}", sock.1.local_addr().ok().unwrap());
+                info!("Starting server on {}", sock.1);
             }
             self.accept
                 .start(mem::replace(&mut self.sockets, Vec::new()), workers);
 
             // handle signals
             if !self.no_signals {
-                Signals::start(self.server.clone());
+                Signals::start(self.server.clone()).unwrap();
             }
 
             // start http server actor
@@ -259,20 +306,11 @@ impl ServerBuilder {
     }
 
     fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
-        let (tx1, rx1) = unbounded();
-        let (tx2, rx2) = unbounded();
-        let timeout = self.shutdown_timeout;
         let avail = WorkerAvailability::new(notify);
-        let worker = WorkerClient::new(idx, tx1, tx2, avail.clone());
-        let services: Vec<Box<InternalServiceFactory>> =
+        let services: Vec<Box<dyn InternalServiceFactory>> =
             self.services.iter().map(|v| v.clone_factory()).collect();
 
-        Arbiter::new().send(lazy(move || {
-            Worker::start(rx1, rx2, services, avail, timeout);
-            Ok::<_, ()>(())
-        }));
-
-        worker
+        Worker::start(idx, services, avail, self.shutdown_timeout)
     }
 
     fn handle_cmd(&mut self, item: ServerCommand) {
@@ -316,6 +354,9 @@ impl ServerBuilder {
                     _ => (),
                 }
             }
+            ServerCommand::Notify(tx) => {
+                self.notify.push(tx);
+            }
             ServerCommand::Stop {
                 graceful,
                 completion,
@@ -324,43 +365,59 @@ impl ServerBuilder {
 
                 // stop accept thread
                 self.accept.send(Command::Stop);
+                let notify = std::mem::replace(&mut self.notify, Vec::new());
 
                 // stop workers
-                if !self.workers.is_empty() {
+                if !self.workers.is_empty() && graceful {
                     spawn(
-                        futures_unordered(
-                            self.workers
-                                .iter()
-                                .map(move |worker| worker.1.stop(graceful)),
-                        )
-                        .collect()
-                        .then(move |_| {
-                            if let Some(tx) = completion {
-                                let _ = tx.send(());
-                            }
-                            if exit {
-                                spawn(sleep(Duration::from_millis(300)).then(|_| {
-                                    System::current().stop();
-                                    ok(())
-                                }));
-                            }
-                            ok(())
-                        }),
+                        self.workers
+                            .iter()
+                            .map(move |worker| worker.1.stop(graceful))
+                            .collect::<FuturesUnordered<_>>()
+                            .collect::<Vec<_>>()
+                            .then(move |_| {
+                                if let Some(tx) = completion {
+                                    let _ = tx.send(());
+                                }
+                                for tx in notify {
+                                    let _ = tx.send(());
+                                }
+                                if exit {
+                                    spawn(
+                                        async {
+                                            delay_until(
+                                                Instant::now() + Duration::from_millis(300),
+                                            )
+                                            .await;
+                                            System::current().stop();
+                                        }
+                                            .boxed(),
+                                    );
+                                }
+                                ready(())
+                            }),
                     )
                 } else {
                     // we need to stop system if server was spawned
                     if self.exit {
-                        spawn(sleep(Duration::from_millis(300)).then(|_| {
-                            System::current().stop();
-                            ok(())
-                        }));
+                        spawn(
+                            delay_until(Instant::now() + Duration::from_millis(300)).then(
+                                |_| {
+                                    System::current().stop();
+                                    ready(())
+                                },
+                            ),
+                        );
                     }
                     if let Some(tx) = completion {
                         let _ = tx.send(());
                     }
+                    for tx in notify {
+                        let _ = tx.send(());
+                    }
                 }
             }
-            ServerCommand::WorkerDied(idx) => {
+            ServerCommand::WorkerFaulted(idx) => {
                 let mut found = false;
                 for i in 0..self.workers.len() {
                     if self.workers[i].0 == idx {
@@ -394,26 +451,29 @@ impl ServerBuilder {
 }
 
 impl Future for ServerBuilder {
-    type Item = ();
-    type Error = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         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),
+            match ready!(Pin::new(&mut self.cmd).poll_next(cx)) {
+                Some(it) => self.as_mut().get_mut().handle_cmd(it),
+                None => {
+                    return Poll::Pending;
+                }
             }
         }
     }
 }
 
-pub(super) fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::TcpListener>> {
+pub(super) fn bind_addr<S: net::ToSocketAddrs>(
+    addr: S,
+    backlog: i32,
+) -> io::Result<Vec<net::TcpListener>> {
     let mut err = None;
     let mut succ = false;
     let mut sockets = Vec::new();
     for addr in addr.to_socket_addrs()? {
-        match create_tcp_listener(addr) {
+        match create_tcp_listener(addr, backlog) {
             Ok(lst) => {
                 succ = true;
                 sockets.push(lst);
@@ -436,12 +496,12 @@ pub(super) fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::T
     }
 }
 
-fn create_tcp_listener(addr: net::SocketAddr) -> io::Result<net::TcpListener> {
+fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
     let builder = match addr {
         net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
         net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
     };
     builder.reuse_address(true)?;
     builder.bind(addr)?;
-    Ok(builder.listen(1024)?)
+    Ok(builder.listen(backlog)?)
 }

actix-server/src/config.rs

@@ -1,29 +1,30 @@
 use std::collections::HashMap;
 use std::{fmt, io, net};
 
-use actix_service::{IntoNewService, NewService};
-use futures::future::{join_all, Future};
+use actix_rt::net::TcpStream;
+use actix_service as actix;
+use actix_utils::counter::CounterGuard;
+use futures::future::{ok, Future, FutureExt, LocalBoxFuture};
 use log::error;
-use tokio_tcp::TcpStream;
-
-use crate::counter::CounterGuard;
 
 use super::builder::bind_addr;
-use super::services::{
+use super::service::{
     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) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
     pub(crate) threads: usize,
+    pub(crate) backlog: i32,
 }
 
 impl ServiceConfig {
-    pub(super) fn new(threads: usize) -> ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
         ServiceConfig {
             threads,
+            backlog,
             services: Vec::new(),
             apply: None,
         }
@@ -42,7 +43,7 @@ impl ServiceConfig {
     where
         U: net::ToSocketAddrs,
     {
-        let sockets = bind_addr(addr)?;
+        let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
             self.listen(name.as_ref(), lst);
@@ -72,59 +73,92 @@ impl ServiceConfig {
 }
 
 pub(super) struct ConfiguredService {
-    rt: Box<ServiceRuntimeConfiguration>,
-    names: HashMap<Token, String>,
-    services: HashMap<String, Token>,
+    rt: Box<dyn ServiceRuntimeConfiguration>,
+    names: HashMap<Token, (String, net::SocketAddr)>,
+    topics: HashMap<String, Token>,
+    services: Vec<Token>,
 }
 
 impl ConfiguredService {
-    pub(super) fn new(rt: Box<ServiceRuntimeConfiguration>) -> Self {
+    pub(super) fn new(rt: Box<dyn ServiceRuntimeConfiguration>) -> Self {
         ConfiguredService {
             rt,
             names: HashMap::new(),
-            services: HashMap::new(),
+            topics: HashMap::new(),
+            services: Vec::new(),
         }
     }
 
-    pub(super) fn stream(&mut self, token: Token, name: String) {
-        self.names.insert(token, name.clone());
-        self.services.insert(name, token);
+    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
+        self.names.insert(token, (name.clone(), addr));
+        self.topics.insert(name.clone(), token);
+        self.services.push(token);
     }
 }
 
 impl InternalServiceFactory for ConfiguredService {
     fn name(&self, token: Token) -> &str {
-        &self.names[&token]
+        &self.names[&token].0
     }
 
-    fn clone_factory(&self) -> Box<InternalServiceFactory> {
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
         Box::new(Self {
             rt: self.rt.clone(),
             names: self.names.clone(),
+            topics: self.topics.clone(),
             services: self.services.clone(),
         })
     }
 
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
+    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
         // configure services
-        let mut rt = ServiceRuntime::new(self.services.clone());
+        let mut rt = ServiceRuntime::new(self.topics.clone());
         self.rt.configure(&mut rt);
         rt.validate();
+        let mut names = self.names.clone();
+        let tokens = self.services.clone();
 
         // construct services
-        let mut fut = Vec::new();
-        for (token, ns) in rt.services {
-            fut.push(ns.new_service().map(move |service| (token, service)));
+        async move {
+            let mut services = rt.services;
+            // TODO: Proper error handling here
+            for f in rt.onstart.into_iter() {
+                f.await;
+            }
+            let mut res = vec![];
+            for token in tokens {
+                if let Some(srv) = services.remove(&token) {
+                    let newserv = srv.new_service(());
+                    match newserv.await {
+                        Ok(serv) => {
+                            res.push((token, serv));
+                        }
+                        Err(_) => {
+                            error!("Can not construct service");
+                            return Err(());
+                        }
+                    }
+                } else {
+                    let name = names.remove(&token).unwrap().0;
+                    res.push((
+                        token,
+                        Box::new(StreamService::new(actix::fn_service(
+                            move |_: TcpStream| {
+                                error!("Service {:?} is not configured", name);
+                                ok::<_, ()>(())
+                            },
+                        ))),
+                    ));
+                };
+            }
+            return Ok(res);
         }
-
-        Box::new(join_all(fut).map_err(|e| {
-            error!("Can not construct service: {:?}", e);
-        }))
+            .boxed_local()
     }
 }
 
 pub(super) trait ServiceRuntimeConfiguration: Send {
-    fn clone(&self) -> Box<ServiceRuntimeConfiguration>;
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration>;
 
     fn configure(&self, rt: &mut ServiceRuntime);
 }
@@ -133,7 +167,7 @@ impl<F> ServiceRuntimeConfiguration for F
 where
     F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
 {
-    fn clone(&self) -> Box<ServiceRuntimeConfiguration> {
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration> {
         Box::new(self.clone())
     }
 
@@ -149,6 +183,7 @@ fn not_configured(_: &mut ServiceRuntime) {
 pub struct ServiceRuntime {
     names: HashMap<String, Token>,
     services: HashMap<Token, BoxedNewService>,
+    onstart: Vec<LocalBoxFuture<'static, ()>>,
 }
 
 impl ServiceRuntime {
@@ -156,6 +191,7 @@ impl ServiceRuntime {
         ServiceRuntime {
             names,
             services: HashMap::new(),
+            onstart: Vec::new(),
         }
     }
 
@@ -167,10 +203,14 @@ impl ServiceRuntime {
         }
     }
 
+    /// Register service.
+    ///
+    /// Name of the service must be registered during configuration stage with
+    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: IntoNewService<T>,
-        T: NewService<Request = TcpStream, Response = ()> + 'static,
+        F: actix::IntoServiceFactory<T>,
+        T: actix::ServiceFactory<Config = (), Request = TcpStream> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -180,23 +220,32 @@ impl ServiceRuntime {
             self.services.insert(
                 token.clone(),
                 Box::new(ServiceFactory {
-                    inner: service.into_new_service(),
+                    inner: service.into_factory(),
                 }),
             );
         } else {
             panic!("Unknown service: {:?}", name);
         }
     }
+
+    /// Execute future before services initialization.
+    pub fn on_start<F>(&mut self, fut: F)
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        self.onstart.push(fut.boxed_local())
+    }
 }
 
 type BoxedNewService = Box<
-    NewService<
+    dyn actix::ServiceFactory<
         Request = (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         InitError = (),
+        Config = (),
         Service = BoxedServerService,
-        Future = Box<Future<Item = BoxedServerService, Error = ()>>,
+        Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>,
     >,
 >;
 
@@ -204,9 +253,9 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> NewService for ServiceFactory<T>
+impl<T> actix::ServiceFactory for ServiceFactory<T>
 where
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: actix::ServiceFactory<Config = (), Request = TcpStream>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
@@ -216,13 +265,21 @@ where
     type Response = ();
     type Error = ();
     type InitError = ();
+    type Config = ();
     type Service = BoxedServerService;
-    type Future = Box<Future<Item = BoxedServerService, Error = ()>>;
+    type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
 
-    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
-        }))
+    fn new_service(&self, _: ()) -> Self::Future {
+        let fut = self.inner.new_service(());
+        async move {
+            return match fut.await {
+                Ok(s) => Ok(Box::new(StreamService::new(s)) as BoxedServerService),
+                Err(e) => {
+                    error!("Can not construct service: {:?}", e);
+                    Err(())
+                }
+            };
+        }
+            .boxed_local()
     }
 }

actix-server/src/counter.rs

@@ -1,80 +0,0 @@
-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

@@ -1,19 +1,23 @@
 //! General purpose tcp server
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
 
 mod accept;
 mod builder;
 mod config;
-mod counter;
 mod server;
-mod services;
+mod service;
 mod signals;
-pub mod ssl;
+mod socket;
 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};
+pub use self::service::ServiceFactory;
+
+#[doc(hidden)]
+pub use self::socket::FromStream;
 
 /// Socket id token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -21,13 +25,13 @@ pub(crate) struct Token(usize);
 
 impl Token {
     pub(crate) fn next(&mut self) -> Token {
-        let token = Token(self.0 + 1);
+        let token = Token(self.0);
         self.0 += 1;
         token
     }
 }
 
 /// Start server building process
-pub fn build() -> ServerBuilder {
+pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }

actix-server/src/server.rs

@@ -1,12 +1,18 @@
-use futures::sync::mpsc::UnboundedSender;
-use futures::sync::oneshot;
-use futures::Future;
+use std::future::Future;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures::channel::mpsc::UnboundedSender;
+use futures::channel::oneshot;
+use futures::FutureExt;
 
 use crate::builder::ServerBuilder;
 use crate::signals::Signal;
 
+#[derive(Debug)]
 pub(crate) enum ServerCommand {
-    WorkerDied(usize),
+    WorkerFaulted(usize),
     Pause(oneshot::Sender<()>),
     Resume(oneshot::Sender<()>),
     Signal(Signal),
@@ -15,14 +21,19 @@ pub(crate) enum ServerCommand {
         graceful: bool,
         completion: Option<oneshot::Sender<()>>,
     },
+    /// Notify of server stop
+    Notify(oneshot::Sender<()>),
 }
 
-#[derive(Clone)]
-pub struct Server(UnboundedSender<ServerCommand>);
+#[derive(Debug)]
+pub struct Server(
+    UnboundedSender<ServerCommand>,
+    Option<oneshot::Receiver<()>>,
+);
 
 impl Server {
     pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
-        Server(tx)
+        Server(tx, None)
     }
 
     /// Start server building process
@@ -34,36 +45,64 @@ impl Server {
         let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
     }
 
-    pub(crate) fn worker_died(&self, idx: usize) {
-        let _ = self.0.unbounded_send(ServerCommand::WorkerDied(idx));
+    pub(crate) fn worker_faulted(&self, idx: usize) {
+        let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(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 = ()> {
+    pub fn pause(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
-        rx.map_err(|_| ())
+        rx.map(|_| ())
     }
 
     /// Resume accepting incoming connections
-    pub fn resume(&self) -> impl Future<Item = (), Error = ()> {
+    pub fn resume(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
-        rx.map_err(|_| ())
+        rx.map(|_| ())
     }
 
     /// 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 = ()> {
+    pub fn stop(&self, graceful: bool) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Stop {
             graceful,
             completion: Some(tx),
         });
-        rx.map_err(|_| ())
+        rx.map(|_| ())
+    }
+}
+
+impl Clone for Server {
+    fn clone(&self) -> Self {
+        Self(self.0.clone(), None)
+    }
+}
+
+impl Future for Server {
+    type Output = io::Result<()>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        if this.1.is_none() {
+            let (tx, rx) = oneshot::channel();
+            if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() {
+                return Poll::Ready(Ok(()));
+            }
+            this.1 = Some(rx);
+        }
+
+        match Pin::new(this.1.as_mut().unwrap()).poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
+            Poll::Ready(Err(_)) => Poll::Ready(Ok(())),
+        }
     }
 }

actix-server/src/service.rs

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

actix-server/src/services.rs

@@ -1,263 +0,0 @@
-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 log::error;
-use tokio_reactor::Handle;
-use tokio_tcp::TcpStream;
-
-use super::Token;
-use crate::counter::CounterGuard;
-
-/// Server message
-pub enum ServerMessage {
-    /// New stream
-    Connect(net::TcpStream),
-    /// Gracefull shutdown
-    Shutdown(Duration),
-    /// Force shutdown
-    ForceShutdown,
-}
-
-pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = TcpStream, Response = ()>;
-
-    fn create(&self) -> Self::NewService;
-}
-
-pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = ServerMessage, Response = ()>;
-
-    fn create(&self) -> Self::NewService;
-}
-
-pub(crate) trait InternalServiceFactory: Send {
-    fn name(&self, token: Token) -> &str;
-
-    fn clone_factory(&self) -> Box<InternalServiceFactory>;
-
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>;
-}
-
-pub(crate) type BoxedServerService = Box<
-    Service<
-        Request = (Option<CounterGuard>, ServerMessage),
-        Response = (),
-        Error = (),
-        Future = FutureResult<(), ()>,
-    >,
->;
-
-pub(crate) struct StreamService<T> {
-    service: T,
-}
-
-impl<T> StreamService<T> {
-    pub(crate) fn new(service: T) -> Self {
-        StreamService { service }
-    }
-}
-
-impl<T> Service for StreamService<T>
-where
-    T: Service<Request = TcpStream, Response = ()>,
-    T::Future: 'static,
-    T::Error: 'static,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type Future = FutureResult<(), ()>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|_| ())
-    }
-
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        match req {
-            ServerMessage::Connect(stream) => {
-                let stream = TcpStream::from_std(stream, &Handle::default()).map_err(|e| {
-                    error!("Can not convert to an async tcp stream: {}", e);
-                });
-
-                if let Ok(stream) = stream {
-                    spawn(self.service.call(stream).then(move |res| {
-                        drop(guard);
-                        res.map_err(|_| ())
-                    }));
-                    ok(())
-                } else {
-                    err(())
-                }
-            }
-            _ => ok(()),
-        }
-    }
-}
-
-pub(crate) struct ServerService<T> {
-    service: T,
-}
-
-impl<T> ServerService<T> {
-    fn new(service: T) -> Self {
-        ServerService { service }
-    }
-}
-
-impl<T> Service for ServerService<T>
-where
-    T: Service<Request = ServerMessage, Response = ()>,
-    T::Future: 'static,
-    T::Error: 'static,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type Future = FutureResult<(), ()>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|_| ())
-    }
-
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        spawn(self.service.call(req).then(move |res| {
-            drop(guard);
-            res.map_err(|_| ())
-        }));
-        ok(())
-    }
-}
-
-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, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, inner, token })
-    }
-}
-
-impl<F> InternalServiceFactory for ServiceNewService<F>
-where
-    F: ServiceFactory,
-{
-    fn name(&self, _: Token) -> &str {
-        &self.name
-    }
-
-    fn clone_factory(&self) -> Box<InternalServiceFactory> {
-        Box::new(Self {
-            name: self.name.clone(),
-            inner: self.inner.clone(),
-            token: self.token,
-        })
-    }
-
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        let token = self.token;
-        Box::new(
-            self.inner
-                .create()
-                .new_service()
-                .map_err(|_| ())
-                .map(move |inner| {
-                    let service: BoxedServerService = Box::new(ServerService::new(inner));
-                    vec![(token, service)]
-                }),
-        )
-    }
-}
-
-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, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, token, inner })
-    }
-}
-
-impl<F> InternalServiceFactory for StreamNewService<F>
-where
-    F: StreamServiceFactory,
-{
-    fn name(&self, _: Token) -> &str {
-        &self.name
-    }
-
-    fn clone_factory(&self) -> Box<InternalServiceFactory> {
-        Box::new(Self {
-            name: self.name.clone(),
-            inner: self.inner.clone(),
-            token: self.token,
-        })
-    }
-
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        let token = self.token;
-        Box::new(
-            self.inner
-                .create()
-                .new_service()
-                .map_err(|_| ())
-                .map(move |inner| {
-                    let service: BoxedServerService = Box::new(StreamService::new(inner));
-                    vec![(token, service)]
-                }),
-        )
-    }
-}
-
-impl InternalServiceFactory for Box<InternalServiceFactory> {
-    fn name(&self, token: Token) -> &str {
-        self.as_ref().name(token)
-    }
-
-    fn clone_factory(&self) -> Box<InternalServiceFactory> {
-        self.as_ref().clone_factory()
-    }
-
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        self.as_ref().create()
-    }
-}
-
-impl<F, T> ServiceFactory for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = ServerMessage, Response = ()>,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}
-
-impl<F, T> StreamServiceFactory for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = TcpStream, Response = ()>,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}

actix-server/src/signals.rs

@@ -1,12 +1,14 @@
+use std::future::Future;
 use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use actix_rt::spawn;
-use futures::stream::futures_unordered;
-use futures::{Async, Future, Poll, Stream};
+use futures::future::lazy;
 
 use crate::server::Server;
 
 /// Different types of process signals
+#[allow(dead_code)]
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub(crate) enum Signal {
     /// SIGHUP
@@ -22,97 +24,80 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    stream: SigStream,
+    stream: Pin<Box<dyn Future<Output = io::Result<()>>>>,
     #[cfg(unix)]
-    streams: Vec<SigStream>,
+    streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
 }
 
-type SigStream = Box<Stream<Item = Signal, Error = io::Error>>;
-
 impl Signals {
-    pub(crate) fn start(srv: Server) {
-        let fut = {
+    pub(crate) fn start(srv: Server) -> io::Result<()> {
+        actix_rt::spawn(lazy(|_| {
             #[cfg(not(unix))]
             {
-                tokio_signal::ctrl_c()
-                    .map_err(|_| ())
-                    .and_then(move |stream| Signals {
-                        srv,
-                        stream: Box::new(stream.map(|_| Signal::Int)),
-                    })
+                actix_rt::spawn(Signals {
+                    srv,
+                    stream: Box::pin(actix_rt::signal::ctrl_c()),
+                });
             }
-
             #[cfg(unix)]
             {
-                use tokio_signal::unix;
+                use actix_rt::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 })
+                let mut streams = Vec::new();
+
+                let sig_map = [
+                    (unix::SignalKind::interrupt(), Signal::Int),
+                    (unix::SignalKind::hangup(), Signal::Hup),
+                    (unix::SignalKind::terminate(), Signal::Term),
+                    (unix::SignalKind::quit(), Signal::Quit),
+                ];
+
+                for (kind, sig) in sig_map.iter() {
+                    match unix::signal(*kind) {
+                        Ok(stream) => streams.push((*sig, stream)),
+                        Err(e) => log::error!(
+                            "Can not initialize stream handler for {:?} err: {}",
+                            sig,
+                            e
+                        ),
+                    }
+                }
+
+                actix_rt::spawn(Signals { srv, streams })
             }
-        };
-        spawn(fut);
+        }));
+
+        Ok(())
     }
 }
 
 impl Future for Signals {
-    type Item = ();
-    type Error = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         #[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),
+        match Pin::new(&mut self.stream).poll(cx) {
+            Poll::Ready(_) => {
+                self.srv.signal(Signal::Int);
+                Poll::Ready(())
             }
+            Poll::Pending => return Poll::Pending,
         }
         #[cfg(unix)]
         {
-            for s in &mut self.streams {
+            for idx in 0..self.streams.len() {
                 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),
+                    match self.streams[idx].1.poll_recv(cx) {
+                        Poll::Ready(None) => return Poll::Ready(()),
+                        Poll::Pending => break,
+                        Poll::Ready(Some(_)) => {
+                            let sig = self.streams[idx].0;
+                            self.srv.signal(sig);
+                        }
                     }
                 }
             }
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }

actix-server/src/socket.rs

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

actix-server/src/ssl/nativetls.rs

@@ -1,166 +0,0 @@
-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 crate::counter::{Counter, CounterGuard};
-
-/// Support `SSL` connections via native-tls package
-///
-/// `tls` feature enables `NativeTlsAcceptor` type
-pub struct NativeTlsAcceptor<T> {
-    acceptor: TlsAcceptor,
-    io: PhantomData<T>,
-}
-
-impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
-    /// Create `NativeTlsAcceptor` instance
-    pub fn new(acceptor: TlsAcceptor) -> Self {
-        NativeTlsAcceptor {
-            acceptor,
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
-    fn clone(&self) -> Self {
-        Self {
-            acceptor: self.acceptor.clone(),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
-    type Request = T;
-    type Response = TlsStream<T>;
-    type Error = Error;
-    type Service = NativeTlsAcceptorService<T>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
-            ok(NativeTlsAcceptorService {
-                acceptor: self.acceptor.clone(),
-                conns: conns.clone(),
-                io: PhantomData,
-            })
-        })
-    }
-}
-
-pub struct NativeTlsAcceptorService<T> {
-    acceptor: TlsAcceptor,
-    io: PhantomData<T>,
-    conns: Counter,
-}
-
-impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
-    type Request = T;
-    type Response = TlsStream<T>;
-    type Error = Error;
-    type Future = Accept<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 {
-        Accept {
-            _guard: self.conns.get(),
-            inner: Some(self.acceptor.accept(req)),
-        }
-    }
-}
-
-/// A wrapper around an underlying raw stream which implements the TLS or SSL
-/// protocol.
-///
-/// A `TlsStream<S>` represents a handshake that has been completed successfully
-/// and both the server and the client are ready for receiving and sending
-/// data. Bytes read from a `TlsStream` are decrypted from `S` and bytes written
-/// to a `TlsStream` are encrypted when passing through to `S`.
-#[derive(Debug)]
-pub struct TlsStream<S> {
-    inner: native_tls::TlsStream<S>,
-}
-
-/// Future returned from `NativeTlsAcceptor::accept` which will resolve
-/// once the accept handshake has finished.
-pub struct Accept<S> {
-    inner: Option<Result<native_tls::TlsStream<S>, HandshakeError<S>>>,
-    _guard: CounterGuard,
-}
-
-impl<Io: AsyncRead + AsyncWrite> Future for Accept<Io> {
-    type Item = TlsStream<Io>;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.inner.take().expect("cannot poll MidHandshake twice") {
-            Ok(stream) => Ok(TlsStream { inner: stream }.into()),
-            Err(HandshakeError::Failure(e)) => Err(e),
-            Err(HandshakeError::WouldBlock(s)) => match s.handshake() {
-                Ok(stream) => Ok(TlsStream { inner: stream }.into()),
-                Err(HandshakeError::Failure(e)) => Err(e),
-                Err(HandshakeError::WouldBlock(s)) => {
-                    self.inner = Some(Err(HandshakeError::WouldBlock(s)));
-                    Ok(Async::NotReady)
-                }
-            },
-        }
-    }
-}
-
-impl<S> TlsStream<S> {
-    /// Get access to the internal `native_tls::TlsStream` stream which also
-    /// transitively allows access to `S`.
-    pub fn get_ref(&self) -> &native_tls::TlsStream<S> {
-        &self.inner
-    }
-
-    /// Get mutable access to the internal `native_tls::TlsStream` stream which
-    /// also transitively allows mutable access to `S`.
-    pub fn get_mut(&mut self) -> &mut native_tls::TlsStream<S> {
-        &mut self.inner
-    }
-}
-
-impl<S: io::Read + io::Write> io::Read for TlsStream<S> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.read(buf)
-    }
-}
-
-impl<S: io::Read + io::Write> io::Write for TlsStream<S> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.inner.flush()
-    }
-}
-
-impl<S: AsyncRead + AsyncWrite> AsyncRead for TlsStream<S> {}
-
-impl<S: AsyncRead + AsyncWrite> AsyncWrite for TlsStream<S> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        match self.inner.shutdown() {
-            Ok(_) => (),
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => (),
-            Err(e) => return Err(e),
-        }
-        self.inner.get_mut().shutdown()
-    }
-}

actix-server/src/ssl/openssl.rs

@@ -1,101 +0,0 @@
-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 for OpensslAcceptor<T> {
-    type Request = 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 for OpensslAcceptorService<T> {
-    type Request = 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

@@ -1,103 +0,0 @@
-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 crate::counter::{Counter, CounterGuard};
-
-/// Support `SSL` connections via rustls package
-///
-/// `rust-tls` feature enables `RustlsAcceptor` type
-pub struct RustlsAcceptor<T> {
-    config: Arc<ServerConfig>,
-    io: PhantomData<T>,
-}
-
-impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
-    /// Create `RustlsAcceptor` new service
-    pub fn new(config: ServerConfig) -> Self {
-        RustlsAcceptor {
-            config: Arc::new(config),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for RustlsAcceptor<T> {
-    fn clone(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
-    type Request = T;
-    type Response = TlsStream<T, ServerSession>;
-    type Error = io::Error;
-    type Service = RustlsAcceptorService<T>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
-            ok(RustlsAcceptorService {
-                acceptor: self.config.clone().into(),
-                conns: conns.clone(),
-                io: PhantomData,
-            })
-        })
-    }
-}
-
-pub struct RustlsAcceptorService<T> {
-    acceptor: TlsAcceptor,
-    io: PhantomData<T>,
-    conns: Counter,
-}
-
-impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
-    type Request = T;
-    type Response = TlsStream<T, ServerSession>;
-    type Error = io::Error;
-    type Future = RustlsAcceptorServiceFut<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 {
-        RustlsAcceptorServiceFut {
-            _guard: self.conns.get(),
-            fut: self.acceptor.accept(req),
-        }
-    }
-}
-
-pub struct RustlsAcceptorServiceFut<T>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    fut: Accept<T>,
-    _guard: CounterGuard,
-}
-
-impl<T: AsyncRead + AsyncWrite> Future for RustlsAcceptorServiceFut<T> {
-    type Item = TlsStream<T, ServerSession>;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll()
-    }
-}

actix-server/src/worker.rs

@@ -1,17 +1,21 @@
+use std::pin::Pin;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
-use std::{mem, net, time};
+use std::task::{Context, Poll};
+use std::time;
 
+use actix_rt::time::{delay_until, Delay, Instant};
 use actix_rt::{spawn, Arbiter};
-use futures::sync::mpsc::{UnboundedReceiver, UnboundedSender};
-use futures::sync::oneshot;
-use futures::{future, Async, Future, Poll, Stream};
+use actix_utils::counter::Counter;
+use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures::channel::oneshot;
+use futures::future::{join_all, LocalBoxFuture, MapOk};
+use futures::{Future, FutureExt, Stream, TryFutureExt};
 use log::{error, info, trace};
-use tokio_timer::{sleep, Delay};
 
 use crate::accept::AcceptNotify;
-use crate::counter::Counter;
-use crate::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::socket::{SocketAddr, StdStream};
 use crate::Token;
 
 pub(crate) struct WorkerCommand(Conn);
@@ -25,9 +29,9 @@ pub(crate) struct StopCommand {
 
 #[derive(Debug)]
 pub(crate) struct Conn {
-    pub io: net::TcpStream,
+    pub io: StdStream,
     pub token: Token,
-    pub peer: Option<net::SocketAddr>,
+    pub peer: Option<SocketAddr>,
 }
 
 static MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
@@ -124,100 +128,163 @@ impl WorkerAvailability {
 pub(crate) struct Worker {
     rx: UnboundedReceiver<WorkerCommand>,
     rx2: UnboundedReceiver<StopCommand>,
-    services: Vec<Option<(usize, BoxedServerService)>>,
+    services: Vec<WorkerService>,
     availability: WorkerAvailability,
     conns: Counter,
-    factories: Vec<Box<InternalServiceFactory>>,
+    factories: Vec<Box<dyn InternalServiceFactory>>,
     state: WorkerState,
     shutdown_timeout: time::Duration,
 }
 
+struct WorkerService {
+    factory: usize,
+    status: WorkerServiceStatus,
+    service: BoxedServerService,
+}
+
+impl WorkerService {
+    fn created(&mut self, service: BoxedServerService) {
+        self.service = service;
+        self.status = WorkerServiceStatus::Unavailable;
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum WorkerServiceStatus {
+    Available,
+    Unavailable,
+    Failed,
+    Restarting,
+    Stopping,
+    Stopped,
+}
+
 impl Worker {
     pub(crate) fn start(
-        rx: UnboundedReceiver<WorkerCommand>,
-        rx2: UnboundedReceiver<StopCommand>,
-        factories: Vec<Box<InternalServiceFactory>>,
+        idx: usize,
+        factories: Vec<Box<dyn 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,
-            services: Vec::new(),
-            conns: conns.clone(),
-            state: WorkerState::Unavailable(Vec::new()),
-        });
+    ) -> WorkerClient {
+        let (tx1, rx) = unbounded();
+        let (tx2, rx2) = unbounded();
+        let avail = availability.clone();
 
-        let mut fut = Vec::new();
-        for (idx, factory) in wrk.factories.iter().enumerate() {
-            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().stop();
-                })
-                .and_then(move |services| {
-                    for item in services {
-                        for (idx, token, service) in item {
-                            while token.0 >= wrk.services.len() {
-                                wrk.services.push(None);
+        Arbiter::new().send(
+            async move {
+                availability.set(false);
+                let mut wrk = MAX_CONNS_COUNTER.with(move |conns| Worker {
+                    rx,
+                    rx2,
+                    availability,
+                    factories,
+                    shutdown_timeout,
+                    services: Vec::new(),
+                    conns: conns.clone(),
+                    state: WorkerState::Unavailable(Vec::new()),
+                });
+
+                let mut fut: Vec<MapOk<LocalBoxFuture<'static, _>, _>> = Vec::new();
+                for (idx, factory) in wrk.factories.iter().enumerate() {
+                    fut.push(factory.create().map_ok(move |r| {
+                        r.into_iter()
+                            .map(|(t, s): (Token, _)| (idx, t, s))
+                            .collect::<Vec<_>>()
+                    }));
+                }
+
+                spawn(async move {
+                    let res = join_all(fut).await;
+                    let res: Result<Vec<_>, _> = res.into_iter().collect();
+                    match res {
+                        Ok(services) => {
+                            for item in services {
+                                for (factory, token, service) in item {
+                                    assert_eq!(token.0, wrk.services.len());
+                                    wrk.services.push(WorkerService {
+                                        factory,
+                                        service,
+                                        status: WorkerServiceStatus::Unavailable,
+                                    });
+                                }
                             }
-                            wrk.services[token.0] = Some((idx, service));
+                        }
+                        Err(e) => {
+                            error!("Can not start worker: {:?}", e);
+                            Arbiter::current().stop();
                         }
                     }
-                    wrk
-                }),
+                    wrk.await
+                });
+            }
+                .boxed(),
         );
+
+        WorkerClient::new(idx, tx1, tx2, avail)
     }
 
     fn shutdown(&mut self, force: bool) {
         if force {
-            self.services.iter_mut().for_each(|h| {
-                if let Some(h) = h {
-                    let _ = h.1.call((None, ServerMessage::ForceShutdown));
+            self.services.iter_mut().for_each(|srv| {
+                if srv.status == WorkerServiceStatus::Available {
+                    srv.status = WorkerServiceStatus::Stopped;
+                    actix_rt::spawn(
+                        srv.service
+                            .call((None, ServerMessage::ForceShutdown))
+                            .map(|_| ()),
+                    );
                 }
             });
         } else {
             let timeout = self.shutdown_timeout;
-            self.services.iter_mut().for_each(move |h| {
-                if let Some(h) = h {
-                    let _ = h.1.call((None, ServerMessage::Shutdown(timeout)));
+            self.services.iter_mut().for_each(move |srv| {
+                if srv.status == WorkerServiceStatus::Available {
+                    srv.status = WorkerServiceStatus::Stopping;
+                    actix_rt::spawn(
+                        srv.service
+                            .call((None, ServerMessage::Shutdown(timeout)))
+                            .map(|_| ()),
+                    );
                 }
             });
         }
     }
 
-    fn check_readiness(&mut self, trace: bool) -> Result<bool, (Token, usize)> {
-        let mut ready = self.conns.available();
+    fn check_readiness(&mut self, cx: &mut Context<'_>) -> Result<bool, (Token, usize)> {
+        let mut ready = self.conns.available(cx);
         let mut failed = None;
-        for (token, service) in &mut self.services.iter_mut().enumerate() {
-            if let Some(service) = service {
-                match service.1.poll_ready() {
-                    Ok(Async::Ready(_)) => {
-                        if trace {
+        for (idx, srv) in &mut self.services.iter_mut().enumerate() {
+            if srv.status == WorkerServiceStatus::Available
+                || srv.status == WorkerServiceStatus::Unavailable
+            {
+                match srv.service.poll_ready(cx) {
+                    Poll::Ready(Ok(_)) => {
+                        if srv.status == WorkerServiceStatus::Unavailable {
                             trace!(
                                 "Service {:?} is available",
-                                self.factories[service.0].name(Token(token))
+                                self.factories[srv.factory].name(Token(idx))
                             );
+                            srv.status = WorkerServiceStatus::Available;
                         }
                     }
-                    Ok(Async::NotReady) => ready = false,
-                    Err(_) => {
+                    Poll::Pending => {
+                        ready = false;
+
+                        if srv.status == WorkerServiceStatus::Available {
+                            trace!(
+                                "Service {:?} is unavailable",
+                                self.factories[srv.factory].name(Token(idx))
+                            );
+                            srv.status = WorkerServiceStatus::Unavailable;
+                        }
+                    }
+                    Poll::Ready(Err(_)) => {
                         error!(
                             "Service {:?} readiness check returned error, restarting",
-                            self.factories[service.0].name(Token(token))
+                            self.factories[srv.factory].name(Token(idx))
                         );
-                        failed = Some((Token(token), service.0));
+                        failed = Some((Token(idx), srv.factory));
+                        srv.status = WorkerServiceStatus::Failed;
                     }
                 }
             }
@@ -231,175 +298,163 @@ impl Worker {
 }
 
 enum WorkerState {
-    None,
     Available,
     Unavailable(Vec<Conn>),
     Restarting(
         usize,
         Token,
-        Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>,
+        Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
+    ),
+    Shutdown(
+        Pin<Box<Delay>>,
+        Pin<Box<Delay>>,
+        Option<oneshot::Sender<bool>>,
     ),
-    Shutdown(Delay, Delay, oneshot::Sender<bool>),
 }
 
 impl Future for Worker {
-    type Item = ();
-    type Error = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // `StopWorker` message handler
-        if let Ok(Async::Ready(Some(StopCommand { graceful, result }))) = self.rx2.poll() {
+        if let Poll::Ready(Some(StopCommand { graceful, result })) =
+            Pin::new(&mut self.rx2).poll_next(cx)
+        {
             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(()));
+                return Poll::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,
+                        Box::pin(delay_until(Instant::now() + time::Duration::from_secs(1))),
+                        Box::pin(delay_until(Instant::now() + self.shutdown_timeout)),
+                        Some(result),
                     );
                 } else {
                     let _ = result.send(true);
-                    return Ok(Async::Ready(()));
+                    return Poll::Ready(());
                 }
             } else {
                 info!("Force shutdown worker, {} connections", num);
                 self.shutdown(true);
                 let _ = result.send(false);
-                return Ok(Async::Ready(()));
+                return Poll::Ready(());
             }
         }
 
-        let state = mem::replace(&mut self.state, WorkerState::None);
-
-        match state {
-            WorkerState::Unavailable(mut conns) => {
-                match self.check_readiness(true) {
+        match self.state {
+            WorkerState::Unavailable(ref mut conns) => {
+                let conn = conns.pop();
+                match self.check_readiness(cx) {
                     Ok(true) => {
-                        self.state = WorkerState::Available;
-
                         // process requests from wait queue
-                        while let Some(msg) = conns.pop() {
-                            match self.check_readiness(false) {
-                                Ok(true) => {
-                                    let guard = self.conns.get();
-                                    let _ = self.services[msg.token.0]
-                                        .as_mut()
-                                        .expect("actix net bug")
-                                        .1
-                                        .call((Some(guard), ServerMessage::Connect(msg.io)));
-                                }
-                                Ok(false) => {
-                                    trace!("Worker is unavailable");
-                                    self.state = WorkerState::Unavailable(conns);
-                                    return self.poll();
-                                }
-                                Err((token, idx)) => {
-                                    trace!(
-                                        "Service {:?} failed, restarting",
-                                        self.factories[idx].name(token)
-                                    );
-                                    self.state = WorkerState::Restarting(
-                                        idx,
-                                        token,
-                                        self.factories[idx].create(),
-                                    );
-                                    return self.poll();
-                                }
-                            }
+                        if let Some(conn) = conn {
+                            let guard = self.conns.get();
+                            let _ = self.services[conn.token.0]
+                                .service
+                                .call((Some(guard), ServerMessage::Connect(conn.io)));
+                        } else {
+                            self.state = WorkerState::Available;
+                            self.availability.set(true);
                         }
-                        self.availability.set(true);
-                        return self.poll();
+                        self.poll(cx)
                     }
                     Ok(false) => {
-                        self.state = WorkerState::Unavailable(conns);
-                        return Ok(Async::NotReady);
+                        // push connection back to queue
+                        if let Some(conn) = conn {
+                            match self.state {
+                                WorkerState::Unavailable(ref mut conns) => {
+                                    conns.push(conn);
+                                }
+                                _ => (),
+                            }
+                        }
+                        Poll::Pending
                     }
                     Err((token, idx)) => {
                         trace!(
                             "Service {:?} failed, restarting",
                             self.factories[idx].name(token)
                         );
+                        self.services[token.0].status = WorkerServiceStatus::Restarting;
                         self.state =
                             WorkerState::Restarting(idx, token, self.factories[idx].create());
-                        return self.poll();
+                        self.poll(cx)
                     }
                 }
             }
-            WorkerState::Restarting(idx, token, mut fut) => {
-                match fut.poll() {
-                    Ok(Async::Ready(item)) => {
+            WorkerState::Restarting(idx, token, ref mut fut) => {
+                match Pin::new(fut).poll(cx) {
+                    Poll::Ready(Ok(item)) => {
                         for (token, service) in item {
                             trace!(
                                 "Service {:?} has been restarted",
                                 self.factories[idx].name(token)
                             );
-                            self.services[token.0] = Some((idx, service));
+                            self.services[token.0].created(service);
                             self.state = WorkerState::Unavailable(Vec::new());
+                            return self.poll(cx);
                         }
                     }
-                    Ok(Async::NotReady) => {
-                        self.state = WorkerState::Restarting(idx, token, fut);
-                        return Ok(Async::NotReady);
-                    }
-                    Err(_) => {
+                    Poll::Ready(Err(_)) => {
                         panic!(
                             "Can not restart {:?} service",
                             self.factories[idx].name(token)
                         );
                     }
+                    Poll::Pending => {
+                        return Poll::Pending;
+                    }
                 }
-                return self.poll();
+                self.poll(cx)
             }
-            WorkerState::Shutdown(mut t1, mut t2, tx) => {
+            WorkerState::Shutdown(ref mut t1, ref mut t2, ref mut tx) => {
                 let num = num_connections();
                 if num == 0 {
-                    let _ = tx.send(true);
+                    let _ = tx.take().unwrap().send(true);
                     Arbiter::current().stop();
-                    return Ok(Async::Ready(()));
+                    return Poll::Ready(());
                 }
 
                 // check graceful timeout
-                match t2.poll().unwrap() {
-                    Async::NotReady => (),
-                    Async::Ready(_) => {
+                match t2.as_mut().poll(cx) {
+                    Poll::Pending => (),
+                    Poll::Ready(_) => {
+                        let _ = tx.take().unwrap().send(false);
                         self.shutdown(true);
-                        let _ = tx.send(false);
                         Arbiter::current().stop();
-                        return Ok(Async::Ready(()));
+                        return Poll::Ready(());
                     }
                 }
 
                 // sleep for 1 second and then check again
-                match t1.poll().unwrap() {
-                    Async::NotReady => (),
-                    Async::Ready(_) => {
-                        t1 = sleep(time::Duration::from_secs(1));
-                        let _ = t1.poll();
+                match t1.as_mut().poll(cx) {
+                    Poll::Pending => (),
+                    Poll::Ready(_) => {
+                        *t1 = Box::pin(delay_until(
+                            Instant::now() + time::Duration::from_secs(1),
+                        ));
+                        let _ = t1.as_mut().poll(cx);
                     }
                 }
-                self.state = WorkerState::Shutdown(t1, t2, tx);
-                return Ok(Async::NotReady);
+                Poll::Pending
             }
             WorkerState::Available => {
                 loop {
-                    match self.rx.poll() {
-                        // handle incoming tcp stream
-                        Ok(Async::Ready(Some(WorkerCommand(msg)))) => {
-                            match self.check_readiness(false) {
+                    match Pin::new(&mut self.rx).poll_next(cx) {
+                        // handle incoming io stream
+                        Poll::Ready(Some(WorkerCommand(msg))) => {
+                            match self.check_readiness(cx) {
                                 Ok(true) => {
                                     let guard = self.conns.get();
                                     let _ = self.services[msg.token.0]
-                                        .as_mut()
-                                        .expect("actix-server bug")
-                                        .1
+                                        .service
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                     continue;
                                 }
@@ -414,6 +469,8 @@ impl Future for Worker {
                                         self.factories[idx].name(token)
                                     );
                                     self.availability.set(false);
+                                    self.services[token.0].status =
+                                        WorkerServiceStatus::Restarting;
                                     self.state = WorkerState::Restarting(
                                         idx,
                                         token,
@@ -421,17 +478,16 @@ impl Future for Worker {
                                     );
                                 }
                             }
-                            return self.poll();
+                            return self.poll(cx);
                         }
-                        Ok(Async::NotReady) => {
+                        Poll::Pending => {
                             self.state = WorkerState::Available;
-                            return Ok(Async::NotReady);
+                            return Poll::Pending;
                         }
-                        Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                        Poll::Ready(None) => return Poll::Ready(()),
                     }
                 }
             }
-            WorkerState::None => panic!(),
-        };
+        }
     }
 }

actix-server/tests/test_server.rs

@@ -0,0 +1,183 @@
+use std::io::Read;
+use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::{mpsc, Arc};
+use std::{net, thread, time};
+
+use actix_codec::{BytesCodec, Framed};
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::fn_service;
+use bytes::Bytes;
+use futures::future::{lazy, ok};
+use futures::SinkExt;
+use net2::TcpBuilder;
+
+fn unused_addr() -> net::SocketAddr {
+    let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+    let socket = TcpBuilder::new_v4().unwrap();
+    socket.bind(&addr).unwrap();
+    socket.reuse_address(true).unwrap();
+    let tcp = socket.to_tcp_listener().unwrap();
+    tcp.local_addr().unwrap()
+}
+
+#[test]
+fn test_bind() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .workers(1)
+            .disable_signals()
+            .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
+            .unwrap()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+fn test_listen() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let lst = net::TcpListener::bind(addr).unwrap();
+        Server::build()
+            .disable_signals()
+            .workers(1)
+            .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
+            .unwrap()
+            .start();
+        let _ = tx.send(actix_rt::System::current());
+        let _ = sys.run();
+    });
+    let sys = rx.recv().unwrap();
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_start() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv: Server = Server::build()
+            .backlog(100)
+            .disable_signals()
+            .bind("test", addr, move || {
+                fn_service(|io: TcpStream| {
+                    async move {
+                        let mut f = Framed::new(io, BytesCodec);
+                        f.send(Bytes::from_static(b"test")).await.unwrap();
+                        Ok::<_, ()>(())
+                    }
+                })
+            })
+            .unwrap()
+            .start();
+
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (srv, sys) = rx.recv().unwrap();
+
+    let mut buf = [1u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // pause
+    let _ = srv.pause();
+    thread::sleep(time::Duration::from_millis(200));
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    conn.set_read_timeout(Some(time::Duration::from_millis(100)))
+        .unwrap();
+    let res = conn.read_exact(&mut buf);
+    assert!(res.is_err());
+
+    // resume
+    let _ = srv.resume();
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+
+    let mut buf = [0u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // stop
+    let _ = srv.stop(false);
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_err());
+
+    thread::sleep(time::Duration::from_millis(100));
+    let _ = sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+fn test_configure() {
+    let addr1 = unused_addr();
+    let addr2 = unused_addr();
+    let addr3 = unused_addr();
+    let (tx, rx) = mpsc::channel();
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let h = thread::spawn(move || {
+        let num = num2.clone();
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .disable_signals()
+            .configure(move |cfg| {
+                let num = num.clone();
+                let lst = net::TcpListener::bind(addr3).unwrap();
+                cfg.bind("addr1", addr1)
+                    .unwrap()
+                    .bind("addr2", addr2)
+                    .unwrap()
+                    .listen("addr3", lst)
+                    .apply(move |rt| {
+                        let num = num.clone();
+                        rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
+                        rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
+                        rt.on_start(lazy(move |_| {
+                            let _ = num.fetch_add(1, Relaxed);
+                        }))
+                    })
+            })
+            .unwrap()
+            .workers(1)
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+    thread::sleep(time::Duration::from_millis(500));
+
+    assert!(net::TcpStream::connect(addr1).is_ok());
+    assert!(net::TcpStream::connect(addr2).is_ok());
+    assert!(net::TcpStream::connect(addr3).is_ok());
+    assert_eq!(num.load(Relaxed), 1);
+    let _ = sys.stop();
+    let _ = h.join();
+}

actix-service/CHANGES.md

@@ -1,5 +1,172 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+### Added
+
+* Add Clone impl for Apply service
+
+
+## [1.0.0-alpha.4] - 2019-12-08
+
+### Changed
+
+* Renamed `service_fn` to `fn_service`
+
+* Renamed `factory_fn` to `fn_factory`
+
+* Renamed `factory_fn_cfg` to `fn_factory_with_config`
+
+
+## [1.0.0-alpha.3] - 2019-12-06
+
+### Changed
+
+* Add missing Clone impls
+
+* Restore `Transform::map_init_err()` combinator
+
+* Restore `Service/Factory::apply_fn()` in form of `Pipeline/Factory::and_then_apply_fn()`
+
+* Optimize service combinators and futures memory layout
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+### Changed
+
+* Use owned config value for service factory
+
+* Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
+
+
+## [1.0.0-alpha.1] - 2019-11-25
+
+### Changed
+
+* Migraded to `std::future`
+
+* `NewService` renamed to `ServiceFactory`
+
+* Added `pipeline` and `pipeline_factory` function
+
+
+## [0.4.2] - 2019-08-27
+
+### Fixed
+
+* Check service readiness for `new_apply_cfg` combinator
+
+
+## [0.4.1] - 2019-06-06
+
+### Added
+
+* Add `new_apply_cfg` function
+
+## [0.4.0] - 2019-05-12
+
+### Changed
+
+* Use associated type for `NewService` config
+
+* Change `apply_cfg` function
+
+* Renamed helper functions
+
+### Added
+
+* Add `NewService::map_config` and `NewService::unit_config` combinators
+
+
+## [0.3.6] - 2019-04-07
+
+### Changed
+
+* Poll boxed service call result immediately
+
+
+## [0.3.5] - 2019-03-29
+
+### Added
+
+* Add `impl<S: Service> Service for Rc<RefCell<S>>`
+
+
+## [0.3.4] - 2019-03-12
+
+### Added
+
+* Add `Transform::from_err()` combinator
+
+* Add `apply_fn` helper
+
+* Add `apply_fn_factory` helper
+
+* Add `apply_transform` helper
+
+* Add `apply_cfg` helper
+
+
+## [0.3.3] - 2019-03-09
+
+### Added
+
+* Add `ApplyTransform` new service for transform and new service.
+
+* Add `NewService::apply_cfg()` combinator, allows to use
+  nested `NewService` with different config parameter.
+
+### Changed
+
+* Revert IntoFuture change
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+
+* Export `AndThenTransform` type
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Simplify Transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+## Added
+
+* Added boxed NewService and Service.
+
+## Changed
+
+* Added `Config` parameter to `NewService` trait.
+
+* Added `Config` parameter to `NewTransform` trait.
+
+
+## [0.2.2] - 2019-02-19
+
+### Added
+
+* Added `NewService` impl for `Rc<S> where S: NewService`
+
+* Added `NewService` impl for `Arc<S> where S: NewService`
+
+
+## [0.2.1] - 2019-02-03
+
+### Changed
+
+* Generalize `.apply` combinator with Transform trait
+
+
 ## [0.2.0] - 2019-02-01
 
 ### Changed

actix-service/Cargo.toml

@@ -1,17 +1,16 @@
 [package]
 name = "actix-service"
-version = "0.2.0"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Service"
+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 = "../"
+workspace = ".."
 
 [badges]
 travis-ci = { repository = "actix/actix-service", branch = "master" }
@@ -23,4 +22,8 @@ name = "actix_service"
 path = "src/lib.rs"
 
 [dependencies]
-futures = "0.1.24"
+futures-util = "0.3.1"
+pin-project = "0.4.6"
+
+[dev-dependencies]
+actix-rt = "1.0.0"

actix-service/LICENSE-APACHE

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

actix-service/LICENSE-MIT

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

actix-service/src/and_then.rs

@@ -1,41 +1,34 @@
-use futures::{try_ready, Async, Future, Poll};
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use super::{IntoNewService, NewService, Service};
+use super::{Service, ServiceFactory};
 use crate::cell::Cell;
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
 /// This is created by the `ServiceExt::and_then` method.
-pub struct AndThen<A, B> {
-    a: A,
-    b: Cell<B>,
-}
+pub struct AndThenService<A, B>(Cell<(A, B)>);
 
-impl<A, B> AndThen<A, B> {
+impl<A, B> AndThenService<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new(a: A, b: B) -> Self
+    pub(crate) fn new(a: A, b: B) -> Self
     where
         A: Service,
         B: Service<Request = A::Response, Error = A::Error>,
     {
-        Self { a, b: Cell::new(b) }
+        Self(Cell::new((a, b)))
     }
 }
 
-impl<A, B> Clone for AndThen<A, B>
-where
-    A: Clone,
-{
+impl<A, B> Clone for AndThenService<A, B> {
     fn clone(&self) -> Self {
-        AndThen {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
+        AndThenService(self.0.clone())
     }
 }
 
-impl<A, B> Service for AndThen<A, B>
+impl<A, B> Service for AndThenService<A, B>
 where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
@@ -43,109 +36,150 @@ where
     type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B>;
+    type Future = AndThenServiceResponse<A, B>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.a.poll_ready());
-        self.b.get_mut().poll_ready()
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let srv = self.0.get_mut();
+
+        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
+            Poll::Pending
+        } else {
+            Poll::Ready(Ok(()))
+        }
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
-        AndThenFuture::new(self.a.call(req), self.b.clone())
-    }
-}
-
-pub struct AndThenFuture<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    b: Cell<B>,
-    fut_b: Option<B::Future>,
-    fut_a: Option<A::Future>,
-}
-
-impl<A, B> AndThenFuture<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    fn new(a: A::Future, b: Cell<B>) -> Self {
-        AndThenFuture {
-            b,
-            fut_a: Some(a),
-            fut_b: None,
+        AndThenServiceResponse {
+            state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())),
         }
     }
 }
 
-impl<A, B> Future for AndThenFuture<A, B>
+#[pin_project::pin_project]
+pub struct AndThenServiceResponse<A, B>
 where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
 {
-    type Item = B::Response;
-    type Error = A::Error;
+    #[pin]
+    state: State<A, B>,
+}
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut_b {
-            return fut.poll();
-        }
+#[pin_project::pin_project]
+enum State<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    A(#[pin] A::Future, Option<Cell<(A, B)>>),
+    B(#[pin] B::Future),
+    Empty,
+}
 
-        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
-            Ok(Async::Ready(resp)) => {
-                let _ = self.fut_a.take();
-                self.fut_b = Some(self.b.get_mut().call(resp));
-                self.poll()
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(err) => Err(err),
+impl<A, B> Future for AndThenServiceResponse<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    type Output = Result<B::Response, A::Error>;
+
+    #[pin_project::project]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let mut b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = b.get_mut().1.call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            State::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
         }
     }
 }
 
-/// `AndThenNewService` new service combinator
-pub struct AndThenNewService<A, B> {
+/// `.and_then()` service factory combinator
+pub struct AndThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
     a: A,
     b: B,
 }
 
-impl<A, B> AndThenNewService<A, B> {
-    /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self
-    where
-        A: NewService,
-        B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
-    {
-        Self {
-            a,
-            b: f.into_new_service(),
-        }
+impl<A, B> AndThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    /// Create new `AndThenFactory` combinator
+    pub(crate) fn new(a: A, b: B) -> Self {
+        Self { a, b }
     }
 }
 
-impl<A, B> NewService for AndThenNewService<A, B>
+impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
 where
-    A: NewService,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Service = AndThen<A::Service, B::Service>;
 
+    type Config = A::Config;
+    type Service = AndThenService<A::Service, B::Service>;
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B>;
+    type Future = AndThenServiceFactoryResponse<A, B>;
 
-    fn new_service(&self) -> Self::Future {
-        AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        AndThenServiceFactoryResponse::new(
+            self.a.new_service(cfg.clone()),
+            self.b.new_service(cfg),
+        )
     }
 }
 
-impl<A, B> Clone for AndThenNewService<A, B>
+impl<A, B> Clone for AndThenServiceFactory<A, B>
 where
-    A: Clone,
-    B: Clone,
+    A: ServiceFactory + Clone,
+    A::Config: Clone,
+    B: ServiceFactory<
+            Config = A::Config,
+            Request = A::Response,
+            Error = A::Error,
+            InitError = A::InitError,
+        > + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -155,24 +189,28 @@ where
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B>
+#[pin_project::pin_project]
+pub struct AndThenServiceFactoryResponse<A, B>
 where
-    A: NewService,
-    B: NewService<Request = A::Response>,
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response>,
 {
-    fut_b: B::Future,
+    #[pin]
     fut_a: A::Future,
+    #[pin]
+    fut_b: B::Future,
+
     a: Option<A::Service>,
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenNewServiceFuture<A, B>
+impl<A, B> AndThenServiceFactoryResponse<A, B>
 where
-    A: NewService,
-    B: NewService<Request = A::Response>,
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
-        AndThenNewServiceFuture {
+        AndThenServiceFactoryResponse {
             fut_a,
             fut_b,
             a: None,
@@ -181,58 +219,58 @@ where
     }
 }
 
-impl<A, B> Future for AndThenNewServiceFuture<A, B>
+impl<A, B> Future for AndThenServiceFactoryResponse<A, B>
 where
-    A: NewService,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Item = AndThen<A::Service, B::Service>;
-    type Error = A::InitError;
+    type Output = Result<AndThenService<A::Service, B::Service>, A::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if self.a.is_none() {
-            if let Async::Ready(service) = self.fut_a.poll()? {
-                self.a = Some(service);
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        if this.a.is_none() {
+            if let Poll::Ready(service) = this.fut_a.poll(cx)? {
+                *this.a = Some(service);
             }
         }
-
-        if self.b.is_none() {
-            if let Async::Ready(service) = self.fut_b.poll()? {
-                self.b = Some(service);
+        if this.b.is_none() {
+            if let Poll::Ready(service) = this.fut_b.poll(cx)? {
+                *this.b = Some(service);
             }
         }
-
-        if self.a.is_some() && self.b.is_some() {
-            Ok(Async::Ready(AndThen::new(
-                self.a.take().unwrap(),
-                self.b.take().unwrap(),
+        if this.a.is_some() && this.b.is_some() {
+            Poll::Ready(Ok(AndThenService::new(
+                this.a.take().unwrap(),
+                this.b.take().unwrap(),
             )))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Poll};
     use std::cell::Cell;
     use std::rc::Rc;
+    use std::task::{Context, Poll};
 
-    use super::*;
-    use crate::{NewService, Service, ServiceExt};
+    use futures_util::future::{lazy, ok, ready, Ready};
+
+    use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory};
 
     struct Srv1(Rc<Cell<usize>>);
+
     impl Service for Srv1 {
         type Request = &'static str;
         type Response = &'static str;
         type Error = ();
-        type Future = FutureResult<Self::Response, ()>;
+        type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             self.0.set(self.0.get() + 1);
-            Ok(Async::Ready(()))
+            Poll::Ready(Ok(()))
         }
 
         fn call(&mut self, req: &'static str) -> Self::Future {
@@ -247,11 +285,11 @@ mod tests {
         type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
-        type Future = FutureResult<Self::Response, ()>;
+        type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             self.0.set(self.0.get() + 1);
-            Ok(Async::Ready(()))
+            Poll::Ready(Ok(()))
         }
 
         fn call(&mut self, req: &'static str) -> Self::Future {
@@ -259,39 +297,35 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_poll_ready() {
+    #[actix_rt::test]
+    async fn test_poll_ready() {
         let cnt = Rc::new(Cell::new(0));
-        let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt.clone()));
-        let res = srv.poll_ready();
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(()));
+        let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone()));
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
         assert_eq!(cnt.get(), 2);
     }
 
-    #[test]
-    fn test_call() {
+    #[actix_rt::test]
+    async fn test_call() {
         let cnt = Rc::new(Cell::new(0));
-        let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt));
-        let res = srv.call("srv1").poll();
+        let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
+        let res = srv.call("srv1").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));
+        assert_eq!(res.unwrap(), (("srv1", "srv2")));
     }
 
-    #[test]
-    fn test_new_service() {
+    #[actix_rt::test]
+    async fn test_new_service() {
         let cnt = Rc::new(Cell::new(0));
         let cnt2 = cnt.clone();
-        let blank = move || Ok::<_, ()>(Srv1(cnt2.clone()));
-        let new_srv = blank
-            .into_new_service()
-            .and_then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            let res = srv.call("srv1").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));
-        } else {
-            panic!()
-        }
+        let new_srv =
+            pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
+                .and_then(move || ready(Ok(Srv2(cnt.clone()))));
+
+        let mut srv = new_srv.new_service(()).await.unwrap();
+        let res = srv.call("srv1").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv1", "srv2"));
     }
 }

actix-service/src/and_then_apply.rs

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

actix-service/src/and_then_apply_fn.rs

@@ -0,0 +1,334 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::cell::Cell;
+use crate::{Service, ServiceFactory};
+
+/// `Apply` service combinator
+pub struct AndThenApplyFn<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    a: A,
+    b: Cell<(B, F)>,
+    r: PhantomData<(Fut, Res, Err)>,
+}
+
+impl<A, B, F, Fut, Res, Err> AndThenApplyFn<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    /// Create new `Apply` combinator
+    pub(crate) fn new(a: A, b: B, f: F) -> Self {
+        Self {
+            a,
+            b: Cell::new((b, f)),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
+where
+    A: Service + Clone,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    fn clone(&self) -> Self {
+        AndThenApplyFn {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Service for AndThenApplyFn<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    type Request = A::Request;
+    type Response = Res;
+    type Error = Err;
+    type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let not_ready = self.a.poll_ready(cx)?.is_pending();
+        if self.b.get_mut().0.poll_ready(cx)?.is_pending() || not_ready {
+            Poll::Pending
+        } else {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        AndThenApplyFnFuture {
+            state: State::A(self.a.call(req), Some(self.b.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error>,
+    Err: From<B::Error>,
+{
+    #[pin]
+    state: State<A, B, F, Fut, Res, Err>,
+}
+
+#[pin_project::pin_project]
+enum State<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error>,
+    Err: From<B::Error>,
+{
+    A(#[pin] A::Future, Option<Cell<(B, F)>>),
+    B(#[pin] Fut),
+    Empty,
+}
+
+impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
+where
+    A: Service,
+    B: Service,
+    F: FnMut(A::Response, &mut B) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    type Output = Result<Res, Err>;
+
+    #[pin_project::project]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let mut b = b.take().unwrap();
+                    this.state.set(State::Empty);
+                    let b = b.get_mut();
+                    let fut = (&mut b.1)(res, &mut b.0);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            State::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+        }
+    }
+}
+
+/// `AndThenApplyFn` service factory
+pub struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+    a: A,
+    b: B,
+    f: F,
+    r: PhantomData<(Fut, Res, Err)>,
+}
+
+impl<A, B, F, Fut, Res, Err> AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub(crate) fn new(a: A, b: B, f: F) -> Self {
+        Self {
+            a: a,
+            b: b,
+            f: f,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+where
+    A: Clone,
+    B: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> ServiceFactory for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    type Request = A::Request;
+    type Response = Res;
+    type Error = Err;
+    type Service = AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>;
+    type Config = A::Config;
+    type InitError = A::InitError;
+    type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        AndThenApplyFnFactoryResponse {
+            a: None,
+            b: None,
+            f: self.f.clone(),
+            fut_a: self.a.new_service(cfg.clone()),
+            fut_b: self.b.new_service(cfg),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error>,
+    Err: From<B::Error>,
+{
+    #[pin]
+    fut_b: B::Future,
+    #[pin]
+    fut_a: A::Future,
+    f: F,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+    Err: From<A::Error> + From<B::Error>,
+{
+    type Output =
+        Result<AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>, A::InitError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        if this.a.is_none() {
+            if let Poll::Ready(service) = this.fut_a.poll(cx)? {
+                *this.a = Some(service);
+            }
+        }
+
+        if this.b.is_none() {
+            if let Poll::Ready(service) = this.fut_b.poll(cx)? {
+                *this.b = Some(service);
+            }
+        }
+
+        if this.a.is_some() && this.b.is_some() {
+            Poll::Ready(Ok(AndThenApplyFn {
+                a: this.a.take().unwrap(),
+                b: Cell::new((this.b.take().unwrap(), this.f.clone())),
+                r: PhantomData,
+            }))
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use futures_util::future::{lazy, ok, Ready, TryFutureExt};
+
+    use crate::{fn_service, pipeline, pipeline_factory, Service, ServiceFactory};
+
+    #[derive(Clone)]
+    struct Srv;
+    impl Service for Srv {
+        type Request = ();
+        type Response = ();
+        type Error = ();
+        type Future = Ready<Result<(), ()>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, req: Self::Request) -> Self::Future {
+            ok(req)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let mut srv = pipeline(|r: &'static str| ok(r))
+            .and_then_apply_fn(Srv, |req: &'static str, s| {
+                s.call(()).map_ok(move |res| (req, res))
+            });
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv", ()));
+    }
+
+    #[actix_rt::test]
+    async fn test_service_factory() {
+        let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(|r: &'static str| ok(r))))
+            .and_then_apply_fn(
+                || ok(Srv),
+                |req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
+            );
+        let mut srv = new_srv.new_service(()).await.unwrap();
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv", ()));
+    }
+}

actix-service/src/apply.rs

@@ -1,40 +1,66 @@
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use futures::{Async, Future, IntoFuture, Poll};
+use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+/// Apply tranform function to a service.
+pub fn apply_fn<T, F, R, In, Out, Err, U>(service: U, f: F) -> Apply<T, F, R, In, Out, Err>
+where
+    T: Service<Error = Err>,
+    F: FnMut(In, &mut T) -> R,
+    R: Future<Output = Result<Out, Err>>,
+    U: IntoService<T>,
+{
+    Apply::new(service.into_service(), f)
+}
+
+/// Service factory that prodices `apply_fn` service.
+pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
+    service: U,
+    f: F,
+) -> ApplyServiceFactory<T, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+    U: IntoServiceFactory<T>,
+{
+    ApplyServiceFactory::new(service.into_factory(), f)
+}
 
 /// `Apply` service combinator
-pub struct Apply<T, F, In, Out>
+pub struct Apply<T, F, R, In, Out, Err>
 where
-    T: Service,
+    T: Service<Error = Err>,
 {
     service: T,
     f: F,
-    r: PhantomData<(In, Out)>,
+    r: PhantomData<(In, Out, R)>,
 }
 
-impl<T, F, In, Out> Apply<T, F, In, Out>
+impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
 where
-    T: Service,
-    F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
+    T: Service<Error = Err>,
+    F: FnMut(In, &mut T) -> R,
+    R: Future<Output = Result<Out, Err>>,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
+    fn new(service: T, f: F) -> Self {
         Self {
-            service: service.into_service(),
+            service,
             f,
             r: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
+impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
 where
-    T: Service + Clone,
-    F: Clone,
+    T: Service<Error = Err> + Clone,
+    F: FnMut(In, &mut T) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     fn clone(&self) -> Self {
         Apply {
@@ -45,59 +71,59 @@ where
     }
 }
 
-impl<T, F, In, Out> Service for Apply<T, F, In, Out>
+impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
 where
-    T: Service,
-    F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
+    T: Service<Error = Err>,
+    F: FnMut(In, &mut T) -> R,
+    R: Future<Output = Result<Out, Err>>,
 {
     type Request = In;
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Future = Out::Future;
+    type Response = Out;
+    type Error = Err;
+    type Future = R;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|e| e.into())
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(futures_util::ready!(self.service.poll_ready(cx)))
     }
 
     fn call(&mut self, req: In) -> Self::Future {
-        (self.f)(req, &mut self.service).into_future()
+        (self.f)(req, &mut self.service)
     }
 }
 
-/// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out>
+/// `apply()` service factory
+pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
 where
-    T: NewService,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     service: T,
     f: F,
-    r: PhantomData<(In, Out)>,
+    r: PhantomData<(R, In, Out)>,
 }
 
-impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
+impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err>
 where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
+    fn new(service: T, f: F) -> Self {
         Self {
             f,
-            service: service.into_new_service(),
+            service,
             r: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
+impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
 where
-    T: NewService + Clone,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    T: ServiceFactory<Error = Err> + Clone,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     fn clone(&self) -> Self {
         Self {
@@ -108,45 +134,47 @@ where
     }
 }
 
-impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out>
+impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
 where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     type Request = In;
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Service = Apply<T::Service, F, In, Out>;
+    type Response = Out;
+    type Error = Err;
 
+    type Config = T::Config;
+    type Service = Apply<T::Service, F, R, In, Out, Err>;
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out>;
+    type Future = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
 
-    fn new_service(&self) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
+    fn new_service(&self, cfg: T::Config) -> Self::Future {
+        ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, In, Out>
+#[pin_project::pin_project]
+pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R,
+    R: Future<Output = Result<Out, Err>>,
 {
+    #[pin]
     fut: T::Future,
     f: Option<F>,
     r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
+impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R,
+    R: Future<Output = Result<Out, Err>>,
 {
     fn new(fut: T::Future, f: F) -> Self {
-        ApplyNewServiceFuture {
+        Self {
             f: Some(f),
             fut,
             r: PhantomData,
@@ -154,42 +182,45 @@ where
     }
 }
 
-impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
+impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R,
+    R: Future<Output = Result<Out, Err>>,
 {
-    type Item = Apply<T::Service, F, In, Out>;
-    type Error = T::InitError;
+    type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(Apply::new(service, self.f.take().unwrap())))
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        if let Poll::Ready(svc) = this.fut.poll(cx)? {
+            Poll::Ready(Ok(Apply::new(svc, this.f.take().unwrap())))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Future, Poll};
+    use std::task::{Context, Poll};
 
-    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
+    use futures_util::future::{lazy, ok, Ready};
+
+    use super::*;
+    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
+
     impl Service for Srv {
         type Request = ();
         type Response = ();
         type Error = ();
-        type Future = FutureResult<(), ()>;
+        type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Ok(Async::Ready(()))
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
         }
 
         fn call(&mut self, _: ()) -> Self::Future {
@@ -197,34 +228,42 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_call() {
-        let blank = |req| Ok(req);
+    #[actix_rt::test]
+    async fn test_call() {
+        let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
+            let fut = srv.call(());
+            async move {
+                let res = fut.await.unwrap();
+                Ok((req, res))
+            }
+        }));
 
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
-            srv.call(()).map(move |res| (req, res))
-        });
-        assert!(srv.poll_ready().is_ok());
-        let res = srv.call("srv").poll();
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+        assert_eq!(res.unwrap(), (("srv", ())));
     }
 
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
+    #[actix_rt::test]
+    async fn test_new_service() {
+        let new_srv = pipeline_factory(apply_fn_factory(
+            || ok::<_, ()>(Srv),
+            |req: &'static str, srv| {
+                let fut = srv.call(());
+                async move {
+                    let res = fut.await.unwrap();
+                    Ok((req, res))
+                }
+            },
+        ));
 
-        let new_srv = blank.into_new_service().apply(
-            || Ok(Srv),
-            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
-        );
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            assert!(srv.poll_ready().is_ok());
-            let res = srv.call("srv").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-        } else {
-            panic!()
-        }
+        let mut srv = new_srv.new_service(()).await.unwrap();
+
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), (("srv", ())));
     }
 }

actix-service/src/apply_cfg.rs

@@ -0,0 +1,209 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::cell::Cell;
+use crate::{Service, ServiceFactory};
+
+/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
+pub fn apply_cfg<F, C, T, R, S, E>(srv: T, f: F) -> ApplyConfigService<F, C, T, R, S, E>
+where
+    F: FnMut(C, &mut T) -> R,
+    T: Service,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    ApplyConfigService {
+        srv: Cell::new((srv, f)),
+        _t: PhantomData,
+    }
+}
+
+/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
+///
+/// Service1 get constructed from `T` factory.
+pub fn apply_cfg_factory<F, C, T, R, S>(
+    factory: T,
+    f: F,
+) -> ApplyConfigServiceFactory<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    ApplyConfigServiceFactory {
+        srv: Cell::new((factory, f)),
+        _t: PhantomData,
+    }
+}
+
+/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
+pub struct ApplyConfigService<F, C, T, R, S, E>
+where
+    F: FnMut(C, &mut T) -> R,
+    T: Service,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    srv: Cell<(T, F)>,
+    _t: PhantomData<(C, R, S)>,
+}
+
+impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
+where
+    F: FnMut(C, &mut T) -> R,
+    T: Service,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        ApplyConfigService {
+            srv: self.srv.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E>
+where
+    F: FnMut(C, &mut T) -> R,
+    T: Service,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    type Config = C;
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = E;
+    type Future = R;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        unsafe {
+            let srv = self.srv.get_mut_unsafe();
+            (srv.1)(cfg, &mut srv.0)
+        }
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+pub struct ApplyConfigServiceFactory<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    srv: Cell<(T, F)>,
+    _t: PhantomData<(C, R, S)>,
+}
+
+impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        Self {
+            srv: self.srv.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    type Config = C;
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = T::InitError;
+    type Future = ApplyConfigServiceFactoryResponse<F, C, T, R, S>;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        ApplyConfigServiceFactoryResponse {
+            cfg: Some(cfg),
+            store: self.srv.clone(),
+            state: State::A(self.srv.get_ref().0.new_service(())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    cfg: Option<C>,
+    store: Cell<(T, F)>,
+    #[pin]
+    state: State<T, R, S>,
+}
+
+#[pin_project::pin_project]
+enum State<T, R, S>
+where
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    A(#[pin] T::Future),
+    B(T::Service),
+    C(#[pin] R),
+}
+
+impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+where
+    F: FnMut(C, &mut T::Service) -> R,
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    type Output = Result<S, T::InitError>;
+
+    #[pin_project::project]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut) => match fut.poll(cx)? {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(srv) => {
+                    this.state.set(State::B(srv));
+                    self.poll(cx)
+                }
+            },
+            State::B(srv) => match srv.poll_ready(cx)? {
+                Poll::Ready(_) => {
+                    let fut = (this.store.get_mut().1)(this.cfg.take().unwrap(), srv);
+                    this.state.set(State::C(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            State::C(fut) => fut.poll(cx),
+        }
+    }
+}

actix-service/src/boxed.rs

@@ -0,0 +1,145 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures_util::future::FutureExt;
+
+use crate::{Service, ServiceFactory};
+
+pub type BoxFuture<I, E> = Pin<Box<dyn Future<Output = Result<I, E>>>>;
+
+pub type BoxService<Req, Res, Err> =
+    Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
+
+pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+
+/// Create boxed service factory
+pub fn factory<T>(
+    factory: T,
+) -> BoxServiceFactory<T::Config, T::Request, T::Response, T::Error, T::InitError>
+where
+    T: ServiceFactory + 'static,
+    T::Request: 'static,
+    T::Response: 'static,
+    T::Service: 'static,
+    T::Future: 'static,
+    T::Error: 'static,
+    T::InitError: 'static,
+{
+    BoxServiceFactory(Box::new(FactoryWrapper {
+        factory,
+        _t: std::marker::PhantomData,
+    }))
+}
+
+/// Create boxed service
+pub fn service<T>(service: T) -> BoxService<T::Request, T::Response, T::Error>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    Box::new(ServiceWrapper(service))
+}
+
+type Inner<C, Req, Res, Err, InitErr> = Box<
+    dyn ServiceFactory<
+        Config = C,
+        Request = Req,
+        Response = Res,
+        Error = Err,
+        InitError = InitErr,
+        Service = BoxService<Req, Res, Err>,
+        Future = BoxFuture<BoxService<Req, Res, Err>, InitErr>,
+    >,
+>;
+
+impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxServiceFactory<C, Req, Res, Err, InitErr>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Config = C;
+    type Service = BoxService<Req, Res, Err>;
+
+    type Future = BoxFuture<Self::Service, InitErr>;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        self.0.new_service(cfg)
+    }
+}
+
+struct FactoryWrapper<C, T: ServiceFactory> {
+    factory: T,
+    _t: std::marker::PhantomData<C>,
+}
+
+impl<C, T, Req, Res, Err, InitErr> ServiceFactory for FactoryWrapper<C, T>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+    T: ServiceFactory<
+        Config = C,
+        Request = Req,
+        Response = Res,
+        Error = Err,
+        InitError = InitErr,
+    >,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Config = C;
+    type Service = BoxService<Req, Res, Err>;
+    type Future = BoxFuture<Self::Service, Self::InitError>;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        Box::pin(
+            self.factory
+                .new_service(cfg)
+                .map(|res| res.map(ServiceWrapper::boxed)),
+        )
+    }
+}
+
+struct ServiceWrapper<T: Service>(T);
+
+impl<T> ServiceWrapper<T>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    fn boxed(service: T) -> BoxService<T::Request, T::Response, T::Error> {
+        Box::new(ServiceWrapper(service))
+    }
+}
+
+impl<T, Req, Res, Err> Service for ServiceWrapper<T>
+where
+    T: Service<Request = Req, Response = Res, Error = Err>,
+    T::Future: 'static,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type Future = BoxFuture<Res, Err>;
+
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.0.poll_ready(ctx)
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        Box::pin(self.0.call(req))
+    }
+}

actix-service/src/cell.rs

@@ -1,4 +1,5 @@
-//! Custom cell impl
+//! Custom cell impl, internal use only
+use std::task::{Context, Poll};
 use std::{cell::UnsafeCell, fmt, rc::Rc};
 
 pub(crate) struct Cell<T> {
@@ -14,7 +15,7 @@ impl<T> Clone for Cell<T> {
 }
 
 impl<T: fmt::Debug> fmt::Debug for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.inner.fmt(f)
     }
 }
@@ -26,7 +27,31 @@ impl<T> Cell<T> {
         }
     }
 
+    pub(crate) fn get_ref(&self) -> &T {
+        unsafe { &*self.inner.as_ref().get() }
+    }
+
     pub(crate) fn get_mut(&mut self) -> &mut T {
         unsafe { &mut *self.inner.as_ref().get() }
     }
+
+    #[allow(clippy::mut_from_ref)]
+    pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
+        &mut *self.inner.as_ref().get()
+    }
+}
+
+impl<T: crate::Service> crate::Service for Cell<T> {
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.get_mut().poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        self.get_mut().call(req)
+    }
 }

actix-service/src/fn_service.rs

@@ -1,131 +1,403 @@
-use std::marker;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::task::{Context, Poll};
 
-use futures::{
-    future::{ok, FutureResult},
-    Async, IntoFuture, Poll,
-};
+use futures_util::future::{ok, Ready};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-pub struct FnService<F, Req, Resp, E, Fut>
+/// Create `ServiceFactory` for function that can act as a `Service`
+pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
+    f: F,
+) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    FnServiceFactory::new(f)
+}
+
+/// Create `ServiceFactory` for function that can produce services
+///
+/// # Example
+///
+/// ```rust
+/// use std::io;
+/// use actix_service::{fn_factory, fn_service, Service, ServiceFactory};
+/// use futures_util::future::ok;
+///
+/// /// Service that divides two usize values.
+/// async fn div((x, y): (usize, usize)) -> Result<usize, io::Error> {
+///     if y == 0 {
+///         Err(io::Error::new(io::ErrorKind::Other, "divide by zdro"))
+///     } else {
+///         Ok(x / y)
+///     }
+/// }
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     // Create service factory that produces `div` services
+///     let factory = fn_factory(|| {
+///         ok::<_, io::Error>(fn_service(div))
+///     });
+///
+///     // construct new service
+///     let mut srv = factory.new_service(()).await?;
+///
+///     // now we can use `div` service
+///     let result = srv.call((10, 20)).await?;
+///
+///     println!("10 / 20 = {}", result);
+///
+///     Ok(())
+/// }
+/// ```
+pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
+where
+    Srv: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+{
+    FnServiceNoConfig::new(f)
+}
+
+/// Create `ServiceFactory` for function that accepts config argument and can produce services
+///
+/// Any function that has following form `Fn(Config) -> Future<Output = Service>` could
+/// act as a `ServiceFactory`.
+///
+/// # Example
+///
+/// ```rust
+/// use std::io;
+/// use actix_service::{fn_factory_with_config, fn_service, Service, ServiceFactory};
+/// use futures_util::future::ok;
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     // Create service factory. factory uses config argument for
+///     // services it generates.
+///     let factory = fn_factory_with_config(|y: usize| {
+///         ok::<_, io::Error>(fn_service(move |x: usize| ok::<_, io::Error>(x * y)))
+///     });
+///
+///     // construct new service with config argument
+///     let mut srv = factory.new_service(10).await?;
+///
+///     let result = srv.call(10).await?;
+///     assert_eq!(result, 100);
+///
+///     println!("10 * 10 = {}", result);
+///     Ok(())
+/// }
+/// ```
+pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Err>(
+    f: F,
+) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    FnServiceConfig::new(f)
+}
+
+pub struct FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     f: F,
-    _t: marker::PhantomData<(Req, Resp, E)>,
+    _t: PhantomData<Req>,
 }
 
-impl<F, Req, Resp, E, Fut> FnService<F, Req, Resp, E, Fut>
+impl<F, Fut, Req, Res, Err> FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    pub fn new(f: F) -> Self {
-        FnService {
-            f,
-            _t: marker::PhantomData,
-        }
+    pub(crate) fn new(f: F) -> Self {
+        Self { f, _t: PhantomData }
     }
 }
 
-impl<F, Req, Resp, E, Fut> Clone for FnService<F, Req, Resp, E, Fut>
+impl<F, Fut, Req, Res, Err> Clone for FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = E>,
-{
-    fn clone(&self) -> Self {
-        FnService {
-            f: self.f.clone(),
-            _t: marker::PhantomData,
-        }
-    }
-}
-
-impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut>
-where
-    F: FnMut(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
-{
-    type Request = Req;
-    type Response = Resp;
-    type Error = E;
-    type Future = Fut::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Req) -> Self::Future {
-        (self.f)(req).into_future()
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
-where
-    F: FnMut(Req) -> Fut + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    fn into_service(self) -> FnService<F, Req, Resp, Err, Fut> {
-        FnService::new(self)
-    }
-}
-
-pub struct FnNewService<F, Req, Resp, Err, Fut>
-where
-    F: FnMut(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    f: F,
-    _t: marker::PhantomData<(Req, Resp, Err)>,
-}
-
-impl<F, Req, Resp, Err, Fut> FnNewService<F, Req, Resp, Err, Fut>
-where
-    F: FnMut(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    pub fn new(f: F) -> Self {
-        FnNewService {
-            f,
-            _t: marker::PhantomData,
-        }
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut>
-where
-    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>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self) -> Self::Future {
-        ok(FnService::new(self.f.clone()))
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F
-where
-    F: FnMut(Req) -> Fut + Clone + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    fn into_new_service(self) -> FnNewService<F, Req, Resp, Err, Fut> {
-        FnNewService::new(self)
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> Clone for FnNewService<F, Req, Resp, Err, Fut>
-where
-    F: FnMut(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
+
+impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err>
+where
+    F: FnMut(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type Future = Fut;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Req) -> Self::Future {
+        (self.f)(req)
+    }
+}
+
+impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F
+where
+    F: FnMut(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn into_service(self) -> FnService<F, Fut, Req, Res, Err> {
+        FnService::new(self)
+    }
+}
+
+pub struct FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    f: F,
+    _t: PhantomData<(Req, Cfg)>,
+}
+
+impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn new(f: F) -> Self {
+        FnServiceFactory { f, _t: PhantomData }
+    }
+}
+
+impl<F, Fut, Req, Res, Err, Cfg> Clone for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()>
+where
+    F: FnMut(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+    type Future = Fut;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        (self.f)(req)
+    }
+}
+
+impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    type Request = Req;
+    type Response = Res;
+    type Error = Err;
+
+    type Config = Cfg;
+    type Service = FnService<F, Fut, Req, Res, Err>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: Cfg) -> Self::Future {
+        ok(FnService::new(self.f.clone()))
+    }
+}
+
+impl<F, Fut, Req, Res, Err, Cfg>
+    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>> for F
+where
+    F: Fn(Req) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn into_factory(self) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg> {
+        FnServiceFactory::new(self)
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+pub struct FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    f: F,
+    _t: PhantomData<(Fut, Cfg, Srv, Err)>,
+}
+
+impl<F, Fut, Cfg, Srv, Err> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    fn new(f: F) -> Self {
+        FnServiceConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, Fut, Cfg, Srv, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut + Clone,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    fn clone(&self) -> Self {
+        FnServiceConfig {
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, Fut, Cfg, Srv, Err> ServiceFactory for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    type Request = Srv::Request;
+    type Response = Srv::Response;
+    type Error = Srv::Error;
+
+    type Config = Cfg;
+    type Service = Srv;
+    type InitError = Err;
+    type Future = Fut;
+
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
+        (self.f)(cfg)
+    }
+}
+
+/// Converter for `Fn() -> Future<Service>` fn
+pub struct FnServiceNoConfig<F, C, S, R, E>
+where
+    F: Fn() -> R,
+    S: Service,
+    R: Future<Output = Result<S, E>>,
+{
+    f: F,
+    _t: PhantomData<C>,
+}
+
+impl<F, C, S, R, E> FnServiceNoConfig<F, C, S, R, E>
+where
+    F: Fn() -> R,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    fn new(f: F) -> Self {
+        Self { f, _t: PhantomData }
+    }
+}
+
+impl<F, C, S, R, E> ServiceFactory for FnServiceNoConfig<F, C, S, R, E>
+where
+    F: Fn() -> R,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+    type Config = C;
+    type InitError = E;
+    type Future = R;
+
+    fn new_service(&self, _: C) -> Self::Future {
+        (self.f)()
+    }
+}
+
+impl<F, C, S, R, E> Clone for FnServiceNoConfig<F, C, S, R, E>
+where
+    F: Fn() -> R + Clone,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, C, S, R, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, E>> for F
+where
+    F: Fn() -> R,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> {
+        FnServiceNoConfig::new(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+
+    use futures_util::future::{lazy, ok};
+
+    use super::*;
+    use crate::{Service, ServiceFactory};
+
+    #[actix_rt::test]
+    async fn test_fn_service() {
+        let new_srv = fn_service(|()| ok::<_, ()>("srv"));
+
+        let mut srv = new_srv.new_service(()).await.unwrap();
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), "srv");
+    }
+
+    #[actix_rt::test]
+    async fn test_fn_service_service() {
+        let mut srv = fn_service(|()| ok::<_, ()>("srv"));
+
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), "srv");
+    }
+
+    #[actix_rt::test]
+    async fn test_fn_service_with_config() {
+        let new_srv = fn_factory_with_config(|cfg: usize| {
+            ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg))))
+        });
+
+        let mut srv = new_srv.new_service(1).await.unwrap();
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv", 1));
+    }
+}

actix-service/src/from_err.rs

@@ -1,219 +0,0 @@
-use std::marker::PhantomData;
-
-use futures::{Async, Future, Poll};
-
-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> {
-    service: A,
-    f: PhantomData<E>,
-}
-
-impl<A, E> FromErr<A, E> {
-    pub(crate) fn new(service: A) -> Self
-    where
-        A: Service,
-        E: From<A::Error>,
-    {
-        FromErr {
-            service,
-            f: PhantomData,
-        }
-    }
-}
-
-impl<A, E> Clone for FromErr<A, E>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
-        FromErr {
-            service: self.service.clone(),
-            f: PhantomData,
-        }
-    }
-}
-
-impl<A, E> Service for FromErr<A, E>
-where
-    A: Service,
-    E: From<A::Error>,
-{
-    type Request = A::Request;
-    type Response = A::Response;
-    type Error = E;
-    type Future = FromErrFuture<A, E>;
-
-    fn poll_ready(&mut self) -> Poll<(), E> {
-        self.service.poll_ready().map_err(E::from)
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        FromErrFuture {
-            fut: self.service.call(req),
-            f: PhantomData,
-        }
-    }
-}
-
-pub struct FromErrFuture<A: Service, E> {
-    fut: A::Future,
-    f: PhantomData<E>,
-}
-
-impl<A, E> Future for FromErrFuture<A, E>
-where
-    A: Service,
-    E: From<A::Error>,
-{
-    type Item = A::Response;
-    type Error = E;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll().map_err(E::from)
-    }
-}
-
-/// NewService for the `from_err` combinator, changing the type of a new
-/// service's error.
-///
-/// This is created by the `NewServiceExt::from_err` method.
-pub struct FromErrNewService<A, E> {
-    a: A,
-    e: PhantomData<E>,
-}
-
-impl<A, E> FromErrNewService<A, E> {
-    /// Create new `FromErr` new service instance
-    pub fn new(a: A) -> Self
-    where
-        A: NewService,
-        E: From<A::Error>,
-    {
-        Self { a, e: PhantomData }
-    }
-}
-
-impl<A, E> Clone for FromErrNewService<A, E>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            a: self.a.clone(),
-            e: PhantomData,
-        }
-    }
-}
-
-impl<A, E> NewService for FromErrNewService<A, E>
-where
-    A: NewService,
-    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>;
-
-    fn new_service(&self) -> Self::Future {
-        FromErrNewServiceFuture {
-            fut: self.a.new_service(),
-            e: PhantomData,
-        }
-    }
-}
-
-pub struct FromErrNewServiceFuture<A, E>
-where
-    A: NewService,
-    E: From<A::Error>,
-{
-    fut: A::Future,
-    e: PhantomData<E>,
-}
-
-impl<A, E> Future for FromErrNewServiceFuture<A, E>
-where
-    A: NewService,
-    E: From<A::Error>,
-{
-    type Item = FromErr<A::Service, E>;
-    type Error = A::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(FromErr::new(service)))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use futures::future::{err, FutureResult};
-
-    use super::*;
-    use crate::{IntoNewService, NewService, Service, ServiceExt};
-
-    struct Srv;
-    impl Service for Srv {
-        type Request = ();
-        type Response = ();
-        type Error = ();
-        type Future = FutureResult<(), ()>;
-
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Err(())
-        }
-
-        fn call(&mut self, _: ()) -> Self::Future {
-            err(())
-        }
-    }
-
-    #[derive(Debug, PartialEq)]
-    struct Error;
-
-    impl From<()> for Error {
-        fn from(_: ()) -> Self {
-            Error
-        }
-    }
-
-    #[test]
-    fn test_poll_ready() {
-        let mut srv = Srv.from_err::<Error>();
-        let res = srv.poll_ready();
-        assert!(res.is_err());
-        assert_eq!(res.err().unwrap(), Error);
-    }
-
-    #[test]
-    fn test_call() {
-        let mut srv = Srv.from_err::<Error>();
-        let res = srv.call(()).poll();
-        assert!(res.is_err());
-        assert_eq!(res.err().unwrap(), Error);
-    }
-
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>(Srv);
-        let new_srv = blank.into_new_service().from_err::<Error>();
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            let res = srv.call(()).poll();
-            assert!(res.is_err());
-            assert_eq!(res.err().unwrap(), Error);
-        } else {
-            panic!()
-        }
-    }
-}

actix-service/src/lib.rs

@@ -1,27 +1,72 @@
-use futures::{Future, IntoFuture, Poll};
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
+use std::cell::RefCell;
+use std::future::Future;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::task::{self, Context, Poll};
 
 mod and_then;
-mod and_then_apply;
+mod and_then_apply_fn;
 mod apply;
+mod apply_cfg;
+pub mod boxed;
 mod cell;
 mod fn_service;
-mod from_err;
 mod map;
+mod map_config;
 mod map_err;
 mod map_init_err;
+mod pipeline;
 mod then;
+mod transform;
+mod transform_err;
 
-pub use self::and_then::{AndThen, AndThenNewService};
-pub use self::and_then_apply::{AndThenApply, AndThenApplyNewService};
-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};
+pub use self::apply::{apply_fn, apply_fn_factory};
+pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
+pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
+pub use self::map_config::{map_config, unit_config};
+pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
+pub use self::transform::{apply, Transform};
 
 /// An asynchronous function from `Request` to a `Response`.
+///
+/// `Service` represents a service that represanting interation, taking requests and giving back
+/// replies. You can think about service as a function with one argument and result as a return
+/// type. In general form it looks like `async fn(Req) -> Result<Res, Err>`. `Service`
+/// trait just generalizing form of this function. Each parameter described as an assotiated type.
+///
+/// Services provides a symmetric and uniform API, same abstractions represents
+/// clients and servers. Services describe only `transforamtion` operation
+/// which encorouge to simplify api surface and phrases `value transformation`.
+/// That leads to simplier design of each service. That also allows better testability
+/// and better composition.
+///
+/// Services could be represented in several different forms. In general,
+/// Service is a type that implements `Service` trait.
+///
+/// ```rust,ignore
+/// struct MyService;
+///
+/// impl Service for MyService {
+///      type Request = u8;
+///      type Response = u64;
+///      type Error = MyError;
+///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>;
+///
+///      fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
+///
+///      fn call(&mut self) -> Self::Future { ... }
+/// }
+/// ```
+///
+/// Service can have mutable state that influence computation.
+/// This service could be rewritten as a simple function:
+///
+/// ```rust,ignore
+/// async fn my_service(req: u8) -> Result<u64, MyError>;
+/// ```
 pub trait Service {
     /// Requests handled by the service.
     type Request;
@@ -33,7 +78,7 @@ pub trait Service {
     type Error;
 
     /// The future response value.
-    type Future: Future<Item = Self::Response, Error = Self::Error>;
+    type Future: Future<Output = Result<Self::Response, Self::Error>>;
 
     /// Returns `Ready` when the service is able to process requests.
     ///
@@ -44,7 +89,13 @@ pub trait Service {
     /// 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>;
+    ///
+    /// There are several notes to consider:
+    ///
+    /// 1. `.poll_ready()` might be called on different task from actual service call.
+    ///
+    /// 2. In case of chained services, `.poll_ready()` get called for all services at once.
+    fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Process the request and return the response asynchronously.
     ///
@@ -56,68 +107,6 @@ pub trait Service {
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
     fn call(&mut self, req: Self::Request) -> Self::Future;
-}
-
-/// An extension trait for `Service`s that provides a variety of convenient
-/// adapters
-pub trait ServiceExt: Service {
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    fn apply<B, I, F, Out, Req>(self, service: I, f: F) -> AndThenApply<Self, B, F, Out>
-    where
-        Self: Sized,
-        B: Service<Request = Req, Error = Self::Error>,
-        I: IntoService<B>,
-        F: FnMut(Self::Response, &mut B) -> Out,
-        Out: IntoFuture,
-        Out::Error: Into<Self::Error>,
-    {
-        AndThenApply::new(self, 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 service 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.
@@ -128,12 +117,12 @@ pub trait ServiceExt: 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>
+    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R,
     {
-        Map::new(self, f)
+        crate::dev::Map::new(self, f)
     }
 
     /// Map this service's error to a different error, returning a new service.
@@ -144,25 +133,25 @@ pub trait ServiceExt: Service {
     ///
     /// 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>
+    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
     {
-        MapErr::new(self, f)
+        crate::dev::MapErr::new(self, f)
     }
 }
 
-impl<T: ?Sized> ServiceExt for T where T: Service {}
-
 /// Creates new `Service` values.
 ///
 /// Acts as a service factory. This is useful for cases where new `Service`
-/// values must be produced. One case is a TCP servier listener. The listner
+/// values must be produced. One case is a TCP server listener. The listener
 /// accepts new TCP streams, obtains a new `Service` value using the
-/// `NewService` trait, and uses that new `Service` value to process inbound
+/// `ServiceFactory` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
-pub trait NewService {
+///
+/// `Config` is a service factory configuration type.
+pub trait ServiceFactory {
     /// Requests handled by the service.
     type Request;
 
@@ -172,6 +161,9 @@ pub trait NewService {
     /// Errors produced by the service
     type Error;
 
+    /// Service factory configuration
+    type Config;
+
     /// The `Service` value created by this factory
     type Service: Service<
         Request = Self::Request,
@@ -183,102 +175,37 @@ pub trait NewService {
     type InitError;
 
     /// The future of the `Service` instance.
-    type Future: Future<Item = Self::Service, Error = Self::InitError>;
+    type Future: Future<Output = Result<Self::Service, 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<B, I, F, Out, Req>(
-        self,
-        service: I,
-        f: F,
-    ) -> AndThenApplyNewService<Self, B, F, Out>
-    where
-        Self: Sized,
-        B: NewService<Request = Req, Error = Self::Error, InitError = Self::InitError>,
-        I: IntoNewService<B>,
-        F: FnMut(Self::Response, &mut B::Service) -> Out,
-        Out: IntoFuture,
-        Out::Error: Into<Self::Error>,
-    {
-        AndThenApplyNewService::new(self, service, f)
-    }
-
-    /// Call another service after call to this one has resolved successfully.
-    fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
-    where
-        Self: Sized,
-        F: IntoNewService<B>,
-        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 new_service(&self, cfg: Self::Config) -> Self::Future;
 
     /// 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>
+    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
     where
         Self: Sized,
-        F: FnMut(Self::Response) -> R,
+        F: FnMut(Self::Response) -> R + Clone,
     {
-        MapNewService::new(self, f)
+        crate::map::MapServiceFactory::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>
+    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
     where
         Self: Sized,
-        F: Fn(Self::Error) -> E,
+        F: Fn(Self::Error) -> E + Clone,
     {
-        MapErrNewService::new(self, f)
+        crate::map_err::MapErrServiceFactory::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>
+    /// Map this factory's init error to a different error, returning a new service.
+    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
     where
         Self: Sized,
-        F: Fn(Self::InitError) -> E,
+        F: Fn(Self::InitError) -> E + Clone,
     {
-        MapInitErr::new(self, f)
+        crate::map_init_err::MapInitErr::new(self, f)
     }
 }
 
@@ -291,8 +218,8 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self) -> Poll<(), S::Error> {
-        (**self).poll_ready()
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        (**self).poll_ready(ctx)
     }
 
     fn call(&mut self, request: Self::Request) -> S::Future {
@@ -309,8 +236,8 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self) -> Poll<(), S::Error> {
-        (**self).poll_ready()
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+        (**self).poll_ready(ctx)
     }
 
     fn call(&mut self, request: Self::Request) -> S::Future {
@@ -318,21 +245,73 @@ where
     }
 }
 
-impl<F, R, E, S> NewService for F
+impl<S> Service for RefCell<S>
 where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
     S: Service,
 {
     type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
-    type Service = S;
-    type InitError = E;
-    type Future = R::Future;
+    type Future = S::Future;
 
-    fn new_service(&self) -> Self::Future {
-        (*self)().into_future()
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.borrow_mut().poll_ready(ctx)
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        self.borrow_mut().call(request)
+    }
+}
+
+impl<S> Service for Rc<RefCell<S>>
+where
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.borrow_mut().poll_ready(ctx)
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        (&mut (**self).borrow_mut()).call(request)
+    }
+}
+
+impl<S> ServiceFactory for Rc<S>
+where
+    S: ServiceFactory,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Config = S::Config;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
+
+    fn new_service(&self, cfg: S::Config) -> S::Future {
+        self.as_ref().new_service(cfg)
+    }
+}
+
+impl<S> ServiceFactory for Arc<S>
+where
+    S: ServiceFactory,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Config = S::Config;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
+
+    fn new_service(&self, cfg: S::Config) -> S::Future {
+        self.as_ref().new_service(cfg)
     }
 }
 
@@ -345,13 +324,13 @@ where
     fn into_service(self) -> T;
 }
 
-/// Trait for types that can be converted to a Service
-pub trait IntoNewService<T>
+/// Trait for types that can be converted to a `ServiceFactory`
+pub trait IntoServiceFactory<T>
 where
-    T: NewService,
+    T: ServiceFactory,
 {
-    /// Convert to an `NewService`
-    fn into_new_service(self) -> T;
+    /// Convert `Self` to a `ServiceFactory`
+    fn into_factory(self) -> T;
 }
 
 impl<T> IntoService<T> for T
@@ -363,11 +342,28 @@ where
     }
 }
 
-impl<T> IntoNewService<T> for T
+impl<T> IntoServiceFactory<T> for T
 where
-    T: NewService,
+    T: ServiceFactory,
 {
-    fn into_new_service(self) -> T {
+    fn into_factory(self) -> T {
         self
     }
 }
+
+pub mod dev {
+    pub use crate::and_then::{AndThenService, AndThenServiceFactory};
+    pub use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
+    pub use crate::apply::{Apply, ApplyServiceFactory};
+    pub use crate::apply_cfg::{ApplyConfigService, ApplyConfigServiceFactory};
+    pub use crate::fn_service::{
+        FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
+    };
+    pub use crate::map::{Map, MapServiceFactory};
+    pub use crate::map_config::{MapConfig, UnitConfig};
+    pub use crate::map_err::{MapErr, MapErrServiceFactory};
+    pub use crate::map_init_err::MapInitErr;
+    pub use crate::then::{ThenService, ThenServiceFactory};
+    pub use crate::transform::ApplyTransform;
+    pub use crate::transform_err::TransformMapInitErr;
+}

actix-service/src/map.rs

@@ -1,8 +1,9 @@
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use futures::{Async, Future, Poll};
-
-use super::{NewService, Service};
+use super::{Service, ServiceFactory};
 
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
@@ -15,7 +16,7 @@ pub struct Map<A, F, Response> {
 
 impl<A, F, Response> Map<A, F, Response> {
     /// Create new `Map` combinator
-    pub fn new(service: A, f: F) -> Self
+    pub(crate) fn new(service: A, f: F) -> Self
     where
         A: Service,
         F: FnMut(A::Response) -> Response,
@@ -52,8 +53,8 @@ where
     type Error = A::Error;
     type Future = MapFuture<A, F, Response>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(ctx)
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
@@ -61,12 +62,14 @@ where
     }
 }
 
+#[pin_project::pin_project]
 pub struct MapFuture<A, F, Response>
 where
     A: Service,
     F: FnMut(A::Response) -> Response,
 {
     f: F,
+    #[pin]
     fut: A::Future,
 }
 
@@ -85,30 +88,32 @@ where
     A: Service,
     F: FnMut(A::Response) -> Response,
 {
-    type Item = Response;
-    type Error = A::Error;
+    type Output = Result<Response, A::Error>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.fut.poll()? {
-            Async::Ready(resp) => Ok(Async::Ready((self.f)(resp))),
-            Async::NotReady => Ok(Async::NotReady),
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        match this.fut.poll(cx) {
+            Poll::Ready(Ok(resp)) => Poll::Ready(Ok((this.f)(resp))),
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+            Poll::Pending => Poll::Pending,
         }
     }
 }
 
 /// `MapNewService` new service combinator
-pub struct MapNewService<A, F, Response> {
+pub struct MapServiceFactory<A, F, Res> {
     a: A,
     f: F,
-    r: PhantomData<Response>,
+    r: PhantomData<Res>,
 }
 
-impl<A, F, Response> MapNewService<A, F, Response> {
+impl<A, F, Res> MapServiceFactory<A, F, Res> {
     /// Create new `Map` new service instance
-    pub fn new(a: A, f: F) -> Self
+    pub(crate) fn new(a: A, f: F) -> Self
     where
-        A: NewService,
-        F: FnMut(A::Response) -> Response,
+        A: ServiceFactory,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             a,
@@ -118,7 +123,7 @@ impl<A, F, Response> MapNewService<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for MapNewService<A, F, Response>
+impl<A, F, Res> Clone for MapServiceFactory<A, F, Res>
 where
     A: Clone,
     F: Clone,
@@ -132,76 +137,81 @@ where
     }
 }
 
-impl<A, F, Response> NewService for MapNewService<A, F, Response>
+impl<A, F, Res> ServiceFactory for MapServiceFactory<A, F, Res>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response + Clone,
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res + Clone,
 {
     type Request = A::Request;
-    type Response = Response;
+    type Response = Res;
     type Error = A::Error;
-    type Service = Map<A::Service, F, Response>;
 
+    type Config = A::Config;
+    type Service = Map<A::Service, F, Res>;
     type InitError = A::InitError;
-    type Future = MapNewServiceFuture<A, F, Response>;
+    type Future = MapServiceFuture<A, F, Res>;
 
-    fn new_service(&self) -> Self::Future {
-        MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, Response>
+#[pin_project::pin_project]
+pub struct MapServiceFuture<A, F, Res>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response,
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
 {
+    #[pin]
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, Response> MapNewServiceFuture<A, F, Response>
+impl<A, F, Res> MapServiceFuture<A, F, Res>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response,
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
-        MapNewServiceFuture { f: Some(f), fut }
+        MapServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, Response> Future for MapNewServiceFuture<A, F, Response>
+impl<A, F, Res> Future for MapServiceFuture<A, F, Res>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response,
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
 {
-    type Item = Map<A::Service, F, Response>;
-    type Error = A::InitError;
+    type Output = Result<Map<A::Service, F, Res>, A::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(Map::new(service, self.f.take().unwrap())))
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        if let Poll::Ready(svc) = this.fut.poll(cx)? {
+            Poll::Ready(Ok(Map::new(svc, this.f.take().unwrap())))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{ok, FutureResult};
+    use futures_util::future::{lazy, ok, Ready};
 
     use super::*;
-    use crate::{IntoNewService, Service, ServiceExt};
+    use crate::{IntoServiceFactory, Service, ServiceFactory};
 
     struct Srv;
+
     impl Service for Srv {
         type Request = ();
         type Response = ();
         type Error = ();
-        type Future = FutureResult<(), ()>;
+        type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Ok(Async::Ready(()))
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
         }
 
         fn call(&mut self, _: ()) -> Self::Future {
@@ -209,32 +219,27 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_poll_ready() {
+    #[actix_rt::test]
+    async fn test_poll_ready() {
         let mut srv = Srv.map(|_| "ok");
-        let res = srv.poll_ready();
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(()));
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
     }
 
-    #[test]
-    fn test_call() {
+    #[actix_rt::test]
+    async fn test_call() {
         let mut srv = Srv.map(|_| "ok");
-        let res = srv.call(()).poll();
+        let res = srv.call(()).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready("ok"));
+        assert_eq!(res.unwrap(), "ok");
     }
 
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>(Srv);
-        let new_srv = blank.into_new_service().map(|_| "ok");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            let res = srv.call(()).poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready("ok"));
-        } else {
-            panic!()
-        }
+    #[actix_rt::test]
+    async fn test_new_service() {
+        let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map(|_| "ok");
+        let mut srv = new_srv.new_service(&()).await.unwrap();
+        let res = srv.call(()).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("ok"));
     }
 }

actix-service/src/map_config.rs

@@ -0,0 +1,124 @@
+use std::marker::PhantomData;
+
+use super::ServiceFactory;
+
+/// Adapt external config argument to a config for provided service factory
+///
+/// Note that this function consumes the receiving service factory and returns
+/// a wrapped version of it.
+pub fn map_config<T, F, C>(factory: T, f: F) -> MapConfig<T, F, C>
+where
+    T: ServiceFactory,
+    F: Fn(C) -> T::Config,
+{
+    MapConfig::new(factory, f)
+}
+
+/// Replace config with unit
+pub fn unit_config<T, C>(new_service: T) -> UnitConfig<T, C>
+where
+    T: ServiceFactory<Config = ()>,
+{
+    UnitConfig::new(new_service)
+}
+
+/// `.map_config()` service combinator
+pub struct MapConfig<A, F, C> {
+    a: A,
+    f: F,
+    e: PhantomData<C>,
+}
+
+impl<A, F, C> MapConfig<A, F, C> {
+    /// Create new `MapConfig` combinator
+    pub(crate) fn new(a: A, f: F) -> Self
+    where
+        A: ServiceFactory,
+        F: Fn(C) -> A::Config,
+    {
+        Self {
+            a,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, C> Clone for MapConfig<A, F, C>
+where
+    A: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, C> ServiceFactory for MapConfig<A, F, C>
+where
+    A: ServiceFactory,
+    F: Fn(C) -> A::Config,
+{
+    type Request = A::Request;
+    type Response = A::Response;
+    type Error = A::Error;
+
+    type Config = C;
+    type Service = A::Service;
+    type InitError = A::InitError;
+    type Future = A::Future;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        self.a.new_service((self.f)(cfg))
+    }
+}
+
+/// `unit_config()` config combinator
+pub struct UnitConfig<A, C> {
+    a: A,
+    e: PhantomData<C>,
+}
+
+impl<A, C> UnitConfig<A, C>
+where
+    A: ServiceFactory<Config = ()>,
+{
+    /// Create new `UnitConfig` combinator
+    pub(crate) fn new(a: A) -> Self {
+        Self { a, e: PhantomData }
+    }
+}
+
+impl<A, C> Clone for UnitConfig<A, C>
+where
+    A: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, C> ServiceFactory for UnitConfig<A, C>
+where
+    A: ServiceFactory<Config = ()>,
+{
+    type Request = A::Request;
+    type Response = A::Response;
+    type Error = A::Error;
+
+    type Config = C;
+    type Service = A::Service;
+    type InitError = A::InitError;
+    type Future = A::Future;
+
+    fn new_service(&self, _: C) -> Self::Future {
+        self.a.new_service(())
+    }
+}

actix-service/src/map_err.rs

@@ -1,8 +1,9 @@
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use futures::{Async, Future, Poll};
-
-use super::{NewService, Service};
+use super::{Service, ServiceFactory};
 
 /// Service for the `map_err` combinator, changing the type of a service's
 /// error.
@@ -16,7 +17,7 @@ pub struct MapErr<A, F, E> {
 
 impl<A, F, E> MapErr<A, F, E> {
     /// Create new `MapErr` combinator
-    pub fn new(service: A, f: F) -> Self
+    pub(crate) fn new(service: A, f: F) -> Self
     where
         A: Service,
         F: Fn(A::Error) -> E,
@@ -53,8 +54,8 @@ where
     type Error = E;
     type Future = MapErrFuture<A, F, E>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(&self.f)
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(ctx).map_err(&self.f)
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
@@ -62,12 +63,14 @@ where
     }
 }
 
+#[pin_project::pin_project]
 pub struct MapErrFuture<A, F, E>
 where
     A: Service,
     F: Fn(A::Error) -> E,
 {
     f: F,
+    #[pin]
     fut: A::Future,
 }
 
@@ -86,31 +89,35 @@ where
     A: Service,
     F: Fn(A::Error) -> E,
 {
-    type Item = A::Response;
-    type Error = E;
+    type Output = Result<A::Response, E>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll().map_err(&self.f)
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        this.fut.poll(cx).map_err(this.f)
     }
 }
 
-/// NewService for the `map_err` combinator, changing the type of a new
+/// Factory for the `map_err` combinator, changing the type of a new
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrNewService<A, F, E> {
+pub struct MapErrServiceFactory<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E + Clone,
+{
     a: A,
     f: F,
     e: PhantomData<E>,
 }
 
-impl<A, F, E> MapErrNewService<A, F, E> {
+impl<A, F, E> MapErrServiceFactory<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E + Clone,
+{
     /// Create new `MapErr` new service instance
-    pub fn new(a: A, f: F) -> Self
-    where
-        A: NewService,
-        F: Fn(A::Error) -> E,
-    {
+    pub(crate) fn new(a: A, f: F) -> Self {
         Self {
             a,
             f,
@@ -119,10 +126,10 @@ impl<A, F, E> MapErrNewService<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErrNewService<A, F, E>
+impl<A, F, E> Clone for MapErrServiceFactory<A, F, E>
 where
-    A: Clone,
-    F: Clone,
+    A: ServiceFactory + Clone,
+    F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -133,66 +140,69 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapErrNewService<A, F, E>
+impl<A, F, E> ServiceFactory for MapErrServiceFactory<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::Error) -> E + Clone,
 {
     type Request = A::Request;
     type Response = A::Response;
     type Error = E;
+
+    type Config = A::Config;
     type Service = MapErr<A::Service, F, E>;
-
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E>;
+    type Future = MapErrServiceFuture<A, F, E>;
 
-    fn new_service(&self) -> Self::Future {
-        MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E>
+#[pin_project::pin_project]
+pub struct MapErrServiceFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::Error) -> E,
 {
+    #[pin]
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E> MapErrNewServiceFuture<A, F, E>
+impl<A, F, E> MapErrServiceFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
-        MapErrNewServiceFuture { f, fut }
+        MapErrServiceFuture { f, fut }
     }
 }
 
-impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
+impl<A, F, E> Future for MapErrServiceFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Item = MapErr<A::Service, F, E>;
-    type Error = A::InitError;
+    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(MapErr::new(service, self.f.clone())))
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        if let Poll::Ready(svc) = this.fut.poll(cx)? {
+            Poll::Ready(Ok(MapErr::new(svc, this.f.clone())))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{err, FutureResult};
+    use futures_util::future::{err, lazy, ok, Ready};
 
     use super::*;
-    use crate::{IntoNewService, NewService, Service, ServiceExt};
+    use crate::{IntoServiceFactory, Service, ServiceFactory};
 
     struct Srv;
 
@@ -200,10 +210,10 @@ mod tests {
         type Request = ();
         type Response = ();
         type Error = ();
-        type Future = FutureResult<(), ()>;
+        type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Err(())
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Err(()))
         }
 
         fn call(&mut self, _: ()) -> Self::Future {
@@ -211,32 +221,27 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_poll_ready() {
+    #[actix_rt::test]
+    async fn test_poll_ready() {
         let mut srv = Srv.map_err(|_| "error");
-        let res = srv.poll_ready();
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Err("error")));
+    }
+
+    #[actix_rt::test]
+    async fn test_call() {
+        let mut srv = Srv.map_err(|_| "error");
+        let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
     }
 
-    #[test]
-    fn test_call() {
-        let mut srv = Srv.map_err(|_| "error");
-        let res = srv.call(()).poll();
+    #[actix_rt::test]
+    async fn test_new_service() {
+        let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map_err(|_| "error");
+        let mut srv = new_srv.new_service(&()).await.unwrap();
+        let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
     }
-
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>(Srv);
-        let new_srv = blank.into_new_service().map_err(|_| "error");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            let res = srv.call(()).poll();
-            assert!(res.is_err());
-            assert_eq!(res.err().unwrap(), "error");
-        } else {
-            panic!()
-        }
-    }
 }

actix-service/src/map_init_err.rs

@@ -1,8 +1,9 @@
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use futures::{Future, Poll};
-
-use super::NewService;
+use super::ServiceFactory;
 
 /// `MapInitErr` service combinator
 pub struct MapInitErr<A, F, E> {
@@ -11,13 +12,13 @@ pub struct MapInitErr<A, F, E> {
     e: PhantomData<E>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E> {
+impl<A, F, E> MapInitErr<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::InitError) -> E,
+{
     /// Create new `MapInitErr` combinator
-    pub fn new(a: A, f: F) -> Self
-    where
-        A: NewService,
-        F: Fn(A::InitError) -> E,
-    {
+    pub(crate) fn new(a: A, f: F) -> Self {
         Self {
             a,
             f,
@@ -40,36 +41,39 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E> ServiceFactory for MapInitErr<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::InitError) -> E + Clone,
 {
     type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
-    type Service = A::Service;
 
+    type Config = A::Config;
+    type Service = A::Service;
     type InitError = E;
     type Future = MapInitErrFuture<A, F, E>;
 
-    fn new_service(&self) -> Self::Future {
-        MapInitErrFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
+#[pin_project::pin_project]
 pub struct MapInitErrFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::InitError) -> E,
 {
     f: F,
+    #[pin]
     fut: A::Future,
 }
 
 impl<A, F, E> MapInitErrFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -79,13 +83,13 @@ where
 
 impl<A, F, E> Future for MapInitErrFuture<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::InitError) -> E,
 {
-    type Item = A::Service;
-    type Error = E;
+    type Output = Result<A::Service, E>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll().map_err(&self.f)
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        this.fut.poll(cx).map_err(this.f)
     }
 }