prepare testing beta release

* intra doc conversion

* rm trailing blank comment

.appveyor.yml

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

.github/PULL_REQUEST_TEMPLATE.md

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

.github/workflows/clippy-fmt.yml

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

.github/workflows/linux.yml

@@ -0,0 +1,82 @@
+name: CI (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+      - '1.0'
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - 1.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

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

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

.github/workflows/windows-mingw.yml

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

.github/workflows/windows.yml

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

.travis.yml

@@ -1,49 +0,0 @@
-language: rust
-sudo: required
-dist: trusty
-
-cache:
-  cargo: true
-  apt: true
-
-matrix:
-  include:
-    - rust: stable
-    - rust: beta
-    - rust: nightly-2019-11-07
-  allow_failures:
-    - rust: nightly-2019-11-07
-
-env:
-  global:
-    - RUSTFLAGS="-C link-dead-code"
-    - OPENSSL_VERSION=openssl-1.0.2
-
-before_install:
-  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
-  - sudo apt-get update -qq
-  - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
-
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-07" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
-  fi
-
-# Add clippy
-before_script:
-  - export PATH=$PATH:~/.cargo/bin
-
-script:
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-11-07" ]]; then
-    cargo clean
-    cargo test --all --all-features -- --nocapture
-    fi
-
-after_success:
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-07" ]]; then
-    taskset -c 0 cargo tarpaulin --all --all-features --out Xml
-    echo "Uploaded code coverage"
-    bash <(curl -s https://codecov.io/bash)
-    fi

CODE_OF_CONDUCT.md

@@ -34,10 +34,13 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fafhrd91@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at robjtede@icloud.com ([@robjtede]) or huyuumi@neet.club ([@JohnTitor]). The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 
+[@robjtede]: https://github.com/robjtede
+[@JohnTitor]: https://github.com/JohnTitor
+
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

Cargo.toml

@@ -2,7 +2,6 @@
 members = [
   "actix-codec",
   "actix-connect",
-  "actix-ioframe",
   "actix-rt",
   "actix-macros",
   "actix-service",
@@ -10,22 +9,23 @@ members = [
   "actix-testing",
   "actix-threadpool",
   "actix-tls",
+  "actix-tracing",
   "actix-utils",
   "router",
   "string",
 ]
 
 [patch.crates-io]
-actix-codec = { path = "actix-codec" }
+actix-codec = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
 actix-connect = { path = "actix-connect" }
-actix-ioframe = { path = "actix-ioframe" }
-actix-rt = { path = "actix-rt" }
+actix-rt = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
 actix-macros = { path = "actix-macros" }
 actix-server = { path = "actix-server" }
-actix-service = { path = "actix-service" }
+actix-service = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
 actix-testing = { path = "actix-testing" }
 actix-threadpool = { path = "actix-threadpool" }
 actix-tls = { path = "actix-tls" }
-actix-utils = { path = "actix-utils" }
+actix-tracing = { path = "actix-tracing" }
+actix-utils = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
 actix-router = { path = "router" }
 bytestring = { path = "string" }

README.md

@@ -1,11 +1,20 @@
-# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix net [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Actix net - framework for composable network services
 
+## Build statuses
+
+| Platform         | Build Status |
+| ---------------- | ------------ |
+| Linux            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Linux)") |
+| macOS            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28macOS%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(macOS)") |
+| Windows          | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows)") |
+| Windows (MinGW)  | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows-mingw%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows-mingw)") |
+
 ## Documentation & community resources
 
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Minimum supported Rust version: 1.39 or later
+* [Chat on Gitter](https://gitter.im/actix/actix)
+* Minimum supported Rust version: 1.46 or later
 
 ## Example
 

actix-codec/CHANGES.md

@@ -1,31 +1,59 @@
 # Changes
 
-## [0.2.0] - 2019-12-10
+## Unreleased - 2020-xx-xx
 
+
+## 0.4.0-beta.1 - 2020-12-28
+* Replace `pin-project` with `pin-project-lite`. [#237]
+* Upgrade `tokio` dependency to `1`. [#237]
+* Upgrade `tokio-util` dependency to `0.6`. [#237]
+* Upgrade `bytes` dependency to `1`. [#237]
+
+[#237]: https://github.com/actix/actix-net/pull/237
+
+
+## 0.3.0 - 2020-08-23
+* No changes from beta 2.
+
+
+## 0.3.0-beta.2 - 2020-08-19
+* Remove unused type parameter from `Framed::replace_codec`.
+
+
+## 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()` 
+* 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
 
-## [0.2.0-alpha.4]
 
-* Fix buffer remaining capacity calcualtion
+## 0.2.0-alpha.4
+* Fix buffer remaining capacity calculation
 
-## [0.2.0-alpha.3]
 
+## 0.2.0-alpha.3
 * Use tokio 0.2
-
 * Fix low/high watermark for write/read buffers
 
-## [0.2.0-alpha.2]
 
+## 0.2.0-alpha.2
 * Migrated to `std::future`
 
-## [0.1.2] - 2019-03-27
 
+## 0.1.2 - 2019-03-27
 * Added `Framed::map_io()` method.
 
-## [0.1.1] - 2019-03-06
 
+## 0.1.1 - 2019-03-06
 * Added `FramedParts::with_read_buffer()` method.
 
-## [0.1.0] - 2018-12-09
 
+## 0.1.0 - 2018-12-09
 * Move codec to separate crate

actix-codec/Cargo.toml

@@ -1,16 +1,15 @@
 [package]
 name = "actix-codec"
-version = "0.2.0"
+version = "0.4.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Utilities for encoding and decoding frames"
+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/"
 categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_codec"
@@ -18,9 +17,10 @@ path = "src/lib.rs"
 
 [dependencies]
 bitflags = "1.2.1"
-bytes = "0.5.2"
-futures-core = "0.3.1"
-futures-sink = "0.3.1"
-tokio = { version = "0.2.4", default-features=false }
-tokio-util = { version = "0.2.0", default-features=false, features=["codec"] }
-log = "0.4"
+bytes = "1"
+futures-core = { version = "0.3.7", default-features = false }
+futures-sink = { version = "0.3.7", default-features = false }
+log = "0.4"
+pin-project-lite = "0.2"
+tokio = "1"
+tokio-util = { version = "0.6", features = ["codec", "io"] }

actix-codec/src/bcodec.rs

@@ -1,4 +1,4 @@
-use bytes::{BufMut, Bytes, BytesMut};
+use bytes::{Buf, Bytes, BytesMut};
 use std::io;
 
 use super::{Decoder, Encoder};
@@ -9,13 +9,12 @@ use super::{Decoder, Encoder};
 #[derive(Debug, Copy, Clone)]
 pub struct BytesCodec;
 
-impl Encoder for BytesCodec {
-    type Item = Bytes;
+impl Encoder<Bytes> for BytesCodec {
     type Error = io::Error;
 
+    #[inline]
     fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.reserve(item.len());
-        dst.put(item);
+        dst.extend_from_slice(item.chunk());
         Ok(())
     }
 }
@@ -28,8 +27,7 @@ impl Decoder for BytesCodec {
         if src.is_empty() {
             Ok(None)
         } else {
-            let len = src.len();
-            Ok(Some(src.split_to(len)))
+            Ok(Some(src.split()))
         }
     }
 }

actix-codec/src/framed.rs

@@ -2,13 +2,15 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io};
 
-use bytes::BytesMut;
+use bytes::{Buf, BytesMut};
 use futures_core::{ready, Stream};
 use futures_sink::Sink;
 
 use crate::{AsyncRead, AsyncWrite, Decoder, Encoder};
 
+/// Low-water mark
 const LW: usize = 1024;
+/// High-water mark
 const HW: usize = 8 * 1024;
 
 bitflags::bitflags! {
@@ -18,32 +20,30 @@ bitflags::bitflags! {
     }
 }
 
-/// A unified `Stream` and `Sink` interface to an underlying I/O object, using
-/// the `Encoder` and `Decoder` traits to encode and decode frames.
-pub struct Framed<T, U> {
-    io: T,
-    codec: U,
-    flags: Flags,
-    read_buf: BytesMut,
-    write_buf: BytesMut,
+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.
+    ///
+    /// 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,
+        codec: U,
+        flags: Flags,
+        read_buf: BytesMut,
+        write_buf: BytesMut,
+    }
 }
 
-impl<T, U> Unpin for Framed<T, U> {}
-
 impl<T, U> Framed<T, U>
 where
     T: AsyncRead + AsyncWrite,
-    U: Decoder + Encoder,
+    U: Decoder,
 {
-    /// Provides a `Stream` and `Sink` interface for reading and writing to this
-    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
-    ///
-    /// Raw I/O objects work with byte sequences, but higher-level code usually
-    /// wants to batch these into meaningful chunks, called "frames". This
-    /// method layers framing on top of an I/O object, by using the `Codec`
-    /// traits to handle encoding and decoding of messages frames. Note that
-    /// the incoming and outgoing frame types may be distinct.
-    ///
     /// This function returns a *single* object that is both `Stream` and
     /// `Sink`; grouping this into a single object is often useful for layering
     /// things like gzip or TLS, which require both read and write access to the
@@ -60,40 +60,13 @@ where
 }
 
 impl<T, U> Framed<T, U> {
-    /// Provides a `Stream` and `Sink` interface for reading and writing to this
-    /// `Io` object, using `Decode` and `Encode` to read and write the raw data.
-    ///
-    /// Raw I/O objects work with byte sequences, but higher-level code usually
-    /// wants to batch these into meaningful chunks, called "frames". This
-    /// method layers framing on top of an I/O object, by using the `Codec`
-    /// traits to handle encoding and decoding of messages frames. Note that
-    /// the incoming and outgoing frame types may be distinct.
-    ///
-    /// This function returns a *single* object that is both `Stream` and
-    /// `Sink`; grouping this into a single object is often useful for layering
-    /// things like gzip or TLS, which require both read and write access to the
-    /// underlying object.
-    ///
-    /// This objects takes a stream and a readbuffer and a writebuffer. These
-    /// field can be obtained from an existing `Framed` with the
-    /// `into_parts` method.
-    pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
-        Framed {
-            io: parts.io,
-            codec: parts.codec,
-            flags: parts.flags,
-            write_buf: parts.write_buf,
-            read_buf: parts.read_buf,
-        }
-    }
-
     /// Returns a reference to the underlying codec.
-    pub fn get_codec(&self) -> &U {
+    pub fn codec_ref(&self) -> &U {
         &self.codec
     }
 
     /// Returns a mutable reference to the underlying codec.
-    pub fn get_codec_mut(&mut self) -> &mut U {
+    pub fn codec_mut(&mut self) -> &mut U {
         &mut self.codec
     }
 
@@ -103,20 +76,29 @@ impl<T, U> Framed<T, U> {
     /// Note that care should be taken to not tamper with the underlying stream
     /// of data coming in as it may corrupt the stream of frames otherwise
     /// being worked with.
-    pub fn get_ref(&self) -> &T {
+    pub fn io_ref(&self) -> &T {
         &self.io
     }
 
-    /// Returns a mutable reference to the underlying I/O stream wrapped by
-    /// `Frame`.
+    /// 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.
-    pub fn get_mut(&mut self) -> &mut T {
+    pub fn io_mut(&mut self) -> &mut T {
         &mut self.io
     }
 
+    /// Returns a `Pin` of a mutable reference to the underlying I/O stream.
+    pub fn io_pin(self: Pin<&mut Self>) -> Pin<&mut T> {
+        self.project().io
+    }
+
+    /// Check if read buffer is empty.
+    pub fn is_read_buf_empty(&self) -> bool {
+        self.read_buf.is_empty()
+    }
+
     /// Check if write buffer is empty.
     pub fn is_write_buf_empty(&self) -> bool {
         self.write_buf.is_empty()
@@ -127,8 +109,15 @@ impl<T, U> Framed<T, U> {
         self.write_buf.len() >= HW
     }
 
+    /// Check if framed is able to write more data.
+    ///
+    /// `Framed` object considers ready if there is free space in write buffer.
+    pub fn is_write_ready(&self) -> bool {
+        self.write_buf.len() < HW
+    }
+
     /// Consume the `Frame`, returning `Frame` with different codec.
-    pub fn into_framed<U2>(self, codec: U2) -> Framed<T, U2> {
+    pub fn replace_codec<U2>(self, codec: U2) -> Framed<T, U2> {
         Framed {
             codec,
             io: self.io,
@@ -139,7 +128,7 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Consume the `Frame`, returning `Frame` with different io.
-    pub fn map_io<F, T2>(self, f: F) -> Framed<T2, U>
+    pub fn into_map_io<F, T2>(self, f: F) -> Framed<T2, U>
     where
         F: Fn(T) -> T2,
     {
@@ -153,7 +142,7 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Consume the `Frame`, returning `Frame` with different codec.
-    pub fn map_codec<F, U2>(self, f: F) -> Framed<T, U2>
+    pub fn into_map_codec<F, U2>(self, f: F) -> Framed<T, U2>
     where
         F: Fn(U) -> U2,
     {
@@ -165,6 +154,209 @@ impl<T, U> Framed<T, U> {
             write_buf: self.write_buf,
         }
     }
+}
+
+impl<T, U> Framed<T, U> {
+    /// Serialize item and Write to the inner buffer
+    pub fn write<I>(mut self: Pin<&mut Self>, item: I) -> Result<(), <U as Encoder<I>>::Error>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let this = self.as_mut().project();
+        let remaining = this.write_buf.capacity() - this.write_buf.len();
+        if remaining < LW {
+            this.write_buf.reserve(HW - remaining);
+        }
+
+        this.codec.encode(item, this.write_buf)?;
+        Ok(())
+    }
+
+    /// Try to read underlying I/O stream and decode item.
+    pub fn next_item(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<<U as Decoder>::Item, U::Error>>>
+    where
+        T: AsyncRead,
+        U: Decoder,
+    {
+        loop {
+            let mut this = self.as_mut().project();
+            // Repeatedly call `decode` or `decode_eof` as long as it is
+            // "readable". Readable is defined as not having returned `None`. If
+            // the upstream has returned EOF, and the decoder is no longer
+            // readable, it can be assumed that the decoder will never become
+            // readable again, at which point the stream is terminated.
+
+            if this.flags.contains(Flags::READABLE) {
+                if this.flags.contains(Flags::EOF) {
+                    match this.codec.decode_eof(&mut this.read_buf) {
+                        Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
+                        Ok(None) => return Poll::Ready(None),
+                        Err(e) => return Poll::Ready(Some(Err(e))),
+                    }
+                }
+
+                log::trace!("attempting to decode a frame");
+
+                match this.codec.decode(&mut this.read_buf) {
+                    Ok(Some(frame)) => {
+                        log::trace!("frame decoded from buffer");
+                        return Poll::Ready(Some(Ok(frame)));
+                    }
+                    Err(e) => return Poll::Ready(Some(Err(e))),
+                    _ => (), // Need more data
+                }
+
+                this.flags.remove(Flags::READABLE);
+            }
+
+            debug_assert!(!this.flags.contains(Flags::EOF));
+
+            // Otherwise, try to read more data and try again. Make sure we've got room
+            let remaining = this.read_buf.capacity() - this.read_buf.len();
+            if remaining < LW {
+                this.read_buf.reserve(HW - remaining)
+            }
+
+            let cnt = match tokio_util::io::poll_read_buf(this.io, cx, this.read_buf) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
+                Poll::Ready(Ok(cnt)) => cnt,
+            };
+
+            if cnt == 0 {
+                this.flags.insert(Flags::EOF);
+            }
+            this.flags.insert(Flags::READABLE);
+        }
+    }
+
+    /// Flush write buffer to underlying I/O stream.
+    pub fn flush<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let mut this = self.as_mut().project();
+        log::trace!("flushing framed transport");
+
+        while !this.write_buf.is_empty() {
+            log::trace!("writing; remaining={}", this.write_buf.len());
+
+            let n = ready!(this.io.as_mut().poll_write(cx, this.write_buf))?;
+
+            if n == 0 {
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::WriteZero,
+                    "failed to write frame to transport",
+                )
+                .into()));
+            }
+
+            // remove written data
+            this.write_buf.advance(n);
+        }
+
+        // Try flushing the underlying IO
+        ready!(this.io.poll_flush(cx))?;
+
+        log::trace!("framed transport flushed");
+        Poll::Ready(Ok(()))
+    }
+
+    /// Flush write buffer and shutdown underlying I/O stream.
+    pub fn close<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
+    where
+        T: AsyncWrite,
+        U: Encoder<I>,
+    {
+        let mut this = self.as_mut().project();
+        ready!(this.io.as_mut().poll_flush(cx))?;
+        ready!(this.io.as_mut().poll_shutdown(cx))?;
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<T, U> Stream for Framed<T, U>
+where
+    T: AsyncRead,
+    U: Decoder,
+{
+    type Item = Result<U::Item, U::Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.next_item(cx)
+    }
+}
+
+impl<T, U, I> Sink<I> for Framed<T, U>
+where
+    T: AsyncWrite,
+    U: Encoder<I>,
+    U::Error: From<io::Error>,
+{
+    type Error = U::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.is_write_ready() {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
+        self.write(item)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.close(cx)
+    }
+}
+
+impl<T, U> fmt::Debug for Framed<T, U>
+where
+    T: fmt::Debug,
+    U: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Framed")
+            .field("io", &self.io)
+            .field("codec", &self.codec)
+            .finish()
+    }
+}
+
+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.
+    ///
+    /// 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,
+            codec: parts.codec,
+            flags: parts.flags,
+            write_buf: parts.write_buf,
+            read_buf: parts.read_buf,
+        }
+    }
 
     /// Consumes the `Frame`, returning its underlying I/O stream, the buffer
     /// with unprocessed data, and the codec.
@@ -183,198 +375,6 @@ impl<T, U> Framed<T, U> {
     }
 }
 
-impl<T, U> Framed<T, U> {
-    /// Serialize item and Write to the inner buffer
-    pub fn write(&mut self, item: <U as Encoder>::Item) -> Result<(), <U as Encoder>::Error>
-    where
-        T: AsyncWrite,
-        U: Encoder,
-    {
-        let remaining = self.write_buf.capacity() - self.write_buf.len();
-        if remaining < LW {
-            self.write_buf.reserve(HW - remaining);
-        }
-
-        self.codec.encode(item, &mut self.write_buf)?;
-        Ok(())
-    }
-
-    /// Check if framed is able to write more data.
-    ///
-    /// `Framed` object considers ready if there is free space in write buffer.
-    pub fn is_write_ready(&self) -> bool {
-        self.write_buf.len() < HW
-    }
-
-    /// Try to read underlying I/O stream and decode item.
-    pub fn next_item(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<U::Item, U::Error>>>
-    where
-        T: AsyncRead,
-        U: Decoder,
-    {
-        loop {
-            // Repeatedly call `decode` or `decode_eof` as long as it is
-            // "readable". Readable is defined as not having returned `None`. If
-            // the upstream has returned EOF, and the decoder is no longer
-            // readable, it can be assumed that the decoder will never become
-            // readable again, at which point the stream is terminated.
-
-            if self.flags.contains(Flags::READABLE) {
-                if self.flags.contains(Flags::EOF) {
-                    match self.codec.decode_eof(&mut self.read_buf) {
-                        Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
-                        Ok(None) => return Poll::Ready(None),
-                        Err(e) => return Poll::Ready(Some(Err(e))),
-                    }
-                }
-
-                log::trace!("attempting to decode a frame");
-
-                match self.codec.decode(&mut self.read_buf) {
-                    Ok(Some(frame)) => {
-                        log::trace!("frame decoded from buffer");
-                        return Poll::Ready(Some(Ok(frame)));
-                    }
-                    Err(e) => return Poll::Ready(Some(Err(e))),
-                    _ => (), // Need more data
-                }
-
-                self.flags.remove(Flags::READABLE);
-            }
-
-            debug_assert!(!self.flags.contains(Flags::EOF));
-
-            // Otherwise, try to read more data and try again. Make sure we've got room
-            let remaining = self.read_buf.capacity() - self.read_buf.len();
-            if remaining < LW {
-                self.read_buf.reserve(HW - remaining)
-            }
-            let cnt = match unsafe {
-                Pin::new_unchecked(&mut self.io).poll_read_buf(cx, &mut self.read_buf)
-            } {
-                Poll::Pending => return Poll::Pending,
-                Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
-                Poll::Ready(Ok(cnt)) => cnt,
-            };
-
-            if cnt == 0 {
-                self.flags.insert(Flags::EOF);
-            }
-            self.flags.insert(Flags::READABLE);
-        }
-    }
-
-    /// Flush write buffer to underlying I/O stream.
-    pub fn flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
-    where
-        T: AsyncWrite,
-        U: Encoder,
-    {
-        log::trace!("flushing framed transport");
-
-        while !self.write_buf.is_empty() {
-            log::trace!("writing; remaining={}", self.write_buf.len());
-
-            let n = ready!(unsafe {
-                Pin::new_unchecked(&mut self.io).poll_write(cx, &self.write_buf)
-            })?;
-
-            if n == 0 {
-                return Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::WriteZero,
-                    "failed to write frame to transport",
-                )
-                .into()));
-            }
-
-            // remove written data
-            let _ = self.write_buf.split_to(n);
-        }
-
-        // Try flushing the underlying IO
-        ready!(unsafe { Pin::new_unchecked(&mut self.io).poll_flush(cx) })?;
-
-        log::trace!("framed transport flushed");
-        Poll::Ready(Ok(()))
-    }
-
-    /// Flush write buffer and shutdown underlying I/O stream.
-    pub fn close(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
-    where
-        T: AsyncWrite,
-        U: Encoder,
-    {
-        unsafe {
-            ready!(Pin::new_unchecked(&mut self.io).poll_flush(cx))?;
-            ready!(Pin::new_unchecked(&mut self.io).poll_shutdown(cx))?;
-        }
-        Poll::Ready(Ok(()))
-    }
-}
-
-impl<T, U> Stream for Framed<T, U>
-where
-    T: AsyncRead,
-    U: Decoder,
-{
-    type Item = Result<U::Item, U::Error>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.next_item(cx)
-    }
-}
-
-impl<T, U> Sink<U::Item> for Framed<T, U>
-where
-    T: AsyncWrite,
-    U: Encoder,
-    U::Error: From<io::Error>,
-{
-    type Error = U::Error;
-
-    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.is_write_ready() {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn start_send(
-        mut self: Pin<&mut Self>,
-        item: <U as Encoder>::Item,
-    ) -> Result<(), Self::Error> {
-        self.write(item)
-    }
-
-    fn poll_flush(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), Self::Error>> {
-        self.flush(cx)
-    }
-
-    fn poll_close(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), Self::Error>> {
-        self.close(cx)
-    }
-}
-
-impl<T, U> fmt::Debug for Framed<T, U>
-where
-    T: fmt::Debug,
-    U: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Framed")
-            .field("io", &self.io)
-            .field("codec", &self.codec)
-            .finish()
-    }
-}
-
 /// `FramedParts` contains an export of the data of a Framed transport.
 /// It can be used to construct a new `Framed` with a different codec.
 /// It contains all current buffers and the inner transport.

actix-codec/src/lib.rs

@@ -1,12 +1,16 @@
-//! Utilities for encoding and decoding frames.
+//! Codec utilities for working with framed protocols.
 //!
 //! Contains adapters to go from streams of bytes, [`AsyncRead`] and
 //! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
-//! Framed streams are also known as [transports].
+//! Framed streams are also known as `transports`.
 //!
-//! [`AsyncRead`]: #
-//! [`AsyncWrite`]: #
-#![deny(rust_2018_idioms, warnings)]
+//! [`Sink`]: futures_sink::Sink
+//! [`Stream`]: futures_core::Stream
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![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;
@@ -14,5 +18,6 @@ mod framed;
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
 
-pub use tokio::io::{AsyncRead, AsyncWrite};
+pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 pub use tokio_util::codec::{Decoder, Encoder};
+pub use tokio_util::io::poll_read_buf;

actix-connect/CHANGES.md

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

actix-connect/Cargo.toml

@@ -1,17 +1,15 @@
 [package]
 name = "actix-connect"
-version = "1.0.0-alpha.3"
+version = "2.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix connect - tcp connector service"
+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/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [package.metadata.docs.rs]
 features = ["openssl", "rustls", "uri"]
@@ -33,26 +31,28 @@ rustls = ["rust-tls", "tokio-rustls", "webpki"]
 uri = ["http"]
 
 [dependencies]
-actix-service = "1.0.0-alpha.3"
-actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.3"
-actix-rt = "1.0.0-alpha.3"
+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.2"
-futures = "0.3.1"
+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-resolver = { version="0.18.0-alpha.2", default-features = false, features=["tokio"] }
+trust-dns-proto = { version = "0.19", default-features = false, features = ["tokio-runtime"] }
+trust-dns-resolver = { version = "0.19", default-features = false, features = ["tokio-runtime", "system-config"] }
 
 # openssl
-open-ssl = { version="0.10", package = "openssl", optional = true }
+open-ssl = { package = "openssl", version = "0.10", optional = true }
 tokio-openssl = { version = "0.4.0", optional = true }
 
 # rustls
-rust-tls = { version = "0.16.0", package = "rustls", optional = true }
-tokio-rustls = { version = "0.12.0", optional = true }
+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.2"
-actix-testing = { version="1.0.0-alpha.2" }
+bytes = "0.5.3"
+actix-testing = "1.0.0"

actix-connect/src/connect.rs

@@ -6,7 +6,7 @@ use std::net::SocketAddr;
 use either::Either;
 
 /// Connect request
-pub trait Address: Unpin {
+pub trait Address: Unpin + 'static {
     /// Host name of the request
     fn host(&self) -> &str;
 
@@ -43,7 +43,7 @@ pub struct Connect<T> {
 }
 
 impl<T: Address> Connect<T> {
-    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
+    /// 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 {
@@ -53,7 +53,8 @@ impl<T: Address> Connect<T> {
         }
     }
 
-    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
+    /// 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,
@@ -102,7 +103,7 @@ impl<T: Address> Connect<T> {
         self.req.port().unwrap_or(self.port)
     }
 
-    /// Preresolved addresses of the request.
+    /// Pre-resolved addresses of the request.
     pub fn addrs(&self) -> ConnectAddrsIter<'_> {
         let inner = match self.addr {
             None => Either::Left(None),
@@ -113,7 +114,7 @@ impl<T: Address> Connect<T> {
         ConnectAddrsIter { inner }
     }
 
-    /// Takes preresolved addresses of the request.
+    /// Takes pre-resolved addresses of the request.
     pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter {
         let inner = match self.addr.take() {
             None => Either::Left(None),
@@ -137,7 +138,7 @@ impl<T: Address> fmt::Display for Connect<T> {
     }
 }
 
-/// Iterator over addresses in a [`Connect`](struct.Connect.html) request.
+/// Iterator over addresses in a [`Connect`] request.
 #[derive(Clone)]
 pub struct ConnectAddrsIter<'a> {
     inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
@@ -172,7 +173,7 @@ impl ExactSizeIterator for ConnectAddrsIter<'_> {}
 
 impl FusedIterator for ConnectAddrsIter<'_> {}
 
-/// Owned iterator over addresses in a [`Connect`](struct.Connect.html) request.
+/// Owned iterator over addresses in a [`Connect`] request.
 #[derive(Debug)]
 pub struct ConnectTakeAddrsIter {
     inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,

actix-connect/src/connector.rs

@@ -8,12 +8,12 @@ use std::task::{Context, Poll};
 
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
-use futures::future::{err, ok, BoxFuture, Either, FutureExt, Ready};
+use futures_util::future::{err, ok, BoxFuture, Either, FutureExt, Ready};
 
 use super::connect::{Address, Connect, Connection};
 use super::error::ConnectError;
 
-/// Tcp connector service factory
+/// TCP connector service factory
 #[derive(Debug)]
 pub struct TcpConnectorFactory<T>(PhantomData<T>);
 
@@ -22,7 +22,7 @@ impl<T> TcpConnectorFactory<T> {
         TcpConnectorFactory(PhantomData)
     }
 
-    /// Create tcp connector service
+    /// Create TCP connector service
     pub fn service(&self) -> TcpConnector<T> {
         TcpConnector(PhantomData)
     }
@@ -40,8 +40,7 @@ impl<T> Clone for TcpConnectorFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for TcpConnectorFactory<T> {
-    type Request = Connect<T>;
+impl<T: Address> ServiceFactory<Connect<T>> for TcpConnectorFactory<T> {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
@@ -54,7 +53,7 @@ impl<T: Address> ServiceFactory for TcpConnectorFactory<T> {
     }
 }
 
-/// Tcp connector service
+/// TCP connector service
 #[derive(Default, Debug)]
 pub struct TcpConnector<T>(PhantomData<T>);
 
@@ -70,15 +69,13 @@ impl<T> Clone for TcpConnector<T> {
     }
 }
 
-impl<T: Address> Service for TcpConnector<T> {
-    type Request = Connect<T>;
+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>>>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         let port = req.port();
@@ -88,13 +85,13 @@ impl<T: Address> Service for TcpConnector<T> {
             Either::Left(TcpConnectorResponse::new(req, port, addr))
         } else {
             error!("TCP connector: got unresolved address");
-            Either::Right(err(ConnectError::Unresolverd))
+            Either::Right(err(ConnectError::Unresolved))
         }
     }
 }
 
 #[doc(hidden)]
-/// Tcp stream connector response future
+/// TCP stream connector response future
 pub struct TcpConnectorResponse<T> {
     req: Option<T>,
     port: u16,

actix-connect/src/error.rs

@@ -18,9 +18,9 @@ pub enum ConnectError {
 
     /// Unresolved host name
     #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolverd,
+    Unresolved,
 
-    /// Connection io error
+    /// Connection IO error
     #[display(fmt = "{}", _0)]
     Io(io::Error),
 }

actix-connect/src/lib.rs

@@ -1,12 +1,14 @@
-//! Actix connect - tcp connector service
+//! TCP connector service for Actix ecosystem.
 //!
 //! ## Package feature
 //!
-//! * `openssl` - enables ssl support via `openssl` crate
-//! * `rustls` - enables ssl support via `rustls` crate
-#![deny(rust_2018_idioms, warnings)]
-#![allow(clippy::type_complexity)]
+//! * `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;
@@ -25,7 +27,7 @@ use actix_rt::{net::TcpStream, Arbiter};
 use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory};
 use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
 use trust_dns_resolver::system_conf::read_system_conf;
-use trust_dns_resolver::AsyncResolver;
+use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
 
 pub mod resolver {
     pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
@@ -39,17 +41,18 @@ pub use self::error::ConnectError;
 pub use self::resolve::{Resolver, ResolverFactory};
 pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
 
-pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
-    let (resolver, bg) = AsyncResolver::new(cfg, opts);
-    actix_rt::spawn(bg);
-    resolver
+pub async fn start_resolver(
+    cfg: ResolverConfig,
+    opts: ResolverOpts,
+) -> Result<AsyncResolver, ConnectError> {
+    Ok(AsyncResolver::tokio(cfg, opts).await?)
 }
 
 struct DefaultResolver(AsyncResolver);
 
-pub(crate) fn get_default_resolver() -> AsyncResolver {
+pub(crate) async fn get_default_resolver() -> Result<AsyncResolver, ConnectError> {
     if Arbiter::contains_item::<DefaultResolver>() {
-        Arbiter::get_item(|item: &DefaultResolver| item.0.clone())
+        Ok(Arbiter::get_item(|item: &DefaultResolver| item.0.clone()))
     } else {
         let (cfg, opts) = match read_system_conf() {
             Ok((cfg, opts)) => (cfg, opts),
@@ -59,32 +62,31 @@ pub(crate) fn get_default_resolver() -> AsyncResolver {
             }
         };
 
-        let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        actix_rt::spawn(bg);
+        let resolver = AsyncResolver::tokio(cfg, opts).await?;
 
         Arbiter::set_item(DefaultResolver(resolver.clone()));
-        resolver
+        Ok(resolver)
     }
 }
 
-pub fn start_default_resolver() -> AsyncResolver {
-    get_default_resolver()
+pub async fn start_default_resolver() -> Result<AsyncResolver, ConnectError> {
+    get_default_resolver().await
 }
 
-/// Create tcp connector service
-pub fn new_connector<T: Address>(
+/// Create TCP connector service.
+pub fn new_connector<T: Address + 'static>(
     resolver: AsyncResolver,
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
-       + Clone {
+) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
+{
     pipeline(Resolver::new(resolver)).and_then(TcpConnector::new())
 }
 
-/// Create tcp connector service
-pub fn new_connector_factory<T: Address>(
+/// Create TCP connector service factory.
+pub fn new_connector_factory<T: Address + 'static>(
     resolver: AsyncResolver,
 ) -> impl ServiceFactory<
+    Connect<T>,
     Config = (),
-    Request = Connect<T>,
     Response = Connection<T, TcpStream>,
     Error = ConnectError,
     InitError = (),
@@ -92,17 +94,17 @@ pub fn new_connector_factory<T: Address>(
     pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory::new())
 }
 
-/// Create connector service with default parameters
-pub fn default_connector<T: Address>(
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
-       + Clone {
+/// 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>() -> impl ServiceFactory<
+/// Create connector service factory with default parameters.
+pub fn default_connector_factory<T: Address + 'static>() -> impl ServiceFactory<
+    Connect<T>,
     Config = (),
-    Request = Connect<T>,
     Response = Connection<T, TcpStream>,
     Error = ConnectError,
     InitError = (),

actix-connect/src/resolve.rs

@@ -5,9 +5,9 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use actix_service::{Service, ServiceFactory};
-use futures::future::{ok, Either, Ready};
-use trust_dns_resolver::lookup_ip::LookupIpFuture;
-use trust_dns_resolver::{AsyncResolver, Background};
+use 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;
@@ -54,8 +54,7 @@ impl<T> Clone for ResolverFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for ResolverFactory<T> {
-    type Request = Connect<T>;
+impl<T: Address> ServiceFactory<Connect<T>> for ResolverFactory<T> {
     type Response = Connect<T>;
     type Error = ConnectError;
     type Config = ();
@@ -102,15 +101,16 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: Address> Service for Resolver<T> {
-    type Request = Connect<T>;
+impl<T: Address> Service<Connect<T>> for Resolver<T> {
     type Response = Connect<T>;
     type Error = ConnectError;
-    type Future = Either<ResolverFuture<T>, Ready<Result<Connect<T>, Self::Error>>>;
+    #[allow(clippy::type_complexity)]
+    type Future = Either<
+        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>,
+        Ready<Result<Connect<T>, Self::Error>>,
+    >;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, mut req: Connect<T>) -> Self::Future {
         if req.addr.is_some() {
@@ -119,32 +119,48 @@ impl<T: Address> Service for Resolver<T> {
             req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
             Either::Right(ok(req))
         } else {
-            trace!("DNS resolver: resolving host {:?}", req.host());
-            if self.resolver.is_none() {
-                self.resolver = Some(get_default_resolver());
-            }
-            Either::Left(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
+            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: Background<LookupIpFuture>,
+    lookup: LookupIpFuture,
 }
 
 impl<T: Address> ResolverFuture<T> {
     pub fn new(req: Connect<T>, resolver: &AsyncResolver) -> Self {
-        let lookup = if let Some(host) = req.host().splitn(2, ':').next() {
-            resolver.lookup_ip(host)
+        let host = if let Some(host) = req.host().splitn(2, ':').next() {
+            host
         } else {
-            resolver.lookup_ip(req.host())
+            req.host()
         };
 
+        // Clone data to be moved to the lookup future
+        let host_clone = host.to_owned();
+        let resolver_clone = resolver.clone();
+
         ResolverFuture {
-            lookup,
+            lookup: Box::pin(async move {
+                let resolver = resolver_clone;
+                resolver.lookup_ip(host_clone).await
+            }),
             req: Some(req),
         }
     }

actix-connect/src/service.rs

@@ -5,8 +5,8 @@ use std::task::{Context, Poll};
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
 use either::Either;
-use futures::future::{ok, Ready};
-use trust_dns_resolver::AsyncResolver;
+use futures_util::future::{ok, Ready};
+use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
 
 use crate::connect::{Address, Connect, Connection};
 use crate::connector::{TcpConnector, TcpConnectorFactory};
@@ -70,8 +70,7 @@ impl<T> Clone for ConnectServiceFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for ConnectServiceFactory<T> {
-    type Request = Connect<T>;
+impl<T: Address> ServiceFactory<Connect<T>> for ConnectServiceFactory<T> {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
@@ -90,15 +89,12 @@ pub struct ConnectService<T> {
     resolver: Resolver<T>,
 }
 
-impl<T: Address> Service for ConnectService<T> {
-    type Request = Connect<T>;
+impl<T: Address> Service<Connect<T>> for ConnectService<T> {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Future = ConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         ConnectServiceResponse {
@@ -109,11 +105,12 @@ impl<T: Address> Service for ConnectService<T> {
 }
 
 enum ConnectState<T: Address> {
-    Resolve(<Resolver<T> as Service>::Future),
-    Connect(<TcpConnector<T> as Service>::Future),
+    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<'_>,
@@ -159,15 +156,12 @@ pub struct TcpConnectService<T> {
     resolver: Resolver<T>,
 }
 
-impl<T: Address + 'static> Service for TcpConnectService<T> {
-    type Request = Connect<T>;
+impl<T: Address + 'static> Service<Connect<T>> for TcpConnectService<T> {
     type Response = TcpStream;
     type Error = ConnectError;
     type Future = TcpConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         TcpConnectServiceResponse {
@@ -178,8 +172,8 @@ impl<T: Address + 'static> Service for TcpConnectService<T> {
 }
 
 enum TcpConnectState<T: Address> {
-    Resolve(<Resolver<T> as Service>::Future),
-    Connect(<TcpConnector<T> as Service>::Future),
+    Resolve(<Resolver<T> as Service<Connect<T>>>::Future),
+    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
 }
 
 impl<T: Address> TcpConnectState<T> {

actix-connect/src/ssl/openssl.rs

@@ -10,14 +10,14 @@ pub use tokio_openssl::{HandshakeError, SslStream};
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
-use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready};
-use trust_dns_resolver::AsyncResolver;
+use 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
+/// OpenSSL connector factory
 pub struct OpensslConnector<T, U> {
     connector: SslConnector,
     _t: PhantomData<(T, U)>,
@@ -97,11 +97,10 @@ where
     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>>>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
         trace!("SSL Handshake start for: {:?}", stream.host());
@@ -164,7 +163,7 @@ impl<T> OpensslConnectServiceFactory<T> {
         }
     }
 
-    /// Construct new connect service with custom dns resolver
+    /// Construct new connect service with custom DNS resolver
     pub fn with_resolver(connector: SslConnector, resolver: AsyncResolver) -> Self {
         OpensslConnectServiceFactory {
             tcp: ConnectServiceFactory::with_resolver(resolver),
@@ -172,7 +171,7 @@ impl<T> OpensslConnectServiceFactory<T> {
         }
     }
 
-    /// Construct openssl connect service
+    /// Construct OpenSSL connect service
     pub fn service(&self) -> OpensslConnectService<T> {
         OpensslConnectService {
             tcp: self.tcp.service(),
@@ -219,9 +218,7 @@ impl<T: Address + 'static> Service for OpensslConnectService<T> {
     type Error = ConnectError;
     type Future = OpensslConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         OpensslConnectServiceResponse {
@@ -243,7 +240,7 @@ impl<T: Address> Future for OpensslConnectServiceResponse<T> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         if let Some(ref mut fut) = self.fut1 {
-            match futures::ready!(Pin::new(fut).poll(cx)) {
+            match futures_util::ready!(Pin::new(fut).poll(cx)) {
                 Ok(res) => {
                     let _ = self.fut1.take();
                     self.fut2 = Some(self.openssl.call(res));
@@ -253,7 +250,7 @@ impl<T: Address> Future for OpensslConnectServiceResponse<T> {
         }
 
         if let Some(ref mut fut) = self.fut2 {
-            match futures::ready!(Pin::new(fut).poll(cx)) {
+            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,

actix-connect/src/ssl/rustls.rs

@@ -10,7 +10,7 @@ pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::{Service, ServiceFactory};
-use futures::future::{ok, Ready};
+use futures_util::future::{ok, Ready};
 use tokio_rustls::{Connect, TlsConnector};
 use webpki::DNSNameRef;
 
@@ -38,7 +38,7 @@ where
 {
     pub fn service(connector: Arc<ClientConfig>) -> RustlsConnectorService<T, U> {
         RustlsConnectorService {
-            connector: connector,
+            connector,
             _t: PhantomData,
         }
     }
@@ -96,9 +96,7 @@ where
     type Error = std::io::Error;
     type Future = ConnectAsyncExt<T, U>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    actix_service::always_ready!();
 
     fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
         trace!("SSL Handshake start for: {:?}", stream.host());
@@ -126,7 +124,7 @@ where
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
         Poll::Ready(
-            futures::ready!(Pin::new(&mut this.fut).poll(cx)).map(|stream| {
+            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/tests/test_connect.rs

@@ -5,7 +5,7 @@ use actix_rt::net::TcpStream;
 use actix_service::{fn_service, Service, ServiceFactory};
 use actix_testing::TestServer;
 use bytes::Bytes;
-use futures::SinkExt;
+use futures_util::sink::SinkExt;
 
 use actix_connect::resolver::{ResolverConfig, ResolverOpts};
 use actix_connect::Connect;
@@ -14,12 +14,10 @@ use actix_connect::Connect;
 #[actix_rt::test]
 async fn test_string() {
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 
@@ -33,12 +31,10 @@ async fn test_string() {
 #[actix_rt::test]
 async fn test_rustls_string() {
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 
@@ -51,16 +47,14 @@ async fn test_rustls_string() {
 #[actix_rt::test]
 async fn test_static_str() {
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 
-    let resolver = actix_connect::start_default_resolver();
+    let resolver = actix_connect::start_default_resolver().await.unwrap();
     let mut conn = actix_connect::new_connector(resolver.clone());
 
     let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
@@ -75,17 +69,17 @@ async fn test_static_str() {
 #[actix_rt::test]
 async fn test_new_service() {
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 
     let resolver =
-        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default());
+        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
+            .await
+            .unwrap();
 
     let factory = actix_connect::new_connector_factory(resolver);
 
@@ -94,18 +88,16 @@ async fn test_new_service() {
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
-#[cfg(feature = "openssl")]
+#[cfg(all(feature = "openssl", feature = "uri"))]
 #[actix_rt::test]
-async fn test_uri() {
+async fn test_openssl_uri() {
     use std::convert::TryFrom;
 
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 
@@ -115,18 +107,16 @@ async fn test_uri() {
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
-#[cfg(feature = "rustls")]
+#[cfg(all(feature = "rustls", feature = "uri"))]
 #[actix_rt::test]
 async fn test_rustls_uri() {
     use std::convert::TryFrom;
 
     let srv = TestServer::with(|| {
-        fn_service(|io: TcpStream| {
-            async {
-                let mut framed = Framed::new(io, BytesCodec);
-                framed.send(Bytes::from_static(b"test")).await?;
-                Ok::<_, io::Error>(())
-            }
+        fn_service(|io: TcpStream| async {
+            let mut framed = Framed::new(io, BytesCodec);
+            framed.send(Bytes::from_static(b"test")).await?;
+            Ok::<_, io::Error>(())
         })
     });
 

actix-ioframe/CHANGES.md

@@ -1,17 +0,0 @@
-# Changes
-
-## [0.3.0-alpha.3] - 2019-12-07
-
-* Migrate to tokio 0.2
-
-## [0.3.0-alpha.2] - 2019-12-02
-
-* Migrate to `std::future`
-
-## [0.1.1] - 2019-10-14
-
-* Re-register task on every dispatcher poll.
-
-## [0.1.0] - 2019-09-25
-
-* Initial release

actix-ioframe/Cargo.toml

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

actix-ioframe/src/cell.rs

@@ -1,39 +0,0 @@
-//! Custom cell impl
-
-use std::cell::UnsafeCell;
-use std::fmt;
-use std::rc::Rc;
-
-pub(crate) struct Cell<T> {
-    inner: Rc<UnsafeCell<T>>,
-}
-
-impl<T> Clone for Cell<T> {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl<T> Cell<T> {
-    pub fn new(inner: T) -> Self {
-        Self {
-            inner: Rc::new(UnsafeCell::new(inner)),
-        }
-    }
-
-    pub(crate) unsafe fn get_ref(&mut self) -> &T {
-        &*self.inner.as_ref().get()
-    }
-
-    pub(crate) unsafe fn get_mut(&mut self) -> &mut T {
-        &mut *self.inner.as_ref().get()
-    }
-}

actix-ioframe/src/connect.rs

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

actix-ioframe/src/dispatcher.rs

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

actix-ioframe/src/error.rs

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

actix-ioframe/src/item.rs

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

actix-ioframe/src/lib.rs

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

actix-ioframe/src/service.rs

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

actix-ioframe/src/sink.rs

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

actix-ioframe/tests/test_server.rs

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

actix-macros/.gitignore

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

actix-macros/CHANGES.md

@@ -0,0 +1,13 @@
+# CHANGES
+
+## 0.1.3 - 2020-12-3
+
+* 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,21 +1,26 @@
 [package]
 name = "actix-macros"
-version = "0.1.0-alpha.1"
+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/"
 categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 proc-macro = true
 
 [dependencies]
-quote = "^1"
+quote = "1.0.3"
 syn = { version = "^1", features = ["full"] }
 
+[features]
+actix-reexport = []
+
 [dev-dependencies]
-actix-rt = { version = "1.0.0-alpha.1" }
+actix-rt = "1.0"
+
+futures-util = { version = "0.3", default-features = false }
+trybuild = "1"

actix-macros/src/lib.rs

@@ -1,5 +1,8 @@
 //! Macros for use with Tokio
-extern crate proc_macro;
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use proc_macro::TokenStream;
 use quote::quote;
@@ -14,6 +17,7 @@ use quote::quote;
 ///     println!("Hello world");
 /// }
 /// ```
+#[allow(clippy::needless_doctest_main)]
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
@@ -32,14 +36,25 @@ pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
 
     sig.asyncness = None;
 
-    (quote! {
-        #(#attrs)*
-        #vis #sig {
-            actix_rt::System::new(stringify!(#name))
-                .block_on(async move { #body })
-        }
-    })
-    .into()
+    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()
+    }
 }
 
 /// Marks async test function to be executed by actix runtime.
@@ -54,12 +69,11 @@ pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
-    let input = syn::parse_macro_input!(item as syn::ItemFn);
-
-    let ret = &input.sig.output;
-    let name = &input.sig.ident;
-    let body = &input.block;
+    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
     let attrs = &input.attrs;
+    let vis = &input.vis;
+    let sig = &mut input.sig;
+    let body = &input.block;
     let mut has_test_attr = false;
 
     for attr in attrs {
@@ -68,19 +82,21 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
         }
     }
 
-    if input.sig.asyncness.is_none() {
+    if sig.asyncness.is_none() {
         return syn::Error::new_spanned(
             input.sig.fn_token,
-            format!("only async fn is supported, {:?}", input.sig.ident),
+            format!("only async fn is supported, {}", input.sig.ident),
         )
         .to_compile_error()
         .into();
     }
 
+    sig.asyncness = None;
+
     let result = if has_test_attr {
         quote! {
             #(#attrs)*
-            fn #name() #ret {
+            #vis #sig {
                 actix_rt::System::new("test")
                     .block_on(async { #body })
             }
@@ -89,7 +105,7 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
         quote! {
             #[test]
             #(#attrs)*
-            fn #name() #ret {
+            #vis #sig {
                 actix_rt::System::new("test")
                     .block_on(async { #body })
             }

actix-macros/tests/trybuild.rs

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

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

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

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

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

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

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

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

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

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

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

actix-rt/CHANGES.md

@@ -1,5 +1,54 @@
 # Changes
 
+## Unreleased - 2020-xx-xx
+
+
+## 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]
+* Remove `'static` lifetime requirement for `Runtime::block_on` and `SystemRunner::block_on`.
+  * 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
+
+* Fix memory leak due to [#94] (see [#129] for more detail)
+
+[#129]: https://github.com/actix/actix-net/issues/129
+
+## [1.1.0] - 2020-04-08
+
+**This version has been yanked.**
+
+### Added
+
+* Expose `System::is_set` to check if current system has ben started [#99]
+* Add `Arbiter::is_running` to check if event loop is running [#124]
+* Add `Arbiter::local_join` associated function
+  to get be able to `await` for spawned futures [#94]
+
+[#94]: https://github.com/actix/actix-net/pull/94
+[#99]: https://github.com/actix/actix-net/pull/99
+[#124]: https://github.com/actix/actix-net/pull/124
+
+## [1.0.0] - 2019-12-11
+
+* Update dependencies
+
 ## [1.0.0-alpha.3] - 2019-12-07
 
 ### Fixed

actix-rt/Cargo.toml

@@ -1,25 +1,21 @@
 [package]
 name = "actix-rt"
-version = "1.0.0-alpha.3"
+version = "2.0.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime"
+description = "Tokio-based single-thread async runtime 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-rt/"
 categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_rt"
 path = "src/lib.rs"
 
 [dependencies]
-actix-macros = "0.1.0-alpha.1"
-actix-threadpool = "0.3"
-futures = "0.3.1"
-copyless = "0.1.4"
-tokio = { version = "0.2.4", default-features=false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }
+actix-macros = "0.1.0"
+
+tokio = { version = "1", features = ["rt", "net", "signal", "sync", "time"] }

actix-rt/src/arbiter.rs

@@ -1,24 +1,30 @@
 use std::any::{Any, TypeId};
-use std::cell::{Cell, RefCell};
+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 futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
-use futures::channel::oneshot::{channel, Canceled, Sender};
-use futures::{future, Future, FutureExt, Stream};
+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 crate::runtime::Runtime;
 use crate::system::System;
 
-use copyless::BoxHelper;
-
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
-    static RUNNING: Cell<bool> = Cell::new(false);
-    static Q: RefCell<Vec<Pin<Box<dyn Future<Output = ()>>>>> = RefCell::new(Vec::new());
+    // 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());
 );
 
@@ -42,8 +48,8 @@ impl fmt::Debug for ArbiterCommand {
 
 #[derive(Debug)]
 /// Arbiters provide an asynchronous execution environment for actors, functions
-/// and futures. When an Arbiter is created, they spawn a new OS thread, and
-/// host an event loop. Some Arbiter functions execute on the current thread.
+/// 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<()>>,
@@ -62,14 +68,14 @@ impl Default for Arbiter {
 }
 
 impl Arbiter {
-    pub(crate) fn new_system() -> Self {
-        let (tx, rx) = unbounded();
+    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()));
-        RUNNING.with(|cell| cell.set(false));
         STORAGE.with(|cell| cell.borrow_mut().clear());
-        Arbiter::spawn(ArbiterController { stop: None, rx });
+
+        local.spawn_local(ArbiterController { rx });
 
         arb
     }
@@ -83,9 +89,15 @@ impl Arbiter {
         })
     }
 
+    /// 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.unbounded_send(ArbiterCommand::Stop);
+        let _ = self.sender.send(ArbiterCommand::Stop);
     }
 
     /// Spawn new thread and run event loop in spawned thread.
@@ -94,72 +106,47 @@ impl Arbiter {
         let id = COUNT.fetch_add(1, Ordering::Relaxed);
         let name = format!("actix-rt:worker:{}", id);
         let sys = System::current();
-        let (arb_tx, arb_rx) = unbounded();
-        let arb_tx2 = arb_tx.clone();
+        let (tx, rx) = unbounded_channel();
 
         let handle = thread::Builder::new()
             .name(name.clone())
-            .spawn(move || {
-                let mut rt = Runtime::new().expect("Can not create Runtime");
-                let arb = Arbiter::with_sender(arb_tx);
+            .spawn({
+                let tx = tx.clone();
+                move || {
+                    let rt = Runtime::new().expect("Can not create Runtime");
+                    let arb = Arbiter::with_sender(tx);
 
-                let (stop, stop_rx) = channel();
-                RUNNING.with(|cell| cell.set(true));
-                STORAGE.with(|cell| cell.borrow_mut().clear());
+                    STORAGE.with(|cell| cell.borrow_mut().clear());
 
-                System::set_current(sys);
+                    System::set_current(sys);
 
-                // start arbiter controller
-                rt.spawn(ArbiterController {
-                    stop: Some(stop),
-                    rx: arb_rx,
-                });
-                ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+                    ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
 
-                // register arbiter
-                let _ = System::current()
-                    .sys()
-                    .unbounded_send(SystemCommand::RegisterArbiter(id, arb));
+                    // register arbiter
+                    let _ = System::current()
+                        .sys()
+                        .send(SystemCommand::RegisterArbiter(id, arb));
 
-                // run loop
-                let _ = match rt.block_on(stop_rx) {
-                    Ok(code) => code,
-                    Err(_) => 1,
-                };
+                    // start arbiter controller
+                    // run loop
+                    rt.block_on(ArbiterController { rx });
 
-                // unregister arbiter
-                let _ = System::current()
-                    .sys()
-                    .unbounded_send(SystemCommand::UnregisterArbiter(id));
+                    // unregister arbiter
+                    let _ = System::current()
+                        .sys()
+                        .send(SystemCommand::UnregisterArbiter(id));
+                }
             })
             .unwrap_or_else(|err| {
                 panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
             });
 
         Arbiter {
-            sender: arb_tx2,
+            sender: tx,
             thread_handle: Some(handle),
         }
     }
 
-    pub(crate) fn run_system(rt: Option<&Runtime>) {
-        RUNNING.with(|cell| cell.set(true));
-        Q.with(|cell| {
-            let mut v = cell.borrow_mut();
-            for fut in v.drain(..) {
-                if let Some(rt) = rt {
-                    rt.spawn(fut);
-                } else {
-                    tokio::task::spawn_local(fut);
-                }
-            }
-        });
-    }
-
-    pub(crate) fn stop_system() {
-        RUNNING.with(|cell| cell.set(false));
-    }
-
     /// Spawn a future on the current thread. This does not create a new Arbiter
     /// or Arbiter address, it is simply a helper for spawning futures on the current
     /// thread.
@@ -167,19 +154,12 @@ impl Arbiter {
     where
         F: Future<Output = ()> + 'static,
     {
-        RUNNING.with(move |cell| {
-            if cell.get() {
-                // Spawn the future on running executor
-                tokio::task::spawn_local(future);
-            } else {
-                // Box the future and push it to the queue, this results in double boxing
-                // because the executor boxes the future again, but works for now
-                Q.with(move |cell| {
-                    cell.borrow_mut()
-                        .push(unsafe { Pin::new_unchecked(Box::alloc().init(future)) })
-                });
-            }
-        });
+        // 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);
     }
 
     /// Executes a future on the current thread. This does not create a new Arbiter
@@ -190,7 +170,9 @@ impl Arbiter {
         F: FnOnce() -> R + 'static,
         R: Future<Output = ()> + 'static,
     {
-        Arbiter::spawn(future::lazy(|_| f()).flatten())
+        Arbiter::spawn(async {
+            f();
+        })
     }
 
     /// Send a future to the Arbiter's thread, and spawn it.
@@ -198,9 +180,7 @@ impl Arbiter {
     where
         F: Future<Output = ()> + Send + Unpin + 'static,
     {
-        let _ = self
-            .sender
-            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
+        let _ = self.sender.send(ArbiterCommand::Execute(Box::new(future)));
     }
 
     /// Send a function to the Arbiter's thread, and execute it. Any result from the function
@@ -211,7 +191,7 @@ impl Arbiter {
     {
         let _ = self
             .sender
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
                 f();
             })));
     }
@@ -227,8 +207,8 @@ impl Arbiter {
         let (tx, rx) = channel();
         let _ = self
             .sender
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                if !tx.is_canceled() {
+            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                if !tx.is_closed() {
                     let _ = tx.send(f());
                 }
             })));
@@ -294,10 +274,36 @@ impl Arbiter {
             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.")
+    }
 }
 
+// /// 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 {
-    stop: Option<Sender<i32>>,
     rx: UnboundedReceiver<ArbiterCommand>,
 }
 
@@ -319,16 +325,16 @@ impl Future for ArbiterController {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match Pin::new(&mut self.rx).poll_next(cx) {
+            match Pin::new(&mut self.rx).poll_recv(cx) {
                 Poll::Ready(None) => return Poll::Ready(()),
                 Poll::Ready(Some(item)) => match item {
-                    ArbiterCommand::Stop => {
-                        if let Some(stop) = self.stop.take() {
-                            let _ = stop.send(0);
-                        };
-                        return Poll::Ready(());
-                    }
+                    ArbiterCommand::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);
                     }
                     ArbiterCommand::ExecuteFn(f) => {
@@ -341,6 +347,20 @@ impl Future for ArbiterController {
     }
 }
 
+// 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),
@@ -370,7 +390,7 @@ impl Future for SystemArbiter {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match Pin::new(&mut self.commands).poll_next(cx) {
+            match Pin::new(&mut self.commands).poll_recv(cx) {
                 Poll::Ready(None) => return Poll::Ready(()),
                 Poll::Ready(Some(cmd)) => match cmd {
                     SystemCommand::Exit(code) => {

actix-rt/src/builder.rs

@@ -1,9 +1,9 @@
 use std::borrow::Cow;
+use std::future::Future;
 use std::io;
 
-use futures::channel::mpsc::unbounded;
-use futures::channel::oneshot::{channel, Receiver};
-use futures::future::{lazy, Future, FutureExt};
+use tokio::sync::mpsc::unbounded_channel;
+use tokio::sync::oneshot::{channel, Receiver};
 use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemArbiter};
@@ -65,16 +65,17 @@ impl Builder {
     /// Function `f` get called within tokio runtime context.
     pub fn run<F>(self, f: F) -> io::Result<()>
     where
-        F: FnOnce() + 'static,
+        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();
+        let (sys_sender, sys_receiver) = unbounded_channel();
 
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+        let system =
+            System::construct(sys_sender, Arbiter::new_system(local), self.stop_on_panic);
 
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
@@ -87,21 +88,26 @@ impl Builder {
 
     fn create_runtime<F>(self, f: F) -> SystemRunner
     where
-        F: FnOnce() + 'static,
+        F: FnOnce(),
     {
         let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded();
+        let (sys_sender, sys_receiver) = unbounded_channel();
 
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+        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);
 
-        let mut rt = Runtime::new().unwrap();
         rt.spawn(arb);
 
         // init system arbiter and run configuration method
-        rt.block_on(lazy(move |_| f()));
+        rt.block_on(async { f() });
 
         SystemRunner { rt, stop, system }
     }
@@ -120,27 +126,21 @@ impl AsyncSystemRunner {
         let AsyncSystemRunner { stop, .. } = self;
 
         // run loop
-        lazy(|_| {
-            Arbiter::run_system(None);
-            async {
-                let res = match stop.await {
-                    Ok(code) => {
-                        if code != 0 {
-                            Err(io::Error::new(
-                                io::ErrorKind::Other,
-                                format!("Non-zero exit code: {}", code),
-                            ))
-                        } else {
-                            Ok(())
-                        }
+        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)),
-                };
-                Arbiter::stop_system();
-                return res;
+                }
+                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
             }
-        })
-        .flatten()
+        }
     }
 }
 
@@ -157,11 +157,10 @@ impl SystemRunner {
     /// This function will start event loop and will finish once the
     /// `System::stop()` function is called.
     pub fn run(self) -> io::Result<()> {
-        let SystemRunner { mut rt, stop, .. } = self;
+        let SystemRunner { rt, stop, .. } = self;
 
         // run loop
-        Arbiter::run_system(Some(&rt));
-        let result = match rt.block_on(stop) {
+        match rt.block_on(stop) {
             Ok(code) => {
                 if code != 0 {
                     Err(io::Error::new(
@@ -173,19 +172,12 @@ impl SystemRunner {
                 }
             }
             Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
-        };
-        Arbiter::stop_system();
-        result
+        }
     }
 
     /// Execute a future and wait for result.
-    pub fn block_on<F, O>(&mut self, fut: F) -> O
-    where
-        F: Future<Output = O> + 'static,
-    {
-        Arbiter::run_system(Some(&self.rt));
-        let res = self.rt.block_on(fut);
-        Arbiter::stop_system();
-        res
+    #[inline]
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
+        self.rt.block_on(fut)
     }
 }

actix-rt/src/lib.rs

@@ -1,6 +1,11 @@
-//! A runtime implementation that runs everything on the current thread.
-#![deny(rust_2018_idioms, warnings)]
+//! Tokio-based single-thread async runtime for the Actix ecosystem.
+
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+use std::future::Future;
 
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub use actix_macros::{main, test};
@@ -15,23 +20,17 @@ pub use self::builder::{Builder, SystemRunner};
 pub use self::runtime::Runtime;
 pub use self::system::System;
 
-#[doc(hidden)]
-pub use actix_threadpool as blocking;
-
 /// Spawns a future on the current arbiter.
 ///
 /// # Panics
 ///
 /// This function panics if actix system is not running.
+#[inline]
 pub fn spawn<F>(f: F)
 where
-    F: futures::Future<Output = ()> + 'static,
+    F: Future<Output = ()> + 'static,
 {
-    if !System::is_set() {
-        panic!("System is not running");
-    }
-
-    Arbiter::spawn(f);
+    Arbiter::spawn(f)
 }
 
 /// Asynchronous signal handling
@@ -60,7 +59,7 @@ pub mod net {
 /// Utilities for tracking time.
 pub mod time {
     pub use tokio::time::Instant;
-    pub use tokio::time::{delay_for, delay_until, Delay};
     pub use tokio::time::{interval, interval_at, Interval};
+    pub use tokio::time::{sleep, sleep_until, Sleep};
     pub use tokio::time::{timeout, Timeout};
 }

actix-rt/src/runtime.rs

@@ -7,7 +7,7 @@ use tokio::{runtime, task::LocalSet};
 ///
 /// See [module level][mod] documentation for more details.
 ///
-/// [mod]: index.html
+/// [mod]: crate
 #[derive(Debug)]
 pub struct Runtime {
     local: LocalSet,
@@ -18,10 +18,9 @@ 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()
+        let rt = runtime::Builder::new_current_thread()
             .enable_io()
             .enable_time()
-            .basic_scheduler()
             .build()?;
 
         Ok(Runtime {
@@ -30,11 +29,15 @@ impl Runtime {
         })
     }
 
+    pub(super) fn local(&self) -> &LocalSet {
+        &self.local
+    }
+
     /// Spawn a future onto the single-threaded runtime.
     ///
     /// See [module level][mod] documentation for more details.
     ///
-    /// [mod]: index.html
+    /// [mod]: crate
     ///
     /// # Examples
     ///
@@ -44,7 +47,7 @@ impl Runtime {
     ///
     /// # fn dox() {
     /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
+    /// let rt = Runtime::new().unwrap();
     ///
     /// // Spawn a future onto the runtime
     /// rt.spawn(future::lazy(|_| {
@@ -82,11 +85,10 @@ impl Runtime {
     ///
     /// The caller is responsible for ensuring that other spawned futures
     /// complete execution by calling `block_on` or `run`.
-    pub fn block_on<F>(&mut self, f: F) -> F::Output
+    pub fn block_on<F>(&self, f: F) -> F::Output
     where
-        F: Future + 'static,
+        F: Future,
     {
-        let res = self.local.block_on(&mut self.rt, f);
-        res
+        self.local.block_on(&self.rt, f)
     }
 }

actix-rt/src/system.rs

@@ -3,7 +3,7 @@ use std::future::Future;
 use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use futures::channel::mpsc::UnboundedSender;
+use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemCommand};
@@ -57,10 +57,57 @@ impl System {
         Self::builder().name(name).build()
     }
 
-    #[allow(clippy::new_ret_no_self)]
-    /// Create new system using provided tokio Handle.
+    /// 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,
@@ -71,6 +118,75 @@ impl System {
             .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.
     pub fn current() -> System {
         CURRENT.with(|cell| match *cell.borrow() {
@@ -79,8 +195,8 @@ impl System {
         })
     }
 
-    /// Set current running system.
-    pub(crate) fn is_set() -> bool {
+    /// Check if current system is set, i.e., as already been started.
+    pub fn is_set() -> bool {
         CURRENT.with(|cell| cell.borrow().is_some())
     }
 
@@ -115,7 +231,7 @@ impl System {
 
     /// Stop the system with a particular exit code.
     pub fn stop_with_code(&self, code: i32) {
-        let _ = self.sys.unbounded_send(SystemCommand::Exit(code));
+        let _ = self.sys.send(SystemCommand::Exit(code));
     }
 
     pub(crate) fn sys(&self) -> &UnboundedSender<SystemCommand> {
@@ -138,7 +254,7 @@ impl System {
     /// Function `f` get called within tokio runtime context.
     pub fn run<F>(f: F) -> io::Result<()>
     where
-        F: FnOnce() + 'static,
+        F: FnOnce(),
     {
         Self::builder().run(f)
     }

actix-rt/tests/integration_tests.rs

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

@@ -1,181 +1,144 @@
 # Changes
 
-## [1.0.0-alpha.4] - 2019-12-08
+## Unreleased - 2020-xx-xx
 
-### Changed
 
+## 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
+* Update actix-codec to 0.3.0.
+* Workers must be greater than 0. [#167]
+
+[#167]: https://github.com/actix/actix-net/pull/167
+
+
+## 1.0.3 - 2020-05-19
+* Replace deprecated `net2` crate with `socket2` [#140]
+
+[#140]: https://github.com/actix/actix-net/pull/140
+
+
+## 1.0.2 - 2020-02-26
+* Avoid error by calling `reregister()` on Windows [#103]
+
+[#103]: https://github.com/actix/actix-net/pull/103
+
+
+## 1.0.1 - 2019-12-29
+* Rename `.start()` method to `.run()`
+
+
+## 1.0.0 - 2019-12-11
+* Use actix-net releases
+
+
+## 1.0.0-alpha.4 - 2019-12-08
 * Use actix-service 1.0.0-alpha.4
 
-## [1.0.0-alpha.3] - 2019-12-07
-
-### Changed
 
+## 1.0.0-alpha.3 - 2019-12-07
 * Migrate to tokio 0.2
-
-### Fixed
-
 * Fix compilation on non-unix platforms
-
 * Better handling server configuration
 
 
-## [1.0.0-alpha.2] - 2019-12-02
-
-### Changed
-
+## 1.0.0-alpha.2 - 2019-12-02
 * Simplify server service (remove actix-server-config)
-
 * Allow to wait on `Server` until server stops
 
 
-## [0.8.0-alpha.1] - 2019-11-22
-
-### Changed
-
+## 0.8.0-alpha.1 - 2019-11-22
 * Migrate to `std::future`
 
 
-## [0.7.0] - 2019-10-04
-
-### Changed
-
+## 0.7.0 - 2019-10-04
 * Update `rustls` to 0.16
 * Minimum required Rust version upped to 1.37.0
 
 
-## [0.6.1] - 2019-09-25
-
-### Added
-
+## 0.6.1 - 2019-09-25
 * Add UDS listening support to `ServerBuilder`
 
 
-## [0.6.0] - 2019-07-18
-
-### Added
-
+## 0.6.0 - 2019-07-18
 * Support Unix domain sockets #3
 
 
-## [0.5.1] - 2019-05-18
-
-### Changed
-
+## 0.5.1 - 2019-05-18
 * ServerBuilder::shutdown_timeout() accepts u64
 
 
-## [0.5.0] - 2019-05-12
-
-### Added
-
+## 0.5.0 - 2019-05-12
 * Add `Debug` impl for `SslError`
-
 * Derive debug for `Server` and `ServerCommand`
-
-### Changed
-
 * Upgrade to actix-service 0.4
 
 
-## [0.4.3] - 2019-04-16
-
-### Added
-
+## 0.4.3 - 2019-04-16
 * Re-export `IoStream` trait
-
-### Changed
-
-* Deppend on `ssl` and `rust-tls` features from actix-server-config
+* Depend on `ssl` and `rust-tls` features from actix-server-config
 
 
-## [0.4.2] - 2019-03-30
-
-### Fixed
-
+## 0.4.2 - 2019-03-30
 * Fix SIGINT force shutdown
 
 
-## [0.4.1] - 2019-03-14
-
-### Added
-
+## 0.4.1 - 2019-03-14
 * `SystemRuntime::on_start()` - allow to run future before server service initialization
 
 
-## [0.4.0] - 2019-03-12
-
-### Changed
-
+## 0.4.0 - 2019-03-12
 * Use `ServerConfig` for service factory
-
 * Wrap tcp socket to `Io` type
-
 * Upgrade actix-service
 
 
-## [0.3.1] - 2019-03-04
-
-### Added
-
+## 0.3.1 - 2019-03-04
 * Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
-
 * Add helper ssl error `SslError`
-
-
-### Changed
-
 * Rename `StreamServiceFactory` to `ServiceFactory`
-
 * Deprecate `StreamServiceFactory`
 
 
-## [0.3.0] - 2019-03-02
-
-### Changed
-
+## 0.3.0 - 2019-03-02
 * Use new `NewService` trait
 
 
-## [0.2.1] - 2019-02-09
-
-### Changed
-
+## 0.2.1 - 2019-02-09
 * Drop service response
 
 
-## [0.2.0] - 2019-02-01
-
-### Changed
-
+## 0.2.0 - 2019-02-01
 * Migrate to actix-service 0.2
-
 * Updated rustls dependency
 
 
-## [0.1.3] - 2018-12-21
-
-### Fixed
-
+## 0.1.3 - 2018-12-21
 * Fix max concurrent connections handling
 
 
-## [0.1.2] - 2018-12-12
-
-### Changed
-
+## 0.1.2 - 2018-12-12
 * rename ServiceConfig::rt() to ServiceConfig::apply()
-
-
-### Fixed
-
 * Fix back-pressure for concurrent ssl handshakes
 
 
-## [0.1.1] - 2018-12-11
-
+## 0.1.1 - 2018-12-11
 * Fix signal handling on windows
 
 
-## [0.1.0] - 2018-12-09
-
+## 0.1.0 - 2018-12-09
 * Move server to separate crate

actix-server/Cargo.toml

@@ -1,17 +1,19 @@
 [package]
 name = "actix-server"
-version = "1.0.0-alpha.4"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix server - General purpose tcp server"
+version = "2.0.0-beta.1"
+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/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+license = "MIT OR Apache-2.0"
+exclude = [".gitignore", ".cargo/config"]
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_server"
@@ -21,22 +23,21 @@ path = "src/lib.rs"
 default = []
 
 [dependencies]
-actix-service = "1.0.0-alpha.4"
-actix-rt = "1.0.0-alpha.3"
-actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.3"
+actix-codec = "0.4.0-beta.1"
+actix-rt = "2.0.0-beta.1"
+actix-service = "2.0.0-beta.1"
+actix-utils = "3.0.0-beta.1"
 
+futures-core = { version = "0.3.7", default-features = false }
 log = "0.4"
-num_cpus = "1.0"
-mio = "0.6.19"
-net2 = "0.2"
-futures = "0.3.1"
+mio = { version = "0.7.6", features = ["os-poll", "net"] }
+num_cpus = "1.13"
 slab = "0.4"
-
-# unix domain sockets
-mio-uds = { version = "0.6.7" }
+tokio = { version = "1", features = ["sync"] }
 
 [dev-dependencies]
-bytes = "0.5"
-env_logger = "0.6"
-actix-testing = "1.0.0-alpha.3"
+actix-testing = "2.0.0-beta.1"
+bytes = "1"
+env_logger = "0.8"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
+tokio = { version = "1", features = ["io-util"] }

actix-server/examples/basic.rs

@@ -0,0 +1,88 @@
+//! Simple composite-service TCP echo server.
+//!
+//! Using the following command:
+//!
+//! ```sh
+//! nc 127.0.0.1 8080
+//! ```
+//!
+//! 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::{env, io};
+
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::pipeline_factory;
+use bytes::BytesMut;
+use futures_util::future::ok;
+use log::{error, info};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env::set_var("RUST_LOG", "actix=trace,basic=trace");
+    env_logger::init();
+
+    let count = Arc::new(AtomicUsize::new(0));
+
+    let addr = ("127.0.0.1", 8080);
+    info!("starting server on port: {}", &addr.0);
+
+    // Bind socket address and start worker(s). By default, the server uses the number of available
+    // logical CPU cores as the worker count. For this reason, the closure passed to bind needs
+    // to return a service *factory*; so it can be created once per worker.
+    Server::build()
+        .bind("echo", addr, move || {
+            let count = Arc::clone(&count);
+            let num2 = Arc::clone(&count);
+
+            pipeline_factory(move |mut stream: TcpStream| {
+                let count = Arc::clone(&count);
+
+                async move {
+                    let num = count.fetch_add(1, Ordering::SeqCst);
+                    let num = num + 1;
+
+                    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,
+
+                            // more bytes to process
+                            Ok(bytes_read) => {
+                                info!("[{}] read {} bytes", num, bytes_read);
+                                stream.write_all(&buf[size..]).await.unwrap();
+                                size += bytes_read;
+                            }
+
+                            // stream error; bail from loop with error
+                            Err(err) => {
+                                error!("Stream Error: {:?}", err);
+                                return Err(());
+                            }
+                        }
+                    }
+
+                    // send data down service pipeline
+                    Ok((buf.freeze(), size))
+                }
+            })
+            .map_err(|err| error!("Service Error: {:?}", err))
+            .and_then(move |(_, size)| {
+                let num = num2.load(Ordering::SeqCst);
+                info!("[{}] total bytes read: {}", num, size);
+                ok(size)
+            })
+        })?
+        .workers(1)
+        .run()
+        .await
+}

actix-server/src/accept.rs

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

actix-server/src/builder.rs

@@ -1,37 +1,35 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::time::Duration;
-use std::{io, mem, net};
+use std::{io, mem};
 
 use actix_rt::net::TcpStream;
-use actix_rt::time::{delay_until, Instant};
+use actix_rt::time::{sleep_until, Instant};
 use actix_rt::{spawn, System};
-use futures::channel::mpsc::{unbounded, UnboundedReceiver};
-use futures::channel::oneshot;
-use futures::future::ready;
-use futures::stream::FuturesUnordered;
-use futures::{ready, Future, FutureExt, Stream, StreamExt};
 use log::{error, info};
-use net2::TcpBuilder;
-use num_cpus;
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+use tokio::sync::oneshot;
 
-use crate::accept::{AcceptLoop, AcceptNotify, Command};
+use crate::accept::AcceptLoop;
 use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
 use crate::service::{InternalServiceFactory, ServiceFactory, StreamNewService};
 use crate::signals::{Signal, Signals};
-use crate::socket::StdListener;
-use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use crate::Token;
+use crate::socket::{MioListener, StdSocketAddr, StdTcpListener, ToSocketAddrs};
+use crate::socket::{MioTcpListener, MioTcpSocket};
+use crate::waker_queue::{WakerInterest, WakerQueue};
+use crate::worker::{self, Worker, WorkerAvailability, WorkerHandle};
+use crate::{join_all, Token};
 
 /// Server builder
 pub struct ServerBuilder {
     threads: usize,
     token: Token,
-    backlog: i32,
-    workers: Vec<(usize, WorkerClient)>,
+    backlog: u32,
+    handles: Vec<(usize, WorkerHandle)>,
     services: Vec<Box<dyn InternalServiceFactory>>,
-    sockets: Vec<(Token, StdListener)>,
+    sockets: Vec<(Token, String, MioListener)>,
     accept: AcceptLoop,
     exit: bool,
     shutdown_timeout: Duration,
@@ -50,13 +48,13 @@ impl Default for ServerBuilder {
 impl ServerBuilder {
     /// Create new Server builder instance
     pub fn new() -> ServerBuilder {
-        let (tx, rx) = unbounded();
+        let (tx, rx) = unbounded_channel();
         let server = Server::new(tx);
 
         ServerBuilder {
             threads: num_cpus::get(),
-            token: Token(0),
-            workers: Vec::new(),
+            token: Token::default(),
+            handles: Vec::new(),
             services: Vec::new(),
             sockets: Vec::new(),
             accept: AcceptLoop::new(server.clone()),
@@ -73,8 +71,9 @@ impl ServerBuilder {
     /// Set number of workers to start.
     ///
     /// By default server uses number of available logical cpu as workers
-    /// count.
+    /// 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
     }
@@ -89,7 +88,7 @@ impl ServerBuilder {
     /// Generally set in the 64-2048 range. Default value is 2048.
     ///
     /// This method should be called before `bind()` method call.
-    pub fn backlog(mut self, num: i32) -> Self {
+    pub fn backlog(mut self, num: u32) -> Self {
         self.backlog = num;
         self
     }
@@ -146,8 +145,8 @@ impl ServerBuilder {
             let mut srv = ConfiguredService::new(apply);
             for (name, lst) in cfg.services {
                 let token = self.token.next();
-                srv.stream(token, name, lst.local_addr()?);
-                self.sockets.push((token, StdListener::Tcp(lst)));
+                srv.stream(token, name.clone(), lst.local_addr()?);
+                self.sockets.push((token, name, MioListener::Tcp(lst)));
             }
             self.services.push(Box::new(srv));
         }
@@ -160,7 +159,7 @@ impl ServerBuilder {
     pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
         F: ServiceFactory<TcpStream>,
-        U: net::ToSocketAddrs,
+        U: ToSocketAddrs,
     {
         let sockets = bind_addr(addr, self.backlog)?;
 
@@ -172,12 +171,13 @@ impl ServerBuilder {
                 factory.clone(),
                 lst.local_addr()?,
             ));
-            self.sockets.push((token, StdListener::Tcp(lst)));
+            self.sockets
+                .push((token, name.as_ref().to_string(), MioListener::Tcp(lst)));
         }
         Ok(self)
     }
 
-    #[cfg(all(unix))]
+    #[cfg(unix)]
     /// Add new unix domain service to the server.
     pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
@@ -185,8 +185,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()) {
@@ -196,33 +194,35 @@ impl ServerBuilder {
             }
         }
 
-        let lst = UnixListener::bind(addr)?;
+        let lst = crate::socket::StdUnixListener::bind(addr)?;
         self.listen_uds(name, lst, factory)
     }
 
-    #[cfg(all(unix))]
+    #[cfg(unix)]
     /// Add new unix domain service to the server.
     /// Useful when running as a systemd service and
     /// a socket FD can be acquired using the systemd crate.
     pub fn listen_uds<F, N: AsRef<str>>(
         mut self,
         name: N,
-        lst: std::os::unix::net::UnixListener,
+        lst: crate::socket::StdUnixListener,
         factory: F,
     ) -> io::Result<Self>
     where
         F: ServiceFactory<actix_rt::net::UnixStream>,
     {
-        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+        use std::net::{IpAddr, Ipv4Addr};
+        lst.set_nonblocking(true)?;
         let token = self.token.next();
-        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let addr = StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
-            factory.clone(),
+            factory,
             addr,
         ));
-        self.sockets.push((token, StdListener::Uds(lst)));
+        self.sockets
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
         Ok(self)
     }
 
@@ -230,72 +230,65 @@ impl ServerBuilder {
     pub fn listen<F, N: AsRef<str>>(
         mut self,
         name: N,
-        lst: net::TcpListener,
+        lst: StdTcpListener,
         factory: F,
     ) -> io::Result<Self>
     where
         F: ServiceFactory<TcpStream>,
     {
+        lst.set_nonblocking(true)?;
+        let addr = lst.local_addr()?;
+
         let token = self.token.next();
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
             factory,
-            lst.local_addr()?,
+            addr,
         ));
-        self.sockets.push((token, StdListener::Tcp(lst)));
+
+        self.sockets
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
         Ok(self)
     }
 
-    /// Spawn new thread and start listening for incoming connections.
-    ///
-    /// This method spawns new thread and starts new actix system. Other than
-    /// that it is similar to `start()` method. This method blocks.
-    ///
-    /// This methods panics if no socket addresses get bound.
-    ///
-    /// ```rust,ignore
-    /// use actix_web::*;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     Server::new().
-    ///         .service(
-    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
-    ///                .bind("127.0.0.1:0")
-    ///         .run()
-    /// }
-    /// ```
-    pub fn run(self) -> io::Result<()> {
-        let sys = System::new("http-server");
-        self.start();
-        sys.run()
+    #[doc(hidden)]
+    pub fn start(self) -> Server {
+        self.run()
     }
 
     /// Starts processing incoming connections and return server controller.
-    pub fn start(mut self) -> Server {
+    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 mut workers = Vec::new();
-            for idx in 0..self.threads {
-                let worker = self.start_worker(idx, self.accept.get_notify());
-                workers.push(worker.clone());
-                self.workers.push((idx, worker));
-            }
+            let handles = (0..self.threads)
+                .map(|idx| {
+                    let handle = self.start_worker(idx, self.accept.waker_owned());
+                    self.handles.push((idx, handle.clone()));
+
+                    handle
+                })
+                .collect();
 
             // start accept thread
             for sock in &self.sockets {
-                info!("Starting server on {}", sock.1);
+                info!("Starting \"{}\" service on {}", sock.1, sock.2);
             }
-            self.accept
-                .start(mem::replace(&mut self.sockets, Vec::new()), workers);
+            self.accept.start(
+                mem::take(&mut self.sockets)
+                    .into_iter()
+                    .map(|t| (t.0, t.2))
+                    .collect(),
+                handles,
+            );
 
             // handle signals
             if !self.no_signals {
-                Signals::start(self.server.clone()).unwrap();
+                Signals::start(self.server.clone());
             }
 
             // start http server actor
@@ -305,10 +298,9 @@ impl ServerBuilder {
         }
     }
 
-    fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
-        let avail = WorkerAvailability::new(notify);
-        let services: Vec<Box<dyn InternalServiceFactory>> =
-            self.services.iter().map(|v| v.clone_factory()).collect();
+    fn start_worker(&self, idx: usize, waker: WakerQueue) -> WorkerHandle {
+        let avail = WorkerAvailability::new(waker);
+        let services = self.services.iter().map(|v| v.clone_factory()).collect();
 
         Worker::start(idx, services, avail, self.shutdown_timeout)
     }
@@ -316,11 +308,11 @@ impl ServerBuilder {
     fn handle_cmd(&mut self, item: ServerCommand) {
         match item {
             ServerCommand::Pause(tx) => {
-                self.accept.send(Command::Pause);
+                self.accept.wake(WakerInterest::Pause);
                 let _ = tx.send(());
             }
             ServerCommand::Resume(tx) => {
-                self.accept.send(Command::Resume);
+                self.accept.wake(WakerInterest::Resume);
                 let _ = tx.send(());
             }
             ServerCommand::Signal(sig) => {
@@ -364,50 +356,41 @@ impl ServerBuilder {
                 let exit = self.exit;
 
                 // stop accept thread
-                self.accept.send(Command::Stop);
-                let notify = std::mem::replace(&mut self.notify, Vec::new());
+                self.accept.wake(WakerInterest::Stop);
+                let notify = std::mem::take(&mut self.notify);
 
                 // stop workers
-                if !self.workers.is_empty() && graceful {
-                    spawn(
-                        self.workers
-                            .iter()
-                            .map(move |worker| worker.1.stop(graceful))
-                            .collect::<FuturesUnordered<_>>()
-                            .collect::<Vec<_>>()
-                            .then(move |_| {
-                                if let Some(tx) = completion {
-                                    let _ = tx.send(());
-                                }
-                                for tx in notify {
-                                    let _ = tx.send(());
-                                }
-                                if exit {
-                                    spawn(
-                                        async {
-                                            delay_until(
-                                                Instant::now() + Duration::from_millis(300),
-                                            )
-                                            .await;
-                                            System::current().stop();
-                                        }
-                                            .boxed(),
-                                    );
-                                }
-                                ready(())
-                            }),
-                    )
+                if !self.handles.is_empty() && graceful {
+                    let iter = self
+                        .handles
+                        .iter()
+                        .map(move |worker| worker.1.stop(graceful))
+                        .collect();
+
+                    let fut = join_all(iter);
+
+                    spawn(async move {
+                        let _ = fut.await;
+                        if let Some(tx) = completion {
+                            let _ = tx.send(());
+                        }
+                        for tx in notify {
+                            let _ = tx.send(());
+                        }
+                        if exit {
+                            spawn(async {
+                                sleep_until(Instant::now() + Duration::from_millis(300)).await;
+                                System::current().stop();
+                            });
+                        }
+                    })
                 } else {
                     // we need to stop system if server was spawned
                     if self.exit {
-                        spawn(
-                            delay_until(Instant::now() + Duration::from_millis(300)).then(
-                                |_| {
-                                    System::current().stop();
-                                    ready(())
-                                },
-                            ),
-                        );
+                        spawn(async {
+                            sleep_until(Instant::now() + Duration::from_millis(300)).await;
+                            System::current().stop();
+                        });
                     }
                     if let Some(tx) = completion {
                         let _ = tx.send(());
@@ -419,9 +402,9 @@ impl ServerBuilder {
             }
             ServerCommand::WorkerFaulted(idx) => {
                 let mut found = false;
-                for i in 0..self.workers.len() {
-                    if self.workers[i].0 == idx {
-                        self.workers.swap_remove(i);
+                for i in 0..self.handles.len() {
+                    if self.handles[i].0 == idx {
+                        self.handles.swap_remove(i);
                         found = true;
                         break;
                     }
@@ -430,10 +413,10 @@ impl ServerBuilder {
                 if found {
                     error!("Worker has died {:?}, restarting", idx);
 
-                    let mut new_idx = self.workers.len();
+                    let mut new_idx = self.handles.len();
                     'found: loop {
-                        for i in 0..self.workers.len() {
-                            if self.workers[i].0 == new_idx {
+                        for i in 0..self.handles.len() {
+                            if self.handles[i].0 == new_idx {
                                 new_idx += 1;
                                 continue 'found;
                             }
@@ -441,9 +424,9 @@ impl ServerBuilder {
                         break;
                     }
 
-                    let worker = self.start_worker(new_idx, self.accept.get_notify());
-                    self.workers.push((new_idx, worker.clone()));
-                    self.accept.send(Command::Worker(worker));
+                    let handle = self.start_worker(new_idx, self.accept.waker_owned());
+                    self.handles.push((new_idx, handle.clone()));
+                    self.accept.wake(WakerInterest::Worker(handle));
                 }
             }
         }
@@ -455,20 +438,18 @@ impl Future for ServerBuilder {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match ready!(Pin::new(&mut self.cmd).poll_next(cx)) {
-                Some(it) => self.as_mut().get_mut().handle_cmd(it),
-                None => {
-                    return Poll::Pending;
-                }
+            match Pin::new(&mut self.cmd).poll_recv(cx) {
+                Poll::Ready(Some(it)) => self.as_mut().get_mut().handle_cmd(it),
+                _ => return Poll::Pending,
             }
         }
     }
 }
 
-pub(super) fn bind_addr<S: net::ToSocketAddrs>(
+pub(super) fn bind_addr<S: ToSocketAddrs>(
     addr: S,
-    backlog: i32,
-) -> io::Result<Vec<net::TcpListener>> {
+    backlog: u32,
+) -> io::Result<Vec<MioTcpListener>> {
     let mut err = None;
     let mut succ = false;
     let mut sockets = Vec::new();
@@ -496,12 +477,13 @@ pub(super) fn bind_addr<S: net::ToSocketAddrs>(
     }
 }
 
-fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
-    let builder = match addr {
-        net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
-        net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
+fn create_tcp_listener(addr: StdSocketAddr, backlog: u32) -> io::Result<MioTcpListener> {
+    let socket = match addr {
+        StdSocketAddr::V4(_) => MioTcpSocket::new_v4()?,
+        StdSocketAddr::V6(_) => MioTcpSocket::new_v6()?,
     };
-    builder.reuse_address(true)?;
-    builder.bind(addr)?;
-    Ok(builder.listen(backlog)?)
+
+    socket.set_reuseaddr(true)?;
+    socket.bind(addr)?;
+    socket.listen(backlog)
 }

actix-server/src/config.rs

@@ -1,27 +1,30 @@
 use std::collections::HashMap;
-use std::{fmt, io, net};
+use std::future::Future;
+use std::{fmt, io};
 
 use actix_rt::net::TcpStream;
-use actix_service as actix;
+use actix_service::{
+    fn_service, IntoServiceFactory as IntoBaseServiceFactory,
+    ServiceFactory as BaseServiceFactory,
+};
 use actix_utils::counter::CounterGuard;
-use futures::future::{ok, Future, FutureExt, LocalBoxFuture};
+use futures_core::future::LocalBoxFuture;
 use log::error;
 
-use super::builder::bind_addr;
-use super::service::{
-    BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
-};
-use super::Token;
+use crate::builder::bind_addr;
+use crate::service::{BoxedServerService, InternalServiceFactory, StreamService};
+use crate::socket::{MioStream, MioTcpListener, StdSocketAddr, StdTcpListener, ToSocketAddrs};
+use crate::{ready, Token};
 
 pub struct ServiceConfig {
-    pub(crate) services: Vec<(String, net::TcpListener)>,
+    pub(crate) services: Vec<(String, MioTcpListener)>,
     pub(crate) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
     pub(crate) threads: usize,
-    pub(crate) backlog: i32,
+    pub(crate) backlog: u32,
 }
 
 impl ServiceConfig {
-    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: u32) -> ServiceConfig {
         ServiceConfig {
             threads,
             backlog,
@@ -41,24 +44,20 @@ impl ServiceConfig {
     /// Add new service to server
     pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
     where
-        U: net::ToSocketAddrs,
+        U: ToSocketAddrs,
     {
         let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
-            self.listen(name.as_ref(), lst);
+            self._listen(name.as_ref(), lst);
         }
 
         Ok(self)
     }
 
     /// Add new service to server
-    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
-        if self.apply.is_none() {
-            self.apply = Some(Box::new(not_configured));
-        }
-        self.services.push((name.as_ref().to_string(), lst));
-        self
+    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: StdTcpListener) -> &mut Self {
+        self._listen(name, MioTcpListener::from_std(lst))
     }
 
     /// Register service configuration function. This function get called
@@ -70,11 +69,19 @@ impl ServiceConfig {
         self.apply = Some(Box::new(f));
         Ok(())
     }
+
+    fn _listen<N: AsRef<str>>(&mut self, name: N, lst: MioTcpListener) -> &mut Self {
+        if self.apply.is_none() {
+            self.apply = Some(Box::new(not_configured));
+        }
+        self.services.push((name.as_ref().to_string(), lst));
+        self
+    }
 }
 
 pub(super) struct ConfiguredService {
     rt: Box<dyn ServiceRuntimeConfiguration>,
-    names: HashMap<Token, (String, net::SocketAddr)>,
+    names: HashMap<Token, (String, StdSocketAddr)>,
     topics: HashMap<String, Token>,
     services: Vec<Token>,
 }
@@ -89,9 +96,9 @@ impl ConfiguredService {
         }
     }
 
-    pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
+    pub(super) fn stream(&mut self, token: Token, name: String, addr: StdSocketAddr) {
         self.names.insert(token, (name.clone(), addr));
-        self.topics.insert(name.clone(), token);
+        self.topics.insert(name, token);
         self.services.push(token);
     }
 }
@@ -119,7 +126,7 @@ impl InternalServiceFactory for ConfiguredService {
         let tokens = self.services.clone();
 
         // construct services
-        async move {
+        Box::pin(async move {
             let mut services = rt.services;
             // TODO: Proper error handling here
             for f in rt.onstart.into_iter() {
@@ -142,18 +149,15 @@ impl InternalServiceFactory for ConfiguredService {
                     let name = names.remove(&token).unwrap().0;
                     res.push((
                         token,
-                        Box::new(StreamService::new(actix::fn_service(
-                            move |_: TcpStream| {
-                                error!("Service {:?} is not configured", name);
-                                ok::<_, ()>(())
-                            },
-                        ))),
+                        Box::new(StreamService::new(fn_service(move |_: TcpStream| {
+                            error!("Service {:?} is not configured", name);
+                            ready::<Result<_, ()>>(Ok(()))
+                        }))),
                     ));
                 };
             }
-            return Ok(res);
-        }
-            .boxed_local()
+            Ok(res)
+        })
     }
 }
 
@@ -209,8 +213,8 @@ impl ServiceRuntime {
     /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: actix::IntoServiceFactory<T>,
-        T: actix::ServiceFactory<Config = (), Request = TcpStream> + 'static,
+        F: IntoBaseServiceFactory<T, TcpStream>,
+        T: BaseServiceFactory<TcpStream, Config = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -218,7 +222,7 @@ impl ServiceRuntime {
         // let name = name.to_owned();
         if let Some(token) = self.names.get(name) {
             self.services.insert(
-                token.clone(),
+                *token,
                 Box::new(ServiceFactory {
                     inner: service.into_factory(),
                 }),
@@ -233,13 +237,13 @@ impl ServiceRuntime {
     where
         F: Future<Output = ()> + 'static,
     {
-        self.onstart.push(fut.boxed_local())
+        self.onstart.push(Box::pin(fut))
     }
 }
 
 type BoxedNewService = Box<
-    dyn actix::ServiceFactory<
-        Request = (Option<CounterGuard>, ServerMessage),
+    dyn BaseServiceFactory<
+        (Option<CounterGuard>, MioStream),
         Response = (),
         Error = (),
         InitError = (),
@@ -253,33 +257,31 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> actix::ServiceFactory for ServiceFactory<T>
+impl<T> BaseServiceFactory<(Option<CounterGuard>, MioStream)> for ServiceFactory<T>
 where
-    T: actix::ServiceFactory<Config = (), Request = TcpStream>,
+    T: BaseServiceFactory<TcpStream, Config = ()>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
     T::InitError: fmt::Debug + 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
-    type InitError = ();
     type Config = ();
     type Service = BoxedServerService;
+    type InitError = ();
     type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
         let fut = self.inner.new_service(());
-        async move {
-            return match fut.await {
+        Box::pin(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/lib.rs

@@ -1,6 +1,8 @@
-//! General purpose tcp server
-#![deny(rust_2018_idioms, warnings)]
-#![allow(clippy::type_complexity)]
+//! General purpose TCP server.
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 mod accept;
 mod builder;
@@ -9,6 +11,7 @@ mod server;
 mod service;
 mod signals;
 mod socket;
+mod waker_queue;
 mod worker;
 
 pub use self::builder::ServerBuilder;
@@ -19,11 +22,25 @@ pub use self::service::ServiceFactory;
 #[doc(hidden)]
 pub use self::socket::FromStream;
 
-/// Socket id token
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+/// Socket ID token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(crate) struct Token(usize);
 
+impl Default for Token {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Token {
+    fn new() -> Self {
+        Self(0)
+    }
+
     pub(crate) fn next(&mut self) -> Token {
         let token = Token(self.0);
         self.0 += 1;
@@ -35,3 +52,90 @@ impl Token {
 pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }
+
+// temporary Ready type for std::future::{ready, Ready}; Can be removed when MSRV surpass 1.48
+#[doc(hidden)]
+pub struct Ready<T>(Option<T>);
+
+pub(crate) fn ready<T>(t: T) -> Ready<T> {
+    Ready(Some(t))
+}
+
+impl<T> Unpin for Ready<T> {}
+
+impl<T> Future for Ready<T> {
+    type Output = T;
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(self.get_mut().0.take().unwrap())
+    }
+}
+
+// a poor man's join future. joined future is only used when starting/stopping the server.
+// pin_project and pinned futures are overkill for this task.
+pub(crate) struct JoinAll<T> {
+    fut: Vec<JoinFuture<T>>,
+}
+
+pub(crate) fn join_all<T>(fut: Vec<impl Future<Output = T> + 'static>) -> JoinAll<T> {
+    let fut = fut
+        .into_iter()
+        .map(|f| JoinFuture::Future(Box::pin(f)))
+        .collect();
+
+    JoinAll { fut }
+}
+
+enum JoinFuture<T> {
+    Future(Pin<Box<dyn Future<Output = T>>>),
+    Result(Option<T>),
+}
+
+impl<T> Unpin for JoinAll<T> {}
+
+impl<T> Future for JoinAll<T> {
+    type Output = Vec<T>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut ready = true;
+
+        let this = self.get_mut();
+        for fut in this.fut.iter_mut() {
+            if let JoinFuture::Future(f) = fut {
+                match f.as_mut().poll(cx) {
+                    Poll::Ready(t) => {
+                        *fut = JoinFuture::Result(Some(t));
+                    }
+                    Poll::Pending => ready = false,
+                }
+            }
+        }
+
+        if ready {
+            let mut res = Vec::new();
+            for fut in this.fut.iter_mut() {
+                if let JoinFuture::Result(f) = fut {
+                    res.push(f.take().unwrap());
+                }
+            }
+
+            Poll::Ready(res)
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[actix_rt::test]
+    async fn test_join_all() {
+        let futs = vec![ready(Ok(1)), ready(Err(3)), ready(Ok(9))];
+        let mut res = join_all(futs).await.into_iter();
+        assert_eq!(Ok(1), res.next().unwrap());
+        assert_eq!(Err(3), res.next().unwrap());
+        assert_eq!(Ok(9), res.next().unwrap());
+    }
+}

actix-server/src/server.rs

@@ -3,9 +3,8 @@ use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures::channel::mpsc::UnboundedSender;
-use futures::channel::oneshot;
-use futures::FutureExt;
+use tokio::sync::mpsc::UnboundedSender;
+use tokio::sync::oneshot;
 
 use crate::builder::ServerBuilder;
 use crate::signals::Signal;
@@ -42,11 +41,11 @@ impl Server {
     }
 
     pub(crate) fn signal(&self, sig: Signal) {
-        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+        let _ = self.0.send(ServerCommand::Signal(sig));
     }
 
     pub(crate) fn worker_faulted(&self, idx: usize) {
-        let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(idx));
+        let _ = self.0.send(ServerCommand::WorkerFaulted(idx));
     }
 
     /// Pause accepting incoming connections
@@ -55,15 +54,19 @@ impl Server {
     /// All opened connection remains active.
     pub fn pause(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
-        rx.map(|_| ())
+        let _ = self.0.send(ServerCommand::Pause(tx));
+        async {
+            let _ = rx.await;
+        }
     }
 
     /// Resume accepting incoming connections
     pub fn resume(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
-        rx.map(|_| ())
+        let _ = self.0.send(ServerCommand::Resume(tx));
+        async {
+            let _ = rx.await;
+        }
     }
 
     /// Stop incoming connection processing, stop all workers and exit.
@@ -71,11 +74,13 @@ impl Server {
     /// If server starts with `spawn()` method, then spawned thread get terminated.
     pub fn stop(&self, graceful: bool) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Stop {
+        let _ = self.0.send(ServerCommand::Stop {
             graceful,
             completion: Some(tx),
         });
-        rx.map(|_| ())
+        async {
+            let _ = rx.await;
+        }
     }
 }
 
@@ -93,7 +98,7 @@ impl Future for Server {
 
         if this.1.is_none() {
             let (tx, rx) = oneshot::channel();
-            if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() {
+            if this.0.send(ServerCommand::Notify(tx)).is_err() {
                 return Poll::Ready(Ok(()));
             }
             this.1 = Some(rx);
@@ -101,8 +106,7 @@ impl Future for Server {
 
         match Pin::new(this.1.as_mut().unwrap()).poll(cx) {
             Poll::Pending => Poll::Pending,
-            Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
-            Poll::Ready(Err(_)) => Poll::Ready(Ok(())),
+            Poll::Ready(_) => Poll::Ready(Ok(())),
         }
     }
 }

actix-server/src/service.rs

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

actix-server/src/signals.rs

@@ -1,9 +1,8 @@
 use std::future::Future;
-use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures::future::lazy;
+use futures_core::future::LocalBoxFuture;
 
 use crate::server::Server;
 
@@ -24,50 +23,51 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    stream: Pin<Box<dyn Future<Output = io::Result<()>>>>,
+    signals: LocalBoxFuture<'static, std::io::Result<()>>,
     #[cfg(unix)]
-    streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
+    signals: Vec<(Signal, LocalBoxFuture<'static, ()>)>,
 }
 
 impl Signals {
-    pub(crate) fn start(srv: Server) -> io::Result<()> {
-        actix_rt::spawn(lazy(|_| {
-            #[cfg(not(unix))]
-            {
-                actix_rt::spawn(Signals {
-                    srv,
-                    stream: Box::pin(actix_rt::signal::ctrl_c()),
-                });
-            }
-            #[cfg(unix)]
-            {
-                use actix_rt::signal::unix;
+    pub(crate) fn start(srv: Server) {
+        #[cfg(not(unix))]
+        {
+            actix_rt::spawn(Signals {
+                srv,
+                signals: Box::pin(actix_rt::signal::ctrl_c()),
+            });
+        }
+        #[cfg(unix)]
+        {
+            use actix_rt::signal::unix;
 
-                let mut streams = Vec::new();
+            let sig_map = [
+                (unix::SignalKind::interrupt(), Signal::Int),
+                (unix::SignalKind::hangup(), Signal::Hup),
+                (unix::SignalKind::terminate(), Signal::Term),
+                (unix::SignalKind::quit(), Signal::Quit),
+            ];
 
-                let sig_map = [
-                    (unix::SignalKind::interrupt(), Signal::Int),
-                    (unix::SignalKind::hangup(), Signal::Hup),
-                    (unix::SignalKind::terminate(), Signal::Term),
-                    (unix::SignalKind::quit(), Signal::Quit),
-                ];
+            let mut signals = Vec::new();
 
-                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
-                        ),
+            for (kind, sig) in sig_map.iter() {
+                match unix::signal(*kind) {
+                    Ok(mut stream) => {
+                        let fut = Box::pin(async move {
+                            let _ = stream.recv().await;
+                        }) as _;
+                        signals.push((*sig, fut));
                     }
+                    Err(e) => log::error!(
+                        "Can not initialize stream handler for {:?} err: {}",
+                        sig,
+                        e
+                    ),
                 }
-
-                actix_rt::spawn(Signals { srv, streams })
             }
-        }));
 
-        Ok(())
+            actix_rt::spawn(Signals { srv, signals });
+        }
     }
 }
 
@@ -76,25 +76,20 @@ impl Future for Signals {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         #[cfg(not(unix))]
-        match Pin::new(&mut self.stream).poll(cx) {
+        match self.signals.as_mut().poll(cx) {
             Poll::Ready(_) => {
                 self.srv.signal(Signal::Int);
                 Poll::Ready(())
             }
-            Poll::Pending => return Poll::Pending,
+            Poll::Pending => Poll::Pending,
         }
         #[cfg(unix)]
         {
-            for idx in 0..self.streams.len() {
-                loop {
-                    match self.streams[idx].1.poll_recv(cx) {
-                        Poll::Ready(None) => return Poll::Ready(()),
-                        Poll::Pending => break,
-                        Poll::Ready(Some(_)) => {
-                            let sig = self.streams[idx].0;
-                            self.srv.signal(sig);
-                        }
-                    }
+            for (sig, fut) in self.signals.iter_mut() {
+                if fut.as_mut().poll(cx).is_ready() {
+                    let sig = *sig;
+                    self.srv.signal(sig);
+                    return Poll::Ready(());
                 }
             }
             Poll::Pending

actix-server/src/socket.rs

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

actix-server/src/waker_queue.rs

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

actix-server/src/worker.rs

@@ -1,22 +1,22 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::time;
+use std::time::Duration;
 
-use actix_rt::time::{delay_until, Delay, Instant};
+use actix_rt::time::{sleep_until, Instant, Sleep};
 use actix_rt::{spawn, Arbiter};
 use actix_utils::counter::Counter;
-use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
-use futures::channel::oneshot;
-use futures::future::{join_all, LocalBoxFuture, MapOk};
-use futures::{Future, FutureExt, Stream, TryFutureExt};
+use futures_core::future::LocalBoxFuture;
 use log::{error, info, trace};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
+use tokio::sync::oneshot;
 
-use crate::accept::AcceptNotify;
-use crate::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
-use crate::socket::{SocketAddr, StdStream};
-use crate::Token;
+use crate::service::{BoxedServerService, InternalServiceFactory};
+use crate::socket::{MioStream, SocketAddr};
+use crate::waker_queue::{WakerInterest, WakerQueue};
+use crate::{join_all, Token};
 
 pub(crate) struct WorkerCommand(Conn);
 
@@ -29,7 +29,7 @@ pub(crate) struct StopCommand {
 
 #[derive(Debug)]
 pub(crate) struct Conn {
-    pub io: StdStream,
+    pub io: MioStream,
     pub token: Token,
     pub peer: Option<SocketAddr>,
 }
@@ -46,31 +46,33 @@ pub fn max_concurrent_connections(num: usize) {
     MAX_CONNS.store(num, Ordering::Relaxed);
 }
 
-pub(crate) fn num_connections() -> usize {
-    MAX_CONNS_COUNTER.with(|conns| conns.total())
-}
-
 thread_local! {
     static MAX_CONNS_COUNTER: Counter =
         Counter::new(MAX_CONNS.load(Ordering::Relaxed));
 }
 
+pub(crate) fn num_connections() -> usize {
+    MAX_CONNS_COUNTER.with(|conns| conns.total())
+}
+
+// a handle to worker that can send message to worker and share the availability of worker to other
+// thread.
 #[derive(Clone)]
-pub(crate) struct WorkerClient {
+pub(crate) struct WorkerHandle {
     pub idx: usize,
     tx1: UnboundedSender<WorkerCommand>,
     tx2: UnboundedSender<StopCommand>,
     avail: WorkerAvailability,
 }
 
-impl WorkerClient {
+impl WorkerHandle {
     pub fn new(
         idx: usize,
         tx1: UnboundedSender<WorkerCommand>,
         tx2: UnboundedSender<StopCommand>,
         avail: WorkerAvailability,
     ) -> Self {
-        WorkerClient {
+        WorkerHandle {
             idx,
             tx1,
             tx2,
@@ -79,9 +81,7 @@ impl WorkerClient {
     }
 
     pub fn send(&self, msg: Conn) -> Result<(), Conn> {
-        self.tx1
-            .unbounded_send(WorkerCommand(msg))
-            .map_err(|msg| msg.into_inner().0)
+        self.tx1.send(WorkerCommand(msg)).map_err(|msg| msg.0 .0)
     }
 
     pub fn available(&self) -> bool {
@@ -90,21 +90,21 @@ impl WorkerClient {
 
     pub fn stop(&self, graceful: bool) -> oneshot::Receiver<bool> {
         let (result, rx) = oneshot::channel();
-        let _ = self.tx2.unbounded_send(StopCommand { graceful, result });
+        let _ = self.tx2.send(StopCommand { graceful, result });
         rx
     }
 }
 
 #[derive(Clone)]
 pub(crate) struct WorkerAvailability {
-    notify: AcceptNotify,
+    waker: WakerQueue,
     available: Arc<AtomicBool>,
 }
 
 impl WorkerAvailability {
-    pub fn new(notify: AcceptNotify) -> Self {
+    pub fn new(waker: WakerQueue) -> Self {
         WorkerAvailability {
-            notify,
+            waker,
             available: Arc::new(AtomicBool::new(false)),
         }
     }
@@ -115,8 +115,9 @@ impl WorkerAvailability {
 
     pub fn set(&self, val: bool) {
         let old = self.available.swap(val, Ordering::Release);
+        // notify the accept on switched to available.
         if !old && val {
-            self.notify.notify()
+            self.waker.wake(WakerInterest::WorkerAvailable);
         }
     }
 }
@@ -133,7 +134,7 @@ pub(crate) struct Worker {
     conns: Counter,
     factories: Vec<Box<dyn InternalServiceFactory>>,
     state: WorkerState,
-    shutdown_timeout: time::Duration,
+    shutdown_timeout: Duration,
 }
 
 struct WorkerService {
@@ -164,63 +165,65 @@ impl Worker {
         idx: usize,
         factories: Vec<Box<dyn InternalServiceFactory>>,
         availability: WorkerAvailability,
-        shutdown_timeout: time::Duration,
-    ) -> WorkerClient {
-        let (tx1, rx) = unbounded();
-        let (tx2, rx2) = unbounded();
+        shutdown_timeout: Duration,
+    ) -> WorkerHandle {
+        let (tx1, rx) = unbounded_channel();
+        let (tx2, rx2) = unbounded_channel();
         let avail = availability.clone();
 
-        Arbiter::new().send(
-            async move {
-                availability.set(false);
-                let mut wrk = MAX_CONNS_COUNTER.with(move |conns| Worker {
-                    rx,
-                    rx2,
-                    availability,
-                    factories,
-                    shutdown_timeout,
-                    services: Vec::new(),
-                    conns: conns.clone(),
-                    state: WorkerState::Unavailable(Vec::new()),
-                });
+        // every worker runs in it's own arbiter.
+        Arbiter::new().send(Box::pin(async move {
+            availability.set(false);
+            let mut wrk = MAX_CONNS_COUNTER.with(move |conns| Worker {
+                rx,
+                rx2,
+                availability,
+                factories,
+                shutdown_timeout,
+                services: Vec::new(),
+                conns: conns.clone(),
+                state: WorkerState::Unavailable,
+            });
 
-                let mut fut: Vec<MapOk<LocalBoxFuture<'static, _>, _>> = Vec::new();
-                for (idx, factory) in wrk.factories.iter().enumerate() {
-                    fut.push(factory.create().map_ok(move |r| {
-                        r.into_iter()
-                            .map(|(t, s): (Token, _)| (idx, t, s))
-                            .collect::<Vec<_>>()
-                    }));
-                }
+            let fut = wrk
+                .factories
+                .iter()
+                .enumerate()
+                .map(|(idx, factory)| {
+                    let fut = factory.create();
+                    async move {
+                        fut.await.map(|r| {
+                            r.into_iter().map(|(t, s)| (idx, t, s)).collect::<Vec<_>>()
+                        })
+                    }
+                })
+                .collect::<Vec<_>>();
 
-                spawn(async move {
-                    let res = join_all(fut).await;
-                    let res: Result<Vec<_>, _> = res.into_iter().collect();
-                    match res {
-                        Ok(services) => {
-                            for item in services {
-                                for (factory, token, service) in item {
-                                    assert_eq!(token.0, wrk.services.len());
-                                    wrk.services.push(WorkerService {
-                                        factory,
-                                        service,
-                                        status: WorkerServiceStatus::Unavailable,
-                                    });
-                                }
+            spawn(async move {
+                let res: Result<Vec<_>, _> = join_all(fut).await.into_iter().collect();
+                match res {
+                    Ok(services) => {
+                        for item in services {
+                            for (factory, token, service) in item {
+                                assert_eq!(token.0, wrk.services.len());
+                                wrk.services.push(WorkerService {
+                                    factory,
+                                    service,
+                                    status: WorkerServiceStatus::Unavailable,
+                                });
                             }
                         }
-                        Err(e) => {
-                            error!("Can not start worker: {:?}", e);
-                            Arbiter::current().stop();
-                        }
                     }
-                    wrk.await
-                });
-            }
-                .boxed(),
-        );
+                    Err(e) => {
+                        error!("Can not start worker: {:?}", e);
+                        Arbiter::current().stop();
+                    }
+                }
+                wrk.await
+            });
+        }));
 
-        WorkerClient::new(idx, tx1, tx2, avail)
+        WorkerHandle::new(idx, tx1, tx2, avail)
     }
 
     fn shutdown(&mut self, force: bool) {
@@ -228,23 +231,12 @@ impl Worker {
             self.services.iter_mut().for_each(|srv| {
                 if srv.status == WorkerServiceStatus::Available {
                     srv.status = WorkerServiceStatus::Stopped;
-                    actix_rt::spawn(
-                        srv.service
-                            .call((None, ServerMessage::ForceShutdown))
-                            .map(|_| ()),
-                    );
                 }
             });
         } else {
-            let timeout = self.shutdown_timeout;
             self.services.iter_mut().for_each(move |srv| {
                 if srv.status == WorkerServiceStatus::Available {
                     srv.status = WorkerServiceStatus::Stopping;
-                    actix_rt::spawn(
-                        srv.service
-                            .call((None, ServerMessage::Shutdown(timeout)))
-                            .map(|_| ()),
-                    );
                 }
             });
         }
@@ -253,7 +245,7 @@ impl Worker {
     fn check_readiness(&mut self, cx: &mut Context<'_>) -> Result<bool, (Token, usize)> {
         let mut ready = self.conns.available(cx);
         let mut failed = None;
-        for (idx, srv) in &mut self.services.iter_mut().enumerate() {
+        for (idx, srv) in self.services.iter_mut().enumerate() {
             if srv.status == WorkerServiceStatus::Available
                 || srv.status == WorkerServiceStatus::Unavailable
             {
@@ -299,15 +291,15 @@ impl Worker {
 
 enum WorkerState {
     Available,
-    Unavailable(Vec<Conn>),
+    Unavailable,
     Restarting(
         usize,
         Token,
-        Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
+        LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>>,
     ),
     Shutdown(
-        Pin<Box<Delay>>,
-        Pin<Box<Delay>>,
+        Pin<Box<Sleep>>,
+        Pin<Box<Sleep>>,
         Option<oneshot::Sender<bool>>,
     ),
 }
@@ -318,7 +310,7 @@ impl Future for Worker {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // `StopWorker` message handler
         if let Poll::Ready(Some(StopCommand { graceful, result })) =
-            Pin::new(&mut self.rx2).poll_next(cx)
+            Pin::new(&mut self.rx2).poll_recv(cx)
         {
             self.availability.set(false);
             let num = num_connections();
@@ -332,8 +324,8 @@ impl Future for Worker {
                 if num != 0 {
                     info!("Graceful worker shutdown, {} connections", num);
                     self.state = WorkerState::Shutdown(
-                        Box::pin(delay_until(Instant::now() + time::Duration::from_secs(1))),
-                        Box::pin(delay_until(Instant::now() + self.shutdown_timeout)),
+                        Box::pin(sleep_until(Instant::now() + Duration::from_secs(1))),
+                        Box::pin(sleep_until(Instant::now() + self.shutdown_timeout)),
                         Some(result),
                     );
                 } else {
@@ -349,56 +341,35 @@ impl Future for Worker {
         }
 
         match self.state {
-            WorkerState::Unavailable(ref mut conns) => {
-                let conn = conns.pop();
-                match self.check_readiness(cx) {
-                    Ok(true) => {
-                        // process requests from wait queue
-                        if let Some(conn) = conn {
-                            let guard = self.conns.get();
-                            let _ = self.services[conn.token.0]
-                                .service
-                                .call((Some(guard), ServerMessage::Connect(conn.io)));
-                        } else {
-                            self.state = WorkerState::Available;
-                            self.availability.set(true);
-                        }
-                        self.poll(cx)
-                    }
-                    Ok(false) => {
-                        // push connection back to queue
-                        if let Some(conn) = conn {
-                            match self.state {
-                                WorkerState::Unavailable(ref mut conns) => {
-                                    conns.push(conn);
-                                }
-                                _ => (),
-                            }
-                        }
-                        Poll::Pending
-                    }
-                    Err((token, idx)) => {
-                        trace!(
-                            "Service {:?} failed, restarting",
-                            self.factories[idx].name(token)
-                        );
-                        self.services[token.0].status = WorkerServiceStatus::Restarting;
-                        self.state =
-                            WorkerState::Restarting(idx, token, self.factories[idx].create());
-                        self.poll(cx)
-                    }
+            WorkerState::Unavailable => match self.check_readiness(cx) {
+                Ok(true) => {
+                    self.state = WorkerState::Available;
+                    self.availability.set(true);
+                    self.poll(cx)
                 }
-            }
+                Ok(false) => Poll::Pending,
+                Err((token, idx)) => {
+                    trace!(
+                        "Service {:?} failed, restarting",
+                        self.factories[idx].name(token)
+                    );
+                    self.services[token.0].status = WorkerServiceStatus::Restarting;
+                    self.state =
+                        WorkerState::Restarting(idx, token, self.factories[idx].create());
+                    self.poll(cx)
+                }
+            },
             WorkerState::Restarting(idx, token, ref mut fut) => {
-                match Pin::new(fut).poll(cx) {
+                match fut.as_mut().poll(cx) {
                     Poll::Ready(Ok(item)) => {
-                        for (token, service) in item {
+                        // only interest in the first item?
+                        if let Some((token, service)) = item.into_iter().next() {
                             trace!(
                                 "Service {:?} has been restarted",
                                 self.factories[idx].name(token)
                             );
                             self.services[token.0].created(service);
-                            self.state = WorkerState::Unavailable(Vec::new());
+                            self.state = WorkerState::Unavailable;
                             return self.poll(cx);
                         }
                     }
@@ -408,9 +379,7 @@ impl Future for Worker {
                             self.factories[idx].name(token)
                         );
                     }
-                    Poll::Pending => {
-                        return Poll::Pending;
-                    }
+                    Poll::Pending => return Poll::Pending,
                 }
                 self.poll(cx)
             }
@@ -423,71 +392,56 @@ impl Future for Worker {
                 }
 
                 // check graceful timeout
-                match t2.as_mut().poll(cx) {
-                    Poll::Pending => (),
-                    Poll::Ready(_) => {
-                        let _ = tx.take().unwrap().send(false);
-                        self.shutdown(true);
-                        Arbiter::current().stop();
-                        return Poll::Ready(());
-                    }
+                if Pin::new(t2).poll(cx).is_ready() {
+                    let _ = tx.take().unwrap().send(false);
+                    self.shutdown(true);
+                    Arbiter::current().stop();
+                    return Poll::Ready(());
                 }
 
                 // sleep for 1 second and then check again
-                match t1.as_mut().poll(cx) {
-                    Poll::Pending => (),
-                    Poll::Ready(_) => {
-                        *t1 = Box::pin(delay_until(
-                            Instant::now() + time::Duration::from_secs(1),
-                        ));
-                        let _ = t1.as_mut().poll(cx);
-                    }
+                if t1.as_mut().poll(cx).is_ready() {
+                    *t1 = Box::pin(sleep_until(Instant::now() + Duration::from_secs(1)));
+                    let _ = t1.as_mut().poll(cx);
                 }
+
                 Poll::Pending
             }
-            WorkerState::Available => {
-                loop {
-                    match Pin::new(&mut self.rx).poll_next(cx) {
-                        // handle incoming io stream
-                        Poll::Ready(Some(WorkerCommand(msg))) => {
-                            match self.check_readiness(cx) {
-                                Ok(true) => {
-                                    let guard = self.conns.get();
-                                    let _ = self.services[msg.token.0]
-                                        .service
-                                        .call((Some(guard), ServerMessage::Connect(msg.io)));
-                                    continue;
-                                }
-                                Ok(false) => {
-                                    trace!("Worker is unavailable");
-                                    self.availability.set(false);
-                                    self.state = WorkerState::Unavailable(vec![msg]);
-                                }
-                                Err((token, idx)) => {
-                                    trace!(
-                                        "Service {:?} failed, restarting",
-                                        self.factories[idx].name(token)
-                                    );
-                                    self.availability.set(false);
-                                    self.services[token.0].status =
-                                        WorkerServiceStatus::Restarting;
-                                    self.state = WorkerState::Restarting(
-                                        idx,
-                                        token,
-                                        self.factories[idx].create(),
-                                    );
-                                }
-                            }
-                            return self.poll(cx);
-                        }
-                        Poll::Pending => {
-                            self.state = WorkerState::Available;
-                            return Poll::Pending;
-                        }
-                        Poll::Ready(None) => return Poll::Ready(()),
+            // actively poll stream and handle worker command
+            WorkerState::Available => loop {
+                match self.check_readiness(cx) {
+                    Ok(true) => (),
+                    Ok(false) => {
+                        trace!("Worker is unavailable");
+                        self.availability.set(false);
+                        self.state = WorkerState::Unavailable;
+                        return self.poll(cx);
+                    }
+                    Err((token, idx)) => {
+                        trace!(
+                            "Service {:?} failed, restarting",
+                            self.factories[idx].name(token)
+                        );
+                        self.availability.set(false);
+                        self.services[token.0].status = WorkerServiceStatus::Restarting;
+                        self.state =
+                            WorkerState::Restarting(idx, token, self.factories[idx].create());
+                        return self.poll(cx);
                     }
                 }
-            }
+
+                match Pin::new(&mut self.rx).poll_recv(cx) {
+                    // handle incoming io stream
+                    Poll::Ready(Some(WorkerCommand(msg))) => {
+                        let guard = self.conns.get();
+                        let _ = self.services[msg.token.0]
+                            .service
+                            .call((Some(guard), msg.io));
+                    }
+                    Poll::Pending => return Poll::Pending,
+                    Poll::Ready(None) => return Poll::Ready(()),
+                };
+            },
         }
     }
 }

actix-server/tests/test_server.rs

@@ -1,23 +1,17 @@
-use std::io::Read;
 use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use std::sync::{mpsc, Arc};
 use std::{net, thread, time};
 
-use actix_codec::{BytesCodec, Framed};
-use actix_rt::net::TcpStream;
 use actix_server::Server;
 use actix_service::fn_service;
-use bytes::Bytes;
-use futures::future::{lazy, ok};
-use futures::SinkExt;
-use net2::TcpBuilder;
+use futures_util::future::{lazy, ok};
 
 fn unused_addr() -> net::SocketAddr {
     let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let socket = TcpBuilder::new_v4().unwrap();
-    socket.bind(&addr).unwrap();
-    socket.reuse_address(true).unwrap();
-    let tcp = socket.to_tcp_listener().unwrap();
+    let socket = mio::net::TcpSocket::new_v4().unwrap();
+    socket.bind(addr).unwrap();
+    socket.set_reuseaddr(true).unwrap();
+    let tcp = socket.listen(32).unwrap();
     tcp.local_addr().unwrap()
 }
 
@@ -28,12 +22,14 @@ fn test_bind() {
 
     let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
-        let srv = Server::build()
-            .workers(1)
-            .disable_signals()
-            .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
-            .unwrap()
-            .start();
+        let srv = sys.block_on(lazy(|_| {
+            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();
     });
@@ -41,7 +37,7 @@ fn test_bind() {
 
     thread::sleep(time::Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
-    let _ = sys.stop();
+    sys.stop();
     let _ = h.join();
 }
 
@@ -53,49 +49,58 @@ fn test_listen() {
     let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
         let lst = net::TcpListener::bind(addr).unwrap();
-        Server::build()
-            .disable_signals()
-            .workers(1)
-            .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
-            .unwrap()
-            .start();
-        let _ = tx.send(actix_rt::System::current());
+        sys.block_on(async {
+            Server::build()
+                .disable_signals()
+                .workers(1)
+                .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
+                .unwrap()
+                .start();
+            let _ = tx.send(actix_rt::System::current());
+        });
         let _ = sys.run();
     });
     let sys = rx.recv().unwrap();
 
     thread::sleep(time::Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
-    let _ = sys.stop();
+    sys.stop();
     let _ = h.join();
 }
 
 #[test]
 #[cfg(unix)]
 fn test_start() {
+    use actix_codec::{BytesCodec, Framed};
+    use actix_rt::net::TcpStream;
+    use bytes::Bytes;
+    use futures_util::sink::SinkExt;
+    use std::io::Read;
+
     let addr = unused_addr();
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
-        let srv: Server = Server::build()
-            .backlog(100)
-            .disable_signals()
-            .bind("test", addr, move || {
-                fn_service(|io: TcpStream| {
-                    async move {
+        let srv = sys.block_on(lazy(|_| {
+            Server::build()
+                .backlog(100)
+                .disable_signals()
+                .bind("test", addr, move || {
+                    fn_service(|io: TcpStream| async move {
                         let mut f = Framed::new(io, BytesCodec);
                         f.send(Bytes::from_static(b"test")).await.unwrap();
                         Ok::<_, ()>(())
-                    }
+                    })
                 })
-            })
-            .unwrap()
-            .start();
+                .unwrap()
+                .start()
+        }));
 
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
+
     let (srv, sys) = rx.recv().unwrap();
 
     let mut buf = [1u8; 4];
@@ -130,7 +135,7 @@ fn test_start() {
     assert!(net::TcpStream::connect(addr).is_err());
 
     thread::sleep(time::Duration::from_millis(100));
-    let _ = sys.stop();
+    sys.stop();
     let _ = h.join();
 }
 
@@ -146,28 +151,30 @@ fn test_configure() {
     let h = thread::spawn(move || {
         let num = num2.clone();
         let sys = actix_rt::System::new("test");
-        let srv = Server::build()
-            .disable_signals()
-            .configure(move |cfg| {
-                let num = num.clone();
-                let lst = net::TcpListener::bind(addr3).unwrap();
-                cfg.bind("addr1", addr1)
-                    .unwrap()
-                    .bind("addr2", addr2)
-                    .unwrap()
-                    .listen("addr3", lst)
-                    .apply(move |rt| {
-                        let num = num.clone();
-                        rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
-                        rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
-                        rt.on_start(lazy(move |_| {
-                            let _ = num.fetch_add(1, Relaxed);
-                        }))
-                    })
-            })
-            .unwrap()
-            .workers(1)
-            .start();
+        let 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()
+                .workers(1)
+                .start()
+        }));
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
@@ -178,6 +185,6 @@ fn test_configure() {
     assert!(net::TcpStream::connect(addr2).is_ok());
     assert!(net::TcpStream::connect(addr3).is_ok());
     assert_eq!(num.load(Relaxed), 1);
-    let _ = sys.stop();
+    sys.stop();
     let _ = h.join();
 }

actix-service/CHANGES.md

@@ -1,5 +1,64 @@
 # Changes
 
+## Unreleased - 2020-xx-xx
+
+
+## 2.0.0-beta.1 - 2020-12-28
+* `Service`, other traits, and many type signatures now take the the request type as a type
+  parameter instead of an associated type. [#232]
+* Add `always_ready!` and `forward_ready!` macros. [#233]
+* Crate is now `no_std`. [#233]
+* Migrate pin projections to `pin-project-lite`. [#233]
+* Remove `AndThenApplyFn` and Pipeline `and_then_apply_fn`. Use the
+  `.and_then(apply_fn(...))` construction. [#233]
+* Move non-vital methods to `ServiceExt` and `ServiceFactoryExt` extension traits. [#235]
+
+[#232]: https://github.com/actix/actix-net/pull/232
+[#233]: https://github.com/actix/actix-net/pull/233
+[#235]: https://github.com/actix/actix-net/pull/235
+
+
+## 1.0.6 - 2020-08-09
+
+### Fixed
+
+* Removed unsound custom Cell implementation that allowed obtaining several mutable references to
+  the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through
+  service combinators. Attempts to acquire several mutable references to the same data will instead
+  result in a panic.
+
+## [1.0.5] - 2020-01-16
+
+### Fixed
+
+* Fixed unsoundness in .and_then()/.then() service combinators
+
+## [1.0.4] - 2020-01-15
+
+### Fixed
+
+* Revert 1.0.3 change
+
+## [1.0.3] - 2020-01-15
+
+### Fixed
+
+* Fixed unsoundness in `AndThenService` impl
+
+## [1.0.2] - 2020-01-08
+
+### Added
+
+* Add `into_service` helper function
+
+
+## [1.0.1] - 2019-12-22
+
+### Changed
+
+* `map_config()` and `unit_config()` accepts `IntoServiceFactory` type
+
+
 ## [1.0.0] - 2019-12-11
 
 ### Added

actix-service/Cargo.toml

@@ -1,29 +1,28 @@
 [package]
 name = "actix-service"
-version = "1.0.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix service"
-keywords = ["network", "framework", "async", "futures"]
+version = "2.0.0-beta.1"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.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/"
+documentation = "https://docs.rs/actix-service"
+readme = "README.md"
 categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
-
-[badges]
-travis-ci = { repository = "actix/actix-service", branch = "master" }
-appveyor = { repository = "actix/actix-net" }
-codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
 
 [lib]
 name = "actix_service"
 path = "src/lib.rs"
 
 [dependencies]
-futures-util = "0.3.1"
-pin-project = "0.4.6"
+futures-core = { version = "0.3.7", default-features = false }
+pin-project-lite = "0.2"
 
 [dev-dependencies]
-actix-rt = "1.0.0-alpha.3"
+actix-rt = "1.0.0"
+futures-util = { version = "0.3.7", default-features = false }

actix-service/README.md

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

actix-service/src/and_then.rs

@@ -1,46 +1,50 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use alloc::rc::Rc;
+use core::{
+    cell::RefCell,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
-use crate::cell::Cell;
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
-/// This is created by the `ServiceExt::and_then` method.
-pub struct AndThenService<A, B>(Cell<(A, B)>);
+/// This is created by the `Pipeline::and_then` method.
+pub(crate) struct AndThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> AndThenService<A, B> {
+impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self
     where
-        A: Service,
-        B: Service<Request = A::Response, Error = A::Error>,
+        A: Service<Req>,
+        B: Service<A::Response, Error = A::Error>,
     {
-        Self(Cell::new((a, b)))
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for AndThenService<A, B> {
+impl<A, B, Req> Clone for AndThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        AndThenService(self.0.clone())
+        AndThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for AndThenService<A, B>
+impl<A, B, Req> Service<Req> for AndThenService<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenServiceResponse<A, B>;
+    type Future = AndThenServiceResponse<A, B, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let srv = self.0.get_mut();
-
+        let mut srv = self.0.borrow_mut();
         let not_ready = !srv.0.poll_ready(cx)?.is_ready();
         if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
@@ -49,165 +53,182 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         AndThenServiceResponse {
-            state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())),
+            state: State::A {
+                fut: self.0.borrow_mut().0.call(req),
+                b: Some(self.0.clone()),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
-pub struct AndThenServiceResponse<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    #[pin]
-    state: State<A, B>,
+pin_project! {
+    pub(crate) struct AndThenServiceResponse<A, B, Req>
+    where
+        A: Service<Req>,
+        B: Service<A::Response, Error = A::Error>,
+    {
+        #[pin]
+        state: State<A, B, Req>,
+    }
 }
 
-#[pin_project::pin_project]
-enum State<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    A(#[pin] A::Future, Option<Cell<(A, B)>>),
-    B(#[pin] B::Future),
-    Empty,
+pin_project! {
+    #[project = StateProj]
+    enum State<A, B, Req>
+    where
+        A: Service<Req>,
+        B: Service<A::Response, Error = A::Error>,
+    {
+        A {
+            #[pin]
+            fut: A::Future,
+            b: Option<Rc<RefCell<(A, B)>>>,
+        },
+        B {
+            #[pin]
+            fut: B::Future,
+        },
+        Empty,
+    }
 }
 
-impl<A, B> Future for AndThenServiceResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
 {
     type Output = Result<B::Response, A::Error>;
 
-    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        #[project]
         match this.state.as_mut().project() {
-            State::A(fut, b) => match fut.poll(cx)? {
+            StateProj::A { fut, b } => match fut.poll(cx)? {
                 Poll::Ready(res) => {
-                    let mut b = b.take().unwrap();
+                    let b = b.take().unwrap();
                     this.state.set(State::Empty); // drop fut A
-                    let fut = b.get_mut().1.call(res);
-                    this.state.set(State::B(fut));
+                    let fut = b.borrow_mut().1.call(res);
+                    this.state.set(State::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            State::B(fut) => fut.poll(cx).map(|r| {
+            StateProj::B { fut } => fut.poll(cx).map(|r| {
                 this.state.set(State::Empty);
                 r
             }),
-            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }
 
 /// `.and_then()` service factory combinator
-pub struct AndThenServiceFactory<A, B>
+pub(crate) struct AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    a: A,
-    b: B,
+    inner: Rc<(A, B)>,
+    _phantom: PhantomData<Req>,
 }
 
-impl<A, B> AndThenServiceFactory<A, B>
+impl<A, B, Req> AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
     /// Create new `AndThenFactory` combinator
     pub(crate) fn new(a: A, b: B) -> Self {
-        Self { a, b }
-    }
-}
-
-impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
-where
-    A: ServiceFactory,
-    A::Config: Clone,
-    B: ServiceFactory<
-        Config = A::Config,
-        Request = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
-{
-    type Request = A::Request;
-    type Response = B::Response;
-    type Error = A::Error;
-
-    type Config = A::Config;
-    type Service = AndThenService<A::Service, B::Service>;
-    type InitError = A::InitError;
-    type Future = AndThenServiceFactoryResponse<A, B>;
-
-    fn new_service(&self, cfg: A::Config) -> Self::Future {
-        AndThenServiceFactoryResponse::new(
-            self.a.new_service(cfg.clone()),
-            self.b.new_service(cfg),
-        )
-    }
-}
-
-impl<A, B> Clone for AndThenServiceFactory<A, B>
-where
-    A: ServiceFactory + Clone,
-    A::Config: Clone,
-    B: ServiceFactory<
-            Config = A::Config,
-            Request = A::Response,
-            Error = A::Error,
-            InitError = A::InitError,
-        > + Clone,
-{
-    fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
+            inner: Rc::new((a, b)),
+            _phantom: PhantomData,
         }
     }
 }
 
-#[pin_project::pin_project]
-pub struct AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> ServiceFactory<Req> for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response>,
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<
+        A::Response,
+        Config = A::Config,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
-    #[pin]
-    fut_a: A::Future,
-    #[pin]
-    fut_b: B::Future,
+    type Response = B::Response;
+    type Error = A::Error;
 
-    a: Option<A::Service>,
-    b: Option<B::Service>,
+    type Config = A::Config;
+    type Service = AndThenService<A::Service, B::Service, Req>;
+    type InitError = A::InitError;
+    type Future = AndThenServiceFactoryResponse<A, B, Req>;
+
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let inner = &*self.inner;
+        AndThenServiceFactoryResponse::new(
+            inner.0.new_service(cfg.clone()),
+            inner.1.new_service(cfg),
+        )
+    }
 }
 
-impl<A, B> AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Clone for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response>,
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<
+        A::Response,
+        Config = A::Config,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+pin_project! {
+    pub(crate) struct AndThenServiceFactoryResponse<A, B, Req>
+    where
+        A: ServiceFactory<Req>,
+        B: ServiceFactory<A::Response>,
+    {
+        #[pin]
+        fut_a: A::Future,
+        #[pin]
+        fut_b: B::Future,
+
+        a: Option<A::Service>,
+        b: Option<B::Service>,
+    }
+}
+
+impl<A, B, Req> AndThenServiceFactoryResponse<A, B, Req>
+where
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenServiceFactoryResponse {
@@ -219,12 +240,12 @@ where
     }
 }
 
-impl<A, B> Future for AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
-    B: ServiceFactory<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Output = Result<AndThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<AndThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -252,18 +273,21 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::cell::Cell;
-    use std::rc::Rc;
-    use std::task::{Context, Poll};
+    use alloc::rc::Rc;
+    use core::{
+        cell::Cell,
+        task::{Context, Poll},
+    };
 
-    use futures_util::future::{lazy, ok, ready, Ready};
+    use futures_util::future::lazy;
 
-    use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{
+        fn_factory, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory,
+    };
 
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
-        type Request = &'static str;
+    impl Service<&'static str> for Srv1 {
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
@@ -281,8 +305,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
-        type Request = &'static str;
+    impl Service<&'static str> for Srv2 {
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
@@ -312,7 +335,7 @@ mod tests {
         let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
         let res = srv.call("srv1").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv1", "srv2")));
+        assert_eq!(res.unwrap(), ("srv1", "srv2"));
     }
 
     #[actix_rt::test]

actix-service/src/and_then_apply_fn.rs

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

actix-service/src/apply.rs

@@ -1,227 +1,230 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// Apply tranform function to a service.
-pub fn apply_fn<T, F, R, In, Out, Err, U>(service: U, f: F) -> Apply<T, F, R, In, Out, Err>
+/// Apply transform function to a service.
+///
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub fn apply_fn<I, S, F, Fut, Req, In, Res, Err>(
+    service: I,
+    wrap_fn: F,
+) -> Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
-    F: FnMut(In, &mut T) -> R,
-    R: Future<Output = Result<Out, Err>>,
-    U: IntoService<T>,
+    I: IntoService<S, In>,
+    S: Service<In, Error = Err>,
+    F: FnMut(Req, &mut S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    Apply::new(service.into_service(), f)
+    Apply::new(service.into_service(), wrap_fn)
 }
 
-/// Service factory that prodices `apply_fn` service.
-pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
-    service: U,
+/// Service factory that produces `apply_fn` service.
+///
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub fn apply_fn_factory<I, SF, F, Fut, Req, In, Res, Err>(
+    service: I,
     f: F,
-) -> ApplyServiceFactory<T, F, R, In, Out, Err>
+) -> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
-    U: IntoServiceFactory<T>,
+    I: IntoServiceFactory<SF, In>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    ApplyServiceFactory::new(service.into_factory(), f)
+    ApplyFactory::new(service.into_factory(), f)
 }
 
-/// `Apply` service combinator
-pub struct Apply<T, F, R, In, Out, Err>
+/// `Apply` service combinator.
+///
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub struct Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
+    S: Service<In, Error = Err>,
 {
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out, R)>,
+    service: S,
+    wrap_fn: F,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
 }
 
-impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
-    F: FnMut(In, &mut T) -> R,
-    R: Future<Output = Result<Out, Err>>,
+    S: Service<In, Error = Err>,
+    F: FnMut(Req, &mut S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `Apply` combinator
-    fn new(service: T, f: F) -> Self {
+    fn new(service: S, wrap_fn: F) -> Self {
         Self {
             service,
-            f,
-            r: PhantomData,
+            wrap_fn,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Clone for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err> + Clone,
-    F: FnMut(In, &mut T) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    S: Service<In, Error = Err> + Clone,
+    F: FnMut(Req, &mut S) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
         Apply {
             service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
+            wrap_fn: self.wrap_fn.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
-    F: FnMut(In, &mut T) -> R,
-    R: Future<Output = Result<Out, Err>>,
+    S: Service<In, Error = Err>,
+    F: FnMut(Req, &mut S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = In;
-    type Response = Out;
+    type Response = Res;
     type Error = Err;
-    type Future = R;
+    type Future = Fut;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(futures_util::ready!(self.service.poll_ready(cx)))
-    }
+    crate::forward_ready!(service);
 
-    fn call(&mut self, req: In) -> Self::Future {
-        (self.f)(req, &mut self.service)
+    fn call(&mut self, req: Req) -> Self::Future {
+        (self.wrap_fn)(req, &mut self.service)
     }
 }
 
-/// `apply()` service factory
-pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
-where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
-{
-    service: T,
-    f: F,
-    r: PhantomData<(R, In, Out)>,
+/// `ApplyFactory` service factory combinator.
+pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
+    factory: SF,
+    wrap_fn: F,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    /// Create new `ApplyNewService` new service instance
-    fn new(service: T, f: F) -> Self {
+    /// Create new `ApplyFactory` new service instance
+    fn new(factory: SF, wrap_fn: F) -> Self {
         Self {
-            f,
-            service,
-            r: PhantomData,
+            factory,
+            wrap_fn,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> Clone for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err> + Clone,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    SF: ServiceFactory<In, Error = Err> + Clone,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
         Self {
-            service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
+            factory: self.factory.clone(),
+            wrap_fn: self.wrap_fn.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req>
+    for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = In;
-    type Response = Out;
+    type Response = Res;
     type Error = Err;
 
-    type Config = T::Config;
-    type Service = Apply<T::Service, F, R, In, Out, Err>;
-    type InitError = T::InitError;
-    type Future = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
+    type Config = SF::Config;
+    type Service = Apply<SF::Service, F, Req, In, Res, Err>;
+    type InitError = SF::InitError;
+    type Future = ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>;
 
-    fn new_service(&self, cfg: T::Config) -> Self::Future {
-        ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
+    fn new_service(&self, cfg: SF::Config) -> Self::Future {
+        let svc = self.factory.new_service(cfg);
+        ApplyServiceFactoryResponse::new(svc, self.wrap_fn.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
-where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
-    R: Future<Output = Result<Out, Err>>,
-{
-    #[pin]
-    fut: T::Future,
-    f: Option<F>,
-    r: PhantomData<(In, Out)>,
+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,
+        Fut: Future<Output = Result<Res, Err>>,
+    {
+        #[pin]
+        fut: SF::Future,
+        wrap_fn: Option<F>,
+        _phantom: PhantomData<(Req, Res)>,
+    }
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
-    R: Future<Output = Result<Out, Err>>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: FnMut(Req, &mut SF::Service) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    fn new(fut: T::Future, f: F) -> Self {
+    fn new(fut: SF::Future, wrap_fn: F) -> Self {
         Self {
-            f: Some(f),
             fut,
-            r: PhantomData,
+            wrap_fn: Some(wrap_fn),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> Future
+    for ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
-    R: Future<Output = Result<Out, Err>>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: FnMut(Req, &mut SF::Service) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
+    type Output = Result<Apply<SF::Service, F, Req, In, Res, Err>, 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(Apply::new(svc, this.f.take().unwrap())))
-        } else {
-            Poll::Pending
-        }
+        let svc = ready!(this.fut.poll(cx))?;
+        Poll::Ready(Ok(Apply::new(svc, this.wrap_fn.take().unwrap())))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::task::{Context, Poll};
+    use core::task::Poll;
 
-    use futures_util::future::{lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{ok, pipeline, pipeline_factory, Ready, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
+        crate::always_ready!();
 
         fn call(&mut self, _: ()) -> Self::Future {
             ok(())
@@ -233,8 +236,8 @@ mod tests {
         let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
             let fut = srv.call(());
             async move {
-                let res = fut.await.unwrap();
-                Ok((req, res))
+                fut.await.unwrap();
+                Ok((req, ()))
             }
         }));
 
@@ -242,7 +245,7 @@ mod tests {
 
         let res = srv.call("srv").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv", ())));
+        assert_eq!(res.unwrap(), ("srv", ()));
     }
 
     #[actix_rt::test]
@@ -252,8 +255,8 @@ mod tests {
             |req: &'static str, srv| {
                 let fut = srv.call(());
                 async move {
-                    let res = fut.await.unwrap();
-                    Ok((req, res))
+                    fut.await.unwrap();
+                    Ok((req, ()))
                 }
             },
         ));
@@ -264,6 +267,6 @@ mod tests {
 
         let res = srv.call("srv").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv", ())));
+        assert_eq!(res.unwrap(), ("srv", ()));
     }
 }

actix-service/src/apply_cfg.rs

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

actix-service/src/boxed.rs

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

actix-service/src/cell.rs

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

actix-service/src/ext.rs

@@ -0,0 +1,70 @@
+use crate::{dev, Service, ServiceFactory};
+
+pub trait ServiceExt<Req>: Service<Req> {
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    ///
+    /// This function is similar to the `Option::map` or `Iterator::map` where
+    /// it will change the type of the underlying service.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it, similar to the existing `map` methods in the
+    /// standard library.
+    fn map<F, R>(self, f: F) -> dev::Map<Self, F, Req, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R,
+    {
+        dev::Map::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying service. For example, this can be useful to
+    /// ensure that services have the same error type.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn map_err<F, E>(self, f: F) -> dev::MapErr<Self, Req, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        dev::MapErr::new(self, f)
+    }
+}
+
+impl<S, Req> ServiceExt<Req> for S where S: Service<Req> {}
+
+pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R + Clone,
+    {
+        crate::map::MapServiceFactory::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Req, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E + Clone,
+    {
+        crate::map_err::MapErrServiceFactory::new(self, f)
+    }
+
+    /// Map this factory's init error to a different error, returning a new service.
+    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, Req, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E + Clone,
+    {
+        crate::map_init_err::MapInitErr::new(self, f)
+    }
+}
+
+impl<S, Req> ServiceFactoryExt<Req> for S where S: ServiceFactory<Req> {}

actix-service/src/fn_service.rs

@@ -1,10 +1,6 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::task::{Context, Poll};
+use core::{future::Future, marker::PhantomData, task::Poll};
 
-use futures_util::future::{ok, Ready};
-
-use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory};
 
 /// Create `ServiceFactory` for function that can act as a `Service`
 pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
@@ -29,7 +25,7 @@ where
 /// /// Service that divides two usize values.
 /// async fn div((x, y): (usize, usize)) -> Result<usize, io::Error> {
 ///     if y == 0 {
-///         Err(io::Error::new(io::ErrorKind::Other, "divide by zdro"))
+///         Err(io::Error::new(io::ErrorKind::Other, "divide by zero"))
 ///     } else {
 ///         Ok(x / y)
 ///     }
@@ -53,9 +49,11 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
+pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(
+    f: F,
+) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    Srv: Service,
+    Srv: Service<Req>,
     F: Fn() -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
 {
@@ -92,13 +90,13 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Err>(
+pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Req, Err>(
     f: F,
-) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+) -> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     FnServiceConfig::new(f)
 }
@@ -132,26 +130,23 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    crate::always_ready!();
 
     fn call(&mut self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
-impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F
+impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>, Req> for F
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
@@ -190,31 +185,28 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+    crate::always_ready!();
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
-impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req>
+    for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
 
@@ -229,7 +221,7 @@ where
 }
 
 impl<F, Fut, Req, Res, Err, Cfg>
-    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>> for F
+    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>, Req> for F
 where
     F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
@@ -240,32 +232,32 @@ where
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-pub struct FnServiceConfig<F, Fut, Cfg, Srv, Err>
+pub struct FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     f: F,
-    _t: PhantomData<(Fut, Cfg, Srv, Err)>,
+    _t: PhantomData<(Fut, Cfg, Req, Srv, Err)>,
 }
 
-impl<F, Fut, Cfg, Srv, Err> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         FnServiceConfig { f, _t: PhantomData }
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut + Clone,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         FnServiceConfig {
@@ -275,13 +267,13 @@ where
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> ServiceFactory for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req>
+    for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
-    type Request = Srv::Request;
     type Response = Srv::Response;
     type Error = Srv::Error;
 
@@ -296,76 +288,77 @@ where
 }
 
 /// Converter for `Fn() -> Future<Service>` fn
-pub struct FnServiceNoConfig<F, C, S, R, E>
+pub struct FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    S: Service,
-    R: Future<Output = Result<S, E>>,
+    F: Fn() -> Fut,
+    Srv: Service<Req>,
+    Fut: Future<Output = Result<Srv, Err>>,
 {
     f: F,
-    _t: PhantomData<C>,
+    _t: PhantomData<(Cfg, Req)>,
 }
 
-impl<F, C, S, R, E> FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         Self { f, _t: PhantomData }
     }
 }
 
-impl<F, C, S, R, E> ServiceFactory for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> ServiceFactory<Req>
+    for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Service = S;
-    type Config = C;
-    type InitError = E;
-    type Future = R;
+    type Response = Srv::Response;
+    type Error = Srv::Error;
+    type Service = Srv;
+    type Config = Cfg;
+    type InitError = Err;
+    type Future = Fut;
 
-    fn new_service(&self, _: C) -> Self::Future {
+    fn new_service(&self, _: Cfg) -> Self::Future {
         (self.f)()
     }
 }
 
-impl<F, C, S, R, E> Clone for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> Clone for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R + Clone,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut + Clone,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
 
-impl<F, C, S, R, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, E>> for F
+impl<F, Cfg, Srv, Req, Fut, Err>
+    IntoServiceFactory<FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>, Req> for F
 where
-    F: Fn() -> R,
-    R: Future<Output = Result<S, E>>,
-    S: Service,
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
 {
-    fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> {
+    fn into_factory(self) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err> {
         FnServiceNoConfig::new(self)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::task::Poll;
+    use core::task::Poll;
 
-    use futures_util::future::{lazy, ok};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{Service, ServiceFactory};
+    use crate::{ok, Service, ServiceFactory};
 
     #[actix_rt::test]
     async fn test_fn_service() {

actix-service/src/lib.rs

@@ -1,50 +1,64 @@
-#![deny(rust_2018_idioms, warnings)]
-#![allow(clippy::type_complexity)]
+//! See [`Service`] docs for information on this crate's foundational trait.
 
-use std::cell::RefCell;
-use std::future::Future;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::task::{self, Context, Poll};
+#![no_std]
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+extern crate alloc;
+
+use alloc::{boxed::Box, rc::Rc, sync::Arc};
+use core::{
+    cell::RefCell,
+    future::Future,
+    task::{self, Context, Poll},
+};
 
 mod and_then;
-mod and_then_apply_fn;
 mod apply;
 mod apply_cfg;
 pub mod boxed;
-mod cell;
+mod ext;
 mod fn_service;
 mod map;
 mod map_config;
 mod map_err;
 mod map_init_err;
 mod pipeline;
+mod ready;
 mod then;
 mod transform;
 mod transform_err;
 
 pub use self::apply::{apply_fn, apply_fn_factory};
 pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
+pub use self::ext::{ServiceExt, ServiceFactoryExt};
 pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
 pub use self::map_config::{map_config, unit_config};
 pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 pub use self::transform::{apply, Transform};
 
-/// An asynchronous function from `Request` to a `Response`.
+#[allow(unused_imports)]
+use self::ready::{err, ok, ready, Ready};
+
+/// An asynchronous operation from `Request` to a `Response`.
 ///
-/// `Service` represents a service that represanting interation, taking requests and giving back
-/// replies. You can think about service as a function with one argument and result as a return
-/// type. In general form it looks like `async fn(Req) -> Result<Res, Err>`. `Service`
-/// trait just generalizing form of this function. Each parameter described as an assotiated type.
+/// The `Service` trait models a request/response interaction, receiving requests and returning
+/// replies. You can think about a service as a function with one argument that returns some result
+/// asynchronously. Conceptually, the operation looks like this:
 ///
-/// Services provides a symmetric and uniform API, same abstractions represents
-/// clients and servers. Services describe only `transforamtion` operation
-/// which encorouge to simplify api surface and phrases `value transformation`.
-/// That leads to simplier design of each service. That also allows better testability
-/// and better composition.
+/// ```rust,ignore
+/// async fn(Request) -> Result<Response, Err>
+/// ```
 ///
-/// Services could be represented in several different forms. In general,
-/// Service is a type that implements `Service` trait.
+/// The `Service` trait just generalizes this form where each parameter is described as an
+/// associated type on the trait. Services can also have mutable state that influence computation.
+///
+/// `Service` provides a symmetric and uniform API; the same abstractions can be used to represent
+/// both clients and servers. Services describe only _transformation_ operations which encourage
+/// simple API surfaces. This leads to simpler design of each service, improves test-ability and
+/// makes composition easier.
 ///
 /// ```rust,ignore
 /// struct MyService;
@@ -53,28 +67,25 @@ pub use self::transform::{apply, Transform};
 ///      type Request = u8;
 ///      type Response = u64;
 ///      type Error = MyError;
-///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>;
+///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>>;
 ///
 ///      fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
 ///
-///      fn call(&mut self) -> Self::Future { ... }
+///      fn call(&mut self, req: Self::Request) -> Self::Future { ... }
 /// }
 /// ```
 ///
-/// Service can have mutable state that influence computation.
-/// This service could be rewritten as a simple function:
+/// Sometimes it is not necessary to implement the Service trait. For example, the above service
+/// could be rewritten as a simple function and passed to [fn_service](fn_service()).
 ///
 /// ```rust,ignore
 /// async fn my_service(req: u8) -> Result<u64, MyError>;
 /// ```
-pub trait Service {
-    /// Requests handled by the service.
-    type Request;
-
+pub trait Service<Req> {
     /// Responses given by the service.
     type Response;
 
-    /// Errors produced by the service.
+    /// Errors produced by the service when polling readiness or executing call.
     type Error;
 
     /// The future response value.
@@ -82,7 +93,7 @@ pub trait Service {
 
     /// Returns `Ready` when the service is able to process requests.
     ///
-    /// If the service is at capacity, then `NotReady` is returned and the 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.
     ///
@@ -90,11 +101,9 @@ pub trait Service {
     /// It is permitted for the service to return `Ready` from a `poll_ready`
     /// call and the next invocation of `call` results in an error.
     ///
-    /// There are several notes to consider:
-    ///
+    /// # Notes
     /// 1. `.poll_ready()` might be called on different task from actual service call.
-    ///
-    /// 2. In case of chained services, `.poll_ready()` get called for all services at once.
+    /// 1. In case of chained services, `.poll_ready()` get called for all services at once.
     fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Process the request and return the response asynchronously.
@@ -106,114 +115,45 @@ pub trait Service {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Self::Request) -> Self::Future;
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    ///
-    /// This function is similar to the `Option::map` or `Iterator::map` where
-    /// it will change the type of the underlying service.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it, similar to the existing `map` methods in the
-    /// standard library.
-    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R,
-    {
-        crate::dev::Map::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    ///
-    /// This function is similar to the `Result::map_err` where it will change
-    /// the error type of the underlying service. This is useful for example to
-    /// ensure that services have the same error type.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E,
-    {
-        crate::dev::MapErr::new(self, f)
-    }
+    fn call(&mut self, req: Req) -> Self::Future;
 }
 
-/// Creates new `Service` values.
+/// Factory for creating `Service`s.
 ///
-/// Acts as a service factory. This is useful for cases where new `Service`
-/// values must be produced. One case is a TCP server listener. The listener
-/// accepts new TCP streams, obtains a new `Service` value using the
-/// `ServiceFactory` trait, and uses that new `Service` value to process inbound
+/// Acts as a service factory. This is useful for cases where new `Service`s
+/// must be produced. One case is a TCP server listener. The listener
+/// accepts new TCP streams, obtains a new `Service` using the
+/// `ServiceFactory` trait, and uses the new `Service` to process inbound
 /// requests on that new TCP stream.
 ///
 /// `Config` is a service factory configuration type.
-pub trait ServiceFactory {
-    /// Requests handled by the service.
-    type Request;
-
-    /// Responses given by the service
+pub trait ServiceFactory<Req> {
+    /// Responses given by the created services.
     type Response;
 
-    /// Errors produced by the service
+    /// Errors produced by the created services.
     type Error;
 
-    /// Service factory configuration
+    /// Service factory configuration.
     type Config;
 
-    /// The `Service` value created by this factory
-    type Service: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
+    /// The kind of `Service` created by this factory.
+    type Service: Service<Req, Response = Self::Response, Error = Self::Error>;
 
-    /// Errors produced while building a service.
+    /// Errors potentially raised while building a service.
     type InitError;
 
     /// The future of the `Service` instance.
     type Future: Future<Output = Result<Self::Service, Self::InitError>>;
 
-    /// Create and return a new service value asynchronously.
+    /// Create and return a new service asynchronously.
     fn new_service(&self, cfg: Self::Config) -> Self::Future;
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R + Clone,
-    {
-        crate::map::MapServiceFactory::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E + Clone,
-    {
-        crate::map_err::MapErrServiceFactory::new(self, f)
-    }
-
-    /// Map this factory's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::InitError) -> E + Clone,
-    {
-        crate::map_init_err::MapInitErr::new(self, f)
-    }
 }
 
-impl<'a, S> Service for &'a mut S
+impl<'a, S, Req> Service<Req> for &'a mut S
 where
-    S: Service + 'a,
+    S: Service<Req> + 'a,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -222,16 +162,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for Box<S>
+impl<S, Req> Service<Req> for Box<S>
 where
-    S: Service + ?Sized,
+    S: Service<Req> + ?Sized,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -240,16 +179,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for RefCell<S>
+impl<S, Req> Service<Req> for RefCell<S>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -258,16 +196,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         self.borrow_mut().call(request)
     }
 }
 
-impl<S> Service for Rc<RefCell<S>>
+impl<S, Req> Service<Req> for Rc<RefCell<S>>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -276,16 +213,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (&mut (**self).borrow_mut()).call(request)
     }
 }
 
-impl<S> ServiceFactory for Rc<S>
+impl<S, Req> ServiceFactory<Req> for Rc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -298,11 +234,10 @@ where
     }
 }
 
-impl<S> ServiceFactory for Arc<S>
+impl<S, Req> ServiceFactory<Req> for Arc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -316,46 +251,52 @@ where
 }
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
+pub trait IntoService<S, Req>
 where
-    T: Service,
+    S: Service<Req>,
 {
     /// Convert to a `Service`
-    fn into_service(self) -> T;
+    fn into_service(self) -> S;
 }
 
 /// Trait for types that can be converted to a `ServiceFactory`
-pub trait IntoServiceFactory<T>
+pub trait IntoServiceFactory<SF, Req>
 where
-    T: ServiceFactory,
+    SF: ServiceFactory<Req>,
 {
     /// Convert `Self` to a `ServiceFactory`
-    fn into_factory(self) -> T;
+    fn into_factory(self) -> SF;
 }
 
-impl<T> IntoService<T> for T
+impl<S, Req> IntoService<S, Req> for S
 where
-    T: Service,
+    S: Service<Req>,
 {
-    fn into_service(self) -> T {
+    fn into_service(self) -> S {
         self
     }
 }
 
-impl<T> IntoServiceFactory<T> for T
+impl<SF, Req> IntoServiceFactory<SF, Req> for SF
 where
-    T: ServiceFactory,
+    SF: ServiceFactory<Req>,
 {
-    fn into_factory(self) -> T {
+    fn into_factory(self) -> SF {
         self
     }
 }
 
+/// Convert object of type `U` to a service `S`
+pub fn into_service<I, S, Req>(tp: I) -> S
+where
+    I: IntoService<S, Req>,
+    S: Service<Req>,
+{
+    tp.into_service()
+}
+
 pub mod dev {
-    pub use crate::and_then::{AndThenService, AndThenServiceFactory};
-    pub use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
-    pub use crate::apply::{Apply, ApplyServiceFactory};
-    pub use crate::apply_cfg::{ApplyConfigService, ApplyConfigServiceFactory};
+    pub use crate::apply::{Apply, ApplyFactory};
     pub use crate::fn_service::{
         FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
     };
@@ -363,7 +304,30 @@ pub mod dev {
     pub use crate::map_config::{MapConfig, UnitConfig};
     pub use crate::map_err::{MapErr, MapErrServiceFactory};
     pub use crate::map_init_err::MapInitErr;
-    pub use crate::then::{ThenService, ThenServiceFactory};
     pub use crate::transform::ApplyTransform;
     pub use crate::transform_err::TransformMapInitErr;
 }
+
+#[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/map.rs

@@ -1,25 +1,29 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
 /// This is created by the `ServiceExt::map` method.
-pub struct Map<A, F, Response> {
+pub struct Map<A, F, Req, Res> {
     service: A,
     f: F,
-    _t: PhantomData<Response>,
+    _t: PhantomData<(Req, Res)>,
 }
 
-impl<A, F, Response> Map<A, F, Response> {
+impl<A, F, Req, Res> Map<A, F, Req, Res> {
     /// Create new `Map` combinator
     pub(crate) fn new(service: A, f: F) -> Self
     where
-        A: Service,
-        F: FnMut(A::Response) -> Response,
+        A: Service<Req>,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             service,
@@ -29,7 +33,7 @@ impl<A, F, Response> Map<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for Map<A, F, Response>
+impl<A, F, Req, Res> Clone for Map<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -43,52 +47,50 @@ where
     }
 }
 
-impl<A, F, Response> Service for Map<A, F, Response>
+impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response + Clone,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
-    type Response = Response;
+    type Response = Res;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Response>;
+    type Future = MapFuture<A, F, Req, Res>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(ctx)
-    }
+    crate::forward_ready!(service);
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct MapFuture<A, F, Response>
-where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
-{
-    f: F,
-    #[pin]
-    fut: A::Future,
+pin_project! {
+    pub struct MapFuture<A, F, Req, Res>
+    where
+        A: Service<Req>,
+        F: FnMut(A::Response) -> Res,
+    {
+        f: F,
+        #[pin]
+        fut: A::Future,
+    }
 }
 
-impl<A, F, Response> MapFuture<A, F, Response>
+impl<A, F, Req, Res> MapFuture<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, Response> Future for MapFuture<A, F, Response>
+impl<A, F, Req, Res> Future for MapFuture<A, F, Req, Res>
 where
-    A: Service,
-    F: FnMut(A::Response) -> Response,
+    A: Service<Req>,
+    F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Response, A::Error>;
+    type Output = Result<Res, A::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -102,17 +104,17 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapServiceFactory<A, F, Res> {
+pub struct MapServiceFactory<A, F, Req, Res> {
     a: A,
     f: F,
-    r: PhantomData<Res>,
+    r: PhantomData<(Res, Req)>,
 }
 
-impl<A, F, Res> MapServiceFactory<A, F, Res> {
+impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> {
     /// Create new `Map` new service instance
     pub(crate) fn new(a: A, f: F) -> Self
     where
-        A: ServiceFactory,
+        A: ServiceFactory<Req>,
         F: FnMut(A::Response) -> Res,
     {
         Self {
@@ -123,7 +125,7 @@ impl<A, F, Res> MapServiceFactory<A, F, Res> {
     }
 }
 
-impl<A, F, Res> Clone for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> Clone for MapServiceFactory<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -137,39 +139,39 @@ where
     }
 }
 
-impl<A, F, Res> ServiceFactory for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> ServiceFactory<Req> for MapServiceFactory<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
     type Response = Res;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = Map<A::Service, F, Res>;
+    type Service = Map<A::Service, F, Req, Res>;
     type InitError = A::InitError;
-    type Future = MapServiceFuture<A, F, Res>;
+    type Future = MapServiceFuture<A, F, Req, Res>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct MapServiceFuture<A, F, Res>
-where
-    A: ServiceFactory,
-    F: FnMut(A::Response) -> Res,
-{
-    #[pin]
-    fut: A::Future,
-    f: Option<F>,
+pin_project! {
+    pub struct MapServiceFuture<A, F, Req, Res>
+    where
+        A: ServiceFactory<Req>,
+        F: FnMut(A::Response) -> Res,
+    {
+        #[pin]
+        fut: A::Future,
+        f: Option<F>,
+    }
 }
 
-impl<A, F, Res> MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -177,12 +179,12 @@ where
     }
 }
 
-impl<A, F, Res> Future for MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> Future for MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Map<A::Service, F, Res>, A::InitError>;
+    type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -197,22 +199,21 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures_util::future::{lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{IntoServiceFactory, Service, ServiceFactory};
+    use crate::{
+        ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt,
+    };
 
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
+        crate::always_ready!();
 
         fn call(&mut self, _: ()) -> Self::Future {
             ok(())

actix-service/src/map_config.rs

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

actix-service/src/map_err.rs

@@ -1,7 +1,11 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
@@ -9,18 +13,18 @@ use super::{Service, ServiceFactory};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E> {
-    service: A,
+pub struct MapErr<S, Req, F, E> {
+    service: S,
     f: F,
-    _t: PhantomData<E>,
+    _t: PhantomData<(E, Req)>,
 }
 
-impl<A, F, E> MapErr<A, F, E> {
+impl<S, Req, F, E> MapErr<S, Req, F, E> {
     /// Create new `MapErr` combinator
-    pub(crate) fn new(service: A, f: F) -> Self
+    pub(crate) fn new(service: S, f: F) -> Self
     where
-        A: Service,
-        F: Fn(A::Error) -> E,
+        S: Service<Req>,
+        F: Fn(S::Error) -> E,
     {
         Self {
             service,
@@ -30,9 +34,9 @@ impl<A, F, E> MapErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErr<A, F, E>
+impl<S, Req, F, E> Clone for MapErr<S, Req, F, E>
 where
-    A: Clone,
+    S: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -44,39 +48,39 @@ where
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, Req, F, E> Service<Req> for MapErr<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, 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 call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct MapErrFuture<A, F, E>
-where
-    A: Service,
-    F: Fn(A::Error) -> E,
-{
-    f: F,
-    #[pin]
-    fut: A::Future,
+pin_project! {
+    pub struct MapErrFuture<A, Req, F, E>
+    where
+        A: Service<Req>,
+        F: Fn(A::Error) -> E,
+    {
+        f: F,
+        #[pin]
+        fut: A::Future,
+    }
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, Req, F, E> MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -84,9 +88,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     type Output = Result<A::Response, E>;
@@ -101,19 +105,19 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrServiceFactory<A, F, E>
+pub struct MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(E, Req)>,
 }
 
-impl<A, F, E> MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     /// Create new `MapErr` new service instance
@@ -126,9 +130,9 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> Clone for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory + Clone,
+    A: ServiceFactory<Req> + Clone,
     F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
@@ -140,39 +144,39 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> ServiceFactory<Req> for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
 
     type Config = A::Config;
-    type Service = MapErr<A::Service, F, E>;
+    type Service = MapErr<A::Service, Req, F, E>;
     type InitError = A::InitError;
-    type Future = MapErrServiceFuture<A, F, E>;
+    type Future = MapErrServiceFuture<A, Req, F, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct MapErrServiceFuture<A, F, E>
-where
-    A: ServiceFactory,
-    F: Fn(A::Error) -> E,
-{
-    #[pin]
-    fut: A::Future,
-    f: F,
+pin_project! {
+    pub struct MapErrServiceFuture<A, Req, F, E>
+    where
+        A: ServiceFactory<Req>,
+        F: Fn(A::Error) -> E,
+    {
+        #[pin]
+        fut: A::Future,
+        f: F,
+    }
 }
 
-impl<A, F, E> MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -180,12 +184,12 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
+    type Output = Result<MapErr<A::Service, Req, F, E>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -199,15 +203,17 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures_util::future::{err, lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{IntoServiceFactory, Service, ServiceFactory};
+    use crate::{
+        err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory,
+        ServiceFactoryExt,
+    };
 
     struct Srv;
 
-    impl Service for Srv {
-        type Request = ();
+    impl Service<()> for Srv {
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;

actix-service/src/map_init_err.rs

@@ -1,21 +1,25 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::ServiceFactory;
 
 /// `MapInitErr` service combinator
-pub struct MapInitErr<A, F, E> {
+pub struct MapInitErr<A, F, Req, Err> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(Req, Err)>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E>
+impl<A, F, Req, Err> MapInitErr<A, F, Req, Err>
 where
-    A: ServiceFactory,
-    F: Fn(A::InitError) -> E,
+    A: ServiceFactory<Req>,
+    F: Fn(A::InitError) -> Err,
 {
     /// Create new `MapInitErr` combinator
     pub(crate) fn new(a: A, f: F) -> Self {
@@ -27,7 +31,7 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapInitErr<A, F, E>
+impl<A, F, Req, E> Clone for MapInitErr<A, F, Req, E>
 where
     A: Clone,
     F: Clone,
@@ -41,39 +45,39 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapInitErr<A, F, E>
+impl<A, F, Req, E> ServiceFactory<Req> for MapInitErr<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
 
     type Config = A::Config;
     type Service = A::Service;
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, F, Req, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
-pub struct MapInitErrFuture<A, F, E>
-where
-    A: ServiceFactory,
-    F: Fn(A::InitError) -> E,
-{
-    f: F,
-    #[pin]
-    fut: A::Future,
+pin_project! {
+    pub struct MapInitErrFuture<A, F, Req, E>
+    where
+        A: ServiceFactory<Req>,
+        F: Fn(A::InitError) -> E,
+    {
+        f: F,
+        #[pin]
+        fut: A::Future,
+    }
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, Req, E> MapInitErrFuture<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -81,9 +85,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, F, Req, E> Future for MapInitErrFuture<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     type Output = Result<A::Service, E>;

actix-service/src/pipeline.rs

@@ -1,42 +1,49 @@
-use std::future::Future;
-use std::task::{Context, Poll};
+use core::{
+    marker::PhantomData,
+    task::{Context, Poll},
+};
 
 use crate::and_then::{AndThenService, AndThenServiceFactory};
-use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
 use crate::map::{Map, MapServiceFactory};
 use crate::map_err::{MapErr, MapErrServiceFactory};
 use crate::map_init_err::MapInitErr;
 use crate::then::{ThenService, ThenServiceFactory};
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// Contruct new pipeline with one service in pipeline chain.
-pub fn pipeline<F, T>(service: F) -> Pipeline<T>
+/// Construct new pipeline with one service in pipeline chain.
+pub fn pipeline<I, S, Req>(service: I) -> Pipeline<S, Req>
 where
-    F: IntoService<T>,
-    T: Service,
+    I: IntoService<S, Req>,
+    S: Service<Req>,
 {
     Pipeline {
         service: service.into_service(),
+        _phantom: PhantomData,
     }
 }
 
-/// Contruct new pipeline factory with one service factory.
-pub fn pipeline_factory<T, F>(factory: F) -> PipelineFactory<T>
+/// Construct new pipeline factory with one service factory.
+pub fn pipeline_factory<I, SF, Req>(factory: I) -> PipelineFactory<SF, Req>
 where
-    T: ServiceFactory,
-    F: IntoServiceFactory<T>,
+    I: IntoServiceFactory<SF, Req>,
+    SF: ServiceFactory<Req>,
 {
     PipelineFactory {
         factory: factory.into_factory(),
+        _phantom: PhantomData,
     }
 }
 
 /// Pipeline service - pipeline allows to compose multiple service into one service.
-pub struct Pipeline<T> {
-    service: T,
+pub struct Pipeline<S, Req> {
+    service: S,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: Service> Pipeline<T> {
+impl<S, Req> Pipeline<S, Req>
+where
+    S: Service<Req>,
+{
     /// Call another service after call to this one has resolved successfully.
     ///
     /// This function can be used to chain two services together and ensure that
@@ -46,36 +53,18 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn and_then<F, U>(self, service: F) -> Pipeline<AndThenService<T, U>>
+    pub fn and_then<I, S1>(
+        self,
+        service: I,
+    ) -> Pipeline<impl Service<Req, Response = S1::Response, Error = S::Error> + Clone, Req>
     where
         Self: Sized,
-        F: IntoService<U>,
-        U: Service<Request = T::Response, Error = T::Error>,
+        I: IntoService<S1, S::Response>,
+        S1: Service<S::Response, Error = S::Error>,
     {
         Pipeline {
             service: AndThenService::new(self.service, service.into_service()),
-        }
-    }
-
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    ///
-    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
-    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
-        self,
-        service: I,
-        f: F,
-    ) -> Pipeline<AndThenApplyFn<T, U, F, Fut, Res, Err>>
-    where
-        Self: Sized,
-        I: IntoService<U>,
-        U: Service,
-        F: FnMut(T::Response, &mut U) -> Fut,
-        Fut: Future<Output = Result<Res, Err>>,
-        Err: From<T::Error> + From<U::Error>,
-    {
-        Pipeline {
-            service: AndThenApplyFn::new(self.service, service.into_service(), f),
+            _phantom: PhantomData,
         }
     }
 
@@ -84,14 +73,18 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving pipeline and returns a
     /// wrapped version of it.
-    pub fn then<F, U>(self, service: F) -> Pipeline<ThenService<T, U>>
+    pub fn then<F, S1>(
+        self,
+        service: F,
+    ) -> Pipeline<impl Service<Req, Response = S1::Response, Error = S::Error> + Clone, Req>
     where
         Self: Sized,
-        F: IntoService<U>,
-        U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>,
+        F: IntoService<S1, Result<S::Response, S::Error>>,
+        S1: Service<Result<S::Response, S::Error>, Error = S::Error>,
     {
         Pipeline {
             service: ThenService::new(self.service, service.into_service()),
+            _phantom: PhantomData,
         }
     }
 
@@ -104,13 +97,14 @@ impl<T: Service> Pipeline<T> {
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it, similar to the existing `map` methods in the
     /// standard library.
-    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> Pipeline<Map<S, F, Req, R>, Req>
     where
         Self: Sized,
-        F: FnMut(T::Response) -> R,
+        F: FnMut(S::Response) -> R,
     {
         Pipeline {
             service: Map::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 
@@ -122,89 +116,85 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>>
+    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<S, Req, F, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::Error) -> E,
+        F: Fn(S::Error) -> E,
     {
         Pipeline {
             service: MapErr::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for Pipeline<T>
+impl<T, Req> Clone for Pipeline<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         Pipeline {
             service: self.service.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: Service> Service for Pipeline<T> {
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Future = T::Future;
+impl<S: Service<Req>, Req> Service<Req> for Pipeline<S, Req> {
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
 
     #[inline]
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), T::Error>> {
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         self.service.poll_ready(ctx)
     }
 
     #[inline]
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         self.service.call(req)
     }
 }
 
 /// Pipeline factory
-pub struct PipelineFactory<T> {
-    factory: T,
+pub struct PipelineFactory<SF, Req> {
+    factory: SF,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: ServiceFactory> PipelineFactory<T> {
+impl<SF, Req> PipelineFactory<SF, Req>
+where
+    SF: ServiceFactory<Req>,
+{
     /// Call another service after call to this one has resolved successfully.
-    pub fn and_then<F, U>(self, factory: F) -> PipelineFactory<AndThenServiceFactory<T, U>>
+    pub fn and_then<I, SF1>(
+        self,
+        factory: I,
+    ) -> PipelineFactory<
+        impl ServiceFactory<
+                Req,
+                Response = SF1::Response,
+                Error = SF::Error,
+                Config = SF::Config,
+                InitError = SF::InitError,
+                Service = impl Service<Req, Response = SF1::Response, Error = SF::Error> + Clone,
+            > + Clone,
+        Req,
+    >
     where
         Self: Sized,
-        T::Config: Clone,
-        F: IntoServiceFactory<U>,
-        U: ServiceFactory<
-            Config = T::Config,
-            Request = T::Response,
-            Error = T::Error,
-            InitError = T::InitError,
+        SF::Config: Clone,
+        I: IntoServiceFactory<SF1, SF::Response>,
+        SF1: ServiceFactory<
+            SF::Response,
+            Config = SF::Config,
+            Error = SF::Error,
+            InitError = SF::InitError,
         >,
     {
         PipelineFactory {
             factory: AndThenServiceFactory::new(self.factory, factory.into_factory()),
-        }
-    }
-
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    ///
-    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
-    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
-        self,
-        factory: I,
-        f: F,
-    ) -> PipelineFactory<AndThenApplyFnFactory<T, U, F, Fut, Res, Err>>
-    where
-        Self: Sized,
-        T::Config: Clone,
-        I: IntoServiceFactory<U>,
-        U: ServiceFactory<Config = T::Config, InitError = T::InitError>,
-        F: FnMut(T::Response, &mut U::Service) -> Fut + Clone,
-        Fut: Future<Output = Result<Res, Err>>,
-        Err: From<T::Error> + From<U::Error>,
-    {
-        PipelineFactory {
-            factory: AndThenApplyFnFactory::new(self.factory, factory.into_factory(), f),
+            _phantom: PhantomData,
         }
     }
 
@@ -214,80 +204,103 @@ impl<T: ServiceFactory> PipelineFactory<T> {
     ///
     /// Note that this function consumes the receiving pipeline and returns a
     /// wrapped version of it.
-    pub fn then<F, U>(self, factory: F) -> PipelineFactory<ThenServiceFactory<T, U>>
+    pub fn then<I, SF1>(
+        self,
+        factory: I,
+    ) -> PipelineFactory<
+        impl ServiceFactory<
+                Req,
+                Response = SF1::Response,
+                Error = SF::Error,
+                Config = SF::Config,
+                InitError = SF::InitError,
+                Service = impl Service<Req, Response = SF1::Response, Error = SF::Error> + Clone,
+            > + Clone,
+        Req,
+    >
     where
         Self: Sized,
-        T::Config: Clone,
-        F: IntoServiceFactory<U>,
-        U: ServiceFactory<
-            Config = T::Config,
-            Request = Result<T::Response, T::Error>,
-            Error = T::Error,
-            InitError = T::InitError,
+        SF::Config: Clone,
+        I: IntoServiceFactory<SF1, Result<SF::Response, SF::Error>>,
+        SF1: ServiceFactory<
+            Result<SF::Response, SF::Error>,
+            Config = SF::Config,
+            Error = SF::Error,
+            InitError = SF::InitError,
         >,
     {
         PipelineFactory {
             factory: ThenServiceFactory::new(self.factory, factory.into_factory()),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<SF, F, Req, R>, Req>
     where
         Self: Sized,
-        F: FnMut(T::Response) -> R + Clone,
+        F: FnMut(SF::Response) -> R + Clone,
     {
         PipelineFactory {
             factory: MapServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's error to a different error, returning a new service.
-    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<T, F, E>>
+    pub fn map_err<F, E>(
+        self,
+        f: F,
+    ) -> PipelineFactory<MapErrServiceFactory<SF, Req, F, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::Error) -> E + Clone,
+        F: Fn(SF::Error) -> E + Clone,
     {
         PipelineFactory {
             factory: MapErrServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this factory's init error to a different error, returning a new service.
-    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>>
+    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<SF, F, Req, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::InitError) -> E + Clone,
+        F: Fn(SF::InitError) -> E + Clone,
     {
         PipelineFactory {
             factory: MapInitErr::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for PipelineFactory<T>
+impl<T, Req> Clone for PipelineFactory<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         PipelineFactory {
             factory: self.factory.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: ServiceFactory> ServiceFactory for PipelineFactory<T> {
-    type Config = T::Config;
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Service = T::Service;
-    type InitError = T::InitError;
-    type Future = T::Future;
+impl<SF, Req> ServiceFactory<Req> for PipelineFactory<SF, Req>
+where
+    SF: ServiceFactory<Req>,
+{
+    type Config = SF::Config;
+    type Response = SF::Response;
+    type Error = SF::Error;
+    type Service = SF::Service;
+    type InitError = SF::InitError;
+    type Future = SF::Future;
 
     #[inline]
-    fn new_service(&self, cfg: T::Config) -> Self::Future {
+    fn new_service(&self, cfg: SF::Config) -> Self::Future {
         self.factory.new_service(cfg)
     }
 }

actix-service/src/ready.rs

@@ -0,0 +1,54 @@
+//! When MSRV is 1.48, replace with `core::future::Ready` and `core::future::ready()`.
+
+use core::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// Future for the [`ready`](ready()) function.
+#[derive(Debug, Clone)]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct Ready<T> {
+    val: Option<T>,
+}
+
+impl<T> Ready<T> {
+    /// Unwraps the value from this immediately ready future.
+    #[inline]
+    pub fn into_inner(mut self) -> T {
+        self.val.take().unwrap()
+    }
+}
+
+impl<T> Unpin for Ready<T> {}
+
+impl<T> Future for Ready<T> {
+    type Output = T;
+
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<T> {
+        let val = self.val.take().expect("Ready can not be polled twice.");
+        Poll::Ready(val)
+    }
+}
+
+/// Creates a future that is immediately ready with a value.
+#[allow(dead_code)]
+pub(crate) fn ready<T>(val: T) -> Ready<T> {
+    Ready { val: Some(val) }
+}
+
+/// Create a future that is immediately ready with a success value.
+#[allow(dead_code)]
+pub(crate) fn ok<T, E>(val: T) -> Ready<Result<T, E>> {
+    Ready { val: Some(Ok(val)) }
+}
+
+/// Create a future that is immediately ready with an error value.
+#[allow(dead_code)]
+pub(crate) fn err<T, E>(err: E) -> Ready<Result<T, E>> {
+    Ready {
+        val: Some(Err(err)),
+    }
+}

actix-service/src/then.rs

@@ -1,210 +1,201 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use alloc::rc::Rc;
+use core::{
+    cell::RefCell,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
-use crate::cell::Cell;
 
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
 ///
-/// This is created by the `ServiceExt::then` method.
-pub struct ThenService<A, B> {
-    a: A,
-    b: Cell<B>,
-}
+/// This is created by the `Pipeline::then` method.
+pub(crate) struct ThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> ThenService<A, B> {
+impl<A, B, Req> ThenService<A, B, Req> {
     /// Create new `.then()` combinator
-    pub(crate) fn new(a: A, b: B) -> ThenService<A, B>
+    pub(crate) fn new(a: A, b: B) -> ThenService<A, B, Req>
     where
-        A: Service,
-        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+        A: Service<Req>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
-        Self { a, b: Cell::new(b) }
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for ThenService<A, B>
-where
-    A: Clone,
-{
+impl<A, B, Req> Clone for ThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        ThenService {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
+        ThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for ThenService<A, B>
+impl<A, B, Req> Service<Req> for ThenService<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenServiceResponse<A, B>;
+    type Future = ThenServiceResponse<A, B, Req>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let not_ready = !self.a.poll_ready(ctx)?.is_ready();
-        if !self.b.get_mut().poll_ready(ctx)?.is_ready() || not_ready {
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut srv = self.0.borrow_mut();
+        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         ThenServiceResponse {
-            state: State::A(self.a.call(req), Some(self.b.clone())),
+            state: State::A {
+                fut: self.0.borrow_mut().0.call(req),
+                b: Some(self.0.clone()),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
-pub struct ThenServiceResponse<A, B>
-where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
-{
-    #[pin]
-    state: State<A, B>,
+pin_project! {
+    pub(crate) struct ThenServiceResponse<A, B, Req>
+    where
+        A: Service<Req>,
+        B: Service<Result<A::Response, A::Error>>,
+    {
+        #[pin]
+        state: State<A, B, Req>,
+    }
 }
 
-#[pin_project::pin_project]
-enum State<A, B>
-where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
-{
-    A(#[pin] A::Future, Option<Cell<B>>),
-    B(#[pin] B::Future),
-    Empty,
+pin_project! {
+    #[project = StateProj]
+    enum State<A, B, Req>
+    where
+        A: Service<Req>,
+        B: Service<Result<A::Response, A::Error>>,
+    {
+        A { #[pin] fut: A::Future, b: Option<Rc<RefCell<(A, B)>>> },
+        B { #[pin] fut: B::Future },
+        Empty,
+    }
 }
 
-impl<A, B> Future for ThenServiceResponse<A, B>
+impl<A, B, Req> Future for ThenServiceResponse<A, B, Req>
 where
-    A: Service,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    A: Service<Req>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Output = Result<B::Response, B::Error>;
 
-    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        #[project]
         match this.state.as_mut().project() {
-            State::A(fut, b) => match fut.poll(cx) {
+            StateProj::A { fut, b } => match fut.poll(cx) {
                 Poll::Ready(res) => {
-                    let mut b = b.take().unwrap();
+                    let b = b.take().unwrap();
                     this.state.set(State::Empty); // drop fut A
-                    let fut = b.get_mut().call(res);
-                    this.state.set(State::B(fut));
+                    let fut = b.borrow_mut().1.call(res);
+                    this.state.set(State::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            State::B(fut) => fut.poll(cx).map(|r| {
+            StateProj::B { fut } => fut.poll(cx).map(|r| {
                 this.state.set(State::Empty);
                 r
             }),
-            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }
 
 /// `.then()` service factory combinator
-pub struct ThenServiceFactory<A, B> {
-    a: A,
-    b: B,
-}
+pub(crate) struct ThenServiceFactory<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
-impl<A, B> ThenServiceFactory<A, B>
+impl<A, B, Req> ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self {
-        Self { a, b }
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
-impl<A, B> ServiceFactory for ThenServiceFactory<A, B>
+impl<A, B, Req> ServiceFactory<Req> for ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = ThenService<A::Service, B::Service>;
+    type Service = ThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = ThenServiceFactoryResponse<A, B>;
+    type Future = ThenServiceFactoryResponse<A, B, Req>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
-        ThenServiceFactoryResponse::new(
-            self.a.new_service(cfg.clone()),
-            self.b.new_service(cfg),
-        )
+        let srv = &*self.0;
+        ThenServiceFactoryResponse::new(srv.0.new_service(cfg.clone()), srv.1.new_service(cfg))
     }
 }
 
-impl<A, B> Clone for ThenServiceFactory<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
+impl<A, B, Req> Clone for ThenServiceFactory<A, B, Req> {
     fn clone(&self) -> Self {
-        Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
+        Self(self.0.clone(), PhantomData)
     }
 }
 
-#[pin_project::pin_project]
-pub struct ThenServiceFactoryResponse<A, B>
-where
-    A: ServiceFactory,
-    B: ServiceFactory<
-        Config = A::Config,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
-{
-    #[pin]
-    fut_b: B::Future,
-    #[pin]
-    fut_a: A::Future,
-    a: Option<A::Service>,
-    b: Option<B::Service>,
+pin_project! {
+    pub(crate) struct ThenServiceFactoryResponse<A, B, Req>
+    where
+        A: ServiceFactory<Req>,
+        B: ServiceFactory<
+            Result<A::Response, A::Error>,
+            Config = A::Config,
+            Error = A::Error,
+            InitError = A::InitError,
+        >,
+    {
+        #[pin]
+        fut_b: B::Future,
+        #[pin]
+        fut_a: A::Future,
+        a: Option<A::Service>,
+        b: Option<B::Service>,
+    }
 }
 
-impl<A, B> ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -219,17 +210,17 @@ where
     }
 }
 
-impl<A, B> Future for ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Output = Result<ThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<ThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -257,19 +248,20 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::cell::Cell;
-    use std::rc::Rc;
-    use std::task::{Context, Poll};
+    use alloc::rc::Rc;
+    use core::{
+        cell::Cell,
+        task::{Context, Poll},
+    };
 
-    use futures_util::future::{err, lazy, ok, ready, Ready};
+    use futures_util::future::lazy;
 
-    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{err, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
-        type Request = Result<&'static str, &'static str>;
+    impl Service<Result<&'static str, &'static str>> for Srv1 {
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, Self::Error>>;
@@ -289,8 +281,7 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
-        type Request = Result<&'static str, ()>;
+    impl Service<Result<&'static str, ()>> for Srv2 {
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
@@ -324,11 +315,11 @@ mod tests {
 
         let res = srv.call(Ok("srv1")).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv1", "ok")));
+        assert_eq!(res.unwrap(), ("srv1", "ok"));
 
         let res = srv.call(Err("srv")).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv2", "err")));
+        assert_eq!(res.unwrap(), ("srv2", "err"));
     }
 
     #[actix_rt::test]
@@ -340,10 +331,10 @@ mod tests {
         let mut srv = factory.new_service(&()).await.unwrap();
         let res = srv.call(Ok("srv1")).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv1", "ok")));
+        assert_eq!(res.unwrap(), ("srv1", "ok"));
 
         let res = srv.call(Err("srv")).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), (("srv2", "err")));
+        assert_eq!(res.unwrap(), ("srv2", "err"));
     }
 }

actix-service/src/transform.rs

@@ -1,18 +1,22 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::task::{Context, Poll};
+use alloc::{rc::Rc, sync::Arc};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use crate::transform_err::TransformMapInitErr;
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform to a service.
-pub fn apply<T, S, U>(t: T, factory: U) -> ApplyTransform<T, S>
+pub fn apply<T, S, I, Req>(t: T, factory: I) -> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
-    U: IntoServiceFactory<S>,
+    I: IntoServiceFactory<S, Req>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     ApplyTransform::new(t, factory.into_factory())
 }
@@ -70,7 +74,7 @@ where
 ///     timeout: Duration,
 /// }
 ///
-/// impl<S> Transform<S> for TimeoutTransform<E>
+/// impl<S> Transform<S> for TimeoutTransform
 /// where
 ///     S: Service,
 /// {
@@ -89,10 +93,7 @@ where
 ///     }
 /// }
 /// ```
-pub trait Transform<S> {
-    /// Requests handled by the service.
-    type Request;
-
+pub trait Transform<S, Req> {
     /// Responses given by the service.
     type Response;
 
@@ -100,11 +101,7 @@ pub trait Transform<S> {
     type Error;
 
     /// The `TransformService` value created by this factory
-    type Transform: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
+    type Transform: Service<Req, Response = Self::Response, Error = Self::Error>;
 
     /// Errors produced while building a transform service.
     type InitError;
@@ -115,9 +112,9 @@ pub trait Transform<S> {
     /// Creates and returns a new Transform component, asynchronously
     fn new_transform(&self, service: S) -> Self::Future;
 
-    /// Map this transforms's factory error to a different error,
+    /// 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, F, E>
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E + Clone,
@@ -126,11 +123,10 @@ pub trait Transform<S> {
     }
 }
 
-impl<T, S> Transform<S> for Rc<T>
+impl<T, S, Req> Transform<S, Req> for Rc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -142,11 +138,10 @@ where
     }
 }
 
-impl<T, S> Transform<S> for Arc<T>
+impl<T, S, Req> Transform<S, Req> for Arc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -159,90 +154,92 @@ where
 }
 
 /// `Apply` transform to new service
-pub struct ApplyTransform<T, S>(Rc<(T, S)>);
+pub struct ApplyTransform<T, S, Req>(Rc<(T, S)>, PhantomData<Req>);
 
-impl<T, S> ApplyTransform<T, S>
+impl<T, S, Req> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     /// Create new `ApplyTransform` new service instance
     fn new(t: T, service: S) -> Self {
-        Self(Rc::new((t, service)))
+        Self(Rc::new((t, service)), PhantomData)
     }
 }
 
-impl<T, S> Clone for ApplyTransform<T, S> {
+impl<T, S, Req> Clone for ApplyTransform<T, S, Req> {
     fn clone(&self) -> Self {
-        ApplyTransform(self.0.clone())
+        ApplyTransform(self.0.clone(), PhantomData)
     }
 }
 
-impl<T, S> ServiceFactory for ApplyTransform<T, S>
+impl<T, S, Req> ServiceFactory<Req> for ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
 
     type Config = S::Config;
     type Service = T::Transform;
     type InitError = T::InitError;
-    type Future = ApplyTransformFuture<T, S>;
+    type Future = ApplyTransformFuture<T, S, Req>;
 
     fn new_service(&self, cfg: S::Config) -> Self::Future {
         ApplyTransformFuture {
             store: self.0.clone(),
-            state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)),
+            state: ApplyTransformFutureState::A {
+                fut: self.0.as_ref().1.new_service(cfg),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
-pub struct ApplyTransformFuture<T, S>
-where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    store: Rc<(T, S)>,
-    #[pin]
-    state: ApplyTransformFutureState<T, S>,
+pin_project! {
+    pub struct ApplyTransformFuture<T, S, Req>
+    where
+        S: ServiceFactory<Req>,
+        T: Transform<S::Service, Req, InitError = S::InitError>,
+    {
+        store: Rc<(T, S)>,
+        #[pin]
+        state: ApplyTransformFutureState<T, S, Req>,
+    }
 }
 
-#[pin_project::pin_project]
-pub enum ApplyTransformFutureState<T, S>
-where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    A(#[pin] S::Future),
-    B(#[pin] T::Future),
+pin_project! {
+    #[project = ApplyTransformFutureStateProj]
+    pub enum ApplyTransformFutureState<T, S, Req>
+    where
+        S: ServiceFactory<Req>,
+        T: Transform<S::Service, Req, InitError = S::InitError>,
+    {
+        A { #[pin] fut: S::Future },
+        B { #[pin] fut: T::Future },
+    }
 }
 
-impl<T, S> Future for ApplyTransformFuture<T, S>
+impl<T, S, Req> Future for ApplyTransformFuture<T, S, Req>
 where
-    S: ServiceFactory,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     type Output = Result<T::Transform, T::InitError>;
 
-    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        #[project]
         match this.state.as_mut().project() {
-            ApplyTransformFutureState::A(fut) => match fut.poll(cx)? {
+            ApplyTransformFutureStateProj::A { fut } => match fut.poll(cx)? {
                 Poll::Ready(srv) => {
                     let fut = this.store.0.new_transform(srv);
-                    this.state.set(ApplyTransformFutureState::B(fut));
+                    this.state.set(ApplyTransformFutureState::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            ApplyTransformFutureState::B(fut) => fut.poll(cx),
+            ApplyTransformFutureStateProj::B { fut } => fut.poll(cx),
         }
     }
 }

actix-service/src/transform_err.rs

@@ -1,7 +1,11 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::Transform;
 
@@ -9,75 +13,75 @@ use super::Transform;
 /// transform's init error.
 ///
 /// This is created by the `Transform::map_init_err` method.
-pub struct TransformMapInitErr<T, S, F, E> {
-    t: T,
-    f: F,
-    e: PhantomData<(S, E)>,
+pub struct TransformMapInitErr<T, S, Req, F, E> {
+    transform: T,
+    mapper: F,
+    _phantom: PhantomData<(S, Req, E)>,
 }
 
-impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+impl<T, S, F, E, Req> TransformMapInitErr<T, S, Req, F, E> {
     pub(crate) fn new(t: T, f: F) -> Self
     where
-        T: Transform<S>,
+        T: Transform<S, Req>,
         F: Fn(T::InitError) -> E,
     {
         Self {
-            t,
-            f,
-            e: PhantomData,
+            transform: t,
+            mapper: f,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+impl<T, S, Req, F, E> Clone for TransformMapInitErr<T, S, Req, F, E>
 where
     T: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
-            t: self.t.clone(),
-            f: self.f.clone(),
-            e: PhantomData,
+            transform: self.transform.clone(),
+            mapper: self.mapper.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+impl<T, S, F, E, Req> Transform<S, Req> for TransformMapInitErr<T, S, Req, F, E>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E + Clone,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type Transform = T::Transform;
 
     type InitError = E;
-    type Future = TransformMapInitErrFuture<T, S, F, E>;
+    type Future = TransformMapInitErrFuture<T, S, F, E, Req>;
 
     fn new_transform(&self, service: S) -> Self::Future {
         TransformMapInitErrFuture {
-            fut: self.t.new_transform(service),
-            f: self.f.clone(),
+            fut: self.transform.new_transform(service),
+            f: self.mapper.clone(),
         }
     }
 }
 
-#[pin_project::pin_project]
-pub struct TransformMapInitErrFuture<T, S, F, E>
-where
-    T: Transform<S>,
+pin_project! {
+    pub struct TransformMapInitErrFuture<T, S, F, E, Req>
+    where
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E,
-{
-    #[pin]
-    fut: T::Future,
-    f: F,
+    {
+        #[pin]
+        fut: T::Future,
+        f: F,
+    }
 }
 
-impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+impl<T, S, F, E, Req> Future for TransformMapInitErrFuture<T, S, F, E, Req>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E + Clone,
 {
     type Output = Result<T::Transform, E>;

actix-testing/CHANGES.md

@@ -1,23 +1,37 @@
 # Changes
 
-## [1.0.0-alpha.3] - 2019-12-07
+## Unreleased - 2021-xx-xx
 
+
+## 2.0.0-beta.1 - 2020-12-28
+* Update `actix-server` to v2.0.0-beta.1.
+
+
+## 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
 
+## 1.0.0-alpha.2 - 2019-12-02
 * Re-export `test` attribute macros
 
 
-## [0.3.0-alpha.1] - 2019-11-22
 
+## 0.3.0-alpha.1 - 2019-11-22
 * Migrate to std::future
 
-## [0.2.0] - 2019-10-14
 
+## 0.2.0 - 2019-10-14
 * Upgrade actix-server and actix-server-config deps
 
 
-## [0.1.0] - 2019-09-25
-
+## 0.1.0 - 2019-09-25
 * Initial impl

actix-testing/Cargo.toml

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

actix-testing/README.md

@@ -6,4 +6,4 @@
 * [API Documentation](https://docs.rs/actix-testing/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-http-test](https://crates.io/crates/actix-testing)
-* Minimum supported Rust version: 1.37 or later
+* Minimum supported Rust version: 1.46 or later

actix-testing/src/lib.rs

@@ -1,13 +1,16 @@
 //! Various helpers for Actix applications to use during testing.
-#![deny(rust_2018_idioms, warnings)]
-#![allow(clippy::type_complexity)]
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![allow(clippy::type_complexity, clippy::needless_doctest_main)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use std::sync::mpsc;
 use std::{net, thread};
 
 use actix_rt::{net::TcpStream, System};
 use actix_server::{Server, ServerBuilder, ServiceFactory};
-use net2::TcpBuilder;
+use socket2::{Domain, Protocol, Socket, Type};
 
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub use actix_macros::test;
@@ -37,7 +40,7 @@ pub use actix_macros::test;
 /// ```
 pub struct TestServer;
 
-/// Test server runstime
+/// Test server runtime
 pub struct TestServerRuntime {
     addr: net::SocketAddr,
     host: String,
@@ -84,13 +87,15 @@ impl TestServer {
             let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
             let local_addr = tcp.local_addr().unwrap();
 
-            Server::build()
-                .listen("test", tcp, factory)?
-                .workers(1)
-                .disable_signals()
-                .start();
-
-            tx.send((System::current(), local_addr)).unwrap();
+            sys.block_on(async {
+                Server::build()
+                    .listen("test", tcp, factory)
+                    .unwrap()
+                    .workers(1)
+                    .disable_signals()
+                    .start();
+                tx.send((System::current(), local_addr)).unwrap();
+            });
             sys.run()
         });
 
@@ -107,13 +112,14 @@ impl TestServer {
         }
     }
 
-    /// Get firat 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 = TcpBuilder::new_v4().unwrap();
-        socket.bind(&addr).unwrap();
-        socket.reuse_address(true).unwrap();
-        let tcp = socket.to_tcp_listener().unwrap();
+        let socket =
+            Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+        socket.bind(&addr.into()).unwrap();
+        socket.set_reuse_address(true).unwrap();
+        let tcp = socket.into_tcp_listener();
         tcp.local_addr().unwrap()
     }
 }

actix-threadpool/CHANGES.md

@@ -1,5 +1,25 @@
 # Changes
 
+## [0.3.3] - 2020-07-14
+
+### Changed
+
+* Update parking_lot to 0.11
+
+## [0.3.2] - 2020-05-20
+
+## Added
+
+* Implement `std::error::Error` for `BlockingError` [#120]
+
+[#120]: https://github.com/actix/actix-net/pull/120
+
+## [0.3.1] - 2019-12-12
+
+### Changed
+
+* Update parking_lot to 0.10
+
 ## [0.3.0] - 2019-12-02
 
 ### Changed

actix-threadpool/Cargo.toml

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