prepare actix-service 1.0.6 release (#175)

Tweak actions trigger events

.appveyor.yml

@@ -1,41 +0,0 @@
-environment:
-  global:
-    PROJECT_NAME: actix-net
-  matrix:
-    # Stable channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: stable
-    # Nightly channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: nightly
-
-# Install Rust and Cargo
-# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
-install:
-  - ps: >-
-        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
-           $Env:PATH += ';C:\msys64\mingw64\bin'
-        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
-           $Env:PATH += ';C:\MinGW\bin'
-        }
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs
-  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -Vv
-  - cargo -V
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage.
-build: false
-
-# Equivalent to Travis' `script` phase
-test_script:
-  - cargo clean
-  - cargo test

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,24 @@
+## PR Type
+<!-- What kind of change does this PR make? -->
+<!-- Bug Fix / Feature / Refactor / Code Style / Other -->
+INSERT_PR_TYPE
+
+
+## PR Checklist
+Check your PR fulfills the following:
+
+<!-- For draft PRs check the boxes as you complete them. -->
+
+- [ ] Tests for the changes have been added / updated.
+- [ ] Documentation comments have been added / updated.
+- [ ] A changelog entry has been made for the appropriate packages.
+- [ ] Format code with the latest stable rustfmt
+
+
+## Overview
+<!-- Describe the current and new behavior. -->
+<!-- Emphasize any breaking changes. -->
+
+
+<!-- If this PR fixes or closes an issue, reference it here. -->
+<!-- Closes #000 -->

.github/workflows/bench.yml

@@ -0,0 +1,29 @@
+name: Benchmark (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+jobs:
+  check_benchmark:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          profile: minimal
+          override: true
+
+      - name: Check benchmark
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: --package=actix-service

.github/workflows/clippy-fmt.yml

@@ -0,0 +1,34 @@
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+name: Clippy and rustfmt Check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: rustfmt
+          profile: minimal
+          override: true
+      - name: Check with rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          components: clippy
+          profile: minimal
+          override: true
+      - name: Check with Clippy
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features --all --tests

.github/workflows/linux.yml

@@ -0,0 +1,82 @@
+name: CI (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - 1.39.0
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-unknown-linux-gnu
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with:
+          command: generate-lockfile
+      - name: Cache cargo dirs
+        uses: actions/cache@v2
+        with:
+          path:
+            ~/.cargo/registry
+            ~/.cargo/git
+            ~/.cargo/bin
+          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-trimmed-${{ hashFiles('**/Cargo.lock') }}
+      - name: Cache cargo build
+        uses: actions/cache@v2
+        with:
+          path: target
+          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+
+      - name: Generate coverage file
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        run: |
+          cargo install cargo-tarpaulin
+          cargo tarpaulin --out Xml --workspace --all-features
+
+      - name: Upload to Codecov
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        uses: codecov/codecov-action@v1
+        with:
+          file: cobertura.xml
+
+      - name: Clear the cargo caches
+        run: |
+          rustup update stable
+          rustup override set stable
+          cargo install cargo-cache --no-default-features --features ci-autoclean
+          cargo-cache

.github/workflows/macos.yml

@@ -0,0 +1,43 @@
+name: CI (macOS)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-apple-darwin
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-apple-darwin
+          profile: minimal
+          override: true
+
+      - name: check build
+        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 --all-features --no-fail-fast -- --nocapture

.github/workflows/windows-mingw.yml

@@ -0,0 +1,45 @@
+name: CI (Windows-mingw)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-pc-windows-gnu
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-pc-windows-gnu
+          profile: minimal
+          override: true
+
+      - name: Install MSYS2
+        uses: msys2/setup-msys2@v2
+
+      - name: Install packages
+        run: |
+          msys2 -c 'pacman -Sy --noconfirm pacman'
+          msys2 -c 'pacman --noconfirm -S base-devel pkg-config'
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests

.github/workflows/windows.yml

@@ -0,0 +1,69 @@
+name: CI (Windows)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+env:
+  VCPKGRS_DYNAMIC: 1
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+        target:
+          - x86_64-pc-windows-msvc
+          - i686-pc-windows-msvc
+
+    name: ${{ matrix.version }} - ${{ matrix.target }}
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-${{ matrix.target }}
+          profile: minimal
+          override: true
+
+      - name: Install OpenSSL (x64)
+        if: matrix.target == 'x86_64-pc-windows-msvc'
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:x64-windows
+          Get-ChildItem C:\vcpkg\installed\x64-windows\bin
+          Get-ChildItem C:\vcpkg\installed\x64-windows\lib
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libcrypto-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libcrypto.dll
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libssl-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libssl.dll
+
+      - name: Install OpenSSL (x86)
+        if: matrix.target == 'i686-pc-windows-msvc'
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:x86-windows
+          Get-ChildItem C:\vcpkg\installed\x86-windows\bin
+          Get-ChildItem C:\vcpkg\installed\x86-windows\lib
+          Copy-Item C:\vcpkg\installed\x86-windows\bin\libcrypto-1_1.dll C:\vcpkg\installed\x86-windows\bin\libcrypto.dll
+          Copy-Item C:\vcpkg\installed\x86-windows\bin\libssl-1_1.dll C:\vcpkg\installed\x86-windows\bin\libssl.dll
+
+      - name: check build
+        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 --all-features --no-fail-fast -- --nocapture

.gitignore

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

.travis.yml

@@ -1,54 +0,0 @@
-language: rust
-sudo: required
-dist: trusty
-
-cache:
-  cargo: true
-  apt: true
-
-matrix:
-  include:
-    - rust: stable
-    - rust: beta
-    - rust: nightly
-  allow_failures:
-    - rust: nightly
-
-env:
-  global:
-    # - RUSTFLAGS="-C link-dead-code"
-    - OPENSSL_VERSION=openssl-1.0.2
-
-before_install:
-  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
-  - sudo apt-get update -qq
-  - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
-
-# Add clippy
-before_script:
-  - export PATH=$PATH:~/.cargo/bin
-
-script:
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
-    cargo clean
-    cargo test --features="ssl,tls,rust-tls" -- --nocapture
-    fi
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
-    cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
-    bash <(curl -s https://codecov.io/bash)
-    echo "Uploaded code coverage"
-    fi
-
-# Upload docs
-after_success:
-  - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then
-      cargo doc --features "ssl,tls,rust-tls" --no-deps &&
-      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
-      git clone https://github.com/davisp/ghp-import.git &&
-      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
-      echo "Uploaded documentation"
-    fi

CHANGES.md

@@ -1,54 +0,0 @@
-# Changes
-
-## [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,83 +1,31 @@
-[package]
-name = "actix-net"
-version = "0.2.3"
-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"]
+[workspace]
+members = [
+  "actix-codec",
+  "actix-connect",
+  "actix-rt",
+  "actix-macros",
+  "actix-service",
+  "actix-server",
+  "actix-testing",
+  "actix-threadpool",
+  "actix-tls",
+  "actix-tracing",
+  "actix-utils",
+  "router",
+  "string",
+]
 
-[package.metadata.docs.rs]
-features = ["ssl", "tls", "rust-tls"]
-
-[badges]
-travis-ci = { repository = "actix/actix-net", branch = "master" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
-codecov = { repository = "actix/actix-net", branch = "master", service = "github" }
-
-[lib]
-name = "actix_net"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# tls
-tls = ["native-tls"]
-
-# openssl
-ssl = ["openssl", "tokio-openssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
-
-cell = []
-
-[dependencies]
-actix = "0.7.6"
-
-log = "0.4"
-num_cpus = "1.0"
-
-# io
-mio = "^0.6.13"
-net2 = "0.2"
-bytes = "0.4"
-futures = "0.1"
-slab = "0.4"
-tokio = "0.1"
-tokio-codec = "0.1"
-tokio-io = "0.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2"
-tokio-reactor = "0.1"
-tokio-current-thread = "0.1"
-tower-service = "0.1"
-trust-dns-proto = "^0.5.0"
-trust-dns-resolver = "^0.10.0"
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.2", optional = true }
-
-#rustls
-rustls = { version = "^0.14", optional = true }
-tokio-rustls = { version = "^0.8", optional = true }
-webpki = { version = "0.18", optional = true }
-webpki-roots = { version = "0.15", optional = true }
-
-[dev-dependencies]
-env_logger = "0.5"
-
-[profile.release]
-lto = true
-opt-level = 3
-codegen-units = 1
+[patch.crates-io]
+actix-codec = { path = "actix-codec" }
+actix-connect = { path = "actix-connect" }
+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-tracing = { path = "actix-tracing" }
+actix-utils = { path = "actix-utils" }
+actix-router = { path = "router" }
+bytestring = { path = "string" }

README.md

@@ -1,20 +1,25 @@
-# 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 [![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
+
+## Build statuses
+
+| Platform         | Build Status |
+| ---------------- | ------------ |
+| Linux            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Linux)") |
+| macOS            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28macOS%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(macOS)") |
+| Windows          | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows)") |
+| Windows (MinGW)  | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows-mingw%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows-mingw)") |
 
 ## 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::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 +31,7 @@ fn main() {
     // bind socket address and start workers. By default server uses number of
     // available logical cpu as threads count. actix net start separate
     // instances of service pipeline in each worker.
-    Server::default()
+    Server::build()
         .bind(
             // configure service pipeline
             "basic", "0.0.0.0:8443",
@@ -34,29 +39,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

@@ -0,0 +1,37 @@
+# Changes
+
+## Unreleased - 2020-xx-xx
+* Use `.advance()` instead of `.split_to()`.
+* Upgrade `tokio-util` to `0.3`.
+* Improve `BytesCodec` `.encode()` performance
+* Simplify `BytesCodec` `.decode()` 
+
+## [0.2.0] - 2019-12-10
+
+* Use specific futures dependencies
+
+## [0.2.0-alpha.4]
+
+* Fix buffer remaining capacity calculation
+
+## [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

@@ -0,0 +1,27 @@
+[package]
+name = "actix-codec"
+version = "0.2.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Utilities for encoding and decoding frames"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-codec/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_codec"
+path = "src/lib.rs"
+
+[dependencies]
+bitflags = "1.2.1"
+bytes = "0.5.2"
+futures-core = { version = "0.3.4", default-features = false }
+futures-sink = { version = "0.3.4", default-features = false }
+tokio = { version = "0.2.5", default-features = false }
+tokio-util = { version = "0.3.1", default-features = false, features = ["codec"] }
+log = "0.4"
+pin-project = "0.4.17"

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::{Buf, Bytes, BytesMut};
 use std::io;
 
-use bytes::{Bytes, BytesMut};
-use tokio_codec::{Decoder, Encoder};
+use super::{Decoder, Encoder};
 
 /// Bytes codec.
 ///
@@ -9,12 +9,12 @@ use tokio_codec::{Decoder, Encoder};
 #[derive(Debug, Copy, Clone)]
 pub struct BytesCodec;
 
-impl Encoder for BytesCodec {
-    type Item = Bytes;
+impl Encoder<Bytes> for BytesCodec {
     type Error = io::Error;
 
+    #[inline]
     fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.extend_from_slice(&item[..]);
+        dst.extend_from_slice(item.bytes());
         Ok(())
     }
 }
@@ -27,7 +27,7 @@ impl Decoder for BytesCodec {
         if src.is_empty() {
             Ok(None)
         } else {
-            Ok(Some(src.take()))
+            Ok(Some(src.split()))
         }
     }
 }

actix-codec/src/framed.rs

@@ -0,0 +1,421 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{fmt, io};
+
+use bytes::{Buf, BytesMut};
+use futures_core::{ready, Stream};
+use futures_sink::Sink;
+use pin_project::pin_project;
+
+use crate::{AsyncRead, AsyncWrite, Decoder, Encoder};
+
+/// Low-water mark
+const LW: usize = 1024;
+/// High-water mark
+const HW: usize = 8 * 1024;
+
+bitflags::bitflags! {
+    struct Flags: u8 {
+        const EOF = 0b0001;
+        const READABLE = 0b0010;
+    }
+}
+
+/// A unified `Stream` and `Sink` interface to an underlying I/O object, using
+/// the `Encoder` and `Decoder` traits to encode and decode frames.
+#[pin_project]
+pub struct Framed<T, U> {
+    #[pin]
+    io: T,
+    codec: U,
+    flags: Flags,
+    read_buf: BytesMut,
+    write_buf: BytesMut,
+}
+
+impl<T, U> Framed<T, U>
+where
+    T: AsyncRead + AsyncWrite,
+    U: Decoder,
+{
+    /// Provides a `Stream` and `Sink` interface for reading and writing to this
+    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
+    ///
+    /// Raw I/O objects work with byte sequences, but higher-level code usually
+    /// wants to batch these into meaningful chunks, called "frames". This
+    /// method layers framing on top of an I/O object, by using the `Codec`
+    /// traits to handle encoding and decoding of messages frames. Note that
+    /// the incoming and outgoing frame types may be distinct.
+    ///
+    /// This function returns a *single* object that is both `Stream` and
+    /// `Sink`; grouping this into a single object is often useful for layering
+    /// things like gzip or TLS, which require both read and write access to the
+    /// underlying object.
+    pub fn new(io: T, codec: U) -> Framed<T, U> {
+        Framed {
+            io,
+            codec,
+            flags: Flags::empty(),
+            read_buf: BytesMut::with_capacity(HW),
+            write_buf: BytesMut::with_capacity(HW),
+        }
+    }
+}
+
+impl<T, U> Framed<T, U> {
+    /// Provides a `Stream` and `Sink` interface for reading and writing to this
+    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
+    ///
+    /// Raw I/O objects work with byte sequences, but higher-level code usually
+    /// wants to batch these into meaningful chunks, called "frames". This
+    /// method layers framing on top of an I/O object, by using the `Codec`
+    /// traits to handle encoding and decoding of messages frames. Note that
+    /// the incoming and outgoing frame types may be distinct.
+    ///
+    /// This function returns a *single* object that is both `Stream` and
+    /// `Sink`; grouping this into a single object is often useful for layering
+    /// things like gzip or TLS, which require both read and write access to the
+    /// underlying object.
+    ///
+    /// This objects takes a stream and a readbuffer and a writebuffer. These
+    /// field can be obtained from an existing `Framed` with the
+    /// `into_parts` method.
+    pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
+        Framed {
+            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.codec
+    }
+
+    /// Returns a mutable reference to the underlying codec.
+    pub fn get_codec_mut(&mut self) -> &mut U {
+        &mut self.codec
+    }
+
+    /// Returns a reference to the underlying I/O stream wrapped by
+    /// `Frame`.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream
+    /// of data coming in as it may corrupt the stream of frames otherwise
+    /// being worked with.
+    pub fn get_ref(&self) -> &T {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying I/O stream wrapped by
+    /// `Frame`.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream
+    /// of data coming in as it may corrupt the stream of frames otherwise
+    /// being worked with.
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.io
+    }
+
+    /// Check if write buffer is empty.
+    pub fn is_write_buf_empty(&self) -> bool {
+        self.write_buf.is_empty()
+    }
+
+    /// Check if write buffer is full.
+    pub fn is_write_buf_full(&self) -> bool {
+        self.write_buf.len() >= HW
+    }
+
+    /// Consume the `Frame`, returning `Frame` with different codec.
+    pub fn into_framed<U2, I2>(self, codec: U2) -> Framed<T, U2> {
+        Framed {
+            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, I2>(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,
+        }
+    }
+
+    /// Consume the `Frame`, returning `Frame` with different codec.
+    pub fn map_codec<F, U2, I2>(self, f: F) -> Framed<T, U2>
+    where
+        F: Fn(U) -> U2,
+    {
+        Framed {
+            io: self.io,
+            codec: f(self.codec),
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+
+    /// Consumes the `Frame`, returning its underlying I/O stream, the buffer
+    /// with unprocessed data, and the codec.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream
+    /// of data coming in as it may corrupt the stream of frames otherwise
+    /// being worked with.
+    pub fn into_parts(self) -> FramedParts<T, U> {
+        FramedParts {
+            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<I>(mut self: Pin<&mut Self>, item: I) -> Result<(), <U as Encoder<I>>::Error>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let this = self.as_mut().project();
+        let remaining = this.write_buf.capacity() - this.write_buf.len();
+        if remaining < LW {
+            this.write_buf.reserve(HW - remaining);
+        }
+
+        this.codec.encode(item, this.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: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<<U as Decoder>::Item, U::Error>>>
+    where
+        T: AsyncRead,
+        U: Decoder,
+    {
+        loop {
+            let mut this = self.as_mut().project();
+            // 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 this.flags.contains(Flags::READABLE) {
+                if this.flags.contains(Flags::EOF) {
+                    match this.codec.decode_eof(&mut this.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 this.codec.decode(&mut this.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
+                }
+
+                this.flags.remove(Flags::READABLE);
+            }
+
+            debug_assert!(!this.flags.contains(Flags::EOF));
+
+            // Otherwise, try to read more data and try again. Make sure we've got room
+            let remaining = this.read_buf.capacity() - this.read_buf.len();
+            if remaining < LW {
+                this.read_buf.reserve(HW - remaining)
+            }
+            let cnt = match this.io.poll_read_buf(cx, &mut this.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 {
+                this.flags.insert(Flags::EOF);
+            }
+            this.flags.insert(Flags::READABLE);
+        }
+    }
+
+    /// Flush write buffer to underlying I/O stream.
+    pub fn flush<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let mut this = self.as_mut().project();
+        log::trace!("flushing framed transport");
+
+        while !this.write_buf.is_empty() {
+            log::trace!("writing; remaining={}", this.write_buf.len());
+
+            let n = ready!(this.io.as_mut().poll_write(cx, this.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
+            this.write_buf.advance(n);
+        }
+
+        // Try flushing the underlying IO
+        ready!(this.io.poll_flush(cx))?;
+
+        log::trace!("framed transport flushed");
+        Poll::Ready(Ok(()))
+    }
+
+    /// Flush write buffer and shutdown underlying I/O stream.
+    pub fn close<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let mut this = self.as_mut().project();
+        ready!(this.io.as_mut().poll_flush(cx))?;
+        ready!(this.io.as_mut().poll_shutdown(cx))?;
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<T, U> Stream for Framed<T, U>
+where
+    T: AsyncRead,
+    U: Decoder,
+{
+    type Item = Result<U::Item, U::Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.next_item(cx)
+    }
+}
+
+impl<T, U, I> Sink<I> for Framed<T, U>
+where
+    T: AsyncWrite,
+    U: Encoder<I>,
+    U::Error: From<io::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(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
+        self.write(item)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.close(cx)
+    }
+}
+
+impl<T, U> fmt::Debug for Framed<T, U>
+where
+    T: fmt::Debug,
+    U: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Framed")
+            .field("io", &self.io)
+            .field("codec", &self.codec)
+            .finish()
+    }
+}
+
+/// `FramedParts` contains an export of the data of a Framed transport.
+/// It can be used to construct a new `Framed` with a different codec.
+/// It contains all current buffers and the inner transport.
+#[derive(Debug)]
+pub struct FramedParts<T, U> {
+    /// The inner transport used to read bytes to and write bytes to
+    pub io: T,
+
+    /// The codec
+    pub codec: U,
+
+    /// The buffer with read but unprocessed data.
+    pub read_buf: BytesMut,
+
+    /// A buffer with unprocessed data which are not written yet.
+    pub write_buf: BytesMut,
+
+    flags: Flags,
+}
+
+impl<T, U> FramedParts<T, U> {
+    /// Create a new, default, `FramedParts`
+    pub fn new(io: T, codec: U) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            flags: Flags::empty(),
+            read_buf: BytesMut::new(),
+            write_buf: BytesMut::new(),
+        }
+    }
+
+    /// 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/lib.rs

@@ -0,0 +1,20 @@
+//! Utilities for encoding and decoding frames.
+//!
+//! Contains adapters to go from streams of bytes, [`AsyncRead`] and
+//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
+//! Framed streams are also known as `transports`.
+//!
+//! [`AsyncRead`]: AsyncRead
+//! [`AsyncWrite`]: AsyncWrite
+//! [`Sink`]: futures_sink::Sink
+//! [`Stream`]: futures_core::Stream
+#![deny(rust_2018_idioms)]
+
+mod bcodec;
+mod framed;
+
+pub use self::bcodec::BytesCodec;
+pub use self::framed::{Framed, FramedParts};
+
+pub use tokio::io::{AsyncRead, AsyncWrite};
+pub use tokio_util::codec::{Decoder, Encoder};

actix-connect/CHANGES.md

@@ -0,0 +1,147 @@
+# Changes
+
+## [unreleased]
+
+### Changed
+
+* Update `rustls` dependency to 0.18
+* Update `tokio-rustls` dependency to 0.14
+
+## [2.0.0-alpha.3] - 2020-05-08
+
+### Fixed
+
+* Corrected spelling of `ConnectError::Unresolverd` to `ConnectError::Unresolved`
+
+## [2.0.0-alpha.2] - 2020-03-08
+
+### Changed
+
+* Update `trust-dns-proto` dependency to 0.19. [#116]
+* Update `trust-dns-resolver` dependency to 0.19. [#116]
+* `Address` trait is now required to have static lifetime. [#116]
+* `start_resolver` and `start_default_resolver` are now `async` and may return a `ConnectError`. [#116]
+
+[#116]: https://github.com/actix/actix-net/pull/116
+
+## [2.0.0-alpha.1] - 2020-03-03
+
+### Changed
+
+* Update `rustls` dependency to 0.17
+* Update `tokio-rustls` dependency to 0.13
+
+## [1.0.2] - 2020-01-15
+
+* Fix actix-service 1.0.3 compatibility
+
+## [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,57 @@
+[package]
+name = "actix-connect"
+version = "2.0.0-alpha.3"
+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 OR Apache-2.0"
+edition = "2018"
+
+[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.3"
+actix-codec = "0.2.0"
+actix-utils = "1.0.6"
+actix-rt = "1.0.0"
+derive_more = "0.99.2"
+either = "1.5.3"
+futures-util = { version = "0.3.4", default-features = false }
+http = { version = "0.2.0", optional = true }
+log = "0.4"
+trust-dns-proto = { version = "0.19", default-features = false, features = ["tokio-runtime"] }
+trust-dns-resolver = { version = "0.19", default-features = false, features = ["tokio-runtime", "system-config"] }
+
+# openssl
+open-ssl = { version="0.10", package = "openssl", optional = true }
+tokio-openssl = { version = "0.4.0", optional = true }
+
+# rustls
+rust-tls = { version = "0.18.0", package = "rustls", optional = true }
+tokio-rustls = { version = "0.14.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 + 'static {
+    /// 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_util::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::Unresolved))
+        }
+    }
+}
+
+#[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")]
+    Unresolved,
+
+    /// 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::TokioAsyncResolver as 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 async fn start_resolver(
+    cfg: ResolverConfig,
+    opts: ResolverOpts,
+) -> Result<AsyncResolver, ConnectError> {
+    Ok(AsyncResolver::tokio(cfg, opts).await?)
+}
+
+struct DefaultResolver(AsyncResolver);
+
+pub(crate) async fn get_default_resolver() -> Result<AsyncResolver, ConnectError> {
+    if Arbiter::contains_item::<DefaultResolver>() {
+        Ok(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 = AsyncResolver::tokio(cfg, opts).await?;
+
+        Arbiter::set_item(DefaultResolver(resolver.clone()));
+        Ok(resolver)
+    }
+}
+
+pub async fn start_default_resolver() -> Result<AsyncResolver, ConnectError> {
+    get_default_resolver().await
+}
+
+/// Create tcp connector service
+pub fn new_connector<T: Address + 'static>(
+    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 + 'static>(
+    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 + 'static>(
+) -> 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 + 'static>() -> 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,207 @@
+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_util::future::{ok, Either, Ready};
+use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
+use trust_dns_resolver::{error::ResolveError, lookup_ip::LookupIp};
+
+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<
+        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>,
+        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 {
+            let resolver = self.resolver.as_ref().map(AsyncResolver::clone);
+            Either::Left(Box::pin(async move {
+                trace!("DNS resolver: resolving host {:?}", req.host());
+                let resolver = if let Some(resolver) = resolver {
+                    resolver
+                } else {
+                    get_default_resolver()
+                        .await
+                        .expect("Failed to get default resolver")
+                };
+                ResolverFuture::new(req, &resolver).await
+            }))
+        }
+    }
+}
+
+type LookupIpFuture = Pin<Box<dyn Future<Output = Result<LookupIp, ResolveError>>>>;
+
+#[doc(hidden)]
+/// Resolver future
+pub struct ResolverFuture<T: Address> {
+    req: Option<Connect<T>>,
+    lookup: LookupIpFuture,
+}
+
+impl<T: Address> ResolverFuture<T> {
+    pub fn new(req: Connect<T>, resolver: &AsyncResolver) -> Self {
+        let host = if let Some(host) = req.host().splitn(2, ':').next() {
+            host
+        } else {
+            req.host()
+        };
+
+        // Clone data to be moved to the lookup future
+        let host_clone = host.to_owned();
+        let resolver_clone = resolver.clone();
+
+        ResolverFuture {
+            lookup: Box::pin(async move {
+                let resolver = resolver_clone;
+                resolver.lookup_ip(host_clone).await
+            }),
+            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_util::future::{ok, Ready};
+use trust_dns_resolver::TokioAsyncResolver as 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_util::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready};
+use trust_dns_resolver::TokioAsyncResolver as 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_util::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_util::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_util::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,
+            _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_util::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,127 @@
+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_util::sink::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().await.unwrap();
+    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())
+            .await
+            .unwrap();
+
+    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-ioframe/README.md

@@ -0,0 +1,3 @@
+# actix-ioframe
+
+**This crate has been deprecated and removed.**

actix-macros/.gitignore

@@ -0,0 +1 @@
+/wip

actix-macros/CHANGES.md

@@ -0,0 +1,9 @@
+# CHANGES
+
+## 0.1.2 - 2020-05-18
+
+### Changed
+
+* Forward actix_rt::test arguments to test function [#127]
+
+[#127]: https://github.com/actix/actix-net/pull/127

actix-macros/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "actix-macros"
+version = "0.1.2"
+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 OR Apache-2.0"
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.3"
+syn = { version = "^1", features = ["full"] }
+
+[dev-dependencies]
+actix-rt = "1.0"
+
+futures-util = { version = "0.3", default-features = false }
+trybuild = "1"

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,102 @@
+//! 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");
+/// }
+/// ```
+#[allow(clippy::needless_doctest_main)]
+#[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 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 mut has_test_attr = false;
+
+    for attr in attrs {
+        if attr.path.is_ident("test") {
+            has_test_attr = true;
+        }
+    }
+
+    if 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();
+    }
+
+    sig.asyncness = None;
+
+    let result = if has_test_attr {
+        quote! {
+            #(#attrs)*
+            #vis #sig {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    } else {
+        quote! {
+            #[test]
+            #(#attrs)*
+            #vis #sig {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    };
+
+    result.into()
+}

actix-macros/tests/trybuild.rs

@@ -0,0 +1,9 @@
+#[test]
+fn compile_macros() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/trybuild/main-01-basic.rs");
+    t.compile_fail("tests/trybuild/main-02-only-async.rs");
+
+    t.pass("tests/trybuild/test-01-basic.rs");
+    t.pass("tests/trybuild/test-02-keep-attrs.rs");
+}

actix-macros/tests/trybuild/main-01-basic.rs

@@ -0,0 +1,4 @@
+#[actix_rt::main]
+async fn main() {
+    println!("Hello world");
+}

actix-macros/tests/trybuild/main-02-only-async.rs

@@ -0,0 +1,4 @@
+#[actix_rt::main]
+fn main() {
+    futures_util::future::ready(()).await
+}

actix-macros/tests/trybuild/main-02-only-async.stderr

@@ -0,0 +1,14 @@
+error: only async fn is supported
+ --> $DIR/main-02-only-async.rs:2:1
+  |
+2 | fn main() {
+  | ^^
+
+error[E0601]: `main` function not found in crate `$CRATE`
+ --> $DIR/main-02-only-async.rs:1:1
+  |
+1 | / #[actix_rt::main]
+2 | | fn main() {
+3 | |     futures_util::future::ready(()).await
+4 | | }
+  | |_^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs`

actix-macros/tests/trybuild/test-01-basic.rs

@@ -0,0 +1,6 @@
+#[actix_rt::test]
+async fn my_test() {
+    assert!(true);
+}
+
+fn main() {}

actix-macros/tests/trybuild/test-02-keep-attrs.rs

@@ -0,0 +1,7 @@
+#[actix_rt::test]
+#[should_panic]
+async fn my_test() {
+    todo!()
+}
+
+fn main() {}

actix-rt/CHANGES.md

@@ -0,0 +1,118 @@
+# Changes
+
+## [1.1.1] - 2020-04-30
+
+### Fixed
+
+* Fix memory leak due to [#94] (see [#129] for more detail)
+
+[#129]: https://github.com/actix/actix-net/issues/129
+
+## [1.1.0] - 2020-04-08
+
+**This version has been yanked.**
+
+### Added
+
+* Expose `System::is_set` to check if current system has ben started [#99]
+* Add `Arbiter::is_running` to check if event loop is running [#124]
+* Add `Arbiter::local_join` associated function
+  to get be able to `await` for spawned futures [#94]
+
+[#94]: https://github.com/actix/actix-net/pull/94
+[#99]: https://github.com/actix/actix-net/pull/99
+[#124]: https://github.com/actix/actix-net/pull/124
+
+## [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

@@ -0,0 +1,25 @@
+[package]
+name = "actix-rt"
+version = "1.1.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix runtime"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-rt/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+
+[lib]
+name = "actix_rt"
+path = "src/lib.rs"
+
+[dependencies]
+actix-macros = "0.1.0"
+actix-threadpool = "0.3"
+futures-channel = { version = "0.3.4", default-features = false }
+futures-util = { version = "0.3.4", default-features = false, features = ["alloc"] }
+copyless = "0.1.4"
+smallvec = "1"
+tokio = { version = "0.2.6", 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

@@ -0,0 +1,471 @@
+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_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures_channel::oneshot::{channel, Canceled, Sender};
+use futures_util::{
+    future::{self, Future, FutureExt},
+    stream::Stream,
+};
+
+use crate::runtime::Runtime;
+use crate::system::System;
+
+use copyless::BoxHelper;
+
+use smallvec::SmallVec;
+pub use tokio::task::JoinHandle;
+
+thread_local!(
+    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
+    static RUNNING: Cell<bool> = Cell::new(false);
+    static Q: RefCell<Vec<Pin<Box<dyn Future<Output = ()>>>>> = RefCell::new(Vec::new());
+    static PENDING: RefCell<SmallVec<[JoinHandle<()>; 8]>> = RefCell::new(SmallVec::new());
+    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
+);
+
+pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
+
+pub(crate) enum ArbiterCommand {
+    Stop,
+    Execute(Box<dyn Future<Output = ()> + Unpin + Send>),
+    ExecuteFn(Box<dyn FnExec>),
+}
+
+impl fmt::Debug for ArbiterCommand {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
+            ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
+        }
+    }
+}
+
+#[derive(Debug)]
+/// Arbiters provide an asynchronous execution environment for actors, functions
+/// and futures. When an Arbiter is created, it spawns a new OS thread, and
+/// hosts 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 {
+        Self::new()
+    }
+}
+
+impl Arbiter {
+    pub(crate) fn new_system() -> Self {
+        let (tx, rx) = unbounded();
+
+        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 the current thread's arbiter's address. If no Arbiter is present, then this
+    /// function will panic!
+    pub fn current() -> Arbiter {
+        ADDR.with(|cell| match *cell.borrow() {
+            Some(ref addr) => addr.clone(),
+            None => panic!("Arbiter is not running"),
+        })
+    }
+
+    /// Check if current arbiter is running.
+    pub fn is_running() -> bool {
+        RUNNING.with(|cell| cell.get())
+    }
+
+    /// Stop arbiter from continuing it's event loop.
+    pub fn stop(&self) {
+        let _ = self.sender.unbounded_send(ArbiterCommand::Stop);
+    }
+
+    /// Spawn new thread and run event loop in spawned thread.
+    /// Returns address of newly created arbiter.
+    pub fn new() -> Arbiter {
+        let id = COUNT.fetch_add(1, Ordering::Relaxed);
+        let name = format!("actix-rt:worker:{}", id);
+        let sys = System::current();
+        let (arb_tx, arb_rx) = unbounded();
+        let arb_tx2 = arb_tx.clone();
+
+        let 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));
+                STORAGE.with(|cell| cell.borrow_mut().clear());
+
+                System::set_current(sys);
+
+                // start arbiter controller
+                rt.spawn(ArbiterController {
+                    stop: Some(stop),
+                    rx: arb_rx,
+                });
+                ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+
+                // register arbiter
+                let _ = System::current()
+                    .sys()
+                    .unbounded_send(SystemCommand::RegisterArbiter(id, arb));
+
+                // 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)
+            });
+
+        Arbiter {
+            sender: arb_tx2,
+            thread_handle: Some(handle),
+        }
+    }
+
+    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(..) {
+                if let Some(rt) = rt {
+                    rt.spawn(fut);
+                } else {
+                    tokio::task::spawn_local(fut);
+                }
+            }
+        });
+    }
+
+    pub(crate) fn stop_system() {
+        RUNNING.with(|cell| cell.set(false));
+    }
+
+    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    /// thread.
+    pub fn spawn<F>(future: F)
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        RUNNING.with(move |cell| {
+            if cell.get() {
+                // Spawn the future on running executor
+                let len = PENDING.with(move |cell| {
+                    let mut p = cell.borrow_mut();
+                    p.push(tokio::task::spawn_local(future));
+                    p.len()
+                });
+                if len > 7 {
+                    // Before reaching the inline size
+                    tokio::task::spawn_local(CleanupPending);
+                }
+            } else {
+                // 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(Pin::from(Box::alloc().init(future)))
+                });
+            }
+        });
+    }
+
+    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for executing futures on the current
+    /// thread.
+    pub fn spawn_fn<F, R>(f: F)
+    where
+        F: FnOnce() -> R + 'static,
+        R: Future<Output = ()> + 'static,
+    {
+        Arbiter::spawn(future::lazy(|_| f()).flatten())
+    }
+
+    /// Send a future to the Arbiter's thread, and spawn it.
+    pub fn send<F>(&self, future: F)
+    where
+        F: Future<Output = ()> + Send + Unpin + 'static,
+    {
+        let _ = self
+            .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(())
+        }
+    }
+
+    /// Returns a future that will be completed once all currently spawned futures
+    /// have completed.
+    pub fn local_join() -> impl Future<Output = ()> {
+        PENDING.with(move |cell| {
+            let current = cell.replace(SmallVec::new());
+            future::join_all(current).map(|_| ())
+        })
+    }
+}
+
+/// Future used for cleaning-up already finished `JoinHandle`s
+/// from the `PENDING` list so the vector doesn't grow indefinitely
+struct CleanupPending;
+
+impl Future for CleanupPending {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        PENDING.with(move |cell| {
+            let mut pending = cell.borrow_mut();
+            let mut i = 0;
+            while i != pending.len() {
+                if let Poll::Ready(_) = Pin::new(&mut pending[i]).poll(cx) {
+                    pending.remove(i);
+                } else {
+                    i += 1;
+                }
+            }
+        });
+
+        Poll::Ready(())
+    }
+}
+
+struct ArbiterController {
+    stop: Option<Sender<i32>>,
+    rx: UnboundedReceiver<ArbiterCommand>,
+}
+
+impl Drop for ArbiterController {
+    fn drop(&mut self) {
+        if thread::panicking() {
+            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 Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            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 Poll::Ready(());
+                    }
+                    ArbiterCommand::Execute(fut) => {
+                        let len = PENDING.with(move |cell| {
+                            let mut p = cell.borrow_mut();
+                            p.push(tokio::task::spawn_local(fut));
+                            p.len()
+                        });
+                        if len > 7 {
+                            // Before reaching the inline size
+                            tokio::task::spawn_local(CleanupPending);
+                        }
+                    }
+                    ArbiterCommand::ExecuteFn(f) => {
+                        f.call_box();
+                    }
+                },
+                Poll::Pending => return Poll::Pending,
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum SystemCommand {
+    Exit(i32),
+    RegisterArbiter(usize, Arbiter),
+    UnregisterArbiter(usize),
+}
+
+#[derive(Debug)]
+pub(crate) struct SystemArbiter {
+    stop: Option<Sender<i32>>,
+    commands: UnboundedReceiver<SystemCommand>,
+    arbiters: HashMap<usize, Arbiter>,
+}
+
+impl SystemArbiter {
+    pub(crate) fn new(stop: Sender<i32>, commands: UnboundedReceiver<SystemCommand>) -> Self {
+        SystemArbiter {
+            commands,
+            stop: Some(stop),
+            arbiters: HashMap::new(),
+        }
+    }
+}
+
+impl Future for SystemArbiter {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            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() {
+                            arb.stop();
+                        }
+                        // stop event loop
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(code);
+                        }
+                    }
+                    SystemCommand::RegisterArbiter(name, hnd) => {
+                        self.arbiters.insert(name, hnd);
+                    }
+                    SystemCommand::UnregisterArbiter(name) => {
+                        self.arbiters.remove(&name);
+                    }
+                },
+                Poll::Pending => return Poll::Pending,
+            }
+        }
+    }
+}
+
+pub trait FnExec: Send + 'static {
+    fn call_box(self: Box<Self>);
+}
+
+impl<F> FnExec for F
+where
+    F: FnOnce() + Send + 'static,
+{
+    #[allow(clippy::boxed_local)]
+    fn call_box(self: Box<Self>) {
+        (*self)()
+    }
+}

actix-rt/src/builder.rs

@@ -0,0 +1,191 @@
+use std::borrow::Cow;
+use std::io;
+
+use futures_channel::mpsc::unbounded;
+use futures_channel::oneshot::{channel, Receiver};
+use futures_util::future::{lazy, Future, FutureExt};
+use tokio::task::LocalSet;
+
+use crate::arbiter::{Arbiter, SystemArbiter};
+use crate::runtime::Runtime;
+use crate::system::System;
+
+/// Builder struct for a actix runtime.
+///
+/// Either use `Builder::build` to create a system and start actors.
+/// Alternatively, use `Builder::run` to start the tokio runtime and
+/// run a function in its context.
+pub struct Builder {
+    /// Name of the System. Defaults to "actix" if unset.
+    name: Cow<'static, str>,
+
+    /// Whether the Arbiter will stop the whole System on uncaught panic. Defaults to false.
+    stop_on_panic: bool,
+}
+
+impl Builder {
+    pub(crate) fn new() -> Self {
+        Builder {
+            name: Cow::Borrowed("actix"),
+            stop_on_panic: false,
+        }
+    }
+
+    /// Sets the name of the System.
+    pub fn name<T: Into<String>>(mut self, name: T) -> Self {
+        self.name = Cow::Owned(name.into());
+        self
+    }
+
+    /// Sets the option 'stop_on_panic' which controls whether the System is stopped when an
+    /// uncaught panic is thrown from a worker thread.
+    ///
+    /// Defaults to false.
+    pub fn stop_on_panic(mut self, stop_on_panic: bool) -> Self {
+        self.stop_on_panic = stop_on_panic;
+        self
+    }
+
+    /// Create new System.
+    ///
+    /// This method panics if it can not create tokio runtime
+    pub fn build(self) -> SystemRunner {
+        self.create_runtime(|| {})
+    }
+
+    /// Create new System that can run asynchronously.
+    ///
+    /// This method panics if it cannot start the system arbiter
+    pub(crate) fn build_async(self, 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) -> 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,
+    {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+
+        // system arbiter
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);
+
+        let mut rt = Runtime::new().unwrap();
+        rt.spawn(arb);
+
+        // init system arbiter and run configuration method
+        rt.block_on(lazy(move |_| f()));
+
+        SystemRunner { rt, stop, system }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct AsyncSystemRunner {
+    stop: Receiver<i32>,
+    system: System,
+}
+
+impl AsyncSystemRunner {
+    /// This function will start event loop and returns a future that
+    /// resolves once the `System::stop()` function is called.
+    pub(crate) fn run_nonblocking(self) -> impl Future<Output = Result<(), io::Error>> + Send {
+        let AsyncSystemRunner { stop, .. } = self;
+
+        // 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()
+    }
+}
+
+/// Helper object that runs System's event loop
+#[must_use = "SystemRunner must be run"]
+#[derive(Debug)]
+pub struct SystemRunner {
+    rt: Runtime,
+    stop: Receiver<i32>,
+    system: System,
+}
+
+impl SystemRunner {
+    /// This function will start event loop and will finish once the
+    /// `System::stop()` function is called.
+    pub fn run(self) -> io::Result<()> {
+        let SystemRunner { mut rt, stop, .. } = self;
+
+        // run loop
+        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();
+        result
+    }
+
+    /// Execute a future and wait for result.
+    pub fn block_on<F, O>(&mut self, fut: F) -> O
+    where
+        F: Future<Output = O> + 'static,
+    {
+        Arbiter::run_system(Some(&self.rt));
+        let res = self.rt.block_on(fut);
+        Arbiter::stop_system();
+        res
+    }
+}

actix-rt/src/lib.rs

@@ -0,0 +1,66 @@
+//! 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;
+mod runtime;
+mod system;
+
+pub use self::arbiter::Arbiter;
+pub use self::builder::{Builder, SystemRunner};
+pub use self::runtime::Runtime;
+pub use self::system::System;
+
+#[doc(hidden)]
+pub use actix_threadpool as blocking;
+
+/// Spawns a future on the current arbiter.
+///
+/// # Panics
+///
+/// This function panics if actix system is not running.
+pub fn spawn<F>(f: F)
+where
+    F: futures_util::future::Future<Output = ()> + 'static,
+{
+    if !System::is_set() {
+        panic!("System is not running");
+    }
+
+    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/runtime.rs

@@ -0,0 +1,91 @@
+use std::future::Future;
+use std::io;
+use tokio::{runtime, task::LocalSet};
+
+/// Single-threaded runtime provides a way to start reactor
+/// and runtime on the current thread.
+///
+/// See [module level][mod] documentation for more details.
+///
+/// [mod]: index.html
+#[derive(Debug)]
+pub struct Runtime {
+    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> {
+        let rt = runtime::Builder::new()
+            .enable_io()
+            .enable_time()
+            .basic_scheduler()
+            .build()?;
+
+        Ok(Runtime {
+            rt,
+            local: LocalSet::new(),
+        })
+    }
+
+    /// Spawn a future onto the single-threaded runtime.
+    ///
+    /// See [module level][mod] documentation for more details.
+    ///
+    /// [mod]: index.html
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// # use futures::{future, Future, Stream};
+    /// use actix_rt::Runtime;
+    ///
+    /// # fn dox() {
+    /// // Create the runtime
+    /// let mut rt = Runtime::new().unwrap();
+    ///
+    /// // Spawn a future onto the runtime
+    /// rt.spawn(future::lazy(|_| {
+    ///     println!("running on the runtime");
+    /// }));
+    /// # }
+    /// # pub fn main() {}
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the spawn fails. Failure occurs if the executor
+    /// is currently at capacity and is unable to spawn a new future.
+    pub fn spawn<F>(&self, future: F) -> &Self
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        self.local.spawn_local(future);
+        self
+    }
+
+    /// Runs the provided future, blocking the current thread until the future
+    /// completes.
+    ///
+    /// This function can be used to synchronously block the current thread
+    /// until the provided `future` has resolved either successfully or with an
+    /// error. The result of the future is then returned from this function
+    /// call.
+    ///
+    /// Note that this function will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed. Once the function returns, any uncompleted futures
+    /// remain pending in the `Runtime` instance. These futures will not run
+    /// until `block_on` or `run` is called again.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution by calling `block_on` or `run`.
+    pub fn block_on<F>(&mut self, f: F) -> F::Output
+    where
+        F: Future + 'static,
+    {
+        self.local.block_on(&mut self.rt, f)
+    }
+}

actix-rt/src/system.rs

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

actix-rt/tests/integration_tests.rs

@@ -0,0 +1,114 @@
+use std::time::{Duration, Instant};
+
+#[test]
+fn start_and_stop() {
+    actix_rt::System::new("start_and_stop").block_on(async move {
+        assert!(
+            actix_rt::Arbiter::is_running(),
+            "System doesn't seem to have started"
+        );
+    });
+    assert!(
+        !actix_rt::Arbiter::is_running(),
+        "System doesn't seem to have stopped"
+    );
+}
+
+#[test]
+fn await_for_timer() {
+    let time = Duration::from_secs(2);
+    let instant = Instant::now();
+    actix_rt::System::new("test_wait_timer").block_on(async move {
+        tokio::time::delay_for(time).await;
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Block on should poll awaited future to completion"
+    );
+}
+
+#[test]
+fn join_another_arbiter() {
+    let time = Duration::from_secs(2);
+    let instant = Instant::now();
+    actix_rt::System::new("test_join_another_arbiter").block_on(async move {
+        let mut arbiter = actix_rt::Arbiter::new();
+        arbiter.send(Box::pin(async move {
+            tokio::time::delay_for(time).await;
+            actix_rt::Arbiter::current().stop();
+        }));
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on another arbiter should complete only when it calls stop"
+    );
+
+    let instant = Instant::now();
+    actix_rt::System::new("test_join_another_arbiter").block_on(async move {
+        let mut arbiter = actix_rt::Arbiter::new();
+        arbiter.exec_fn(move || {
+            actix_rt::spawn(async move {
+                tokio::time::delay_for(time).await;
+                actix_rt::Arbiter::current().stop();
+            });
+        });
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on a arbiter that has used actix_rt::spawn should wait for said future"
+    );
+
+    let instant = Instant::now();
+    actix_rt::System::new("test_join_another_arbiter").block_on(async move {
+        let mut arbiter = actix_rt::Arbiter::new();
+        arbiter.send(Box::pin(async move {
+            tokio::time::delay_for(time).await;
+            actix_rt::Arbiter::current().stop();
+        }));
+        arbiter.stop();
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() < time,
+        "Premature stop of arbiter should conclude regardless of it's current state"
+    );
+}
+
+#[test]
+fn join_current_arbiter() {
+    let time = Duration::from_secs(2);
+
+    let instant = Instant::now();
+    actix_rt::System::new("test_join_current_arbiter").block_on(async move {
+        actix_rt::spawn(async move {
+            tokio::time::delay_for(time).await;
+            actix_rt::Arbiter::current().stop();
+        });
+        actix_rt::Arbiter::local_join().await;
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on current arbiter should wait for all spawned futures"
+    );
+
+    let large_timer = Duration::from_secs(20);
+    let instant = Instant::now();
+    actix_rt::System::new("test_join_current_arbiter").block_on(async move {
+        actix_rt::spawn(async move {
+            tokio::time::delay_for(time).await;
+            actix_rt::Arbiter::current().stop();
+        });
+        let f = actix_rt::Arbiter::local_join();
+        actix_rt::spawn(async move {
+            tokio::time::delay_for(large_timer).await;
+            actix_rt::Arbiter::current().stop();
+        });
+        f.await;
+    });
+    assert!(
+        instant.elapsed() < large_timer,
+        "local_join should await only for the already spawned futures"
+    );
+}

actix-server/CHANGES.md

@@ -0,0 +1,210 @@
+# Changes
+
+## [1.0.3] - 2020-05-19
+
+### Changed
+
+* Replace deprecated `net2` crate with `socket2` [#140]
+
+[#140]: https://github.com/actix/actix-net/pull/140
+
+## [1.0.2] - 2020-02-26
+
+### Fixed
+
+* Avoid error by calling `reregister()` on Windows [#103]
+
+[#103]: https://github.com/actix/actix-net/pull/103
+
+## [1.0.1] - 2019-12-29
+
+### Changed
+
+* Rename `.start()` method to `.run()`
+
+## [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
+
+### Changed
+
+* Migrate to actix-service 0.2
+
+* Updated rustls dependency
+
+
+## [0.1.3] - 2018-12-21
+
+### Fixed
+
+* Fix max concurrent connections handling
+
+
+## [0.1.2] - 2018-12-12
+
+### Changed
+
+* rename ServiceConfig::rt() to ServiceConfig::apply()
+
+
+### Fixed
+
+* Fix back-pressure for concurrent ssl handshakes
+
+
+## [0.1.1] - 2018-12-11
+
+* Fix signal handling on windows
+
+
+## [0.1.0] - 2018-12-09
+
+* Move server to separate crate

actix-server/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "actix-server"
+version = "1.0.3"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix server - General purpose tcp server"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-server/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+exclude = [".gitignore", ".cargo/config"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_server"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+[dependencies]
+actix-service = "1.0.1"
+actix-rt = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.4"
+
+log = "0.4"
+num_cpus = "1.11"
+mio = "0.6.19"
+socket2 = "0.3"
+futures-channel = { version = "0.3.4", default-features = false }
+futures-util = { version = "0.3.4", default-features = false, features = ["sink"] }
+slab = "0.4"
+
+# unix domain sockets
+# FIXME: Remove it and use mio own uds feature once mio 0.7 is released
+mio-uds = { version = "0.6.7" }
+
+[dev-dependencies]
+bytes = "0.5"
+env_logger = "0.7"
+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 futures::{sync::mpsc, Future};
-use mio;
+use actix_rt::time::{delay_until, Instant};
+use actix_rt::System;
+use log::{error, info};
 use slab::Slab;
-use tokio_timer::Delay;
 
-use actix::{msgs::Execute, Arbiter, System};
-
-use super::server::ServerCommand;
-use super::worker::{Conn, WorkerClient};
-use super::Token;
+use crate::server::Server;
+use crate::socket::{SocketAddr, SocketListener, StdListener};
+use crate::worker::{Conn, WorkerClient};
+use crate::Token;
 
 pub(crate) enum Command {
     Pause,
@@ -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>,
 }
 
@@ -53,14 +52,11 @@ pub(crate) struct AcceptLoop {
     notify_ready: mio::SetReadiness,
     tx: sync_mpsc::Sender<Command>,
     rx: Option<sync_mpsc::Receiver<Command>>,
-    srv: Option<(
-        mpsc::UnboundedSender<ServerCommand>,
-        mpsc::UnboundedReceiver<ServerCommand>,
-    )>,
+    srv: Option<Server>,
 }
 
 impl AcceptLoop {
-    pub fn new() -> AcceptLoop {
+    pub fn new(srv: Server) -> AcceptLoop {
         let (tx, rx) = sync_mpsc::channel();
         let (cmd_reg, cmd_ready) = mio::Registration::new2();
         let (notify_reg, notify_ready) = mio::Registration::new2();
@@ -72,7 +68,7 @@ impl AcceptLoop {
             notify_ready,
             notify_reg: Some(notify_reg),
             rx: Some(rx),
-            srv: Some(mpsc::unbounded()),
+            srv: Some(srv),
         }
     }
 
@@ -87,20 +83,19 @@ impl AcceptLoop {
 
     pub(crate) fn start(
         &mut self,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
-    ) -> mpsc::UnboundedReceiver<ServerCommand> {
-        let (tx, rx) = self.srv.take().expect("Can not re-use AcceptInfo");
+    ) {
+        let srv = self.srv.take().expect("Can not re-use AcceptInfo");
 
         Accept::start(
             self.rx.take().expect("Can not re-use AcceptInfo"),
             self.cmd_reg.take().expect("Can not re-use AcceptInfo"),
             self.notify_reg.take().expect("Can not re-use AcceptInfo"),
             socks,
-            tx,
+            srv,
             workers,
         );
-        rx
     }
 }
 
@@ -109,7 +104,7 @@ struct Accept {
     rx: sync_mpsc::Receiver<Command>,
     sockets: Slab<ServerSocketInfo>,
     workers: Vec<WorkerClient>,
-    srv: mpsc::UnboundedSender<ServerCommand>,
+    srv: Server,
     timer: (mio::Registration, mio::SetReadiness),
     next: usize,
     backpressure: bool,
@@ -134,20 +129,20 @@ fn connection_error(e: &io::Error) -> bool {
 }
 
 impl Accept {
-    #![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
+    #![allow(clippy::too_many_arguments)]
     pub(crate) fn start(
         rx: sync_mpsc::Receiver<Command>,
         cmd_reg: mio::Registration,
         notify_reg: mio::Registration,
-        socks: Vec<(Token, net::TcpListener)>,
-        srv: mpsc::UnboundedSender<ServerCommand>,
+        socks: Vec<(Token, StdListener)>,
+        srv: Server,
         workers: Vec<WorkerClient>,
     ) {
         let sys = System::current();
 
         // start accept thread
         let _ = thread::Builder::new()
-            .name("actix-web accept loop".to_owned())
+            .name("actix-server accept loop".to_owned())
             .spawn(move || {
                 System::set_current(sys);
                 let mut accept = Accept::new(rx, socks, workers, srv);
@@ -178,9 +173,9 @@ impl Accept {
 
     fn new(
         rx: sync_mpsc::Receiver<Command>,
-        socks: Vec<(Token, net::TcpListener)>,
+        socks: Vec<(Token, StdListener)>,
         workers: Vec<WorkerClient>,
-        srv: mpsc::UnboundedSender<ServerCommand>,
+        srv: Server,
     ) -> Accept {
         // Create a poll instance
         let poll = match mio::Poll::new() {
@@ -191,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();
 
@@ -304,12 +298,7 @@ impl Accept {
                     }
                     Command::Resume => {
                         for (token, info) in self.sockets.iter() {
-                            if let Err(err) = self.poll.register(
-                                &info.sock,
-                                mio::Token(token + DELTA),
-                                mio::Ready::readable(),
-                                mio::PollOpt::edge(),
-                            ) {
+                            if let Err(err) = self.register(token, info) {
                                 error!("Can not resume socket accept process: {}", err);
                             } else {
                                 info!(
@@ -344,17 +333,44 @@ impl Accept {
         true
     }
 
+    #[cfg(not(target_os = "windows"))]
+    fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> {
+        self.poll.register(
+            &info.sock,
+            mio::Token(token + DELTA),
+            mio::Ready::readable(),
+            mio::PollOpt::edge(),
+        )
+    }
+
+    #[cfg(target_os = "windows")]
+    fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> {
+        // On windows, calling register without deregister cause an error.
+        // See https://github.com/actix/actix-web/issues/905
+        // Calling reregister seems to fix the issue.
+        self.poll
+            .register(
+                &info.sock,
+                mio::Token(token + DELTA),
+                mio::Ready::readable(),
+                mio::PollOpt::edge(),
+            )
+            .or_else(|_| {
+                self.poll.reregister(
+                    &info.sock,
+                    mio::Token(token + DELTA),
+                    mio::Ready::readable(),
+                    mio::PollOpt::edge(),
+                )
+            })
+    }
+
     fn backpressure(&mut self, on: bool) {
         if self.backpressure {
             if !on {
                 self.backpressure = false;
                 for (token, info) in self.sockets.iter() {
-                    if let Err(err) = self.poll.register(
-                        &info.sock,
-                        mio::Token(token + DELTA),
-                        mio::Ready::readable(),
-                        mio::PollOpt::edge(),
-                    ) {
+                    if let Err(err) = self.register(token, info) {
                         error!("Can not resume socket accept process: {}", err);
                     } else {
                         info!("Accepting connections on {} has been resumed", info.addr);
@@ -375,9 +391,7 @@ impl Accept {
                 match self.workers[self.next].send(msg) {
                     Ok(_) => (),
                     Err(tmp) => {
-                        let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
-                            self.workers[self.next].idx,
-                        ));
+                        self.srv.worker_faulted(self.workers[self.next].idx);
                         msg = tmp;
                         self.workers.swap_remove(self.next);
                         if self.workers.is_empty() {
@@ -403,9 +417,7 @@ impl Accept {
                             return;
                         }
                         Err(tmp) => {
-                            let _ = self.srv.unbounded_send(ServerCommand::WorkerDied(
-                                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() {
@@ -430,12 +442,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) => {
@@ -448,19 +461,10 @@ impl Accept {
                         info.timeout = Some(Instant::now() + Duration::from_millis(500));
 
                         let r = self.timer.1.clone();
-                        System::current().arbiter().do_send(Execute::new(
-                            move || -> Result<(), ()> {
-                                Arbiter::spawn(
-                                    Delay::new(Instant::now() + Duration::from_millis(510))
-                                        .map_err(|_| ())
-                                        .and_then(move |_| {
-                                            let _ = r.set_readiness(mio::Ready::readable());
-                                            Ok(())
-                                        }),
-                                );
-                                Ok(())
-                            },
-                        ));
+                        System::current().arbiter().send(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

@@ -0,0 +1,499 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::time::Duration;
+use std::{io, mem, net};
+
+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_util::future::ready;
+use futures_util::stream::FuturesUnordered;
+use futures_util::{future::Future, ready, stream::Stream, FutureExt, StreamExt};
+use log::{error, info};
+use socket2::{Domain, Protocol, Socket, Type};
+
+use crate::accept::{AcceptLoop, AcceptNotify, Command};
+use crate::config::{ConfiguredService, ServiceConfig};
+use crate::server::{Server, ServerCommand};
+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;
+
+/// Server builder
+pub struct ServerBuilder {
+    threads: usize,
+    token: Token,
+    backlog: i32,
+    workers: Vec<(usize, WorkerClient)>,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    sockets: Vec<(Token, String, StdListener)>,
+    accept: AcceptLoop,
+    exit: bool,
+    shutdown_timeout: Duration,
+    no_signals: bool,
+    cmd: UnboundedReceiver<ServerCommand>,
+    server: Server,
+    notify: Vec<oneshot::Sender<()>>,
+}
+
+impl Default for ServerBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ServerBuilder {
+    /// Create new Server builder instance
+    pub fn new() -> ServerBuilder {
+        let (tx, rx) = unbounded();
+        let server = Server::new(tx);
+
+        ServerBuilder {
+            threads: num_cpus::get(),
+            token: Token(0),
+            workers: Vec::new(),
+            services: Vec::new(),
+            sockets: Vec::new(),
+            accept: AcceptLoop::new(server.clone()),
+            backlog: 2048,
+            exit: false,
+            shutdown_timeout: Duration::from_secs(30),
+            no_signals: false,
+            cmd: rx,
+            notify: Vec::new(),
+            server,
+        }
+    }
+
+    /// Set number of workers to start.
+    ///
+    /// By default server uses number of available logical cpu as workers
+    /// count.
+    pub fn workers(mut self, num: usize) -> Self {
+        self.threads = num;
+        self
+    }
+
+    /// Set the maximum number of pending connections.
+    ///
+    /// This refers to the number of clients that can be waiting to be served.
+    /// Exceeding this number results in the client getting an error when
+    /// attempting to connect. It should only affect servers under significant
+    /// load.
+    ///
+    /// Generally set in the 64-2048 range. Default value is 2048.
+    ///
+    /// This method should be called before `bind()` method call.
+    pub fn backlog(mut self, num: i32) -> Self {
+        self.backlog = num;
+        self
+    }
+
+    /// Sets the maximum per-worker number of concurrent connections.
+    ///
+    /// All socket listeners will stop accepting connections when this limit is
+    /// reached for each worker.
+    ///
+    /// By default max connections is set to a 25k per worker.
+    pub fn maxconn(self, num: usize) -> Self {
+        worker::max_concurrent_connections(num);
+        self
+    }
+
+    /// Stop actix system.
+    pub fn system_exit(mut self) -> Self {
+        self.exit = true;
+        self
+    }
+
+    /// Disable signal handling
+    pub fn disable_signals(mut self) -> Self {
+        self.no_signals = true;
+        self
+    }
+
+    /// Timeout for graceful workers shutdown in seconds.
+    ///
+    /// After receiving a stop signal, workers have this much time to finish
+    /// serving requests. Workers still alive after the timeout are force
+    /// dropped.
+    ///
+    /// By default shutdown timeout sets to 30 seconds.
+    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
+        self.shutdown_timeout = Duration::from_secs(sec);
+        self
+    }
+
+    /// Execute external configuration as part of the server building
+    /// process.
+    ///
+    /// This function is useful for moving parts of configuration to a
+    /// different module or even library.
+    pub fn configure<F>(mut self, f: F) -> io::Result<ServerBuilder>
+    where
+        F: Fn(&mut ServiceConfig) -> io::Result<()>,
+    {
+        let mut cfg = ServiceConfig::new(self.threads, self.backlog);
+
+        f(&mut cfg)?;
+
+        if let Some(apply) = cfg.apply {
+            let mut srv = ConfiguredService::new(apply);
+            for (name, lst) in cfg.services {
+                let token = self.token.next();
+                srv.stream(token, name.clone(), lst.local_addr()?);
+                self.sockets.push((token, name, StdListener::Tcp(lst)));
+            }
+            self.services.push(Box::new(srv));
+        }
+        self.threads = cfg.threads;
+
+        Ok(self)
+    }
+
+    /// Add new service to the server.
+    pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
+    where
+        F: ServiceFactory<TcpStream>,
+        U: net::ToSocketAddrs,
+    {
+        let sockets = bind_addr(addr, self.backlog)?;
+
+        for lst in sockets {
+            let token = self.token.next();
+            self.services.push(StreamNewService::create(
+                name.as_ref().to_string(),
+                token,
+                factory.clone(),
+                lst.local_addr()?,
+            ));
+            self.sockets
+                .push((token, name.as_ref().to_string(), 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,
+            addr,
+        ));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Uds(lst)));
+        Ok(self)
+    }
+
+    /// Add new service to the server.
+    pub fn listen<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: net::TcpListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServiceFactory<TcpStream>,
+    {
+        let token = self.token.next();
+        self.services.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+            lst.local_addr()?,
+        ));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
+        Ok(self)
+    }
+
+    #[doc(hidden)]
+    pub fn start(self) -> Server {
+        self.run()
+    }
+
+    /// Starts processing incoming connections and return server controller.
+    pub fn run(mut self) -> Server {
+        if self.sockets.is_empty() {
+            panic!("Server should have at least one bound socket");
+        } else {
+            info!("Starting {} workers", self.threads);
+
+            // start workers
+            let workers = (0..self.threads)
+                .map(|idx| {
+                    let worker = self.start_worker(idx, self.accept.get_notify());
+                    self.workers.push((idx, worker.clone()));
+
+                    worker
+                })
+                .collect();
+
+            // start accept thread
+            for sock in &self.sockets {
+                info!("Starting \"{}\" service on {}", sock.1, sock.2);
+            }
+            self.accept.start(
+                mem::replace(&mut self.sockets, Vec::new())
+                    .into_iter()
+                    .map(|t| (t.0, t.2))
+                    .collect(),
+                workers,
+            );
+
+            // handle signals
+            if !self.no_signals {
+                Signals::start(self.server.clone()).unwrap();
+            }
+
+            // start http server actor
+            let server = self.server.clone();
+            spawn(self);
+            server
+        }
+    }
+
+    fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
+        let avail = WorkerAvailability::new(notify);
+        let services: Vec<Box<dyn InternalServiceFactory>> =
+            self.services.iter().map(|v| v.clone_factory()).collect();
+
+        Worker::start(idx, services, avail, self.shutdown_timeout)
+    }
+
+    fn handle_cmd(&mut self, item: ServerCommand) {
+        match item {
+            ServerCommand::Pause(tx) => {
+                self.accept.send(Command::Pause);
+                let _ = tx.send(());
+            }
+            ServerCommand::Resume(tx) => {
+                self.accept.send(Command::Resume);
+                let _ = tx.send(());
+            }
+            ServerCommand::Signal(sig) => {
+                // Signals support
+                // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
+                match sig {
+                    Signal::Int => {
+                        info!("SIGINT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    Signal::Term => {
+                        info!("SIGTERM received, stopping");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: true,
+                            completion: None,
+                        })
+                    }
+                    Signal::Quit => {
+                        info!("SIGQUIT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    _ => (),
+                }
+            }
+            ServerCommand::Notify(tx) => {
+                self.notify.push(tx);
+            }
+            ServerCommand::Stop {
+                graceful,
+                completion,
+            } => {
+                let exit = self.exit;
+
+                // 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() && graceful {
+                    spawn(
+                        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(
+                            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::WorkerFaulted(idx) => {
+                let mut found = false;
+                for i in 0..self.workers.len() {
+                    if self.workers[i].0 == idx {
+                        self.workers.swap_remove(i);
+                        found = true;
+                        break;
+                    }
+                }
+
+                if found {
+                    error!("Worker has died {:?}, restarting", idx);
+
+                    let mut new_idx = self.workers.len();
+                    'found: loop {
+                        for i in 0..self.workers.len() {
+                            if self.workers[i].0 == new_idx {
+                                new_idx += 1;
+                                continue 'found;
+                            }
+                        }
+                        break;
+                    }
+
+                    let worker = self.start_worker(new_idx, self.accept.get_notify());
+                    self.workers.push((new_idx, worker.clone()));
+                    self.accept.send(Command::Worker(worker));
+                }
+            }
+        }
+    }
+}
+
+impl Future for ServerBuilder {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            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,
+    backlog: i32,
+) -> io::Result<Vec<net::TcpListener>> {
+    let mut err = None;
+    let mut succ = false;
+    let mut sockets = Vec::new();
+    for addr in addr.to_socket_addrs()? {
+        match create_tcp_listener(addr, backlog) {
+            Ok(lst) => {
+                succ = true;
+                sockets.push(lst);
+            }
+            Err(e) => err = Some(e),
+        }
+    }
+
+    if !succ {
+        if let Some(e) = err.take() {
+            Err(e)
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Can not bind to address.",
+            ))
+        }
+    } else {
+        Ok(sockets)
+    }
+}
+
+fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
+    let domain = match addr {
+        net::SocketAddr::V4(_) => Domain::ipv4(),
+        net::SocketAddr::V6(_) => Domain::ipv6(),
+    };
+    let socket = Socket::new(domain, Type::stream(), Some(Protocol::tcp()))?;
+    socket.set_reuse_address(true)?;
+    socket.bind(&addr.into())?;
+    socket.listen(backlog)?;
+    Ok(socket.into_tcp_listener())
+}

actix-server/src/config.rs

@@ -0,0 +1,285 @@
+use std::collections::HashMap;
+use std::{fmt, io, net};
+
+use actix_rt::net::TcpStream;
+use actix_service as actix;
+use actix_utils::counter::CounterGuard;
+use futures_util::future::{ok, Future, FutureExt, LocalBoxFuture};
+use log::error;
+
+use super::builder::bind_addr;
+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<dyn ServiceRuntimeConfiguration>>,
+    pub(crate) threads: usize,
+    pub(crate) backlog: i32,
+}
+
+impl ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
+        ServiceConfig {
+            threads,
+            backlog,
+            services: Vec::new(),
+            apply: None,
+        }
+    }
+
+    /// Set number of workers to start.
+    ///
+    /// By default server uses number of available logical cpu as workers
+    /// count.
+    pub fn workers(&mut self, num: usize) {
+        self.threads = num;
+    }
+
+    /// Add new service to server
+    pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
+    where
+        U: net::ToSocketAddrs,
+    {
+        let sockets = bind_addr(addr, self.backlog)?;
+
+        for lst in sockets {
+            self.listen(name.as_ref(), lst);
+        }
+
+        Ok(self)
+    }
+
+    /// Add new service to server
+    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
+        if self.apply.is_none() {
+            self.apply = Some(Box::new(not_configured));
+        }
+        self.services.push((name.as_ref().to_string(), lst));
+        self
+    }
+
+    /// Register service configuration function. This function get called
+    /// during worker runtime configuration. It get executed in worker thread.
+    pub fn apply<F>(&mut self, f: F) -> io::Result<()>
+    where
+        F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
+    {
+        self.apply = Some(Box::new(f));
+        Ok(())
+    }
+}
+
+pub(super) struct ConfiguredService {
+    rt: Box<dyn ServiceRuntimeConfiguration>,
+    names: HashMap<Token, (String, net::SocketAddr)>,
+    topics: HashMap<String, Token>,
+    services: Vec<Token>,
+}
+
+impl ConfiguredService {
+    pub(super) fn new(rt: Box<dyn ServiceRuntimeConfiguration>) -> Self {
+        ConfiguredService {
+            rt,
+            names: HashMap::new(),
+            topics: HashMap::new(),
+            services: Vec::new(),
+        }
+    }
+
+    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
+        self.names.insert(token, (name.clone(), addr));
+        self.topics.insert(name, token);
+        self.services.push(token);
+    }
+}
+
+impl InternalServiceFactory for ConfiguredService {
+    fn name(&self, token: Token) -> &str {
+        &self.names[&token].0
+    }
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            rt: self.rt.clone(),
+            names: self.names.clone(),
+            topics: self.topics.clone(),
+            services: self.services.clone(),
+        })
+    }
+
+    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
+        // configure services
+        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
+        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);
+        }
+        .boxed_local()
+    }
+}
+
+pub(super) trait ServiceRuntimeConfiguration: Send {
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration>;
+
+    fn configure(&self, rt: &mut ServiceRuntime);
+}
+
+impl<F> ServiceRuntimeConfiguration for F
+where
+    F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
+{
+    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration> {
+        Box::new(self.clone())
+    }
+
+    fn configure(&self, rt: &mut ServiceRuntime) {
+        (self)(rt)
+    }
+}
+
+fn not_configured(_: &mut ServiceRuntime) {
+    error!("Service is not configured");
+}
+
+pub struct ServiceRuntime {
+    names: HashMap<String, Token>,
+    services: HashMap<Token, BoxedNewService>,
+    onstart: Vec<LocalBoxFuture<'static, ()>>,
+}
+
+impl ServiceRuntime {
+    fn new(names: HashMap<String, Token>) -> Self {
+        ServiceRuntime {
+            names,
+            services: HashMap::new(),
+            onstart: Vec::new(),
+        }
+    }
+
+    fn validate(&self) {
+        for (name, token) in &self.names {
+            if !self.services.contains_key(&token) {
+                error!("Service {:?} is not configured", name);
+            }
+        }
+    }
+
+    /// Register service.
+    ///
+    /// Name of the service must be registered during configuration stage with
+    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
+    pub fn service<T, F>(&mut self, name: &str, service: F)
+    where
+        F: actix::IntoServiceFactory<T>,
+        T: actix::ServiceFactory<Config = (), Request = TcpStream> + 'static,
+        T::Future: 'static,
+        T::Service: 'static,
+        T::InitError: fmt::Debug,
+    {
+        // let name = name.to_owned();
+        if let Some(token) = self.names.get(name) {
+            self.services.insert(
+                *token,
+                Box::new(ServiceFactory {
+                    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<
+    dyn actix::ServiceFactory<
+        Request = (Option<CounterGuard>, ServerMessage),
+        Response = (),
+        Error = (),
+        InitError = (),
+        Config = (),
+        Service = BoxedServerService,
+        Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>,
+    >,
+>;
+
+struct ServiceFactory<T> {
+    inner: T,
+}
+
+impl<T> actix::ServiceFactory for ServiceFactory<T>
+where
+    T: actix::ServiceFactory<Config = (), Request = TcpStream>,
+    T::Future: 'static,
+    T::Service: 'static,
+    T::Error: 'static,
+    T::InitError: fmt::Debug + 'static,
+{
+    type Request = (Option<CounterGuard>, ServerMessage);
+    type Response = ();
+    type Error = ();
+    type InitError = ();
+    type Config = ();
+    type Service = BoxedServerService;
+    type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
+
+    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/lib.rs

@@ -0,0 +1,37 @@
+//! General purpose tcp server
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
+mod accept;
+mod builder;
+mod config;
+mod server;
+mod service;
+mod signals;
+mod socket;
+mod worker;
+
+pub use self::builder::ServerBuilder;
+pub use self::config::{ServiceConfig, ServiceRuntime};
+pub use self::server::Server;
+pub use self::service::ServiceFactory;
+
+#[doc(hidden)]
+pub use self::socket::FromStream;
+
+/// Socket id token
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct Token(usize);
+
+impl Token {
+    pub(crate) fn next(&mut self) -> Token {
+        let token = Token(self.0);
+        self.0 += 1;
+        token
+    }
+}
+
+/// Start server building process
+pub fn new() -> ServerBuilder {
+    ServerBuilder::default()
+}

actix-server/src/server.rs

@@ -0,0 +1,108 @@
+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_util::FutureExt;
+
+use crate::builder::ServerBuilder;
+use crate::signals::Signal;
+
+#[derive(Debug)]
+pub(crate) enum ServerCommand {
+    WorkerFaulted(usize),
+    Pause(oneshot::Sender<()>),
+    Resume(oneshot::Sender<()>),
+    Signal(Signal),
+    /// Whether to try and shut down gracefully
+    Stop {
+        graceful: bool,
+        completion: Option<oneshot::Sender<()>>,
+    },
+    /// Notify of server stop
+    Notify(oneshot::Sender<()>),
+}
+
+#[derive(Debug)]
+pub struct Server(
+    UnboundedSender<ServerCommand>,
+    Option<oneshot::Receiver<()>>,
+);
+
+impl Server {
+    pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
+        Server(tx, None)
+    }
+
+    /// Start server building process
+    pub fn build() -> ServerBuilder {
+        ServerBuilder::default()
+    }
+
+    pub(crate) fn signal(&self, sig: Signal) {
+        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+    }
+
+    pub(crate) fn worker_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<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
+        rx.map(|_| ())
+    }
+
+    /// Resume accepting incoming connections
+    pub fn resume(&self) -> impl Future<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
+        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<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(ServerCommand::Stop {
+            graceful,
+            completion: Some(tx),
+        });
+        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_util::future::{err, ok, LocalBoxFuture, Ready};
+use futures_util::{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/signals.rs

@@ -0,0 +1,103 @@
+use std::future::Future;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures_util::future::lazy;
+
+use crate::server::Server;
+
+/// Different types of process signals
+#[allow(dead_code)]
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub(crate) enum Signal {
+    /// SIGHUP
+    Hup,
+    /// SIGINT
+    Int,
+    /// SIGTERM
+    Term,
+    /// SIGQUIT
+    Quit,
+}
+
+pub(crate) struct Signals {
+    srv: Server,
+    #[cfg(not(unix))]
+    stream: Pin<Box<dyn Future<Output = io::Result<()>>>>,
+    #[cfg(unix)]
+    streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
+}
+
+impl Signals {
+    pub(crate) fn start(srv: Server) -> io::Result<()> {
+        actix_rt::spawn(lazy(|_| {
+            #[cfg(not(unix))]
+            {
+                actix_rt::spawn(Signals {
+                    srv,
+                    stream: Box::pin(actix_rt::signal::ctrl_c()),
+                });
+            }
+            #[cfg(unix)]
+            {
+                use actix_rt::signal::unix;
+
+                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 })
+            }
+        }));
+
+        Ok(())
+    }
+}
+
+impl Future for Signals {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        #[cfg(not(unix))]
+        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 idx in 0..self.streams.len() {
+                loop {
+                    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);
+                        }
+                    }
+                }
+            }
+            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/worker.rs

@@ -0,0 +1,492 @@
+use std::pin::Pin;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use std::time;
+
+use actix_rt::time::{delay_until, Delay, Instant};
+use actix_rt::{spawn, Arbiter};
+use actix_utils::counter::Counter;
+use futures_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures_channel::oneshot;
+use futures_util::future::{join_all, LocalBoxFuture, MapOk};
+use futures_util::{future::Future, stream::Stream, FutureExt, TryFutureExt};
+use log::{error, info, trace};
+
+use crate::accept::AcceptNotify;
+use crate::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::socket::{SocketAddr, StdStream};
+use crate::Token;
+
+pub(crate) struct WorkerCommand(Conn);
+
+/// Stop worker message. Returns `true` on successful shutdown
+/// and `false` if some connections still alive.
+pub(crate) struct StopCommand {
+    graceful: bool,
+    result: oneshot::Sender<bool>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Conn {
+    pub io: StdStream,
+    pub token: Token,
+    pub peer: Option<SocketAddr>,
+}
+
+static MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
+
+/// Sets the maximum per-worker number of concurrent connections.
+///
+/// All socket listeners will stop accepting connections when this limit is
+/// reached for each worker.
+///
+/// By default max connections is set to a 25k per worker.
+pub fn max_concurrent_connections(num: usize) {
+    MAX_CONNS.store(num, Ordering::Relaxed);
+}
+
+pub(crate) fn num_connections() -> usize {
+    MAX_CONNS_COUNTER.with(|conns| conns.total())
+}
+
+thread_local! {
+    static MAX_CONNS_COUNTER: Counter =
+        Counter::new(MAX_CONNS.load(Ordering::Relaxed));
+}
+
+#[derive(Clone)]
+pub(crate) struct WorkerClient {
+    pub idx: usize,
+    tx1: UnboundedSender<WorkerCommand>,
+    tx2: UnboundedSender<StopCommand>,
+    avail: WorkerAvailability,
+}
+
+impl WorkerClient {
+    pub fn new(
+        idx: usize,
+        tx1: UnboundedSender<WorkerCommand>,
+        tx2: UnboundedSender<StopCommand>,
+        avail: WorkerAvailability,
+    ) -> Self {
+        WorkerClient {
+            idx,
+            tx1,
+            tx2,
+            avail,
+        }
+    }
+
+    pub fn send(&self, msg: Conn) -> Result<(), Conn> {
+        self.tx1
+            .unbounded_send(WorkerCommand(msg))
+            .map_err(|msg| msg.into_inner().0)
+    }
+
+    pub fn available(&self) -> bool {
+        self.avail.available()
+    }
+
+    pub fn stop(&self, graceful: bool) -> oneshot::Receiver<bool> {
+        let (result, rx) = oneshot::channel();
+        let _ = self.tx2.unbounded_send(StopCommand { graceful, result });
+        rx
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct WorkerAvailability {
+    notify: AcceptNotify,
+    available: Arc<AtomicBool>,
+}
+
+impl WorkerAvailability {
+    pub fn new(notify: AcceptNotify) -> Self {
+        WorkerAvailability {
+            notify,
+            available: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    pub fn available(&self) -> bool {
+        self.available.load(Ordering::Acquire)
+    }
+
+    pub fn set(&self, val: bool) {
+        let old = self.available.swap(val, Ordering::Release);
+        if !old && val {
+            self.notify.notify()
+        }
+    }
+}
+
+/// Service worker
+///
+/// Worker accepts Socket objects via unbounded channel and starts stream
+/// processing.
+pub(crate) struct Worker {
+    rx: UnboundedReceiver<WorkerCommand>,
+    rx2: UnboundedReceiver<StopCommand>,
+    services: Vec<WorkerService>,
+    availability: WorkerAvailability,
+    conns: Counter,
+    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(
+        idx: usize,
+        factories: Vec<Box<dyn InternalServiceFactory>>,
+        availability: WorkerAvailability,
+        shutdown_timeout: time::Duration,
+    ) -> WorkerClient {
+        let (tx1, rx) = unbounded();
+        let (tx2, rx2) = unbounded();
+        let avail = availability.clone();
+
+        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,
+                                    });
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            error!("Can not start worker: {:?}", e);
+                            Arbiter::current().stop();
+                        }
+                    }
+                    wrk.await
+                });
+            }
+            .boxed(),
+        );
+
+        WorkerClient::new(idx, tx1, tx2, avail)
+    }
+
+    fn shutdown(&mut self, force: bool) {
+        if force {
+            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 |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, cx: &mut Context<'_>) -> Result<bool, (Token, usize)> {
+        let mut ready = self.conns.available(cx);
+        let mut failed = None;
+        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[srv.factory].name(Token(idx))
+                            );
+                            srv.status = WorkerServiceStatus::Available;
+                        }
+                    }
+                    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[srv.factory].name(Token(idx))
+                        );
+                        failed = Some((Token(idx), srv.factory));
+                        srv.status = WorkerServiceStatus::Failed;
+                    }
+                }
+            }
+        }
+        if let Some(idx) = failed {
+            Err(idx)
+        } else {
+            Ok(ready)
+        }
+    }
+}
+
+enum WorkerState {
+    Available,
+    Unavailable(Vec<Conn>),
+    Restarting(
+        usize,
+        Token,
+        Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
+    ),
+    Shutdown(
+        Pin<Box<Delay>>,
+        Pin<Box<Delay>>,
+        Option<oneshot::Sender<bool>>,
+    ),
+}
+
+impl Future for Worker {
+    type Output = ();
+
+    // FIXME: remove this attribute
+    #[allow(clippy::never_loop)]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // `StopWorker` message handler
+        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 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(
+                        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 Poll::Ready(());
+                }
+            } else {
+                info!("Force shutdown worker, {} connections", num);
+                self.shutdown(true);
+                let _ = result.send(false);
+                return Poll::Ready(());
+            }
+        }
+
+        match self.state {
+            WorkerState::Unavailable(ref mut conns) => {
+                let conn = conns.pop();
+                match self.check_readiness(cx) {
+                    Ok(true) => {
+                        // process requests from wait queue
+                        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.poll(cx)
+                    }
+                    Ok(false) => {
+                        // push connection back to queue
+                        if let Some(conn) = conn {
+                            if let WorkerState::Unavailable(ref mut conns) = self.state {
+                                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());
+                        self.poll(cx)
+                    }
+                }
+            }
+            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].created(service);
+                            self.state = WorkerState::Unavailable(Vec::new());
+                            return self.poll(cx);
+                        }
+                    }
+                    Poll::Ready(Err(_)) => {
+                        panic!(
+                            "Can not restart {:?} service",
+                            self.factories[idx].name(token)
+                        );
+                    }
+                    Poll::Pending => {
+                        return Poll::Pending;
+                    }
+                }
+                self.poll(cx)
+            }
+            WorkerState::Shutdown(ref mut t1, ref mut t2, ref mut tx) => {
+                let num = num_connections();
+                if num == 0 {
+                    let _ = tx.take().unwrap().send(true);
+                    Arbiter::current().stop();
+                    return Poll::Ready(());
+                }
+
+                // check graceful timeout
+                match t2.as_mut().poll(cx) {
+                    Poll::Pending => (),
+                    Poll::Ready(_) => {
+                        let _ = tx.take().unwrap().send(false);
+                        self.shutdown(true);
+                        Arbiter::current().stop();
+                        return Poll::Ready(());
+                    }
+                }
+
+                // sleep for 1 second and then check again
+                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);
+                    }
+                }
+                Poll::Pending
+            }
+            WorkerState::Available => {
+                loop {
+                    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]
+                                        .service
+                                        .call((Some(guard), ServerMessage::Connect(msg.io)));
+                                    continue;
+                                }
+                                Ok(false) => {
+                                    trace!("Worker is unavailable");
+                                    self.availability.set(false);
+                                    self.state = WorkerState::Unavailable(vec![msg]);
+                                }
+                                Err((token, idx)) => {
+                                    trace!(
+                                        "Service {:?} failed, restarting",
+                                        self.factories[idx].name(token)
+                                    );
+                                    self.availability.set(false);
+                                    self.services[token.0].status =
+                                        WorkerServiceStatus::Restarting;
+                                    self.state = WorkerState::Restarting(
+                                        idx,
+                                        token,
+                                        self.factories[idx].create(),
+                                    );
+                                }
+                            }
+                            return self.poll(cx);
+                        }
+                        Poll::Pending => {
+                            self.state = WorkerState::Available;
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(None) => return Poll::Ready(()),
+                    }
+                }
+            }
+        }
+    }
+}

actix-server/tests/test_server.rs

@@ -0,0 +1,182 @@
+use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::{mpsc, Arc};
+use std::{net, thread, time};
+
+use actix_server::Server;
+use actix_service::fn_service;
+use futures_util::future::{lazy, ok};
+use socket2::{Domain, Protocol, Socket, Type};
+
+fn unused_addr() -> net::SocketAddr {
+    let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+    let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+    socket.bind(&addr.into()).unwrap();
+    socket.set_reuse_address(true).unwrap();
+    let tcp = socket.into_tcp_listener();
+    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());
+    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());
+    sys.stop();
+    let _ = h.join();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_start() {
+    use actix_codec::{BytesCodec, Framed};
+    use actix_rt::net::TcpStream;
+    use bytes::Bytes;
+    use futures_util::sink::SinkExt;
+    use std::io::Read;
+
+    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));
+    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);
+    sys.stop();
+    let _ = h.join();
+}

actix-service/CHANGES.md

@@ -0,0 +1,282 @@
+# Changes
+
+## Unreleased - 2020-xx-xx
+
+
+## 1.0.6 - 2020-08-09
+
+### Fixed
+
+* Removed unsound custom Cell implementation that allowed obtaining several mutable references to the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through service combinators. Attempts to acquire several mutable references to the same data will instead result in a panic.
+
+## [1.0.5] - 2020-01-16
+
+### Fixed
+
+* Fixed unsoundness in .and_then()/.then() service combinators
+
+## [1.0.4] - 2020-01-15
+
+### Fixed
+
+* Revert 1.0.3 change
+
+## [1.0.3] - 2020-01-15
+
+### Fixed
+
+* Fixed unsoundness in `AndThenService` impl
+
+## [1.0.2] - 2020-01-08
+
+### Added
+
+* Add `into_service` helper function
+
+
+## [1.0.1] - 2019-12-22
+
+### Changed
+
+* `map_config()` and `unit_config()` accepts `IntoServiceFactory` type
+
+
+## [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
+
+* Use associated type instead of generic for Service definition.
+
+  * Before:
+
+    ```rust
+    impl Service<Request> for Client {
+        type Response = Response;
+        // ...
+    }
+    ```
+  * After:
+
+    ```rust
+    impl Service for Client {
+        type Request = Request;
+        type Response = Response;
+        // ...
+    }
+    ```
+
+
+## [0.1.6] - 2019-01-24
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
+
+* Change `.apply()` error semantic, new service's error is `From<Self::Error>`
+
+
+## [0.1.5] - 2019-01-13
+
+### Changed
+
+* Make `Out::Error` convertable from `T::Error` for apply combinator
+
+
+## [0.1.4] - 2019-01-11
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for `FnService`
+
+
+## [0.1.3] - 2018-12-12
+
+### Changed
+
+* Split service combinators to separate trait
+
+
+## [0.1.2] - 2018-12-12
+
+### Fixed
+
+* Release future early for `.and_then()` and `.then()` combinators
+
+
+## [0.1.1] - 2018-12-09
+
+### Added
+
+* Added Service impl for Box<S: Service>
+
+
+## [0.1.0] - 2018-12-09
+
+* Initial import

actix-service/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "actix-service"
+version = "1.0.6"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Service trait and combinators for representing asynchronous request/response operations."
+keywords = ["network", "framework", "async", "futures", "service"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-service"
+readme = "actix-service/README.md"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+
+[lib]
+name = "actix_service"
+path = "src/lib.rs"
+
+[dependencies]
+futures-util = "0.3.1"
+pin-project = "0.4.17"
+
+[dev-dependencies]
+actix-rt = "1.0.0"
+criterion = "0.3"
+
+[[bench]]
+name = "unsafecell_vs_refcell"
+harness = false
+
+[[bench]]
+name = "and_then"
+harness = false

actix-service/LICENSE-APACHE

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

actix-service/LICENSE-MIT

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

actix-service/README.md

@@ -0,0 +1,7 @@
+# actix-service
+
+> Service trait and combinators for representing asynchronous request/response operations.
+
+See documentation for detailed explanations these components: [https://docs.rs/actix-service](docs).
+
+[docs]: https://docs.rs/actix-service

actix-service/benches/and_then.rs

@@ -0,0 +1,332 @@
+use actix_service::boxed::BoxFuture;
+use actix_service::IntoService;
+use actix_service::Service;
+/// Benchmark various implementations of and_then
+use criterion::{criterion_main, Criterion};
+use futures_util::future::join_all;
+use futures_util::future::TryFutureExt;
+use std::cell::{RefCell, UnsafeCell};
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+/*
+ * Test services A,B for AndThen service implementations
+ */
+
+async fn svc1(_: ()) -> Result<usize, ()> {
+    Ok(1)
+}
+
+async fn svc2(req: usize) -> Result<usize, ()> {
+    Ok(req + 1)
+}
+
+/*
+ * AndThenUC - original AndThen service based on UnsafeCell
+ * Cut down version of actix_service::AndThenService based on actix-service::Cell
+ */
+
+struct AndThenUC<A, B>(Rc<UnsafeCell<(A, B)>>);
+
+impl<A, B> AndThenUC<A, B> {
+    fn new(a: A, b: B) -> Self
+    where
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
+    {
+        Self(Rc::new(UnsafeCell::new((a, b))))
+    }
+}
+
+impl<A, B> Clone for AndThenUC<A, B> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<A, B> Service for AndThenUC<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = A::Error;
+    type Future = AndThenServiceResponse<A, B>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        let fut = unsafe { &mut *(*self.0).get() }.0.call(req);
+        AndThenServiceResponse {
+            state: State::A(fut, Some(self.0.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct AndThenServiceResponse<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    #[pin]
+    state: State<A, B>,
+}
+
+#[pin_project::pin_project(project = StateProj)]
+enum State<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    A(#[pin] A::Future, Option<Rc<UnsafeCell<(A, B)>>>),
+    B(#[pin] B::Future),
+    Empty,
+}
+
+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>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = unsafe { &mut (*b.get()).1 }.call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateProj::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
+        }
+    }
+}
+
+/*
+ * AndThenRC - AndThen service based on RefCell
+ */
+
+struct AndThenRC<A, B>(Rc<RefCell<(A, B)>>);
+
+impl<A, B> AndThenRC<A, B> {
+    fn new(a: A, b: B) -> Self
+    where
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
+    {
+        Self(Rc::new(RefCell::new((a, b))))
+    }
+}
+
+impl<A, B> Clone for AndThenRC<A, B> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<A, B> Service for AndThenRC<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = A::Error;
+    type Future = AndThenServiceResponseRC<A, B>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        let fut = self.0.borrow_mut().0.call(req);
+        AndThenServiceResponseRC {
+            state: StateRC::A(fut, Some(self.0.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct AndThenServiceResponseRC<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    #[pin]
+    state: StateRC<A, B>,
+}
+
+#[pin_project::pin_project(project = StateRCProj)]
+enum StateRC<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
+    B(#[pin] B::Future),
+    Empty,
+}
+
+impl<A, B> Future for AndThenServiceResponseRC<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    type Output = Result<B::Response, A::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateRCProj::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let b = b.take().unwrap();
+                    this.state.set(StateRC::Empty); // drop fut A
+                    let fut = b.borrow_mut().1.call(res);
+                    this.state.set(StateRC::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateRCProj::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(StateRC::Empty);
+                r
+            }),
+            StateRCProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
+        }
+    }
+}
+
+/*
+ * AndThenRCFuture - AndThen service based on RefCell
+ * and standard futures::future::and_then combinator in a Box
+ */
+
+struct AndThenRCFuture<A, B>(Rc<RefCell<(A, B)>>);
+
+impl<A, B> AndThenRCFuture<A, B> {
+    fn new(a: A, b: B) -> Self
+    where
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
+    {
+        Self(Rc::new(RefCell::new((a, b))))
+    }
+}
+
+impl<A, B> Clone for AndThenRCFuture<A, B> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<A, B> Service for AndThenRCFuture<A, B>
+where
+    A: Service + 'static,
+    A::Future: 'static,
+    B: Service<Request = A::Response, Error = A::Error> + 'static,
+    B::Future: 'static,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = A::Error;
+    type Future = BoxFuture<Self::Response, Self::Error>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        let fut = self.0.borrow_mut().0.call(req);
+        let core = self.0.clone();
+        let fut2 = move |res| (*core).borrow_mut().1.call(res);
+        Box::pin(fut.and_then(fut2))
+    }
+}
+
+/// Criterion Benchmark for async Service
+/// Should be used from within criterion group:
+/// ```rust,ignore
+/// let mut criterion: ::criterion::Criterion<_> =
+///     ::criterion::Criterion::default().configure_from_args();
+/// bench_async_service(&mut criterion, ok_service(), "async_service_direct");
+/// ```
+///
+/// Usable for benching Service wrappers:
+/// Using minimum service code implementation we first measure
+/// time to run minimum service, then measure time with wrapper.
+///
+/// Sample output
+/// async_service_direct    time:   [1.0908 us 1.1656 us 1.2613 us]
+pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
+where
+    S: Service<Request = (), Response = usize, Error = ()> + Clone + 'static,
+{
+    let mut rt = actix_rt::System::new("test");
+
+    // start benchmark loops
+    c.bench_function(name, move |b| {
+        b.iter_custom(|iters| {
+            let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect();
+            // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
+            let start = std::time::Instant::now();
+            // benchmark body
+            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
+            // check that at least first request succeeded
+            start.elapsed()
+        })
+    });
+}
+
+pub fn service_benches() {
+    let mut criterion: ::criterion::Criterion<_> =
+        ::criterion::Criterion::default().configure_from_args();
+    bench_async_service(
+        &mut criterion,
+        AndThenUC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with UnsafeCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenUC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with UnsafeCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRCFuture::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell via future::and_then",
+    );
+}
+
+criterion_main!(service_benches);

actix-service/benches/unsafecell_vs_refcell.rs

@@ -0,0 +1,112 @@
+use actix_service::Service;
+use criterion::{criterion_main, Criterion};
+use futures_util::future::join_all;
+use futures_util::future::{ok, Ready};
+use std::cell::{RefCell, UnsafeCell};
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+struct SrvUC(Rc<UnsafeCell<usize>>);
+
+impl Default for SrvUC {
+    fn default() -> Self {
+        Self(Rc::new(UnsafeCell::new(0)))
+    }
+}
+
+impl Clone for SrvUC {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl Service for SrvUC {
+    type Request = ();
+    type Response = usize;
+    type Error = ();
+    type Future = Ready<Result<Self::Response, ()>>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, _: ()) -> Self::Future {
+        unsafe { *(*self.0).get() = *(*self.0).get() + 1 };
+        ok(unsafe { *self.0.get() })
+    }
+}
+
+struct SrvRC(Rc<RefCell<usize>>);
+
+impl Default for SrvRC {
+    fn default() -> Self {
+        Self(Rc::new(RefCell::new(0)))
+    }
+}
+
+impl Clone for SrvRC {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl Service for SrvRC {
+    type Request = ();
+    type Response = usize;
+    type Error = ();
+    type Future = Ready<Result<Self::Response, ()>>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, _: ()) -> Self::Future {
+        let prev = *self.0.borrow();
+        *(*self.0).borrow_mut() = prev + 1;
+        ok(*self.0.borrow())
+    }
+}
+
+/// Criterion Benchmark for async Service
+/// Should be used from within criterion group:
+/// ```rust,ignore
+/// let mut criterion: ::criterion::Criterion<_> =
+///     ::criterion::Criterion::default().configure_from_args();
+/// bench_async_service(&mut criterion, ok_service(), "async_service_direct");
+/// ```
+///
+/// Usable for benching Service wrappers:
+/// Using minimum service code implementation we first measure
+/// time to run minimum service, then measure time with wrapper.
+///
+/// Sample output
+/// async_service_direct    time:   [1.0908 us 1.1656 us 1.2613 us]
+pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
+where
+    S: Service<Request = (), Response = usize, Error = ()> + Clone + 'static,
+{
+    let mut rt = actix_rt::System::new("test");
+
+    // start benchmark loops
+    c.bench_function(name, move |b| {
+        b.iter_custom(|iters| {
+            let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect();
+            // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
+            let start = std::time::Instant::now();
+            // benchmark body
+            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
+            // check that at least first request succeeded
+            start.elapsed()
+        })
+    });
+}
+
+pub fn service_benches() {
+    let mut criterion: ::criterion::Criterion<_> =
+        ::criterion::Criterion::default().configure_from_args();
+    bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell");
+    bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell");
+    bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell");
+    bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell");
+}
+criterion_main!(service_benches);

actix-service/src/and_then.rs

@@ -0,0 +1,332 @@
+use std::cell::RefCell;
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use super::{Service, ServiceFactory};
+
+/// 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(crate) struct AndThenService<A, B>(Rc<RefCell<(A, B)>>);
+
+impl<A, B> AndThenService<A, B> {
+    /// Create new `AndThen` combinator
+    pub(crate) fn new(a: A, b: B) -> Self
+    where
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
+    {
+        Self(Rc::new(RefCell::new((a, b))))
+    }
+}
+
+impl<A, B> Clone for AndThenService<A, B> {
+    fn clone(&self) -> Self {
+        AndThenService(self.0.clone())
+    }
+}
+
+impl<A, B> Service for AndThenService<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = A::Error;
+    type Future = AndThenServiceResponse<A, B>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut srv = self.0.borrow_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 {
+        AndThenServiceResponse {
+            state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct AndThenServiceResponse<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    #[pin]
+    state: State<A, B>,
+}
+
+#[pin_project::pin_project(project = StateProj)]
+enum State<A, B>
+where
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
+{
+    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
+    B(#[pin] B::Future),
+    Empty,
+}
+
+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>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = b.borrow_mut().1.call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateProj::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
+        }
+    }
+}
+
+/// `.and_then()` service factory combinator
+pub(crate) struct AndThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    inner: Rc<(A, B)>,
+}
+
+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 {
+            inner: Rc::new((a, b)),
+        }
+    }
+}
+
+impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
+where
+    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 Config = A::Config;
+    type Service = AndThenService<A::Service, B::Service>;
+    type InitError = A::InitError;
+    type Future = AndThenServiceFactoryResponse<A, B>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let inner = &*self.inner;
+        AndThenServiceFactoryResponse::new(
+            inner.0.new_service(cfg.clone()),
+            inner.1.new_service(cfg),
+        )
+    }
+}
+
+impl<A, B> Clone for AndThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct AndThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response>,
+{
+    #[pin]
+    fut_a: A::Future,
+    #[pin]
+    fut_b: B::Future,
+
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B> AndThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response>,
+{
+    fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
+        AndThenServiceFactoryResponse {
+            fut_a,
+            fut_b,
+            a: None,
+            b: None,
+        }
+    }
+}
+
+impl<A, B> Future for AndThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+{
+    type Output = Result<AndThenService<A::Service, B::Service>, 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(AndThenService::new(
+                this.a.take().unwrap(),
+                this.b.take().unwrap(),
+            )))
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cell::Cell;
+    use std::rc::Rc;
+    use std::task::{Context, Poll};
+
+    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 = Ready<Result<Self::Response, ()>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            self.0.set(self.0.get() + 1);
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, req: &'static str) -> Self::Future {
+            ok(req)
+        }
+    }
+
+    #[derive(Clone)]
+    struct Srv2(Rc<Cell<usize>>);
+
+    impl Service for Srv2 {
+        type Request = &'static str;
+        type Response = (&'static str, &'static str);
+        type Error = ();
+        type Future = Ready<Result<Self::Response, ()>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            self.0.set(self.0.get() + 1);
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, req: &'static str) -> Self::Future {
+            ok((req, "srv2"))
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_poll_ready() {
+        let cnt = Rc::new(Cell::new(0));
+        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);
+    }
+
+    #[actix_rt::test]
+    async fn test_call() {
+        let cnt = Rc::new(Cell::new(0));
+        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(), ("srv1", "srv2"));
+    }
+
+    #[actix_rt::test]
+    async fn test_new_service() {
+        let cnt = Rc::new(Cell::new(0));
+        let cnt2 = cnt.clone();
+        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_fn.rs

@@ -0,0 +1,326 @@
+use std::cell::RefCell;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use crate::{Service, ServiceFactory};
+
+/// `Apply` service combinator
+pub(crate) 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>,
+{
+    srv: Rc<RefCell<(A, 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 {
+            srv: Rc::new(RefCell::new((a, b, f))),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone 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>,
+{
+    fn clone(&self) -> Self {
+        AndThenApplyFn {
+            srv: self.srv.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 mut inner = self.srv.borrow_mut();
+        let not_ready = inner.0.poll_ready(cx)?.is_pending();
+        if inner.1.poll_ready(cx)?.is_pending() || not_ready {
+            Poll::Pending
+        } else {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        let fut = self.srv.borrow_mut().0.call(req);
+        AndThenApplyFnFuture {
+            state: State::A(fut, Some(self.srv.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) 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(project = StateProj)]
+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<Rc<RefCell<(A, 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>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let b = b.take().unwrap();
+                    this.state.set(State::Empty);
+                    let (_, b, f) = &mut *b.borrow_mut();
+                    let fut = f(res, b);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateProj::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
+        }
+    }
+}
+
+/// `AndThenApplyFn` service factory
+pub(crate) struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+    srv: Rc<(A, B, 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 {
+            srv: Rc::new((a, b, f)),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+    fn clone(&self) -> Self {
+        Self {
+            srv: self.srv.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 {
+        let srv = &*self.srv;
+        AndThenApplyFnFactoryResponse {
+            a: None,
+            b: None,
+            f: srv.2.clone(),
+            fut_a: srv.0.new_service(cfg.clone()),
+            fut_b: srv.1.new_service(cfg),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) 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 {
+                srv: Rc::new(RefCell::new((
+                    this.a.take().unwrap(),
+                    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(()))
+        }
+
+        #[allow(clippy::unit_arg)]
+        fn call(&mut self, req: Self::Request) -> Self::Future {
+            ok(req)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let mut srv = pipeline(ok).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(ok))).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

@@ -0,0 +1,269 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+
+/// 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, R, In, Out, Err>
+where
+    T: Service<Error = Err>,
+{
+    service: T,
+    f: F,
+    r: PhantomData<(In, Out, R)>,
+}
+
+impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
+where
+    T: Service<Error = Err>,
+    F: FnMut(In, &mut T) -> R,
+    R: Future<Output = Result<Out, Err>>,
+{
+    /// Create new `Apply` combinator
+    fn new(service: T, f: F) -> Self {
+        Self {
+            service,
+            f,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
+where
+    T: Service<Error = Err> + Clone,
+    F: FnMut(In, &mut T) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn clone(&self) -> Self {
+        Apply {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
+where
+    T: Service<Error = Err>,
+    F: FnMut(In, &mut T) -> R,
+    R: Future<Output = Result<Out, Err>>,
+{
+    type Request = In;
+    type Response = Out;
+    type Error = Err;
+    type Future = R;
+
+    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)
+    }
+}
+
+/// `apply()` service factory
+pub struct 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>>,
+{
+    service: T,
+    f: F,
+    r: PhantomData<(R, In, Out)>,
+}
+
+impl<T, F, R, In, Out, Err> 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>>,
+{
+    /// Create new `ApplyNewService` new service instance
+    fn new(service: T, f: F) -> Self {
+        Self {
+            f,
+            service,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Error = Err> + Clone,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn clone(&self) -> Self {
+        Self {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<T, F, R, In, Out, Err> ServiceFactory for 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>>,
+{
+    type Request = In;
+    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 = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
+
+    fn new_service(&self, cfg: T::Config) -> Self::Future {
+        ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+where
+    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, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+where
+    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 {
+        Self {
+            f: Some(f),
+            fut,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R,
+    R: Future<Output = Result<Out, Err>>,
+{
+    type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
+
+    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 {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::{Context, Poll};
+
+    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 = Ready<Result<(), ()>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            ok(())
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_call() {
+        let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
+            let fut = srv.call(());
+            async move {
+                fut.await.unwrap();
+                Ok((req, ()))
+            }
+        }));
+
+        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_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 {
+                    fut.await.unwrap();
+                    Ok((req, ()))
+                }
+            },
+        ));
+
+        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,227 @@
+use std::cell::RefCell;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+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,
+) -> impl ServiceFactory<
+    Config = C,
+    Request = S::Request,
+    Response = S::Response,
+    Error = S::Error,
+    Service = S,
+    InitError = E,
+    Future = R,
+> + Clone
+where
+    F: FnMut(C, &mut T) -> R,
+    T: Service,
+    R: Future<Output = Result<S, E>>,
+    S: Service,
+{
+    ApplyConfigService {
+        srv: Rc::new(RefCell::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,
+) -> impl ServiceFactory<
+    Config = C,
+    Request = S::Request,
+    Response = S::Response,
+    Error = S::Error,
+    Service = S,
+    InitError = T::InitError,
+> + Clone
+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: Rc::new(RefCell::new((factory, f))),
+        _t: PhantomData,
+    }
+}
+
+/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
+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: Rc<RefCell<(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 {
+        let (t, f) = &mut *self.srv.borrow_mut();
+        f(cfg, t)
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+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: Rc<RefCell<(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.borrow().0.new_service(())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+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: Rc<RefCell<(T, F)>>,
+    #[pin]
+    state: State<T, R, S>,
+}
+
+#[pin_project::pin_project(project = StateProj)]
+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>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A(fut) => match fut.poll(cx)? {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(srv) => {
+                    this.state.set(State::B(srv));
+                    self.poll(cx)
+                }
+            },
+            StateProj::B(srv) => match srv.poll_ready(cx)? {
+                Poll::Ready(_) => {
+                    {
+                        let (_, f) = &mut *this.store.borrow_mut();
+                        let fut = f(this.cfg.take().unwrap(), srv);
+                        this.state.set(State::C(fut));
+                    }
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateProj::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/fn_service.rs

@@ -0,0 +1,403 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::task::{Context, Poll};
+
+use futures_util::future::{ok, Ready};
+
+use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+
+/// 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 zero"))
+///     } 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: Future<Output = Result<Res, Err>>,
+{
+    f: F,
+    _t: PhantomData<Req>,
+}
+
+impl<F, Fut, Req, Res, Err> FnService<F, Fut, Req, Res, Err>
+where
+    F: FnMut(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    pub(crate) fn new(f: F) -> Self {
+        Self { f, _t: PhantomData }
+    }
+}
+
+impl<F, Fut, Req, Res, Err> Clone for FnService<F, Fut, Req, Res, Err>
+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 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/lib.rs

@@ -0,0 +1,375 @@
+//! See [`Service`](trait.Service.html) docs for information on this crate's foundational trait.
+
+#![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_fn;
+mod apply;
+mod apply_cfg;
+pub mod boxed;
+mod fn_service;
+mod map;
+mod map_config;
+mod map_err;
+mod map_init_err;
+mod pipeline;
+mod then;
+mod transform;
+mod transform_err;
+
+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 operation from `Request` to a `Response`.
+///
+/// The `Service` trait models a request/response interaction, receiving requests and returning
+/// replies. You can think about a service as a function with one argument that returns some result
+/// asynchronously. Conceptually, the operation looks like this:
+///
+/// ```rust,ignore
+/// async fn(Request) -> Result<Response, Err>
+/// ```
+///
+/// The `Service` trait just generalizes this form where each parameter is described as an
+/// associated type on the trait. Services can also have mutable state that influence computation.
+///
+/// `Service` provides a symmetric and uniform API; the same abstractions can be used to represent
+/// both clients and servers. Services describe only _transformation_ operations which encourage
+/// simple API surfaces. This leads to simpler design of each service, improves test-ability and
+/// makes composition easier.
+///
+/// ```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, req: Self::Request) -> Self::Future { ... }
+/// }
+/// ```
+///
+/// Sometimes it is not necessary to implement the Service trait. For example, the above service
+/// could be rewritten as a simple function and passed to [fn_service](fn.fn_service.html).
+///
+/// ```rust,ignore
+/// async fn my_service(req: u8) -> Result<u64, MyError>;
+/// ```
+pub trait Service {
+    /// Requests handled by the service.
+    type Request;
+
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The future response value.
+    type Future: Future<Output = Result<Self::Response, Self::Error>>;
+
+    /// Returns `Ready` when the service is able to process requests.
+    ///
+    /// If the service is at capacity, then `Pending` is returned and the task
+    /// is notified when the service becomes ready again. This function is
+    /// expected to be called while on a task.
+    ///
+    /// This is a **best effort** implementation. False positives are permitted.
+    /// It is permitted for the service to return `Ready` from a `poll_ready`
+    /// call and the next invocation of `call` results in an error.
+    ///
+    /// # Notes
+    /// 1. `.poll_ready()` might be called on different task from actual service call.
+    /// 1. 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.
+    ///
+    /// This function is expected to be callable off task. As such,
+    /// implementations should take care to not call `poll_ready`. If the
+    /// service is at capacity and the request is unable to be handled, the
+    /// returned `Future` should resolve to an error.
+    ///
+    /// Calling `call` without calling `poll_ready` is permitted. The
+    /// implementation must be resilient to this fact.
+    fn call(&mut self, req: Self::Request) -> Self::Future;
+
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    ///
+    /// This function is similar to the `Option::map` or `Iterator::map` where
+    /// it will change the type of the underlying service.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it, similar to the existing `map` methods in the
+    /// standard library.
+    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R,
+    {
+        crate::dev::Map::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying service. For example, this can be useful to
+    /// ensure that services have the same error type.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        crate::dev::MapErr::new(self, f)
+    }
+}
+
+/// Factory for creating `Service`s.
+///
+/// Acts as a service factory. This is useful for cases where new `Service`s
+/// must be produced. One case is a TCP server listener. The listener
+/// accepts new TCP streams, obtains a new `Service` using the
+/// `ServiceFactory` trait, and uses the new `Service` to process inbound
+/// requests on that new TCP stream.
+///
+/// `Config` is a service factory configuration type.
+pub trait ServiceFactory {
+    /// Requests handled by the created services.
+    type Request;
+
+    /// Responses given by the created services.
+    type Response;
+
+    /// Errors produced by the created services.
+    type Error;
+
+    /// Service factory configuration.
+    type Config;
+
+    /// The kind of `Service` created by this factory.
+    type Service: Service<
+        Request = Self::Request,
+        Response = Self::Response,
+        Error = Self::Error,
+    >;
+
+    /// Errors potentially raised while building a service.
+    type InitError;
+
+    /// The future of the `Service` instance.
+    type Future: Future<Output = Result<Self::Service, Self::InitError>>;
+
+    /// Create and return a new service asynchronously.
+    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) -> crate::map::MapServiceFactory<Self, F, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R + Clone,
+    {
+        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) -> crate::map_err::MapErrServiceFactory<Self, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E + Clone,
+    {
+        crate::map_err::MapErrServiceFactory::new(self, f)
+    }
+
+    /// 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 + Clone,
+    {
+        crate::map_init_err::MapInitErr::new(self, f)
+    }
+}
+
+impl<'a, S> Service for &'a mut S
+where
+    S: Service + 'a,
+{
+    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).poll_ready(ctx)
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        (**self).call(request)
+    }
+}
+
+impl<S> Service for Box<S>
+where
+    S: Service + ?Sized,
+{
+    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<(), S::Error>> {
+        (**self).poll_ready(ctx)
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        (**self).call(request)
+    }
+}
+
+impl<S> Service for 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 {
+        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)
+    }
+}
+
+/// Trait for types that can be converted to a `Service`
+pub trait IntoService<T>
+where
+    T: Service,
+{
+    /// Convert to a `Service`
+    fn into_service(self) -> T;
+}
+
+/// Trait for types that can be converted to a `ServiceFactory`
+pub trait IntoServiceFactory<T>
+where
+    T: ServiceFactory,
+{
+    /// Convert `Self` to a `ServiceFactory`
+    fn into_factory(self) -> T;
+}
+
+impl<T> IntoService<T> for T
+where
+    T: Service,
+{
+    fn into_service(self) -> T {
+        self
+    }
+}
+
+impl<T> IntoServiceFactory<T> for T
+where
+    T: ServiceFactory,
+{
+    fn into_factory(self) -> T {
+        self
+    }
+}
+
+/// Convert object of type `T` to a service `S`
+pub fn into_service<T, S>(tp: T) -> S
+where
+    S: Service,
+    T: IntoService<S>,
+{
+    tp.into_service()
+}
+
+pub mod dev {
+    pub use crate::apply::{Apply, ApplyServiceFactory};
+    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::transform::ApplyTransform;
+    pub use crate::transform_err::TransformMapInitErr;
+}

actix-service/src/map.rs

@@ -0,0 +1,245 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::{Service, ServiceFactory};
+
+/// Service for the `map` combinator, changing the type of a service's response.
+///
+/// This is created by the `ServiceExt::map` method.
+pub struct Map<A, F, Response> {
+    service: A,
+    f: F,
+    _t: PhantomData<Response>,
+}
+
+impl<A, F, Response> Map<A, F, Response> {
+    /// Create new `Map` combinator
+    pub(crate) fn new(service: A, f: F) -> Self
+    where
+        A: Service,
+        F: FnMut(A::Response) -> Response,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<A, F, Response> Clone for Map<A, F, Response>
+where
+    A: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Map {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<A, F, Response> Service for Map<A, F, Response>
+where
+    A: Service,
+    F: FnMut(A::Response) -> Response + Clone,
+{
+    type Request = A::Request;
+    type Response = Response;
+    type Error = A::Error;
+    type Future = MapFuture<A, F, Response>;
+
+    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 {
+        MapFuture::new(self.service.call(req), self.f.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub struct MapFuture<A, F, Response>
+where
+    A: Service,
+    F: FnMut(A::Response) -> Response,
+{
+    f: F,
+    #[pin]
+    fut: A::Future,
+}
+
+impl<A, F, Response> MapFuture<A, F, Response>
+where
+    A: Service,
+    F: FnMut(A::Response) -> Response,
+{
+    fn new(fut: A::Future, f: F) -> Self {
+        MapFuture { f, fut }
+    }
+}
+
+impl<A, F, Response> Future for MapFuture<A, F, Response>
+where
+    A: Service,
+    F: FnMut(A::Response) -> Response,
+{
+    type Output = Result<Response, A::Error>;
+
+    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 MapServiceFactory<A, F, Res> {
+    a: A,
+    f: F,
+    r: PhantomData<Res>,
+}
+
+impl<A, F, Res> MapServiceFactory<A, F, Res> {
+    /// Create new `Map` new service instance
+    pub(crate) fn new(a: A, f: F) -> Self
+    where
+        A: ServiceFactory,
+        F: FnMut(A::Response) -> Res,
+    {
+        Self {
+            a,
+            f,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, F, Res> Clone for MapServiceFactory<A, F, Res>
+where
+    A: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, F, Res> ServiceFactory for MapServiceFactory<A, F, Res>
+where
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res + Clone,
+{
+    type Request = A::Request;
+    type Response = Res;
+    type Error = A::Error;
+
+    type Config = A::Config;
+    type Service = Map<A::Service, F, Res>;
+    type InitError = A::InitError;
+    type Future = MapServiceFuture<A, F, Res>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub struct MapServiceFuture<A, F, Res>
+where
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
+{
+    #[pin]
+    fut: A::Future,
+    f: Option<F>,
+}
+
+impl<A, F, Res> MapServiceFuture<A, F, Res>
+where
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
+{
+    fn new(fut: A::Future, f: F) -> Self {
+        MapServiceFuture { f: Some(f), fut }
+    }
+}
+
+impl<A, F, Res> Future for MapServiceFuture<A, F, Res>
+where
+    A: ServiceFactory,
+    F: FnMut(A::Response) -> Res,
+{
+    type Output = Result<Map<A::Service, F, Res>, A::InitError>;
+
+    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 {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures_util::future::{lazy, ok, Ready};
+
+    use super::*;
+    use crate::{IntoServiceFactory, Service, ServiceFactory};
+
+    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, _: ()) -> Self::Future {
+            ok(())
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_poll_ready() {
+        let mut srv = Srv.map(|_| "ok");
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
+    }
+
+    #[actix_rt::test]
+    async fn test_call() {
+        let mut srv = Srv.map(|_| "ok");
+        let res = srv.call(()).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), "ok");
+    }
+
+    #[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,126 @@
+use std::marker::PhantomData;
+
+use super::{IntoServiceFactory, 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, U, F, C>(factory: U, f: F) -> MapConfig<T, F, C>
+where
+    T: ServiceFactory,
+    U: IntoServiceFactory<T>,
+    F: Fn(C) -> T::Config,
+{
+    MapConfig::new(factory.into_factory(), f)
+}
+
+/// Replace config with unit
+pub fn unit_config<T, U, C>(factory: U) -> UnitConfig<T, C>
+where
+    T: ServiceFactory<Config = ()>,
+    U: IntoServiceFactory<T>,
+{
+    UnitConfig::new(factory.into_factory())
+}
+
+/// `map_config()` adapter service factory
+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

@@ -0,0 +1,247 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::{Service, ServiceFactory};
+
+/// Service for the `map_err` combinator, changing the type of a service's
+/// error.
+///
+/// This is created by the `ServiceExt::map_err` method.
+pub struct MapErr<A, F, E> {
+    service: A,
+    f: F,
+    _t: PhantomData<E>,
+}
+
+impl<A, F, E> MapErr<A, F, E> {
+    /// Create new `MapErr` combinator
+    pub(crate) fn new(service: A, f: F) -> Self
+    where
+        A: Service,
+        F: Fn(A::Error) -> E,
+    {
+        Self {
+            service,
+            f,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<A, F, E> Clone for MapErr<A, F, E>
+where
+    A: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        MapErr {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<A, F, E> Service for MapErr<A, F, E>
+where
+    A: Service,
+    F: Fn(A::Error) -> E + Clone,
+{
+    type Request = A::Request;
+    type Response = A::Response;
+    type Error = E;
+    type Future = MapErrFuture<A, F, E>;
+
+    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 {
+        MapErrFuture::new(self.service.call(req), self.f.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub struct MapErrFuture<A, F, E>
+where
+    A: Service,
+    F: Fn(A::Error) -> E,
+{
+    f: F,
+    #[pin]
+    fut: A::Future,
+}
+
+impl<A, F, E> MapErrFuture<A, F, E>
+where
+    A: Service,
+    F: Fn(A::Error) -> E,
+{
+    fn new(fut: A::Future, f: F) -> Self {
+        MapErrFuture { f, fut }
+    }
+}
+
+impl<A, F, E> Future for MapErrFuture<A, F, E>
+where
+    A: Service,
+    F: Fn(A::Error) -> E,
+{
+    type Output = Result<A::Response, E>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        this.fut.poll(cx).map_err(this.f)
+    }
+}
+
+/// 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 MapErrServiceFactory<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E + Clone,
+{
+    a: A,
+    f: F,
+    e: PhantomData<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(crate) fn new(a: A, f: F) -> Self {
+        Self {
+            a,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, E> Clone for MapErrServiceFactory<A, F, E>
+where
+    A: ServiceFactory + Clone,
+    F: Fn(A::Error) -> E + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<A, F, E> ServiceFactory for MapErrServiceFactory<A, F, E>
+where
+    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 = MapErrServiceFuture<A, F, E>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub struct MapErrServiceFuture<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E,
+{
+    #[pin]
+    fut: A::Future,
+    f: F,
+}
+
+impl<A, F, E> MapErrServiceFuture<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E,
+{
+    fn new(fut: A::Future, f: F) -> Self {
+        MapErrServiceFuture { f, fut }
+    }
+}
+
+impl<A, F, E> Future for MapErrServiceFuture<A, F, E>
+where
+    A: ServiceFactory,
+    F: Fn(A::Error) -> E + Clone,
+{
+    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
+
+    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 {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures_util::future::{err, lazy, ok, Ready};
+
+    use super::*;
+    use crate::{IntoServiceFactory, Service, ServiceFactory};
+
+    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(Err(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            err(())
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_poll_ready() {
+        let mut srv = Srv.map_err(|_| "error");
+        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");
+    }
+
+    #[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");
+    }
+}

actix-service/src/map_init_err.rs

@@ -1,75 +1,79 @@
-use std::marker;
+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> {
     a: A,
     f: F,
-    e: marker::PhantomData<E>,
+    e: PhantomData<E>,
 }
 
 impl<A, F, E> MapInitErr<A, F, E>
 where
-    A: NewService,
+    A: ServiceFactory,
     F: Fn(A::InitError) -> E,
 {
     /// Create new `MapInitErr` combinator
-    pub fn new(a: A, f: F) -> Self {
+    pub(crate) fn new(a: A, f: F) -> Self {
         Self {
             a,
             f,
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
 impl<A, F, E> Clone for MapInitErr<A, F, E>
 where
-    A: NewService + Clone,
-    F: Fn(A::InitError) -> E + Clone,
+    A: Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             a: self.a.clone(),
             f: self.f.clone(),
-            e: marker::PhantomData,
+            e: PhantomData,
         }
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E> 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)
     }
 }

actix-service/src/pipeline.rs

@@ -0,0 +1,344 @@
+use std::future::Future;
+use std::task::{Context, Poll};
+
+use crate::and_then::{AndThenService, AndThenServiceFactory};
+use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
+use crate::map::{Map, MapServiceFactory};
+use crate::map_err::{MapErr, MapErrServiceFactory};
+use crate::map_init_err::MapInitErr;
+use crate::then::{ThenService, ThenServiceFactory};
+use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+
+/// Contruct new pipeline with one service in pipeline chain.
+pub fn pipeline<F, T>(service: F) -> Pipeline<T>
+where
+    F: IntoService<T>,
+    T: Service,
+{
+    Pipeline {
+        service: service.into_service(),
+    }
+}
+
+/// Contruct new pipeline factory with one service factory.
+pub fn pipeline_factory<T, F>(factory: F) -> PipelineFactory<T>
+where
+    T: ServiceFactory,
+    F: IntoServiceFactory<T>,
+{
+    PipelineFactory {
+        factory: factory.into_factory(),
+    }
+}
+
+/// Pipeline service - pipeline allows to compose multiple service into one service.
+pub struct Pipeline<T> {
+    service: T,
+}
+
+impl<T: Service> Pipeline<T> {
+    /// 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.
+    pub fn and_then<F, U>(
+        self,
+        service: F,
+    ) -> Pipeline<
+        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
+    >
+    where
+        Self: Sized,
+        F: IntoService<U>,
+        U: Service<Request = T::Response, Error = T::Error>,
+    {
+        Pipeline {
+            service: AndThenService::new(self.service, service.into_service()),
+        }
+    }
+
+    /// Apply function to specified service and use it as a next service in
+    /// chain.
+    ///
+    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
+    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
+        self,
+        service: I,
+        f: F,
+    ) -> Pipeline<impl Service<Request = T::Request, Response = Res, Error = Err> + Clone>
+    where
+        Self: Sized,
+        I: IntoService<U>,
+        U: Service,
+        F: FnMut(T::Response, &mut U) -> Fut,
+        Fut: Future<Output = Result<Res, Err>>,
+        Err: From<T::Error> + From<U::Error>,
+    {
+        Pipeline {
+            service: AndThenApplyFn::new(self.service, service.into_service(), f),
+        }
+    }
+
+    /// Chain on a computation for when a call to the service finished,
+    /// passing the result of the call to the next service `U`.
+    ///
+    /// Note that this function consumes the receiving pipeline and returns a
+    /// wrapped version of it.
+    pub fn then<F, U>(
+        self,
+        service: F,
+    ) -> Pipeline<
+        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
+    >
+    where
+        Self: Sized,
+        F: IntoService<U>,
+        U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>,
+    {
+        Pipeline {
+            service: ThenService::new(self.service, service.into_service()),
+        }
+    }
+
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    ///
+    /// This function is similar to the `Option::map` or `Iterator::map` where
+    /// it will change the type of the underlying service.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it, similar to the existing `map` methods in the
+    /// standard library.
+    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>>
+    where
+        Self: Sized,
+        F: FnMut(T::Response) -> R,
+    {
+        Pipeline {
+            service: Map::new(self.service, f),
+        }
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying service. This is useful for example to
+    /// ensure that services have the same error type.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>>
+    where
+        Self: Sized,
+        F: Fn(T::Error) -> E,
+    {
+        Pipeline {
+            service: MapErr::new(self.service, f),
+        }
+    }
+}
+
+impl<T> Clone for Pipeline<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Pipeline {
+            service: self.service.clone(),
+        }
+    }
+}
+
+impl<T: Service> Service for Pipeline<T> {
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    #[inline]
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), T::Error>> {
+        self.service.poll_ready(ctx)
+    }
+
+    #[inline]
+    fn call(&mut self, req: T::Request) -> Self::Future {
+        self.service.call(req)
+    }
+}
+
+/// Pipeline factory
+pub struct PipelineFactory<T> {
+    factory: T,
+}
+
+impl<T: ServiceFactory> PipelineFactory<T> {
+    /// Call another service after call to this one has resolved successfully.
+    pub fn and_then<F, U>(
+        self,
+        factory: F,
+    ) -> PipelineFactory<
+        impl ServiceFactory<
+                Request = T::Request,
+                Response = U::Response,
+                Error = T::Error,
+                Config = T::Config,
+                InitError = T::InitError,
+                Service = impl Service<
+                    Request = T::Request,
+                    Response = U::Response,
+                    Error = T::Error,
+                > + Clone,
+            > + Clone,
+    >
+    where
+        Self: Sized,
+        T::Config: Clone,
+        F: IntoServiceFactory<U>,
+        U: ServiceFactory<
+            Config = T::Config,
+            Request = T::Response,
+            Error = T::Error,
+            InitError = T::InitError,
+        >,
+    {
+        PipelineFactory {
+            factory: AndThenServiceFactory::new(self.factory, factory.into_factory()),
+        }
+    }
+
+    /// Apply function to specified service and use it as a next service in
+    /// chain.
+    ///
+    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
+    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
+        self,
+        factory: I,
+        f: F,
+    ) -> PipelineFactory<
+        impl ServiceFactory<
+                Request = T::Request,
+                Response = Res,
+                Error = Err,
+                Config = T::Config,
+                InitError = T::InitError,
+                Service = impl Service<Request = T::Request, Response = Res, Error = Err> + Clone,
+            > + Clone,
+    >
+    where
+        Self: Sized,
+        T::Config: Clone,
+        I: IntoServiceFactory<U>,
+        U: ServiceFactory<Config = T::Config, InitError = T::InitError>,
+        F: FnMut(T::Response, &mut U::Service) -> Fut + Clone,
+        Fut: Future<Output = Result<Res, Err>>,
+        Err: From<T::Error> + From<U::Error>,
+    {
+        PipelineFactory {
+            factory: AndThenApplyFnFactory::new(self.factory, factory.into_factory(), f),
+        }
+    }
+
+    /// 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 `U`.
+    ///
+    /// Note that this function consumes the receiving pipeline and returns a
+    /// wrapped version of it.
+    pub fn then<F, U>(
+        self,
+        factory: F,
+    ) -> PipelineFactory<
+        impl ServiceFactory<
+                Request = T::Request,
+                Response = U::Response,
+                Error = T::Error,
+                Config = T::Config,
+                InitError = T::InitError,
+                Service = impl Service<
+                    Request = T::Request,
+                    Response = U::Response,
+                    Error = T::Error,
+                > + Clone,
+            > + Clone,
+    >
+    where
+        Self: Sized,
+        T::Config: Clone,
+        F: IntoServiceFactory<U>,
+        U: ServiceFactory<
+            Config = T::Config,
+            Request = Result<T::Response, T::Error>,
+            Error = T::Error,
+            InitError = T::InitError,
+        >,
+    {
+        PipelineFactory {
+            factory: ThenServiceFactory::new(self.factory, factory.into_factory()),
+        }
+    }
+
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, R>>
+    where
+        Self: Sized,
+        F: FnMut(T::Response) -> R + Clone,
+    {
+        PipelineFactory {
+            factory: MapServiceFactory::new(self.factory, f),
+        }
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<T, F, E>>
+    where
+        Self: Sized,
+        F: Fn(T::Error) -> E + Clone,
+    {
+        PipelineFactory {
+            factory: MapErrServiceFactory::new(self.factory, f),
+        }
+    }
+
+    /// Map this factory's init error to a different error, returning a new service.
+    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>>
+    where
+        Self: Sized,
+        F: Fn(T::InitError) -> E + Clone,
+    {
+        PipelineFactory {
+            factory: MapInitErr::new(self.factory, f),
+        }
+    }
+}
+
+impl<T> Clone for PipelineFactory<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        PipelineFactory {
+            factory: self.factory.clone(),
+        }
+    }
+}
+
+impl<T: ServiceFactory> ServiceFactory for PipelineFactory<T> {
+    type Config = T::Config;
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Service = T::Service;
+    type InitError = T::InitError;
+    type Future = T::Future;
+
+    #[inline]
+    fn new_service(&self, cfg: T::Config) -> Self::Future {
+        self.factory.new_service(cfg)
+    }
+}

actix-service/src/then.rs

@@ -0,0 +1,330 @@
+use std::cell::RefCell;
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use super::{Service, ServiceFactory};
+
+/// Service for the `then` combinator, chaining a computation onto the end of
+/// another service.
+///
+/// This is created by the `Pipeline::then` method.
+pub(crate) struct ThenService<A, B>(Rc<RefCell<(A, B)>>);
+
+impl<A, B> ThenService<A, B> {
+    /// Create new `.then()` combinator
+    pub(crate) fn new(a: A, b: B) -> ThenService<A, B>
+    where
+        A: Service,
+        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    {
+        Self(Rc::new(RefCell::new((a, b))))
+    }
+}
+
+impl<A, B> Clone for ThenService<A, B> {
+    fn clone(&self) -> Self {
+        ThenService(self.0.clone())
+    }
+}
+
+impl<A, B> Service for ThenService<A, B>
+where
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = B::Error;
+    type Future = ThenServiceResponse<A, B>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut srv = self.0.borrow_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 {
+        ThenServiceResponse {
+            state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct ThenServiceResponse<A, B>
+where
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
+{
+    #[pin]
+    state: State<A, B>,
+}
+
+#[pin_project::pin_project(project = StateProj)]
+enum State<A, B>
+where
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
+{
+    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
+    B(#[pin] B::Future),
+    Empty,
+}
+
+impl<A, B> Future for ThenServiceResponse<A, B>
+where
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
+{
+    type Output = Result<B::Response, B::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A(fut, b) => match fut.poll(cx) {
+                Poll::Ready(res) => {
+                    let b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = b.borrow_mut().1.call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            StateProj::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
+        }
+    }
+}
+
+/// `.then()` service factory combinator
+pub(crate) struct ThenServiceFactory<A, B>(Rc<(A, B)>);
+
+impl<A, B> ThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    /// Create new `AndThen` combinator
+    pub(crate) fn new(a: A, b: B) -> Self {
+        Self(Rc::new((a, b)))
+    }
+}
+
+impl<A, B> ServiceFactory for ThenServiceFactory<A, B>
+where
+    A: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    type Request = A::Request;
+    type Response = B::Response;
+    type Error = A::Error;
+
+    type Config = A::Config;
+    type Service = ThenService<A::Service, B::Service>;
+    type InitError = A::InitError;
+    type Future = ThenServiceFactoryResponse<A, B>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let srv = &*self.0;
+        ThenServiceFactoryResponse::new(srv.0.new_service(cfg.clone()), srv.1.new_service(cfg))
+    }
+}
+
+impl<A, B> Clone for ThenServiceFactory<A, B> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct ThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    #[pin]
+    fut_b: B::Future,
+    #[pin]
+    fut_a: A::Future,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B> ThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
+        Self {
+            fut_a,
+            fut_b,
+            a: None,
+            b: None,
+        }
+    }
+}
+
+impl<A, B> Future for ThenServiceFactoryResponse<A, B>
+where
+    A: ServiceFactory,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    type Output = Result<ThenService<A::Service, B::Service>, 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(ThenService::new(
+                this.a.take().unwrap(),
+                this.b.take().unwrap(),
+            )))
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cell::Cell;
+    use std::rc::Rc;
+    use std::task::{Context, Poll};
+
+    use futures_util::future::{err, lazy, ok, ready, Ready};
+
+    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
+
+    #[derive(Clone)]
+    struct Srv1(Rc<Cell<usize>>);
+
+    impl Service for Srv1 {
+        type Request = Result<&'static str, &'static str>;
+        type Response = &'static str;
+        type Error = ();
+        type Future = Ready<Result<Self::Response, Self::Error>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            self.0.set(self.0.get() + 1);
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, req: Result<&'static str, &'static str>) -> Self::Future {
+            match req {
+                Ok(msg) => ok(msg),
+                Err(_) => err(()),
+            }
+        }
+    }
+
+    struct Srv2(Rc<Cell<usize>>);
+
+    impl Service for Srv2 {
+        type Request = Result<&'static str, ()>;
+        type Response = (&'static str, &'static str);
+        type Error = ();
+        type Future = Ready<Result<Self::Response, ()>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            self.0.set(self.0.get() + 1);
+            Poll::Ready(Err(()))
+        }
+
+        fn call(&mut self, req: Result<&'static str, ()>) -> Self::Future {
+            match req {
+                Ok(msg) => ok((msg, "ok")),
+                Err(()) => ok(("srv2", "err")),
+            }
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_poll_ready() {
+        let cnt = Rc::new(Cell::new(0));
+        let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone()));
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Err(())));
+        assert_eq!(cnt.get(), 2);
+    }
+
+    #[actix_rt::test]
+    async fn test_call() {
+        let cnt = Rc::new(Cell::new(0));
+        let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt));
+
+        let res = srv.call(Ok("srv1")).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv1", "ok"));
+
+        let res = srv.call(Err("srv")).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv2", "err"));
+    }
+
+    #[actix_rt::test]
+    async fn test_factory() {
+        let cnt = Rc::new(Cell::new(0));
+        let cnt2 = cnt.clone();
+        let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone())));
+        let factory = pipeline_factory(blank).then(move || ready(Ok(Srv2(cnt.clone()))));
+        let mut srv = factory.new_service(&()).await.unwrap();
+        let res = srv.call(Ok("srv1")).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv1", "ok"));
+
+        let res = srv.call(Err("srv")).await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv2", "err"));
+    }
+}

actix-service/src/transform.rs

@@ -0,0 +1,246 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use crate::transform_err::TransformMapInitErr;
+use crate::{IntoServiceFactory, Service, ServiceFactory};
+
+/// Apply transform to a service.
+pub fn apply<T, S, U>(t: T, factory: U) -> ApplyTransform<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+    U: IntoServiceFactory<S>,
+{
+    ApplyTransform::new(t, factory.into_factory())
+}
+
+/// The `Transform` trait defines the interface of a service factory that wraps inner service
+/// during construction.
+///
+/// Transform(middleware) wraps inner service and runs during
+/// inbound and/or outbound processing in the request/response lifecycle.
+/// It may modify request and/or response.
+///
+/// For example, timeout transform:
+///
+/// ```rust,ignore
+/// pub struct Timeout<S> {
+///     service: S,
+///     timeout: Duration,
+/// }
+///
+/// impl<S> Service for Timeout<S>
+/// where
+///     S: Service,
+/// {
+///     type Request = S::Request;
+///     type Response = S::Response;
+///     type Error = TimeoutError<S::Error>;
+///     type Future = TimeoutServiceResponse<S>;
+///
+///     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+///         ready!(self.service.poll_ready(cx)).map_err(TimeoutError::Service)
+///     }
+///
+///     fn call(&mut self, req: S::Request) -> Self::Future {
+///         TimeoutServiceResponse {
+///             fut: self.service.call(req),
+///             sleep: Delay::new(clock::now() + self.timeout),
+///         }
+///     }
+/// }
+/// ```
+///
+/// Timeout service in above example is decoupled from underlying service implementation
+/// and could be applied to any service.
+///
+/// The `Transform` trait defines the interface of a Service factory. `Transform`
+/// is often implemented for middleware, defining how to construct a
+/// middleware Service. A Service that is constructed by the factory takes
+/// the Service that follows it during execution as a parameter, assuming
+/// ownership of the next Service.
+///
+/// Factory for `Timeout` middleware from the above example could look like this:
+///
+/// ```rust,,ignore
+/// pub struct TimeoutTransform {
+///     timeout: Duration,
+/// }
+///
+/// impl<S> Transform<S> for TimeoutTransform<E>
+/// where
+///     S: Service,
+/// {
+///     type Request = S::Request;
+///     type Response = S::Response;
+///     type Error = TimeoutError<S::Error>;
+///     type InitError = S::Error;
+///     type Transform = Timeout<S>;
+///     type Future = Ready<Result<Self::Transform, Self::InitError>>;
+///
+///     fn new_transform(&self, service: S) -> Self::Future {
+///         ok(TimeoutService {
+///             service,
+///             timeout: self.timeout,
+///         })
+///     }
+/// }
+/// ```
+pub trait Transform<S> {
+    /// Requests handled by the service.
+    type Request;
+
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The `TransformService` value created by this factory
+    type Transform: Service<
+        Request = Self::Request,
+        Response = Self::Response,
+        Error = Self::Error,
+    >;
+
+    /// Errors produced while building a transform service.
+    type InitError;
+
+    /// The future response value.
+    type Future: Future<Output = Result<Self::Transform, Self::InitError>>;
+
+    /// Creates and returns a new Transform component, asynchronously
+    fn new_transform(&self, service: S) -> Self::Future;
+
+    /// Map this transforms's factory error to a different error,
+    /// returning a new transform service factory.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E + Clone,
+    {
+        TransformMapInitErr::new(self, f)
+    }
+}
+
+impl<T, S> Transform<S> for Rc<T>
+where
+    T: Transform<S>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+impl<T, S> Transform<S> for Arc<T>
+where
+    T: Transform<S>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+/// `Apply` transform to new service
+pub struct ApplyTransform<T, S>(Rc<(T, S)>);
+
+impl<T, S> ApplyTransform<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    /// Create new `ApplyTransform` new service instance
+    fn new(t: T, service: S) -> Self {
+        Self(Rc::new((t, service)))
+    }
+}
+
+impl<T, S> Clone for ApplyTransform<T, S> {
+    fn clone(&self) -> Self {
+        ApplyTransform(self.0.clone())
+    }
+}
+
+impl<T, S> ServiceFactory for ApplyTransform<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type Config = S::Config;
+    type Service = T::Transform;
+    type InitError = T::InitError;
+    type Future = ApplyTransformFuture<T, S>;
+
+    fn new_service(&self, cfg: S::Config) -> Self::Future {
+        ApplyTransformFuture {
+            store: self.0.clone(),
+            state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct ApplyTransformFuture<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    store: Rc<(T, S)>,
+    #[pin]
+    state: ApplyTransformFutureState<T, S>,
+}
+
+#[pin_project::pin_project(project = ApplyTransformFutureStateProj)]
+pub enum ApplyTransformFutureState<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    A(#[pin] S::Future),
+    B(#[pin] T::Future),
+}
+
+impl<T, S> Future for ApplyTransformFuture<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    type Output = Result<T::Transform, T::InitError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            ApplyTransformFutureStateProj::A(fut) => match fut.poll(cx)? {
+                Poll::Ready(srv) => {
+                    let fut = this.store.0.new_transform(srv);
+                    this.state.set(ApplyTransformFutureState::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            ApplyTransformFutureStateProj::B(fut) => fut.poll(cx),
+        }
+    }
+}

actix-service/src/transform_err.rs

@@ -0,0 +1,93 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::Transform;
+
+/// Transform for the `map_init_err` combinator, changing the type of a new
+/// transform's init error.
+///
+/// This is created by the `Transform::map_init_err` method.
+pub struct TransformMapInitErr<T, S, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, E)>,
+}
+
+impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+    pub(crate) fn new(t: T, f: F) -> Self
+    where
+        T: Transform<S>,
+        F: Fn(T::InitError) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformMapInitErrFuture<T, S, F, E>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        TransformMapInitErrFuture {
+            fut: self.t.new_transform(service),
+            f: self.f.clone(),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E,
+{
+    #[pin]
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Output = Result<T::Transform, E>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        if let Poll::Ready(res) = this.fut.poll(cx) {
+            Poll::Ready(res.map_err(this.f))
+        } else {
+            Poll::Pending
+        }
+    }
+}

actix-testing/CHANGES.md

@@ -0,0 +1,33 @@
+# Changes
+
+## [1.0.1] - 2020-05-19
+
+* Replace deprecated `net2` crate with `socket2`
+
+* Remove unused `futures` dependency
+
+## [1.0.0] - 2019-12-11
+
+* Update actix-server to 1.0.0
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+* Migrate to tokio 0.2
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+* Re-export `test` attribute macros
+
+
+## [0.3.0-alpha.1] - 2019-11-22
+
+* Migrate to std::future
+
+## [0.2.0] - 2019-10-14
+
+* Upgrade actix-server and actix-server-config deps
+
+
+## [0.1.0] - 2019-09-25
+
+* Initial impl

actix-testing/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "actix-testing"
+version = "1.0.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix testing utils"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-testing/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+workspace = ".."
+readme = "README.md"
+
+[lib]
+name = "actix_testing"
+path = "src/lib.rs"
+
+[dependencies]
+actix-rt = "1.0.0"
+actix-macros = "0.1.0"
+actix-server = "1.0.0"
+actix-service = "1.0.0"
+
+log = "0.4"
+socket2 = "0.3"

actix-testing/LICENSE-APACHE

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

actix-testing/LICENSE-MIT

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

actix-testing/README.md

@@ -0,0 +1,9 @@
+# Actix test utilities [![crates.io](https://meritbadge.herokuapp.com/actix-testing)](https://crates.io/crates/actix-testint) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/actix-testing/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-http-test](https://crates.io/crates/actix-testing)
+* Minimum supported Rust version: 1.37 or later

actix-testing/src/lib.rs

@@ -0,0 +1,153 @@
+//! Various helpers for Actix applications to use during testing.
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity, clippy::needless_doctest_main)]
+
+use std::sync::mpsc;
+use std::{net, thread};
+
+use actix_rt::{net::TcpStream, System};
+use actix_server::{Server, ServerBuilder, ServiceFactory};
+use socket2::{Domain, Protocol, Socket, Type};
+
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub use actix_macros::test;
+
+/// The `TestServer` type.
+///
+/// `TestServer` is very simple test server that simplify process of writing
+/// integration tests for actix-net applications.
+///
+/// # Examples
+///
+/// ```rust
+/// use actix_service::fn_service;
+/// use actix_testing::TestServer;
+///
+/// #[actix_rt::main]
+/// async fn main() {
+///     let srv = TestServer::with(|| fn_service(
+///         |sock| async move {
+///             println!("New connection: {:?}", sock);
+///             Ok::<_, ()>(())
+///         }
+///     ));
+///
+///     println!("SOCKET: {:?}", srv.connect());
+/// }
+/// ```
+pub struct TestServer;
+
+/// Test server runstime
+pub struct TestServerRuntime {
+    addr: net::SocketAddr,
+    host: String,
+    port: u16,
+    system: System,
+}
+
+impl TestServer {
+    /// Start new server with server builder
+    pub fn start<F>(mut factory: F) -> TestServerRuntime
+    where
+        F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static,
+    {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        thread::spawn(move || {
+            let sys = System::new("actix-test-server");
+            factory(Server::build())
+                .workers(1)
+                .disable_signals()
+                .start();
+
+            tx.send(System::current()).unwrap();
+            sys.run()
+        });
+        let system = rx.recv().unwrap();
+
+        TestServerRuntime {
+            system,
+            addr: "127.0.0.1:0".parse().unwrap(),
+            host: "127.0.0.1".to_string(),
+            port: 0,
+        }
+    }
+
+    /// Start new test server with application factory
+    pub fn with<F: ServiceFactory<TcpStream>>(factory: F) -> TestServerRuntime {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        thread::spawn(move || {
+            let sys = System::new("actix-test-server");
+            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let local_addr = tcp.local_addr().unwrap();
+
+            Server::build()
+                .listen("test", tcp, factory)?
+                .workers(1)
+                .disable_signals()
+                .start();
+
+            tx.send((System::current(), local_addr)).unwrap();
+            sys.run()
+        });
+
+        let (system, addr) = rx.recv().unwrap();
+
+        let host = format!("{}", addr.ip());
+        let port = addr.port();
+
+        TestServerRuntime {
+            system,
+            addr,
+            host,
+            port,
+        }
+    }
+
+    /// Get firat available unused local address
+    pub fn unused_addr() -> net::SocketAddr {
+        let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+        let socket =
+            Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+        socket.bind(&addr.into()).unwrap();
+        socket.set_reuse_address(true).unwrap();
+        let tcp = socket.into_tcp_listener();
+        tcp.local_addr().unwrap()
+    }
+}
+
+impl TestServerRuntime {
+    /// Test server host
+    pub fn host(&self) -> &str {
+        &self.host
+    }
+
+    /// Test server port
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    /// Get test server address
+    pub fn addr(&self) -> net::SocketAddr {
+        self.addr
+    }
+
+    /// Stop http server
+    fn stop(&mut self) {
+        self.system.stop();
+    }
+
+    /// Connect to server, return tokio TcpStream
+    pub fn connect(&self) -> std::io::Result<TcpStream> {
+        TcpStream::from_std(net::TcpStream::connect(self.addr)?)
+    }
+}
+
+impl Drop for TestServerRuntime {
+    fn drop(&mut self) {
+        self.stop()
+    }
+}