prepare actix-tls release 3.0.0-beta.8

Co-authored-by: Rob Ede <robjtede@icloud.com>

.cargo/config.toml

@@ -0,0 +1,26 @@
+[alias]
+lint = "clippy --workspace --tests --examples --bins -- -Dclippy::todo"
+lint-all = "clippy --workspace --all-features --tests --examples --bins -- -Dclippy::todo"
+
+ci-doctest = "test --workspace --all-features --doc --no-fail-fast -- --nocapture"
+
+# just check the library (without dev deps)
+ci-check-min = "hack --workspace check --no-default-features"
+ci-check-lib = "hack --workspace --feature-powerset --exclude-features=io-uring check"
+ci-check-lib-linux = "hack --workspace --feature-powerset check"
+
+# check everything
+ci-check = "hack --workspace --feature-powerset --exclude-features=io-uring check --tests --examples"
+ci-check-linux = "hack --workspace --feature-powerset check --tests --examples"
+
+# tests avoiding io-uring feature
+ci-test = "hack test --workspace --exclude=actix-rt --exclude=actix-server --all-features --lib --tests --no-fail-fast -- --nocapture"
+ci-test-rt = "    hack --feature-powerset --exclude-features=io-uring test --package=actix-rt     --lib --tests --no-fail-fast -- --nocapture"
+ci-test-server = "hack --feature-powerset --exclude-features=io-uring test --package=actix-server --lib --tests --no-fail-fast -- --nocapture"
+
+# test with io-uring feature
+ci-test-rt-linux = "    hack --feature-powerset test --package=actix-rt     --lib --tests --no-fail-fast -- --nocapture"
+ci-test-server-linux = "hack --feature-powerset test --package=actix-server --lib --tests --no-fail-fast -- --nocapture"
+
+# test lower msrv
+ci-test-lower-msrv = "hack --workspace --exclude=actix-server --exclude=actix-tls --feature-powerset test --lib --tests --no-fail-fast -- --nocapture"

.github/workflows/ci.yml

@@ -0,0 +1,201 @@
+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.52.0 # MSRV for -server and -tls
+          - stable
+          - nightly
+
+    name: ${{ matrix.target.name }} / ${{ matrix.version }}
+    runs-on: ${{ matrix.target.os }}
+
+    env:
+      VCPKGRS_DYNAMIC: 1
+
+    steps:
+      - name: Setup Routing
+        if: matrix.target.os == 'macos-latest'
+        run: sudo ifconfig lo0 alias 127.0.0.3
+
+      - uses: actions/checkout@v2
+
+      # install OpenSSL on Windows
+      - name: Set vcpkg root
+        if: matrix.target.triple == 'x86_64-pc-windows-msvc' || matrix.target.triple == 'i686-pc-windows-msvc'
+        run: echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append
+      - name: Install OpenSSL
+        if: matrix.target.triple == 'x86_64-pc-windows-msvc'
+        run: vcpkg install openssl:x64-windows
+      - name: Install OpenSSL
+        if: matrix.target.triple == 'i686-pc-windows-msvc'
+        run: vcpkg install openssl:x86-windows
+
+      - 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 lib
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-lib }
+      - name: check lib
+        if: matrix.target.os == 'ubuntu-latest'
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-lib-linux }
+      - name: check lib
+        if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-min }
+      
+      - name: check full
+        # TODO: compile OpenSSL and run tests on MinGW
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check }
+      - name: check all
+        if: matrix.target.os == 'ubuntu-latest'
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-linux }
+
+      - name: tests
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: |
+          cargo ci-test
+          cargo ci-test-rt
+          cargo ci-test-server
+      - name: tests
+        if: matrix.target.os == 'ubuntu-latest'
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rt-linux && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-server-linux"
+
+      - name: Clear the cargo caches
+        run: |
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
+          cargo-cache
+  
+  build_and_test_lower_msrv:
+    name: Linux / 1.46 (lower MSRV)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install 1.46.0 # MSRV for all but -server and -tls
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.46.0-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: tests
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=1.46 cargo ci-test-lower-msrv"
+
+      - name: Clear the cargo caches
+        run: |
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
+          cargo-cache
+  
+  coverage:
+    name: coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust (nightly)
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.3.0
+    
+      - name: Generate coverage file
+        if: github.ref == 'refs/heads/master'
+        run: |
+          cargo install cargo-tarpaulin
+          cargo tarpaulin --out Xml --verbose
+      - name: Upload to Codecov
+        if: github.ref == 'refs/heads/master'
+        uses: codecov/codecov-action@v1
+        with: { file: cobertura.xml }
+
+  rustdoc:
+    name: rustdoc
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust (nightly)
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.3.0
+
+      - name: doc tests io-uring
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=nightly cargo ci-doctest"

.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 --all-features --tests --examples --bins -- -Dclippy::todo

.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,32 @@
 [workspace]
 members = [
   "actix-codec",
-  "actix-connect",
-  "actix-rt",
   "actix-macros",
-  "actix-service",
+  "actix-rt",
   "actix-server",
-  "actix-testing",
-  "actix-threadpool",
+  "actix-service",
   "actix-tls",
   "actix-tracing",
   "actix-utils",
-  "router",
-  "string",
+  "bytestring",
+  "local-channel",
+  "local-waker",
 ]
 
 [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-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" }
+local-channel = { path = "local-channel" }
+local-waker = { path = "local-waker" }
+
+[profile.release]
+lto = true
+opt-level = 3
+codegen-units = 1

LICENSE-APACHE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2017-NOW Nikolay Kim
+   Copyright 2017-NOW Actix Team
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Nikolay Kim
+Copyright (c) 2017-NOW Actix Team
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

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,18 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 0.4.1 - 2021-11-05
+* Added `LinesCodec.` [#338]
+* `Framed::poll_ready` flushes when the buffer is full. [#409]
+
+[#338]: https://github.com/actix/actix-net/pull/338
+[#409]: https://github.com/actix/actix-net/pull/409
+
+
+## 0.4.0 - 2021-04-20
+* No significant changes since v0.4.0-beta.1.
 
 
 ## 0.4.0-beta.1 - 2020-12-28
@@ -23,28 +35,28 @@
 ## 0.3.0-beta.1 - 2020-08-19
 * Use `.advance()` instead of `.split_to()`.
 * Upgrade `tokio-util` to `0.3`.
-* Improve `BytesCodec` `.encode()` performance
-* Simplify `BytesCodec` `.decode()` 
+* Improve `BytesCodec::encode()` performance.
+* Simplify `BytesCodec::decode()`.
 * Rename methods on `Framed` to better describe their use.
 * Add method on `Framed` to get a pinned reference to the underlying I/O.
 * Add method on `Framed` check emptiness of read buffer.
 
 
 ## 0.2.0 - 2019-12-10
-* Use specific futures dependencies
+* Use specific futures dependencies.
 
 
 ## 0.2.0-alpha.4
-* Fix buffer remaining capacity calculation
+* Fix buffer remaining capacity calculation.
 
 
 ## 0.2.0-alpha.3
-* Use tokio 0.2
-* Fix low/high watermark for write/read buffers
+* Use tokio 0.2.
+* Fix low/high watermark for write/read buffers.
 
 
 ## 0.2.0-alpha.2
-* Migrated to `std::future`
+* Migrated to `std::future`.
 
 
 ## 0.1.2 - 2019-03-27
@@ -56,4 +68,4 @@
 
 
 ## 0.1.0 - 2018-12-09
-* Move codec to separate crate
+* Move codec to separate crate.

actix-codec/Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "actix-codec"
-version = "0.4.0-beta.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+version = "0.4.1"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
 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/"
+repository = "https://github.com/actix/actix-net"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -21,6 +22,15 @@ bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
 futures-sink = { version = "0.3.7", default-features = false }
 log = "0.4"
+memchr = "2.3"
 pin-project-lite = "0.2"
-tokio = "1"
+tokio = "1.5.1"
 tokio-util = { version = "0.6", features = ["codec", "io"] }
+
+[dev-dependencies]
+criterion = { version = "0.3", features = ["html_reports"] }
+tokio-test = "0.4.2"
+
+[[bench]]
+name = "lines"
+harness = false

actix-codec/benches/lines.rs

@@ -0,0 +1,57 @@
+use bytes::BytesMut;
+use criterion::{criterion_group, criterion_main, Criterion};
+
+const INPUT: &[u8] = include_bytes!("./lorem.txt");
+
+fn bench_lines_codec(c: &mut Criterion) {
+    let mut decode_group = c.benchmark_group("lines decode");
+
+    decode_group.bench_function("actix", |b| {
+        b.iter(|| {
+            use actix_codec::Decoder as _;
+
+            let mut codec = actix_codec::LinesCodec::default();
+            let mut buf = BytesMut::from(INPUT);
+            while let Ok(Some(_bytes)) = codec.decode_eof(&mut buf) {}
+        });
+    });
+
+    decode_group.bench_function("tokio", |b| {
+        b.iter(|| {
+            use tokio_util::codec::Decoder as _;
+
+            let mut codec = tokio_util::codec::LinesCodec::new();
+            let mut buf = BytesMut::from(INPUT);
+            while let Ok(Some(_bytes)) = codec.decode_eof(&mut buf) {}
+        });
+    });
+
+    decode_group.finish();
+
+    let mut encode_group = c.benchmark_group("lines encode");
+
+    encode_group.bench_function("actix", |b| {
+        b.iter(|| {
+            use actix_codec::Encoder as _;
+
+            let mut codec = actix_codec::LinesCodec::default();
+            let mut buf = BytesMut::new();
+            codec.encode("123", &mut buf).unwrap();
+        });
+    });
+
+    encode_group.bench_function("tokio", |b| {
+        b.iter(|| {
+            use tokio_util::codec::Encoder as _;
+
+            let mut codec = tokio_util::codec::LinesCodec::new();
+            let mut buf = BytesMut::new();
+            codec.encode("123", &mut buf).unwrap();
+        });
+    });
+
+    encode_group.finish();
+}
+
+criterion_group!(benches, bench_lines_codec);
+criterion_main!(benches);

actix-codec/benches/lorem.txt

@@ -0,0 +1,5 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tortor quam, pulvinar sit amet vestibulum eget, tincidunt non urna. Sed eu sem in felis malesuada venenatis. Suspendisse volutpat aliquet nisi, in condimentum nibh convallis id. Quisque gravida felis scelerisque ipsum aliquam consequat. Praesent libero odio, malesuada vitae odio quis, aliquam aliquet enim. In fringilla ut turpis nec pharetra. Duis eu posuere metus. Sed a aliquet massa. Mauris non tempus mi, quis mattis libero. Vivamus ornare ex at semper cursus. Vestibulum sed facilisis erat, aliquet mollis est. In interdum, magna iaculis ultricies elementum, mi ante vestibulum mauris, nec viverra turpis lorem quis ante. Proin in auctor erat. Vivamus dictum congue massa, fermentum bibendum leo pretium quis. Integer dapibus sodales ligula, sit amet imperdiet felis suscipit eu. Phasellus non ornare enim.
+Nam feugiat neque sit amet hendrerit rhoncus. Nunc suscipit molestie vehicula. Aenean vulputate porttitor augue, sit amet molestie dolor volutpat vitae. Nulla vitae condimentum eros. Aliquam tristique purus at metus lacinia egestas. Cras euismod lorem eu orci lobortis, sed tincidunt nisl laoreet. Ut suscipit fermentum mi, et euismod tortor. Pellentesque vitae tempor quam, sed dignissim mi. Suspendisse luctus lacus vitae ligula blandit vehicula. Quisque interdum iaculis tincidunt. Nunc elementum mi vitae tempor placerat. Suspendisse potenti. Donec blandit laoreet ipsum, quis rhoncus velit vulputate sed.
+Aliquam suscipit lectus eros, at maximus dolor efficitur quis. Integer blandit tortor orci, nec mattis nunc eleifend ac. Mauris pharetra vel quam quis lacinia. Duis lobortis condimentum nunc ut facilisis. Praesent arcu nisi, porta sit amet viverra sit amet, pellentesque ut nisi. Nunc gravida tortor eu ligula tempus, in interdum magna pretium. Fusce eu ornare sapien. Nullam pellentesque cursus eros. Nam orci massa, faucibus eget leo eget, elementum vulputate erat. Fusce vehicula augue et dui hendrerit vulputate. Mauris neque lacus, porttitor ut condimentum id, efficitur ac neque. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Donec accumsan, lectus fermentum elementum tristique, ipsum tortor mollis ante, non lacinia nibh ex quis sapien.
+Donec pharetra, elit eget rutrum luctus, urna ligula facilisis lorem, sit amet rhoncus ante est eu mi. Vestibulum vestibulum ultricies interdum. Nulla tincidunt ante non hendrerit venenatis. Curabitur vestibulum turpis erat, id efficitur quam venenatis eu. Fusce nulla sem, dapibus vel quam feugiat, ornare fermentum ligula. Praesent tempus tincidunt mauris, non pellentesque felis varius in. Aenean eu arcu ligula. Morbi dapibus maximus nulla a pharetra. Fusce leo metus, luctus ut cursus non, sollicitudin non lectus. Integer pellentesque eleifend erat, vel gravida purus tempus a. Mauris id vestibulum quam. Nunc vitae ullamcorper metus, pharetra placerat enim. Fusce in ultrices nisl. Curabitur justo mauris, dignissim in aliquam sit amet, sollicitudin ut risus. Cras tempor rutrum justo, non tincidunt est maximus at.
+Aliquam ac velit tincidunt, ullamcorper velit sit amet, pulvinar nisi. Nullam rhoncus rhoncus egestas. Cras ac luctus nisi. Mauris sit amet risus at magna volutpat ultrices quis ac dui. Aliquam condimentum tellus purus, vel sagittis odio vulputate at. Sed ut finibus tellus. Aliquam tincidunt vehicula diam. 

actix-codec/src/bcodec.rs

@@ -1,11 +1,10 @@
-use bytes::{Buf, Bytes, BytesMut};
 use std::io;
 
+use bytes::{Buf, Bytes, BytesMut};
+
 use super::{Decoder, Encoder};
 
-/// Bytes codec.
-///
-/// Reads/Writes chunks of bytes from a stream.
+/// Bytes codec. Reads/writes chunks of bytes from a stream.
 #[derive(Debug, Copy, Clone)]
 pub struct BytesCodec;
 

actix-codec/src/framed.rs

@@ -21,14 +21,13 @@ bitflags::bitflags! {
 }
 
 pin_project_lite::pin_project! {
-    /// A unified `Stream` and `Sink` interface to an underlying I/O object, using
-    /// the `Encoder` and `Decoder` traits to encode and decode frames.
+    /// A unified `Stream` and `Sink` interface to an underlying I/O object, using the `Encoder` and
+    /// `Decoder` traits to encode and decode frames.
     ///
-    /// Raw I/O objects work with byte sequences, but higher-level code usually
-    /// wants to batch these into meaningful chunks, called "frames". This
-    /// method layers framing on top of an I/O object, by using the `Encoder`/`Decoder`
-    /// traits to handle encoding and decoding of message frames. Note that
-    /// the incoming and outgoing frame types may be distinct.
+    /// Raw I/O objects work with byte sequences, but higher-level code usually wants to batch these
+    /// into meaningful chunks, called "frames". This method layers framing on top of an I/O object,
+    /// by using the `Encoder`/`Decoder` traits to handle encoding and decoding of message frames.
+    /// Note that the incoming and outgoing frame types may be distinct.
     pub struct Framed<T, U> {
         #[pin]
         io: T,
@@ -44,10 +43,9 @@ where
     T: AsyncRead + AsyncWrite,
     U: Decoder,
 {
-    /// This function returns a *single* object that is both `Stream` and
-    /// `Sink`; grouping this into a single object is often useful for layering
-    /// things like gzip or TLS, which require both read and write access to the
-    /// underlying object.
+    /// This function returns a *single* object that is both `Stream` and `Sink`; grouping this into
+    /// a single object is often useful for layering things like gzip or TLS, which require both
+    /// read and write access to the underlying object.
     pub fn new(io: T, codec: U) -> Framed<T, U> {
         Framed {
             io,
@@ -70,21 +68,18 @@ impl<T, U> Framed<T, U> {
         &mut self.codec
     }
 
-    /// Returns a reference to the underlying I/O stream wrapped by
-    /// `Frame`.
+    /// Returns a reference to the underlying I/O stream wrapped by `Frame`.
     ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
     pub fn io_ref(&self) -> &T {
         &self.io
     }
 
     /// Returns a mutable reference to the underlying I/O stream.
     ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
     pub fn io_mut(&mut self) -> &mut T {
         &mut self.io
     }
@@ -183,16 +178,15 @@ impl<T, U> Framed<T, U> {
         U: Decoder,
     {
         loop {
-            let mut this = self.as_mut().project();
-            // Repeatedly call `decode` or `decode_eof` as long as it is
-            // "readable". Readable is defined as not having returned `None`. If
-            // the upstream has returned EOF, and the decoder is no longer
-            // readable, it can be assumed that the decoder will never become
+            let this = self.as_mut().project();
+            // Repeatedly call `decode` or `decode_eof` as long as it is "readable". Readable is
+            // defined as not having returned `None`. If the upstream has returned EOF, and the
+            // decoder is no longer readable, it can be assumed that the decoder will never become
             // readable again, at which point the stream is terminated.
 
             if this.flags.contains(Flags::READABLE) {
                 if this.flags.contains(Flags::EOF) {
-                    match this.codec.decode_eof(&mut this.read_buf) {
+                    match this.codec.decode_eof(this.read_buf) {
                         Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
                         Ok(None) => return Poll::Ready(None),
                         Err(e) => return Poll::Ready(Some(Err(e))),
@@ -201,7 +195,7 @@ impl<T, U> Framed<T, U> {
 
                 log::trace!("attempting to decode a frame");
 
-                match this.codec.decode(&mut this.read_buf) {
+                match this.codec.decode(this.read_buf) {
                     Ok(Some(frame)) => {
                         log::trace!("frame decoded from buffer");
                         return Poll::Ready(Some(Ok(frame)));
@@ -215,7 +209,7 @@ impl<T, U> Framed<T, U> {
 
             debug_assert!(!this.flags.contains(Flags::EOF));
 
-            // Otherwise, try to read more data and try again. Make sure we've got room
+            // Otherwise, try to read more data and try again. Make sure we've got room.
             let remaining = this.read_buf.capacity() - this.read_buf.len();
             if remaining < LW {
                 this.read_buf.reserve(HW - remaining)
@@ -306,11 +300,11 @@ where
 {
     type Error = U::Error;
 
-    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.is_write_ready() {
             Poll::Ready(Ok(()))
         } else {
-            Poll::Pending
+            self.flush(cx)
         }
     }
 
@@ -341,13 +335,12 @@ where
 }
 
 impl<T, U> Framed<T, U> {
-    /// This function returns a *single* object that is both `Stream` and
-    /// `Sink`; grouping this into a single object is often useful for layering
-    /// things like gzip or TLS, which require both read and write access to the
-    /// underlying object.
+    /// This function returns a *single* object that is both `Stream` and `Sink`; grouping this into
+    /// a single object is often useful for layering things like gzip or TLS, which require both
+    /// read and write access to the underlying object.
     ///
-    /// These objects take a stream, a read buffer and a write buffer. These
-    /// fields can be obtained from an existing `Framed` with the `into_parts` method.
+    /// These objects take a stream, a read buffer and a write buffer. These fields can be obtained
+    /// from an existing `Framed` with the `into_parts` method.
     pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
         Framed {
             io: parts.io,
@@ -358,12 +351,11 @@ impl<T, U> Framed<T, U> {
         }
     }
 
-    /// Consumes the `Frame`, returning its underlying I/O stream, the buffer
-    /// with unprocessed data, and the codec.
+    /// Consumes the `Frame`, returning its underlying I/O stream, the buffer with unprocessed data,
+    /// and the codec.
     ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
     pub fn into_parts(self) -> FramedParts<T, U> {
         FramedParts {
             io: self.io,
@@ -376,14 +368,15 @@ impl<T, U> Framed<T, U> {
 }
 
 /// `FramedParts` contains an export of the data of a Framed transport.
-/// It can be used to construct a new `Framed` with a different codec.
-/// It contains all current buffers and the inner transport.
+///
+/// It can be used to construct a new `Framed` with a different codec. It contains all current
+/// buffers and the inner transport.
 #[derive(Debug)]
 pub struct FramedParts<T, U> {
-    /// The inner transport used to read bytes to and write bytes to
+    /// The inner transport used to read bytes to and write bytes to.
     pub io: T,
 
-    /// The codec
+    /// The codec object.
     pub codec: U,
 
     /// The buffer with read but unprocessed data.
@@ -396,7 +389,7 @@ pub struct FramedParts<T, U> {
 }
 
 impl<T, U> FramedParts<T, U> {
-    /// Create a new, default, `FramedParts`
+    /// Creates a new default `FramedParts`.
     pub fn new(io: T, codec: U) -> FramedParts<T, U> {
         FramedParts {
             io,
@@ -407,7 +400,7 @@ impl<T, U> FramedParts<T, U> {
         }
     }
 
-    /// Create a new `FramedParts` with read buffer
+    /// Creates a new `FramedParts` with read buffer.
     pub fn with_read_buf(io: T, codec: U, read_buf: BytesMut) -> FramedParts<T, U> {
         FramedParts {
             io,

actix-codec/src/lib.rs

@@ -7,16 +7,18 @@
 //! [`Sink`]: futures_sink::Sink
 //! [`Stream`]: futures_core::Stream
 
-#![deny(rust_2018_idioms, nonstandard_style)]
+#![deny(rust_2018_idioms, nonstandard_style, future_incompatible)]
 #![warn(missing_docs)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 mod bcodec;
 mod framed;
+mod lines;
 
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
+pub use self::lines::LinesCodec;
 
 pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 pub use tokio_util::codec::{Decoder, Encoder};

actix-codec/src/lines.rs

@@ -0,0 +1,158 @@
+use std::io;
+
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use memchr::memchr;
+
+use super::{Decoder, Encoder};
+
+/// Lines codec. Reads/writes line delimited strings.
+///
+/// Will split input up by LF or CRLF delimiters. I.e. carriage return characters at the end of
+/// lines are not preserved.
+#[derive(Debug, Copy, Clone, Default)]
+#[non_exhaustive]
+pub struct LinesCodec;
+
+impl<T: AsRef<str>> Encoder<T> for LinesCodec {
+    type Error = io::Error;
+
+    #[inline]
+    fn encode(&mut self, item: T, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        let item = item.as_ref();
+        dst.reserve(item.len() + 1);
+        dst.put_slice(item.as_bytes());
+        dst.put_u8(b'\n');
+        Ok(())
+    }
+}
+
+impl Decoder for LinesCodec {
+    type Item = String;
+    type Error = io::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.is_empty() {
+            return Ok(None);
+        }
+
+        let len = match memchr(b'\n', src) {
+            Some(n) => n,
+            None => {
+                return Ok(None);
+            }
+        };
+
+        // split up to new line char
+        let mut buf = src.split_to(len);
+        debug_assert_eq!(len, buf.len());
+
+        // remove new line char from source
+        src.advance(1);
+
+        match buf.last() {
+            // remove carriage returns at the end of buf
+            Some(b'\r') => buf.truncate(len - 1),
+
+            // line is empty
+            None => return Ok(Some(String::new())),
+
+            _ => {}
+        }
+
+        try_into_utf8(buf.freeze())
+    }
+
+    fn decode_eof(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self.decode(src)? {
+            Some(frame) => Ok(Some(frame)),
+            None if src.is_empty() => Ok(None),
+            None => {
+                let buf = match src.last() {
+                    // if last line ends in a CR then take everything up to it
+                    Some(b'\r') => src.split_to(src.len() - 1),
+
+                    // take all bytes from source
+                    _ => src.split(),
+                };
+
+                if buf.is_empty() {
+                    return Ok(None);
+                }
+
+                try_into_utf8(buf.freeze())
+            }
+        }
+    }
+}
+
+// Attempts to convert bytes into a `String`.
+fn try_into_utf8(buf: Bytes) -> io::Result<Option<String>> {
+    String::from_utf8(buf.to_vec())
+        .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
+        .map(Some)
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::BufMut as _;
+
+    use super::*;
+
+    #[test]
+    fn lines_decoder() {
+        let mut codec = LinesCodec::default();
+        let mut buf = BytesMut::from("\nline 1\nline 2\r\nline 3\n\r\n\r");
+
+        assert_eq!("", codec.decode(&mut buf).unwrap().unwrap());
+        assert_eq!("line 1", codec.decode(&mut buf).unwrap().unwrap());
+        assert_eq!("line 2", codec.decode(&mut buf).unwrap().unwrap());
+        assert_eq!("line 3", codec.decode(&mut buf).unwrap().unwrap());
+        assert_eq!("", codec.decode(&mut buf).unwrap().unwrap());
+        assert!(codec.decode(&mut buf).unwrap().is_none());
+        assert!(codec.decode_eof(&mut buf).unwrap().is_none());
+
+        buf.put_slice(b"k");
+        assert!(codec.decode(&mut buf).unwrap().is_none());
+        assert_eq!("\rk", codec.decode_eof(&mut buf).unwrap().unwrap());
+
+        assert!(codec.decode(&mut buf).unwrap().is_none());
+        assert!(codec.decode_eof(&mut buf).unwrap().is_none());
+    }
+
+    #[test]
+    fn lines_encoder() {
+        let mut codec = LinesCodec::default();
+
+        let mut buf = BytesMut::new();
+
+        codec.encode("", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"\n");
+
+        codec.encode("test", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"\ntest\n");
+
+        codec.encode("a\nb", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"\ntest\na\nb\n");
+    }
+
+    #[test]
+    fn lines_encoder_no_overflow() {
+        let mut codec = LinesCodec::default();
+
+        let mut buf = BytesMut::new();
+        codec.encode("1234567", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"1234567\n");
+
+        let mut buf = BytesMut::new();
+        codec.encode("12345678", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"12345678\n");
+
+        let mut buf = BytesMut::new();
+        codec.encode("123456789111213", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"123456789111213\n");
+
+        let mut buf = BytesMut::new();
+        codec.encode("1234567891112131", &mut buf).unwrap();
+        assert_eq!(&buf[..], b"1234567891112131\n");
+    }
+}

actix-codec/tests/test_framed_sink.rs

@@ -0,0 +1,221 @@
+use actix_codec::*;
+use bytes::Buf;
+use bytes::{BufMut, BytesMut};
+use futures_sink::Sink;
+use std::collections::VecDeque;
+use std::io::{self, Write};
+use std::pin::Pin;
+use std::task::Poll::{Pending, Ready};
+use std::task::{Context, Poll};
+use tokio_test::{assert_ready, task};
+
+macro_rules! bilateral {
+    ($($x:expr,)*) => {{
+        let mut v = VecDeque::new();
+        v.extend(vec![$($x),*]);
+        Bilateral { calls: v }
+    }};
+}
+
+macro_rules! assert_ready {
+    ($e:expr) => {{
+        use core::task::Poll::*;
+        match $e {
+            Ready(v) => v,
+            Pending => panic!("pending"),
+        }
+    }};
+    ($e:expr, $($msg:tt),+) => {{
+        use core::task::Poll::*;
+        match $e {
+            Ready(v) => v,
+            Pending => {
+                let msg = format_args!($($msg),+);
+                panic!("pending; {}", msg)
+            }
+        }
+    }};
+}
+
+#[derive(Debug)]
+pub struct Bilateral {
+    pub calls: VecDeque<io::Result<Vec<u8>>>,
+}
+
+impl Write for Bilateral {
+    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
+        match self.calls.pop_front() {
+            Some(Ok(data)) => {
+                assert!(src.len() >= data.len());
+                assert_eq!(&data[..], &src[..data.len()]);
+                Ok(data.len())
+            }
+            Some(Err(e)) => Err(e),
+            None => panic!("unexpected write; {:?}", src),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl AsyncWrite for Bilateral {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        match Pin::get_mut(self).write(buf) {
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Pending,
+            other => Ready(other),
+        }
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        match Pin::get_mut(self).flush() {
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Pending,
+            other => Ready(other),
+        }
+    }
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        unimplemented!()
+    }
+}
+
+impl AsyncRead for Bilateral {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        use io::ErrorKind::WouldBlock;
+
+        match self.calls.pop_front() {
+            Some(Ok(data)) => {
+                debug_assert!(buf.remaining() >= data.len());
+                buf.put_slice(&data);
+                Ready(Ok(()))
+            }
+            Some(Err(ref e)) if e.kind() == WouldBlock => Pending,
+            Some(Err(e)) => Ready(Err(e)),
+            None => Ready(Ok(())),
+        }
+    }
+}
+
+pub struct U32;
+
+impl Encoder<u32> for U32 {
+    type Error = io::Error;
+
+    fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
+        // Reserve space
+        dst.reserve(4);
+        dst.put_u32(item);
+        Ok(())
+    }
+}
+
+impl Decoder for U32 {
+    type Item = u32;
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
+        if buf.len() < 4 {
+            return Ok(None);
+        }
+
+        let n = buf.split_to(4).get_u32();
+        Ok(Some(n))
+    }
+}
+
+#[test]
+fn test_write_hits_highwater_mark() {
+    // see here for what this test is based on:
+    // https://github.com/tokio-rs/tokio/blob/75c07770bfbfea4e5fd914af819c741ed9c3fc36/tokio-util/tests/framed_write.rs#L69
+
+    const ITER: usize = 2 * 1024;
+
+    let mut bi = bilateral! {
+        Err(io::Error::new(io::ErrorKind::WouldBlock, "not ready")),
+        Ok(b"".to_vec()),
+    };
+
+    for i in 0..=ITER {
+        let mut b = BytesMut::with_capacity(4);
+        b.put_u32(i as u32);
+
+        // Append to the end
+        match bi.calls.back_mut().unwrap() {
+            Ok(ref mut data) => {
+                // Write in 2kb chunks
+                if data.len() < ITER {
+                    data.extend_from_slice(&b[..]);
+                    continue;
+                } // else fall through and create a new buffer
+            }
+            _ => unreachable!(),
+        }
+
+        // Push a new new chunk
+        bi.calls.push_back(Ok(b[..].to_vec()));
+    }
+
+    assert_eq!(bi.calls.len(), 6);
+    let mut framed = Framed::new(bi, U32);
+    // Send 8KB. This fills up FramedWrite2 buffer
+    let mut task = task::spawn(());
+    task.enter(|cx, _| {
+        // Send 8KB. This fills up Framed buffer
+        for i in 0..ITER {
+            {
+                #[allow(unused_mut)]
+                let mut framed = Pin::new(&mut framed);
+                assert!(assert_ready!(framed.poll_ready(cx)).is_ok());
+            }
+
+            #[allow(unused_mut)]
+            let mut framed = Pin::new(&mut framed);
+            // write the buffer
+            assert!(framed.start_send(i as u32).is_ok());
+        }
+
+        {
+            #[allow(unused_mut)]
+            let mut framed = Pin::new(&mut framed);
+
+            // Now we poll_ready which forces a flush. The bilateral pops the front message
+            // and decides to block.
+            assert!(framed.poll_ready(cx).is_pending());
+        }
+
+        {
+            #[allow(unused_mut)]
+            let mut framed = Pin::new(&mut framed);
+            // We poll again, forcing another flush, which this time succeeds
+            // The whole 8KB buffer is flushed
+            assert!(assert_ready!(framed.poll_ready(cx)).is_ok());
+        }
+
+        {
+            #[allow(unused_mut)]
+            let mut framed = Pin::new(&mut framed);
+            // Send more data. This matches the final message expected by the bilateral
+            assert!(framed.start_send(ITER as u32).is_ok());
+        }
+
+        {
+            #[allow(unused_mut)]
+            let mut framed = Pin::new(&mut framed);
+            // Flush the rest of the buffer
+            assert!(assert_ready!(framed.poll_flush(cx)).is_ok());
+        }
+
+        // Ensure the mock is empty
+        assert_eq!(0, Pin::new(&framed).get_ref().io_ref().calls.len());
+    });
+}

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/ssl/openssl.rs

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

actix-connect/src/ssl/rustls.rs

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

actix-connect/src/uri.rs

@@ -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,46 @@
-# CHANGES
+# Changes
 
-## 0.1.3 - 2020-12-3
+## Unreleased - 2021-xx-xx
+
+
+## 0.2.3 - 2021-10-19
+* Fix test macro in presence of other imports named "test". [#399]
+
+[#399]: https://github.com/actix/actix-net/pull/399
+
+
+## 0.2.2 - 2021-10-14
+* Improve error recovery potential when macro input is invalid. [#391]
+* Allow custom `System`s on test macro. [#391]
+
+[#391]: https://github.com/actix/actix-net/pull/391
+
+
+## 0.2.1 - 2021-02-02
+* Add optional argument `system` to `main` macro which can be used to specify the path to `actix_rt::System` (useful for re-exports). [#363]
+
+[#363]: https://github.com/actix/actix-net/pull/363
+
+
+## 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,13 @@
 [package]
 name = "actix-macros"
-version = "0.1.3"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime macros"
-repository = "https://github.com/actix/actix-net"
-documentation = "https://docs.rs/actix-macros/"
+version = "0.2.3"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Ibraheem Ahmed <ibrah1440@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
+description = "Macros for Actix system and runtime"
+repository = "https://github.com/actix/actix-net.git"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -16,11 +19,9 @@ 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 }
+futures-util = { version = "0.3.7", default-features = false }
+rustversion = "1"
 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");
@@ -20,56 +27,94 @@ use quote::quote;
 #[allow(clippy::needless_doctest_main)]
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
-    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
+        Ok(input) => input,
+        // on parse err, make IDEs happy; see fn docs
+        Err(err) => return input_and_compile_error(item, err),
+    };
+
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
     let attrs = &input.attrs;
     let vis = &input.vis;
     let sig = &mut input.sig;
     let body = &input.block;
-    let name = &sig.ident;
 
     if sig.asyncness.is_none() {
-        return syn::Error::new_spanned(sig.fn_token, "only async fn is supported")
-            .to_compile_error()
-            .into();
+        return syn::Error::new_spanned(
+            sig.fn_token,
+            "the async keyword is missing from the function declaration",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let mut system = syn::parse_str::<syn::Path>("::actix_rt::System").unwrap();
+
+    for arg in &args {
+        match arg {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
+                lit: syn::Lit::Str(lit),
+                path,
+                ..
+            })) => match path
+                .get_ident()
+                .map(|i| i.to_string().to_lowercase())
+                .as_deref()
+            {
+                Some("system") => match lit.parse() {
+                    Ok(path) => system = path,
+                    Err(_) => {
+                        return syn::Error::new_spanned(lit, "Expected path")
+                            .to_compile_error()
+                            .into();
+                    }
+                },
+                _ => {
+                    return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                        .to_compile_error()
+                        .into();
+                }
+            },
+            _ => {
+                return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                    .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 {
+            <#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);
 /// }
 /// ```
 #[proc_macro_attribute]
-pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
-    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
+        Ok(input) => input,
+        // on parse err, make IDEs happy; see fn docs
+        Err(err) => return input_and_compile_error(item, err),
+    };
+
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
     let attrs = &input.attrs;
     let vis = &input.vis;
     let sig = &mut input.sig;
@@ -85,7 +130,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 +138,65 @@ 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! { #[::core::prelude::v1::test] }
     };
 
-    result.into()
+    let mut system = syn::parse_str::<syn::Path>("::actix_rt::System").unwrap();
+
+    for arg in &args {
+        match arg {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
+                lit: syn::Lit::Str(lit),
+                path,
+                ..
+            })) => match path
+                .get_ident()
+                .map(|i| i.to_string().to_lowercase())
+                .as_deref()
+            {
+                Some("system") => match lit.parse() {
+                    Ok(path) => system = path,
+                    Err(_) => {
+                        return syn::Error::new_spanned(lit, "Expected path")
+                            .to_compile_error()
+                            .into();
+                    }
+                },
+                _ => {
+                    return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                        .to_compile_error()
+                        .into();
+                }
+            },
+            _ => {
+                return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                    .to_compile_error()
+                    .into();
+            }
+        }
+    }
+
+    (quote! {
+        #missing_test_attr
+        #(#attrs)*
+        #vis #sig {
+            <#system>::new().block_on(async { #body })
+        }
+    })
+    .into()
+}
+
+/// Converts the error to a token stream and appends it to the original input.
+///
+/// Returning the original input in addition to the error is good for IDEs which can gracefully
+/// recover and show more precise errors within the macro body.
+///
+/// See <https://github.com/rust-analyzer/rust-analyzer/issues/10468> for more info.
+fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> TokenStream {
+    let compile_err = TokenStream::from(err.to_compile_error());
+    item.extend(compile_err);
+    item
 }

actix-macros/tests/trybuild.rs

@@ -1,9 +1,18 @@
+#[rustversion::stable(1.46)] // MSRV
 #[test]
 fn compile_macros() {
     let t = trybuild::TestCases::new();
     t.pass("tests/trybuild/main-01-basic.rs");
     t.compile_fail("tests/trybuild/main-02-only-async.rs");
+    t.pass("tests/trybuild/main-03-fn-params.rs");
+    t.pass("tests/trybuild/main-04-system-path.rs");
+    t.compile_fail("tests/trybuild/main-05-system-expect-path.rs");
+    t.compile_fail("tests/trybuild/main-06-unknown-attr.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");
+    t.pass("tests/trybuild/test-04-system-path.rs");
+    t.compile_fail("tests/trybuild/test-05-system-expect-path.rs");
+    t.compile_fail("tests/trybuild/test-06-unknown-attr.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/main-04-system-path.rs

@@ -0,0 +1,8 @@
+mod system {
+    pub use actix_rt::System as MySystem;
+}
+
+#[actix_rt::main(system = "system::MySystem")]
+async fn main() {
+    futures_util::future::ready(()).await
+}

actix-macros/tests/trybuild/main-05-system-expect-path.rs

@@ -0,0 +1,4 @@
+#[actix_rt::main(system = "!@#*&")]
+async fn main2() {}
+
+fn main() {}

actix-macros/tests/trybuild/main-05-system-expect-path.stderr

@@ -0,0 +1,5 @@
+error: Expected path
+ --> $DIR/main-05-system-expect-path.rs:1:27
+  |
+1 | #[actix_rt::main(system = "!@#*&")]
+  |                           ^^^^^^^

actix-macros/tests/trybuild/main-06-unknown-attr.rs

@@ -0,0 +1,7 @@
+#[actix_rt::main(foo = "bar")]
+async fn async_main() {}
+
+#[actix_rt::main(bar::baz)]
+async fn async_main2() {}
+
+fn main() {}

actix-macros/tests/trybuild/main-06-unknown-attr.stderr

@@ -0,0 +1,11 @@
+error: Unknown attribute specified
+ --> $DIR/main-06-unknown-attr.rs:1:18
+  |
+1 | #[actix_rt::main(foo = "bar")]
+  |                  ^^^^^^^^^^^
+
+error: Unknown attribute specified
+ --> $DIR/main-06-unknown-attr.rs:4:18
+  |
+4 | #[actix_rt::main(bar::baz)]
+  |                  ^^^^^^^^

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-macros/tests/trybuild/test-04-system-path.rs

@@ -0,0 +1,10 @@
+mod system {
+    pub use actix_rt::System as MySystem;
+}
+
+#[actix_rt::test(system = "system::MySystem")]
+async fn my_test() {
+    futures_util::future::ready(()).await
+}
+
+fn main() {}

actix-macros/tests/trybuild/test-05-system-expect-path.rs

@@ -0,0 +1,4 @@
+#[actix_rt::test(system = "!@#*&")]
+async fn my_test() {}
+
+fn main() {}

actix-macros/tests/trybuild/test-05-system-expect-path.stderr

@@ -0,0 +1,5 @@
+error: Expected path
+ --> $DIR/test-05-system-expect-path.rs:1:27
+  |
+1 | #[actix_rt::test(system = "!@#*&")]
+  |                           ^^^^^^^

actix-macros/tests/trybuild/test-06-unknown-attr.rs

@@ -0,0 +1,7 @@
+#[actix_rt::test(foo = "bar")]
+async fn my_test_1() {}
+
+#[actix_rt::test(bar::baz)]
+async fn my_test_2() {}
+
+fn main() {}

actix-macros/tests/trybuild/test-06-unknown-attr.stderr

@@ -0,0 +1,11 @@
+error: Unknown attribute specified
+ --> $DIR/test-06-unknown-attr.rs:1:18
+  |
+1 | #[actix_rt::test(foo = "bar")]
+  |                  ^^^^^^^^^^^
+
+error: Unknown attribute specified
+ --> $DIR/test-06-unknown-attr.rs:4:18
+  |
+4 | #[actix_rt::test(bar::baz)]
+  |                  ^^^^^^^^

actix-rt/CHANGES.md

@@ -1,13 +1,94 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.4.0 - 2021-11-05
+* Add `Arbiter::try_current` for situations where thread may or may not have Arbiter context. [#408]
+* Start io-uring with `System::new` when feature is enabled. [#395]
+
+[#395]: https://github.com/actix/actix-net/pull/395
+[#408]: https://github.com/actix/actix-net/pull/408
+
+
+## 2.3.0 - 2021-10-11
+* The `spawn` method can now resolve with non-unit outputs. [#369]
+* Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux. [#374]
+
+[#369]: https://github.com/actix/actix-net/pull/369
+[#374]: https://github.com/actix/actix-net/pull/374
+
+
+## 2.2.0 - 2021-03-29
+* **BREAKING** `ActixStream::{poll_read_ready, poll_write_ready}` methods now return
+  `Ready` object in ok variant. [#293]
+  * Breakage is acceptable since `ActixStream` was not intended to be public.
+
+[#293]: https://github.com/actix/actix-net/pull/293
+
+
+## 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
-### Added
 * Add `System::attach_to_tokio` method. [#173]
-
-### Changed
 * Update `tokio` dependency to `1.0`. [#236]
 * Rename `time` module `delay_for` to `sleep`, `delay_until` to `sleep_until`, `Delay` to `Sleep`
   to stay aligned with Tokio's naming. [#236]
@@ -15,27 +96,19 @@
   * These methods now accept `&self` when calling. [#236]
 * Remove `'static` lifetime requirement for `System::run` and `Builder::run`. [#236]
 * `Arbiter::spawn` now panics when `System` is not in scope. [#207]
-
-### Fixed
 * Fix work load issue by removing `PENDING` thread local. [#207]
 
 [#207]: https://github.com/actix/actix-net/pull/207
 [#236]: https://github.com/actix/actix-net/pull/236
 
-## [1.1.1] - 2020-04-30
-
-### Fixed
 
+## 1.1.1 - 2020-04-30
 * Fix memory leak due to [#94] (see [#129] for more detail)
 
 [#129]: https://github.com/actix/actix-net/issues/129
 
-## [1.1.0] - 2020-04-08
-
-**This version has been yanked.**
-
-### Added
 
+## 1.1.0 - 2020-04-08 _(YANKED)_
 * Expose `System::is_set` to check if current system has ben started [#99]
 * Add `Arbiter::is_running` to check if event loop is running [#124]
 * Add `Arbiter::local_join` associated function
@@ -45,96 +118,57 @@
 [#99]: https://github.com/actix/actix-net/pull/99
 [#124]: https://github.com/actix/actix-net/pull/124
 
-## [1.0.0] - 2019-12-11
 
+## 1.0.0 - 2019-12-11
 * Update dependencies
 
-## [1.0.0-alpha.3] - 2019-12-07
-
-### Fixed
 
+## 1.0.0-alpha.3 - 2019-12-07
+* Migrate to tokio 0.2
 * Fix compilation on non-unix platforms
 
-### Changed
-
-* Migrate to tokio 0.2
-
-
-## [1.0.0-alpha.2] - 2019-12-02
-
-Added
 
+## 1.0.0-alpha.2 - 2019-12-02
 * Export `main` and `test` attribute macros
-
 * Export `time` module (re-export of tokio-timer)
-
 * Export `net` module (re-export of tokio-net)
 
 
-## [1.0.0-alpha.1] - 2019-11-22
-
-### Changed
-
+## 1.0.0-alpha.1 - 2019-11-22
 * Migrate to std::future and tokio 0.2
 
 
-## [0.2.6] - 2019-11-14
-
-### Fixed
-
+## 0.2.6 - 2019-11-14
+* Allow to join arbiter's thread. #60
 * Fix arbiter's thread panic message.
 
-### Added
-
-* Allow to join arbiter's thread. #60
-
-
-## [0.2.5] - 2019-09-02
-
-### Added
 
+## 0.2.5 - 2019-09-02
 * Add arbiter specific storage
 
 
-## [0.2.4] - 2019-07-17
-
-### Changed
-
+## 0.2.4 - 2019-07-17
 * Avoid a copy of the Future when initializing the Box. #29
 
 
-## [0.2.3] - 2019-06-22
-
-### Added
-
-* Allow to start System using exsiting CurrentThread Handle #22
+## 0.2.3 - 2019-06-22
+* Allow to start System using existing CurrentThread Handle #22
 
 
-## [0.2.2] - 2019-03-28
-
-### Changed
-
+## 0.2.2 - 2019-03-28
 * Moved `blocking` module to `actix-threadpool` crate
 
 
-## [0.2.1] - 2019-03-11
-
-### Added
-
+## 0.2.1 - 2019-03-11
 * Added `blocking` module
-
-* Arbiter::exec_fn - execute fn on the arbiter's thread
-
-* Arbiter::exec - execute fn on the arbiter's thread and wait result
+* Added `Arbiter::exec_fn` - execute fn on the arbiter's thread
+* Added `Arbiter::exec` - execute fn on the arbiter's thread and wait result
 
 
-## [0.2.0] - 2019-03-06
-
+## 0.2.0 - 2019-03-06
 * `run` method returns `io::Result<()>`
-
 * Removed `Handle`
 
 
-## [0.1.0] - 2018-12-09
-
+## 0.1.0 - 2018-12-09
 * Initial release

actix-rt/Cargo.toml

@@ -1,12 +1,14 @@
 [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.4.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/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -15,7 +17,20 @@ edition = "2018"
 name = "actix_rt"
 path = "src/lib.rs"
 
-[dependencies]
-actix-macros = "0.1.0"
+[features]
+default = ["macros"]
+macros = ["actix-macros"]
+io-uring = ["tokio-uring"]
 
-tokio = { version = "1", features = ["rt", "net", "signal", "sync", "time"] }
+[dependencies]
+actix-macros = { version = "0.2.3", optional = true }
+
+futures-core = { version = "0.3", default-features = false }
+tokio = { version = "1.5.1", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+tokio-uring = { version = "0.1", optional = true }
+
+[dev-dependencies]
+tokio = { version = "1.5.1", 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.4.0)](https://docs.rs/actix-rt/2.4.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.4.0/status.svg)](https://deps.rs/crate/actix-rt/2.4.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/examples/multi_thread_system.rs

@@ -0,0 +1,60 @@
+//! An example on how to build a multi-thread tokio runtime for Actix System.
+//! Then spawn async task that can make use of work stealing of tokio runtime.
+
+use actix_rt::System;
+
+fn main() {
+    System::with_tokio_rt(|| {
+        // build system with a multi-thread tokio runtime.
+        tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(2)
+            .enable_all()
+            .build()
+            .unwrap()
+    })
+    .block_on(async_main());
+}
+
+// async main function that acts like #[actix_web::main] or #[tokio::main]
+async fn async_main() {
+    let (tx, rx) = tokio::sync::oneshot::channel();
+
+    // get a handle to system arbiter and spawn async task on it
+    System::current().arbiter().spawn(async {
+        // use tokio::spawn to get inside the context of multi thread tokio runtime
+        let h1 = tokio::spawn(async {
+            println!("thread id is {:?}", std::thread::current().id());
+            std::thread::sleep(std::time::Duration::from_secs(2));
+        });
+
+        // work stealing occurs for this task spawn
+        let h2 = tokio::spawn(async {
+            println!("thread id is {:?}", std::thread::current().id());
+        });
+
+        h1.await.unwrap();
+        h2.await.unwrap();
+        let _ = tx.send(());
+    });
+
+    rx.await.unwrap();
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    let now = std::time::Instant::now();
+
+    // without additional tokio::spawn, all spawned tasks run on single thread
+    System::current().arbiter().spawn(async {
+        println!("thread id is {:?}", std::thread::current().id());
+        std::thread::sleep(std::time::Duration::from_secs(2));
+        let _ = tx.send(());
+    });
+
+    // previous spawn task has blocked the system arbiter thread
+    // so this task will wait for 2 seconds until it can be run
+    System::current().arbiter().spawn(async move {
+        println!("thread id is {:?}", std::thread::current().id());
+        assert!(now.elapsed() > std::time::Duration::from_secs(2));
+    });
+
+    rx.await.unwrap();
+}

actix-rt/src/arbiter.rs

@@ -1,39 +1,27 @@
-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;
 
-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::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 +29,293 @@ 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.
+    #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Arbiter {
+        Self::with_tokio_rt(|| {
+            crate::runtime::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
+    #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+    #[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 = crate::runtime::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);
+    /// Spawn a new Arbiter thread and start its event loop with `tokio-uring` runtime.
+    ///
+    /// # Panics
+    /// Panics if a [System] is not registered on the current thread.
+    #[cfg(all(target_os = "linux", feature = "io-uring"))]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Arbiter {
+        let sys = System::current();
+        let system_id = sys.id();
+        let arb_id = COUNT.fetch_add(1, Ordering::Relaxed);
+
+        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 hnd = ArbiterHandle::new(tx);
+
+                    System::set_current(sys);
+
+                    HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+                    // register arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::RegisterArbiter(arb_id, hnd));
+
+                    ready_tx.send(()).unwrap();
+
+                    // run arbiter event processing loop
+                    tokio_uring::start(ArbiterRunner { rx });
+
+                    // deregister arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::DeregisterArbiter(arb_id));
+                }
+            })
+            .unwrap_or_else(|err| {
+                panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err)
+            });
+
+        ready_rx.recv().unwrap();
+
+        Arbiter { tx, thread_handle }
     }
 
-    /// 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();
+    /// Sets up an Arbiter runner in a new System using the environment's local set.
+    pub(crate) fn in_new_system() -> ArbiterHandle {
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let hnd = ArbiterHandle::new(tx);
+
+        HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+        crate::spawn(ArbiterRunner { rx });
+
+        hnd
+    }
+
+    /// 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)));
+    /// Try to get current running arbiter handle.
+    ///
+    /// Returns `None` if no Arbiter has been started.
+    ///
+    /// Unlike [`current`](Self::current), this never panics.
+    pub fn try_current() -> Option<ArbiterHandle> {
+        HANDLE.with(|cell| cell.borrow().clone())
     }
 
-    /// 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)
+    /// 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 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,205 @@
-//! 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
+//! ```no_run
+//! 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();
+//! ```
+//!
+//! # `io-uring` Support
+//! There is experimental support for using io-uring with this crate by enabling the
+//! `io-uring` feature. For now, it is semver exempt.
 
 #![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")]
 
+#[cfg(all(not(target_os = "linux"), feature = "io-uring"))]
+compile_error!("io_uring is a linux only feature.");
+
 use std::future::Future;
 
-#[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub use actix_macros::{main, test};
+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;
+
+#[cfg(feature = "macros")]
+pub use actix_macros::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::{
+        future::Future,
+        io,
+        task::{Context, Poll},
+    };
+
+    pub use tokio::io::Ready;
+    use tokio::io::{AsyncRead, AsyncWrite, Interest};
     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.
+    #[doc(hidden)]
+    pub trait ActixStream: AsyncRead + AsyncWrite + Unpin {
+        /// 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<io::Result<Ready>>;
+
+        /// 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<io::Result<Ready>>;
+    }
+
+    impl ActixStream for TcpStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::READABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::WRITABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
     }
 
     #[cfg(unix)]
-    pub use self::unix::*;
+    impl ActixStream for UnixStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::READABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::WRITABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+    }
+
+    impl<Io: ActixStream + ?Sized> ActixStream for Box<Io> {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            (**self).poll_read_ready(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            (**self).poll_write_ready(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 as a new task.
+///
+/// If not immediately awaited, the task can be cancelled using [`JoinHandle::abort`].
+///
+/// The provided future is spawned as a new task; therefore, panics are caught.
+///
+/// # Panics
+/// Panics if Actix system is not running.
+///
+/// # Examples
+/// ```
+/// # use std::time::Duration;
+/// # actix_rt::Runtime::new().unwrap().block_on(async {
+/// // task resolves successfully
+/// assert_eq!(actix_rt::spawn(async { 1 }).await.unwrap(), 1);
+///
+/// // task panics
+/// assert!(actix_rt::spawn(async {
+///     panic!("panic is caught at task boundary");
+/// })
+/// .await
+/// .unwrap_err()
+/// .is_panic());
+///
+/// // task is cancelled before completion
+/// let handle = actix_rt::spawn(actix_rt::time::sleep(Duration::from_secs(100)));
+/// handle.abort();
+/// assert!(handle.await.unwrap_err().is_cancelled());
+/// # });
+/// ```
+#[inline]
+pub fn spawn<Fut>(f: Fut) -> JoinHandle<Fut::Output>
+where
+    Fut: Future + 'static,
+    Fut::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,48 @@ impl Runtime {
         })
     }
 
-    pub(super) fn local(&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 +80,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,124 @@
-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, Arbiter};
 
 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,
+}
+
+#[cfg(not(feature = "io-uring"))]
 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(|| {
+            crate::runtime::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 = crate::runtime::Runtime::from(runtime_factory());
+        let sys_arbiter = rt.block_on(async { Arbiter::in_new_system() });
+        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,
+        }
+    }
+}
+
+#[cfg(feature = "io-uring")]
+impl System {
+    /// Create a new system.
+    ///
+    /// # Panics
+    /// Panics if underlying Tokio runtime can not be created.
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> SystemRunner {
+        SystemRunner
+    }
+
+    /// 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>(_: F) -> SystemRunner
+    where
+        F: Fn() -> tokio::runtime::Runtime,
+    {
+        unimplemented!("System::with_tokio_rt is not implemented yet")
+    }
+}
+
+impl 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 +126,198 @@ 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.
+    ///
+    /// Unlike [`current`](Self::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
+    }
+}
+
+#[cfg(not(feature = "io-uring"))]
+/// 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: crate::runtime::Runtime,
+    stop_rx: oneshot::Receiver<i32>,
+    #[allow(dead_code)]
+    system: System,
+}
+
+#[cfg(not(feature = "io-uring"))]
+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)
+    }
+}
+
+#[cfg(feature = "io-uring")]
+/// 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;
+
+#[cfg(feature = "io-uring")]
+impl SystemRunner {
+    /// Starts event loop and will return once [System] is [stopped](System::stop).
+    pub fn run(self) -> io::Result<()> {
+        unimplemented!("SystemRunner::run is not implemented yet")
+    }
+
+    /// Runs the provided future, blocking the current thread until the future completes.
+    #[inline]
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
+        tokio_uring::start(async move {
+            let (stop_tx, stop_rx) = oneshot::channel();
+            let (sys_tx, sys_rx) = mpsc::unbounded_channel();
+
+            let sys_arbiter = Arbiter::in_new_system();
+            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);
+            tokio_uring::spawn(sys_ctrl);
+
+            let res = fut.await;
+            drop(stop_rx);
+            res
+        })
+    }
+}
+
+#[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/test-macro-import-conflict.rs

@@ -0,0 +1,17 @@
+//! Checks that test macro does not cause problems in the presence of imports named "test" that
+//! could be either a module with test items or the "test with runtime" macro itself.
+//!
+//! Before actix/actix-net#399 was implemented, this macro was running twice. The first run output
+//! `#[test]` and it got run again and since it was in scope.
+//!
+//! Prevented by using the fully-qualified test marker (`#[::core::prelude::v1::test]`).
+
+#![cfg(feature = "macros")]
+
+use actix_rt::time as test;
+
+#[actix_rt::test]
+async fn test_naming_conflict() {
+    use test as time;
+    time::sleep(std::time::Duration::from_millis(2)).await;
+}

actix-rt/tests/tests.rs

@@ -0,0 +1,368 @@
+use std::{
+    future::Future,
+    time::{Duration, Instant},
+};
+
+use actix_rt::{task::JoinError, Arbiter, System};
+
+#[cfg(not(feature = "io-uring"))]
+use {
+    std::{sync::mpsc::channel, thread},
+    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());
+}
+
+// Temporary disabled tests for io-uring feature.
+// They should be enabled when possible.
+
+#[cfg(not(feature = "io-uring"))]
+#[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();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[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();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_drop_no_panic_fn() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn_fn(|| panic!("test"));
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_drop_no_panic_fut() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn(async { panic!("test") });
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[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();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[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
+    thread::sleep(Duration::from_millis(500));
+
+    // arbiter should be dead and return false
+    assert!(!Arbiter::current().spawn_fn(|| {}));
+    assert!(!arb.spawn_fn(|| {}));
+
+    arb.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[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);
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn new_arbiter_with_tokio() {
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    };
+
+    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!(!counter.load(Ordering::SeqCst));
+}
+
+#[test]
+#[should_panic]
+fn no_system_current_panic() {
+    System::current();
+}
+
+#[test]
+#[should_panic]
+fn no_system_arbiter_new_panic() {
+    Arbiter::new();
+}
+
+#[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()) });
+}
+
+#[allow(clippy::unit_cmp)]
+#[test]
+fn spawn_local() {
+    System::new().block_on(async {
+        // demonstrate that spawn -> R is strictly more capable than spawn -> ()
+
+        assert_eq!(actix_rt::spawn(async {}).await.unwrap(), ());
+        assert_eq!(actix_rt::spawn(async { 1 }).await.unwrap(), 1);
+        assert!(actix_rt::spawn(async { panic!("") }).await.is_err());
+
+        actix_rt::spawn(async { tokio::time::sleep(Duration::from_millis(50)).await })
+            .await
+            .unwrap();
+
+        fn g<F: Future<Output = Result<(), JoinError>>>(_f: F) {}
+        g(actix_rt::spawn(async {}));
+        // g(actix_rt::spawn(async { 1 })); // compile err
+
+        fn h<F: Future<Output = Result<R, JoinError>>, R>(_f: F) {}
+        h(actix_rt::spawn(async {}));
+        h(actix_rt::spawn(async { 1 }));
+    })
+}
+
+#[cfg(all(target_os = "linux", feature = "io-uring"))]
+#[test]
+fn tokio_uring_arbiter() {
+    System::new().block_on(async {
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        Arbiter::new().spawn(async move {
+            let handle = actix_rt::spawn(async move {
+                let f = tokio_uring::fs::File::create("test.txt").await.unwrap();
+                let buf = b"Hello World!";
+
+                let (res, _) = f.write_at(&buf[..], 0).await;
+                assert!(res.is_ok());
+
+                f.sync_all().await.unwrap();
+                f.close().await.unwrap();
+
+                std::fs::remove_file("test.txt").unwrap();
+            });
+
+            handle.await.unwrap();
+            tx.send(true).unwrap();
+        });
+
+        assert!(rx.recv().unwrap());
+    })
+}

actix-server/CHANGES.md

@@ -1,11 +1,91 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.0.0-beta.9 - 2021-11-15
+* Restore `Arbiter` support lost in `beta.8`. [#417]
+
+[#417]: https://github.com/actix/actix-net/pull/417
+
+
+## 2.0.0-beta.8 - 2021-11-05 _(YANKED)_
+* Fix non-unix signal handler. [#410]
+
+[#410]: https://github.com/actix/actix-net/pull/410
+
+
+## 2.0.0-beta.7 - 2021-11-05 _(YANKED)_
+* Server can be started in regular Tokio runtime. [#408]
+* Expose new `Server` type whose `Future` impl resolves when server stops. [#408]
+* Rename `Server` to `ServerHandle`. [#407]
+* Add `Server::handle` to obtain handle to server. [#408]
+* Rename `ServerBuilder::{maxconn => max_concurrent_connections}`. [#407]
+* Deprecate crate-level `new` shortcut for server builder. [#408]
+* Minimum supported Rust version (MSRV) is now 1.52.
+
+[#407]: https://github.com/actix/actix-net/pull/407
+[#408]: https://github.com/actix/actix-net/pull/408
+
+
+## 2.0.0-beta.6 - 2021-10-11
+* Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux. [#374]
+* Server no long listens to `SIGHUP` signal. Previously, the received was not used but did block
+  subsequent exit signals from working. [#389]
+* Remove `config` module. `ServiceConfig`, `ServiceRuntime` public types are removed due to
+  this change. [#349]
+* Remove `ServerBuilder::configure` [#349]
+
+[#374]: https://github.com/actix/actix-net/pull/374
+[#349]: https://github.com/actix/actix-net/pull/349
+[#389]: https://github.com/actix/actix-net/pull/389
+
+
+## 2.0.0-beta.5 - 2021-04-20
+* Server shutdown notifies all workers to exit regardless if shutdown is graceful. This causes all
+  workers to shutdown immediately in force shutdown case. [#333]
+
+[#333]: https://github.com/actix/actix-net/pull/333
+
+
+## 2.0.0-beta.4 - 2021-04-01
+* Prevent panic when `shutdown_timeout` is very large. [f9262db]
+
+[f9262db]: https://github.com/actix/actix-net/commit/f9262db
+
+
+## 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,15 @@
 [package]
 name = "actix-server"
-version = "1.0.4"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+version = "2.0.0-beta.9"
+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/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-exclude = [".gitignore", ".cargo/config"]
 edition = "2018"
 
 [lib]
@@ -18,27 +18,29 @@ path = "src/lib.rs"
 
 [features]
 default = []
+io-uring = ["tokio-uring", "actix-rt/io-uring"]
 
 [dependencies]
-actix-service = "1.0.6"
-actix-rt = "1.1.1"
-actix-codec = "0.3.0"
-actix-utils = "2.0.0"
+actix-rt = { version = "2.4.0", default-features = false }
+actix-service = "2.0.0"
+actix-utils = "3.0.0"
 
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-util = { 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"
+socket2 = "0.4.2"
+tokio = { version = "1.5.1", features = ["sync"] }
 
-# unix domain sockets
-# FIXME: Remove it and use mio own uds feature once mio 0.7 is released
-mio-uds = { version = "0.6.7" }
+# runtime for io-uring feature
+tokio-uring = { version = "0.1", optional = true }
 
 [dev-dependencies]
-bytes = "0.5"
-env_logger = "0.7"
-actix-testing = "1.0.0"
-tokio = { version = "0.2", features = ["io-util"] }
+actix-codec = "0.4.0"
+actix-rt = "2.0.0"
+
+bytes = "1"
+env_logger = "0.9"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
+tokio = { version = "1.5.1", features = ["io-util", "rt-multi-thread", "macros"] }

actix-server/examples/tcp-echo.rs

@@ -9,24 +9,24 @@
 //! Start typing. When you press enter the typed line will be echoed back. The server will log
 //! the length of each line it echos and the total size of data sent when the connection is closed.
 
-use std::sync::{
-    atomic::{AtomicUsize, Ordering},
-    Arc,
+use std::{
+    io,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
 };
-use std::{env, io};
 
 use actix_rt::net::TcpStream;
 use actix_server::Server;
-use actix_service::pipeline_factory;
+use actix_service::{fn_service, ServiceFactoryExt as _};
 use bytes::BytesMut;
 use futures_util::future::ok;
 use log::{error, info};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
 
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "actix=trace,basic=trace");
-    env_logger::init();
+async fn run() -> io::Result<()> {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
 
     let count = Arc::new(AtomicUsize::new(0));
 
@@ -41,7 +41,7 @@ async fn main() -> io::Result<()> {
             let count = Arc::clone(&count);
             let num2 = Arc::clone(&count);
 
-            pipeline_factory(move |mut stream: TcpStream| {
+            fn_service(move |mut stream: TcpStream| {
                 let count = Arc::clone(&count);
 
                 async move {
@@ -86,3 +86,16 @@ async fn main() -> io::Result<()> {
         .run()
         .await
 }
+
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    run().await?;
+    Ok(())
+}
+
+// alternatively:
+// #[actix_rt::main]
+// async fn main() -> io::Result<()> {
+//     run().await?;
+//     Ok(())
+// }

actix-server/src/accept.rs

@@ -1,484 +1,460 @@
-use std::sync::mpsc as sync_mpsc;
-use std::time::Duration;
-use std::{io, thread};
+use std::{io, thread, time::Duration};
 
-use actix_rt::time::{delay_until, Instant};
-use actix_rt::System;
-use log::{error, info};
-use slab::Slab;
+use actix_rt::time::Instant;
+use log::{debug, error, info};
+use mio::{Interest, Poll, Token as MioToken};
 
-use crate::server::Server;
-use crate::socket::{SocketAddr, SocketListener, StdListener};
-use crate::worker::{Conn, WorkerClient};
-use crate::Token;
+use crate::{
+    availability::Availability,
+    socket::MioListener,
+    waker_queue::{WakerInterest, WakerQueue, WAKER_TOKEN},
+    worker::{Conn, ServerWorker, WorkerHandleAccept, WorkerHandleServer},
+    ServerBuilder, ServerHandle,
+};
 
-pub(crate) enum Command {
-    Pause,
-    Resume,
-    Stop,
-    Worker(WorkerClient),
-}
+const TIMEOUT_DURATION_ON_ERROR: Duration = Duration::from_millis(510);
 
 struct ServerSocketInfo {
-    addr: SocketAddr,
-    token: Token,
-    sock: SocketListener,
-    timeout: Option<Instant>,
+    token: usize,
+
+    lst: MioListener,
+
+    /// Timeout is used to mark the deadline when this socket's listener should be registered again
+    /// after an error.
+    timeout: Option<actix_rt::time::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)
-    }
-}
-
-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>,
-}
-
-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();
-
-        AcceptLoop {
-            tx,
-            cmd_ready,
-            cmd_reg: Some(cmd_reg),
-            notify_ready,
-            notify_reg: Some(notify_reg),
-            rx: Some(rx),
-            srv: Some(srv),
-        }
-    }
-
-    pub fn send(&self, msg: Command) {
-        let _ = self.tx.send(msg);
-        let _ = self.cmd_ready.set_readiness(mio::Ready::readable());
-    }
-
-    pub fn get_notify(&self) -> AcceptNotify {
-        AcceptNotify::new(self.notify_ready.clone())
-    }
-
-    pub(crate) fn start(
-        &mut self,
-        socks: Vec<(Token, StdListener)>,
-        workers: Vec<WorkerClient>,
-    ) {
-        let srv = self.srv.take().expect("Can not re-use AcceptInfo");
-
-        Accept::start(
-            self.rx.take().expect("Can not re-use AcceptInfo"),
-            self.cmd_reg.take().expect("Can not re-use AcceptInfo"),
-            self.notify_reg.take().expect("Can not re-use AcceptInfo"),
-            socks,
-            srv,
-            workers,
-        );
-    }
-}
-
-struct Accept {
-    poll: mio::Poll,
-    rx: sync_mpsc::Receiver<Command>,
-    sockets: Slab<ServerSocketInfo>,
-    workers: Vec<WorkerClient>,
-    srv: Server,
-    timer: (mio::Registration, mio::SetReadiness),
+/// poll instance of the server.
+pub(crate) struct Accept {
+    poll: Poll,
+    waker_queue: WakerQueue,
+    handles: Vec<WorkerHandleAccept>,
+    srv: ServerHandle,
     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.
-///
-/// All other errors will incur a timeout before next `accept()` is performed.
-/// The timeout is useful to handle resource exhaustion errors like ENFILE
-/// and EMFILE. Otherwise, could enter into tight loop.
-fn connection_error(e: &io::Error) -> bool {
-    e.kind() == io::ErrorKind::ConnectionRefused
-        || e.kind() == io::ErrorKind::ConnectionAborted
-        || e.kind() == io::ErrorKind::ConnectionReset
+    avail: Availability,
+    /// use the smallest duration from sockets timeout.
+    timeout: Option<Duration>,
+    paused: 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)>,
-        srv: Server,
-        workers: Vec<WorkerClient>,
-    ) {
-        let sys = System::current();
+        sockets: Vec<(usize, MioListener)>,
+        builder: &ServerBuilder,
+    ) -> io::Result<(WakerQueue, Vec<WorkerHandleServer>)> {
+        let handle_server = ServerHandle::new(builder.cmd_tx.clone());
 
-        // start accept thread
-        let _ = 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);
+        // construct poll instance and its waker
+        let poll = Poll::new()?;
+        let waker_queue = WakerQueue::new(poll.registry())?;
 
-                // 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 workers and collect handles
+        let (handles_accept, handles_server) = (0..builder.threads)
+            .map(|idx| {
+                // clone service factories
+                let factories = builder
+                    .factories
+                    .iter()
+                    .map(|f| f.clone_factory())
+                    .collect::<Vec<_>>();
 
-                // 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);
-                }
+                // start worker using service factories
+                ServerWorker::start(idx, factories, waker_queue.clone(), builder.worker_config)
+            })
+            .collect::<io::Result<Vec<_>>>()?
+            .into_iter()
+            .unzip();
 
-                accept.poll();
-            });
+        let (mut accept, mut sockets) = Accept::new_with_sockets(
+            poll,
+            waker_queue.clone(),
+            sockets,
+            handles_accept,
+            handle_server,
+        )?;
+
+        thread::Builder::new()
+            .name("actix-server acceptor".to_owned())
+            .spawn(move || accept.poll_with(&mut sockets))
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+
+        Ok((waker_queue, handles_server))
     }
 
-    fn new(
-        rx: sync_mpsc::Receiver<Command>,
-        socks: Vec<(Token, StdListener)>,
-        workers: Vec<WorkerClient>,
-        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),
+    fn new_with_sockets(
+        poll: Poll,
+        waker_queue: WakerQueue,
+        sockets: Vec<(usize, MioListener)>,
+        accept_handles: Vec<WorkerHandleAccept>,
+        server_handle: ServerHandle,
+    ) -> io::Result<(Accept, Box<[ServerSocketInfo]>)> {
+        let sockets = sockets
+            .into_iter()
+            .map(|(token, mut lst)| {
+                // Start listening for incoming connections
+                poll.registry()
+                    .register(&mut lst, MioToken(token), Interest::READABLE)?;
+
+                Ok(ServerSocketInfo {
+                    token,
+                    lst,
+                    timeout: None,
+                })
+            })
+            .collect::<io::Result<_>>()?;
+
+        let mut avail = Availability::default();
+
+        // Assume all handles are avail at construct time.
+        avail.set_available_all(&accept_handles);
+
+        let accept = Accept {
+            poll,
+            waker_queue,
+            handles: accept_handles,
+            srv: server_handle,
+            next: 0,
+            avail,
+            timeout: None,
+            paused: false,
         };
 
-        // Start accept
-        let mut sockets = Slab::new();
-        for (hnd_token, 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);
-            }
-
-            entry.insert(ServerSocketInfo {
-                addr,
-                token: hnd_token,
-                sock: server,
-                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 {
-            poll,
-            rx,
-            sockets,
-            workers,
-            srv,
-            next: 0,
-            timer: (tm, tmr),
-            backpressure: false,
-        }
+        Ok((accept, sockets))
     }
 
-    fn poll(&mut self) {
-        // Create storage for events
-        let mut events = mio::Events::with_capacity(128);
+    /// blocking wait for readiness events triggered by mio
+    fn poll_with(&mut self, sockets: &mut [ServerSocketInfo]) {
+        let mut events = mio::Events::with_capacity(256);
 
         loop {
-            if let Err(err) = self.poll.poll(&mut events, None) {
-                panic!("Poll error: {}", err);
+            if let Err(e) = self.poll.poll(&mut events, self.timeout) {
+                match e.kind() {
+                    io::ErrorKind::Interrupted => {}
+                    _ => panic!("Poll error: {}", e),
+                }
             }
 
             for event in events.iter() {
                 let token = event.token();
                 match token {
-                    CMD => {
-                        if !self.process_cmd() {
+                    WAKER_TOKEN => {
+                        let exit = self.handle_waker(sockets);
+                        if exit {
+                            info!("Accept thread stopped");
                             return;
                         }
                     }
-                    TIMER => self.process_timer(),
-                    NOTIFY => self.backpressure(false),
                     _ => {
                         let token = usize::from(token);
-                        if token < DELTA {
-                            continue;
-                        }
-                        self.accept(token - DELTA);
+                        self.accept(sockets, token);
                     }
                 }
             }
+
+            // check for timeout and re-register sockets
+            self.process_timeout(sockets);
         }
     }
 
-    fn process_timer(&mut self) {
-        let now = Instant::now();
-        for (token, info) in self.sockets.iter_mut() {
-            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);
-                    }
-                } else {
-                    info.timeout = Some(inst);
-                }
-            }
-        }
-    }
-
-    fn process_cmd(&mut self) -> bool {
+    fn handle_waker(&mut self, sockets: &mut [ServerSocketInfo]) -> bool {
+        // 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.
         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);
-                            }
-                        }
+            // take guard with every iteration so no new interest can be added
+            // until the current task is done.
+            let mut guard = self.waker_queue.guard();
+            match guard.pop_front() {
+                // worker notify it becomes available.
+                Some(WakerInterest::WorkerAvailable(idx)) => {
+                    drop(guard);
+
+                    self.avail.set_available(idx, true);
+
+                    if !self.paused {
+                        self.accept_all(sockets);
                     }
-                    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
-                                );
-                            }
-                        }
+                }
+
+                // a new worker thread is made and it's handle would be added to Accept
+                Some(WakerInterest::Worker(handle)) => {
+                    drop(guard);
+
+                    self.avail.set_available(handle.idx(), true);
+                    self.handles.push(handle);
+
+                    if !self.paused {
+                        self.accept_all(sockets);
                     }
-                    Command::Stop => {
-                        for (_, info) in self.sockets.iter() {
-                            let _ = self.poll.deregister(&info.sock);
-                        }
-                        return false;
+                }
+
+                Some(WakerInterest::Pause) => {
+                    drop(guard);
+
+                    if !self.paused {
+                        self.paused = true;
+
+                        self.deregister_all(sockets);
                     }
-                    Command::Worker(worker) => {
-                        self.backpressure(false);
-                        self.workers.push(worker);
+                }
+
+                Some(WakerInterest::Resume) => {
+                    drop(guard);
+
+                    if self.paused {
+                        self.paused = false;
+
+                        sockets.iter_mut().for_each(|info| {
+                            self.register_logged(info);
+                        });
+
+                        self.accept_all(sockets);
                     }
-                },
-                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;
+                }
+
+                Some(WakerInterest::Stop) => {
+                    if !self.paused {
+                        self.deregister_all(sockets);
                     }
-                },
+
+                    return true;
+                }
+
+                // waker queue is drained
+                None => {
+                    // Reset the WakerQueue before break so it does not grow infinitely
+                    WakerQueue::reset(&mut guard);
+
+                    return false;
+                }
             }
         }
-        true
+    }
+
+    fn process_timeout(&mut self, sockets: &mut [ServerSocketInfo]) {
+        // always remove old timeouts
+        if self.timeout.take().is_some() {
+            let now = Instant::now();
+
+            sockets
+                .iter_mut()
+                // Only sockets that had an associated timeout were deregistered.
+                .filter(|info| info.timeout.is_some())
+                .for_each(|info| {
+                    let inst = info.timeout.take().unwrap();
+
+                    if now < inst {
+                        // still timed out; try to set new timeout
+                        info.timeout = Some(inst);
+                        self.set_timeout(inst - now);
+                    } else if !self.paused {
+                        // timeout expired; register socket again
+                        self.register_logged(info);
+                    }
+
+                    // Drop the timeout if server is paused and socket timeout is expired.
+                    // When server recovers from pause it will register all sockets without
+                    // a timeout value so this socket register will be delayed till then.
+                });
+        }
+    }
+
+    /// Update accept timeout with `duration` if it is shorter than current timeout.
+    fn set_timeout(&mut self, duration: Duration) {
+        match self.timeout {
+            Some(ref mut timeout) => {
+                if *timeout > duration {
+                    *timeout = duration;
+                }
+            }
+            None => self.timeout = Some(duration),
+        }
     }
 
     #[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, info: &mut ServerSocketInfo) -> io::Result<()> {
+        let token = MioToken(info.token);
+        self.poll
+            .registry()
+            .register(&mut info.lst, token, Interest::READABLE)
     }
 
     #[cfg(target_os = "windows")]
-    fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> {
+    fn register(&self, 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.
+        let token = MioToken(info.token);
         self.poll
-            .register(
-                &info.sock,
-                mio::Token(token + DELTA),
-                mio::Ready::readable(),
-                mio::PollOpt::edge(),
-            )
+            .registry()
+            .register(&mut info.lst, 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, token, Interest::READABLE)
             })
     }
 
-    fn backpressure(&mut self, on: bool) {
-        if self.backpressure {
-            if !on {
-                self.backpressure = false;
-                for (token, info) in self.sockets.iter() {
-                    if info.timeout.is_some() {
-                        // socket will attempt to re-register itself when its timeout completes
-                        continue;
-                    }
+    fn register_logged(&self, info: &mut ServerSocketInfo) {
+        match self.register(info) {
+            Ok(_) => debug!("Resume accepting connections on {}", info.lst.local_addr()),
+            Err(e) => error!("Can not register server socket {}", e),
+        }
+    }
 
-                    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);
-                    }
-                }
-            }
-        } 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);
+    fn deregister_logged(&self, info: &mut ServerSocketInfo) {
+        match self.poll.registry().deregister(&mut info.lst) {
+            Ok(_) => debug!("Paused accepting connections on {}", info.lst.local_addr()),
+            Err(e) => {
+                error!("Can not deregister server socket {}", e)
             }
         }
     }
 
-    fn accept_one(&mut self, mut msg: Conn) {
-        if self.backpressure {
-            while !self.workers.is_empty() {
-                match self.workers[self.next].send(msg) {
-                    Ok(_) => (),
-                    Err(tmp) => {
-                        self.srv.worker_faulted(self.workers[self.next].idx);
-                        msg = tmp;
-                        self.workers.swap_remove(self.next);
-                        if self.workers.is_empty() {
-                            error!("No workers");
-                            return;
-                        } else if self.workers.len() <= self.next {
-                            self.next = 0;
-                        }
-                        continue;
-                    }
+    fn deregister_all(&self, sockets: &mut [ServerSocketInfo]) {
+        // This is a best effort implementation with following limitation:
+        //
+        // Every ServerSocketInfo with associated timeout will be skipped and it's timeout is
+        // removed in the process.
+        //
+        // Therefore WakerInterest::Pause followed by WakerInterest::Resume in a very short gap
+        // (less than 500ms) would cause all timing out ServerSocketInfos be re-registered before
+        // expected timing.
+        sockets
+            .iter_mut()
+            // Take all timeout.
+            // This is to prevent Accept::process_timer method re-register a socket afterwards.
+            .map(|info| (info.timeout.take(), info))
+            // Socket info with a timeout is already deregistered so skip them.
+            .filter(|(timeout, _)| timeout.is_none())
+            .for_each(|(_, info)| self.deregister_logged(info));
+    }
+
+    // Send connection to worker and handle error.
+    fn send_connection(&mut self, conn: Conn) -> Result<(), Conn> {
+        let next = self.next();
+        match next.send(conn) {
+            Ok(_) => {
+                // Increment counter of WorkerHandle.
+                // Set worker to unavailable with it hit max (Return false).
+                if !next.inc_counter() {
+                    let idx = next.idx();
+                    self.avail.set_available(idx, false);
                 }
-                self.next = (self.next + 1) % self.workers.len();
-                break;
+                self.set_next();
+                Ok(())
             }
-        } else {
-            let mut idx = 0;
-            while idx < self.workers.len() {
-                idx += 1;
-                if self.workers[self.next].available() {
-                    match self.workers[self.next].send(msg) {
-                        Ok(_) => {
-                            self.next = (self.next + 1) % self.workers.len();
-                            return;
-                        }
-                        Err(tmp) => {
-                            self.srv.worker_faulted(self.workers[self.next].idx);
-                            msg = tmp;
-                            self.workers.swap_remove(self.next);
-                            if self.workers.is_empty() {
-                                error!("No workers");
-                                self.backpressure(true);
-                                return;
-                            } else if self.workers.len() <= self.next {
-                                self.next = 0;
-                            }
-                            continue;
-                        }
-                    }
+            Err(conn) => {
+                // Worker thread is error and could be gone.
+                // Remove worker handle and notify `ServerBuilder`.
+                self.remove_next();
+
+                if self.handles.is_empty() {
+                    error!("No workers");
+                    // All workers are gone and Conn is nowhere to be sent.
+                    // Treat this situation as Ok and drop Conn.
+                    return Ok(());
+                } else if self.handles.len() <= self.next {
+                    self.next = 0;
                 }
-                self.next = (self.next + 1) % self.workers.len();
+
+                Err(conn)
             }
-            // enable backpressure
-            self.backpressure(true);
-            self.accept_one(msg);
         }
     }
 
-    fn accept(&mut self, token: usize) {
+    fn accept_one(&mut self, mut conn: Conn) {
         loop {
-            let msg = if let Some(info) = self.sockets.get_mut(token) {
-                match info.sock.accept() {
-                    Ok(Some((io, addr))) => Conn {
-                        io,
-                        token: info.token,
-                        peer: Some(addr),
-                    },
-                    Ok(None) => return,
-                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
-                    Err(ref e) if connection_error(e) => continue,
-                    Err(e) => {
-                        error!("Error accepting connection: {}", e);
-                        if let Err(err) = self.poll.deregister(&info.sock) {
-                            error!("Can not deregister server socket {}", err);
-                        }
+            let next = self.next();
+            let idx = next.idx();
 
-                        // sleep after error
-                        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());
-                        }));
-                        return;
-                    }
+            if self.avail.get_available(idx) {
+                match self.send_connection(conn) {
+                    Ok(_) => return,
+                    Err(c) => conn = c,
                 }
             } else {
-                return;
-            };
+                self.avail.set_available(idx, false);
+                self.set_next();
 
-            self.accept_one(msg);
+                if !self.avail.available() {
+                    while let Err(c) = self.send_connection(conn) {
+                        conn = c;
+                    }
+                    return;
+                }
+            }
         }
     }
+
+    fn accept(&mut self, sockets: &mut [ServerSocketInfo], token: usize) {
+        while self.avail.available() {
+            let info = &mut sockets[token];
+
+            match info.lst.accept() {
+                Ok(io) => {
+                    let conn = Conn { io, token };
+                    self.accept_one(conn);
+                }
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
+                Err(ref e) if connection_error(e) => continue,
+                Err(e) => {
+                    error!("Error accepting connection: {}", e);
+
+                    // deregister listener temporary
+                    self.deregister_logged(info);
+
+                    // 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));
+                    self.set_timeout(TIMEOUT_DURATION_ON_ERROR);
+
+                    return;
+                }
+            };
+        }
+    }
+
+    fn accept_all(&mut self, sockets: &mut [ServerSocketInfo]) {
+        sockets
+            .iter_mut()
+            .map(|info| info.token)
+            .collect::<Vec<_>>()
+            .into_iter()
+            .for_each(|idx| self.accept(sockets, idx))
+    }
+
+    #[inline(always)]
+    fn next(&self) -> &WorkerHandleAccept {
+        &self.handles[self.next]
+    }
+
+    /// Set next worker handle that would accept connection.
+    #[inline(always)]
+    fn set_next(&mut self) {
+        self.next = (self.next + 1) % self.handles.len();
+    }
+
+    /// Remove next worker handle that fail to accept connection.
+    fn remove_next(&mut self) {
+        let handle = self.handles.swap_remove(self.next);
+        let idx = handle.idx();
+        // A message is sent to `ServerBuilder` future to notify it a new worker
+        // should be made.
+        self.srv.worker_faulted(idx);
+        self.avail.set_available(idx, false);
+    }
+}
+
+/// This function defines errors that are per-connection; if we get this error from the `accept()`
+/// system call it means the next connection might be ready to be accepted.
+///
+/// All other errors will incur a timeout before next `accept()` call is attempted. The timeout is
+/// useful to handle resource exhaustion errors like `ENFILE` and `EMFILE`. Otherwise, it could
+/// enter into a temporary spin loop.
+fn connection_error(e: &io::Error) -> bool {
+    e.kind() == io::ErrorKind::ConnectionRefused
+        || e.kind() == io::ErrorKind::ConnectionAborted
+        || e.kind() == io::ErrorKind::ConnectionReset
 }

actix-server/src/availability.rs

@@ -0,0 +1,121 @@
+use crate::worker::WorkerHandleAccept;
+
+/// Array of u128 with every bit as marker for a worker handle's availability.
+#[derive(Debug, Default)]
+pub(crate) struct Availability([u128; 4]);
+
+impl Availability {
+    /// Check if any worker handle is available
+    #[inline(always)]
+    pub(crate) fn available(&self) -> bool {
+        self.0.iter().any(|a| *a != 0)
+    }
+
+    /// Check if worker handle is available by index
+    #[inline(always)]
+    pub(crate) fn get_available(&self, idx: usize) -> bool {
+        let (offset, idx) = Self::offset(idx);
+
+        self.0[offset] & (1 << idx as u128) != 0
+    }
+
+    /// Set worker handle available state by index.
+    pub(crate) fn set_available(&mut self, idx: usize, avail: bool) {
+        let (offset, idx) = Self::offset(idx);
+
+        let off = 1 << idx as u128;
+        if avail {
+            self.0[offset] |= off;
+        } else {
+            self.0[offset] &= !off
+        }
+    }
+
+    /// Set all worker handle to available state.
+    /// This would result in a re-check on all workers' availability.
+    pub(crate) fn set_available_all(&mut self, handles: &[WorkerHandleAccept]) {
+        handles.iter().for_each(|handle| {
+            self.set_available(handle.idx(), true);
+        })
+    }
+
+    /// Get offset and adjusted index of given worker handle index.
+    pub(crate) fn offset(idx: usize) -> (usize, usize) {
+        if idx < 128 {
+            (0, idx)
+        } else if idx < 128 * 2 {
+            (1, idx - 128)
+        } else if idx < 128 * 3 {
+            (2, idx - 128 * 2)
+        } else if idx < 128 * 4 {
+            (3, idx - 128 * 3)
+        } else {
+            panic!("Max WorkerHandle count is 512")
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn single(aval: &mut Availability, idx: usize) {
+        aval.set_available(idx, true);
+        assert!(aval.available());
+
+        aval.set_available(idx, true);
+
+        aval.set_available(idx, false);
+        assert!(!aval.available());
+
+        aval.set_available(idx, false);
+        assert!(!aval.available());
+    }
+
+    fn multi(aval: &mut Availability, mut idx: Vec<usize>) {
+        idx.iter().for_each(|idx| aval.set_available(*idx, true));
+
+        assert!(aval.available());
+
+        while let Some(idx) = idx.pop() {
+            assert!(aval.available());
+            aval.set_available(idx, false);
+        }
+
+        assert!(!aval.available());
+    }
+
+    #[test]
+    fn availability() {
+        let mut aval = Availability::default();
+
+        single(&mut aval, 1);
+        single(&mut aval, 128);
+        single(&mut aval, 256);
+        single(&mut aval, 511);
+
+        let idx = (0..511).filter(|i| i % 3 == 0 && i % 5 == 0).collect();
+
+        multi(&mut aval, idx);
+
+        multi(&mut aval, (0..511).collect())
+    }
+
+    #[test]
+    #[should_panic]
+    fn overflow() {
+        let mut aval = Availability::default();
+        single(&mut aval, 512);
+    }
+
+    #[test]
+    fn pin_point() {
+        let mut aval = Availability::default();
+
+        aval.set_available(438, true);
+
+        aval.set_available(479, true);
+
+        assert_eq!(aval.0[3], 1 << (438 - 384) | 1 << (479 - 384));
+    }
+}

actix-server/src/builder.rs

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

actix-server/src/config.rs

@@ -1,284 +0,0 @@
-use std::collections::HashMap;
-use std::{fmt, io, net};
-
-use actix_rt::net::TcpStream;
-use actix_service::{
-    fn_service, IntoServiceFactory as IntoBaseServiceFactory,
-    ServiceFactory as BaseServiceFactory,
-};
-use actix_utils::counter::CounterGuard;
-use futures_util::future::{ok, Future, FutureExt, LocalBoxFuture};
-use log::error;
-
-use super::builder::bind_addr;
-use super::service::{BoxedServerService, InternalServiceFactory, StreamService};
-use super::Token;
-use crate::socket::StdStream;
-
-pub struct ServiceConfig {
-    pub(crate) services: Vec<(String, net::TcpListener)>,
-    pub(crate) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
-    pub(crate) threads: usize,
-    pub(crate) backlog: i32,
-}
-
-impl ServiceConfig {
-    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
-        ServiceConfig {
-            threads,
-            backlog,
-            services: Vec::new(),
-            apply: None,
-        }
-    }
-
-    /// Set number of workers to start.
-    ///
-    /// By default server uses number of available logical cpu as workers
-    /// count.
-    pub fn workers(&mut self, num: usize) {
-        self.threads = num;
-    }
-
-    /// Add new service to server
-    pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
-    where
-        U: net::ToSocketAddrs,
-    {
-        let sockets = bind_addr(addr, self.backlog)?;
-
-        for lst in sockets {
-            self.listen(name.as_ref(), lst);
-        }
-
-        Ok(self)
-    }
-
-    /// Add new service to server
-    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
-        if self.apply.is_none() {
-            self.apply = Some(Box::new(not_configured));
-        }
-        self.services.push((name.as_ref().to_string(), lst));
-        self
-    }
-
-    /// Register service configuration function. This function get called
-    /// during worker runtime configuration. It get executed in worker thread.
-    pub fn apply<F>(&mut self, f: F) -> io::Result<()>
-    where
-        F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
-    {
-        self.apply = Some(Box::new(f));
-        Ok(())
-    }
-}
-
-pub(super) struct ConfiguredService {
-    rt: Box<dyn ServiceRuntimeConfiguration>,
-    names: HashMap<Token, (String, net::SocketAddr)>,
-    topics: HashMap<String, Token>,
-    services: Vec<Token>,
-}
-
-impl ConfiguredService {
-    pub(super) fn new(rt: Box<dyn ServiceRuntimeConfiguration>) -> Self {
-        ConfiguredService {
-            rt,
-            names: HashMap::new(),
-            topics: HashMap::new(),
-            services: Vec::new(),
-        }
-    }
-
-    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
-        self.names.insert(token, (name.clone(), addr));
-        self.topics.insert(name, token);
-        self.services.push(token);
-    }
-}
-
-impl InternalServiceFactory for ConfiguredService {
-    fn name(&self, token: Token) -> &str {
-        &self.names[&token].0
-    }
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
-        Box::new(Self {
-            rt: self.rt.clone(),
-            names: self.names.clone(),
-            topics: self.topics.clone(),
-            services: self.services.clone(),
-        })
-    }
-
-    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
-        // configure services
-        let mut rt = ServiceRuntime::new(self.topics.clone());
-        self.rt.configure(&mut rt);
-        rt.validate();
-        let mut names = self.names.clone();
-        let tokens = self.services.clone();
-
-        // construct services
-        async move {
-            let mut services = rt.services;
-            // TODO: Proper error handling here
-            for f in rt.onstart.into_iter() {
-                f.await;
-            }
-            let mut res = vec![];
-            for token in tokens {
-                if let Some(srv) = services.remove(&token) {
-                    let newserv = srv.new_service(());
-                    match newserv.await {
-                        Ok(serv) => {
-                            res.push((token, serv));
-                        }
-                        Err(_) => {
-                            error!("Can not construct service");
-                            return Err(());
-                        }
-                    }
-                } else {
-                    let name = names.remove(&token).unwrap().0;
-                    res.push((
-                        token,
-                        Box::new(StreamService::new(fn_service(move |_: TcpStream| {
-                            error!("Service {:?} is not configured", name);
-                            ok::<_, ()>(())
-                        }))),
-                    ));
-                };
-            }
-            Ok(res)
-        }
-        .boxed_local()
-    }
-}
-
-pub(super) trait ServiceRuntimeConfiguration: Send {
-    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration>;
-
-    fn configure(&self, rt: &mut ServiceRuntime);
-}
-
-impl<F> ServiceRuntimeConfiguration for F
-where
-    F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
-{
-    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration> {
-        Box::new(self.clone())
-    }
-
-    fn configure(&self, rt: &mut ServiceRuntime) {
-        (self)(rt)
-    }
-}
-
-fn not_configured(_: &mut ServiceRuntime) {
-    error!("Service is not configured");
-}
-
-pub struct ServiceRuntime {
-    names: HashMap<String, Token>,
-    services: HashMap<Token, BoxedNewService>,
-    onstart: Vec<LocalBoxFuture<'static, ()>>,
-}
-
-impl ServiceRuntime {
-    fn new(names: HashMap<String, Token>) -> Self {
-        ServiceRuntime {
-            names,
-            services: HashMap::new(),
-            onstart: Vec::new(),
-        }
-    }
-
-    fn validate(&self) {
-        for (name, token) in &self.names {
-            if !self.services.contains_key(&token) {
-                error!("Service {:?} is not configured", name);
-            }
-        }
-    }
-
-    /// Register service.
-    ///
-    /// Name of the service must be registered during configuration stage with
-    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
-    pub fn service<T, F>(&mut self, name: &str, service: F)
-    where
-        F: IntoBaseServiceFactory<T, TcpStream>,
-        T: BaseServiceFactory<TcpStream, Config = ()> + 'static,
-        T::Future: 'static,
-        T::Service: 'static,
-        T::InitError: fmt::Debug,
-    {
-        // let name = name.to_owned();
-        if let Some(token) = self.names.get(name) {
-            self.services.insert(
-                *token,
-                Box::new(ServiceFactory {
-                    inner: service.into_factory(),
-                }),
-            );
-        } else {
-            panic!("Unknown service: {:?}", name);
-        }
-    }
-
-    /// Execute future before services initialization.
-    pub fn on_start<F>(&mut self, fut: F)
-    where
-        F: Future<Output = ()> + 'static,
-    {
-        self.onstart.push(fut.boxed_local())
-    }
-}
-
-type BoxedNewService = Box<
-    dyn BaseServiceFactory<
-        (Option<CounterGuard>, StdStream),
-        Response = (),
-        Error = (),
-        InitError = (),
-        Config = (),
-        Service = BoxedServerService,
-        Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>,
-    >,
->;
-
-struct ServiceFactory<T> {
-    inner: T,
-}
-
-impl<T> BaseServiceFactory<(Option<CounterGuard>, StdStream)> for ServiceFactory<T>
-where
-    T: BaseServiceFactory<TcpStream, Config = ()>,
-    T::Future: 'static,
-    T::Service: 'static,
-    T::Error: 'static,
-    T::InitError: fmt::Debug + 'static,
-{
-    type Response = ();
-    type Error = ();
-    type Config = ();
-    type Service = BoxedServerService;
-    type InitError = ();
-    type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let fut = self.inner.new_service(());
-        async move {
-            match fut.await {
-                Ok(s) => Ok(Box::new(StreamService::new(s)) as BoxedServerService),
-                Err(e) => {
-                    error!("Can not construct service: {:?}", e);
-                    Err(())
-                }
-            }
-        }
-        .boxed_local()
-    }
-}

actix-server/src/handle.rs

@@ -0,0 +1,55 @@
+use std::future::Future;
+
+use tokio::sync::{mpsc::UnboundedSender, oneshot};
+
+use crate::server::ServerCommand;
+
+/// Server handle.
+#[derive(Debug, Clone)]
+pub struct ServerHandle {
+    cmd_tx: UnboundedSender<ServerCommand>,
+}
+
+impl ServerHandle {
+    pub(crate) fn new(cmd_tx: UnboundedSender<ServerCommand>) -> Self {
+        ServerHandle { cmd_tx }
+    }
+
+    pub(crate) fn worker_faulted(&self, idx: usize) {
+        let _ = self.cmd_tx.send(ServerCommand::WorkerFaulted(idx));
+    }
+
+    /// Pause accepting incoming connections.
+    ///
+    /// May drop socket pending connection. All open connections remain active.
+    pub fn pause(&self) -> impl Future<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.cmd_tx.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.cmd_tx.send(ServerCommand::Resume(tx));
+        async {
+            let _ = rx.await;
+        }
+    }
+
+    /// Stop incoming connection processing, stop all workers and exit.
+    pub fn stop(&self, graceful: bool) -> impl Future<Output = ()> {
+        let (tx, rx) = oneshot::channel();
+
+        let _ = self.cmd_tx.send(ServerCommand::Stop {
+            graceful,
+            completion: Some(tx),
+        });
+
+        async {
+            let _ = rx.await;
+        }
+    }
+}

actix-server/src/join_all.rs

@@ -0,0 +1,78 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures_core::future::BoxFuture;
+
+// 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> + Send + 'static>) -> JoinAll<T> {
+    let fut = fut
+        .into_iter()
+        .map(|f| JoinFuture::Future(Box::pin(f)))
+        .collect();
+
+    JoinAll { fut }
+}
+
+enum JoinFuture<T> {
+    Future(BoxFuture<'static, 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::*;
+
+    use actix_utils::future::ready;
+
+    #[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/lib.rs

@@ -5,35 +5,30 @@
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 mod accept;
+mod availability;
 mod builder;
-mod config;
+mod handle;
+mod join_all;
 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::handle::ServerHandle;
 pub use self::server::Server;
 pub use self::service::ServiceFactory;
+pub use self::test_server::TestServer;
 
 #[doc(hidden)]
 pub use self::socket::FromStream;
 
-/// Socket ID token
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct Token(usize);
-
-impl Token {
-    pub(crate) fn next(&mut self) -> Token {
-        let token = Token(self.0);
-        self.0 += 1;
-        token
-    }
-}
-
 /// Start server building process
+#[doc(hidden)]
+#[deprecated(since = "2.0.0", note = "Use `Server::build()`.")]
 pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }

actix-server/src/server.rs

@@ -1,108 +1,359 @@
-use std::future::Future;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    future::Future,
+    io, mem,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
 
-use futures_channel::mpsc::UnboundedSender;
-use futures_channel::oneshot;
-use futures_util::FutureExt;
+use actix_rt::{time::sleep, System};
+use futures_core::future::BoxFuture;
+use log::{error, info};
+use tokio::sync::{
+    mpsc::{UnboundedReceiver, UnboundedSender},
+    oneshot,
+};
 
-use crate::builder::ServerBuilder;
-use crate::signals::Signal;
+use crate::{
+    accept::Accept,
+    builder::ServerBuilder,
+    join_all::join_all,
+    service::InternalServiceFactory,
+    signals::{Signal, Signals},
+    waker_queue::{WakerInterest, WakerQueue},
+    worker::{ServerWorker, ServerWorkerConfig, WorkerHandleServer},
+    ServerHandle,
+};
 
 #[derive(Debug)]
 pub(crate) enum ServerCommand {
+    /// TODO
     WorkerFaulted(usize),
+
+    /// Contains return channel to notify caller of successful state change.
     Pause(oneshot::Sender<()>),
+
+    /// Contains return channel to notify caller of successful state change.
     Resume(oneshot::Sender<()>),
-    Signal(Signal),
-    /// Whether to try and shut down gracefully
+
+    /// TODO
     Stop {
+        /// True if shut down should be graceful.
         graceful: bool,
+
+        /// Return channel to notify caller that shutdown is complete.
         completion: Option<oneshot::Sender<()>>,
     },
-    /// Notify of server stop
-    Notify(oneshot::Sender<()>),
 }
 
-#[derive(Debug)]
-pub struct Server(
-    UnboundedSender<ServerCommand>,
-    Option<oneshot::Receiver<()>>,
-);
+/// General purpose TCP server that runs services receiving Tokio `TcpStream`s.
+///
+/// Handles creating worker threads, restarting faulted workers, connection accepting, and
+/// back-pressure logic.
+///
+/// Creates a worker per CPU core (or the number specified in [`ServerBuilder::workers`]) and
+/// distributes connections with a round-robin strategy.
+///
+/// The [Server] must be awaited to process stop commands and listen for OS signals. It will resolve
+/// when the server has fully shut down.
+///
+/// # Shutdown Signals
+/// On UNIX systems, `SIGQUIT` will start a graceful shutdown and `SIGTERM` or `SIGINT` will start a
+/// forced shutdown. On Windows, a Ctrl-C signal will start a forced shutdown.
+///
+/// A graceful shutdown will wait for all workers to stop first.
+///
+/// # Examples
+/// The following is a TCP echo server. Test using `telnet 127.0.0.1 8080`.
+///
+/// ```no_run
+/// use std::io;
+///
+/// use actix_rt::net::TcpStream;
+/// use actix_server::Server;
+/// use actix_service::{fn_service, ServiceFactoryExt as _};
+/// use bytes::BytesMut;
+/// use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     let bind_addr = ("127.0.0.1", 8080);
+///
+///     Server::build()
+///         .bind("echo", bind_addr, move || {
+///             fn_service(move |mut stream: TcpStream| {
+///                 async move {
+///                     let mut size = 0;
+///                     let mut buf = BytesMut::new();
+///
+///                     loop {
+///                         match stream.read_buf(&mut buf).await {
+///                             // end of stream; bail from loop
+///                             Ok(0) => break,
+///
+///                             // write bytes back to stream
+///                             Ok(bytes_read) => {
+///                                 stream.write_all(&buf[size..]).await.unwrap();
+///                                 size += bytes_read;
+///                             }
+///
+///                             Err(err) => {
+///                                 eprintln!("Stream Error: {:?}", err);
+///                                 return Err(());
+///                             }
+///                         }
+///                     }
+///
+///                     Ok(())
+///                 }
+///             })
+///             .map_err(|err| eprintln!("Service Error: {:?}", err))
+///         })?
+///         .run()
+///         .await
+/// }
+/// ```
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub enum Server {
+    Server(ServerInner),
+    Error(Option<io::Error>),
+}
 
 impl Server {
-    pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
-        Server(tx, None)
-    }
-
-    /// Start server building process
+    /// Create server build.
     pub fn build() -> ServerBuilder {
         ServerBuilder::default()
     }
 
-    pub(crate) fn signal(&self, sig: Signal) {
-        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+    pub(crate) fn new(mut builder: ServerBuilder) -> Self {
+        let sockets = mem::take(&mut builder.sockets)
+            .into_iter()
+            .map(|t| (t.0, t.2))
+            .collect();
+
+        // Give log information on what runtime will be used.
+        let is_actix = actix_rt::System::try_current().is_some();
+        let is_tokio = tokio::runtime::Handle::try_current().is_ok();
+
+        match (is_actix, is_tokio) {
+            (false, true) => info!("Tokio runtime found. Starting in existing Tokio runtime"),
+            (true, _) => info!("Actix runtime found. Starting in Actix runtime"),
+            (_, _) => info!(
+                "Actix/Tokio runtime not found. Starting in newt Tokio current-thread runtime"
+            ),
+        }
+
+        for (_, name, lst) in &builder.sockets {
+            info!(
+                r#"Starting service: "{}", workers: {}, listening on: {}"#,
+                name,
+                builder.threads,
+                lst.local_addr()
+            );
+        }
+
+        match Accept::start(sockets, &builder) {
+            Ok((waker_queue, worker_handles)) => {
+                // construct OS signals listener future
+                let signals = (builder.listen_os_signals).then(Signals::new);
+
+                Self::Server(ServerInner {
+                    cmd_tx: builder.cmd_tx.clone(),
+                    cmd_rx: builder.cmd_rx,
+                    signals,
+                    waker_queue,
+                    worker_handles,
+                    worker_config: builder.worker_config,
+                    services: builder.factories,
+                    exit: builder.exit,
+                    stop_task: None,
+                })
+            }
+
+            Err(err) => Self::Error(Some(err)),
+        }
     }
 
-    pub(crate) fn worker_faulted(&self, idx: usize) {
-        let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(idx));
-    }
-
-    /// Pause accepting incoming connections
+    /// Get a handle for ServerFuture that can be used to change state of actix server.
     ///
-    /// If socket contains some pending connection, they might be dropped.
-    /// All opened connection remains active.
-    pub fn pause(&self) -> impl Future<Output = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
-        rx.map(|_| ())
-    }
-
-    /// Resume accepting incoming connections
-    pub fn resume(&self) -> impl Future<Output = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
-        rx.map(|_| ())
-    }
-
-    /// Stop incoming connection processing, stop all workers and exit.
-    ///
-    /// If server starts with `spawn()` method, then spawned thread get terminated.
-    pub fn stop(&self, graceful: bool) -> impl Future<Output = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Stop {
-            graceful,
-            completion: Some(tx),
-        });
-        rx.map(|_| ())
-    }
-}
-
-impl Clone for Server {
-    fn clone(&self) -> Self {
-        Self(self.0.clone(), None)
+    /// See [ServerHandle](ServerHandle) for usage.
+    pub fn handle(&self) -> ServerHandle {
+        match self {
+            Server::Server(inner) => ServerHandle::new(inner.cmd_tx.clone()),
+            Server::Error(err) => {
+                // TODO: i don't think this is the best way to handle server startup fail
+                panic!(
+                    "server handle can not be obtained because server failed to start up: {}",
+                    err.as_ref().unwrap()
+                );
+            }
+        }
     }
 }
 
 impl Future for Server {
     type Output = io::Result<()>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.as_mut().get_mut() {
+            Self::Error(err) => Poll::Ready(Err(err
+                .take()
+                .expect("Server future cannot be polled after error"))),
 
-        if this.1.is_none() {
-            let (tx, rx) = oneshot::channel();
-            if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() {
-                return Poll::Ready(Ok(()));
+            Self::Server(inner) => {
+                // poll Signals
+                if let Some(ref mut signals) = inner.signals {
+                    if let Poll::Ready(signal) = Pin::new(signals).poll(cx) {
+                        inner.stop_task = inner.handle_signal(signal);
+                        // drop signals listener
+                        inner.signals = None;
+                    }
+                }
+
+                // handle stop tasks and eager drain command channel
+                loop {
+                    if let Some(ref mut fut) = inner.stop_task {
+                        // only resolve stop task and exit
+                        return fut.as_mut().poll(cx).map(|_| Ok(()));
+                    }
+
+                    match Pin::new(&mut inner.cmd_rx).poll_recv(cx) {
+                        Poll::Ready(Some(cmd)) => {
+                            // if stop task is required, set it and loop
+                            inner.stop_task = inner.handle_cmd(cmd);
+                        }
+                        _ => return Poll::Pending,
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub struct ServerInner {
+    worker_handles: Vec<WorkerHandleServer>,
+    worker_config: ServerWorkerConfig,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    exit: bool,
+    cmd_tx: UnboundedSender<ServerCommand>,
+    cmd_rx: UnboundedReceiver<ServerCommand>,
+    signals: Option<Signals>,
+    waker_queue: WakerQueue,
+    stop_task: Option<BoxFuture<'static, ()>>,
+}
+
+impl ServerInner {
+    fn handle_cmd(&mut self, item: ServerCommand) -> Option<BoxFuture<'static, ()>> {
+        match item {
+            ServerCommand::Pause(tx) => {
+                self.waker_queue.wake(WakerInterest::Pause);
+                let _ = tx.send(());
+                None
+            }
+
+            ServerCommand::Resume(tx) => {
+                self.waker_queue.wake(WakerInterest::Resume);
+                let _ = tx.send(());
+                None
+            }
+
+            ServerCommand::Stop {
+                graceful,
+                completion,
+            } => {
+                let exit = self.exit;
+
+                // stop accept thread
+                self.waker_queue.wake(WakerInterest::Stop);
+
+                // stop workers
+                let workers_stop = self
+                    .worker_handles
+                    .iter()
+                    .map(|worker| worker.stop(graceful))
+                    .collect::<Vec<_>>();
+
+                Some(Box::pin(async move {
+                    if graceful {
+                        // wait for all workers to shut down
+                        let _ = join_all(workers_stop).await;
+                    }
+
+                    if let Some(tx) = completion {
+                        let _ = tx.send(());
+                    }
+
+                    if exit {
+                        sleep(Duration::from_millis(300)).await;
+                        System::try_current().as_ref().map(System::stop);
+                    }
+                }))
+            }
+
+            ServerCommand::WorkerFaulted(idx) => {
+                // TODO: maybe just return with warning log if not found ?
+                assert!(self.worker_handles.iter().any(|wrk| wrk.idx == idx));
+
+                error!("Worker {} has died; restarting", idx);
+
+                let factories = self
+                    .services
+                    .iter()
+                    .map(|service| service.clone_factory())
+                    .collect();
+
+                match ServerWorker::start(
+                    idx,
+                    factories,
+                    self.waker_queue.clone(),
+                    self.worker_config,
+                ) {
+                    Ok((handle_accept, handle_server)) => {
+                        *self
+                            .worker_handles
+                            .iter_mut()
+                            .find(|wrk| wrk.idx == idx)
+                            .unwrap() = handle_server;
+
+                        self.waker_queue.wake(WakerInterest::Worker(handle_accept));
+                    }
+
+                    Err(err) => error!("can not restart worker {}: {}", idx, err),
+                };
+
+                None
+            }
+        }
+    }
+
+    fn handle_signal(&mut self, signal: Signal) -> Option<BoxFuture<'static, ()>> {
+        match signal {
+            Signal::Int => {
+                info!("SIGINT received; starting forced shutdown");
+                self.exit = true;
+                self.handle_cmd(ServerCommand::Stop {
+                    graceful: false,
+                    completion: None,
+                })
+            }
+
+            Signal::Term => {
+                info!("SIGTERM received; starting graceful shutdown");
+                self.exit = true;
+                self.handle_cmd(ServerCommand::Stop {
+                    graceful: true,
+                    completion: None,
+                })
+            }
+
+            Signal::Quit => {
+                info!("SIGQUIT received; starting forced shutdown");
+                self.exit = true;
+                self.handle_cmd(ServerCommand::Stop {
+                    graceful: false,
+                    completion: None,
+                })
             }
-            this.1 = Some(rx);
-        }
-
-        match Pin::new(this.1.as_mut().unwrap()).poll(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
-            Poll::Ready(Err(_)) => Poll::Ready(Ok(())),
         }
     }
 }

actix-server/src/service.rs

@@ -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 actix_utils::future::{ready, Ready};
+use futures_core::future::LocalBoxFuture;
 use log::error;
 
-use super::Token;
-use crate::socket::{FromStream, StdStream};
+use crate::socket::{FromStream, MioStream};
+use crate::worker::WorkerCounterGuard;
 
 pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
     type Factory: BaseServiceFactory<Stream, Config = ()>;
@@ -19,16 +17,16 @@ pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
 }
 
 pub(crate) trait InternalServiceFactory: Send {
-    fn name(&self, token: Token) -> &str;
+    fn name(&self, token: usize) -> &str;
 
     fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
 
-    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>>;
+    fn create(&self) -> LocalBoxFuture<'static, Result<(usize, BoxedServerService), ()>>;
 }
 
 pub(crate) type BoxedServerService = Box<
     dyn Service<
-        (Option<CounterGuard>, StdStream),
+        (WorkerCounterGuard, 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<(WorkerCounterGuard, MioStream)> for StreamService<S, I>
 where
     S: Service<I>,
     S::Future: 'static,
@@ -60,32 +58,32 @@ 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): (WorkerCounterGuard, 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(())
             }
-        }
+        })
     }
 }
 
 pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
     name: String,
     inner: F,
-    token: Token,
+    token: usize,
     addr: SocketAddr,
     _t: PhantomData<Io>,
 }
@@ -97,7 +95,7 @@ where
 {
     pub(crate) fn create(
         name: String,
-        token: Token,
+        token: usize,
         inner: F,
         addr: SocketAddr,
     ) -> Box<dyn InternalServiceFactory> {
@@ -116,7 +114,7 @@ where
     F: ServiceFactory<Io>,
     Io: FromStream + Send + 'static,
 {
-    fn name(&self, _: Token) -> &str {
+    fn name(&self, _: usize) -> &str {
         &self.name
     }
 
@@ -130,17 +128,18 @@ where
         })
     }
 
-    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
+    fn create(&self) -> LocalBoxFuture<'static, Result<(usize, 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((token, service))
+                }
+                Err(_) => Err(()),
+            }
+        })
     }
 }
 

actix-server/src/signals.rs

@@ -1,99 +1,108 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    fmt,
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
-use futures_util::future::lazy;
+use log::trace;
 
-use crate::server::Server;
-
-/// Different types of process signals
-#[allow(dead_code)]
-#[derive(PartialEq, Clone, Copy, Debug)]
+/// Types of process signals.
+// #[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(dead_code)] // variants are never constructed on non-unix
 pub(crate) enum Signal {
-    /// SIGHUP
-    Hup,
-    /// SIGINT
+    /// `SIGINT`
     Int,
-    /// SIGTERM
+
+    /// `SIGTERM`
     Term,
-    /// SIGQUIT
+
+    /// `SIGQUIT`
     Quit,
 }
 
+impl fmt::Display for Signal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Signal::Int => "SIGINT",
+            Signal::Term => "SIGTERM",
+            Signal::Quit => "SIGQUIT",
+        })
+    }
+}
+
+/// Process signal listener.
 pub(crate) struct Signals {
-    srv: Server,
     #[cfg(not(unix))]
-    stream: Pin<Box<dyn Future<Output = std::io::Result<()>>>>,
+    signals: futures_core::future::BoxFuture<'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()),
-                });
+    /// Constructs an OS signal listening future.
+    pub(crate) fn new() -> Self {
+        trace!("setting up OS signal listener");
+
+        #[cfg(not(unix))]
+        {
+            Signals {
+                signals: Box::pin(actix_rt::signal::ctrl_c()),
             }
-            #[cfg(unix)]
-            {
-                use actix_rt::signal::unix;
+        }
 
-                let mut streams = Vec::new();
+        #[cfg(unix)]
+        {
+            use actix_rt::signal::unix;
 
-                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::terminate(), Signal::Term),
+                (unix::SignalKind::quit(), Signal::Quit),
+            ];
 
-                for (kind, sig) in sig_map.iter() {
-                    match unix::signal(*kind) {
-                        Ok(stream) => streams.push((*sig, stream)),
-                        Err(e) => log::error!(
-                            "Can not initialize stream handler for {:?} err: {}",
-                            sig,
-                            e
-                        ),
-                    }
-                }
+            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<_>>();
 
-                actix_rt::spawn(Signals { srv, streams })
-            }
-        }));
+            Signals { signals }
+        }
     }
 }
 
 impl Future for Signals {
-    type Output = ();
+    type Output = Signal;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         #[cfg(not(unix))]
-        match Pin::new(&mut self.stream).poll(cx) {
-            Poll::Ready(_) => {
-                self.srv.signal(Signal::Int);
-                Poll::Ready(())
-            }
-            Poll::Pending => return Poll::Pending,
+        {
+            self.signals.as_mut().poll(cx).map(|_| Signal::Int)
         }
+
         #[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() {
+                // TODO: match on if let Some ?
+                if Pin::new(fut).poll_recv(cx).is_ready() {
+                    trace!("{} received", sig);
+                    return Poll::Ready(*sig);
                 }
             }
+
             Poll::Pending
         }
     }

actix-server/src/socket.rs

@@ -1,135 +1,82 @@
-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;
+#[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, Interest, Registry, Token};
 
-pub(crate) enum StdListener {
-    Tcp(net::TcpListener),
-    #[cfg(all(unix))]
-    Uds(std::os::unix::net::UnixListener),
+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) => lst
+                .local_addr()
+                .map(SocketAddr::Tcp)
+                .unwrap_or(SocketAddr::Unknown),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => lst
+                .local_addr()
+                .map(SocketAddr::Uds)
+                .unwrap_or(SocketAddr::Unknown),
+        }
+    }
+
+    pub(crate) fn accept(&self) -> io::Result<MioStream> {
+        match *self {
+            MioListener::Tcp(ref lst) => lst.accept().map(|(stream, _)| MioStream::Tcp(stream)),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => lst.accept().map(|(stream, _)| MioStream::Uds(stream)),
         }
     }
 }
 
-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 +90,185 @@ 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(_) => {
-                panic!("Should not happen, bug in server impl");
+            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),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
+        }
+    }
+}
+
+pub(crate) enum SocketAddr {
+    Unknown,
+    Tcp(StdSocketAddr),
+    #[cfg(unix)]
+    Uds(mio::net::SocketAddr),
+}
+
+impl fmt::Display for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::Unknown => write!(f, "Unknown SocketAddr"),
+            Self::Tcp(ref addr) => write!(f, "{}", addr),
+            #[cfg(unix)]
+            Self::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+impl fmt::Debug for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::Unknown => write!(f, "Unknown SocketAddr"),
+            Self::Tcp(ref addr) => write!(f, "{:?}", addr),
+            #[cfg(unix)]
+            Self::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum MioStream {
+    Tcp(mio::net::TcpStream),
+    #[cfg(unix)]
+    Uds(mio::net::UnixStream),
+}
+
+/// helper trait for converting mio stream to tokio stream.
+pub trait FromStream: Sized {
+    fn from_mio(sock: MioStream) -> io::Result<Self>;
+}
+
+#[cfg(windows)]
+mod win_impl {
+    use super::*;
+
+    use std::os::windows::io::{FromRawSocket, IntoRawSocket};
+
+    // FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+    impl FromStream for TcpStream {
+        fn from_mio(sock: MioStream) -> io::Result<Self> {
+            match sock {
+                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) })
+                }
             }
         }
     }
 }
 
-#[cfg(all(unix))]
-impl FromStream for actix_rt::net::UnixStream {
-    fn from_stdstream(sock: StdStream) -> io::Result<Self> {
-        match sock {
-            StdStream::Tcp(_) => panic!("Should not happen, bug in server impl"),
-            StdStream::Uds(stream) => actix_rt::net::UnixStream::from_std(stream),
+#[cfg(unix)]
+mod unix_impl {
+    use super::*;
+
+    use std::os::unix::io::{FromRawFd, IntoRawFd};
+
+    use actix_rt::net::UnixStream;
+
+    // FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+    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");
+                }
+            }
+        }
+    }
+
+    // FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream
+    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) })
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn create_mio_tcp_listener(
+    addr: StdSocketAddr,
+    backlog: u32,
+) -> io::Result<MioTcpListener> {
+    use socket2::{Domain, Protocol, Socket, Type};
+
+    let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
+
+    socket.set_reuse_address(true)?;
+    socket.set_nonblocking(true)?;
+    socket.bind(&addr.into())?;
+    socket.listen(backlog as i32)?;
+
+    Ok(MioTcpListener::from_std(StdTcpListener::from(socket)))
+}
+
+#[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 lst = create_mio_tcp_listener(addr, 128).unwrap();
+        let lst = MioListener::Tcp(lst);
+        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,30 +1,19 @@
-//! 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 std::{io, 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, ServerHandle, ServiceFactory};
 
-/// The `TestServer` type.
+/// A testing server.
 ///
-/// `TestServer` is very simple test server that simplify process of writing
-/// integration tests for actix-net applications.
+/// `TestServer` is very simple test server that simplify process of writing integration tests for
+/// network applications.
 ///
 /// # Examples
-///
-/// ```rust
+/// ```
 /// use actix_service::fn_service;
-/// use actix_testing::TestServer;
+/// use actix_server::TestServer;
 ///
 /// #[actix_rt::main]
 /// async fn main() {
@@ -45,11 +34,12 @@ pub struct TestServerRuntime {
     addr: net::SocketAddr,
     host: String,
     port: u16,
-    system: System,
+    server_handle: ServerHandle,
+    thread_handle: Option<thread::JoinHandle<io::Result<()>>>,
 }
 
 impl TestServer {
-    /// Start new server with server builder
+    /// Start new server with server builder.
     pub fn start<F>(mut factory: F) -> TestServerRuntime
     where
         F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static,
@@ -57,96 +47,96 @@ impl TestServer {
         let (tx, rx) = mpsc::channel();
 
         // run server in separate thread
-        thread::spawn(move || {
-            let sys = System::new("actix-test-server");
-            factory(Server::build())
-                .workers(1)
-                .disable_signals()
-                .start();
-
-            tx.send(System::current()).unwrap();
-            sys.run()
+        let thread_handle = thread::spawn(move || {
+            System::new().block_on(async {
+                let server = factory(Server::build()).workers(1).disable_signals().run();
+                tx.send(server.handle()).unwrap();
+                server.await
+            })
         });
-        let system = rx.recv().unwrap();
+
+        let server_handle = rx.recv().unwrap();
 
         TestServerRuntime {
-            system,
             addr: "127.0.0.1:0".parse().unwrap(),
             host: "127.0.0.1".to_string(),
             port: 0,
+            server_handle,
+            thread_handle: Some(thread_handle),
         }
     }
 
-    /// Start new test server with application factory
+    /// Start new test server with application factory.
     pub fn with<F: ServiceFactory<TcpStream>>(factory: F) -> TestServerRuntime {
         let (tx, rx) = mpsc::channel();
 
         // run server in separate thread
-        thread::spawn(move || {
-            let mut sys = System::new("actix-test-server");
+        let thread_handle = thread::spawn(move || {
+            let sys = System::new();
             let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
             let local_addr = tcp.local_addr().unwrap();
 
             sys.block_on(async {
-                Server::build()
+                let server = Server::build()
                     .listen("test", tcp, factory)
                     .unwrap()
                     .workers(1)
                     .disable_signals()
-                    .start();
-            });
+                    .run();
 
-            tx.send((System::current(), local_addr)).unwrap();
-            sys.run()
+                tx.send((server.handle(), local_addr)).unwrap();
+                server.await
+            })
         });
 
-        let (system, addr) = rx.recv().unwrap();
+        let (server_handle, addr) = rx.recv().unwrap();
 
         let host = format!("{}", addr.ip());
         let port = addr.port();
 
         TestServerRuntime {
-            system,
             addr,
             host,
             port,
+            server_handle,
+            thread_handle: Some(thread_handle),
         }
     }
 
-    /// Get first available unused local address
+    /// 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()
     }
 }
 
 impl TestServerRuntime {
-    /// Test server host
+    /// Test server host.
     pub fn host(&self) -> &str {
         &self.host
     }
 
-    /// Test server port
+    /// Test server port.
     pub fn port(&self) -> u16 {
         self.port
     }
 
-    /// Get test server address
+    /// Get test server address.
     pub fn addr(&self) -> net::SocketAddr {
         self.addr
     }
 
-    /// Stop http server
+    /// Stop server.
     fn stop(&mut self) {
-        self.system.stop();
+        let _ = self.server_handle.stop(false);
+        self.thread_handle.take().unwrap().join().unwrap().unwrap();
     }
 
-    /// Connect to server, return tokio TcpStream
+    /// Connect to server, returning a Tokio `TcpStream`.
     pub fn connect(&self) -> std::io::Result<TcpStream> {
         TcpStream::from_std(net::TcpStream::connect(self.addr)?)
     }
@@ -157,3 +147,16 @@ impl Drop for TestServerRuntime {
         self.stop()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use actix_service::fn_service;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn plain_tokio_runtime() {
+        let srv = TestServer::with(|| fn_service(|_sock| async move { Ok::<_, ()>(()) }));
+        assert!(srv.connect().is_ok());
+    }
+}

actix-server/src/waker_queue.rs

@@ -0,0 +1,84 @@
+use std::{
+    collections::VecDeque,
+    ops::Deref,
+    sync::{Arc, Mutex, MutexGuard},
+};
+
+use mio::{Registry, Token as MioToken, Waker};
+
+use crate::worker::WorkerHandleAccept;
+
+/// 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(usize),
+    /// `Pause`, `Resume`, `Stop` Interest are from `ServerBuilder` future. It listens to
+    /// `ServerCommand` and notify `Accept` to do exactly these tasks.
+    Pause,
+    Resume,
+    Stop,
+    /// `Worker` is an interest that is triggered after a worker faults. This is determined by
+    /// trying to send work to it. `Accept` would be waked up and add the new `WorkerHandleAccept`.
+    Worker(WorkerHandleAccept),
+}

actix-server/tests/test_server.rs

@@ -1,19 +1,21 @@
-use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{mpsc, Arc};
-use std::{net, thread, time};
+use std::{net, thread, time::Duration};
 
+use actix_rt::{net::TcpStream, time::sleep};
 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();
+    let socket =
+        Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP)).unwrap();
     socket.set_reuse_address(true).unwrap();
-    let tcp = socket.into_tcp_listener();
-    tcp.local_addr().unwrap()
+    socket.set_nonblocking(true).unwrap();
+    socket.bind(&addr.into()).unwrap();
+    socket.listen(32).unwrap();
+    net::TcpListener::from(socket).local_addr().unwrap()
 }
 
 #[test]
@@ -22,70 +24,111 @@ fn test_bind() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
-
-        let srv = sys.block_on(lazy(|_| {
-            Server::build()
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
                 .workers(1)
                 .disable_signals()
-                .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
-                .unwrap()
-                .start()
-        }));
-        let _ = tx.send((srv, actix_rt::System::current()));
-        let _ = sys.run();
-    });
-    let (_, sys) = rx.recv().unwrap();
+                .bind("test", addr, move || {
+                    fn_service(|_| async { Ok::<_, ()>(()) })
+                })?
+                .run();
 
-    thread::sleep(time::Duration::from_millis(500));
+            let _ = tx.send(srv.handle());
+
+            srv.await
+        })
+    });
+    let srv = rx.recv().unwrap();
+
+    thread::sleep(Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
-    sys.stop();
-    let _ = h.join();
+
+    let _ = srv.stop(true);
+    h.join().unwrap().unwrap();
+}
+
+#[test]
+fn plain_tokio_runtime() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        rt.block_on(async {
+            let srv = Server::build()
+                .workers(1)
+                .disable_signals()
+                .bind("test", addr, move || {
+                    fn_service(|_| async { Ok::<_, ()>(()) })
+                })?
+                .run();
+
+            tx.send(srv.handle()).unwrap();
+
+            srv.await
+        })
+    });
+
+    let srv = rx.recv().unwrap();
+
+    thread::sleep(Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+
+    let _ = srv.stop(true);
+    h.join().unwrap().unwrap();
 }
 
 #[test]
 fn test_listen() {
     let addr = unused_addr();
+    let lst = net::TcpListener::bind(addr).unwrap();
+
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
-        let lst = net::TcpListener::bind(addr).unwrap();
-        sys.block_on(lazy(|_| {
-            Server::build()
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
                 .disable_signals()
                 .workers(1)
-                .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
-                .unwrap()
-                .start()
-        }));
-        let _ = tx.send(actix_rt::System::current());
-        let _ = sys.run();
-    });
-    let sys = rx.recv().unwrap();
+                .listen("test", lst, move || {
+                    fn_service(|_| async { Ok::<_, ()>(()) })
+                })?
+                .run();
 
-    thread::sleep(time::Duration::from_millis(500));
+            let _ = tx.send(srv.handle());
+
+            srv.await
+        })
+    });
+
+    let srv = rx.recv().unwrap();
+
+    thread::sleep(Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
-    sys.stop();
-    let _ = h.join();
+
+    let _ = srv.stop(true);
+    h.join().unwrap().unwrap();
 }
 
 #[test]
 #[cfg(unix)]
 fn test_start() {
+    use std::io::Read;
+
     use actix_codec::{BytesCodec, Framed};
-    use actix_rt::net::TcpStream;
     use bytes::Bytes;
     use futures_util::sink::SinkExt;
-    use std::io::Read;
 
     let addr = unused_addr();
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let mut sys = actix_rt::System::new("test");
-        let srv = sys.block_on(lazy(|_| {
-            Server::build()
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
                 .backlog(100)
                 .disable_signals()
                 .bind("test", addr, move || {
@@ -94,14 +137,15 @@ fn test_start() {
                         f.send(Bytes::from_static(b"test")).await.unwrap();
                         Ok::<_, ()>(())
                     })
-                })
-                .unwrap()
-                .start()
-        }));
+                })?
+                .run();
 
-        let _ = tx.send((srv, actix_rt::System::current()));
-        let _ = sys.run();
+            let _ = tx.send((srv.handle(), actix_rt::System::current()));
+
+            srv.await
+        })
     });
+
     let (srv, sys) = rx.recv().unwrap();
 
     let mut buf = [1u8; 4];
@@ -111,16 +155,16 @@ fn test_start() {
 
     // pause
     let _ = srv.pause();
-    thread::sleep(time::Duration::from_millis(200));
+    thread::sleep(Duration::from_millis(200));
     let mut conn = net::TcpStream::connect(addr).unwrap();
-    conn.set_read_timeout(Some(time::Duration::from_millis(100)))
+    conn.set_read_timeout(Some(Duration::from_millis(100)))
         .unwrap();
     let res = conn.read_exact(&mut buf);
     assert!(res.is_err());
 
     // resume
     let _ = srv.resume();
-    thread::sleep(time::Duration::from_millis(100));
+    thread::sleep(Duration::from_millis(100));
     assert!(net::TcpStream::connect(addr).is_ok());
     assert!(net::TcpStream::connect(addr).is_ok());
     assert!(net::TcpStream::connect(addr).is_ok());
@@ -132,60 +176,314 @@ fn test_start() {
 
     // stop
     let _ = srv.stop(false);
-    thread::sleep(time::Duration::from_millis(100));
-    assert!(net::TcpStream::connect(addr).is_err());
-
-    thread::sleep(time::Duration::from_millis(100));
     sys.stop();
-    let _ = h.join();
+    h.join().unwrap().unwrap();
+
+    thread::sleep(Duration::from_secs(1));
+    assert!(net::TcpStream::connect(addr).is_err());
 }
 
-#[test]
-fn test_configure() {
-    let addr1 = unused_addr();
-    let addr2 = unused_addr();
-    let addr3 = unused_addr();
+#[actix_rt::test]
+async fn test_max_concurrent_connections() {
+    // Note:
+    // A tcp listener would accept connects based on it's backlog setting.
+    //
+    // The limit test on the other hand is only for concurrent tcp stream limiting a work
+    // thread accept.
+
+    use tokio::io::AsyncWriteExt;
+
+    let addr = unused_addr();
     let (tx, rx) = mpsc::channel();
-    let num = Arc::new(AtomicUsize::new(0));
-    let num2 = num.clone();
+
+    let counter = Arc::new(AtomicUsize::new(0));
+    let counter_clone = counter.clone();
+
+    let max_conn = 3;
 
     let h = thread::spawn(move || {
-        let num = num2.clone();
-        let mut sys = actix_rt::System::new("test");
-        let srv = sys.block_on(lazy(|_| {
-            Server::build()
-                .disable_signals()
-                .configure(move |cfg| {
-                    let num = num.clone();
-                    let lst = net::TcpListener::bind(addr3).unwrap();
-                    cfg.bind("addr1", addr1)
-                        .unwrap()
-                        .bind("addr2", addr2)
-                        .unwrap()
-                        .listen("addr3", lst)
-                        .apply(move |rt| {
-                            let num = num.clone();
-                            rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
-                            rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
-                            rt.on_start(lazy(move |_| {
-                                let _ = num.fetch_add(1, Relaxed);
-                            }))
-                        })
-                })
-                .unwrap()
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
+                // Set a relative higher backlog.
+                .backlog(12)
+                // max connection for a worker is 3.
+                .max_concurrent_connections(max_conn)
                 .workers(1)
-                .start()
-        }));
-        let _ = tx.send((srv, actix_rt::System::current()));
-        let _ = sys.run();
-    });
-    let (_, sys) = rx.recv().unwrap();
-    thread::sleep(time::Duration::from_millis(500));
+                .disable_signals()
+                .bind("test", addr, move || {
+                    let counter = counter.clone();
+                    fn_service(move |_io: TcpStream| {
+                        let counter = counter.clone();
+                        async move {
+                            counter.fetch_add(1, Ordering::SeqCst);
+                            sleep(Duration::from_secs(20)).await;
+                            counter.fetch_sub(1, Ordering::SeqCst);
+                            Ok::<(), ()>(())
+                        }
+                    })
+                })?
+                .run();
 
-    assert!(net::TcpStream::connect(addr1).is_ok());
-    assert!(net::TcpStream::connect(addr2).is_ok());
-    assert!(net::TcpStream::connect(addr3).is_ok());
-    assert_eq!(num.load(Relaxed), 1);
+            let _ = tx.send((srv.handle(), actix_rt::System::current()));
+
+            srv.await
+        })
+    });
+
+    let (srv, sys) = rx.recv().unwrap();
+
+    let mut conns = vec![];
+
+    for _ in 0..12 {
+        let conn = tokio::net::TcpStream::connect(addr).await.unwrap();
+        conns.push(conn);
+    }
+
+    sleep(Duration::from_secs(5)).await;
+
+    // counter would remain at 3 even with 12 successful connection.
+    // and 9 of them remain in backlog.
+    assert_eq!(max_conn, counter_clone.load(Ordering::SeqCst));
+
+    for mut conn in conns {
+        conn.shutdown().await.unwrap();
+    }
+
+    srv.stop(false).await;
     sys.stop();
-    let _ = h.join();
+    h.join().unwrap().unwrap();
+}
+
+#[actix_rt::test]
+async fn test_service_restart() {
+    use std::task::{Context, Poll};
+
+    use actix_service::{fn_factory, Service};
+    use futures_core::future::LocalBoxFuture;
+    use tokio::io::AsyncWriteExt;
+
+    struct TestService(Arc<AtomicUsize>);
+
+    impl Service<TcpStream> for TestService {
+        type Response = ();
+        type Error = ();
+        type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            let TestService(ref counter) = self;
+            let c = counter.fetch_add(1, Ordering::SeqCst);
+            // Force the service to restart on first readiness check.
+            if c > 0 {
+                Poll::Ready(Ok(()))
+            } else {
+                Poll::Ready(Err(()))
+            }
+        }
+
+        fn call(&self, _: TcpStream) -> Self::Future {
+            Box::pin(async { Ok(()) })
+        }
+    }
+
+    let addr1 = unused_addr();
+    let addr2 = unused_addr();
+    let (tx, rx) = mpsc::channel();
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = Arc::new(AtomicUsize::new(0));
+
+    let num_clone = num.clone();
+    let num2_clone = num2.clone();
+
+    let h = thread::spawn(move || {
+        let num = num.clone();
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
+                .backlog(1)
+                .disable_signals()
+                .bind("addr1", addr1, move || {
+                    let num = num.clone();
+                    fn_factory(move || {
+                        let num = num.clone();
+                        async move { Ok::<_, ()>(TestService(num)) }
+                    })
+                })?
+                .bind("addr2", addr2, move || {
+                    let num2 = num2.clone();
+                    fn_factory(move || {
+                        let num2 = num2.clone();
+                        async move { Ok::<_, ()>(TestService(num2)) }
+                    })
+                })?
+                .workers(1)
+                .run();
+
+            let _ = tx.send(srv.handle());
+            srv.await
+        })
+    });
+
+    let srv = rx.recv().unwrap();
+
+    for _ in 0..5 {
+        TcpStream::connect(addr1)
+            .await
+            .unwrap()
+            .shutdown()
+            .await
+            .unwrap();
+        TcpStream::connect(addr2)
+            .await
+            .unwrap()
+            .shutdown()
+            .await
+            .unwrap();
+    }
+
+    sleep(Duration::from_secs(3)).await;
+
+    assert!(num_clone.load(Ordering::SeqCst) > 5);
+    assert!(num2_clone.load(Ordering::SeqCst) > 5);
+
+    let _ = srv.stop(false);
+    h.join().unwrap().unwrap();
+}
+
+#[ignore] // non-deterministic on CI
+#[actix_rt::test]
+async fn worker_restart() {
+    use actix_service::{Service, ServiceFactory};
+    use futures_core::future::LocalBoxFuture;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    struct TestServiceFactory(Arc<AtomicUsize>);
+
+    impl ServiceFactory<TcpStream> for TestServiceFactory {
+        type Response = ();
+        type Error = ();
+        type Config = ();
+        type Service = TestService;
+        type InitError = ();
+        type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+        fn new_service(&self, _: Self::Config) -> Self::Future {
+            let counter = self.0.fetch_add(1, Ordering::Relaxed);
+
+            Box::pin(async move { Ok(TestService(counter)) })
+        }
+    }
+
+    struct TestService(usize);
+
+    impl Service<TcpStream> for TestService {
+        type Response = ();
+        type Error = ();
+        type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+        actix_service::always_ready!();
+
+        fn call(&self, stream: TcpStream) -> Self::Future {
+            let counter = self.0;
+
+            let mut stream = stream.into_std().unwrap();
+            use std::io::Write;
+            let str = counter.to_string();
+            let buf = str.as_bytes();
+
+            let mut written = 0;
+
+            while written < buf.len() {
+                if let Ok(n) = stream.write(&buf[written..]) {
+                    written += n;
+                }
+            }
+            stream.flush().unwrap();
+            stream.shutdown(net::Shutdown::Write).unwrap();
+
+            // force worker 2 to restart service once.
+            if counter == 2 {
+                panic!("panic on purpose")
+            } else {
+                Box::pin(async { Ok(()) })
+            }
+        }
+    }
+
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    let counter = Arc::new(AtomicUsize::new(1));
+    let h = thread::spawn(move || {
+        let counter = counter.clone();
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
+                .disable_signals()
+                .bind("addr", addr, move || TestServiceFactory(counter.clone()))?
+                .workers(2)
+                .run();
+
+            let _ = tx.send(srv.handle());
+
+            srv.await
+        })
+    });
+
+    let srv = rx.recv().unwrap();
+
+    sleep(Duration::from_secs(3)).await;
+
+    let mut buf = [0; 8];
+
+    // worker 1 would not restart and return it's id consistently.
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("1", id);
+    stream.shutdown().await.unwrap();
+
+    // worker 2 dead after return response.
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("2", id);
+    stream.shutdown().await.unwrap();
+
+    // request to worker 1
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("1", id);
+    stream.shutdown().await.unwrap();
+
+    // TODO: Remove sleep if it can pass CI.
+    sleep(Duration::from_secs(3)).await;
+
+    // worker 2 restarting and work goes to worker 1.
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("1", id);
+    stream.shutdown().await.unwrap();
+
+    // TODO: Remove sleep if it can pass CI.
+    sleep(Duration::from_secs(3)).await;
+
+    // worker 2 restarted but worker 1 was still the next to accept connection.
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("1", id);
+    stream.shutdown().await.unwrap();
+
+    // TODO: Remove sleep if it can pass CI.
+    sleep(Duration::from_secs(3)).await;
+
+    // worker 2 accept connection again but it's id is 3.
+    let mut stream = TcpStream::connect(addr).await.unwrap();
+    let n = stream.read(&mut buf).await.unwrap();
+    let id = String::from_utf8_lossy(&buf[0..n]);
+    assert_eq!("3", id);
+    stream.shutdown().await.unwrap();
+
+    let _ = srv.stop(false);
+    h.join().unwrap().unwrap();
 }

actix-service/CHANGES.md

@@ -1,6 +1,43 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 2.0.1 - 2021-10-11
+* Documentation fix.
+
+
+## 2.0.0 - 2021-04-16
+* Removed pipeline and related structs/functions. [#335]
+
+[#335]: https://github.com/actix/actix-net/pull/335
+
+
+## 2.0.0-beta.5 - 2021-03-15
+* Add default `Service` trait impl for `Rc<S: Service>` and `&S: Service`. [#288]
+* Add `boxed::rc_service` function for constructing `boxed::RcService` type [#290]
+
+[#288]: https://github.com/actix/actix-net/pull/288
+[#290]: https://github.com/actix/actix-net/pull/290
+
+
+## 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,17 +1,15 @@
 [package]
 name = "actix-service"
-version = "2.0.0-beta.1"
+version = "2.0.1"
 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"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-service"
-readme = "README.md"
-categories = ["network-programming", "asynchronous"]
+categories = ["network-programming", "asynchronous", "no-std"]
+repository = "https://github.com/actix/actix-net"
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
@@ -21,8 +19,10 @@ path = "src/lib.rs"
 
 [dependencies]
 futures-core = { version = "0.3.7", default-features = false }
+paste = "1"
 pin-project-lite = "0.2"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "2.0.0"
+actix-utils = "3.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.1)](https://docs.rs/actix-service/2.0.1)
+[![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.1/status.svg)](https://deps.rs/crate/actix-service/2.0.1)
+![Download](https://img.shields.io/crates/d/actix-service.svg)
+[![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/examples/clone.rs

@@ -0,0 +1,33 @@
+use std::{future::Future, sync::mpsc, time::Duration};
+
+async fn oracle<F, Fut>(f: F) -> (u32, u32)
+where
+    F: FnOnce() -> Fut + Clone + Send + 'static,
+    Fut: Future<Output = u32> + 'static,
+{
+    let f1 = actix_rt::spawn(f.clone()());
+    let f2 = actix_rt::spawn(f());
+
+    (f1.await.unwrap(), f2.await.unwrap())
+}
+
+#[actix_rt::main]
+async fn main() {
+    let (tx, rx) = mpsc::channel();
+
+    let (r1, r2) = oracle({
+        let tx = tx.clone();
+
+        || async move {
+            tx.send(()).unwrap();
+            4 * 4
+        }
+    })
+    .await;
+    assert_eq!(r1, r2);
+
+    tx.send(()).unwrap();
+
+    rx.recv_timeout(Duration::from_millis(100)).unwrap();
+    rx.recv_timeout(Duration::from_millis(100)).unwrap();
+}

actix-service/src/and_then.rs

@@ -1,21 +1,21 @@
 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};
 
-/// Service for the `and_then` combinator, chaining a computation onto the end
-/// of another service which completes successfully.
+/// Service for the `and_then` combinator, chaining a computation onto the end 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 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()),
             },
         }
@@ -64,7 +64,7 @@ where
 }
 
 pin_project! {
-    pub(crate) struct AndThenServiceResponse<A, B, Req>
+    pub struct AndThenServiceResponse<A, B, Req>
     where
         A: Service<Req>,
         B: Service<A::Response, Error = A::Error>,
@@ -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,29 +104,20 @@ 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),
         }
     }
 }
 
 /// `.and_then()` service factory combinator
-pub(crate) struct AndThenServiceFactory<A, B, Req>
+pub struct AndThenServiceFactory<A, B, Req>
 where
     A: ServiceFactory<Req>,
     A::Config: Clone,
@@ -210,7 +200,7 @@ where
 }
 
 pin_project! {
-    pub(crate) struct AndThenServiceFactoryResponse<A, B, Req>
+    pub struct AndThenServiceFactoryResponse<A, B, Req>
     where
         A: ServiceFactory<Req>,
         B: ServiceFactory<A::Response>,
@@ -282,7 +272,9 @@ mod tests {
     use futures_util::future::lazy;
 
     use crate::{
-        fn_factory, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory,
+        fn_factory, ok,
+        pipeline::{pipeline, pipeline_factory},
+        ready, Ready, Service, ServiceFactory,
     };
 
     struct Srv1(Rc<Cell<usize>>);
@@ -292,12 +284,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 +302,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 +315,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 +324,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 +338,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>;
@@ -214,7 +214,11 @@ mod tests {
     use futures_util::future::lazy;
 
     use super::*;
-    use crate::{ok, pipeline, pipeline_factory, Ready, Service, ServiceFactory};
+    use crate::{
+        ok,
+        pipeline::{pipeline, pipeline_factory},
+        Ready, Service, ServiceFactory,
+    };
 
     #[derive(Clone)]
     struct Srv;
@@ -226,14 +230,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 +265,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

@@ -1,21 +1,69 @@
-use alloc::boxed::Box;
-use core::{
-    future::Future,
-    marker::PhantomData,
-    pin::Pin,
-    task::{Context, Poll},
-};
+//! Trait object forms of services and service factories.
+
+use alloc::{boxed::Box, rc::Rc};
+use core::{future::Future, pin::Pin};
+
+use paste::paste;
 
 use crate::{Service, ServiceFactory};
 
+/// A boxed future with no send bound or lifetime parameters.
 pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
-pub type BoxService<Req, Res, Err> =
-    Box<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>>;
+macro_rules! service_object {
+    ($name: ident, $type: tt, $fn_name: ident) => {
+        paste! {
+            #[doc = "Type alias for service trait object using `" $type "`."]
+            pub type $name<Req, Res, Err> = $type<
+                dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>,
+            >;
 
+            #[doc = "Wraps service as a trait object using [`" $name "`]."]
+            pub fn $fn_name<S, Req>(service: S) -> $name<Req, S::Response, S::Error>
+            where
+                S: Service<Req> + 'static,
+                Req: 'static,
+                S::Future: 'static,
+            {
+                $type::new(ServiceWrapper::new(service))
+            }
+        }
+    };
+}
+
+service_object!(BoxService, Box, service);
+service_object!(RcService, Rc, rc_service);
+
+struct ServiceWrapper<S> {
+    inner: S,
+}
+
+impl<S> ServiceWrapper<S> {
+    fn new(inner: S) -> Self {
+        Self { inner }
+    }
+}
+
+impl<S, Req, Res, Err> Service<Req> for ServiceWrapper<S>
+where
+    S: Service<Req, Response = Res, Error = Err>,
+    S::Future: 'static,
+{
+    type Response = Res;
+    type Error = Err;
+    type Future = BoxFuture<Result<Res, Err>>;
+
+    crate::forward_ready!(inner);
+
+    fn call(&self, req: Req) -> Self::Future {
+        Box::pin(self.inner.call(req))
+    }
+}
+
+/// Wrapper for a service factory that will map it's services to boxed trait object services.
 pub struct BoxServiceFactory<Cfg, Req, Res, Err, InitErr>(Inner<Cfg, Req, Res, Err, InitErr>);
 
-/// Create boxed service factory
+/// Wraps a service factory that returns service trait objects.
 pub fn factory<SF, Req>(
     factory: SF,
 ) -> BoxServiceFactory<SF::Config, Req, SF::Response, SF::Error, SF::InitError>
@@ -28,20 +76,7 @@ where
     SF::Error: 'static,
     SF::InitError: 'static,
 {
-    BoxServiceFactory(Box::new(FactoryWrapper {
-        factory,
-        _t: PhantomData,
-    }))
-}
-
-/// Create boxed service
-pub fn service<S, Req>(service: S) -> BoxService<Req, S::Response, S::Error>
-where
-    S: Service<Req> + 'static,
-    Req: 'static,
-    S::Future: 'static,
-{
-    Box::new(ServiceWrapper(service, PhantomData))
+    BoxServiceFactory(Box::new(FactoryWrapper(factory)))
 }
 
 type Inner<C, Req, Res, Err, InitErr> = Box<
@@ -66,9 +101,9 @@ where
 {
     type Response = Res;
     type Error = Err;
-    type InitError = InitErr;
     type Config = C;
     type Service = BoxService<Req, Res, Err>;
+    type InitError = InitErr;
 
     type Future = BoxFuture<Result<Self::Service, InitErr>>;
 
@@ -77,12 +112,9 @@ where
     }
 }
 
-struct FactoryWrapper<SF, Req, Cfg> {
-    factory: SF,
-    _t: PhantomData<(Req, Cfg)>,
-}
+struct FactoryWrapper<SF>(SF);
 
-impl<SF, Req, Cfg, Res, Err, InitErr> ServiceFactory<Req> for FactoryWrapper<SF, Req, Cfg>
+impl<SF, Req, Cfg, Res, Err, InitErr> ServiceFactory<Req> for FactoryWrapper<SF>
 where
     Req: 'static,
     Res: 'static,
@@ -95,47 +127,13 @@ where
 {
     type Response = Res;
     type Error = Err;
-    type InitError = InitErr;
     type Config = Cfg;
     type Service = BoxService<Req, Res, Err>;
+    type InitError = InitErr;
     type Future = BoxFuture<Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, cfg: Cfg) -> Self::Future {
-        let fut = self.factory.new_service(cfg);
-        Box::pin(async {
-            let res = fut.await;
-            res.map(ServiceWrapper::boxed)
-        })
-    }
-}
-
-struct ServiceWrapper<S: Service<Req>, Req>(S, PhantomData<Req>);
-
-impl<S, Req> ServiceWrapper<S, Req>
-where
-    S: Service<Req> + 'static,
-    Req: 'static,
-    S::Future: 'static,
-{
-    fn boxed(service: S) -> BoxService<Req, S::Response, S::Error> {
-        Box::new(ServiceWrapper(service, PhantomData))
-    }
-}
-
-impl<S, Req, Res, Err> Service<Req> for ServiceWrapper<S, Req>
-where
-    S: Service<Req, Response = Res, Error = Err>,
-    S::Future: 'static,
-{
-    type Response = Res;
-    type Error = Err;
-    type Future = BoxFuture<Result<Res, Err>>;
-
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.poll_ready(ctx)
-    }
-
-    fn call(&mut self, req: Req) -> Self::Future {
-        Box::pin(self.0.call(req))
+        let f = self.0.new_service(cfg);
+        Box::pin(async { f.await.map(|s| Box::new(ServiceWrapper::new(s)) as _) })
     }
 }

actix-service/src/ext.rs

@@ -1,5 +1,12 @@
-use crate::{dev, Service, ServiceFactory};
+use crate::{
+    and_then::{AndThenService, AndThenServiceFactory},
+    map::Map,
+    map_err::MapErr,
+    transform_err::TransformMapInitErr,
+    IntoService, IntoServiceFactory, Service, ServiceFactory, Transform,
+};
 
+/// An extension trait for [`Service`]s that provides a variety of convenient adapters.
 pub trait ServiceExt<Req>: Service<Req> {
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
@@ -10,12 +17,12 @@ pub trait ServiceExt<Req>: Service<Req> {
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it, similar to the existing `map` methods in the
     /// standard library.
-    fn map<F, R>(self, f: F) -> dev::Map<Self, F, Req, R>
+    fn map<F, R>(self, f: F) -> Map<Self, F, Req, R>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R,
     {
-        dev::Map::new(self, f)
+        Map::new(self, f)
     }
 
     /// Map this service's error to a different error, returning a new service.
@@ -26,17 +33,34 @@ pub trait ServiceExt<Req>: Service<Req> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> dev::MapErr<Self, Req, F, E>
+    fn map_err<F, E>(self, f: F) -> MapErr<Self, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
     {
-        dev::MapErr::new(self, f)
+        MapErr::new(self, f)
+    }
+
+    /// Call another service after call to this one has resolved successfully.
+    ///
+    /// This function can be used to chain two services together and ensure that the second service
+    /// isn't called until call to the fist service have finished. Result of the call to the first
+    /// service is used as an input parameter for the second service's call.
+    ///
+    /// Note that this function consumes the receiving service and returns a wrapped version of it.
+    fn and_then<I, S1>(self, service: I) -> AndThenService<Self, S1, Req>
+    where
+        Self: Sized,
+        I: IntoService<S1, Self::Response>,
+        S1: Service<Self::Response, Error = Self::Error>,
+    {
+        AndThenService::new(self, service.into_service())
     }
 }
 
 impl<S, Req> ServiceExt<Req> for S where S: Service<Req> {}
 
+/// An extension trait for [`ServiceFactory`]s that provides a variety of convenient adapters.
 pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
@@ -65,6 +89,36 @@ pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
     {
         crate::map_init_err::MapInitErr::new(self, f)
     }
+
+    /// Call another service after call to this one has resolved successfully.
+    fn and_then<I, SF1>(self, factory: I) -> AndThenServiceFactory<Self, SF1, Req>
+    where
+        Self: Sized,
+        Self::Config: Clone,
+        I: IntoServiceFactory<SF1, Self::Response>,
+        SF1: ServiceFactory<
+            Self::Response,
+            Config = Self::Config,
+            Error = Self::Error,
+            InitError = Self::InitError,
+        >,
+    {
+        AndThenServiceFactory::new(self, factory.into_factory())
+    }
 }
 
-impl<S, Req> ServiceFactoryExt<Req> for S where S: ServiceFactory<Req> {}
+impl<SF, Req> ServiceFactoryExt<Req> for SF where SF: ServiceFactory<Req> {}
+
+/// An extension trait for [`Transform`]s that provides a variety of convenient adapters.
+pub trait TransformExt<S, Req>: Transform<S, Req> {
+    /// Return a new `Transform` whose init error is mapped to to a different type.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E + Clone,
+    {
+        TransformMapInitErr::new(self, f)
+    }
+}
+
+impl<T, Req> TransformExt<T, Req> for T where T: Transform<T, Req> {}

actix-service/src/fn_service.rs

@@ -1,4 +1,4 @@
-use core::{future::Future, marker::PhantomData, task::Poll};
+use core::{future::Future, marker::PhantomData};
 
 use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory};
 
@@ -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)
@@ -15,9 +15,8 @@ where
 
 /// Create `ServiceFactory` for function that can produce services
 ///
-/// # Example
-///
-/// ```rust
+/// # Examples
+/// ```
 /// use std::io;
 /// use actix_service::{fn_factory, fn_service, Service, ServiceFactory};
 /// use futures_util::future::ok;
@@ -39,7 +38,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?;
@@ -53,21 +52,20 @@ pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(
     f: F,
 ) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    Srv: Service<Req>,
     F: Fn() -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
     FnServiceNoConfig::new(f)
 }
 
 /// Create `ServiceFactory` for function that accepts config argument and can produce services
 ///
-/// Any function that has following form `Fn(Config) -> Future<Output = Service>` could
-/// act as a `ServiceFactory`.
+/// Any function that has following form `Fn(Config) -> Future<Output = Service>` could act as
+/// a `ServiceFactory`.
 ///
-/// # Example
-///
-/// ```rust
+/// # Examples
+/// ```
 /// use std::io;
 /// use actix_service::{fn_factory_with_config, fn_service, Service, ServiceFactory};
 /// use futures_util::future::ok;
@@ -81,7 +79,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 +130,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 +139,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 +156,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 +165,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 +175,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 +185,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 +194,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 +202,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 +316,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 +362,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 +371,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 +385,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

@@ -1,7 +1,8 @@
 //! See [`Service`] docs for information on this crate's foundational trait.
 
 #![no_std]
-#![deny(rust_2018_idioms, nonstandard_style)]
+#![deny(rust_2018_idioms, nonstandard_style, future_incompatible)]
+#![warn(missing_docs)]
 #![allow(clippy::type_complexity)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
@@ -21,6 +22,7 @@ mod apply_cfg;
 pub mod boxed;
 mod ext;
 mod fn_service;
+mod macros;
 mod map;
 mod map_config;
 mod map_err;
@@ -33,11 +35,10 @@ mod transform_err;
 
 pub use self::apply::{apply_fn, apply_fn_factory};
 pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
-pub use self::ext::{ServiceExt, ServiceFactoryExt};
+pub use self::ext::{ServiceExt, ServiceFactoryExt, TransformExt};
 pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
 pub use self::map_config::{map_config, unit_config};
-pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
-pub use self::transform::{apply, Transform};
+pub use self::transform::{apply, ApplyTransform, Transform};
 
 #[allow(unused_imports)]
 use self::ready::{err, ok, ready, Ready};
@@ -48,38 +49,46 @@ 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>
 /// ```
 ///
-/// The `Service` trait just generalizes this form where each parameter is described as an
-/// associated type on the trait. Services can also have mutable state that influence computation.
+/// The `Service` trait just generalizes this form. Requests are defined as a generic type parameter
+/// and responses and other details are defined as associated types on the trait impl. Notice that
+/// this design means that services can receive many request types and converge them to a single
+/// response type.
+///
+/// Services can also have mutable state that influence computation by using a `Cell`, `RefCell`
+/// or `Mutex`. Services intentionally do not take `&mut self` to reduce overhead in the
+/// common cases.
 ///
 /// `Service` provides a symmetric and uniform API; the same abstractions can be used to represent
 /// both clients and servers. Services describe only _transformation_ operations which encourage
 /// simple API surfaces. This leads to simpler design of each service, improves test-ability and
 /// makes composition easier.
 ///
-/// ```rust,ignore
+/// ```ignore
 /// struct MyService;
 ///
-/// impl Service for MyService {
-///      type Request = u8;
+/// impl Service<u8> for MyService {
 ///      type Response = u64;
 ///      type Error = MyError;
-///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>>;
+///      type Future = Pin<Box<dyn 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: u8) -> 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()).
+/// 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>;
+///
+/// let svc = fn_service(my_service)
+/// svc.call(123)
 /// ```
 pub trait Service<Req> {
     /// Responses given by the service.
@@ -93,40 +102,40 @@ pub trait Service<Req> {
 
     /// Returns `Ready` when the service is able to process requests.
     ///
-    /// If the service is at capacity, then `Pending` is returned and the task
-    /// is notified when the service becomes ready again. This function is
-    /// expected to be called while on a task.
+    /// If the service is at capacity, then `Pending` is returned and the task is notified when the
+    /// service becomes ready again. This function is expected to be called while on a task.
     ///
-    /// This is a **best effort** implementation. False positives are permitted.
-    /// It is permitted for the service to return `Ready` from a `poll_ready`
-    /// call and the next invocation of `call` results in an error.
+    /// This is a best effort implementation. False positives are permitted. It is permitted for
+    /// the service to return `Ready` from a `poll_ready` call and the next invocation of `call`
+    /// results in an error.
     ///
     /// # Notes
-    /// 1. `.poll_ready()` might be called on different task from actual service call.
-    /// 1. In case of chained services, `.poll_ready()` get called for all services at once.
-    fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
+    /// 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.
     ///
-    /// This function is expected to be callable off task. As such,
-    /// implementations should take care to not call `poll_ready`. If the
-    /// service is at capacity and the request is unable to be handled, the
-    /// returned `Future` should resolve to an error.
+    /// This function is expected to be callable off-task. As such, implementations of `call` should
+    /// take care to not call `poll_ready`. If the service is at capacity and the request is unable
+    /// to be handled, the returned `Future` should resolve to an error.
     ///
-    /// Calling `call` without calling `poll_ready` is permitted. The
-    /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Req) -> Self::Future;
+    /// Invoking `call` without first invoking `poll_ready` is permitted. Implementations must be
+    /// resilient to this fact.
+    fn call(&self, req: Req) -> Self::Future;
 }
 
 /// Factory for creating `Service`s.
 ///
-/// Acts as a service factory. This is useful for cases where new `Service`s
-/// must be produced. One case is a TCP server listener. The listener
-/// accepts new TCP streams, obtains a new `Service` using the
-/// `ServiceFactory` trait, and uses the new `Service` to process inbound
-/// requests on that new TCP stream.
+/// This is useful for cases where new `Service`s must be produced. One case is a TCP
+/// server listener: a listener accepts new connections, constructs a new `Service` for each using
+/// the `ServiceFactory` trait, and uses the new `Service` to process inbound requests on that new
+/// connection.
 ///
 /// `Config` is a service factory configuration type.
+///
+/// Simple factories may be able to use [`fn_factory`] or [`fn_factory_with_config`] to
+/// reduce boilerplate.
 pub trait ServiceFactory<Req> {
     /// Responses given by the created services.
     type Response;
@@ -143,13 +152,14 @@ pub trait ServiceFactory<Req> {
     /// Errors potentially raised while building a service.
     type InitError;
 
-    /// The future of the `Service` instance.
+    /// The future of the `Service` instance.g
     type Future: Future<Output = Result<Self::Service, Self::InitError>>;
 
     /// Create and return a new service asynchronously.
     fn new_service(&self, cfg: Self::Config) -> Self::Future;
 }
 
+// TODO: remove implement on mut reference.
 impl<'a, S, Req> Service<Req> for &'a mut S
 where
     S: Service<Req> + 'a,
@@ -158,11 +168,28 @@ 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)
+    }
+}
+
+impl<'a, S, Req> Service<Req> for &'a S
+where
+    S: Service<Req> + 'a,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        (**self).poll_ready(ctx)
+    }
+
+    fn call(&self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
@@ -175,15 +202,33 @@ 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)
     }
 }
 
+impl<S, Req> Service<Req> for Rc<S>
+where
+    S: Service<Req> + ?Sized,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        (**self).poll_ready(ctx)
+    }
+
+    fn call(&self, request: Req) -> S::Future {
+        (**self).call(request)
+    }
+}
+
+/// This impl is deprecated since v2 because the `Service` trait now receives shared reference.
 impl<S, Req> Service<Req> for RefCell<S>
 where
     S: Service<Req>,
@@ -192,29 +237,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)
-    }
-}
-
-impl<S, Req> Service<Req> for Rc<RefCell<S>>
-where
-    S: Service<Req>,
-{
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.borrow_mut().poll_ready(ctx)
-    }
-
-    fn call(&mut self, request: Req) -> S::Future {
-        (&mut (**self).borrow_mut()).call(request)
+    fn call(&self, request: Req) -> S::Future {
+        self.borrow().call(request)
     }
 }
 
@@ -294,40 +322,3 @@ where
 {
     tp.into_service()
 }
-
-pub mod dev {
-    pub use crate::apply::{Apply, ApplyFactory};
-    pub use crate::fn_service::{
-        FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
-    };
-    pub use crate::map::{Map, MapServiceFactory};
-    pub use crate::map_config::{MapConfig, UnitConfig};
-    pub use crate::map_err::{MapErr, MapErrServiceFactory};
-    pub use crate::map_init_err::MapInitErr;
-    pub use crate::transform::ApplyTransform;
-    pub use crate::transform_err::TransformMapInitErr;
-}
-
-#[macro_export]
-macro_rules! always_ready {
-    () => {
-        fn poll_ready(
-            &mut self,
-            _: &mut ::core::task::Context<'_>,
-        ) -> ::core::task::Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! forward_ready {
-    ($field:ident) => {
-        fn poll_ready(
-            &mut self,
-            cx: &mut ::core::task::Context<'_>,
-        ) -> ::core::task::Poll<Result<(), Self::Error>> {
-            self.$field.poll_ready(cx)
-        }
-    };
-}

actix-service/src/macros.rs

@@ -0,0 +1,185 @@
+/// An implementation of [`poll_ready`]() that always signals readiness.
+///
+/// This should only be used for basic leaf services that have no concept of un-readiness.
+/// For wrapper or other service types, use [`forward_ready!`] for simple cases or write a bespoke
+/// `poll_ready` implementation.
+///
+/// [`poll_ready`]: crate::Service::poll_ready
+///
+/// # Examples
+/// ```no_run
+/// use actix_service::Service;
+/// use futures_util::future::{ready, Ready};
+///
+/// struct IdentityService;
+///
+/// impl Service<u32> for IdentityService {
+///     type Response = u32;
+///     type Error = ();
+///     type Future = Ready<Result<Self::Response, Self::Error>>;
+///
+///     actix_service::always_ready!();
+///
+///     fn call(&self, req: u32) -> Self::Future {
+///         ready(Ok(req))
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! always_ready {
+    () => {
+        #[inline]
+        fn poll_ready(
+            &self,
+            _: &mut ::core::task::Context<'_>,
+        ) -> ::core::task::Poll<Result<(), Self::Error>> {
+            ::core::task::Poll::Ready(Ok(()))
+        }
+    };
+}
+
+/// An implementation of [`poll_ready`] that forwards readiness checks to a
+/// named struct field.
+///
+/// Tuple structs are not supported.
+///
+/// [`poll_ready`]: crate::Service::poll_ready
+///
+/// # Examples
+/// ```no_run
+/// use actix_service::Service;
+/// use futures_util::future::{ready, Ready};
+///
+/// struct WrapperService<S> {
+///     inner: S,
+/// }
+///
+/// impl<S> Service<()> for WrapperService<S>
+/// where
+///     S: Service<()>,
+/// {
+///     type Response = S::Response;
+///     type Error = S::Error;
+///     type Future = S::Future;
+///
+///     actix_service::forward_ready!(inner);
+///
+///     fn call(&self, req: ()) -> Self::Future {
+///         self.inner.call(req)
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! forward_ready {
+    ($field:ident) => {
+        #[inline]
+        fn poll_ready(
+            &self,
+            cx: &mut ::core::task::Context<'_>,
+        ) -> ::core::task::Poll<Result<(), Self::Error>> {
+            self.$field
+                .poll_ready(cx)
+                .map_err(::core::convert::Into::into)
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use core::{
+        cell::Cell,
+        convert::Infallible,
+        task::{self, Context, Poll},
+    };
+
+    use futures_util::{
+        future::{ready, Ready},
+        task::noop_waker,
+    };
+
+    use crate::Service;
+
+    struct IdentityService;
+
+    impl Service<u32> for IdentityService {
+        type Response = u32;
+        type Error = Infallible;
+        type Future = Ready<Result<Self::Response, Self::Error>>;
+
+        always_ready!();
+
+        fn call(&self, req: u32) -> Self::Future {
+            ready(Ok(req))
+        }
+    }
+
+    struct CountdownService(Cell<u32>);
+
+    impl Service<()> for CountdownService {
+        type Response = ();
+        type Error = Infallible;
+        type Future = Ready<Result<Self::Response, Self::Error>>;
+
+        fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            let count = self.0.get();
+
+            if count == 0 {
+                Poll::Ready(Ok(()))
+            } else {
+                self.0.set(count - 1);
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }
+
+        fn call(&self, _: ()) -> Self::Future {
+            ready(Ok(()))
+        }
+    }
+
+    struct WrapperService<S> {
+        inner: S,
+    }
+
+    impl<S> Service<()> for WrapperService<S>
+    where
+        S: Service<()>,
+    {
+        type Response = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+
+        forward_ready!(inner);
+
+        fn call(&self, _: ()) -> Self::Future {
+            self.inner.call(())
+        }
+    }
+
+    #[test]
+    fn test_always_ready_macro() {
+        let waker = noop_waker();
+        let mut cx = task::Context::from_waker(&waker);
+
+        let svc = IdentityService;
+
+        assert!(svc.poll_ready(&mut cx).is_ready());
+        assert!(svc.poll_ready(&mut cx).is_ready());
+        assert!(svc.poll_ready(&mut cx).is_ready());
+    }
+
+    #[test]
+    fn test_forward_ready_macro() {
+        let waker = noop_waker();
+        let mut cx = task::Context::from_waker(&waker);
+
+        let svc = WrapperService {
+            inner: CountdownService(Cell::new(3)),
+        };
+
+        assert!(svc.poll_ready(&mut cx).is_pending());
+        assert!(svc.poll_ready(&mut cx).is_pending());
+        assert!(svc.poll_ready(&mut cx).is_pending());
+        assert!(svc.poll_ready(&mut cx).is_ready());
+    }
+}

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

@@ -9,26 +9,25 @@ use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
-/// Service for the `map_err` combinator, changing the type of a service's
-/// error.
+/// Service for the `map_err` combinator, changing the type of a service's error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
 pub struct MapErr<S, Req, F, E> {
     service: S,
-    f: F,
+    mapper: F,
     _t: PhantomData<(E, Req)>,
 }
 
 impl<S, Req, F, E> MapErr<S, Req, F, E> {
     /// Create new `MapErr` combinator
-    pub(crate) fn new(service: S, f: F) -> Self
+    pub(crate) fn new(service: S, mapper: F) -> Self
     where
         S: Service<Req>,
         F: Fn(S::Error) -> E,
     {
         Self {
             service,
-            f,
+            mapper,
             _t: PhantomData,
         }
     }
@@ -42,7 +41,7 @@ where
     fn clone(&self) -> Self {
         MapErr {
             service: self.service.clone(),
-            f: self.f.clone(),
+            mapper: self.mapper.clone(),
             _t: PhantomData,
         }
     }
@@ -57,12 +56,12 @@ where
     type Error = E;
     type Future = MapErrFuture<A, Req, F, E>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(ctx).map_err(&self.f)
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(ctx).map_err(&self.mapper)
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
-        MapErrFuture::new(self.service.call(req), self.f.clone())
+    fn call(&self, req: Req) -> Self::Future {
+        MapErrFuture::new(self.service.call(req), self.mapper.clone())
     }
 }
 
@@ -105,23 +104,23 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrServiceFactory<A, Req, F, E>
+pub struct MapErrServiceFactory<SF, Req, F, E>
 where
-    A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E + Clone,
+    SF: ServiceFactory<Req>,
+    F: Fn(SF::Error) -> E + Clone,
 {
-    a: A,
+    a: SF,
     f: F,
     e: PhantomData<(E, Req)>,
 }
 
-impl<A, Req, F, E> MapErrServiceFactory<A, Req, F, E>
+impl<SF, Req, F, E> MapErrServiceFactory<SF, Req, F, E>
 where
-    A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E + Clone,
+    SF: ServiceFactory<Req>,
+    F: Fn(SF::Error) -> E + Clone,
 {
     /// Create new `MapErr` new service instance
-    pub(crate) fn new(a: A, f: F) -> Self {
+    pub(crate) fn new(a: SF, f: F) -> Self {
         Self {
             a,
             f,
@@ -130,10 +129,10 @@ where
     }
 }
 
-impl<A, Req, F, E> Clone for MapErrServiceFactory<A, Req, F, E>
+impl<SF, Req, F, E> Clone for MapErrServiceFactory<SF, Req, F, E>
 where
-    A: ServiceFactory<Req> + Clone,
-    F: Fn(A::Error) -> E + Clone,
+    SF: ServiceFactory<Req> + Clone,
+    F: Fn(SF::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -144,57 +143,57 @@ where
     }
 }
 
-impl<A, Req, F, E> ServiceFactory<Req> for MapErrServiceFactory<A, Req, F, E>
+impl<SF, Req, F, E> ServiceFactory<Req> for MapErrServiceFactory<SF, Req, F, E>
 where
-    A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E + Clone,
+    SF: ServiceFactory<Req>,
+    F: Fn(SF::Error) -> E + Clone,
 {
-    type Response = A::Response;
+    type Response = SF::Response;
     type Error = E;
 
-    type Config = A::Config;
-    type Service = MapErr<A::Service, Req, F, E>;
-    type InitError = A::InitError;
-    type Future = MapErrServiceFuture<A, Req, F, E>;
+    type Config = SF::Config;
+    type Service = MapErr<SF::Service, Req, F, E>;
+    type InitError = SF::InitError;
+    type Future = MapErrServiceFuture<SF, Req, F, E>;
 
-    fn new_service(&self, cfg: A::Config) -> Self::Future {
+    fn new_service(&self, cfg: SF::Config) -> Self::Future {
         MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
 pin_project! {
-    pub struct MapErrServiceFuture<A, Req, F, E>
+    pub struct MapErrServiceFuture<SF, Req, F, E>
     where
-        A: ServiceFactory<Req>,
-        F: Fn(A::Error) -> E,
+        SF: ServiceFactory<Req>,
+        F: Fn(SF::Error) -> E,
     {
         #[pin]
-        fut: A::Future,
-        f: F,
+        fut: SF::Future,
+        mapper: F,
     }
 }
 
-impl<A, Req, F, E> MapErrServiceFuture<A, Req, F, E>
+impl<SF, Req, F, E> MapErrServiceFuture<SF, Req, F, E>
 where
-    A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E,
+    SF: ServiceFactory<Req>,
+    F: Fn(SF::Error) -> E,
 {
-    fn new(fut: A::Future, f: F) -> Self {
-        MapErrServiceFuture { f, fut }
+    fn new(fut: SF::Future, mapper: F) -> Self {
+        MapErrServiceFuture { fut, mapper }
     }
 }
 
-impl<A, Req, F, E> Future for MapErrServiceFuture<A, Req, F, E>
+impl<SF, Req, F, E> Future for MapErrServiceFuture<SF, Req, F, E>
 where
-    A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E + Clone,
+    SF: ServiceFactory<Req>,
+    F: Fn(SF::Error) -> E + Clone,
 {
-    type Output = Result<MapErr<A::Service, Req, F, E>, A::InitError>;
+    type Output = Result<MapErr<SF::Service, Req, F, E>, SF::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
         if let Poll::Ready(svc) = this.fut.poll(cx)? {
-            Poll::Ready(Ok(MapErr::new(svc, this.f.clone())))
+            Poll::Ready(Ok(MapErr::new(svc, this.mapper.clone())))
         } else {
             Poll::Pending
         }
@@ -218,25 +217,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 +244,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

@@ -1,3 +1,6 @@
+// TODO: see if pipeline is necessary
+#![allow(dead_code)]
+
 use core::{
     marker::PhantomData,
     task::{Context, Poll},
@@ -11,7 +14,7 @@ use crate::then::{ThenService, ThenServiceFactory};
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Construct new pipeline with one service in pipeline chain.
-pub fn pipeline<I, S, Req>(service: I) -> Pipeline<S, Req>
+pub(crate) fn pipeline<I, S, Req>(service: I) -> Pipeline<S, Req>
 where
     I: IntoService<S, Req>,
     S: Service<Req>,
@@ -23,7 +26,7 @@ where
 }
 
 /// Construct new pipeline factory with one service factory.
-pub fn pipeline_factory<I, SF, Req>(factory: I) -> PipelineFactory<SF, Req>
+pub(crate) fn pipeline_factory<I, SF, Req>(factory: I) -> PipelineFactory<SF, Req>
 where
     I: IntoServiceFactory<SF, Req>,
     SF: ServiceFactory<Req>,
@@ -35,7 +38,7 @@ where
 }
 
 /// Pipeline service - pipeline allows to compose multiple service into one service.
-pub struct Pipeline<S, Req> {
+pub(crate) struct Pipeline<S, Req> {
     service: S,
     _phantom: PhantomData<Req>,
 }
@@ -146,18 +149,18 @@ 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)
     }
 }
 
 /// Pipeline factory
-pub struct PipelineFactory<SF, Req> {
+pub(crate) struct PipelineFactory<SF, Req> {
     factory: SF,
     _phantom: PhantomData<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),
         }
     }
 }
@@ -256,7 +246,11 @@ mod tests {
 
     use futures_util::future::lazy;
 
-    use crate::{err, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory};
+    use crate::{
+        err, ok,
+        pipeline::{pipeline, pipeline_factory},
+        ready, Ready, Service, ServiceFactory,
+    };
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
@@ -266,12 +260,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 +280,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 +296,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 +305,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 +322,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,12 +6,12 @@ use core::{
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
-use crate::transform_err::TransformMapInitErr;
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
-/// Apply transform to a service.
+/// Apply a [`Transform`] to a [`Service`].
 pub fn apply<T, S, I, Req>(t: T, factory: I) -> ApplyTransform<T, S, Req>
 where
     I: IntoServiceFactory<S, Req>,
@@ -21,64 +21,51 @@ where
     ApplyTransform::new(t, factory.into_factory())
 }
 
-/// The `Transform` trait defines the interface of a service factory that wraps inner service
-/// during construction.
+/// Defines the interface of a service factory that wraps inner service during construction.
 ///
-/// Transform(middleware) wraps inner service and runs during
-/// inbound and/or outbound processing in the request/response lifecycle.
-/// It may modify request and/or response.
+/// Transformers wrap an inner service and runs during inbound and/or outbound processing in the
+/// service lifecycle. It may modify request and/or response.
 ///
-/// For example, timeout transform:
+/// For example, a timeout service wrapper:
 ///
-/// ```rust,ignore
+/// ```ignore
 /// pub struct Timeout<S> {
 ///     service: S,
 ///     timeout: Duration,
 /// }
 ///
-/// impl<S> Service for Timeout<S>
-/// where
-///     S: Service,
-/// {
-///     type Request = S::Request;
+/// impl<S: Service<Req>, Req> Service<Req> for Timeout<S> {
 ///     type Response = S::Response;
 ///     type Error = TimeoutError<S::Error>;
 ///     type Future = TimeoutServiceResponse<S>;
 ///
-///     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-///         ready!(self.service.poll_ready(cx)).map_err(TimeoutError::Service)
-///     }
+///     actix_service::forward_ready!(service);
 ///
-///     fn call(&mut self, req: S::Request) -> Self::Future {
+///     fn call(&self, req: Req) -> Self::Future {
 ///         TimeoutServiceResponse {
 ///             fut: self.service.call(req),
-///             sleep: Delay::new(clock::now() + self.timeout),
+///             sleep: Sleep::new(clock::now() + self.timeout),
 ///         }
 ///     }
 /// }
 /// ```
 ///
-/// Timeout service in above example is decoupled from underlying service implementation
-/// and could be applied to any service.
+/// This wrapper service is decoupled from the underlying service implementation and could be
+/// applied to any service.
 ///
-/// The `Transform` trait defines the interface of a Service factory. `Transform`
-/// is often implemented for middleware, defining how to construct a
-/// middleware Service. A Service that is constructed by the factory takes
-/// the Service that follows it during execution as a parameter, assuming
-/// ownership of the next Service.
+/// The `Transform` trait defines the interface of a service wrapper. `Transform` is often
+/// implemented for middleware, defining how to construct a middleware Service. A Service that is
+/// constructed by the factory takes the Service that follows it during execution as a parameter,
+/// assuming ownership of the next Service.
 ///
-/// Factory for `Timeout` middleware from the above example could look like this:
+/// A transform for the `Timeout` middleware could look like this:
 ///
-/// ```rust,,ignore
+/// ```ignore
 /// pub struct TimeoutTransform {
 ///     timeout: Duration,
 /// }
 ///
-/// impl<S> Transform<S> for TimeoutTransform
-/// where
-///     S: Service,
-/// {
-///     type Request = S::Request;
+/// impl<S: Service<Req>, Req> Transform<S, Req> for TimeoutTransform {
 ///     type Response = S::Response;
 ///     type Error = TimeoutError<S::Error>;
 ///     type InitError = S::Error;
@@ -86,15 +73,15 @@ where
 ///     type Future = Ready<Result<Self::Transform, Self::InitError>>;
 ///
 ///     fn new_transform(&self, service: S) -> Self::Future {
-///         ok(TimeoutService {
+///         ready(Ok(Timeout {
 ///             service,
 ///             timeout: self.timeout,
-///         })
+///         }))
 ///     }
 /// }
 /// ```
 pub trait Transform<S, Req> {
-    /// Responses given by the service.
+    /// Responses produced by the service.
     type Response;
 
     /// Errors produced by the service.
@@ -111,16 +98,6 @@ pub trait Transform<S, Req> {
 
     /// Creates and returns a new Transform component, asynchronously
     fn new_transform(&self, service: S) -> Self::Future;
-
-    /// Map this transform's factory error to a different error,
-    /// returning a new transform service factory.
-    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::InitError) -> E + Clone,
-    {
-        TransformMapInitErr::new(self, f)
-    }
 }
 
 impl<T, S, Req> Transform<S, Req> for Rc<T>
@@ -129,8 +106,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 +121,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 {
@@ -153,7 +130,7 @@ where
     }
 }
 
-/// `Apply` transform to new service
+/// Apply a [`Transform`] to a [`Service`].
 pub struct ApplyTransform<T, S, Req>(Rc<(T, S)>, PhantomData<Req>);
 
 impl<T, S, Req> ApplyTransform<T, S, Req>
@@ -231,15 +208,63 @@ 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),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use core::time::Duration;
+
+    use actix_utils::future::{ready, Ready};
+
+    use super::*;
+    use crate::Service;
+
+    // pseudo-doctest for Transform trait
+    pub struct TimeoutTransform {
+        timeout: Duration,
+    }
+
+    // pseudo-doctest for Transform trait
+    impl<S: Service<Req>, Req> Transform<S, Req> for TimeoutTransform {
+        type Response = S::Response;
+        type Error = S::Error;
+        type InitError = S::Error;
+        type Transform = Timeout<S>;
+        type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+        fn new_transform(&self, service: S) -> Self::Future {
+            ready(Ok(Timeout {
+                service,
+                _timeout: self.timeout,
+            }))
+        }
+    }
+
+    // pseudo-doctest for Transform trait
+    pub struct Timeout<S> {
+        service: S,
+        _timeout: Duration,
+    }
+
+    // pseudo-doctest for Transform trait
+    impl<S: Service<Req>, Req> Service<Req> for Timeout<S> {
+        type Response = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+
+        crate::forward_ready!(service);
+
+        fn call(&self, req: Req) -> Self::Future {
+            self.service.call(req)
+        }
+    }
+}

actix-service/src/transform_err.rs

@@ -9,10 +9,8 @@ use pin_project_lite::pin_project;
 
 use super::Transform;
 
-/// Transform for the `map_init_err` combinator, changing the type of a new
-/// transform's init error.
-///
-/// This is created by the `Transform::map_init_err` method.
+/// Transform for the [`TransformExt::map_init_err`] combinator, changing the type of a new
+/// [`Transform`]'s initialization error.
 pub struct TransformMapInitErr<T, S, Req, F, E> {
     transform: T,
     mapper: F,

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