prepare rt and tls releases (#287)

* add arbiter handle assoc fn

.github/workflows/ci.yml

@@ -0,0 +1,117 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches: [master]
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
+          - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
+          - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
+          - { name: Windows (MinGW), os: windows-latest, triple: x86_64-pc-windows-gnu }
+          - { name: Windows (32-bit), os: windows-latest, triple: i686-pc-windows-msvc }
+        version:
+          - 1.46.0 # MSRV
+          - stable
+          - nightly
+
+    name: ${{ matrix.target.name }} / ${{ matrix.version }}
+    runs-on: ${{ matrix.target.os }}
+
+    steps:
+      - name: Setup Routing
+        if: matrix.target.os == 'macos-latest'
+        run: sudo ifconfig lo0 alias 127.0.0.3
+
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-${{ matrix.target.triple }}
+          profile: minimal
+          override: true
+
+      # - name: Install MSYS2
+      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+      #   uses: msys2/setup-msys2@v2
+      # - name: Install MinGW Packages
+      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+      #   run: |
+      #     msys2 -c 'pacman -Sy --noconfirm pacman'
+      #     msys2 -c 'pacman --noconfirm -S base-devel pkg-config'
+
+      # - name: Generate Cargo.lock
+      #   uses: actions-rs/cargo@v1
+      #   with:
+      #     command: generate-lockfile
+      # - name: Cache Dependencies
+      #   uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: check minimal
+        uses: actions-rs/cargo@v1
+        with:
+          command: hack
+          args: check --workspace --no-default-features
+
+      - name: check minimal + tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: hack
+          args: check --workspace --no-default-features --tests --examples
+
+      - name: check default
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --workspace --tests --examples
+
+      - name: check full
+        # TODO: compile OpenSSL and run tests on MinGW
+        if: matrix.target.triple != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --workspace --all-features --tests --examples
+
+      - name: tests
+        if: matrix.target.triple != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --all-features --no-fail-fast -- --nocapture
+
+      - name: Generate coverage file
+        if: >
+          matrix.target.os == 'ubuntu-latest'
+          && matrix.version == 'stable'
+          && github.ref == 'refs/heads/master'
+        run: |
+          cargo install cargo-tarpaulin
+          cargo tarpaulin --out Xml --verbose
+      - name: Upload to Codecov
+        if: >
+          matrix.target.os == 'ubuntu-latest'
+          && matrix.version == 'stable'
+          && github.ref == 'refs/heads/master'
+        uses: codecov/codecov-action@v1
+        with:
+          file: cobertura.xml
+
+      - name: Clear the cargo caches
+        run: |
+          cargo install cargo-cache --no-default-features --features ci-autoclean
+          cargo-cache

.github/workflows/clippy-fmt.yml

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

.github/workflows/linux.yml

@@ -1,82 +0,0 @@
-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.46.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: --workspace --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with:
-          command: test
-          args: --workspace --exclude=actix-tls --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
-
-      - 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

@@ -1,43 +0,0 @@
-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: --workspace --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --exclude=actix-tls --no-fail-fast -- --nocapture

.github/workflows/upload-doc.yml

@@ -0,0 +1,35 @@
+name: Upload documentation
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Build Docs
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+          args: --workspace --all-features --no-deps
+
+      - name: Tweak HTML
+        run: echo '<meta http-equiv="refresh" content="0;url=actix_server/index.html">' > target/doc/index.html
+
+      - name: Deploy to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@3.7.1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: target/doc

.github/workflows/windows-mingw.yml

@@ -1,45 +0,0 @@
-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: --workspace --bins --examples --tests

.github/workflows/windows.yml

@@ -1,69 +0,0 @@
-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: --workspace --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --exclude=actix-tls --no-fail-fast -- --nocapture

Cargo.toml

@@ -1,31 +1,25 @@
 [workspace]
 members = [
   "actix-codec",
-  "actix-connect",
-  "actix-rt",
   "actix-macros",
-  "actix-service",
+  "actix-router",
+  "actix-rt",
   "actix-server",
-  "actix-testing",
-  "actix-threadpool",
+  "actix-service",
   "actix-tls",
   "actix-tracing",
   "actix-utils",
-  "router",
-  "string",
+  "bytestring",
 ]
 
 [patch.crates-io]
-actix-codec = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
-actix-connect = { path = "actix-connect" }
-actix-rt = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
+actix-codec = { path = "actix-codec" }
 actix-macros = { path = "actix-macros" }
+actix-router = { path = "actix-router" }
+actix-rt = { path = "actix-rt" }
 actix-server = { path = "actix-server" }
-actix-service = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
-actix-testing = { path = "actix-testing" }
-actix-threadpool = { path = "actix-threadpool" }
+actix-service = { path = "actix-service" }
 actix-tls = { path = "actix-tls" }
 actix-tracing = { path = "actix-tracing" }
-actix-utils = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
-actix-router = { path = "router" }
-bytestring = { path = "string" }
+actix-utils = { path = "actix-utils" }
+bytestring = { path = "bytestring" }

README.md

@@ -1,9 +1,12 @@
-# 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
 
-Actix net - framework for composable network services
+> A collection of lower-level libraries for composable network services.
+
+![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/actix-server)
+[![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 ## 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)") |
@@ -11,59 +14,13 @@ Actix net - framework for composable network services
 | 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
-
-* [Chat on Gitter](https://gitter.im/actix/actix)
-* Minimum supported Rust version: 1.46 or later
-
 ## Example
+See `actix-server/examples` and `actix-tls/examples` for some basic examples.
 
-```rust
-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();
-    builder.set_certificate_chain_file("./examples/cert.pem").unwrap();
-    let acceptor = builder.build();
-
-    let num = Arc::new(AtomicUsize::new(0));
-
-    // 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::build()
-        .bind(
-            // configure service pipeline
-            "basic", "0.0.0.0:8443",
-            move || {
-                let num = num.clone();
-                let acceptor = acceptor.clone();
-
-                // 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()
-}
-```
+### MSRV
+This repo's Minimum Supported Rust Version (MSRV) is 1.46.0.
 
 ## License
-
 This project is licensed under either of
 
 * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
@@ -73,6 +30,5 @@ at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-net crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-net, @fafhrd91, promises to
-intervene to uphold that code of conduct.
+Contribution to the actix-net repo is organized under the terms of the Contributor Covenant.
+The Actix team promises to intervene to uphold that code of conduct.

actix-codec/CHANGES.md

@@ -1,6 +1,6 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
 
 
 ## 0.4.0-beta.1 - 2020-12-28

actix-codec/Cargo.toml

@@ -6,7 +6,7 @@ description = "Codec utilities for working with framed protocols"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-codec/"
+documentation = "https://docs.rs/actix-codec"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"

actix-connect/CHANGES.md

@@ -1,154 +0,0 @@
-# Changes
-
-## Unreleased - 2020-xx-xx
-
-
-## 2.0.0 - 2020-09-02
-- No significant changes from `2.0.0-alpha.4`.
-
-## 2.0.0-alpha.4 - 2020-08-17
-
-### 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

@@ -1,58 +0,0 @@
-[package]
-name = "actix-connect"
-version = "2.0.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "TCP connector service for Actix ecosystem."
-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.6"
-actix-codec = "0.3.0"
-actix-utils = "2.0.0"
-actix-rt = "1.1.1"
-
-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 = { package = "openssl", version = "0.10", optional = true }
-tokio-openssl = { version = "0.4.0", optional = true }
-
-# rustls
-rust-tls = { package = "rustls", version = "0.18.0", optional = true }
-tokio-rustls = { version = "0.14.0", optional = true }
-webpki = { version = "0.21", optional = true }
-
-[dev-dependencies]
-bytes = "0.5.3"
-actix-testing = "1.0.0"

actix-connect/src/connect.rs

@@ -1,282 +0,0 @@
-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 splitting 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)
-    }
-
-    /// Pre-resolved 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 pre-resolved 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`] 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`] 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

@@ -1,168 +0,0 @@
-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<Connect<T>> for TcpConnectorFactory<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<Connect<T>> for TcpConnector<T> {
-    type Response = Connection<T, TcpStream>;
-    type Error = ConnectError;
-    #[allow(clippy::type_complexity)]
-    type Future = Either<TcpConnectorResponse<T>, Ready<Result<Self::Response, Self::Error>>>;
-
-    actix_service::always_ready!();
-
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
-        let port = req.port();
-        let Connect { req, addr, .. } = req;
-
-        if let Some(addr) = addr {
-            Either::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/lib.rs

@@ -1,113 +0,0 @@
-//! TCP connector service for Actix ecosystem.
-//!
-//! ## Package feature
-//!
-//! * `openssl` - enables TLS support via `openssl` crate
-//! * `rustls` - enables TLS support via `rustls` crate
-
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![recursion_limit = "128"]
-#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
-#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-
-#[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<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
-{
-    pipeline(Resolver::new(resolver)).and_then(TcpConnector::new())
-}
-
-/// Create TCP connector service factory.
-pub fn new_connector_factory<T: Address + 'static>(
-    resolver: AsyncResolver,
-) -> impl ServiceFactory<
-    Connect<T>,
-    Config = (),
-    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<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<
-    Connect<T>,
-    Config = (),
-    Response = Connection<T, TcpStream>,
-    Error = ConnectError,
-    InitError = (),
-> + Clone {
-    pipeline_factory(ResolverFactory::default()).and_then(TcpConnectorFactory::new())
-}

actix-connect/src/resolve.rs

@@ -1,204 +0,0 @@
-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<Connect<T>> for ResolverFactory<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<Connect<T>> for Resolver<T> {
-    type Response = Connect<T>;
-    type Error = ConnectError;
-    #[allow(clippy::type_complexity)]
-    type Future = Either<
-        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>,
-        Ready<Result<Connect<T>, Self::Error>>,
-    >;
-
-    actix_service::always_ready!();
-
-    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

@@ -1,225 +0,0 @@
-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<Connect<T>> for ConnectServiceFactory<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<Connect<T>> for ConnectService<T> {
-    type Response = Connection<T, TcpStream>;
-    type Error = ConnectError;
-    type Future = ConnectServiceResponse<T>;
-
-    actix_service::always_ready!();
-
-    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<Connect<T>>>::Future),
-    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
-}
-
-impl<T: Address> ConnectState<T> {
-    #[allow(clippy::type_complexity)]
-    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<Connect<T>> for TcpConnectService<T> {
-    type Response = TcpStream;
-    type Error = ConnectError;
-    type Future = TcpConnectServiceResponse<T>;
-
-    actix_service::always_ready!();
-
-    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<Connect<T>>>::Future),
-    Connect(<TcpConnector<T> as Service<Connect<T>>>::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/uri.rs

@@ -1,37 +0,0 @@
-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-macros/CHANGES.md

@@ -1,13 +1,27 @@
-# CHANGES
+# Changes
 
-## 0.1.3 - 2020-12-3
+## Unreleased - 2021-xx-xx
+
+
+## 0.2.0 - 2021-02-02
+* Update to latest `actix_rt::System::new` signature. [#261]
+
+[#261]: https://github.com/actix/actix-net/pull/261
+
+
+## 0.2.0-beta.1 - 2021-01-09
+* Remove `actix-reexport` feature. [#218]
+
+[#218]: https://github.com/actix/actix-net/pull/218
+
+
+## 0.1.3 - 2020-12-03
+* Add `actix-reexport` feature. [#218]
+
+[#218]: https://github.com/actix/actix-net/pull/218
 
-* Add `actix-reexport` feature
 
 ## 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

@@ -1,10 +1,10 @@
 [package]
 name = "actix-macros"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime macros"
-repository = "https://github.com/actix/actix-net"
-documentation = "https://docs.rs/actix-macros/"
+description = "Macros for Actix system and runtime"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-macros"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -16,11 +16,8 @@ proc-macro = true
 quote = "1.0.3"
 syn = { version = "^1", features = ["full"] }
 
-[features]
-actix-reexport = []
-
 [dev-dependencies]
-actix-rt = "1.0"
+actix-rt = "2.0.0"
 
 futures-util = { version = "0.3", default-features = false }
 trybuild = "1"

actix-macros/src/lib.rs

@@ -1,4 +1,12 @@
-//! Macros for use with Tokio
+//! Macros for Actix system and runtime.
+//!
+//! The [`actix-rt`](https://docs.rs/actix-rt) crate must be available for macro output to compile.
+//!
+//! # Entry-point
+//! See docs for the [`#[main]`](macro@main) macro.
+//!
+//! # Tests
+//! See docs for the [`#[test]`](macro@test) macro.
 
 #![deny(rust_2018_idioms, nonstandard_style)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
@@ -7,11 +15,10 @@
 use proc_macro::TokenStream;
 use quote::quote;
 
-/// Marks async function to be executed by actix system.
+/// Marks async entry-point function to be executed by Actix system.
 ///
-/// ## Usage
-///
-/// ```rust
+/// # Examples
+/// ```
 /// #[actix_rt::main]
 /// async fn main() {
 ///     println!("Hello world");
@@ -26,42 +33,32 @@ pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
     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();
+        return syn::Error::new_spanned(
+            sig.fn_token,
+            "the async keyword is missing from the function declaration",
+        )
+        .to_compile_error()
+        .into();
     }
 
     sig.asyncness = None;
 
-    if cfg!(feature = "actix-reexport") {
-        (quote! {
-            #(#attrs)*
-            #vis #sig {
-                actix::System::new(stringify!(#name))
-                    .block_on(async move { #body })
-            }
-        })
-        .into()
-    } else {
-        (quote! {
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new(stringify!(#name))
-                    .block_on(async move { #body })
-            }
-        })
-        .into()
-    }
+    (quote! {
+        #(#attrs)*
+        #vis #sig {
+            actix_rt::System::new()
+                .block_on(async move { #body })
+        }
+    })
+    .into()
 }
 
-/// Marks async test function to be executed by actix runtime.
+/// Marks async test function to be executed in an Actix system.
 ///
-/// ## Usage
-///
-/// ```no_run
+/// # Examples
+/// ```
 /// #[actix_rt::test]
 /// async fn my_test() {
 ///     assert!(true);
@@ -85,7 +82,7 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
     if sig.asyncness.is_none() {
         return syn::Error::new_spanned(
             input.sig.fn_token,
-            format!("only async fn is supported, {}", input.sig.ident),
+            "the async keyword is missing from the function declaration",
         )
         .to_compile_error()
         .into();
@@ -93,24 +90,19 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
 
     sig.asyncness = None;
 
-    let result = if has_test_attr {
-        quote! {
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new("test")
-                    .block_on(async { #body })
-            }
-        }
+    let missing_test_attr = if has_test_attr {
+        quote!()
     } else {
-        quote! {
-            #[test]
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new("test")
-                    .block_on(async { #body })
-            }
-        }
+        quote!(#[test])
     };
 
-    result.into()
+    (quote! {
+        #missing_test_attr
+        #(#attrs)*
+        #vis #sig {
+            actix_rt::System::new()
+                .block_on(async { #body })
+        }
+    })
+    .into()
 }

actix-macros/tests/trybuild.rs

@@ -3,7 +3,9 @@ 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/main-03-fn-params.rs");
 
     t.pass("tests/trybuild/test-01-basic.rs");
     t.pass("tests/trybuild/test-02-keep-attrs.rs");
+    t.compile_fail("tests/trybuild/test-03-only-async.rs");
 }

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

@@ -1,4 +1,4 @@
-error: only async fn is supported
+error: the async keyword is missing from the function declaration
  --> $DIR/main-02-only-async.rs:2:1
   |
 2 | fn main() {

actix-macros/tests/trybuild/main-03-fn-params.rs

@@ -0,0 +1,6 @@
+#[actix_rt::main]
+async fn main2(_param: bool) {
+    futures_util::future::ready(()).await
+}
+
+fn main() {}

actix-macros/tests/trybuild/test-03-only-async.rs

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

actix-macros/tests/trybuild/test-03-only-async.stderr

@@ -0,0 +1,5 @@
+error: the async keyword is missing from the function declaration
+ --> $DIR/test-03-only-async.rs:2:1
+  |
+2 | fn my_test() {
+  | ^^

actix-router/CHANGES.md

@@ -1,6 +1,18 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 0.2.7 - 2021-02-06
+* Add `Router::recognize_checked` [#247]
+
+[#247]: https://github.com/actix/actix-net/pull/247
+
+
+## 0.2.6 - 2021-01-09
+* Use `bytestring` version range compatible with Bytes v1.0. [#246]
+
+[#246]: https://github.com/actix/actix-net/pull/246
 
 
 ## 0.2.5 - 2020-09-20

actix-router/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "actix-router"
-version = "0.2.5"
+version = "0.2.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Resource path matching library"
-keywords = ["actix"]
+keywords = ["actix", "router", "routing"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-router/"
+documentation = "https://docs.rs/actix-router"
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
@@ -20,10 +20,10 @@ default = ["http"]
 [dependencies]
 regex = "1.3.1"
 serde = "1.0.104"
-bytestring = "0.1.2"
+bytestring = ">=0.1.5, <2"
 log = "0.4.8"
-http = { version = "0.2.0", optional = true }
+http = { version = "0.2.2", optional = true }
 
 [dev-dependencies]
-http = "0.2.0"
+http = "0.2.2"
 serde_derive = "1.0"

actix-router/src/path.rs

@@ -50,20 +50,20 @@ impl<T: ResourcePath> Path<T> {
         }
     }
 
-    #[inline]
     /// Get reference to inner path instance
+    #[inline]
     pub fn get_ref(&self) -> &T {
         &self.path
     }
 
-    #[inline]
     /// Get mutable reference to inner path instance
+    #[inline]
     pub fn get_mut(&mut self) -> &mut T {
         &mut self.path
     }
 
-    #[inline]
     /// Path
+    #[inline]
     pub fn path(&self) -> &str {
         let skip = self.skip as usize;
         let path = self.path.path();
@@ -74,23 +74,23 @@ impl<T: ResourcePath> Path<T> {
         }
     }
 
-    #[inline]
     /// Set new path
+    #[inline]
     pub fn set(&mut self, path: T) {
         self.skip = 0;
         self.path = path;
         self.segments.clear();
     }
 
-    #[inline]
     /// Reset state
+    #[inline]
     pub fn reset(&mut self) {
         self.skip = 0;
         self.segments.clear();
     }
 
-    #[inline]
     /// Skip first `n` chars in path
+    #[inline]
     pub fn skip(&mut self, n: u16) {
         self.skip += n;
     }
@@ -109,14 +109,14 @@ impl<T: ResourcePath> Path<T> {
         self.segments.push((name, PathItem::Static(value)));
     }
 
-    #[inline]
     /// Check if there are any matched patterns
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.segments.is_empty()
     }
 
-    #[inline]
     /// Check number of extracted parameters
+    #[inline]
     pub fn len(&self) -> usize {
         self.segments.len()
     }

actix-router/src/resource.rs

@@ -28,6 +28,7 @@ enum PatternElement {
 }
 
 #[derive(Clone, Debug)]
+#[allow(clippy::large_enum_variant)]
 enum PatternType {
     Static(String),
     Prefix(String),
@@ -154,8 +155,8 @@ impl ResourceDef {
         &self.pattern
     }
 
-    #[inline]
     /// Check if path matches this pattern.
+    #[inline]
     pub fn is_match(&self, path: &str) -> bool {
         match self.tp {
             PatternType::Static(ref s) => s == path,
@@ -669,8 +670,6 @@ pub(crate) fn insert_slash(path: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use http::Uri;
-    use std::convert::TryFrom;
 
     #[test]
     fn test_parse_static() {
@@ -832,8 +831,11 @@ mod tests {
         assert!(re.is_match("/user/2345/sdg"));
     }
 
+    #[cfg(feature = "http")]
     #[test]
     fn test_parse_urlencoded_param() {
+        use std::convert::TryFrom;
+
         let re = ResourceDef::new("/user/{id}/test");
 
         let mut path = Path::new("/user/2345/test");
@@ -844,7 +846,7 @@ mod tests {
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("id").unwrap(), "qwe%25");
 
-        let uri = Uri::try_from("/user/qwe%25/test").unwrap();
+        let uri = http::Uri::try_from("/user/qwe%25/test").unwrap();
         let mut path = Path::new(uri);
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("id").unwrap(), "qwe%25");

actix-router/src/router.rs

@@ -45,6 +45,24 @@ impl<T, U> Router<T, U> {
         None
     }
 
+    pub fn recognize_checked<R, P, F>(
+        &self,
+        resource: &mut R,
+        check: F,
+    ) -> Option<(&T, ResourceId)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        for item in self.0.iter() {
+            if item.0.match_path_checked(resource, &check, &item.2) {
+                return Some((&item.1, ResourceId(item.0.id())));
+            }
+        }
+        None
+    }
+
     pub fn recognize_mut_checked<R, P, F>(
         &mut self,
         resource: &mut R,

actix-rt/CHANGES.md

@@ -1,6 +1,66 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.1.0 - 2021-02-24
+* Add `ActixStream` extension trait to include readiness methods. [#276]
+* Re-export `tokio::net::TcpSocket` in `net` module [#282]
+
+[#276]: https://github.com/actix/actix-net/pull/276
+[#282]: https://github.com/actix/actix-net/pull/282
+
+
+## 2.0.2 - 2021-02-06
+* Add `Arbiter::handle` to get a handle of an owned Arbiter. [#274]
+* Add `System::try_current` for situations where actix may or may not be running a System. [#275]
+
+[#274]: https://github.com/actix/actix-net/pull/274
+[#275]: https://github.com/actix/actix-net/pull/275
+
+
+## 2.0.1 - 2021-02-06
+* Expose `JoinError` from Tokio. [#271]
+
+[#271]: https://github.com/actix/actix-net/pull/271
+
+
+## 2.0.0 - 2021-02-02
+* Remove all Arbiter-local storage methods. [#262]
+* Re-export `tokio::pin`. [#262]
+
+[#262]: https://github.com/actix/actix-net/pull/262
+
+
+## 2.0.0-beta.3 - 2021-01-31
+* Remove `run_in_tokio`, `attach_to_tokio` and `AsyncSystemRunner`. [#253]
+* Return `JoinHandle` from `actix_rt::spawn`. [#253]
+* Remove old `Arbiter::spawn`. Implementation is now inlined into `actix_rt::spawn`. [#253]
+* Rename `Arbiter::{send => spawn}` and `Arbiter::{exec_fn => spawn_fn}`. [#253]
+* Remove `Arbiter::exec`. [#253]
+* Remove deprecated `Arbiter::local_join` and `Arbiter::is_running`. [#253]
+* `Arbiter::spawn` now accepts !Unpin futures. [#256]
+* `System::new` no longer takes arguments. [#257]
+* Remove `System::with_current`. [#257]
+* Remove `Builder`. [#257]
+* Add `System::with_init` as replacement for `Builder::run`. [#257]
+* Rename `System::{is_set => is_registered}`. [#257]
+* Add `ArbiterHandle` for sending messages to non-current-thread arbiters. [#257].
+* `System::arbiter` now returns an `&ArbiterHandle`. [#257]
+* `Arbiter::current` now returns an `ArbiterHandle` instead. [#257]
+* `Arbiter::join` now takes self by value. [#257]
+
+[#253]: https://github.com/actix/actix-net/pull/253
+[#254]: https://github.com/actix/actix-net/pull/254
+[#256]: https://github.com/actix/actix-net/pull/256
+[#257]: https://github.com/actix/actix-net/pull/257
+
+
+## 2.0.0-beta.2 - 2021-01-09
+* Add `task` mod with re-export of `tokio::task::{spawn_blocking, yield_now, JoinHandle}` [#245]
+* Add default "macros" feature to allow faster compile times when using `default-features=false`.
+
+[#245]: https://github.com/actix/actix-net/pull/245
 
 
 ## 2.0.0-beta.1 - 2020-12-28

actix-rt/Cargo.toml

@@ -1,12 +1,15 @@
 [package]
 name = "actix-rt"
-version = "2.0.0-beta.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Tokio-based single-thread async runtime for the Actix ecosystem"
-keywords = ["network", "framework", "async", "futures"]
+version = "2.1.0"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
+description = "Tokio-based single-threaded async runtime for the Actix ecosystem"
+keywords = ["async", "futures", "io", "runtime"]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-rt/"
+repository = "https://github.com/actix/actix-net"
+documentation = "https://docs.rs/actix-rt"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -15,7 +18,16 @@ edition = "2018"
 name = "actix_rt"
 path = "src/lib.rs"
 
-[dependencies]
-actix-macros = "0.1.0"
+[features]
+default = ["macros"]
+macros = ["actix-macros"]
 
-tokio = { version = "1", features = ["rt", "net", "signal", "sync", "time"] }
+[dependencies]
+actix-macros = { version = "0.2.0", optional = true }
+
+futures-core = { version = "0.3", default-features = false }
+tokio = { version = "1.2", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }
+
+[dev-dependencies]
+tokio = { version = "1.2", features = ["full"] }
+hyper = { version = "0.14", default-features = false, features = ["server", "tcp", "http1"] }

actix-rt/README.md

@@ -0,0 +1,14 @@
+# actix-rt
+
+> Tokio-based single-threaded async runtime for the Actix ecosystem.
+
+[![crates.io](https://img.shields.io/crates/v/actix-rt?label=latest)](https://crates.io/crates/actix-rt)
+[![Documentation](https://docs.rs/actix-rt/badge.svg?version=2.1.0)](https://docs.rs/actix-rt/2.1.0)
+[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-rt.svg)
+<br />
+[![dependency status](https://deps.rs/crate/actix-rt/2.1.0/status.svg)](https://deps.rs/crate/actix-rt/2.1.0)
+![Download](https://img.shields.io/crates/d/actix-rt.svg)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/WghFtEH6Hb)
+
+See crate documentation for more: https://docs.rs/actix-rt.

actix-rt/examples/hyper.rs

@@ -0,0 +1,28 @@
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Request, Response, Server};
+use std::convert::Infallible;
+use std::net::SocketAddr;
+
+async fn handle(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
+    Ok(Response::new(Body::from("Hello World")))
+}
+
+fn main() {
+    actix_rt::System::with_tokio_rt(|| {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+    })
+    .block_on(async {
+        let make_service =
+            make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) });
+
+        let server =
+            Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000))).serve(make_service);
+
+        if let Err(e) = server.await {
+            eprintln!("server error: {}", e);
+        }
+    })
+}

actix-rt/src/arbiter.rs

@@ -1,39 +1,30 @@
-use std::any::{Any, TypeId};
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::task::{Context, Poll};
-use std::{fmt, thread};
+use std::{
+    cell::RefCell,
+    fmt,
+    future::Future,
+    pin::Pin,
+    sync::atomic::{AtomicUsize, Ordering},
+    task::{Context, Poll},
+    thread,
+};
 
-use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
-use tokio::sync::oneshot::{channel, error::RecvError as Canceled, Sender};
-// use futures_util::stream::FuturesUnordered;
-// use tokio::task::JoinHandle;
-// use tokio::stream::StreamExt;
-use tokio::task::LocalSet;
+use futures_core::ready;
+use tokio::{sync::mpsc, task::LocalSet};
 
-use crate::runtime::Runtime;
-use crate::system::System;
-
-thread_local!(
-    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
-    // TODO: Commented out code are for Arbiter::local_join function.
-    // It can be safely removed if this function is not used in actix-*.
-    //
-    // /// stores join handle for spawned async tasks.
-    // static HANDLE: RefCell<FuturesUnordered<JoinHandle<()>>> =
-    //     RefCell::new(FuturesUnordered::new());
-    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
-);
+use crate::{
+    runtime::{default_tokio_runtime, Runtime},
+    system::{System, SystemCommand},
+};
 
 pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 
+thread_local!(
+    static HANDLE: RefCell<Option<ArbiterHandle>> = RefCell::new(None);
+);
+
 pub(crate) enum ArbiterCommand {
     Stop,
-    Execute(Box<dyn Future<Output = ()> + Unpin + Send>),
-    ExecuteFn(Box<dyn FnExec>),
+    Execute(Pin<Box<dyn Future<Output = ()> + Send>>),
 }
 
 impl fmt::Debug for ArbiterCommand {
@@ -41,391 +32,229 @@ impl fmt::Debug for ArbiterCommand {
         match self {
             ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
             ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
-            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
         }
     }
 }
 
+/// A handle for sending spawn and stop messages to an [Arbiter].
+#[derive(Debug, Clone)]
+pub struct ArbiterHandle {
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
+}
+
+impl ArbiterHandle {
+    pub(crate) fn new(tx: mpsc::UnboundedSender<ArbiterCommand>) -> Self {
+        Self { tx }
+    }
+
+    /// Send a future to the [Arbiter]'s thread and spawn it.
+    ///
+    /// If you require a result, include a response channel in the future.
+    ///
+    /// Returns true if future was sent successfully and false if the [Arbiter] has died.
+    pub fn spawn<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        self.tx
+            .send(ArbiterCommand::Execute(Box::pin(future)))
+            .is_ok()
+    }
+
+    /// Send a function to the [Arbiter]'s thread and execute it.
+    ///
+    /// Any result from the function is discarded. If you require a result, include a response
+    /// channel in the function.
+    ///
+    /// Returns true if function was sent successfully and false if the [Arbiter] has died.
+    pub fn spawn_fn<F>(&self, f: F) -> bool
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        self.spawn(async { f() })
+    }
+
+    /// Instruct [Arbiter] to stop processing it's event loop.
+    ///
+    /// Returns true if stop message was sent successfully and false if the [Arbiter] has
+    /// been dropped.
+    pub fn stop(&self) -> bool {
+        self.tx.send(ArbiterCommand::Stop).is_ok()
+    }
+}
+
+/// An Arbiter represents a thread that provides an asynchronous execution environment for futures
+/// and functions.
+///
+/// When an arbiter is created, it spawns a new [OS thread](thread), and hosts an event loop.
 #[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()
-    }
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
+    thread_handle: thread::JoinHandle<()>,
 }
 
 impl Arbiter {
-    pub(crate) fn new_system(local: &LocalSet) -> Self {
-        let (tx, rx) = unbounded_channel();
-
-        let arb = Arbiter::with_sender(tx);
-        ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
-        STORAGE.with(|cell| cell.borrow_mut().clear());
-
-        local.spawn_local(ArbiterController { 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"),
+    /// Spawn a new Arbiter thread and start its event loop.
+    ///
+    /// # Panics
+    /// Panics if a [System] is not registered on the current thread.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Arbiter {
+        Self::with_tokio_rt(|| {
+            default_tokio_runtime().expect("Cannot create new Arbiter's Runtime.")
         })
     }
 
-    /// Check if current arbiter is running.
-    #[deprecated(note = "Thread local variables for running state of Arbiter is removed")]
-    pub fn is_running() -> bool {
-        false
-    }
-
-    /// Stop arbiter from continuing it's event loop.
-    pub fn stop(&self) {
-        let _ = self.sender.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);
+    /// Spawn a new Arbiter using the [Tokio Runtime](tokio-runtime) returned from a closure.
+    ///
+    /// [tokio-runtime]: tokio::runtime::Runtime
+    #[doc(hidden)]
+    pub fn with_tokio_rt<F>(runtime_factory: F) -> Arbiter
+    where
+        F: Fn() -> tokio::runtime::Runtime + Send + 'static,
+    {
         let sys = System::current();
-        let (tx, rx) = unbounded_channel();
+        let system_id = sys.id();
+        let arb_id = COUNT.fetch_add(1, Ordering::Relaxed);
 
-        let handle = thread::Builder::new()
+        let name = format!("actix-rt|system:{}|arbiter:{}", system_id, arb_id);
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel::<()>();
+
+        let thread_handle = thread::Builder::new()
             .name(name.clone())
             .spawn({
                 let tx = tx.clone();
                 move || {
-                    let rt = Runtime::new().expect("Can not create Runtime");
-                    let arb = Arbiter::with_sender(tx);
-
-                    STORAGE.with(|cell| cell.borrow_mut().clear());
+                    let rt = Runtime::from(runtime_factory());
+                    let hnd = ArbiterHandle::new(tx);
 
                     System::set_current(sys);
 
-                    ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+                    HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
 
                     // register arbiter
                     let _ = System::current()
-                        .sys()
-                        .send(SystemCommand::RegisterArbiter(id, arb));
+                        .tx()
+                        .send(SystemCommand::RegisterArbiter(arb_id, hnd));
 
-                    // start arbiter controller
-                    // run loop
-                    rt.block_on(ArbiterController { rx });
+                    ready_tx.send(()).unwrap();
 
-                    // unregister arbiter
+                    // run arbiter event processing loop
+                    rt.block_on(ArbiterRunner { rx });
+
+                    // deregister arbiter
                     let _ = System::current()
-                        .sys()
-                        .send(SystemCommand::UnregisterArbiter(id));
+                        .tx()
+                        .send(SystemCommand::DeregisterArbiter(arb_id));
                 }
             })
             .unwrap_or_else(|err| {
-                panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
+                panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err)
             });
 
-        Arbiter {
-            sender: tx,
-            thread_handle: Some(handle),
-        }
+        ready_rx.recv().unwrap();
+
+        Arbiter { tx, thread_handle }
     }
 
-    /// 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,
-    {
-        // HANDLE.with(|handle| {
-        //     let handle = handle.borrow();
-        //     handle.push(tokio::task::spawn_local(future));
-        // });
-        // let _ = tokio::task::spawn_local(CleanupPending);
-        let _ = tokio::task::spawn_local(future);
+    /// Sets up an Arbiter runner in a new System using the provided runtime local task set.
+    pub(crate) fn in_new_system(local: &LocalSet) -> ArbiterHandle {
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let hnd = ArbiterHandle::new(tx);
+
+        HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+        local.spawn_local(ArbiterRunner { rx });
+
+        hnd
     }
 
-    /// 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(async {
-            f();
+    /// Return a handle to the this Arbiter's message sender.
+    pub fn handle(&self) -> ArbiterHandle {
+        ArbiterHandle::new(self.tx.clone())
+    }
+
+    /// Return a handle to the current thread's Arbiter's message sender.
+    ///
+    /// # Panics
+    /// Panics if no Arbiter is running on the current thread.
+    pub fn current() -> ArbiterHandle {
+        HANDLE.with(|cell| match *cell.borrow() {
+            Some(ref hnd) => hnd.clone(),
+            None => panic!("Arbiter is not running."),
         })
     }
 
-    /// 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.send(ArbiterCommand::Execute(Box::new(future)));
+    /// Stop Arbiter from continuing it's event loop.
+    ///
+    /// Returns true if stop message was sent successfully and false if the Arbiter has been dropped.
+    pub fn stop(&self) -> bool {
+        self.tx.send(ArbiterCommand::Stop).is_ok()
     }
 
-    /// 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)
+    /// Send a future to the Arbiter's thread and spawn it.
+    ///
+    /// If you require a result, include a response channel in the future.
+    ///
+    /// Returns true if future was sent successfully and false if the Arbiter has died.
+    pub fn spawn<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        self.tx
+            .send(ArbiterCommand::Execute(Box::pin(future)))
+            .is_ok()
+    }
+
+    /// Send a function to the Arbiter's thread and execute it.
+    ///
+    /// Any result from the function is discarded. If you require a result, include a response
+    /// channel in the function.
+    ///
+    /// Returns true if function was sent successfully and false if the Arbiter has died.
+    pub fn spawn_fn<F>(&self, f: F) -> bool
     where
         F: FnOnce() + Send + 'static,
     {
-        let _ = self
-            .sender
-            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                f();
-            })));
+        self.spawn(async { 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
-            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                if !tx.is_closed() {
-                    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.
+    /// Wait for Arbiter's event loop to complete.
     ///
-    /// 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.
-    #[deprecated(since = "1.2.0", note = "Arbiter::local_join function is removed.")]
-    pub async fn local_join() {
-        // let handle = HANDLE.with(|fut| std::mem::take(&mut *fut.borrow_mut()));
-        // async move {
-        //     handle.collect::<Vec<_>>().await;
-        // }
-        unimplemented!("Arbiter::local_join function is removed.")
+    /// Joins the underlying OS thread handle. See [`JoinHandle::join`](thread::JoinHandle::join).
+    pub fn join(self) -> thread::Result<()> {
+        self.thread_handle.join()
     }
 }
 
-// /// 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> {
-//         HANDLE.with(move |handle| {
-//             recycle_join_handle(&mut *handle.borrow_mut(), cx);
-//         });
-//
-//         Poll::Ready(())
-//     }
-// }
-
-struct ArbiterController {
-    rx: UnboundedReceiver<ArbiterCommand>,
+/// A persistent future that processes [Arbiter] commands.
+struct ArbiterRunner {
+    rx: mpsc::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 {
+impl Future for ArbiterRunner {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // process all items currently buffered in channel
         loop {
-            match Pin::new(&mut self.rx).poll_recv(cx) {
-                Poll::Ready(None) => return Poll::Ready(()),
-                Poll::Ready(Some(item)) => match item {
-                    ArbiterCommand::Stop => return Poll::Ready(()),
-                    ArbiterCommand::Execute(fut) => {
-                        // HANDLE.with(|handle| {
-                        //     let mut handle = handle.borrow_mut();
-                        //     handle.push(tokio::task::spawn_local(fut));
-                        //     recycle_join_handle(&mut *handle, cx);
-                        // });
-                        tokio::task::spawn_local(fut);
+            match ready!(Pin::new(&mut self.rx).poll_recv(cx)) {
+                // channel closed; no more messages can be received
+                None => return Poll::Ready(()),
+
+                // process arbiter command
+                Some(item) => match item {
+                    ArbiterCommand::Stop => {
+                        return Poll::Ready(());
                     }
-                    ArbiterCommand::ExecuteFn(f) => {
-                        f.call_box();
+                    ArbiterCommand::Execute(task_fut) => {
+                        tokio::task::spawn_local(task_fut);
                     }
                 },
-                Poll::Pending => return Poll::Pending,
             }
         }
     }
 }
-
-// fn recycle_join_handle(handle: &mut FuturesUnordered<JoinHandle<()>>, cx: &mut Context<'_>) {
-//     let _ = Pin::new(&mut *handle).poll_next(cx);
-//
-//     // Try to recycle more join handles and free up memory.
-//     //
-//     // this is a guess. The yield limit for FuturesUnordered is 32.
-//     // So poll an extra 3 times would make the total poll below 128.
-//     if handle.len() > 64 {
-//         (0..3).for_each(|_| {
-//             let _ = Pin::new(&mut *handle).poll_next(cx);
-//         })
-//     }
-// }
-
-#[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_recv(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

@@ -1,183 +0,0 @@
-use std::borrow::Cow;
-use std::future::Future;
-use std::io;
-
-use tokio::sync::mpsc::unbounded_channel;
-use tokio::sync::oneshot::{channel, Receiver};
-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(),
-    {
-        self.create_runtime(f).run()
-    }
-
-    fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded_channel();
-
-        let system =
-            System::construct(sys_sender, Arbiter::new_system(local), 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(),
-    {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded_channel();
-
-        let rt = Runtime::new().unwrap();
-
-        let system = System::construct(
-            sys_sender,
-            Arbiter::new_system(rt.local()),
-            self.stop_on_panic,
-        );
-
-        // system arbiter
-        let arb = SystemArbiter::new(stop_tx, sys_receiver);
-
-        rt.spawn(arb);
-
-        // init system arbiter and run configuration method
-        rt.block_on(async { 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
-        async {
-            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)),
-            }
-        }
-    }
-}
-
-/// 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 { rt, stop, .. } = self;
-
-        // run loop
-        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)),
-        }
-    }
-
-    /// Execute a future and wait for result.
-    #[inline]
-    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
-        self.rt.block_on(fut)
-    }
-}

actix-rt/src/lib.rs

@@ -1,65 +1,144 @@
-//! Tokio-based single-thread async runtime for the Actix ecosystem.
+//! Tokio-based single-threaded async runtime for the Actix ecosystem.
+//!
+//! In most parts of the the Actix ecosystem, it has been chosen to use !Send futures. For this
+//! reason, a single-threaded runtime is appropriate since it is guaranteed that futures will not
+//! be moved between threads. This can result in small performance improvements over cases where
+//! atomics would otherwise be needed.
+//!
+//! To achieve similar performance to multi-threaded, work-stealing runtimes, applications
+//! using `actix-rt` will create multiple, mostly disconnected, single-threaded runtimes.
+//! This approach has good performance characteristics for workloads where the majority of tasks
+//! have similar runtime expense.
+//!
+//! The disadvantage is that idle threads will not steal work from very busy, stuck or otherwise
+//! backlogged threads. Tasks that are disproportionately expensive should be offloaded to the
+//! blocking task thread-pool using [`task::spawn_blocking`].
+//!
+//! # Examples
+//! ```
+//! use std::sync::mpsc;
+//! use actix_rt::{Arbiter, System};
+//!
+//! let _ = System::new();
+//!
+//! let (tx, rx) = mpsc::channel::<u32>();
+//!
+//! let arbiter = Arbiter::new();
+//! arbiter.spawn_fn(move || tx.send(42).unwrap());
+//!
+//! let num = rx.recv().unwrap();
+//! assert_eq!(num, 42);
+//!
+//! arbiter.stop();
+//! arbiter.join().unwrap();
+//! ```
 
 #![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity)]
+#![warn(missing_docs)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use std::future::Future;
 
-#[cfg(not(test))] // Work around for rust-lang/rust#62127
+use tokio::task::JoinHandle;
+
+// Cannot define a main macro when compiled into test harness.
+// Workaround for https://github.com/rust-lang/rust/issues/62127.
+#[cfg(all(feature = "macros", not(test)))]
 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::arbiter::{Arbiter, ArbiterHandle};
 pub use self::runtime::Runtime;
-pub use self::system::System;
+pub use self::system::{System, SystemRunner};
 
-/// Spawns a future on the current arbiter.
-///
-/// # Panics
-///
-/// This function panics if actix system is not running.
-#[inline]
-pub fn spawn<F>(f: F)
-where
-    F: Future<Output = ()> + 'static,
-{
-    Arbiter::spawn(f)
-}
+pub use tokio::pin;
 
-/// Asynchronous signal handling
 pub mod signal {
+    //! Asynchronous signal handling (Tokio re-exports).
+
     #[cfg(unix)]
     pub mod unix {
+        //! Unix specific signals (Tokio re-exports).
         pub use tokio::signal::unix::*;
     }
     pub use tokio::signal::ctrl_c;
 }
 
-/// TCP/UDP/Unix bindings
 pub mod net {
+    //! TCP/UDP/Unix bindings (mostly Tokio re-exports).
+
+    use std::task::{Context, Poll};
+
+    use tokio::io::{AsyncRead, AsyncWrite};
     pub use tokio::net::UdpSocket;
-    pub use tokio::net::{TcpListener, TcpStream};
+    pub use tokio::net::{TcpListener, TcpSocket, TcpStream};
 
     #[cfg(unix)]
-    mod unix {
-        pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
+    pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
+
+    /// Extension trait over async read+write types that can also signal readiness.
+    pub trait ActixStream: AsyncRead + AsyncWrite + Unpin + 'static {
+        /// Poll stream and check read readiness of Self.
+        ///
+        /// See [tokio::net::TcpStream::poll_read_ready] for detail on intended use.
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>>;
+
+        /// Poll stream and check write readiness of Self.
+        ///
+        /// See [tokio::net::TcpStream::poll_write_ready] for detail on intended use.
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>>;
+    }
+
+    impl ActixStream for TcpStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            TcpStream::poll_read_ready(self, cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            TcpStream::poll_write_ready(self, cx)
+        }
     }
 
     #[cfg(unix)]
-    pub use self::unix::*;
+    impl ActixStream for UnixStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            UnixStream::poll_read_ready(self, cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            UnixStream::poll_write_ready(self, cx)
+        }
+    }
 }
 
-/// Utilities for tracking time.
 pub mod time {
+    //! Utilities for tracking time (Tokio re-exports).
+
     pub use tokio::time::Instant;
     pub use tokio::time::{interval, interval_at, Interval};
     pub use tokio::time::{sleep, sleep_until, Sleep};
     pub use tokio::time::{timeout, Timeout};
 }
+
+pub mod task {
+    //! Task management (Tokio re-exports).
+
+    pub use tokio::task::{spawn_blocking, yield_now, JoinError, JoinHandle};
+}
+
+/// Spawns a future on the current thread.
+///
+/// # Panics
+/// Panics if Actix system is not running.
+#[inline]
+pub fn spawn<Fut>(f: Fut) -> JoinHandle<()>
+where
+    Fut: Future<Output = ()> + 'static,
+{
+    tokio::task::spawn_local(f)
+}

actix-rt/src/runtime.rs

@@ -1,27 +1,29 @@
-use std::future::Future;
-use std::io;
-use tokio::{runtime, task::LocalSet};
+use std::{future::Future, io};
 
-/// Single-threaded runtime provides a way to start reactor
-/// and runtime on the current thread.
+use tokio::task::{JoinHandle, LocalSet};
+
+/// A Tokio-based runtime proxy.
 ///
-/// See [module level][mod] documentation for more details.
-///
-/// [mod]: crate
+/// All spawned futures will be executed on the current thread. Therefore, there is no `Send` bound
+/// on submitted futures.
 #[derive(Debug)]
 pub struct Runtime {
     local: LocalSet,
-    rt: runtime::Runtime,
+    rt: tokio::runtime::Runtime,
+}
+
+pub(crate) fn default_tokio_runtime() -> io::Result<tokio::runtime::Runtime> {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()
 }
 
 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_current_thread()
-            .enable_io()
-            .enable_time()
-            .build()?;
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> io::Result<Self> {
+        let rt = default_tokio_runtime()?;
 
         Ok(Runtime {
             rt,
@@ -29,62 +31,53 @@ impl Runtime {
         })
     }
 
-    pub(super) fn local(&self) -> &LocalSet {
+    /// Reference to local task set.
+    pub(crate) fn local_set(&self) -> &LocalSet {
         &self.local
     }
 
-    /// Spawn a future onto the single-threaded runtime.
+    /// Offload a future onto the single-threaded runtime.
     ///
-    /// See [module level][mod] documentation for more details.
+    /// The returned join handle can be used to await the future's result.
     ///
-    /// [mod]: crate
+    /// See [crate root][crate] documentation for more details.
     ///
     /// # Examples
-    ///
-    /// ```rust,ignore
-    /// # use futures::{future, Future, Stream};
-    /// use actix_rt::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let rt = Runtime::new().unwrap();
+    /// ```
+    /// let rt = actix_rt::Runtime::new().unwrap();
     ///
     /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|_| {
+    /// let handle = rt.spawn(async {
     ///     println!("running on the runtime");
-    /// }));
-    /// # }
-    /// # pub fn main() {}
+    ///     42
+    /// });
+    ///
+    /// assert_eq!(rt.block_on(handle).unwrap(), 42);
     /// ```
     ///
     /// # 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
+    /// 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) -> JoinHandle<F::Output>
     where
-        F: Future<Output = ()> + 'static,
+        F: Future + 'static,
     {
-        self.local.spawn_local(future);
-        self
+        self.local.spawn_local(future)
     }
 
-    /// Runs the provided future, blocking the current thread until the future
-    /// completes.
+    /// 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.
+    /// 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
+    /// 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`.
+    /// The caller is responsible for ensuring that other spawned futures complete execution by
+    /// calling `block_on` or `run`.
     pub fn block_on<F>(&self, f: F) -> F::Output
     where
         F: Future,
@@ -92,3 +85,12 @@ impl Runtime {
         self.local.block_on(&self.rt, f)
     }
 }
+
+impl From<tokio::runtime::Runtime> for Runtime {
+    fn from(rt: tokio::runtime::Runtime) -> Self {
+        Self {
+            local: LocalSet::new(),
+            rt,
+        }
+    }
+}

actix-rt/src/system.rs

@@ -1,193 +1,98 @@
-use std::cell::RefCell;
-use std::future::Future;
-use std::io;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    future::Future,
+    io,
+    pin::Pin,
+    sync::atomic::{AtomicUsize, Ordering},
+    task::{Context, Poll},
+};
 
-use tokio::sync::mpsc::UnboundedSender;
-use tokio::task::LocalSet;
+use futures_core::ready;
+use tokio::sync::{mpsc, oneshot};
 
-use crate::arbiter::{Arbiter, SystemCommand};
-use crate::builder::{Builder, SystemRunner};
+use crate::{arbiter::ArbiterHandle, runtime::default_tokio_runtime, Arbiter, Runtime};
 
 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);
 );
 
+/// A manager for a per-thread distributed async runtime.
+#[derive(Clone, Debug)]
+pub struct System {
+    id: usize,
+    sys_tx: mpsc::UnboundedSender<SystemCommand>,
+
+    /// Handle to the first [Arbiter] that is created with the System.
+    arbiter_handle: ArbiterHandle,
+}
+
 impl System {
-    /// Constructs new system and sets it as current
+    /// Create a new system.
+    ///
+    /// # Panics
+    /// Panics if underlying Tokio runtime can not be created.
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> SystemRunner {
+        Self::with_tokio_rt(|| {
+            default_tokio_runtime()
+                .expect("Default Actix (Tokio) runtime could not be created.")
+        })
+    }
+
+    /// Create a new System using the [Tokio Runtime](tokio-runtime) returned from a closure.
+    ///
+    /// [tokio-runtime]: tokio::runtime::Runtime
+    #[doc(hidden)]
+    pub fn with_tokio_rt<F>(runtime_factory: F) -> SystemRunner
+    where
+        F: Fn() -> tokio::runtime::Runtime,
+    {
+        let (stop_tx, stop_rx) = oneshot::channel();
+        let (sys_tx, sys_rx) = mpsc::unbounded_channel();
+
+        let rt = Runtime::from(runtime_factory());
+        let sys_arbiter = Arbiter::in_new_system(rt.local_set());
+        let system = System::construct(sys_tx, sys_arbiter.clone());
+
+        system
+            .tx()
+            .send(SystemCommand::RegisterArbiter(usize::MAX, sys_arbiter))
+            .unwrap();
+
+        // init background system arbiter
+        let sys_ctrl = SystemController::new(sys_rx, stop_tx);
+        rt.spawn(sys_ctrl);
+
+        SystemRunner {
+            rt,
+            stop_rx,
+            system,
+        }
+    }
+
+    /// Constructs new system and registers it on the current thread.
     pub(crate) fn construct(
-        sys: UnboundedSender<SystemCommand>,
-        arbiter: Arbiter,
-        stop_on_panic: bool,
+        sys_tx: mpsc::UnboundedSender<SystemCommand>,
+        arbiter_handle: ArbiterHandle,
     ) -> Self {
         let sys = System {
-            sys,
-            arbiter,
-            stop_on_panic,
+            sys_tx,
+            arbiter_handle,
             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()
-    }
-
-    /// Create new system using provided tokio `LocalSet`.
-    ///
-    /// This method panics if it can not spawn system arbiter
-    ///
-    /// Note: This method uses provided `LocalSet` to create a `System` future only.
-    /// All the [`Arbiter`]s will be started in separate threads using their own tokio `Runtime`s.
-    /// It means that using this method currently it is impossible to make `actix-rt` work in the
-    /// alternative `tokio` `Runtime`s (e.g. provided by [`tokio_compat`]).
-    ///
-    /// [`tokio_compat`]: https://crates.io/crates/tokio-compat
-    ///
-    /// # Examples
-    ///
-    /// ```rust,ignore
-    /// use tokio::{runtime::Runtime, task::LocalSet};
-    /// use actix_rt::System;
-    /// use futures_util::future::try_join_all;
-    ///
-    /// async fn run_application() {
-    ///     let first_task = tokio::spawn(async {
-    ///         // ...
-    /// #        println!("One task");
-    /// #        Ok::<(),()>(())
-    ///     });
-    ///
-    ///     let second_task = tokio::spawn(async {
-    ///         // ...
-    /// #       println!("Another task");
-    /// #       Ok::<(),()>(())
-    ///     });
-    ///
-    ///     try_join_all(vec![first_task, second_task])
-    ///         .await
-    ///         .expect("Some of the futures finished unexpectedly");
-    /// }
-    ///
-    ///
-    /// let runtime = tokio::runtime::Builder::new_multi_thread()
-    ///     .worker_threads(2)
-    ///     .enable_all()
-    ///     .build()
-    ///     .unwrap();
-    ///
-    ///
-    /// let actix_system_task = LocalSet::new();
-    /// let sys = System::run_in_tokio("actix-main-system", &actix_system_task);
-    /// actix_system_task.spawn_local(sys);
-    ///
-    /// let rest_operations = run_application();
-    /// runtime.block_on(actix_system_task.run_until(rest_operations));
-    /// ```
-    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()
-    }
-
-    /// Consume the provided tokio Runtime and start the `System` in it.
-    /// This method will create a `LocalSet` object and occupy the current thread
-    /// for the created `System` exclusively. All the other asynchronous tasks that
-    /// should be executed as well must be aggregated into one future, provided as the last
-    /// argument to this method.
-    ///
-    /// Note: This method uses provided `Runtime` to create a `System` future only.
-    /// All the [`Arbiter`]s will be started in separate threads using their own tokio `Runtime`s.
-    /// It means that using this method currently it is impossible to make `actix-rt` work in the
-    /// alternative `tokio` `Runtime`s (e.g. provided by `tokio_compat`).
-    ///
-    /// [`tokio_compat`]: https://crates.io/crates/tokio-compat
-    ///
-    /// # Arguments
-    ///
-    /// - `name`: Name of the System
-    /// - `runtime`: A tokio Runtime to run the system in.
-    /// - `rest_operations`: A future to be executed in the runtime along with the System.
-    ///
-    /// # Examples
-    ///
-    /// ```rust,ignore
-    /// use tokio::runtime::Runtime;
-    /// use actix_rt::System;
-    /// use futures_util::future::try_join_all;
-    ///
-    /// async fn run_application() {
-    ///     let first_task = tokio::spawn(async {
-    ///         // ...
-    /// #        println!("One task");
-    /// #        Ok::<(),()>(())
-    ///     });
-    ///
-    ///     let second_task = tokio::spawn(async {
-    ///         // ...
-    /// #       println!("Another task");
-    /// #       Ok::<(),()>(())
-    ///     });
-    ///
-    ///     try_join_all(vec![first_task, second_task])
-    ///         .await
-    ///         .expect("Some of the futures finished unexpectedly");
-    /// }
-    ///
-    ///
-    /// let runtime = tokio::runtime::Builder::new_multi_thread()
-    ///     .worker_threads(2)
-    ///     .enable_all()
-    ///     .build()
-    ///     .unwrap();
-    ///
-    /// let rest_operations = run_application();
-    /// System::attach_to_tokio("actix-main-system", runtime, rest_operations);
-    /// ```
-    pub fn attach_to_tokio<Fut, R>(
-        name: impl Into<String>,
-        runtime: tokio::runtime::Runtime,
-        rest_operations: Fut,
-    ) -> R
-    where
-        Fut: std::future::Future<Output = R>,
-    {
-        let actix_system_task = LocalSet::new();
-        let sys = System::run_in_tokio(name.into(), &actix_system_task);
-        actix_system_task.spawn_local(sys);
-
-        runtime.block_on(actix_system_task.run_until(rest_operations))
-    }
-
     /// Get current running system.
+    ///
+    /// # Panics
+    /// Panics if no system is registered on the current thread.
     pub fn current() -> System {
         CURRENT.with(|cell| match *cell.borrow() {
             Some(ref sys) => sys.clone(),
@@ -195,67 +100,156 @@ impl System {
         })
     }
 
-    /// Check if current system is set, i.e., as already been started.
-    pub fn is_set() -> bool {
-        CURRENT.with(|cell| cell.borrow().is_some())
+    /// Try to get current running system.
+    ///
+    /// Returns `None` if no System has been started.
+    ///
+    /// Contrary to `current`, this never panics.
+    pub fn try_current() -> Option<System> {
+        CURRENT.with(|cell| cell.borrow().clone())
     }
 
-    /// Set current running system.
+    /// Get handle to a the System's initial [Arbiter].
+    pub fn arbiter(&self) -> &ArbiterHandle {
+        &self.arbiter_handle
+    }
+
+    /// Check if there is a System registered on the current thread.
+    pub fn is_registered() -> bool {
+        CURRENT.with(|sys| sys.borrow().is_some())
+    }
+
+    /// Register given system on current thread.
     #[doc(hidden)]
     pub fn set_current(sys: System) {
-        CURRENT.with(|s| {
-            *s.borrow_mut() = Some(sys);
+        CURRENT.with(|cell| {
+            *cell.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
+    /// Numeric system identifier.
+    ///
+    /// Useful when using multiple Systems.
     pub fn id(&self) -> usize {
         self.id
     }
 
-    /// Stop the system
+    /// Stop the system (with code 0).
     pub fn stop(&self) {
         self.stop_with_code(0)
     }
 
-    /// Stop the system with a particular exit code.
+    /// Stop the system with a given exit code.
     pub fn stop_with_code(&self, code: i32) {
-        let _ = self.sys.send(SystemCommand::Exit(code));
+        let _ = self.sys_tx.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(),
-    {
-        Self::builder().run(f)
+    pub(crate) fn tx(&self) -> &mpsc::UnboundedSender<SystemCommand> {
+        &self.sys_tx
+    }
+}
+
+/// Runner that keeps a [System]'s event loop alive until stop message is received.
+#[must_use = "A SystemRunner does nothing unless `run` is called."]
+#[derive(Debug)]
+pub struct SystemRunner {
+    rt: Runtime,
+    stop_rx: oneshot::Receiver<i32>,
+    system: System,
+}
+
+impl SystemRunner {
+    /// Starts event loop and will return once [System] is [stopped](System::stop).
+    pub fn run(self) -> io::Result<()> {
+        let SystemRunner { rt, stop_rx, .. } = self;
+
+        // run loop
+        match rt.block_on(stop_rx) {
+            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)),
+        }
+    }
+
+    /// Runs the provided future, blocking the current thread until the future completes.
+    #[inline]
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
+        self.rt.block_on(fut)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum SystemCommand {
+    Exit(i32),
+    RegisterArbiter(usize, ArbiterHandle),
+    DeregisterArbiter(usize),
+}
+
+/// There is one `SystemController` per [System]. It runs in the background, keeping track of
+/// [Arbiter]s and is able to distribute a system-wide stop command.
+#[derive(Debug)]
+pub(crate) struct SystemController {
+    stop_tx: Option<oneshot::Sender<i32>>,
+    cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+    arbiters: HashMap<usize, ArbiterHandle>,
+}
+
+impl SystemController {
+    pub(crate) fn new(
+        cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+        stop_tx: oneshot::Sender<i32>,
+    ) -> Self {
+        SystemController {
+            cmd_rx,
+            stop_tx: Some(stop_tx),
+            arbiters: HashMap::with_capacity(4),
+        }
+    }
+}
+
+impl Future for SystemController {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // process all items currently buffered in channel
+        loop {
+            match ready!(Pin::new(&mut self.cmd_rx).poll_recv(cx)) {
+                // channel closed; no more messages can be received
+                None => return Poll::Ready(()),
+
+                // process system command
+                Some(cmd) => match cmd {
+                    SystemCommand::Exit(code) => {
+                        // stop all arbiters
+                        for arb in self.arbiters.values() {
+                            arb.stop();
+                        }
+
+                        // stop event loop
+                        // will only fire once
+                        if let Some(stop_tx) = self.stop_tx.take() {
+                            let _ = stop_tx.send(code);
+                        }
+                    }
+
+                    SystemCommand::RegisterArbiter(id, arb) => {
+                        self.arbiters.insert(id, arb);
+                    }
+
+                    SystemCommand::DeregisterArbiter(id) => {
+                        self.arbiters.remove(&id);
+                    }
+                },
+            }
+        }
     }
 }

actix-rt/tests/integration_tests.rs

@@ -1,126 +0,0 @@
-use std::time::{Duration, Instant};
-
-#[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::sleep(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::sleep(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::sleep(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::sleep(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"
-//     );
-// }
-
-#[test]
-fn non_static_block_on() {
-    let string = String::from("test_str");
-    let str = string.as_str();
-
-    let sys = actix_rt::System::new("borrow some");
-
-    sys.block_on(async {
-        actix_rt::time::sleep(Duration::from_millis(1)).await;
-        assert_eq!("test_str", str);
-    });
-
-    let rt = actix_rt::Runtime::new().unwrap();
-
-    rt.block_on(async {
-        actix_rt::time::sleep(Duration::from_millis(1)).await;
-        assert_eq!("test_str", str);
-    });
-
-    actix_rt::System::run(|| {
-        assert_eq!("test_str", str);
-        actix_rt::System::current().stop();
-    })
-    .unwrap();
-}

actix-rt/tests/tests.rs

@@ -0,0 +1,300 @@
+use std::{
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        mpsc::channel,
+        Arc,
+    },
+    thread,
+    time::{Duration, Instant},
+};
+
+use actix_rt::{Arbiter, System};
+use tokio::sync::oneshot;
+
+#[test]
+fn await_for_timer() {
+    let time = Duration::from_secs(1);
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        tokio::time::sleep(time).await;
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Block on should poll awaited future to completion"
+    );
+}
+
+#[test]
+fn join_another_arbiter() {
+    let time = Duration::from_secs(1);
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn(Box::pin(async move {
+            tokio::time::sleep(time).await;
+            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();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn_fn(move || {
+            actix_rt::spawn(async move {
+                tokio::time::sleep(time).await;
+                Arbiter::current().stop();
+            });
+        });
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on an arbiter that has used actix_rt::spawn should wait for said future"
+    );
+
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn(Box::pin(async move {
+            tokio::time::sleep(time).await;
+            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 non_static_block_on() {
+    let string = String::from("test_str");
+    let string = string.as_str();
+
+    let sys = System::new();
+
+    sys.block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!("test_str", string);
+    });
+
+    let rt = actix_rt::Runtime::new().unwrap();
+
+    rt.block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!("test_str", string);
+    });
+}
+
+#[test]
+fn wait_for_spawns() {
+    let rt = actix_rt::Runtime::new().unwrap();
+
+    let handle = rt.spawn(async {
+        println!("running on the runtime");
+        // assertion panic is caught at task boundary
+        assert_eq!(1, 2);
+    });
+
+    assert!(rt.block_on(handle).is_err());
+}
+
+#[test]
+fn arbiter_spawn_fn_runs() {
+    let _ = System::new();
+
+    let (tx, rx) = channel::<u32>();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn_fn(move || tx.send(42).unwrap());
+
+    let num = rx.recv().unwrap();
+    assert_eq!(num, 42);
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[test]
+fn arbiter_handle_spawn_fn_runs() {
+    let sys = System::new();
+
+    let (tx, rx) = channel::<u32>();
+
+    let arbiter = Arbiter::new();
+    let handle = arbiter.handle();
+    drop(arbiter);
+
+    handle.spawn_fn(move || {
+        tx.send(42).unwrap();
+        System::current().stop()
+    });
+
+    let num = rx.recv_timeout(Duration::from_secs(2)).unwrap();
+    assert_eq!(num, 42);
+
+    handle.stop();
+    sys.run().unwrap();
+}
+
+#[test]
+fn arbiter_drop_no_panic_fn() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn_fn(|| panic!("test"));
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[test]
+fn arbiter_drop_no_panic_fut() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn(async { panic!("test") });
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[test]
+#[should_panic]
+fn no_system_current_panic() {
+    System::current();
+}
+
+#[test]
+#[should_panic]
+fn no_system_arbiter_new_panic() {
+    Arbiter::new();
+}
+
+#[test]
+fn system_arbiter_spawn() {
+    let runner = System::new();
+
+    let (tx, rx) = oneshot::channel();
+    let sys = System::current();
+
+    thread::spawn(|| {
+        // this thread will have no arbiter in it's thread local so call will panic
+        Arbiter::current();
+    })
+    .join()
+    .unwrap_err();
+
+    let thread = thread::spawn(|| {
+        // this thread will have no arbiter in it's thread local so use the system handle instead
+        System::set_current(sys);
+        let sys = System::current();
+
+        let arb = sys.arbiter();
+        arb.spawn(async move {
+            tx.send(42u32).unwrap();
+            System::current().stop();
+        });
+    });
+
+    assert_eq!(runner.block_on(rx).unwrap(), 42);
+    thread.join().unwrap();
+}
+
+#[test]
+fn system_stop_stops_arbiters() {
+    let sys = System::new();
+    let arb = Arbiter::new();
+
+    // arbiter should be alive to receive spawn msg
+    assert!(Arbiter::current().spawn_fn(|| {}));
+    assert!(arb.spawn_fn(|| {}));
+
+    System::current().stop();
+    sys.run().unwrap();
+
+    // account for slightly slow thread de-spawns (only observed on windows)
+    thread::sleep(Duration::from_millis(100));
+
+    // arbiter should be dead and return false
+    assert!(!Arbiter::current().spawn_fn(|| {}));
+    assert!(!arb.spawn_fn(|| {}));
+
+    arb.join().unwrap();
+}
+
+#[test]
+fn new_system_with_tokio() {
+    let (tx, rx) = channel();
+
+    let res = System::with_tokio_rt(move || {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_io()
+            .enable_time()
+            .thread_keep_alive(Duration::from_millis(1000))
+            .worker_threads(2)
+            .max_blocking_threads(2)
+            .on_thread_start(|| {})
+            .on_thread_stop(|| {})
+            .build()
+            .unwrap()
+    })
+    .block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+
+        tokio::task::spawn(async move {
+            tx.send(42).unwrap();
+        })
+        .await
+        .unwrap();
+
+        123usize
+    });
+
+    assert_eq!(res, 123);
+    assert_eq!(rx.recv().unwrap(), 42);
+}
+
+#[test]
+fn new_arbiter_with_tokio() {
+    let _ = System::new();
+
+    let arb = Arbiter::with_tokio_rt(|| {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+    });
+
+    let counter = Arc::new(AtomicBool::new(true));
+
+    let counter1 = counter.clone();
+    let did_spawn = arb.spawn(async move {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        counter1.store(false, Ordering::SeqCst);
+        Arbiter::current().stop();
+    });
+
+    assert!(did_spawn);
+
+    arb.join().unwrap();
+
+    assert_eq!(false, counter.load(Ordering::SeqCst));
+}
+
+#[test]
+fn try_current_no_system() {
+    assert!(System::try_current().is_none())
+}
+
+#[test]
+fn try_current_with_system() {
+    System::new().block_on(async { assert!(System::try_current().is_some()) });
+}

actix-server/CHANGES.md

@@ -1,11 +1,40 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.0.0-beta.3 - 2021-02-06
+* Hidden `ServerBuilder::start` method has been removed. Use `ServerBuilder::run`. [#246]
+* Add retry for EINTR signal (`io::Interrupted`) in `Accept`'s poll loop. [#264]
+* Add `ServerBuilder::worker_max_blocking_threads` to customize blocking thread pool size. [#265]
+* Update `actix-rt` to `2.0.0`. [#273]
+
+[#246]: https://github.com/actix/actix-net/pull/246
+[#264]: https://github.com/actix/actix-net/pull/264
+[#265]: https://github.com/actix/actix-net/pull/265
+[#273]: https://github.com/actix/actix-net/pull/273
+
+
+## 2.0.0-beta.2 - 2021-01-03
+* Merge `actix-testing` to `actix-server` as `test_server` mod. [#242]
+
+[#242]: https://github.com/actix/actix-net/pull/242
+
+
+## 2.0.0-beta.1 - 2020-12-28
 * Added explicit info log message on accept queue pause. [#215]
 * Prevent double registration of sockets when back-pressure is resolved. [#223]
+* Update `mio` dependency to `0.7.3`. [#239]
+* Remove `socket2` dependency. [#239]
+* `ServerBuilder::backlog` now accepts `u32` instead of `i32`. [#239]
+* Remove `AcceptNotify` type and pass `WakerQueue` to `Worker` to wake up `Accept`'s `Poll`. [#239]
+* Convert `mio::net::TcpStream` to `actix_rt::net::TcpStream`(`UnixStream` for uds) using
+  `FromRawFd` and `IntoRawFd`(`FromRawSocket` and `IntoRawSocket` on windows). [#239]
+* Remove `AsyncRead` and `AsyncWrite` trait bound for `socket::FromStream` trait. [#239]
 
 [#215]: https://github.com/actix/actix-net/pull/215
 [#223]: https://github.com/actix/actix-net/pull/223
+[#239]: https://github.com/actix/actix-net/pull/239
 
 
 ## 1.0.4 - 2020-09-12

actix-server/Cargo.toml

@@ -1,15 +1,17 @@
 [package]
 name = "actix-server"
-version = "1.0.4"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+version = "2.0.0-beta.3"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "fakeshadow <24548779@qq.com>",
+]
 description = "General purpose TCP server built for the Actix ecosystem"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-server/"
+documentation = "https://docs.rs/actix-server"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-exclude = [".gitignore", ".cargo/config"]
 edition = "2018"
 
 [lib]
@@ -20,25 +22,21 @@ path = "src/lib.rs"
 default = []
 
 [dependencies]
-actix-service = "1.0.6"
-actix-rt = "1.1.1"
-actix-codec = "0.3.0"
-actix-utils = "2.0.0"
+actix-codec = "0.4.0-beta.1"
+actix-rt = { version = "2.0.0", default-features = false }
+actix-service = "2.0.0-beta.4"
+actix-utils = "3.0.0-beta.2"
 
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 log = "0.4"
+mio = { version = "0.7.6", features = ["os-poll", "net"] }
 num_cpus = "1.13"
-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" }
+tokio = { version = "1.2", features = ["sync"] }
 
 [dev-dependencies]
-bytes = "0.5"
-env_logger = "0.7"
-actix-testing = "1.0.0"
-tokio = { version = "0.2", features = ["io-util"] }
+actix-rt = "2.0.0"
+bytes = "1"
+env_logger = "0.8"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
+tokio = { version = "1", features = ["io-util"] }

actix-server/src/accept.rs

@@ -1,120 +1,88 @@
-use std::sync::mpsc as sync_mpsc;
 use std::time::Duration;
 use std::{io, thread};
 
-use actix_rt::time::{delay_until, Instant};
-use actix_rt::System;
+use actix_rt::{
+    time::{sleep_until, Instant},
+    System,
+};
 use log::{error, info};
+use mio::{Interest, Poll, Token as MioToken};
 use slab::Slab;
 
 use crate::server::Server;
-use crate::socket::{SocketAddr, SocketListener, StdListener};
-use crate::worker::{Conn, WorkerClient};
+use crate::socket::{MioListener, SocketAddr};
+use crate::waker_queue::{WakerInterest, WakerQueue, WAKER_TOKEN};
+use crate::worker::{Conn, WorkerHandle};
 use crate::Token;
 
-pub(crate) enum Command {
-    Pause,
-    Resume,
-    Stop,
-    Worker(WorkerClient),
-}
-
 struct ServerSocketInfo {
+    // addr for socket. mainly used for logging.
     addr: SocketAddr,
+    // be ware this is the crate token for identify socket and should not be confused with
+    // mio::Token
     token: Token,
-    sock: SocketListener,
+    lst: MioListener,
+    // timeout is used to mark the deadline when this socket's listener should be registered again
+    // after an error.
     timeout: Option<Instant>,
 }
 
-#[derive(Clone)]
-pub(crate) struct AcceptNotify(mio::SetReadiness);
-
-impl AcceptNotify {
-    pub(crate) fn new(ready: mio::SetReadiness) -> Self {
-        AcceptNotify(ready)
-    }
-
-    pub(crate) fn notify(&self) {
-        let _ = self.0.set_readiness(mio::Ready::readable());
-    }
-}
-
-impl Default for AcceptNotify {
-    fn default() -> Self {
-        AcceptNotify::new(mio::Registration::new2().1)
-    }
-}
-
+/// Accept loop would live with `ServerBuilder`.
+///
+/// It's tasked with construct `Poll` instance and `WakerQueue` which would be distributed to
+/// `Accept` and `Worker`.
+///
+/// It would also listen to `ServerCommand` and push interests to `WakerQueue`.
 pub(crate) struct AcceptLoop {
-    cmd_reg: Option<mio::Registration>,
-    cmd_ready: mio::SetReadiness,
-    notify_reg: Option<mio::Registration>,
-    notify_ready: mio::SetReadiness,
-    tx: sync_mpsc::Sender<Command>,
-    rx: Option<sync_mpsc::Receiver<Command>>,
     srv: Option<Server>,
+    poll: Option<Poll>,
+    waker: WakerQueue,
 }
 
 impl 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();
+    pub fn new(srv: Server) -> Self {
+        let poll = Poll::new().unwrap_or_else(|e| panic!("Can not create `mio::Poll`: {}", e));
+        let waker = WakerQueue::new(poll.registry())
+            .unwrap_or_else(|e| panic!("Can not create `mio::Waker`: {}", e));
 
-        AcceptLoop {
-            tx,
-            cmd_ready,
-            cmd_reg: Some(cmd_reg),
-            notify_ready,
-            notify_reg: Some(notify_reg),
-            rx: Some(rx),
+        Self {
             srv: Some(srv),
+            poll: Some(poll),
+            waker,
         }
     }
 
-    pub fn send(&self, msg: Command) {
-        let _ = self.tx.send(msg);
-        let _ = self.cmd_ready.set_readiness(mio::Ready::readable());
+    pub(crate) fn waker_owned(&self) -> WakerQueue {
+        self.waker.clone()
     }
 
-    pub fn get_notify(&self) -> AcceptNotify {
-        AcceptNotify::new(self.notify_ready.clone())
+    pub fn wake(&self, i: WakerInterest) {
+        self.waker.wake(i);
     }
 
     pub(crate) fn start(
         &mut self,
-        socks: Vec<(Token, StdListener)>,
-        workers: Vec<WorkerClient>,
+        socks: Vec<(Token, MioListener)>,
+        handles: Vec<WorkerHandle>,
     ) {
         let srv = self.srv.take().expect("Can not re-use AcceptInfo");
+        let poll = self.poll.take().unwrap();
+        let waker = self.waker.clone();
 
-        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,
-            srv,
-            workers,
-        );
+        Accept::start(poll, waker, socks, srv, handles);
     }
 }
 
+/// poll instance of the server.
 struct Accept {
-    poll: mio::Poll,
-    rx: sync_mpsc::Receiver<Command>,
-    sockets: Slab<ServerSocketInfo>,
-    workers: Vec<WorkerClient>,
+    poll: Poll,
+    waker: WakerQueue,
+    handles: Vec<WorkerHandle>,
     srv: Server,
-    timer: (mio::Registration, mio::SetReadiness),
     next: usize,
     backpressure: bool,
 }
 
-const DELTA: usize = 100;
-const CMD: mio::Token = mio::Token(0);
-const TIMER: mio::Token = mio::Token(1);
-const NOTIFY: mio::Token = mio::Token(2);
-
 /// This function defines errors that are per-connection. Which basically
 /// means that if we get this error from `accept()` system call it means
 /// next connection might be ready to be accepted.
@@ -129,326 +97,297 @@ fn connection_error(e: &io::Error) -> bool {
 }
 
 impl Accept {
-    #![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, StdListener)>,
+        poll: Poll,
+        waker: WakerQueue,
+        socks: Vec<(Token, MioListener)>,
         srv: Server,
-        workers: Vec<WorkerClient>,
+        handles: Vec<WorkerHandle>,
     ) {
+        // Accept runs in its own thread and would want to spawn additional futures to current
+        // actix system.
         let sys = System::current();
-
-        // start accept thread
-        let _ = thread::Builder::new()
+        thread::Builder::new()
             .name("actix-server accept loop".to_owned())
             .spawn(move || {
                 System::set_current(sys);
-                let mut accept = Accept::new(rx, socks, workers, srv);
-
-                // Start listening for incoming commands
-                if let Err(err) = accept.poll.register(
-                    &cmd_reg,
-                    CMD,
-                    mio::Ready::readable(),
-                    mio::PollOpt::edge(),
-                ) {
-                    panic!("Can not register Registration: {}", err);
-                }
-
-                // Start listening for notify updates
-                if let Err(err) = accept.poll.register(
-                    &notify_reg,
-                    NOTIFY,
-                    mio::Ready::readable(),
-                    mio::PollOpt::edge(),
-                ) {
-                    panic!("Can not register Registration: {}", err);
-                }
-
-                accept.poll();
-            });
+                let (mut accept, sockets) =
+                    Accept::new_with_sockets(poll, waker, socks, handles, srv);
+                accept.poll_with(sockets);
+            })
+            .unwrap();
     }
 
-    fn new(
-        rx: sync_mpsc::Receiver<Command>,
-        socks: Vec<(Token, StdListener)>,
-        workers: Vec<WorkerClient>,
+    fn new_with_sockets(
+        poll: Poll,
+        waker: WakerQueue,
+        socks: Vec<(Token, MioListener)>,
+        handles: Vec<WorkerHandle>,
         srv: Server,
-    ) -> Accept {
-        // Create a poll instance
-        let poll = match mio::Poll::new() {
-            Ok(poll) => poll,
-            Err(err) => panic!("Can not create mio::Poll: {}", err),
-        };
-
-        // Start accept
+    ) -> (Accept, Slab<ServerSocketInfo>) {
         let mut sockets = Slab::new();
-        for (hnd_token, lst) in socks.into_iter() {
+        for (hnd_token, mut lst) in socks.into_iter() {
             let addr = lst.local_addr();
 
-            let server = lst.into_listener();
             let entry = sockets.vacant_entry();
             let token = entry.key();
 
             // Start listening for incoming connections
-            if let Err(err) = poll.register(
-                &server,
-                mio::Token(token + DELTA),
-                mio::Ready::readable(),
-                mio::PollOpt::edge(),
-            ) {
-                panic!("Can not register io: {}", err);
-            }
+            poll.registry()
+                .register(&mut lst, MioToken(token), Interest::READABLE)
+                .unwrap_or_else(|e| panic!("Can not register io: {}", e));
 
             entry.insert(ServerSocketInfo {
                 addr,
                 token: hnd_token,
-                sock: server,
+                lst,
                 timeout: None,
             });
         }
 
-        // Timer
-        let (tm, tmr) = mio::Registration::new2();
-        if let Err(err) =
-            poll.register(&tm, TIMER, mio::Ready::readable(), mio::PollOpt::edge())
-        {
-            panic!("Can not register Registration: {}", err);
-        }
-
-        Accept {
+        let accept = Accept {
             poll,
-            rx,
-            sockets,
-            workers,
+            waker,
+            handles,
             srv,
             next: 0,
-            timer: (tm, tmr),
             backpressure: false,
-        }
+        };
+
+        (accept, sockets)
     }
 
-    fn poll(&mut self) {
-        // Create storage for events
+    fn poll_with(&mut self, mut sockets: Slab<ServerSocketInfo>) {
         let mut events = mio::Events::with_capacity(128);
 
         loop {
-            if let Err(err) = self.poll.poll(&mut events, None) {
-                panic!("Poll error: {}", err);
+            if let Err(e) = self.poll.poll(&mut events, None) {
+                match e.kind() {
+                    std::io::ErrorKind::Interrupted => {
+                        continue;
+                    }
+                    _ => {
+                        panic!("Poll error: {}", e);
+                    }
+                }
             }
 
             for event in events.iter() {
                 let token = event.token();
                 match token {
-                    CMD => {
-                        if !self.process_cmd() {
-                            return;
+                    // This is a loop because interests for command from previous version was
+                    // a loop that would try to drain the command channel. It's yet unknown
+                    // if it's necessary/good practice to actively drain the waker queue.
+                    WAKER_TOKEN => 'waker: loop {
+                        // take guard with every iteration so no new interest can be added
+                        // until the current task is done.
+                        let mut guard = self.waker.guard();
+                        match guard.pop_front() {
+                            // worker notify it becomes available. we may want to recover
+                            // from  backpressure.
+                            Some(WakerInterest::WorkerAvailable) => {
+                                drop(guard);
+                                self.maybe_backpressure(&mut sockets, false);
+                            }
+                            // a new worker thread is made and it's handle would be added
+                            // to Accept
+                            Some(WakerInterest::Worker(handle)) => {
+                                drop(guard);
+                                // maybe we want to recover from a backpressure.
+                                self.maybe_backpressure(&mut sockets, false);
+                                self.handles.push(handle);
+                            }
+                            // got timer interest and it's time to try register socket(s)
+                            // again.
+                            Some(WakerInterest::Timer) => {
+                                drop(guard);
+                                self.process_timer(&mut sockets)
+                            }
+                            Some(WakerInterest::Pause) => {
+                                drop(guard);
+                                sockets.iter_mut().for_each(|(_, info)| {
+                                    match self.deregister(info) {
+                                        Ok(_) => info!(
+                                            "Paused accepting connections on {}",
+                                            info.addr
+                                        ),
+                                        Err(e) => {
+                                            error!("Can not deregister server socket {}", e)
+                                        }
+                                    }
+                                });
+                            }
+                            Some(WakerInterest::Resume) => {
+                                drop(guard);
+                                sockets.iter_mut().for_each(|(token, info)| {
+                                    self.register_logged(token, info);
+                                });
+                            }
+                            Some(WakerInterest::Stop) => {
+                                return self.deregister_all(&mut sockets);
+                            }
+                            // waker queue is drained.
+                            None => {
+                                // Reset the WakerQueue before break so it does not grow
+                                // infinitely.
+                                WakerQueue::reset(&mut guard);
+                                break 'waker;
+                            }
                         }
-                    }
-                    TIMER => self.process_timer(),
-                    NOTIFY => self.backpressure(false),
+                    },
                     _ => {
                         let token = usize::from(token);
-                        if token < DELTA {
-                            continue;
-                        }
-                        self.accept(token - DELTA);
+                        self.accept(&mut sockets, token);
                     }
                 }
             }
         }
     }
 
-    fn process_timer(&mut self) {
+    fn process_timer(&self, sockets: &mut Slab<ServerSocketInfo>) {
         let now = Instant::now();
-        for (token, info) in self.sockets.iter_mut() {
+        sockets.iter_mut().for_each(|(token, info)| {
+            // only the ServerSocketInfo have an associate timeout value was de registered.
             if let Some(inst) = info.timeout.take() {
                 if now > inst {
-                    if let Err(err) = self.poll.register(
-                        &info.sock,
-                        mio::Token(token + DELTA),
-                        mio::Ready::readable(),
-                        mio::PollOpt::edge(),
-                    ) {
-                        error!("Can not register server socket {}", err);
-                    } else {
-                        info!("Resume accepting connections on {}", info.addr);
-                    }
+                    self.register_logged(token, info);
                 } else {
                     info.timeout = Some(inst);
                 }
             }
-        }
-    }
-
-    fn process_cmd(&mut self) -> bool {
-        loop {
-            match self.rx.try_recv() {
-                Ok(cmd) => match cmd {
-                    Command::Pause => {
-                        for (_, info) in self.sockets.iter_mut() {
-                            if let Err(err) = self.poll.deregister(&info.sock) {
-                                error!("Can not deregister server socket {}", err);
-                            } else {
-                                info!("Paused accepting connections on {}", info.addr);
-                            }
-                        }
-                    }
-                    Command::Resume => {
-                        for (token, info) in self.sockets.iter() {
-                            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
-                                );
-                            }
-                        }
-                    }
-                    Command::Stop => {
-                        for (_, info) in self.sockets.iter() {
-                            let _ = self.poll.deregister(&info.sock);
-                        }
-                        return false;
-                    }
-                    Command::Worker(worker) => {
-                        self.backpressure(false);
-                        self.workers.push(worker);
-                    }
-                },
-                Err(err) => match err {
-                    sync_mpsc::TryRecvError::Empty => break,
-                    sync_mpsc::TryRecvError::Disconnected => {
-                        for (_, info) in self.sockets.iter() {
-                            let _ = self.poll.deregister(&info.sock);
-                        }
-                        return false;
-                    }
-                },
-            }
-        }
-        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(),
-        )
+    fn register(&self, token: usize, info: &mut ServerSocketInfo) -> io::Result<()> {
+        self.poll
+            .registry()
+            .register(&mut info.lst, MioToken(token), Interest::READABLE)
     }
 
     #[cfg(target_os = "windows")]
-    fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> {
+    fn register(&self, token: usize, info: &mut 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(),
-            )
+            .registry()
+            .register(&mut info.lst, mio::Token(token), Interest::READABLE)
             .or_else(|_| {
-                self.poll.reregister(
-                    &info.sock,
-                    mio::Token(token + DELTA),
-                    mio::Ready::readable(),
-                    mio::PollOpt::edge(),
+                self.poll.registry().reregister(
+                    &mut info.lst,
+                    mio::Token(token),
+                    Interest::READABLE,
                 )
             })
     }
 
-    fn backpressure(&mut self, on: bool) {
+    fn register_logged(&self, token: usize, info: &mut ServerSocketInfo) {
+        match self.register(token, info) {
+            Ok(_) => info!("Resume accepting connections on {}", info.addr),
+            Err(e) => error!("Can not register server socket {}", e),
+        }
+    }
+
+    fn deregister(&self, info: &mut ServerSocketInfo) -> io::Result<()> {
+        self.poll.registry().deregister(&mut info.lst)
+    }
+
+    fn deregister_all(&self, sockets: &mut Slab<ServerSocketInfo>) {
+        sockets.iter_mut().for_each(|(_, info)| {
+            info!("Accepting connections on {} has been paused", info.addr);
+            let _ = self.deregister(info);
+        });
+    }
+
+    fn maybe_backpressure(&mut self, sockets: &mut Slab<ServerSocketInfo>, on: bool) {
         if self.backpressure {
             if !on {
                 self.backpressure = false;
-                for (token, info) in self.sockets.iter() {
+                for (token, info) in sockets.iter_mut() {
                     if info.timeout.is_some() {
                         // socket will attempt to re-register itself when its timeout completes
                         continue;
                     }
-
-                    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);
-                    }
+                    self.register_logged(token, info);
                 }
             }
         } else if on {
             self.backpressure = true;
-            for (_, info) in self.sockets.iter() {
-                let _ = self.poll.deregister(&info.sock);
-                info!("Accepting connections on {} has been paused", info.addr);
-            }
+            self.deregister_all(sockets);
         }
     }
 
-    fn accept_one(&mut self, mut msg: Conn) {
+    fn accept_one(&mut self, sockets: &mut Slab<ServerSocketInfo>, mut msg: Conn) {
         if self.backpressure {
-            while !self.workers.is_empty() {
-                match self.workers[self.next].send(msg) {
-                    Ok(_) => (),
+            while !self.handles.is_empty() {
+                match self.handles[self.next].send(msg) {
+                    Ok(_) => {
+                        self.set_next();
+                        break;
+                    }
                     Err(tmp) => {
-                        self.srv.worker_faulted(self.workers[self.next].idx);
+                        // worker lost contact and could be gone. a message is sent to
+                        // `ServerBuilder` future to notify it a new worker should be made.
+                        // after that remove the fault worker.
+                        self.srv.worker_faulted(self.handles[self.next].idx);
                         msg = tmp;
-                        self.workers.swap_remove(self.next);
-                        if self.workers.is_empty() {
+                        self.handles.swap_remove(self.next);
+                        if self.handles.is_empty() {
                             error!("No workers");
                             return;
-                        } else if self.workers.len() <= self.next {
+                        } else if self.handles.len() <= self.next {
                             self.next = 0;
                         }
                         continue;
                     }
                 }
-                self.next = (self.next + 1) % self.workers.len();
-                break;
             }
         } else {
             let mut idx = 0;
-            while idx < self.workers.len() {
+            while idx < self.handles.len() {
                 idx += 1;
-                if self.workers[self.next].available() {
-                    match self.workers[self.next].send(msg) {
+                if self.handles[self.next].available() {
+                    match self.handles[self.next].send(msg) {
                         Ok(_) => {
-                            self.next = (self.next + 1) % self.workers.len();
+                            self.set_next();
                             return;
                         }
+                        // worker lost contact and could be gone. a message is sent to
+                        // `ServerBuilder` future to notify it a new worker should be made.
+                        // after that remove the fault worker and enter backpressure if necessary.
                         Err(tmp) => {
-                            self.srv.worker_faulted(self.workers[self.next].idx);
+                            self.srv.worker_faulted(self.handles[self.next].idx);
                             msg = tmp;
-                            self.workers.swap_remove(self.next);
-                            if self.workers.is_empty() {
+                            self.handles.swap_remove(self.next);
+                            if self.handles.is_empty() {
                                 error!("No workers");
-                                self.backpressure(true);
+                                self.maybe_backpressure(sockets, true);
                                 return;
-                            } else if self.workers.len() <= self.next {
+                            } else if self.handles.len() <= self.next {
                                 self.next = 0;
                             }
                             continue;
                         }
                     }
                 }
-                self.next = (self.next + 1) % self.workers.len();
+                self.set_next();
             }
             // enable backpressure
-            self.backpressure(true);
-            self.accept_one(msg);
+            self.maybe_backpressure(sockets, true);
+            self.accept_one(sockets, msg);
         }
     }
 
-    fn accept(&mut self, token: usize) {
+    // set next worker handle that would accept work.
+    fn set_next(&mut self) {
+        self.next = (self.next + 1) % self.handles.len();
+    }
+
+    fn accept(&mut self, sockets: &mut Slab<ServerSocketInfo>, token: usize) {
         loop {
-            let msg = if let Some(info) = self.sockets.get_mut(token) {
-                match info.sock.accept() {
+            let msg = if let Some(info) = sockets.get_mut(token) {
+                match info.lst.accept() {
                     Ok(Some((io, addr))) => Conn {
                         io,
                         token: info.token,
@@ -458,19 +397,24 @@ impl Accept {
                     Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
                     Err(ref e) if connection_error(e) => continue,
                     Err(e) => {
+                        // deregister listener temporary
                         error!("Error accepting connection: {}", e);
-                        if let Err(err) = self.poll.deregister(&info.sock) {
+                        if let Err(err) = self.deregister(info) {
                             error!("Can not deregister server socket {}", err);
                         }
 
-                        // sleep after error
+                        // sleep after error. write the timeout to socket info as later the poll
+                        // would need it mark which socket and when it's listener should be
+                        // registered.
                         info.timeout = Some(Instant::now() + Duration::from_millis(500));
 
-                        let r = self.timer.1.clone();
-                        System::current().arbiter().send(Box::pin(async move {
-                            delay_until(Instant::now() + Duration::from_millis(510)).await;
-                            let _ = r.set_readiness(mio::Ready::readable());
-                        }));
+                        // after the sleep a Timer interest is sent to Accept Poll
+                        let waker = self.waker.clone();
+                        System::current().arbiter().spawn(async move {
+                            sleep_until(Instant::now() + Duration::from_millis(510)).await;
+                            waker.wake(WakerInterest::Timer);
+                        });
+
                         return;
                     }
                 }
@@ -478,7 +422,7 @@ impl Accept {
                 return;
             };
 
-            self.accept_one(msg);
+            self.accept_one(sockets, msg);
         }
     }
 }

actix-server/src/builder.rs

@@ -1,43 +1,42 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::time::Duration;
-use std::{io, mem, net};
+use std::{io, mem};
 
 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 actix_rt::time::{sleep_until, Instant};
+use actix_rt::{self as rt, System};
 use log::{error, info};
-use socket2::{Domain, Protocol, Socket, Type};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+use tokio::sync::oneshot;
 
-use crate::accept::{AcceptLoop, AcceptNotify, Command};
+use crate::accept::AcceptLoop;
 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;
+use crate::socket::{MioListener, StdSocketAddr, StdTcpListener, ToSocketAddrs};
+use crate::socket::{MioTcpListener, MioTcpSocket};
+use crate::waker_queue::{WakerInterest, WakerQueue};
+use crate::worker::{self, ServerWorker, ServerWorkerConfig, WorkerAvailability, WorkerHandle};
+use crate::{join_all, Token};
 
 /// Server builder
 pub struct ServerBuilder {
     threads: usize,
     token: Token,
-    backlog: i32,
-    workers: Vec<(usize, WorkerClient)>,
+    backlog: u32,
+    handles: Vec<(usize, WorkerHandle)>,
     services: Vec<Box<dyn InternalServiceFactory>>,
-    sockets: Vec<(Token, String, StdListener)>,
+    sockets: Vec<(Token, String, MioListener)>,
     accept: AcceptLoop,
     exit: bool,
-    shutdown_timeout: Duration,
     no_signals: bool,
     cmd: UnboundedReceiver<ServerCommand>,
     server: Server,
     notify: Vec<oneshot::Sender<()>>,
+    worker_config: ServerWorkerConfig,
 }
 
 impl Default for ServerBuilder {
@@ -49,23 +48,23 @@ impl Default for ServerBuilder {
 impl ServerBuilder {
     /// Create new Server builder instance
     pub fn new() -> ServerBuilder {
-        let (tx, rx) = unbounded();
+        let (tx, rx) = unbounded_channel();
         let server = Server::new(tx);
 
         ServerBuilder {
             threads: num_cpus::get(),
-            token: Token(0),
-            workers: Vec::new(),
+            token: Token::default(),
+            handles: 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,
+            worker_config: ServerWorkerConfig::default(),
         }
     }
 
@@ -79,6 +78,24 @@ impl ServerBuilder {
         self
     }
 
+    /// Set max number of threads for each worker's blocking task thread pool.
+    ///
+    /// One thread pool is set up **per worker**; not shared across workers.
+    ///
+    /// # Examples:
+    /// ```
+    /// # use actix_server::ServerBuilder;
+    /// let builder = ServerBuilder::new()
+    ///     .workers(4) // server has 4 worker thread.
+    ///     .worker_max_blocking_threads(4); // every worker has 4 max blocking threads.
+    /// ```
+    ///
+    /// See [tokio::runtime::Builder::max_blocking_threads] for behavior reference.
+    pub fn worker_max_blocking_threads(mut self, num: usize) -> Self {
+        self.worker_config.max_blocking_threads(num);
+        self
+    }
+
     /// Set the maximum number of pending connections.
     ///
     /// This refers to the number of clients that can be waiting to be served.
@@ -89,7 +106,7 @@ impl ServerBuilder {
     /// 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 {
+    pub fn backlog(mut self, num: u32) -> Self {
         self.backlog = num;
         self
     }
@@ -125,7 +142,8 @@ impl ServerBuilder {
     ///
     /// 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.worker_config
+            .shutdown_timeout(Duration::from_secs(sec));
         self
     }
 
@@ -147,7 +165,7 @@ impl ServerBuilder {
             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.sockets.push((token, name, MioListener::Tcp(lst)));
             }
             self.services.push(Box::new(srv));
         }
@@ -160,7 +178,7 @@ impl ServerBuilder {
     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,
+        U: ToSocketAddrs,
     {
         let sockets = bind_addr(addr, self.backlog)?;
 
@@ -173,21 +191,19 @@ impl ServerBuilder {
                 lst.local_addr()?,
             ));
             self.sockets
-                .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
+                .push((token, name.as_ref().to_string(), MioListener::Tcp(lst)));
         }
         Ok(self)
     }
 
-    #[cfg(all(unix))]
     /// Add new unix domain service to the server.
+    #[cfg(unix)]
     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()) {
@@ -197,26 +213,27 @@ impl ServerBuilder {
             }
         }
 
-        let lst = UnixListener::bind(addr)?;
+        let lst = crate::socket::StdUnixListener::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.
+    #[cfg(unix)]
     pub fn listen_uds<F, N: AsRef<str>>(
         mut self,
         name: N,
-        lst: std::os::unix::net::UnixListener,
+        lst: crate::socket::StdUnixListener,
         factory: F,
     ) -> io::Result<Self>
     where
         F: ServiceFactory<actix_rt::net::UnixStream>,
     {
-        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+        use std::net::{IpAddr, Ipv4Addr};
+        lst.set_nonblocking(true)?;
         let token = self.token.next();
-        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let addr = StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
@@ -224,7 +241,7 @@ impl ServerBuilder {
             addr,
         ));
         self.sockets
-            .push((token, name.as_ref().to_string(), StdListener::Uds(lst)));
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
         Ok(self)
     }
 
@@ -232,27 +249,26 @@ impl ServerBuilder {
     pub fn listen<F, N: AsRef<str>>(
         mut self,
         name: N,
-        lst: net::TcpListener,
+        lst: StdTcpListener,
         factory: F,
     ) -> io::Result<Self>
     where
         F: ServiceFactory<TcpStream>,
     {
+        lst.set_nonblocking(true)?;
+        let addr = lst.local_addr()?;
+
         let token = self.token.next();
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
             factory,
-            lst.local_addr()?,
+            addr,
         ));
-        self.sockets
-            .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
-        Ok(self)
-    }
 
-    #[doc(hidden)]
-    pub fn start(self) -> Server {
-        self.run()
+        self.sockets
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
+        Ok(self)
     }
 
     /// Starts processing incoming connections and return server controller.
@@ -263,12 +279,12 @@ impl ServerBuilder {
             info!("Starting {} workers", self.threads);
 
             // start workers
-            let workers = (0..self.threads)
+            let handles = (0..self.threads)
                 .map(|idx| {
-                    let worker = self.start_worker(idx, self.accept.get_notify());
-                    self.workers.push((idx, worker.clone()));
+                    let handle = self.start_worker(idx, self.accept.waker_owned());
+                    self.handles.push((idx, handle.clone()));
 
-                    worker
+                    handle
                 })
                 .collect();
 
@@ -281,7 +297,7 @@ impl ServerBuilder {
                     .into_iter()
                     .map(|t| (t.0, t.2))
                     .collect(),
-                workers,
+                handles,
             );
 
             // handle signals
@@ -291,27 +307,26 @@ impl ServerBuilder {
 
             // start http server actor
             let server = self.server.clone();
-            spawn(self);
+            rt::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();
+    fn start_worker(&self, idx: usize, waker: WakerQueue) -> WorkerHandle {
+        let avail = WorkerAvailability::new(waker);
+        let services = self.services.iter().map(|v| v.clone_factory()).collect();
 
-        Worker::start(idx, services, avail, self.shutdown_timeout)
+        ServerWorker::start(idx, services, avail, self.worker_config)
     }
 
     fn handle_cmd(&mut self, item: ServerCommand) {
         match item {
             ServerCommand::Pause(tx) => {
-                self.accept.send(Command::Pause);
+                self.accept.wake(WakerInterest::Pause);
                 let _ = tx.send(());
             }
             ServerCommand::Resume(tx) => {
-                self.accept.send(Command::Resume);
+                self.accept.wake(WakerInterest::Resume);
                 let _ = tx.send(());
             }
             ServerCommand::Signal(sig) => {
@@ -355,50 +370,41 @@ impl ServerBuilder {
                 let exit = self.exit;
 
                 // stop accept thread
-                self.accept.send(Command::Stop);
+                self.accept.wake(WakerInterest::Stop);
                 let notify = std::mem::take(&mut self.notify);
 
                 // 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(())
-                            }),
-                    )
+                if !self.handles.is_empty() && graceful {
+                    let iter = self
+                        .handles
+                        .iter()
+                        .map(move |worker| worker.1.stop(graceful))
+                        .collect();
+
+                    let fut = join_all(iter);
+
+                    rt::spawn(async move {
+                        let _ = fut.await;
+                        if let Some(tx) = completion {
+                            let _ = tx.send(());
+                        }
+                        for tx in notify {
+                            let _ = tx.send(());
+                        }
+                        if exit {
+                            rt::spawn(async {
+                                sleep_until(Instant::now() + Duration::from_millis(300)).await;
+                                System::current().stop();
+                            });
+                        }
+                    });
                 } 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(())
-                                },
-                            ),
-                        );
+                        rt::spawn(async {
+                            sleep_until(Instant::now() + Duration::from_millis(300)).await;
+                            System::current().stop();
+                        });
                     }
                     if let Some(tx) = completion {
                         let _ = tx.send(());
@@ -410,9 +416,9 @@ impl ServerBuilder {
             }
             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);
+                for i in 0..self.handles.len() {
+                    if self.handles[i].0 == idx {
+                        self.handles.swap_remove(i);
                         found = true;
                         break;
                     }
@@ -421,10 +427,10 @@ impl ServerBuilder {
                 if found {
                     error!("Worker has died {:?}, restarting", idx);
 
-                    let mut new_idx = self.workers.len();
+                    let mut new_idx = self.handles.len();
                     'found: loop {
-                        for i in 0..self.workers.len() {
-                            if self.workers[i].0 == new_idx {
+                        for i in 0..self.handles.len() {
+                            if self.handles[i].0 == new_idx {
                                 new_idx += 1;
                                 continue 'found;
                             }
@@ -432,9 +438,9 @@ impl ServerBuilder {
                         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));
+                    let handle = self.start_worker(new_idx, self.accept.waker_owned());
+                    self.handles.push((new_idx, handle.clone()));
+                    self.accept.wake(WakerInterest::Worker(handle));
                 }
             }
         }
@@ -446,20 +452,18 @@ impl Future for ServerBuilder {
 
     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;
-                }
+            match Pin::new(&mut self.cmd).poll_recv(cx) {
+                Poll::Ready(Some(it)) => self.as_mut().get_mut().handle_cmd(it),
+                _ => return Poll::Pending,
             }
         }
     }
 }
 
-pub(super) fn bind_addr<S: net::ToSocketAddrs>(
+pub(super) fn bind_addr<S: ToSocketAddrs>(
     addr: S,
-    backlog: i32,
-) -> io::Result<Vec<net::TcpListener>> {
+    backlog: u32,
+) -> io::Result<Vec<MioTcpListener>> {
     let mut err = None;
     let mut succ = false;
     let mut sockets = Vec::new();
@@ -487,14 +491,13 @@ pub(super) fn bind_addr<S: net::ToSocketAddrs>(
     }
 }
 
-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(),
+fn create_tcp_listener(addr: StdSocketAddr, backlog: u32) -> io::Result<MioTcpListener> {
+    let socket = match addr {
+        StdSocketAddr::V4(_) => MioTcpSocket::new_v4()?,
+        StdSocketAddr::V6(_) => MioTcpSocket::new_v6()?,
     };
-    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())
+
+    socket.set_reuseaddr(true)?;
+    socket.bind(addr)?;
+    socket.listen(backlog)
 }

actix-server/src/config.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
-use std::{fmt, io, net};
+use std::future::Future;
+use std::{fmt, io};
 
 use actix_rt::net::TcpStream;
 use actix_service::{
@@ -7,23 +8,23 @@ use actix_service::{
     ServiceFactory as BaseServiceFactory,
 };
 use actix_utils::counter::CounterGuard;
-use futures_util::future::{ok, Future, FutureExt, LocalBoxFuture};
+use futures_core::future::LocalBoxFuture;
 use log::error;
 
-use super::builder::bind_addr;
-use super::service::{BoxedServerService, InternalServiceFactory, StreamService};
-use super::Token;
-use crate::socket::StdStream;
+use crate::builder::bind_addr;
+use crate::service::{BoxedServerService, InternalServiceFactory, StreamService};
+use crate::socket::{MioStream, MioTcpListener, StdSocketAddr, StdTcpListener, ToSocketAddrs};
+use crate::{ready, Token};
 
 pub struct ServiceConfig {
-    pub(crate) services: Vec<(String, net::TcpListener)>,
+    pub(crate) services: Vec<(String, MioTcpListener)>,
     pub(crate) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
     pub(crate) threads: usize,
-    pub(crate) backlog: i32,
+    pub(crate) backlog: u32,
 }
 
 impl ServiceConfig {
-    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: u32) -> ServiceConfig {
         ServiceConfig {
             threads,
             backlog,
@@ -43,24 +44,20 @@ impl ServiceConfig {
     /// 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,
+        U: ToSocketAddrs,
     {
         let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
-            self.listen(name.as_ref(), lst);
+            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
+    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: StdTcpListener) -> &mut Self {
+        self._listen(name, MioTcpListener::from_std(lst))
     }
 
     /// Register service configuration function. This function get called
@@ -72,11 +69,19 @@ impl ServiceConfig {
         self.apply = Some(Box::new(f));
         Ok(())
     }
+
+    fn _listen<N: AsRef<str>>(&mut self, name: N, lst: MioTcpListener) -> &mut Self {
+        if self.apply.is_none() {
+            self.apply = Some(Box::new(not_configured));
+        }
+        self.services.push((name.as_ref().to_string(), lst));
+        self
+    }
 }
 
 pub(super) struct ConfiguredService {
     rt: Box<dyn ServiceRuntimeConfiguration>,
-    names: HashMap<Token, (String, net::SocketAddr)>,
+    names: HashMap<Token, (String, StdSocketAddr)>,
     topics: HashMap<String, Token>,
     services: Vec<Token>,
 }
@@ -91,7 +96,7 @@ impl ConfiguredService {
         }
     }
 
-    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
+    pub(super) fn stream(&mut self, token: Token, name: String, addr: StdSocketAddr) {
         self.names.insert(token, (name.clone(), addr));
         self.topics.insert(name, token);
         self.services.push(token);
@@ -121,7 +126,7 @@ impl InternalServiceFactory for ConfiguredService {
         let tokens = self.services.clone();
 
         // construct services
-        async move {
+        Box::pin(async move {
             let mut services = rt.services;
             // TODO: Proper error handling here
             for f in rt.onstart.into_iter() {
@@ -146,14 +151,13 @@ impl InternalServiceFactory for ConfiguredService {
                         token,
                         Box::new(StreamService::new(fn_service(move |_: TcpStream| {
                             error!("Service {:?} is not configured", name);
-                            ok::<_, ()>(())
+                            ready::<Result<_, ()>>(Ok(()))
                         }))),
                     ));
                 };
             }
             Ok(res)
-        }
-        .boxed_local()
+        })
     }
 }
 
@@ -233,13 +237,13 @@ impl ServiceRuntime {
     where
         F: Future<Output = ()> + 'static,
     {
-        self.onstart.push(fut.boxed_local())
+        self.onstart.push(Box::pin(fut))
     }
 }
 
 type BoxedNewService = Box<
     dyn BaseServiceFactory<
-        (Option<CounterGuard>, StdStream),
+        (Option<CounterGuard>, MioStream),
         Response = (),
         Error = (),
         InitError = (),
@@ -253,7 +257,7 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> BaseServiceFactory<(Option<CounterGuard>, StdStream)> for ServiceFactory<T>
+impl<T> BaseServiceFactory<(Option<CounterGuard>, MioStream)> for ServiceFactory<T>
 where
     T: BaseServiceFactory<TcpStream, Config = ()>,
     T::Future: 'static,
@@ -270,7 +274,7 @@ where
 
     fn new_service(&self, _: ()) -> Self::Future {
         let fut = self.inner.new_service(());
-        async move {
+        Box::pin(async move {
             match fut.await {
                 Ok(s) => Ok(Box::new(StreamService::new(s)) as BoxedServerService),
                 Err(e) => {
@@ -278,7 +282,6 @@ where
                     Err(())
                 }
             }
-        }
-        .boxed_local()
+        })
     }
 }

actix-server/src/lib.rs

@@ -11,21 +11,38 @@ mod server;
 mod service;
 mod signals;
 mod socket;
+mod test_server;
+mod waker_queue;
 mod worker;
 
 pub use self::builder::ServerBuilder;
 pub use self::config::{ServiceConfig, ServiceRuntime};
 pub use self::server::Server;
 pub use self::service::ServiceFactory;
+pub use self::test_server::TestServer;
 
 #[doc(hidden)]
 pub use self::socket::FromStream;
 
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
 /// Socket ID token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(crate) struct Token(usize);
 
+impl Default for Token {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Token {
+    fn new() -> Self {
+        Self(0)
+    }
+
     pub(crate) fn next(&mut self) -> Token {
         let token = Token(self.0);
         self.0 += 1;
@@ -37,3 +54,90 @@ impl Token {
 pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }
+
+// temporary Ready type for std::future::{ready, Ready}; Can be removed when MSRV surpass 1.48
+#[doc(hidden)]
+pub struct Ready<T>(Option<T>);
+
+pub(crate) fn ready<T>(t: T) -> Ready<T> {
+    Ready(Some(t))
+}
+
+impl<T> Unpin for Ready<T> {}
+
+impl<T> Future for Ready<T> {
+    type Output = T;
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(self.get_mut().0.take().unwrap())
+    }
+}
+
+// a poor man's join future. joined future is only used when starting/stopping the server.
+// pin_project and pinned futures are overkill for this task.
+pub(crate) struct JoinAll<T> {
+    fut: Vec<JoinFuture<T>>,
+}
+
+pub(crate) fn join_all<T>(fut: Vec<impl Future<Output = T> + 'static>) -> JoinAll<T> {
+    let fut = fut
+        .into_iter()
+        .map(|f| JoinFuture::Future(Box::pin(f)))
+        .collect();
+
+    JoinAll { fut }
+}
+
+enum JoinFuture<T> {
+    Future(Pin<Box<dyn Future<Output = T>>>),
+    Result(Option<T>),
+}
+
+impl<T> Unpin for JoinAll<T> {}
+
+impl<T> Future for JoinAll<T> {
+    type Output = Vec<T>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut ready = true;
+
+        let this = self.get_mut();
+        for fut in this.fut.iter_mut() {
+            if let JoinFuture::Future(f) = fut {
+                match f.as_mut().poll(cx) {
+                    Poll::Ready(t) => {
+                        *fut = JoinFuture::Result(Some(t));
+                    }
+                    Poll::Pending => ready = false,
+                }
+            }
+        }
+
+        if ready {
+            let mut res = Vec::new();
+            for fut in this.fut.iter_mut() {
+                if let JoinFuture::Result(f) = fut {
+                    res.push(f.take().unwrap());
+                }
+            }
+
+            Poll::Ready(res)
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[actix_rt::test]
+    async fn test_join_all() {
+        let futs = vec![ready(Ok(1)), ready(Err(3)), ready(Ok(9))];
+        let mut res = join_all(futs).await.into_iter();
+        assert_eq!(Ok(1), res.next().unwrap());
+        assert_eq!(Err(3), res.next().unwrap());
+        assert_eq!(Ok(9), res.next().unwrap());
+    }
+}

actix-server/src/server.rs

@@ -3,9 +3,8 @@ 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 tokio::sync::mpsc::UnboundedSender;
+use tokio::sync::oneshot;
 
 use crate::builder::ServerBuilder;
 use crate::signals::Signal;
@@ -42,11 +41,11 @@ impl Server {
     }
 
     pub(crate) fn signal(&self, sig: Signal) {
-        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+        let _ = self.0.send(ServerCommand::Signal(sig));
     }
 
     pub(crate) fn worker_faulted(&self, idx: usize) {
-        let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(idx));
+        let _ = self.0.send(ServerCommand::WorkerFaulted(idx));
     }
 
     /// Pause accepting incoming connections
@@ -55,15 +54,19 @@ impl Server {
     /// 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(|_| ())
+        let _ = self.0.send(ServerCommand::Pause(tx));
+        async {
+            let _ = rx.await;
+        }
     }
 
     /// 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(|_| ())
+        let _ = self.0.send(ServerCommand::Resume(tx));
+        async {
+            let _ = rx.await;
+        }
     }
 
     /// Stop incoming connection processing, stop all workers and exit.
@@ -71,11 +74,13 @@ impl Server {
     /// 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 {
+        let _ = self.0.send(ServerCommand::Stop {
             graceful,
             completion: Some(tx),
         });
-        rx.map(|_| ())
+        async {
+            let _ = rx.await;
+        }
     }
 }
 
@@ -93,7 +98,7 @@ impl Future for Server {
 
         if this.1.is_none() {
             let (tx, rx) = oneshot::channel();
-            if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() {
+            if this.0.send(ServerCommand::Notify(tx)).is_err() {
                 return Poll::Ready(Ok(()));
             }
             this.1 = Some(rx);
@@ -101,8 +106,7 @@ impl Future for Server {
 
         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(())),
+            Poll::Ready(_) => Poll::Ready(Ok(())),
         }
     }
 }

actix-server/src/service.rs

@@ -2,15 +2,13 @@ use std::marker::PhantomData;
 use std::net::SocketAddr;
 use std::task::{Context, Poll};
 
-use actix_rt::spawn;
 use actix_service::{Service, ServiceFactory as BaseServiceFactory};
 use actix_utils::counter::CounterGuard;
-use futures_util::future::{err, ok, LocalBoxFuture, Ready};
-use futures_util::{FutureExt, TryFutureExt};
+use futures_core::future::LocalBoxFuture;
 use log::error;
 
-use super::Token;
-use crate::socket::{FromStream, StdStream};
+use crate::socket::{FromStream, MioStream};
+use crate::{ready, Ready, Token};
 
 pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
     type Factory: BaseServiceFactory<Stream, Config = ()>;
@@ -28,7 +26,7 @@ pub(crate) trait InternalServiceFactory: Send {
 
 pub(crate) type BoxedServerService = Box<
     dyn Service<
-        (Option<CounterGuard>, StdStream),
+        (Option<CounterGuard>, MioStream),
         Response = (),
         Error = (),
         Future = Ready<Result<(), ()>>,
@@ -49,7 +47,7 @@ impl<S, I> StreamService<S, I> {
     }
 }
 
-impl<S, I> Service<(Option<CounterGuard>, StdStream)> for StreamService<S, I>
+impl<S, I> Service<(Option<CounterGuard>, MioStream)> for StreamService<S, I>
 where
     S: Service<I>,
     S::Future: 'static,
@@ -60,25 +58,25 @@ where
     type Error = ();
     type Future = Ready<Result<(), ()>>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(|_| ())
     }
 
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, StdStream)) -> Self::Future {
-        match FromStream::from_stdstream(req) {
+    fn call(&self, (guard, req): (Option<CounterGuard>, MioStream)) -> Self::Future {
+        ready(match FromStream::from_mio(req) {
             Ok(stream) => {
                 let f = self.service.call(stream);
-                spawn(async move {
+                actix_rt::spawn(async move {
                     let _ = f.await;
                     drop(guard);
                 });
-                ok(())
+                Ok(())
             }
             Err(e) => {
                 error!("Can not convert to an async tcp stream: {}", e);
-                err(())
+                Err(())
             }
-        }
+        })
     }
 }
 
@@ -132,15 +130,16 @@ where
 
     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()
+        let fut = self.inner.create().new_service(());
+        Box::pin(async move {
+            match fut.await {
+                Ok(inner) => {
+                    let service = Box::new(StreamService::new(inner)) as _;
+                    Ok(vec![(token, service)])
+                }
+                Err(_) => Err(()),
+            }
+        })
     }
 }
 

actix-server/src/signals.rs

@@ -2,8 +2,6 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures_util::future::lazy;
-
 use crate::server::Server;
 
 /// Different types of process signals
@@ -23,48 +21,49 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    stream: Pin<Box<dyn Future<Output = std::io::Result<()>>>>,
+    signals: futures_core::future::LocalBoxFuture<'static, std::io::Result<()>>,
     #[cfg(unix)]
-    streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
+    signals: Vec<(Signal, actix_rt::signal::unix::Signal)>,
 }
 
 impl Signals {
     pub(crate) fn start(srv: Server) {
-        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;
+        #[cfg(not(unix))]
+        {
+            actix_rt::spawn(Signals {
+                srv,
+                signals: 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),
+            ];
 
-                let sig_map = [
-                    (unix::SignalKind::interrupt(), Signal::Int),
-                    (unix::SignalKind::hangup(), Signal::Hup),
-                    (unix::SignalKind::terminate(), Signal::Term),
-                    (unix::SignalKind::quit(), Signal::Quit),
-                ];
+            let signals = sig_map
+                .iter()
+                .filter_map(|(kind, sig)| {
+                    unix::signal(*kind)
+                        .map(|tokio_sig| (*sig, tokio_sig))
+                        .map_err(|e| {
+                            log::error!(
+                                "Can not initialize stream handler for {:?} err: {}",
+                                sig,
+                                e
+                            )
+                        })
+                        .ok()
+                })
+                .collect::<Vec<_>>();
 
-                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 })
-            }
-        }));
+            actix_rt::spawn(Signals { srv, signals });
+        }
     }
 }
 
@@ -73,25 +72,20 @@ impl Future for Signals {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         #[cfg(not(unix))]
-        match Pin::new(&mut self.stream).poll(cx) {
+        match self.signals.as_mut().poll(cx) {
             Poll::Ready(_) => {
                 self.srv.signal(Signal::Int);
                 Poll::Ready(())
             }
-            Poll::Pending => return Poll::Pending,
+            Poll::Pending => 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);
-                        }
-                    }
+            for (sig, fut) in self.signals.iter_mut() {
+                if Pin::new(fut).poll_recv(cx).is_ready() {
+                    let sig = *sig;
+                    self.srv.signal(sig);
+                    return Poll::Ready(());
                 }
             }
             Poll::Pending

actix-server/src/socket.rs

@@ -1,135 +1,91 @@
-use std::{fmt, io, net};
+pub(crate) use std::net::{
+    SocketAddr as StdSocketAddr, TcpListener as StdTcpListener, ToSocketAddrs,
+};
+
+pub(crate) use mio::net::{TcpListener as MioTcpListener, TcpSocket as MioTcpSocket};
+#[cfg(unix)]
+pub(crate) use {
+    mio::net::UnixListener as MioUnixListener,
+    std::os::unix::net::UnixListener as StdUnixListener,
+};
+
+use std::{fmt, io};
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
+use mio::event::Source;
+use mio::net::TcpStream as MioTcpStream;
+use mio::{Interest, Registry, Token};
 
-pub(crate) enum StdListener {
-    Tcp(net::TcpListener),
-    #[cfg(all(unix))]
-    Uds(std::os::unix::net::UnixListener),
+#[cfg(windows)]
+use std::os::windows::io::{FromRawSocket, IntoRawSocket};
+#[cfg(unix)]
+use {
+    actix_rt::net::UnixStream,
+    mio::net::{SocketAddr as MioSocketAddr, UnixStream as MioUnixStream},
+    std::os::unix::io::{FromRawFd, IntoRawFd},
+};
+
+pub(crate) enum MioListener {
+    Tcp(MioTcpListener),
+    #[cfg(unix)]
+    Uds(MioUnixListener),
 }
 
-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 {
+impl MioListener {
     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)))
-            }),
+            MioListener::Tcp(ref lst) => SocketAddr::Tcp(lst.local_addr().unwrap()),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => SocketAddr::Uds(lst.local_addr().unwrap()),
+        }
+    }
+
+    pub(crate) fn accept(&self) -> io::Result<Option<(MioStream, SocketAddr)>> {
+        match *self {
+            MioListener::Tcp(ref lst) => lst
+                .accept()
+                .map(|(stream, addr)| Some((MioStream::Tcp(stream), SocketAddr::Tcp(addr)))),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => lst
+                .accept()
+                .map(|(stream, addr)| Some((MioStream::Uds(stream), SocketAddr::Uds(addr)))),
         }
     }
 }
 
-impl mio::Evented for SocketListener {
+impl Source for MioListener {
     fn register(
-        &self,
-        poll: &mio::Poll,
-        token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
     ) -> 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),
+            MioListener::Tcp(ref mut lst) => lst.register(registry, token, interests),
+            #[cfg(unix)]
+            MioListener::Uds(ref mut lst) => lst.register(registry, token, interests),
         }
     }
 
     fn reregister(
-        &self,
-        poll: &mio::Poll,
-        token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
     ) -> 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),
+            MioListener::Tcp(ref mut lst) => lst.reregister(registry, token, interests),
+            #[cfg(unix)]
+            MioListener::Uds(ref mut lst) => lst.reregister(registry, token, interests),
         }
     }
-    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
+
+    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
         match *self {
-            SocketListener::Tcp(ref lst) => lst.deregister(poll),
-            #[cfg(all(unix))]
-            SocketListener::Uds(ref lst) => {
-                let res = lst.deregister(poll);
+            MioListener::Tcp(ref mut lst) => lst.deregister(registry),
+            #[cfg(unix)]
+            MioListener::Uds(ref mut lst) => {
+                let res = lst.deregister(registry);
 
                 // cleanup file path
                 if let Ok(addr) = lst.local_addr() {
@@ -143,28 +99,156 @@ impl mio::Evented for SocketListener {
     }
 }
 
-pub trait FromStream: AsyncRead + AsyncWrite + Sized {
-    fn from_stdstream(sock: StdStream) -> io::Result<Self>;
+impl From<StdTcpListener> for MioListener {
+    fn from(lst: StdTcpListener) -> Self {
+        MioListener::Tcp(MioTcpListener::from_std(lst))
+    }
 }
 
-impl FromStream for TcpStream {
-    fn from_stdstream(sock: StdStream) -> io::Result<Self> {
-        match sock {
-            StdStream::Tcp(stream) => TcpStream::from_std(stream),
+#[cfg(unix)]
+impl From<StdUnixListener> for MioListener {
+    fn from(lst: StdUnixListener) -> Self {
+        MioListener::Uds(MioUnixListener::from_std(lst))
+    }
+}
+
+impl fmt::Debug for MioListener {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            MioListener::Tcp(ref lst) => write!(f, "{:?}", lst),
             #[cfg(all(unix))]
-            StdStream::Uds(_) => {
+            MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
+        }
+    }
+}
+
+impl fmt::Display for MioListener {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            MioListener::Tcp(ref lst) => write!(f, "{}", lst.local_addr().ok().unwrap()),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => write!(f, "{:?}", lst.local_addr().ok().unwrap()),
+        }
+    }
+}
+
+pub(crate) enum SocketAddr {
+    Tcp(StdSocketAddr),
+    #[cfg(unix)]
+    Uds(MioSocketAddr),
+}
+
+impl fmt::Display for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            SocketAddr::Tcp(ref addr) => write!(f, "{}", addr),
+            #[cfg(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(unix)]
+            SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum MioStream {
+    Tcp(MioTcpStream),
+    #[cfg(unix)]
+    Uds(MioUnixStream),
+}
+
+/// helper trait for converting mio stream to tokio stream.
+pub trait FromStream: Sized {
+    fn from_mio(sock: MioStream) -> io::Result<Self>;
+}
+
+// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+#[cfg(unix)]
+impl FromStream for TcpStream {
+    fn from_mio(sock: MioStream) -> io::Result<Self> {
+        match sock {
+            MioStream::Tcp(mio) => {
+                let raw = IntoRawFd::into_raw_fd(mio);
+                // SAFETY: This is a in place conversion from mio stream to tokio stream.
+                TcpStream::from_std(unsafe { FromRawFd::from_raw_fd(raw) })
+            }
+            MioStream::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> {
+// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+#[cfg(windows)]
+impl FromStream for TcpStream {
+    fn from_mio(sock: MioStream) -> 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),
+            MioStream::Tcp(mio) => {
+                let raw = IntoRawSocket::into_raw_socket(mio);
+                // SAFETY: This is a in place conversion from mio stream to tokio stream.
+                TcpStream::from_std(unsafe { FromRawSocket::from_raw_socket(raw) })
+            }
+        }
+    }
+}
+
+// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+#[cfg(unix)]
+impl FromStream for UnixStream {
+    fn from_mio(sock: MioStream) -> io::Result<Self> {
+        match sock {
+            MioStream::Tcp(_) => panic!("Should not happen, bug in server impl"),
+            MioStream::Uds(mio) => {
+                let raw = IntoRawFd::into_raw_fd(mio);
+                // SAFETY: This is a in place conversion from mio stream to tokio stream.
+                UnixStream::from_std(unsafe { FromRawFd::from_raw_fd(raw) })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn socket_addr() {
+        let addr = SocketAddr::Tcp("127.0.0.1:8080".parse().unwrap());
+        assert!(format!("{:?}", addr).contains("127.0.0.1:8080"));
+        assert_eq!(format!("{}", addr), "127.0.0.1:8080");
+
+        let addr: StdSocketAddr = "127.0.0.1:0".parse().unwrap();
+        let socket = MioTcpSocket::new_v4().unwrap();
+        socket.set_reuseaddr(true).unwrap();
+        socket.bind(addr).unwrap();
+        let tcp = socket.listen(128).unwrap();
+        let lst = MioListener::Tcp(tcp);
+        assert!(format!("{:?}", lst).contains("TcpListener"));
+        assert!(format!("{}", lst).contains("127.0.0.1"));
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn uds() {
+        let _ = std::fs::remove_file("/tmp/sock.xxxxx");
+        if let Ok(socket) = MioUnixListener::bind("/tmp/sock.xxxxx") {
+            let addr = socket.local_addr().expect("Couldn't get local address");
+            let a = SocketAddr::Uds(addr);
+            assert!(format!("{:?}", a).contains("/tmp/sock.xxxxx"));
+            assert!(format!("{}", a).contains("/tmp/sock.xxxxx"));
+
+            let lst = MioListener::Uds(socket);
+            assert!(format!("{:?}", lst).contains("/tmp/sock.xxxxx"));
+            assert!(format!("{}", lst).contains("/tmp/sock.xxxxx"));
         }
     }
 }

actix-server/src/test_server.rs

@@ -1,19 +1,9 @@
-//! Various helpers for Actix applications to use during testing.
-
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![allow(clippy::type_complexity, clippy::needless_doctest_main)]
-#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
-#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-
 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;
+use crate::{Server, ServerBuilder, ServiceFactory};
 
 /// The `TestServer` type.
 ///
@@ -22,9 +12,9 @@ pub use actix_macros::test;
 ///
 /// # Examples
 ///
-/// ```rust
+/// ```
 /// use actix_service::fn_service;
-/// use actix_testing::TestServer;
+/// use actix_server::TestServer;
 ///
 /// #[actix_rt::main]
 /// async fn main() {
@@ -58,11 +48,8 @@ impl TestServer {
 
         // run server in separate thread
         thread::spawn(move || {
-            let sys = System::new("actix-test-server");
-            factory(Server::build())
-                .workers(1)
-                .disable_signals()
-                .start();
+            let sys = System::new();
+            factory(Server::build()).workers(1).disable_signals().run();
 
             tx.send(System::current()).unwrap();
             sys.run()
@@ -83,7 +70,7 @@ impl TestServer {
 
         // run server in separate thread
         thread::spawn(move || {
-            let mut sys = System::new("actix-test-server");
+            let sys = System::new();
             let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
             let local_addr = tcp.local_addr().unwrap();
 
@@ -93,10 +80,9 @@ impl TestServer {
                     .unwrap()
                     .workers(1)
                     .disable_signals()
-                    .start();
+                    .run();
+                tx.send((System::current(), local_addr)).unwrap();
             });
-
-            tx.send((System::current(), local_addr)).unwrap();
             sys.run()
         });
 
@@ -116,11 +102,10 @@ impl TestServer {
     /// Get first 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();
+        let socket = mio::net::TcpSocket::new_v4().unwrap();
+        socket.bind(addr).unwrap();
+        socket.set_reuseaddr(true).unwrap();
+        let tcp = socket.listen(1024).unwrap();
         tcp.local_addr().unwrap()
     }
 }

actix-server/src/waker_queue.rs

@@ -0,0 +1,89 @@
+use std::{
+    collections::VecDeque,
+    ops::Deref,
+    sync::{Arc, Mutex, MutexGuard},
+};
+
+use mio::{Registry, Token as MioToken, Waker};
+
+use crate::worker::WorkerHandle;
+
+/// Waker token for `mio::Poll` instance.
+pub(crate) const WAKER_TOKEN: MioToken = MioToken(usize::MAX);
+
+/// `mio::Waker` with a queue for waking up the `Accept`'s `Poll` and contains the `WakerInterest`
+/// the `Poll` would want to look into.
+pub(crate) struct WakerQueue(Arc<(Waker, Mutex<VecDeque<WakerInterest>>)>);
+
+impl Clone for WakerQueue {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl Deref for WakerQueue {
+    type Target = (Waker, Mutex<VecDeque<WakerInterest>>);
+
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl WakerQueue {
+    /// Construct a waker queue with given `Poll`'s `Registry` and capacity.
+    ///
+    /// A fixed `WAKER_TOKEN` is used to identify the wake interest and the `Poll` needs to match
+    /// event's token for it to properly handle `WakerInterest`.
+    pub(crate) fn new(registry: &Registry) -> std::io::Result<Self> {
+        let waker = Waker::new(registry, WAKER_TOKEN)?;
+        let queue = Mutex::new(VecDeque::with_capacity(16));
+
+        Ok(Self(Arc::new((waker, queue))))
+    }
+
+    /// Push a new interest to the queue and wake up the accept poll afterwards.
+    pub(crate) fn wake(&self, interest: WakerInterest) {
+        let (waker, queue) = self.deref();
+
+        queue
+            .lock()
+            .expect("Failed to lock WakerQueue")
+            .push_back(interest);
+
+        waker
+            .wake()
+            .unwrap_or_else(|e| panic!("can not wake up Accept Poll: {}", e));
+    }
+
+    /// Get a MutexGuard of the waker queue.
+    pub(crate) fn guard(&self) -> MutexGuard<'_, VecDeque<WakerInterest>> {
+        self.deref().1.lock().expect("Failed to lock WakerQueue")
+    }
+
+    /// Reset the waker queue so it does not grow infinitely.
+    pub(crate) fn reset(queue: &mut VecDeque<WakerInterest>) {
+        std::mem::swap(&mut VecDeque::<WakerInterest>::with_capacity(16), queue);
+    }
+}
+
+/// Types of interests we would look into when `Accept`'s `Poll` is waked up by waker.
+///
+/// These interests should not be confused with `mio::Interest` and mostly not I/O related
+pub(crate) enum WakerInterest {
+    /// `WorkerAvailable` is an interest from `Worker` notifying `Accept` there is a worker
+    /// available and can accept new tasks.
+    WorkerAvailable,
+    /// `Pause`, `Resume`, `Stop` Interest are from `ServerBuilder` future. It listens to
+    /// `ServerCommand` and notify `Accept` to do exactly these tasks.
+    Pause,
+    Resume,
+    Stop,
+    /// `Timer` is an interest sent as a delayed future. When an error happens on accepting
+    /// connection `Accept` would deregister socket listener temporary and wake up the poll and
+    /// register them again after the delayed future resolve.
+    Timer,
+    /// `Worker` is an interest happen after a worker runs into faulted state(This is determined
+    /// by if work can be sent to it successfully).`Accept` would be waked up and add the new
+    /// `WorkerHandle`.
+    Worker(WorkerHandle),
+}

actix-server/src/worker.rs

@@ -1,22 +1,22 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::time;
+use std::time::Duration;
 
-use actix_rt::time::{delay_until, Delay, Instant};
+use actix_rt::time::{sleep_until, Instant, Sleep};
 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 futures_core::future::LocalBoxFuture;
 use log::{error, info, trace};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
+use tokio::sync::oneshot;
 
-use crate::accept::AcceptNotify;
 use crate::service::{BoxedServerService, InternalServiceFactory};
-use crate::socket::{SocketAddr, StdStream};
-use crate::Token;
+use crate::socket::{MioStream, SocketAddr};
+use crate::waker_queue::{WakerInterest, WakerQueue};
+use crate::{join_all, Token};
 
 pub(crate) struct WorkerCommand(Conn);
 
@@ -29,7 +29,7 @@ pub(crate) struct StopCommand {
 
 #[derive(Debug)]
 pub(crate) struct Conn {
-    pub io: StdStream,
+    pub io: MioStream,
     pub token: Token,
     pub peer: Option<SocketAddr>,
 }
@@ -46,31 +46,33 @@ 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));
 }
 
+pub(crate) fn num_connections() -> usize {
+    MAX_CONNS_COUNTER.with(|conns| conns.total())
+}
+
+// a handle to worker that can send message to worker and share the availability of worker to other
+// thread.
 #[derive(Clone)]
-pub(crate) struct WorkerClient {
+pub(crate) struct WorkerHandle {
     pub idx: usize,
     tx1: UnboundedSender<WorkerCommand>,
     tx2: UnboundedSender<StopCommand>,
     avail: WorkerAvailability,
 }
 
-impl WorkerClient {
+impl WorkerHandle {
     pub fn new(
         idx: usize,
         tx1: UnboundedSender<WorkerCommand>,
         tx2: UnboundedSender<StopCommand>,
         avail: WorkerAvailability,
     ) -> Self {
-        WorkerClient {
+        WorkerHandle {
             idx,
             tx1,
             tx2,
@@ -79,9 +81,7 @@ impl WorkerClient {
     }
 
     pub fn send(&self, msg: Conn) -> Result<(), Conn> {
-        self.tx1
-            .unbounded_send(WorkerCommand(msg))
-            .map_err(|msg| msg.into_inner().0)
+        self.tx1.send(WorkerCommand(msg)).map_err(|msg| msg.0 .0)
     }
 
     pub fn available(&self) -> bool {
@@ -90,21 +90,21 @@ impl WorkerClient {
 
     pub fn stop(&self, graceful: bool) -> oneshot::Receiver<bool> {
         let (result, rx) = oneshot::channel();
-        let _ = self.tx2.unbounded_send(StopCommand { graceful, result });
+        let _ = self.tx2.send(StopCommand { graceful, result });
         rx
     }
 }
 
 #[derive(Clone)]
 pub(crate) struct WorkerAvailability {
-    notify: AcceptNotify,
+    waker: WakerQueue,
     available: Arc<AtomicBool>,
 }
 
 impl WorkerAvailability {
-    pub fn new(notify: AcceptNotify) -> Self {
+    pub fn new(waker: WakerQueue) -> Self {
         WorkerAvailability {
-            notify,
+            waker,
             available: Arc::new(AtomicBool::new(false)),
         }
     }
@@ -115,17 +115,17 @@ impl WorkerAvailability {
 
     pub fn set(&self, val: bool) {
         let old = self.available.swap(val, Ordering::Release);
+        // notify the accept on switched to available.
         if !old && val {
-            self.notify.notify()
+            self.waker.wake(WakerInterest::WorkerAvailable);
         }
     }
 }
 
-/// Service worker
+/// Service worker.
 ///
-/// Worker accepts Socket objects via unbounded channel and starts stream
-/// processing.
-pub(crate) struct Worker {
+/// Worker accepts Socket objects via unbounded channel and starts stream processing.
+pub(crate) struct ServerWorker {
     rx: UnboundedReceiver<WorkerCommand>,
     rx2: UnboundedReceiver<StopCommand>,
     services: Vec<WorkerService>,
@@ -133,7 +133,7 @@ pub(crate) struct Worker {
     conns: Counter,
     factories: Vec<Box<dyn InternalServiceFactory>>,
     state: WorkerState,
-    shutdown_timeout: time::Duration,
+    config: ServerWorkerConfig,
 }
 
 struct WorkerService {
@@ -159,68 +159,108 @@ enum WorkerServiceStatus {
     Stopped,
 }
 
-impl Worker {
+/// Config for worker behavior passed down from server builder.
+#[derive(Copy, Clone)]
+pub(crate) struct ServerWorkerConfig {
+    shutdown_timeout: Duration,
+    max_blocking_threads: usize,
+}
+
+impl Default for ServerWorkerConfig {
+    fn default() -> Self {
+        // 512 is the default max blocking thread count of tokio runtime.
+        let max_blocking_threads = std::cmp::max(512 / num_cpus::get(), 1);
+        Self {
+            shutdown_timeout: Duration::from_secs(30),
+            max_blocking_threads,
+        }
+    }
+}
+
+impl ServerWorkerConfig {
+    pub(crate) fn max_blocking_threads(&mut self, num: usize) {
+        self.max_blocking_threads = num;
+    }
+
+    pub(crate) fn shutdown_timeout(&mut self, dur: Duration) {
+        self.shutdown_timeout = dur;
+    }
+}
+
+impl ServerWorker {
     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();
+        config: ServerWorkerConfig,
+    ) -> WorkerHandle {
+        let (tx1, rx) = unbounded_channel();
+        let (tx2, rx2) = unbounded_channel();
         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()),
-                });
+        // every worker runs in it's own arbiter.
+        // use a custom tokio runtime builder to change the settings of runtime.
+        Arbiter::with_tokio_rt(move || {
+            tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .max_blocking_threads(config.max_blocking_threads)
+                .build()
+                .unwrap()
+        })
+        .spawn(async move {
+            availability.set(false);
+            let mut wrk = MAX_CONNS_COUNTER.with(move |conns| ServerWorker {
+                rx,
+                rx2,
+                availability,
+                factories,
+                config,
+                services: Vec::new(),
+                conns: conns.clone(),
+                state: WorkerState::Unavailable,
+            });
 
-                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<_>>()
-                    }));
-                }
+            let fut = wrk
+                .factories
+                .iter()
+                .enumerate()
+                .map(|(idx, factory)| {
+                    let fut = factory.create();
+                    async move {
+                        fut.await.map(|r| {
+                            r.into_iter().map(|(t, s)| (idx, t, s)).collect::<Vec<_>>()
+                        })
+                    }
+                })
+                .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,
-                                    });
-                                }
+            // a second spawn to make sure worker future runs as non boxed future.
+            // As Arbiter::spawn would box the future before send it to arbiter.
+            spawn(async move {
+                let res: Result<Vec<_>, _> = join_all(fut).await.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(),
-        );
+                    Err(e) => {
+                        error!("Can not start worker: {:?}", e);
+                        Arbiter::current().stop();
+                    }
+                }
+                wrk.await
+            });
+        });
 
-        WorkerClient::new(idx, tx1, tx2, avail)
+        WorkerHandle::new(idx, tx1, tx2, avail)
     }
 
     fn shutdown(&mut self, force: bool) {
@@ -242,7 +282,7 @@ impl Worker {
     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() {
+        for (idx, srv) in self.services.iter_mut().enumerate() {
             if srv.status == WorkerServiceStatus::Available
                 || srv.status == WorkerServiceStatus::Unavailable
             {
@@ -288,29 +328,26 @@ impl Worker {
 
 enum WorkerState {
     Available,
-    Unavailable(Vec<Conn>),
+    Unavailable,
     Restarting(
         usize,
         Token,
-        #[allow(clippy::type_complexity)]
-        Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
+        LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>>,
     ),
     Shutdown(
-        Pin<Box<Delay>>,
-        Pin<Box<Delay>>,
+        Pin<Box<Sleep>>,
+        Pin<Box<Sleep>>,
         Option<oneshot::Sender<bool>>,
     ),
 }
 
-impl Future for Worker {
+impl Future for ServerWorker {
     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)
+            Pin::new(&mut self.rx2).poll_recv(cx)
         {
             self.availability.set(false);
             let num = num_connections();
@@ -324,8 +361,8 @@ impl Future for Worker {
                 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)),
+                        Box::pin(sleep_until(Instant::now() + Duration::from_secs(1))),
+                        Box::pin(sleep_until(Instant::now() + self.config.shutdown_timeout)),
                         Some(result),
                     );
                 } else {
@@ -341,53 +378,35 @@ impl Future for Worker {
         }
 
         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), 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::Unavailable => match self.check_readiness(cx) {
+                Ok(true) => {
+                    self.state = WorkerState::Available;
+                    self.availability.set(true);
+                    self.poll(cx)
                 }
-            }
+                Ok(false) => 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) {
+                match fut.as_mut().poll(cx) {
                     Poll::Ready(Ok(item)) => {
-                        for (token, service) in item {
+                        // only interest in the first item?
+                        if let Some((token, service)) = item.into_iter().next() {
                             trace!(
                                 "Service {:?} has been restarted",
                                 self.factories[idx].name(token)
                             );
                             self.services[token.0].created(service);
-                            self.state = WorkerState::Unavailable(Vec::new());
+                            self.state = WorkerState::Unavailable;
                             return self.poll(cx);
                         }
                     }
@@ -397,9 +416,7 @@ impl Future for Worker {
                             self.factories[idx].name(token)
                         );
                     }
-                    Poll::Pending => {
-                        return Poll::Pending;
-                    }
+                    Poll::Pending => return Poll::Pending,
                 }
                 self.poll(cx)
             }
@@ -412,71 +429,56 @@ impl Future for Worker {
                 }
 
                 // 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(());
-                    }
+                if Pin::new(t2).poll(cx).is_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);
-                    }
+                if t1.as_mut().poll(cx).is_ready() {
+                    *t1 = Box::pin(sleep_until(Instant::now() + 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), 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(()),
+            // actively poll stream and handle worker command
+            WorkerState::Available => loop {
+                match self.check_readiness(cx) {
+                    Ok(true) => (),
+                    Ok(false) => {
+                        trace!("Worker is unavailable");
+                        self.availability.set(false);
+                        self.state = WorkerState::Unavailable;
+                        return self.poll(cx);
+                    }
+                    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);
                     }
                 }
-            }
+
+                match Pin::new(&mut self.rx).poll_recv(cx) {
+                    // handle incoming io stream
+                    Poll::Ready(Some(WorkerCommand(msg))) => {
+                        let guard = self.conns.get();
+                        let _ = self.services[msg.token.0]
+                            .service
+                            .call((Some(guard), msg.io));
+                    }
+                    Poll::Pending => return Poll::Pending,
+                    Poll::Ready(None) => return Poll::Ready(()),
+                };
+            },
         }
     }
 }

actix-server/tests/test_server.rs

@@ -5,14 +5,13 @@ 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();
+    let socket = mio::net::TcpSocket::new_v4().unwrap();
+    socket.bind(addr).unwrap();
+    socket.set_reuseaddr(true).unwrap();
+    let tcp = socket.listen(32).unwrap();
     tcp.local_addr().unwrap()
 }
 
@@ -22,15 +21,14 @@ fn test_bind() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
-
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .workers(1)
                 .disable_signals()
                 .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
                 .unwrap()
-                .start()
+                .run()
         }));
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
@@ -49,17 +47,17 @@ fn test_listen() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let lst = net::TcpListener::bind(addr).unwrap();
-        sys.block_on(lazy(|_| {
+        sys.block_on(async {
             Server::build()
                 .disable_signals()
                 .workers(1)
                 .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
                 .unwrap()
-                .start()
-        }));
-        let _ = tx.send(actix_rt::System::current());
+                .run();
+            let _ = tx.send(actix_rt::System::current());
+        });
         let _ = sys.run();
     });
     let sys = rx.recv().unwrap();
@@ -83,7 +81,7 @@ fn test_start() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .backlog(100)
@@ -96,12 +94,13 @@ fn test_start() {
                     })
                 })
                 .unwrap()
-                .start()
+                .run()
         }));
 
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
+
     let (srv, sys) = rx.recv().unwrap();
 
     let mut buf = [1u8; 4];
@@ -151,7 +150,7 @@ fn test_configure() {
 
     let h = thread::spawn(move || {
         let num = num2.clone();
-        let mut sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .disable_signals()
@@ -174,7 +173,7 @@ fn test_configure() {
                 })
                 .unwrap()
                 .workers(1)
-                .start()
+                .run()
         }));
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();

actix-service/CHANGES.md

@@ -1,6 +1,25 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.0.0-beta.4 - 2021-02-04
+* `Service::poll_ready` and `Service::call` receive `&self`. [#247]
+* `apply_fn` and `apply_fn_factory` now receive `Fn(Req, &Service)` function type. [#247]
+* `apply_cfg` and `apply_cfg_factory` now receive `Fn(Req, &Service)` function type. [#247]
+* `fn_service` and friends now receive `Fn(Req)` function type. [#247]
+
+[#247]: https://github.com/actix/actix-net/pull/247
+
+
+## 2.0.0-beta.3 - 2021-01-09
+* The `forward_ready!` macro converts errors. [#246]
+
+[#246]: https://github.com/actix/actix-net/pull/246
+
+
+## 2.0.0-beta.2 - 2021-01-03
+* Remove redundant type parameter from `map_config`.
 
 
 ## 2.0.0-beta.1 - 2020-12-28

actix-service/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "actix-service"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.4"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
+    "fakeshadow <24548779@qq.com>",
 ]
 description = "Service trait and combinators for representing asynchronous request/response operations."
 keywords = ["network", "framework", "async", "futures", "service"]
@@ -24,5 +25,5 @@ futures-core = { version = "0.3.7", default-features = false }
 pin-project-lite = "0.2"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "2.0.0"
 futures-util = { version = "0.3.7", default-features = false }

actix-service/README.md

@@ -2,6 +2,12 @@
 
 > Service trait and combinators for representing asynchronous request/response operations.
 
-See documentation for detailed explanations these components: [https://docs.rs/actix-service][docs].
+[![crates.io](https://img.shields.io/crates/v/actix-service?label=latest)](https://crates.io/crates/actix-service)
+[![Documentation](https://docs.rs/actix-service/badge.svg?version=2.0.0-beta.4)](https://docs.rs/actix-service/2.0.0-beta.4)
+[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+![License](https://img.shields.io/crates/l/actix-service.svg)
+[![Dependency Status](https://deps.rs/crate/actix-service/2.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-service/2.0.0-beta.4)
+[![Download](https://img.shields.io/crates/d/actix-service.svg)](https://crates.io/crates/actix-service)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
-[docs]: https://docs.rs/actix-service
+See documentation for detailed explanations of these components: https://docs.rs/actix-service.

actix-service/src/and_then.rs

@@ -1,12 +1,12 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 /// of another service which completes successfully.
 ///
 /// This is created by the `Pipeline::and_then` method.
-pub(crate) struct AndThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
+pub(crate) struct AndThenService<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
 impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
@@ -24,7 +24,7 @@ impl<A, B, Req> AndThenService<A, B, Req> {
         A: Service<Req>,
         B: Service<A::Response, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))), PhantomData)
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
@@ -43,20 +43,20 @@ where
     type Error = A::Error;
     type Future = AndThenServiceResponse<A, B, Req>;
 
-    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 {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let (a, b) = &*self.0;
+        let not_ready = !a.poll_ready(cx)?.is_ready();
+        if !b.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         AndThenServiceResponse {
             state: State::A {
-                fut: self.0.borrow_mut().0.call(req),
+                fut: self.0 .0.call(req),
                 b: Some(self.0.clone()),
             },
         }
@@ -84,13 +84,12 @@ pin_project! {
         A {
             #[pin]
             fut: A::Future,
-            b: Option<Rc<RefCell<(A, B)>>>,
+            b: Option<Rc<(A, B)>>,
         },
         B {
             #[pin]
             fut: B::Future,
         },
-        Empty,
     }
 }
 
@@ -105,23 +104,14 @@ where
         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`")
+            StateProj::A { fut, b } => {
+                let res = ready!(fut.poll(cx))?;
+                let b = b.take().unwrap();
+                let fut = b.1.call(res);
+                this.state.set(State::B { fut });
+                self.poll(cx)
             }
+            StateProj::B { fut } => fut.poll(cx),
         }
     }
 }
@@ -292,12 +282,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&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 {
+        fn call(&self, req: &'static str) -> Self::Future {
             ok(req)
         }
     }
@@ -310,12 +300,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&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 {
+        fn call(&self, req: &'static str) -> Self::Future {
             ok((req, "srv2"))
         }
     }
@@ -323,7 +313,7 @@ mod tests {
     #[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 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);
@@ -332,7 +322,7 @@ mod tests {
     #[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 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"));
@@ -346,7 +336,7 @@ mod tests {
             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 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/apply.rs

@@ -20,7 +20,7 @@ pub fn apply_fn<I, S, F, Fut, Req, In, Res, Err>(
 where
     I: IntoService<S, In>,
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     Apply::new(service.into_service(), wrap_fn)
@@ -36,7 +36,7 @@ pub fn apply_fn_factory<I, SF, F, Fut, Req, In, Res, Err>(
 where
     I: IntoServiceFactory<SF, In>,
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     ApplyFactory::new(service.into_factory(), f)
@@ -57,7 +57,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `Apply` combinator
@@ -73,7 +73,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Clone for Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err> + Clone,
-    F: FnMut(Req, &mut S) -> Fut + Clone,
+    F: Fn(Req, &S) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -88,7 +88,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -97,8 +97,8 @@ where
 
     crate::forward_ready!(service);
 
-    fn call(&mut self, req: Req) -> Self::Future {
-        (self.wrap_fn)(req, &mut self.service)
+    fn call(&self, req: Req) -> Self::Future {
+        (self.wrap_fn)(req, &self.service)
     }
 }
 
@@ -112,7 +112,7 @@ pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
 impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `ApplyFactory` new service instance
@@ -128,7 +128,7 @@ where
 impl<SF, F, Fut, Req, In, Res, Err> Clone for ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err> + Clone,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -144,7 +144,7 @@ impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req>
     for ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -165,7 +165,7 @@ pin_project! {
     pub struct ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
     where
         SF: ServiceFactory<In, Error = Err>,
-        F: FnMut(Req, &mut SF::Service) -> Fut,
+        F: Fn(Req, &SF::Service) -> Fut,
         Fut: Future<Output = Result<Res, Err>>,
     {
         #[pin]
@@ -178,7 +178,7 @@ pin_project! {
 impl<SF, F, Fut, Req, In, Res, Err> ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut,
+    F: Fn(Req, &SF::Service) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn new(fut: SF::Future, wrap_fn: F) -> Self {
@@ -194,7 +194,7 @@ impl<SF, F, Fut, Req, In, Res, Err> Future
     for ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut,
+    F: Fn(Req, &SF::Service) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Output = Result<Apply<SF::Service, F, Req, In, Res, Err>, SF::InitError>;
@@ -226,14 +226,14 @@ mod tests {
 
         crate::always_ready!();
 
-        fn call(&mut self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future {
             ok(())
         }
     }
 
     #[actix_rt::test]
     async fn test_call() {
-        let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
+        let srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
             let fut = srv.call(());
             async move {
                 fut.await.unwrap();
@@ -261,7 +261,7 @@ mod tests {
             },
         ));
 
-        let mut srv = new_srv.new_service(()).await.unwrap();
+        let srv = new_srv.new_service(()).await.unwrap();
 
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 

actix-service/src/apply_cfg.rs

@@ -1,17 +1,17 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use crate::{Service, ServiceFactory};
 
-/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory.
+/// Convert `Fn(Config, &Service1) -> Future<Service2>` fn to a service factory.
 pub fn apply_cfg<S1, Req, F, Cfg, Fut, S2, Err>(
     srv: S1,
     f: F,
@@ -26,17 +26,17 @@ pub fn apply_cfg<S1, Req, F, Cfg, Fut, S2, Err>(
 > + Clone
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
     ApplyConfigService {
-        srv: Rc::new(RefCell::new((srv, f))),
+        srv: Rc::new((srv, f)),
         _phantom: PhantomData,
     }
 }
 
-/// Convert `Fn(Config, &mut ServiceFactory1) -> Future<ServiceFactory2>` fn to a service factory.
+/// Convert `Fn(Config, &ServiceFactory1) -> Future<ServiceFactory2>` fn to a service factory.
 ///
 /// Service1 get constructed from `T` factory.
 pub fn apply_cfg_factory<SF, Req, F, Cfg, Fut, S>(
@@ -52,33 +52,33 @@ pub fn apply_cfg_factory<SF, Req, F, Cfg, Fut, S>(
 > + Clone
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     SF::InitError: From<SF::Error>,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
     ApplyConfigServiceFactory {
-        srv: Rc::new(RefCell::new((factory, f))),
+        srv: Rc::new((factory, f)),
         _phantom: PhantomData,
     }
 }
 
-/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
+/// Convert `Fn(Config, &Server) -> Future<Service>` fn to NewService\
 struct ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
-    srv: Rc<RefCell<(S1, F)>>,
+    srv: Rc<(S1, F)>,
     _phantom: PhantomData<(Cfg, Req, Fut, S2)>,
 }
 
 impl<S1, Req, F, Cfg, Fut, S2, Err> Clone for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
@@ -94,20 +94,20 @@ impl<S1, Req, F, Cfg, Fut, S2, Err> ServiceFactory<Req>
     for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
-    type Config = Cfg;
     type Response = S2::Response;
     type Error = S2::Error;
+    type Config = Cfg;
     type Service = S2;
 
     type InitError = Err;
     type Future = Fut;
 
     fn new_service(&self, cfg: Cfg) -> Self::Future {
-        let (t, f) = &mut *self.srv.borrow_mut();
+        let (t, f) = &*self.srv;
         f(cfg, t)
     }
 }
@@ -116,18 +116,18 @@ where
 struct ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
-    srv: Rc<RefCell<(SF, F)>>,
+    srv: Rc<(SF, F)>,
     _phantom: PhantomData<(Cfg, Req, Fut, S)>,
 }
 
 impl<SF, Req, F, Cfg, Fut, S> Clone for ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
@@ -144,13 +144,13 @@ impl<SF, Req, F, Cfg, Fut, S> ServiceFactory<Req>
 where
     SF: ServiceFactory<Req, Config = ()>,
     SF::InitError: From<SF::Error>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
-    type Config = Cfg;
     type Response = S::Response;
     type Error = S::Error;
+    type Config = Cfg;
     type Service = S;
 
     type InitError = SF::InitError;
@@ -161,7 +161,7 @@ where
             cfg: Some(cfg),
             store: self.srv.clone(),
             state: State::A {
-                fut: self.srv.borrow().0.new_service(()),
+                fut: self.srv.0.new_service(()),
             },
         }
     }
@@ -172,12 +172,12 @@ pin_project! {
     where
         SF: ServiceFactory<Req, Config = ()>,
         SF::InitError: From<SF::Error>,
-        F: FnMut(Cfg, &mut SF::Service) -> Fut,
+        F: Fn(Cfg, &SF::Service) -> Fut,
         Fut: Future<Output = Result<S, SF::InitError>>,
         S: Service<Req>,
     {
         cfg: Option<Cfg>,
-        store: Rc<RefCell<(SF, F)>>,
+        store: Rc<(SF, F)>,
         #[pin]
         state: State<SF, Fut, S, Req>,
     }
@@ -203,7 +203,7 @@ impl<SF, Req, F, Cfg, Fut, S> Future
 where
     SF: ServiceFactory<Req, Config = ()>,
     SF::InitError: From<SF::Error>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
@@ -213,24 +213,20 @@ where
         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(svc) => {
-                    this.state.set(State::B { svc });
-                    self.poll(cx)
+            StateProj::A { fut } => {
+                let svc = ready!(fut.poll(cx))?;
+                this.state.set(State::B { svc });
+                self.poll(cx)
+            }
+            StateProj::B { svc } => {
+                ready!(svc.poll_ready(cx))?;
+                {
+                    let (_, f) = &**this.store;
+                    let fut = f(this.cfg.take().unwrap(), svc);
+                    this.state.set(State::C { fut });
                 }
-            },
-            StateProj::B { svc } => match svc.poll_ready(cx)? {
-                Poll::Ready(_) => {
-                    {
-                        let (_, f) = &mut *this.store.borrow_mut();
-                        let fut = f(this.cfg.take().unwrap(), svc);
-                        this.state.set(State::C { fut });
-                    }
-                    self.poll(cx)
-                }
-                Poll::Pending => Poll::Pending,
-            },
+                self.poll(cx)
+            }
             StateProj::C { fut } => fut.poll(cx),
         }
     }

actix-service/src/boxed.rs

@@ -131,11 +131,11 @@ where
     type Error = Err;
     type Future = BoxFuture<Result<Res, Err>>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.0.poll_ready(ctx)
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         Box::pin(self.0.call(req))
     }
 }

actix-service/src/fn_service.rs

@@ -7,7 +7,7 @@ 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,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     FnServiceFactory::new(f)
@@ -17,7 +17,7 @@ where
 ///
 /// # Example
 ///
-/// ```rust
+/// ```
 /// use std::io;
 /// use actix_service::{fn_factory, fn_service, Service, ServiceFactory};
 /// use futures_util::future::ok;
@@ -39,7 +39,7 @@ where
 ///     });
 ///
 ///     // construct new service
-///     let mut srv = factory.new_service(()).await?;
+///     let srv = factory.new_service(()).await?;
 ///
 ///     // now we can use `div` service
 ///     let result = srv.call((10, 20)).await?;
@@ -67,7 +67,7 @@ where
 ///
 /// # Example
 ///
-/// ```rust
+/// ```
 /// use std::io;
 /// use actix_service::{fn_factory_with_config, fn_service, Service, ServiceFactory};
 /// use futures_util::future::ok;
@@ -81,7 +81,7 @@ where
 ///     });
 ///
 ///     // construct new service with config argument
-///     let mut srv = factory.new_service(10).await?;
+///     let srv = factory.new_service(10).await?;
 ///
 ///     let result = srv.call(10).await?;
 ///     assert_eq!(result, 100);
@@ -132,7 +132,7 @@ where
 
 impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err>
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -141,14 +141,14 @@ where
 
     crate::always_ready!();
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
 impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>, Req> for F
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn into_service(self) -> FnService<F, Fut, Req, Res, Err> {
@@ -158,7 +158,7 @@ where
 
 pub struct FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     f: F,
@@ -167,7 +167,7 @@ where
 
 impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn new(f: F) -> Self {
@@ -177,7 +177,7 @@ where
 
 impl<F, Fut, Req, Res, Err, Cfg> Clone for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -187,7 +187,7 @@ where
 
 impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -196,7 +196,7 @@ where
 
     crate::always_ready!();
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
@@ -204,7 +204,7 @@ where
 impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req>
     for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -318,8 +318,8 @@ where
 {
     type Response = Srv::Response;
     type Error = Srv::Error;
-    type Service = Srv;
     type Config = Cfg;
+    type Service = Srv;
     type InitError = Err;
     type Future = Fut;
 
@@ -364,7 +364,7 @@ mod tests {
     async fn test_fn_service() {
         let new_srv = fn_service(|()| ok::<_, ()>("srv"));
 
-        let mut srv = new_srv.new_service(()).await.unwrap();
+        let 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());
@@ -373,7 +373,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_fn_service_service() {
-        let mut srv = fn_service(|()| ok::<_, ()>("srv"));
+        let srv = fn_service(|()| ok::<_, ()>("srv"));
 
         let res = srv.call(()).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
@@ -387,7 +387,7 @@ mod tests {
             ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg))))
         });
 
-        let mut srv = new_srv.new_service(1).await.unwrap();
+        let 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());

actix-service/src/lib.rs

@@ -48,7 +48,7 @@ use self::ready::{err, ok, ready, Ready};
 /// 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
+/// ```ignore
 /// async fn(Request) -> Result<Response, Err>
 /// ```
 ///
@@ -60,7 +60,7 @@ use self::ready::{err, ok, ready, Ready};
 /// simple API surfaces. This leads to simpler design of each service, improves test-ability and
 /// makes composition easier.
 ///
-/// ```rust,ignore
+/// ```ignore
 /// struct MyService;
 ///
 /// impl Service for MyService {
@@ -69,16 +69,16 @@ use self::ready::{err, ok, ready, Ready};
 ///      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 poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
 ///
-///      fn call(&mut self, req: Self::Request) -> Self::Future { ... }
+///      fn call(&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_service()).
 ///
-/// ```rust,ignore
+/// ```ignore
 /// async fn my_service(req: u8) -> Result<u64, MyError>;
 /// ```
 pub trait Service<Req> {
@@ -102,9 +102,9 @@ pub trait Service<Req> {
     /// 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>>;
+    /// 1. `poll_ready` might be called on a different task to `call`.
+    /// 1. In cases of chained services, `.poll_ready()` is called for all services at once.
+    fn poll_ready(&self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Process the request and return the response asynchronously.
     ///
@@ -115,7 +115,7 @@ pub trait Service<Req> {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Req) -> Self::Future;
+    fn call(&self, req: Req) -> Self::Future;
 }
 
 /// Factory for creating `Service`s.
@@ -158,11 +158,11 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
@@ -175,11 +175,11 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
@@ -192,12 +192,12 @@ where
     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 poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.borrow().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
-        self.borrow_mut().call(request)
+    fn call(&self, request: Req) -> S::Future {
+        self.borrow().call(request)
     }
 }
 
@@ -209,12 +209,12 @@ where
     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 poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.borrow().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
-        (&mut (**self).borrow_mut()).call(request)
+    fn call(&self, request: Req) -> S::Future {
+        self.borrow().call(request)
     }
 }
 
@@ -311,8 +311,9 @@ pub mod dev {
 #[macro_export]
 macro_rules! always_ready {
     () => {
+        #[inline]
         fn poll_ready(
-            &mut self,
+            &self,
             _: &mut ::core::task::Context<'_>,
         ) -> ::core::task::Poll<Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
@@ -323,11 +324,14 @@ macro_rules! always_ready {
 #[macro_export]
 macro_rules! forward_ready {
     ($field:ident) => {
+        #[inline]
         fn poll_ready(
-            &mut self,
+            &self,
             cx: &mut ::core::task::Context<'_>,
         ) -> ::core::task::Poll<Result<(), Self::Error>> {
-            self.$field.poll_ready(cx)
+            self.$field
+                .poll_ready(cx)
+                .map_err(::core::convert::Into::into)
         }
     };
 }

actix-service/src/map.rs

@@ -58,7 +58,7 @@ where
 
     crate::forward_ready!(service);
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
@@ -215,21 +215,21 @@ mod tests {
 
         crate::always_ready!();
 
-        fn call(&mut self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future {
             ok(())
         }
     }
 
     #[actix_rt::test]
     async fn test_poll_ready() {
-        let mut srv = Srv.map(|_| "ok");
+        let 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 srv = Srv.map(|_| "ok");
         let res = srv.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), "ok");
@@ -238,7 +238,7 @@ mod tests {
     #[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 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

@@ -6,7 +6,7 @@ use super::{IntoServiceFactory, ServiceFactory};
 ///
 /// Note that this function consumes the receiving service factory and returns
 /// a wrapped version of it.
-pub fn map_config<I, SF, S, Req, F, Cfg>(factory: I, f: F) -> MapConfig<SF, Req, F, Cfg>
+pub fn map_config<I, SF, Req, F, Cfg>(factory: I, f: F) -> MapConfig<SF, Req, F, Cfg>
 where
     I: IntoServiceFactory<SF, Req>,
     SF: ServiceFactory<Req>,

actix-service/src/map_err.rs

@@ -57,11 +57,11 @@ where
     type Error = E;
     type Future = MapErrFuture<A, Req, F, E>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(&self.f)
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
@@ -218,25 +218,25 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             Poll::Ready(Err(()))
         }
 
-        fn call(&mut self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future {
             err(())
         }
     }
 
     #[actix_rt::test]
     async fn test_poll_ready() {
-        let mut srv = Srv.map_err(|_| "error");
+        let 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 srv = Srv.map_err(|_| "error");
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
@@ -245,7 +245,7 @@ mod tests {
     #[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 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/pipeline.rs

@@ -146,12 +146,12 @@ impl<S: Service<Req>, Req> Service<Req> for Pipeline<S, Req> {
     type Future = S::Future;
 
     #[inline]
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         self.service.poll_ready(ctx)
     }
 
     #[inline]
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         self.service.call(req)
     }
 }

actix-service/src/then.rs

@@ -1,12 +1,12 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 /// another service.
 ///
 /// This is created by the `Pipeline::then` method.
-pub(crate) struct ThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
+pub(crate) struct ThenService<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
 impl<A, B, Req> ThenService<A, B, Req> {
     /// Create new `.then()` combinator
@@ -24,7 +24,7 @@ impl<A, B, Req> ThenService<A, B, Req> {
         A: Service<Req>,
         B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))), PhantomData)
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
@@ -43,20 +43,20 @@ where
     type Error = B::Error;
     type Future = ThenServiceResponse<A, B, Req>;
 
-    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 {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let (a, b) = &*self.0;
+        let not_ready = !a.poll_ready(cx)?.is_ready();
+        if !b.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         ThenServiceResponse {
             state: State::A {
-                fut: self.0.borrow_mut().0.call(req),
+                fut: self.0 .0.call(req),
                 b: Some(self.0.clone()),
             },
         }
@@ -81,9 +81,8 @@ pin_project! {
         A: Service<Req>,
         B: Service<Result<A::Response, A::Error>>,
     {
-        A { #[pin] fut: A::Future, b: Option<Rc<RefCell<(A, B)>>> },
+        A { #[pin] fut: A::Future, b: Option<Rc<(A, B)>> },
         B { #[pin] fut: B::Future },
-        Empty,
     }
 }
 
@@ -98,23 +97,14 @@ where
         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`")
+            StateProj::A { fut, b } => {
+                let res = ready!(fut.poll(cx));
+                let b = b.take().unwrap();
+                let fut = b.1.call(res);
+                this.state.set(State::B { fut });
+                self.poll(cx)
             }
+            StateProj::B { fut } => fut.poll(cx),
         }
     }
 }
@@ -266,12 +256,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, Self::Error>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&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 {
+        fn call(&self, req: Result<&'static str, &'static str>) -> Self::Future {
             match req {
                 Ok(msg) => ok(msg),
                 Err(_) => err(()),
@@ -286,12 +276,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&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 {
+        fn call(&self, req: Result<&'static str, ()>) -> Self::Future {
             match req {
                 Ok(msg) => ok((msg, "ok")),
                 Err(()) => ok(("srv2", "err")),
@@ -302,7 +292,7 @@ mod tests {
     #[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 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);
@@ -311,7 +301,7 @@ mod tests {
     #[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 srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt));
 
         let res = srv.call(Ok("srv1")).await;
         assert!(res.is_ok());
@@ -328,7 +318,7 @@ mod tests {
         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 srv = factory.new_service(&()).await.unwrap();
         let res = srv.call(Ok("srv1")).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv1", "ok"));

actix-service/src/transform.rs

@@ -6,6 +6,7 @@ use core::{
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use crate::transform_err::TransformMapInitErr;
@@ -30,7 +31,7 @@ where
 ///
 /// For example, timeout transform:
 ///
-/// ```rust,ignore
+/// ```ignore
 /// pub struct Timeout<S> {
 ///     service: S,
 ///     timeout: Duration,
@@ -45,11 +46,9 @@ where
 ///     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)
-///     }
+///     actix_service::forward_ready!(service);
 ///
-///     fn call(&mut self, req: S::Request) -> Self::Future {
+///     fn call(&self, req: S::Request) -> Self::Future {
 ///         TimeoutServiceResponse {
 ///             fut: self.service.call(req),
 ///             sleep: Delay::new(clock::now() + self.timeout),
@@ -69,7 +68,7 @@ where
 ///
 /// Factory for `Timeout` middleware from the above example could look like this:
 ///
-/// ```rust,,ignore
+/// ```ignore
 /// pub struct TimeoutTransform {
 ///     timeout: Duration,
 /// }
@@ -129,8 +128,8 @@ where
 {
     type Response = T::Response;
     type Error = T::Error;
-    type InitError = T::InitError;
     type Transform = T::Transform;
+    type InitError = T::InitError;
     type Future = T::Future;
 
     fn new_transform(&self, service: S) -> T::Future {
@@ -144,8 +143,8 @@ where
 {
     type Response = T::Response;
     type Error = T::Error;
-    type InitError = T::InitError;
     type Transform = T::Transform;
+    type InitError = T::InitError;
     type Future = T::Future;
 
     fn new_transform(&self, service: S) -> T::Future {
@@ -231,14 +230,12 @@ where
         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::A { fut } => {
+                let srv = ready!(fut.poll(cx))?;
+                let fut = this.store.0.new_transform(srv);
+                this.state.set(ApplyTransformFutureState::B { fut });
+                self.poll(cx)
+            }
             ApplyTransformFutureStateProj::B { fut } => fut.poll(cx),
         }
     }

actix-testing/CHANGES.md

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

@@ -1,27 +0,0 @@
-[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/README.md

@@ -1,9 +0,0 @@
-# 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-threadpool/CHANGES.md

@@ -1,49 +0,0 @@
-# Changes
-
-## [0.3.3] - 2020-07-14
-
-### Changed
-
-* Update parking_lot to 0.11
-
-## [0.3.2] - 2020-05-20
-
-## Added
-
-* Implement `std::error::Error` for `BlockingError` [#120]
-
-[#120]: https://github.com/actix/actix-net/pull/120
-
-## [0.3.1] - 2019-12-12
-
-### Changed
-
-* Update parking_lot to 0.10
-
-## [0.3.0] - 2019-12-02
-
-### Changed
-
-* Expect `Result` type as a function return type
-
-## [0.2.0] - 2019-11-21
-
-### Changed
-
-* Migrate to `std::future`
-
-## [0.1.2] - 2019-08-05
-
-### Changed
-
-* Update `derive_more` to 0.15
-
-* Update `parking_lot` to 0.9
-
-## [0.1.1] - 2019-06-05
-
-* Update parking_lot
-
-## [0.1.0] - 2019-03-28
-
-* Move threadpool to separate crate

actix-threadpool/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "actix-threadpool"
-version = "0.3.3"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix thread pool for sync code"
-keywords = ["actix", "network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-threadpool/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT OR Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_threadpool"
-path = "src/lib.rs"
-
-[dependencies]
-derive_more = "0.99.2"
-futures-channel = "0.3.1"
-parking_lot = "0.11"
-lazy_static = "1.3"
-log = "0.4"
-num_cpus = "1.10"
-threadpool = "1.7"

actix-threadpool/LICENSE-APACHE

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

actix-threadpool/LICENSE-MIT

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

actix-threadpool/src/lib.rs

@@ -1,96 +0,0 @@
-//! Thread pool for blocking operations
-
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
-#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-
-use std::fmt;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use derive_more::Display;
-use futures_channel::oneshot;
-use parking_lot::Mutex;
-use threadpool::ThreadPool;
-
-/// Env variable for default cpu pool size.
-const ENV_CPU_POOL_VAR: &str = "ACTIX_THREADPOOL";
-
-lazy_static::lazy_static! {
-    pub(crate) static ref DEFAULT_POOL: Mutex<ThreadPool> = {
-        let num = std::env::var(ENV_CPU_POOL_VAR)
-            .map_err(|_| ())
-            .and_then(|val| {
-                val.parse().map_err(|_| log::warn!(
-                    "Can not parse {} value, using default",
-                    ENV_CPU_POOL_VAR,
-                ))
-            })
-            .unwrap_or_else(|_| num_cpus::get() * 5);
-        Mutex::new(
-            threadpool::Builder::new()
-                .thread_name("actix-web".to_owned())
-                .num_threads(num)
-                .build(),
-        )
-    };
-}
-
-thread_local! {
-    static POOL: ThreadPool = {
-        DEFAULT_POOL.lock().clone()
-    };
-}
-
-/// Blocking operation execution error
-#[derive(Debug, Display)]
-pub enum BlockingError<E: fmt::Debug> {
-    #[display(fmt = "{:?}", _0)]
-    Error(E),
-    #[display(fmt = "Thread pool is gone")]
-    Canceled,
-}
-
-impl<E: fmt::Debug> std::error::Error for BlockingError<E> {}
-
-/// Execute blocking function on a thread pool, returns future that resolves
-/// to result of the function execution.
-pub fn run<F, I, E>(f: F) -> CpuFuture<I, E>
-where
-    F: FnOnce() -> Result<I, E> + Send + 'static,
-    I: Send + 'static,
-    E: Send + fmt::Debug + 'static,
-{
-    let (tx, rx) = oneshot::channel();
-    POOL.with(|pool| {
-        pool.execute(move || {
-            if !tx.is_canceled() {
-                let _ = tx.send(f());
-            }
-        })
-    });
-
-    CpuFuture { rx }
-}
-
-/// Blocking operation completion future. It resolves with results
-/// of blocking function execution.
-pub struct CpuFuture<I, E> {
-    rx: oneshot::Receiver<Result<I, E>>,
-}
-
-impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
-    type Output = Result<I, BlockingError<E>>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let rx = Pin::new(&mut self.rx);
-        let res = match rx.poll(cx) {
-            Poll::Pending => return Poll::Pending,
-            Poll::Ready(res) => res
-                .map_err(|_| BlockingError::Canceled)
-                .and_then(|res| res.map_err(BlockingError::Error)),
-        };
-        Poll::Ready(res)
-    }
-}

actix-tls/CHANGES.md

@@ -1,6 +1,44 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 3.0.0-beta.4 - 2021-02-24
+* Rename `accept::openssl::{SslStream => TlsStream}`.
+* Add `connect::Connect::set_local_addr` to attach local `IpAddr`. [#282]
+* `connector::TcpConnector` service will try to bind to local_addr of `IpAddr` when given. [#282]
+
+[#282]: https://github.com/actix/actix-net/pull/282
+
+
+## 3.0.0-beta.3 - 2021-02-06
+* Remove `trust-dns-proto` and `trust-dns-resolver`. [#248]
+* Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248]
+* Add `Resolve` trait for custom DNS resolvers. [#248]
+* Add `Resolver::new_custom` function to construct custom resolvers. [#248]
+* Export `webpki_roots::TLS_SERVER_ROOTS` in `actix_tls::connect` mod and remove
+  the export from `actix_tls::accept` [#248]
+* Remove `ConnectTakeAddrsIter`. `Connect::take_addrs` now returns `ConnectAddrsIter<'static>`
+  as owned iterator. [#248]
+* Rename `Address::{host => hostname}` to more accurately describe which URL segment is returned.
+* Update `actix-rt` to `2.0.0`. [#273]
+
+[#248]: https://github.com/actix/actix-net/pull/248
+[#273]: https://github.com/actix/actix-net/pull/273
+
+
+## 3.0.0-beta.2 - 2021-xx-xx
+* Depend on stable trust-dns packages. [#204]
+
+[#204]: https://github.com/actix/actix-net/pull/204
+
+
+## 3.0.0-beta.1 - 2020-12-29
+* Move acceptors under `accept` module. [#238]
+* Merge `actix-connect` crate under `connect` module. [#238]
+* Add feature flags to enable acceptors and/or connectors individually. [#238]
+
+[#238]: https://github.com/actix/actix-net/pull/238
 
 
 ## 2.0.0 - 2020-09-03

actix-tls/Cargo.toml

@@ -1,64 +1,82 @@
 [package]
 name = "actix-tls"
-version = "2.0.0"
+version = "3.0.0-beta.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "TLS acceptor services for Actix ecosystem."
-keywords = ["network", "framework", "async", "tls", "ssl"]
+description = "TLS acceptor and connector services for Actix ecosystem"
+keywords = ["network", "tls", "ssl", "async", "transport"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-tls/"
+documentation = "https://docs.rs/actix-tls"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "nativetls"]
+features = ["openssl", "rustls", "native-tls", "accept", "connect", "uri"]
 
 [lib]
 name = "actix_tls"
 path = "src/lib.rs"
 
-[[example]]
-name = "basic"
-required-features = ["rustls"]
-
 [features]
-default = []
+default = ["accept", "connect", "uri"]
 
-# openssl
-openssl = ["open-ssl", "tokio-openssl"]
+# enable acceptor services
+accept = []
 
-# rustls
-rustls = ["rust-tls", "webpki", "webpki-roots", "tokio-rustls"]
+# enable connector services
+connect = []
 
-# nativetls
-nativetls = ["native-tls", "tokio-tls"]
+# use openssl impls
+openssl = ["tls-openssl", "tokio-openssl"]
+
+# use rustls impls
+rustls = ["tokio-rustls", "webpki-roots"]
+
+# use native-tls impls
+native-tls = ["tokio-native-tls"]
+
+# support http::Uri as connect address
+uri = ["http"]
 
 [dependencies]
-actix-service = "1.0.0"
-actix-codec = "0.3.0"
-actix-utils = "2.0.0"
+actix-codec = "0.4.0-beta.1"
+actix-rt = { version = "2.1.0", default-features = false }
+actix-service = "2.0.0-beta.4"
+actix-utils = "3.0.0-beta.2"
 
-futures-util = { version = "0.3.4", default-features = false }
+derive_more = "0.99.5"
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+http = { version = "0.2.3", optional = true }
+log = "0.4"
+tokio-util = { version = "0.6.3", default-features = false }
 
 # openssl
-open-ssl = { package = "openssl", version = "0.10", optional = true }
-tokio-openssl = { version = "0.4.0", optional = true }
+tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
+tokio-openssl = { version = "0.6", optional = true }
 
 # rustls
-rust-tls = { package = "rustls", version = "0.18.0", optional = true }
-webpki = { version = "0.21", optional = true }
-webpki-roots = { version = "0.20", optional = true }
-tokio-rustls = { version = "0.14.0", optional = true }
+tokio-rustls = { version = "0.22", optional = true }
+webpki-roots = { version = "0.21", optional = true }
 
 # native-tls
-native-tls = { version = "0.2", optional = true }
-tokio-tls = { version = "0.3", optional = true }
+tokio-native-tls = { version = "0.3", optional = true }
+
+[target.'cfg(windows)'.dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+optional = true
 
 [dev-dependencies]
-bytes = "0.5"
+actix-rt = "2.1.0"
+actix-server = "2.0.0-beta.3"
+bytes = "1"
+env_logger = "0.8"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
 log = "0.4"
-env_logger = "0.7"
-actix-testing = "1.0.0"
-actix-server = "1"
-actix-rt = "1"
+trust-dns-resolver = "0.20.0"
+
+[[example]]
+name = "tcp-rustls"
+required-features = ["accept", "rustls"]

actix-tls/examples/tcp-rustls.rs

@@ -15,6 +15,10 @@
 //! http --verify=false https://127.0.0.1:8443
 //! ```
 
+// this use only exists because of how we have organised the crate
+// it is not necessary for your actual code
+use tokio_rustls::rustls;
+
 use std::{
     env,
     fs::File,
@@ -25,12 +29,13 @@ use std::{
     },
 };
 
+use actix_rt::net::TcpStream;
 use actix_server::Server;
 use actix_service::pipeline_factory;
-use actix_tls::rustls::Acceptor as RustlsAcceptor;
+use actix_tls::accept::rustls::{Acceptor as RustlsAcceptor, TlsStream};
 use futures_util::future::ok;
 use log::info;
-use rust_tls::{
+use rustls::{
     internal::pemfile::certs, internal::pemfile::rsa_private_keys, NoClientAuth, ServerConfig,
 };
 
@@ -70,9 +75,9 @@ async fn main() -> io::Result<()> {
             // Set up TLS service factory
             pipeline_factory(tls_acceptor.clone())
                 .map_err(|err| println!("Rustls error: {:?}", err))
-                .and_then(move |stream| {
+                .and_then(move |stream: TlsStream<TcpStream>| {
                     let num = count.fetch_add(1, Ordering::Relaxed);
-                    info!("[{}] Got TLS connection: {:?}", num, stream);
+                    info!("[{}] Got TLS connection: {:?}", num, &*stream);
                     ok(())
                 })
         })?

actix-tls/src/accept/mod.rs

@@ -0,0 +1,42 @@
+//! TLS acceptor services for Actix ecosystem.
+//!
+//! ## Crate Features
+//! * `openssl` - TLS acceptor using the `openssl` crate.
+//! * `rustls` - TLS acceptor using the `rustls` crate.
+//! * `native-tls` - TLS acceptor using the `native-tls` crate.
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use actix_utils::counter::Counter;
+
+#[cfg(feature = "openssl")]
+pub mod openssl;
+
+#[cfg(feature = "rustls")]
+pub mod rustls;
+
+#[cfg(feature = "native-tls")]
+pub mod nativetls;
+
+pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256);
+
+thread_local! {
+    static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed));
+}
+
+/// Sets the maximum per-worker concurrent TLS connection limit.
+///
+/// All listeners will stop accepting connections when this limit is reached.
+/// It can be used to regulate the global TLS CPU usage.
+///
+/// By default, the connection limit is 256.
+pub fn max_concurrent_tls_connect(num: usize) {
+    MAX_CONN.store(num, Ordering::Relaxed);
+}
+
+/// TLS error combined with service error.
+#[derive(Debug)]
+pub enum TlsError<E1, E2> {
+    Tls(E1),
+    Service(E2),
+}

actix-tls/src/accept/nativetls.rs

@@ -0,0 +1,172 @@
+use std::{
+    io::{self, IoSlice},
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
+use actix_rt::net::ActixStream;
+use actix_service::{Service, ServiceFactory};
+use actix_utils::counter::Counter;
+use futures_core::future::LocalBoxFuture;
+
+pub use tokio_native_tls::native_tls::Error;
+pub use tokio_native_tls::TlsAcceptor;
+
+use super::MAX_CONN_COUNTER;
+
+/// Wrapper type for `tokio_native_tls::TlsStream` in order to impl `ActixStream` trait.
+pub struct TlsStream<T>(tokio_native_tls::TlsStream<T>);
+
+impl<T> From<tokio_native_tls::TlsStream<T>> for TlsStream<T> {
+    fn from(stream: tokio_native_tls::TlsStream<T>) -> Self {
+        Self(stream)
+    }
+}
+
+impl<T: ActixStream> Deref for TlsStream<T> {
+    type Target = tokio_native_tls::TlsStream<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: ActixStream> DerefMut for TlsStream<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: ActixStream> AsyncRead for TlsStream<T> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
+    }
+}
+
+impl<T: ActixStream> AsyncWrite for TlsStream<T> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_flush(cx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        (&**self).is_write_vectored()
+    }
+}
+
+impl<T: ActixStream> ActixStream for TlsStream<T> {
+    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_read_ready((&**self).get_ref().get_ref().get_ref(), cx)
+    }
+
+    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_write_ready((&**self).get_ref().get_ref().get_ref(), cx)
+    }
+}
+
+/// Accept TLS connections via `native-tls` package.
+///
+/// `native-tls` feature enables this `Acceptor` type.
+pub struct Acceptor {
+    acceptor: TlsAcceptor,
+}
+
+impl Acceptor {
+    /// Create `native-tls` based `Acceptor` service factory.
+    #[inline]
+    pub fn new(acceptor: TlsAcceptor) -> Self {
+        Acceptor { acceptor }
+    }
+}
+
+impl Clone for Acceptor {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+        }
+    }
+}
+
+impl<T: ActixStream> ServiceFactory<T> for Acceptor {
+    type Response = TlsStream<T>;
+    type Error = Error;
+    type Config = ();
+
+    type Service = NativeTlsAcceptorService;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let res = MAX_CONN_COUNTER.with(|conns| {
+            Ok(NativeTlsAcceptorService {
+                acceptor: self.acceptor.clone(),
+                conns: conns.clone(),
+            })
+        });
+        Box::pin(async { res })
+    }
+}
+
+pub struct NativeTlsAcceptorService {
+    acceptor: TlsAcceptor,
+    conns: Counter,
+}
+
+impl Clone for NativeTlsAcceptorService {
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+            conns: self.conns.clone(),
+        }
+    }
+}
+
+impl<T: ActixStream> Service<T> for NativeTlsAcceptorService {
+    type Response = TlsStream<T>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<TlsStream<T>, Error>>;
+
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.conns.available(cx) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn call(&self, io: T) -> Self::Future {
+        let guard = self.conns.get();
+        let this = self.clone();
+        Box::pin(async move {
+            let io = this.acceptor.accept(io).await;
+            drop(guard);
+            io.map(Into::into)
+        })
+    }
+}

actix-tls/src/accept/openssl.rs

@@ -0,0 +1,181 @@
+use std::{
+    future::Future,
+    io::{self, IoSlice},
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
+use actix_rt::net::ActixStream;
+use actix_service::{Service, ServiceFactory};
+use actix_utils::counter::{Counter, CounterGuard};
+use futures_core::{future::LocalBoxFuture, ready};
+
+pub use openssl::ssl::{
+    AlpnError, Error as SslError, HandshakeError, Ssl, SslAcceptor, SslAcceptorBuilder,
+};
+
+use super::MAX_CONN_COUNTER;
+
+/// Wrapper type for `tokio_openssl::SslStream` in order to impl `ActixStream` trait.
+pub struct TlsStream<T>(tokio_openssl::SslStream<T>);
+
+impl<T> From<tokio_openssl::SslStream<T>> for TlsStream<T> {
+    fn from(stream: tokio_openssl::SslStream<T>) -> Self {
+        Self(stream)
+    }
+}
+
+impl<T> Deref for TlsStream<T> {
+    type Target = tokio_openssl::SslStream<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for TlsStream<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: ActixStream> AsyncRead for TlsStream<T> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
+    }
+}
+
+impl<T: ActixStream> AsyncWrite for TlsStream<T> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_flush(cx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        (&**self).is_write_vectored()
+    }
+}
+
+impl<T: ActixStream> ActixStream for TlsStream<T> {
+    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_read_ready((&**self).get_ref(), cx)
+    }
+
+    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_write_ready((&**self).get_ref(), cx)
+    }
+}
+
+/// Accept TLS connections via `openssl` package.
+///
+/// `openssl` feature enables this `Acceptor` type.
+pub struct Acceptor {
+    acceptor: SslAcceptor,
+}
+
+impl Acceptor {
+    /// Create OpenSSL based `Acceptor` service factory.
+    #[inline]
+    pub fn new(acceptor: SslAcceptor) -> Self {
+        Acceptor { acceptor }
+    }
+}
+
+impl Clone for Acceptor {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+        }
+    }
+}
+
+impl<T: ActixStream> ServiceFactory<T> for Acceptor {
+    type Response = TlsStream<T>;
+    type Error = SslError;
+    type Config = ();
+    type Service = AcceptorService;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let res = MAX_CONN_COUNTER.with(|conns| {
+            Ok(AcceptorService {
+                acceptor: self.acceptor.clone(),
+                conns: conns.clone(),
+            })
+        });
+        Box::pin(async { res })
+    }
+}
+
+pub struct AcceptorService {
+    acceptor: SslAcceptor,
+    conns: Counter,
+}
+
+impl<T: ActixStream> Service<T> for AcceptorService {
+    type Response = TlsStream<T>;
+    type Error = SslError;
+    type Future = AcceptorServiceResponse<T>;
+
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.conns.available(ctx) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn call(&self, io: T) -> Self::Future {
+        let ssl_ctx = self.acceptor.context();
+        let ssl = Ssl::new(ssl_ctx).expect("Provided SSL acceptor was invalid.");
+        AcceptorServiceResponse {
+            _guard: self.conns.get(),
+            stream: Some(tokio_openssl::SslStream::new(ssl, io).unwrap()),
+        }
+    }
+}
+
+pub struct AcceptorServiceResponse<T: ActixStream> {
+    stream: Option<tokio_openssl::SslStream<T>>,
+    _guard: CounterGuard,
+}
+
+impl<T: ActixStream> Future for AcceptorServiceResponse<T> {
+    type Output = Result<TlsStream<T>, SslError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        ready!(Pin::new(self.stream.as_mut().unwrap()).poll_accept(cx))?;
+        Poll::Ready(Ok(self
+            .stream
+            .take()
+            .expect("SSL connect has resolved.")
+            .into()))
+    }
+}

actix-tls/src/accept/rustls.rs

@@ -0,0 +1,179 @@
+use std::{
+    future::Future,
+    io::{self, IoSlice},
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
+use actix_rt::net::ActixStream;
+use actix_service::{Service, ServiceFactory};
+use actix_utils::counter::{Counter, CounterGuard};
+use futures_core::future::LocalBoxFuture;
+use tokio_rustls::{Accept, TlsAcceptor};
+
+pub use tokio_rustls::rustls::{ServerConfig, Session};
+
+use super::MAX_CONN_COUNTER;
+
+/// Wrapper type for `tokio_openssl::SslStream` in order to impl `ActixStream` trait.
+pub struct TlsStream<T>(tokio_rustls::server::TlsStream<T>);
+
+impl<T> From<tokio_rustls::server::TlsStream<T>> for TlsStream<T> {
+    fn from(stream: tokio_rustls::server::TlsStream<T>) -> Self {
+        Self(stream)
+    }
+}
+
+impl<T> Deref for TlsStream<T> {
+    type Target = tokio_rustls::server::TlsStream<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for TlsStream<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: ActixStream> AsyncRead for TlsStream<T> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
+    }
+}
+
+impl<T: ActixStream> AsyncWrite for TlsStream<T> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_flush(cx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        (&**self).is_write_vectored()
+    }
+}
+
+impl<T: ActixStream> ActixStream for TlsStream<T> {
+    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_read_ready((&**self).get_ref().0, cx)
+    }
+
+    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        T::poll_write_ready((&**self).get_ref().0, cx)
+    }
+}
+
+/// Accept TLS connections via `rustls` package.
+///
+/// `rustls` feature enables this `Acceptor` type.
+pub struct Acceptor {
+    config: Arc<ServerConfig>,
+}
+
+impl Acceptor {
+    /// Create Rustls based `Acceptor` service factory.
+    #[inline]
+    pub fn new(config: ServerConfig) -> Self {
+        Acceptor {
+            config: Arc::new(config),
+        }
+    }
+}
+
+impl Clone for Acceptor {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            config: self.config.clone(),
+        }
+    }
+}
+
+impl<T: ActixStream> ServiceFactory<T> for Acceptor {
+    type Response = TlsStream<T>;
+    type Error = io::Error;
+    type Config = ();
+
+    type Service = AcceptorService;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let res = MAX_CONN_COUNTER.with(|conns| {
+            Ok(AcceptorService {
+                acceptor: self.config.clone().into(),
+                conns: conns.clone(),
+            })
+        });
+        Box::pin(async { res })
+    }
+}
+
+/// Rustls based `Acceptor` service
+pub struct AcceptorService {
+    acceptor: TlsAcceptor,
+    conns: Counter,
+}
+
+impl<T: ActixStream> Service<T> for AcceptorService {
+    type Response = TlsStream<T>;
+    type Error = io::Error;
+    type Future = AcceptorServiceFut<T>;
+
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.conns.available(cx) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn call(&self, req: T) -> Self::Future {
+        AcceptorServiceFut {
+            _guard: self.conns.get(),
+            fut: self.acceptor.accept(req),
+        }
+    }
+}
+
+pub struct AcceptorServiceFut<T: ActixStream> {
+    fut: Accept<T>,
+    _guard: CounterGuard,
+}
+
+impl<T: ActixStream> Future for AcceptorServiceFut<T> {
+    type Output = Result<TlsStream<T>, io::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+        Pin::new(&mut this.fut).poll(cx).map_ok(TlsStream)
+    }
+}

actix-tls/src/connect/connect.rs

@@ -0,0 +1,350 @@
+use std::{
+    collections::{vec_deque, VecDeque},
+    fmt,
+    iter::{self, FromIterator as _},
+    mem,
+    net::{IpAddr, SocketAddr},
+};
+
+/// Parse a host into parts (hostname and port).
+pub trait Address: Unpin + 'static {
+    /// Get hostname part.
+    fn hostname(&self) -> &str;
+
+    /// Get optional port part.
+    fn port(&self) -> Option<u16> {
+        None
+    }
+}
+
+impl Address for String {
+    fn hostname(&self) -> &str {
+        &self
+    }
+}
+
+impl Address for &'static str {
+    fn hostname(&self) -> &str {
+        self
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub(crate) enum ConnectAddrs {
+    None,
+    One(SocketAddr),
+    Multi(VecDeque<SocketAddr>),
+}
+
+impl ConnectAddrs {
+    pub(crate) fn is_none(&self) -> bool {
+        matches!(self, Self::None)
+    }
+
+    pub(crate) fn is_some(&self) -> bool {
+        !self.is_none()
+    }
+}
+
+impl Default for ConnectAddrs {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+impl From<Option<SocketAddr>> for ConnectAddrs {
+    fn from(addr: Option<SocketAddr>) -> Self {
+        match addr {
+            Some(addr) => ConnectAddrs::One(addr),
+            None => ConnectAddrs::None,
+        }
+    }
+}
+
+/// Connection info.
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct Connect<T> {
+    pub(crate) req: T,
+    pub(crate) port: u16,
+    pub(crate) addr: ConnectAddrs,
+    pub(crate) local_addr: Option<IpAddr>,
+}
+
+impl<T: Address> Connect<T> {
+    /// Create `Connect` instance by splitting the string by ':' and convert the second part to u16
+    pub fn new(req: T) -> Connect<T> {
+        let (_, port) = parse_host(req.hostname());
+
+        Connect {
+            req,
+            port: port.unwrap_or(0),
+            addr: ConnectAddrs::None,
+            local_addr: None,
+        }
+    }
+
+    /// Create new `Connect` instance from host and address. Connector skips name resolution stage
+    /// for such connect messages.
+    pub fn with_addr(req: T, addr: SocketAddr) -> Connect<T> {
+        Connect {
+            req,
+            port: 0,
+            addr: ConnectAddrs::One(addr),
+            local_addr: None,
+        }
+    }
+
+    /// Use port if address does not provide one.
+    ///
+    /// Default value is 0.
+    pub fn set_port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    /// Set address.
+    pub fn set_addr(mut self, addr: Option<SocketAddr>) -> Self {
+        self.addr = ConnectAddrs::from(addr);
+        self
+    }
+
+    /// Set list of 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 {
+            ConnectAddrs::from(addrs.pop_front())
+        } else {
+            ConnectAddrs::Multi(addrs)
+        };
+        self
+    }
+
+    /// Set local_addr of connect.
+    pub fn set_local_addr(mut self, addr: impl Into<IpAddr>) -> Self {
+        self.local_addr = Some(addr.into());
+        self
+    }
+
+    /// Get hostname.
+    pub fn hostname(&self) -> &str {
+        self.req.hostname()
+    }
+
+    /// Get request port.
+    pub fn port(&self) -> u16 {
+        self.req.port().unwrap_or(self.port)
+    }
+
+    /// Get resolved request addresses.
+    pub fn addrs(&self) -> ConnectAddrsIter<'_> {
+        match self.addr {
+            ConnectAddrs::None => ConnectAddrsIter::None,
+            ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr),
+            ConnectAddrs::Multi(ref addrs) => ConnectAddrsIter::Multi(addrs.iter()),
+        }
+    }
+
+    /// Take resolved request addresses.
+    pub fn take_addrs(&mut self) -> ConnectAddrsIter<'static> {
+        match mem::take(&mut self.addr) {
+            ConnectAddrs::None => ConnectAddrsIter::None,
+            ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr),
+            ConnectAddrs::Multi(addrs) => ConnectAddrsIter::MultiOwned(addrs.into_iter()),
+        }
+    }
+}
+
+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.hostname(), self.port())
+    }
+}
+
+/// Iterator over addresses in a [`Connect`] request.
+#[derive(Clone)]
+pub enum ConnectAddrsIter<'a> {
+    None,
+    One(SocketAddr),
+    Multi(vec_deque::Iter<'a, SocketAddr>),
+    MultiOwned(vec_deque::IntoIter<SocketAddr>),
+}
+
+impl Iterator for ConnectAddrsIter<'_> {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match *self {
+            Self::None => None,
+            Self::One(addr) => {
+                *self = Self::None;
+                Some(addr)
+            }
+            Self::Multi(ref mut iter) => iter.next().copied(),
+            Self::MultiOwned(ref mut iter) => iter.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match *self {
+            Self::None => (0, Some(0)),
+            Self::One(_) => (1, Some(1)),
+            Self::Multi(ref iter) => iter.size_hint(),
+            Self::MultiOwned(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 iter::ExactSizeIterator for ConnectAddrsIter<'_> {}
+
+impl iter::FusedIterator for ConnectAddrsIter<'_> {}
+
+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_io<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 io_ref(&self) -> &U {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying stream.
+    pub fn io_mut(&mut self) -> &mut U {
+        &mut self.io
+    }
+}
+
+impl<T: Address, U> Connection<T, U> {
+    /// Get hostname.
+    pub fn host(&self) -> &str {
+        self.req.hostname()
+    }
+}
+
+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)
+    }
+}
+
+fn parse_host(host: &str) -> (&str, Option<u16>) {
+    let mut parts_iter = host.splitn(2, ':');
+
+    match parts_iter.next() {
+        Some(hostname) => {
+            let port_str = parts_iter.next().unwrap_or("");
+            let port = port_str.parse::<u16>().ok();
+            (hostname, port)
+        }
+
+        None => (host, None),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::net::Ipv4Addr;
+
+    use super::*;
+
+    #[test]
+    fn test_host_parser() {
+        assert_eq!(parse_host("example.com"), ("example.com", None));
+        assert_eq!(parse_host("example.com:8080"), ("example.com", Some(8080)));
+        assert_eq!(parse_host("example:8080"), ("example", Some(8080)));
+        assert_eq!(parse_host("example.com:false"), ("example.com", None));
+        assert_eq!(parse_host("example.com:false:false"), ("example.com", None));
+    }
+
+    #[test]
+    fn test_addr_iter_multi() {
+        let localhost = SocketAddr::from((IpAddr::from(Ipv4Addr::LOCALHOST), 8080));
+        let unspecified = SocketAddr::from((IpAddr::from(Ipv4Addr::UNSPECIFIED), 8080));
+
+        let mut addrs = VecDeque::new();
+        addrs.push_back(localhost);
+        addrs.push_back(unspecified);
+
+        let mut iter = ConnectAddrsIter::Multi(addrs.iter());
+        assert_eq!(iter.next(), Some(localhost));
+        assert_eq!(iter.next(), Some(unspecified));
+        assert_eq!(iter.next(), None);
+
+        let mut iter = ConnectAddrsIter::MultiOwned(addrs.into_iter());
+        assert_eq!(iter.next(), Some(localhost));
+        assert_eq!(iter.next(), Some(unspecified));
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_addr_iter_single() {
+        let localhost = SocketAddr::from((IpAddr::from(Ipv4Addr::LOCALHOST), 8080));
+
+        let mut iter = ConnectAddrsIter::One(localhost);
+        assert_eq!(iter.next(), Some(localhost));
+        assert_eq!(iter.next(), None);
+
+        let mut iter = ConnectAddrsIter::None;
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_local_addr() {
+        let conn = Connect::new("hello").set_local_addr([127, 0, 0, 1]);
+        assert_eq!(
+            conn.local_addr.unwrap(),
+            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))
+        )
+    }
+}

actix-tls/src/connect/connector.rs

@@ -0,0 +1,199 @@
+use std::{
+    collections::VecDeque,
+    future::Future,
+    io,
+    net::{IpAddr, SocketAddr, SocketAddrV4, SocketAddrV6},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_rt::net::{TcpSocket, TcpStream};
+use actix_service::{Service, ServiceFactory};
+use futures_core::{future::LocalBoxFuture, ready};
+use log::{error, trace};
+use tokio_util::sync::ReusableBoxFuture;
+
+use super::connect::{Address, Connect, ConnectAddrs, Connection};
+use super::error::ConnectError;
+
+/// TCP connector service factory
+#[derive(Debug, Copy, Clone)]
+pub struct TcpConnectorFactory;
+
+impl TcpConnectorFactory {
+    /// Create TCP connector service
+    pub fn service(&self) -> TcpConnector {
+        TcpConnector
+    }
+}
+
+impl<T: Address> ServiceFactory<Connect<T>> for TcpConnectorFactory {
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = TcpConnector;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let service = self.service();
+        Box::pin(async move { Ok(service) })
+    }
+}
+
+/// TCP connector service
+#[derive(Debug, Copy, Clone)]
+pub struct TcpConnector;
+
+impl<T: Address> Service<Connect<T>> for TcpConnector {
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = TcpConnectorResponse<T>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, req: Connect<T>) -> Self::Future {
+        let port = req.port();
+        let Connect {
+            req,
+            addr,
+            local_addr,
+            ..
+        } = req;
+
+        TcpConnectorResponse::new(req, port, local_addr, addr)
+    }
+}
+
+/// TCP stream connector response future
+pub enum TcpConnectorResponse<T> {
+    Response {
+        req: Option<T>,
+        port: u16,
+        local_addr: Option<IpAddr>,
+        addrs: Option<VecDeque<SocketAddr>>,
+        stream: Option<ReusableBoxFuture<Result<TcpStream, io::Error>>>,
+    },
+    Error(Option<ConnectError>),
+}
+
+impl<T: Address> TcpConnectorResponse<T> {
+    pub(crate) fn new(
+        req: T,
+        port: u16,
+        local_addr: Option<IpAddr>,
+        addr: ConnectAddrs,
+    ) -> TcpConnectorResponse<T> {
+        if addr.is_none() {
+            error!("TCP connector: unresolved connection address");
+            return TcpConnectorResponse::Error(Some(ConnectError::Unresolved));
+        }
+
+        trace!(
+            "TCP connector: connecting to {} on port {}",
+            req.hostname(),
+            port
+        );
+
+        match addr {
+            ConnectAddrs::None => unreachable!("none variant already checked"),
+
+            ConnectAddrs::One(addr) => TcpConnectorResponse::Response {
+                req: Some(req),
+                port,
+                local_addr,
+                addrs: None,
+                stream: Some(ReusableBoxFuture::new(connect(addr, local_addr))),
+            },
+
+            // when resolver returns multiple socket addr for request they would be popped from
+            // front end of queue and returns with the first successful tcp connection.
+            ConnectAddrs::Multi(addrs) => TcpConnectorResponse::Response {
+                req: Some(req),
+                port,
+                local_addr,
+                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> {
+        match self.get_mut() {
+            TcpConnectorResponse::Error(err) => Poll::Ready(Err(err.take().unwrap())),
+
+            TcpConnectorResponse::Response {
+                req,
+                port,
+                local_addr,
+                addrs,
+                stream,
+            } => loop {
+                if let Some(new) = stream.as_mut() {
+                    match ready!(new.poll(cx)) {
+                        Ok(sock) => {
+                            let req = req.take().unwrap();
+                            trace!(
+                                "TCP connector: successfully connected to {:?} - {:?}",
+                                req.hostname(),
+                                sock.peer_addr()
+                            );
+                            return Poll::Ready(Ok(Connection::new(sock, req)));
+                        }
+
+                        Err(err) => {
+                            trace!(
+                                "TCP connector: failed to connect to {:?} port: {}",
+                                req.as_ref().unwrap().hostname(),
+                                port,
+                            );
+
+                            if addrs.is_none() || addrs.as_ref().unwrap().is_empty() {
+                                return Poll::Ready(Err(ConnectError::Io(err)));
+                            }
+                        }
+                    }
+                }
+
+                // try to connect
+                let addr = addrs.as_mut().unwrap().pop_front().unwrap();
+
+                let fut = connect(addr, *local_addr);
+                match stream {
+                    Some(rbf) => rbf.set(fut),
+                    None => *stream = Some(ReusableBoxFuture::new(fut)),
+                }
+            },
+        }
+    }
+}
+
+async fn connect(addr: SocketAddr, local_addr: Option<IpAddr>) -> io::Result<TcpStream> {
+    // use local addr if connect asks for it.
+    match local_addr {
+        Some(ip_addr) => {
+            let socket = match ip_addr {
+                IpAddr::V4(ip_addr) => {
+                    let socket = TcpSocket::new_v4()?;
+                    let addr = SocketAddr::V4(SocketAddrV4::new(ip_addr, 0));
+                    socket.bind(addr)?;
+                    socket
+                }
+                IpAddr::V6(ip_addr) => {
+                    let socket = TcpSocket::new_v6()?;
+                    let addr = SocketAddr::V6(SocketAddrV6::new(ip_addr, 0, 0, 0));
+                    socket.bind(addr)?;
+                    socket
+                }
+            };
+
+            socket.connect(addr).await
+        }
+
+        None => TcpStream::connect(addr).await,
+    }
+}

actix-tls/src/connect/error.rs

@@ -1,13 +1,12 @@
 use std::io;
 
-use derive_more::{Display, From};
-use trust_dns_resolver::error::ResolveError;
+use derive_more::Display;
 
-#[derive(Debug, From, Display)]
+#[derive(Debug, Display)]
 pub enum ConnectError {
     /// Failed to resolve the hostname
     #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolveError),
+    Resolver(Box<dyn std::error::Error>),
 
     /// No dns records
     #[display(fmt = "No dns records found for the input")]

actix-tls/src/connect/mod.rs

@@ -0,0 +1,74 @@
+//! TCP connector services for Actix ecosystem.
+//!
+//! # Stages of the TCP connector service:
+//! - Resolve [`Address`] with given [`Resolver`] and collect list of socket addresses.
+//! - Establish TCP connection and return [`TcpStream`].
+//!
+//! # Stages of TLS connector services:
+//! - Establish [`TcpStream`] with connector service.
+//! - Wrap the stream and perform connect handshake with remote peer.
+//! - Return certain stream type that impls `AsyncRead` and `AsyncWrite`.
+//!
+//! # Package feature
+//! * `openssl` - enables TLS support via `openssl` crate
+//! * `rustls` - enables TLS support via `rustls` crate
+//!
+//! [`TcpStream`]: actix_rt::net::TcpStream
+
+#[allow(clippy::module_inception)]
+mod connect;
+mod connector;
+mod error;
+mod resolve;
+mod service;
+pub mod ssl;
+#[cfg(feature = "uri")]
+mod uri;
+
+use actix_rt::net::TcpStream;
+use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory};
+
+pub use self::connect::{Address, Connect, Connection};
+pub use self::connector::{TcpConnector, TcpConnectorFactory};
+pub use self::error::ConnectError;
+pub use self::resolve::{Resolve, Resolver, ResolverFactory};
+pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
+
+/// Create TCP connector service.
+pub fn new_connector<T: Address + 'static>(
+    resolver: Resolver,
+) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
+{
+    pipeline(resolver).and_then(TcpConnector)
+}
+
+/// Create TCP connector service factory.
+pub fn new_connector_factory<T: Address + 'static>(
+    resolver: Resolver,
+) -> impl ServiceFactory<
+    Connect<T>,
+    Config = (),
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory)
+}
+
+/// Create connector service with default parameters.
+pub fn default_connector<T: Address + 'static>(
+) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
+{
+    new_connector(Resolver::Default)
+}
+
+/// Create connector service factory with default parameters.
+pub fn default_connector_factory<T: Address + 'static>() -> impl ServiceFactory<
+    Connect<T>,
+    Config = (),
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    new_connector_factory(Resolver::Default)
+}

actix-tls/src/connect/resolve.rs

@@ -0,0 +1,243 @@
+use std::{
+    future::Future,
+    io,
+    net::SocketAddr,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+    vec::IntoIter,
+};
+
+use actix_rt::task::{spawn_blocking, JoinHandle};
+use actix_service::{Service, ServiceFactory};
+use futures_core::{future::LocalBoxFuture, ready};
+use log::trace;
+
+use super::connect::{Address, Connect};
+use super::error::ConnectError;
+
+/// DNS Resolver Service Factory
+#[derive(Clone)]
+pub struct ResolverFactory {
+    resolver: Resolver,
+}
+
+impl ResolverFactory {
+    pub fn new(resolver: Resolver) -> Self {
+        Self { resolver }
+    }
+
+    pub fn service(&self) -> Resolver {
+        self.resolver.clone()
+    }
+}
+
+impl<T: Address> ServiceFactory<Connect<T>> for ResolverFactory {
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = Resolver;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let service = self.resolver.clone();
+        Box::pin(async { Ok(service) })
+    }
+}
+
+/// DNS Resolver Service
+#[derive(Clone)]
+pub enum Resolver {
+    Default,
+    Custom(Rc<dyn Resolve>),
+}
+
+/// An interface for custom async DNS resolvers.
+///
+/// # Usage
+/// ```rust
+/// use std::net::SocketAddr;
+///
+/// use actix_tls::connect::{Resolve, Resolver};
+/// use futures_util::future::LocalBoxFuture;
+///
+/// // use trust-dns async tokio resolver
+/// use trust_dns_resolver::TokioAsyncResolver;
+///
+/// struct MyResolver {
+///     trust_dns: TokioAsyncResolver,
+/// };
+///
+/// // impl Resolve trait and convert given host address str and port to SocketAddr.
+/// impl Resolve for MyResolver {
+///     fn lookup<'a>(
+///         &'a self,
+///         host: &'a str,
+///         port: u16,
+///     ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+///         Box::pin(async move {
+///             let res = self
+///                 .trust_dns
+///                 .lookup_ip(host)
+///                 .await?
+///                 .iter()
+///                 .map(|ip| SocketAddr::new(ip, port))
+///                 .collect();
+///             Ok(res)
+///         })
+///     }
+/// }
+///
+/// let resolver = MyResolver {
+///     trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(),
+/// };
+///
+/// // construct custom resolver
+/// let resolver = Resolver::new_custom(resolver);
+///
+/// // pass custom resolver to connector builder.
+/// // connector would then be usable as a service or awc's connector.
+/// let connector = actix_tls::connect::new_connector::<&str>(resolver.clone());
+///
+/// // resolver can be passed to connector factory where returned service factory
+/// // can be used to construct new connector services.
+/// let factory = actix_tls::connect::new_connector_factory::<&str>(resolver);
+/// ```
+pub trait Resolve {
+    fn lookup<'a>(
+        &'a self,
+        host: &'a str,
+        port: u16,
+    ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>>;
+}
+
+impl Resolver {
+    /// Constructor for custom Resolve trait object and use it as resolver.
+    pub fn new_custom(resolver: impl Resolve + 'static) -> Self {
+        Self::Custom(Rc::new(resolver))
+    }
+
+    // look up with default resolver variant.
+    fn look_up<T: Address>(req: &Connect<T>) -> JoinHandle<io::Result<IntoIter<SocketAddr>>> {
+        let host = req.hostname();
+        // TODO: Connect should always return host with port if possible.
+        let host = if req
+            .hostname()
+            .splitn(2, ':')
+            .last()
+            .and_then(|p| p.parse::<u16>().ok())
+            .map(|p| p == req.port())
+            .unwrap_or(false)
+        {
+            host.to_string()
+        } else {
+            format!("{}:{}", host, req.port())
+        };
+
+        // run blocking DNS lookup in thread pool
+        spawn_blocking(move || std::net::ToSocketAddrs::to_socket_addrs(&host))
+    }
+}
+
+impl<T: Address> Service<Connect<T>> for Resolver {
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Future = ResolverFuture<T>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, req: Connect<T>) -> Self::Future {
+        if req.addr.is_some() {
+            ResolverFuture::Connected(Some(req))
+        } else if let Ok(ip) = req.hostname().parse() {
+            let addr = SocketAddr::new(ip, req.port());
+            let req = req.set_addr(Some(addr));
+            ResolverFuture::Connected(Some(req))
+        } else {
+            trace!("DNS resolver: resolving host {:?}", req.hostname());
+
+            match self {
+                Self::Default => {
+                    let fut = Self::look_up(&req);
+                    ResolverFuture::LookUp(fut, Some(req))
+                }
+
+                Self::Custom(resolver) => {
+                    let resolver = Rc::clone(&resolver);
+                    ResolverFuture::LookupCustom(Box::pin(async move {
+                        let addrs = resolver
+                            .lookup(req.hostname(), req.port())
+                            .await
+                            .map_err(ConnectError::Resolver)?;
+
+                        let req = req.set_addrs(addrs);
+
+                        if req.addr.is_none() {
+                            Err(ConnectError::NoRecords)
+                        } else {
+                            Ok(req)
+                        }
+                    }))
+                }
+            }
+        }
+    }
+}
+
+pub enum ResolverFuture<T: Address> {
+    Connected(Option<Connect<T>>),
+    LookUp(
+        JoinHandle<io::Result<IntoIter<SocketAddr>>>,
+        Option<Connect<T>>,
+    ),
+    LookupCustom(LocalBoxFuture<'static, Result<Connect<T>, ConnectError>>),
+}
+
+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> {
+        match self.get_mut() {
+            Self::Connected(conn) => Poll::Ready(Ok(conn
+                .take()
+                .expect("ResolverFuture polled after finished"))),
+
+            Self::LookUp(fut, req) => {
+                let res = match ready!(Pin::new(fut).poll(cx)) {
+                    Ok(Ok(res)) => Ok(res),
+                    Ok(Err(e)) => Err(ConnectError::Resolver(Box::new(e))),
+                    Err(e) => Err(ConnectError::Io(e.into())),
+                };
+
+                let req = req.take().unwrap();
+
+                let addrs = res.map_err(|err| {
+                    trace!(
+                        "DNS resolver: failed to resolve host {:?} err: {:?}",
+                        req.hostname(),
+                        err
+                    );
+
+                    err
+                })?;
+
+                let req = req.set_addrs(addrs);
+
+                trace!(
+                    "DNS resolver: host {:?} resolved to {:?}",
+                    req.hostname(),
+                    req.addrs()
+                );
+
+                if req.addr.is_none() {
+                    Poll::Ready(Err(ConnectError::NoRecords))
+                } else {
+                    Poll::Ready(Ok(req))
+                }
+            }
+
+            Self::LookupCustom(fut) => fut.as_mut().poll(cx),
+        }
+    }
+}

actix-tls/src/connect/service.rs

@@ -0,0 +1,178 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_rt::net::TcpStream;
+use actix_service::{Service, ServiceFactory};
+use futures_core::{future::LocalBoxFuture, ready};
+
+use super::connect::{Address, Connect, Connection};
+use super::connector::{TcpConnector, TcpConnectorFactory};
+use super::error::ConnectError;
+use super::resolve::{Resolver, ResolverFactory};
+
+pub struct ConnectServiceFactory {
+    tcp: TcpConnectorFactory,
+    resolver: ResolverFactory,
+}
+
+impl ConnectServiceFactory {
+    /// Construct new ConnectService factory
+    pub fn new(resolver: Resolver) -> Self {
+        ConnectServiceFactory {
+            tcp: TcpConnectorFactory,
+            resolver: ResolverFactory::new(resolver),
+        }
+    }
+
+    /// Construct new service
+    pub fn service(&self) -> ConnectService {
+        ConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+
+    /// Construct new tcp stream service
+    pub fn tcp_service(&self) -> TcpConnectService {
+        TcpConnectService {
+            tcp: self.tcp.service(),
+            resolver: self.resolver.service(),
+        }
+    }
+}
+
+impl Clone for ConnectServiceFactory {
+    fn clone(&self) -> Self {
+        ConnectServiceFactory {
+            tcp: self.tcp,
+            resolver: self.resolver.clone(),
+        }
+    }
+}
+
+impl<T: Address> ServiceFactory<Connect<T>> for ConnectServiceFactory {
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Config = ();
+    type Service = ConnectService;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let service = self.service();
+        Box::pin(async move { Ok(service) })
+    }
+}
+
+#[derive(Clone)]
+pub struct ConnectService {
+    tcp: TcpConnector,
+    resolver: Resolver,
+}
+
+impl<T: Address> Service<Connect<T>> for ConnectService {
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = ConnectServiceResponse<T>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, req: Connect<T>) -> Self::Future {
+        ConnectServiceResponse {
+            fut: ConnectFuture::Resolve(self.resolver.call(req)),
+            tcp: self.tcp,
+        }
+    }
+}
+
+// helper enum to generic over futures of resolve and connect phase.
+pub(crate) enum ConnectFuture<T: Address> {
+    Resolve(<Resolver as Service<Connect<T>>>::Future),
+    Connect(<TcpConnector as Service<Connect<T>>>::Future),
+}
+
+// helper enum to contain the future output of ConnectFuture
+pub(crate) enum ConnectOutput<T: Address> {
+    Resolved(Connect<T>),
+    Connected(Connection<T, TcpStream>),
+}
+
+impl<T: Address> ConnectFuture<T> {
+    fn poll_connect(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<ConnectOutput<T>, ConnectError>> {
+        match self {
+            ConnectFuture::Resolve(ref mut fut) => {
+                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved)
+            }
+            ConnectFuture::Connect(ref mut fut) => {
+                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected)
+            }
+        }
+    }
+}
+
+pub struct ConnectServiceResponse<T: Address> {
+    fut: ConnectFuture<T>,
+    tcp: TcpConnector,
+}
+
+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> {
+        loop {
+            match ready!(self.fut.poll_connect(cx))? {
+                ConnectOutput::Resolved(res) => {
+                    self.fut = ConnectFuture::Connect(self.tcp.call(res));
+                }
+                ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)),
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct TcpConnectService {
+    tcp: TcpConnector,
+    resolver: Resolver,
+}
+
+impl<T: Address> Service<Connect<T>> for TcpConnectService {
+    type Response = TcpStream;
+    type Error = ConnectError;
+    type Future = TcpConnectServiceResponse<T>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, req: Connect<T>) -> Self::Future {
+        TcpConnectServiceResponse {
+            fut: ConnectFuture::Resolve(self.resolver.call(req)),
+            tcp: self.tcp,
+        }
+    }
+}
+
+pub struct TcpConnectServiceResponse<T: Address> {
+    fut: ConnectFuture<T>,
+    tcp: TcpConnector,
+}
+
+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> {
+        loop {
+            match ready!(self.fut.poll_connect(cx))? {
+                ConnectOutput::Resolved(res) => {
+                    self.fut = ConnectFuture::Connect(self.tcp.call(res));
+                }
+                ConnectOutput::Connected(conn) => return Poll::Ready(Ok(conn.into_parts().0)),
+            }
+        }
+    }
+}