build(deps): bump socket2 from 0.5.8 to 0.5.9 (#661)

Bumps [socket2](https://github.com/rust-lang/socket2) from 0.5.8 to 0.5.9.
- [Release notes](https://github.com/rust-lang/socket2/releases)
- [Changelog](https://github.com/rust-lang/socket2/blob/master/CHANGELOG.md)
- [Commits](https://github.com/rust-lang/socket2/commits)

---
updated-dependencies:
- dependency-name: socket2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.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

.cargo/config.toml

@@ -0,0 +1,15 @@
+[alias]
+lint = "clippy --workspace --tests --examples --bins -- -Dclippy::todo"
+lint-all = "clippy --workspace --all-features --tests --examples --bins -- -Dclippy::todo"
+
+# just check the library (without dev deps)
+ci-check-min = "hack --workspace check --no-default-features"
+ci-check-lib = "hack --workspace --feature-powerset --depth=2 --exclude-features=io-uring check"
+ci-check-lib-linux = "hack --workspace --feature-powerset --depth=2 check"
+
+# check everything
+ci-check = "hack --workspace --feature-powerset --depth=2 --exclude-features=io-uring check --tests --examples"
+ci-check-linux = "hack --workspace --feature-powerset --depth=2 check --tests --examples"
+
+# tests avoiding io-uring feature
+ci-test = "hack --feature-powerset --depth=2 --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture"

.envrc

@@ -0,0 +1 @@
+use flake

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,25 @@
+## 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/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly

.github/workflows/ci-post-merge.yml

@@ -0,0 +1,129 @@
+name: CI (post-merge)
+
+on:
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build_and_test_nightly:
+    strategy:
+      fail-fast: false
+      matrix:
+        # prettier-ignore
+        target:
+          - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
+          - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
+          - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
+          - { name: Windows (MinGW), os: windows-latest, triple: x86_64-pc-windows-gnu }
+        version:
+          - nightly
+
+    name: ${{ matrix.target.name }} / ${{ matrix.version }}
+    runs-on: ${{ matrix.target.os }}
+
+    env: {}
+
+    steps:
+      - name: Setup Routing
+        if: matrix.target.os == 'macos-latest'
+        run: sudo ifconfig lo0 alias 127.0.0.3
+
+      - uses: actions/checkout@v4
+
+      - name: Free Disk Space
+        if: matrix.target.os == 'ubuntu-latest'
+        run: ./scripts/free-disk-space.sh
+
+      - name: Setup mold linker
+        if: matrix.target.os == 'ubuntu-latest'
+        uses: rui314/setup-mold@v1
+
+      - name: Install nasm
+        if: matrix.target.os == 'windows-latest'
+        uses: ilammy/setup-nasm@v1.5.2
+
+      - name: Install OpenSSL
+        if: matrix.target.os == 'windows-latest'
+        shell: bash
+        run: |
+          set -e
+          choco install openssl --version=1.1.1.2100 -y --no-progress
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' >> $GITHUB_ENV
+          echo "RUSTFLAGS=-C target-feature=+crt-static" >> $GITHUB_ENV
+
+      - name: Install Rust (${{ matrix.version }})
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: ${{ matrix.version }}
+
+      - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
+
+      - name: check lib
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: cargo ci-check-lib
+      - name: check lib
+        if: matrix.target.os == 'ubuntu-latest'
+        run: cargo ci-check-lib-linux
+      - name: check lib
+        if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+        run: cargo ci-check-min
+
+      - name: check full
+        # TODO: compile OpenSSL and run tests on MinGW
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: cargo ci-check
+      - name: check all
+        if: matrix.target.os == 'ubuntu-latest'
+        run: cargo ci-check-linux
+
+      - name: tests
+        run: just test
+
+      # TODO: re-instate some io-uring tests PRs
+      # - name: tests
+      #   if: matrix.target.os == 'ubuntu-latest'
+      #   run: >-
+      #     sudo bash -c "
+      #     ulimit -Sl 512
+      #     && ulimit -Hl 512
+      #     && PATH=$PATH:/usr/share/rust/.cargo/bin
+      #     && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-020
+      #     && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-021
+      #     && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-linux
+      #     "
+
+      - name: CI cache clean
+        run: cargo-ci-cache-clean
+
+  minimal-versions:
+    name: minimal versions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust (nightly)
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: nightly
+
+      - name: Install cargo-hack & cargo-minimal-versions
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: cargo-hack,cargo-minimal-versions
+
+      - name: Check With Minimal Versions
+        run: cargo minimal-versions check

.github/workflows/ci.yml

@@ -0,0 +1,133 @@
+name: CI
+
+on:
+  pull_request: {}
+  merge_group: { types: [checks_requested] }
+  push: { branches: [master] }
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  read_msrv:
+    name: Read MSRV
+    uses: actions-rust-lang/msrv/.github/workflows/msrv.yml@v0.1.0
+
+  build_and_test:
+    needs:
+      - read_msrv
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # prettier-ignore
+        target:
+          - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
+          - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
+          - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
+          - { name: Windows (MinGW), os: windows-latest, triple: x86_64-pc-windows-gnu }
+        version:
+          - { name: msrv, version: "${{ needs.read_msrv.outputs.msrv }}" }
+          - { name: stable, version: stable }
+
+    name: ${{ matrix.target.name }} / ${{ matrix.version.name }}
+    runs-on: ${{ matrix.target.os }}
+
+    env: {}
+
+    steps:
+      - name: Setup Routing
+        if: matrix.target.os == 'macos-latest'
+        run: sudo ifconfig lo0 alias 127.0.0.3
+
+      - uses: actions/checkout@v4
+
+      - name: Free Disk Space
+        if: matrix.target.os == 'ubuntu-latest'
+        run: ./scripts/free-disk-space.sh
+
+      - name: Setup mold linker
+        if: matrix.target.os == 'ubuntu-latest'
+        uses: rui314/setup-mold@v1
+
+      - name: Install nasm
+        if: matrix.target.os == 'windows-latest'
+        uses: ilammy/setup-nasm@v1.5.2
+
+      - name: Install OpenSSL
+        if: matrix.target.os == 'windows-latest'
+        shell: bash
+        run: |
+          set -e
+          choco install openssl --version=1.1.1.2100 -y --no-progress
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' >> $GITHUB_ENV
+          echo "RUSTFLAGS=-C target-feature=+crt-static" >> $GITHUB_ENV
+
+      - name: Install Rust (${{ matrix.version.name }})
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: ${{ matrix.version.version }}
+
+      - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
+
+      - name: Generate Cargo.lock
+        run: cargo generate-lockfile
+
+      - name: workaround MSRV issues
+        if: matrix.version.name == 'msrv'
+        run: just downgrade-for-msrv
+
+      - name: check lib
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: cargo ci-check-lib
+      - name: check lib
+        if: matrix.target.os == 'ubuntu-latest'
+        run: cargo ci-check-lib-linux
+      - name: check lib
+        if: matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: cargo ci-check-min
+
+      - name: check full
+        # TODO: compile OpenSSL and run tests on MinGW
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: cargo ci-check
+      - name: check all
+        if: matrix.target.os == 'ubuntu-latest'
+        run: cargo ci-check-linux
+
+      - name: tests
+        run: just test
+
+      - name: CI cache clean
+        run: cargo-ci-cache-clean
+
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust (nightly)
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: nightly
+
+      - name: Install just
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: just
+
+      - name: doc tests
+        run: just test-docs

.github/workflows/coverage.yml

@@ -0,0 +1,39 @@
+name: Coverage
+
+on:
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          components: llvm-tools-preview
+
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: cargo-llvm-cov
+
+      - name: Generate code coverage
+        run: cargo llvm-cov --workspace --all-features --codecov --output-path codecov.json
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5.4.0
+        with:
+          files: codecov.json
+          fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/lint.yml

@@ -0,0 +1,69 @@
+name: Lint
+
+on:
+  pull_request: {}
+  merge_group: { types: [checks_requested] }
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: nightly
+          components: rustfmt
+
+      - name: Rustfmt Check
+        run: cargo fmt --all -- --check
+
+  clippy:
+    permissions:
+      contents: write
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with: { components: clippy }
+
+      - uses: giraffate/clippy-action@v1.0.1
+        with:
+          reporter: "github-pr-check"
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          clippy_flags: --workspace --all-features --tests --examples --bins -- -Dclippy::todo -Aunknown_lints
+
+  check-external-types:
+    if: false # rustdoc mismatch currently
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust (${{ vars.RUST_VERSION_EXTERNAL_TYPES }})
+        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        with:
+          toolchain: ${{ vars.RUST_VERSION_EXTERNAL_TYPES }}
+
+      - name: Install just
+        uses: taiki-e/install-action@v2.49.40
+        with:
+          tool: just
+
+      - name: Install cargo-check-external-types
+        uses: taiki-e/cache-cargo-install-action@v2.1.1
+        with:
+          tool: cargo-check-external-types
+
+      - name: check external types
+        run: just check-external-types-all +${{ vars.RUST_VERSION_EXTERNAL_TYPES }}

.gitignore

@@ -1,4 +1,3 @@
-Cargo.lock
 target/
 guide/build/
 /gh-pages
@@ -12,3 +11,9 @@ guide/build/
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+# IDEs
+.idea
+
+# direnv
+/.direnv

.rustfmt.toml

@@ -0,0 +1,3 @@
+group_imports = "StdExternalCrate"
+imports_granularity = "Crate"
+use_field_init_shorthand = true

.taplo.toml

@@ -0,0 +1,29 @@
+exclude = ["target/*"]
+include = ["**/*.toml"]
+
+[formatting]
+column_width = 110
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = [
+  "dependencies",
+  "*-dependencies",
+  "workspace.dependencies",
+  "workspace.*-dependencies",
+  "target.*.dependencies",
+  "target.*.*-dependencies",
+]
+formatting.reorder_keys = true
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = [
+  "dependencies.*",
+  "*-dependencies.*",
+  "workspace.dependencies.*",
+  "workspace.*-dependencies.*",
+  "target.*.dependencies",
+  "target.*.*-dependencies",
+]
+formatting.reorder_keys = false

.travis.yml

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

CHANGES.md

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

CODE_OF_CONDUCT.md

@@ -8,19 +8,19 @@ In the interest of fostering an open and welcoming environment, we as contributo
 
 Examples of behavior that contributes to creating a positive environment include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 
@@ -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

@@ -1,90 +1,44 @@
-[package]
-name = "actix-net"
-version = "0.3.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix net - framework for the compisible network services for Rust (experimental)"
-readme = "README.md"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-net/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-
 [workspace]
+resolver = "2"
 members = [
-  "./",
+  "actix-codec",
+  "actix-macros",
+  "actix-rt",
+  "actix-server",
   "actix-service",
+  "actix-tls",
+  "actix-tracing",
+  "actix-utils",
+  "bytestring",
+  "local-channel",
+  "local-waker",
 ]
 
-[package.metadata.docs.rs]
-features = ["ssl", "tls", "rust-tls"]
+[workspace.package]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.71.1"
 
-[badges]
-travis-ci = { repository = "actix/actix-net", branch = "master" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
-codecov = { repository = "actix/actix-net", branch = "master", service = "github" }
-
-[lib]
-name = "actix_net"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# tls
-tls = ["native-tls"]
-
-# openssl
-ssl = ["openssl", "tokio-openssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
-
-cell = []
-
-[dependencies]
-actix = "0.7.6"
-actix-service = "0.1.1"
-
-log = "0.4"
-num_cpus = "1.0"
-
-# io
-mio = "^0.6.13"
-net2 = "0.2"
-bytes = "0.4"
-futures = "0.1"
-slab = "0.4"
-tokio = "0.1"
-tokio-codec = "0.1"
-tokio-io = "0.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2"
-tokio-reactor = "0.1"
-tokio-current-thread = "0.1"
-trust-dns-proto = "^0.5.0"
-trust-dns-resolver = "^0.10.0"
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.2", optional = true }
-
-#rustls
-rustls = { version = "^0.14", optional = true }
-tokio-rustls = { version = "^0.8", optional = true }
-webpki = { version = "0.18", optional = true }
-webpki-roots = { version = "0.15", optional = true }
-
-[dev-dependencies]
-env_logger = "0.5"
+[patch.crates-io]
+actix-codec = { path = "actix-codec" }
+actix-macros = { path = "actix-macros" }
+actix-rt = { path = "actix-rt" }
+actix-server = { path = "actix-server" }
+actix-service = { path = "actix-service" }
+actix-tls = { path = "actix-tls" }
+actix-tracing = { path = "actix-tracing" }
+actix-utils = { path = "actix-utils" }
+bytestring = { path = "bytestring" }
+local-channel = { path = "local-channel" }
+local-waker = { path = "local-waker" }
 
 [profile.release]
 lto = true
 opt-level = 3
 codegen-units = 1
+
+[workspace.lints.rust]
+rust_2018_idioms = "deny"
+nonstandard-style = "deny"
+future_incompatible = "deny"
+missing_docs = { level = "warn", priority = -1 }

LICENSE-APACHE

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

LICENSE-MIT

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

README.md

@@ -1,76 +1,30 @@
-# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix Net
 
-Actix net - framework for composable network services (experimental)
+> A collection of lower-level libraries for composable network services.
 
-## Documentation & community resources
+[![CI](https://github.com/actix/actix-net/actions/workflows/ci.yml/badge.svg?event=push&style=flat-square)](https://github.com/actix/actix-net/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/actix/actix-net/graph/badge.svg?token=8rKIZKtLLm)](https://codecov.io/gh/actix/actix-net)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+[![Dependency Status](https://deps.rs/repo/github/actix/actix-net/status.svg)](https://deps.rs/repo/github/actix/actix-net)
 
-* [API Documentation (Development)](https://actix.rs/actix-net/actix_net/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-net](https://crates.io/crates/actix-net)
-* Minimum supported Rust version: 1.26 or later
+## Examples
 
-## Example
+See example folders for [`actix-server`](./actix-server/examples) and [`actix-tls`](./actix-tls/examples).
 
-```rust
-fn main() {
-    let sys = actix::System::new("test");
+## MSRV
 
-    // load ssl keys
-    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
-    builder.set_private_key_file("./examples/key.pem", SslFiletype::PEM).unwrap();
-    builder.set_certificate_chain_file("./examples/cert.pem").unwrap();
-    let acceptor = builder.build();
-
-    let num = Arc::new(AtomicUsize::new(0));
-
-    // bind socket address and start workers. By default server uses number of
-    // available logical cpu as threads count. actix net start separate
-    // instances of service pipeline in each worker.
-    Server::default()
-        .bind(
-            // configure service pipeline
-            "basic", "0.0.0.0:8443",
-            move || {
-                let num = num.clone();
-                let acceptor = acceptor.clone();
-
-                // service for converting incoming TcpStream to a SslStream<TcpStream>
-                (move |stream| {
-                SslAcceptorExt::accept_async(&acceptor, stream)
-                    .map_err(|e| println!("Openssl error: {}", e))
-            })
-            // convert closure to a `NewService`
-            .into_new_service()
-
-            // .and_then() combinator uses other service to convert incoming `Request` to a `Response`
-            // and then uses that response as an input for next service.
-            // in this case, on success we use `logger` service
-            .and_then(logger)
-
-            // Next service counts number of connections
-            .and_then(move |req| {
-                let num = num.fetch_add(1, Ordering::Relaxed);
-                println!("processed {:?} connections", num);
-                future::ok(())
-            })
-        }).unwrap()
-        .start();
-
-    sys.run();
-}
-```
+Crates in this repo currently have a Minimum Supported Rust Version (MSRV) of 1.65. As a policy, we permit MSRV increases in non-breaking releases.
 
 ## License
 
-This project is licensed under either of
+The crates in repo are licensed under either of:
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-net crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-net, @fafhrd91, promises to
-intervene to uphold that code of conduct.
+Contribution to the actix-net repo is organized under the terms of the Contributor Covenant.
+The Actix team promises to intervene to uphold that code of conduct.

actix-codec/CHANGES.md

@@ -0,0 +1,85 @@
+# Changes
+
+## Unreleased
+
+- Minimum supported Rust version (MSRV) is now 1.71.
+
+## 0.5.2
+
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 0.5.1
+
+- Logs emitted now use the `tracing` crate with `log` compatibility.
+- Minimum supported Rust version (MSRV) is now 1.49.
+
+## 0.5.0
+
+- Updated `tokio-util` dependency to `0.7.0`.
+
+## 0.4.2
+
+- No significant changes since `0.4.1`.
+
+## 0.4.1
+
+- Added `LinesCodec`.
+- `Framed::poll_ready` flushes when the buffer is full.
+
+## 0.4.0
+
+- No significant changes since v0.4.0-beta.1.
+
+## 0.4.0-beta.1
+
+- Replace `pin-project` with `pin-project-lite`.
+- Upgrade `tokio` dependency to `1`.
+- Upgrade `tokio-util` dependency to `0.6`.
+- Upgrade `bytes` dependency to `1`.
+
+## 0.3.0
+
+- No changes from beta 2.
+
+## 0.3.0-beta.2
+
+- Remove unused type parameter from `Framed::replace_codec`.
+
+## 0.3.0-beta.1
+
+- 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
+
+- Use specific futures dependencies.
+
+## 0.2.0-alpha.4
+
+- Fix buffer remaining capacity calculation.
+
+## 0.2.0-alpha.3
+
+- Use tokio 0.2.
+- Fix low/high watermark for write/read buffers.
+
+## 0.2.0-alpha.2
+
+- Migrated to `std::future`.
+
+## 0.1.2
+
+- Added `Framed::map_io()` method.
+
+## 0.1.1
+
+- Added `FramedParts::with_read_buffer()` method.
+
+## 0.1.0
+
+- Move codec to separate crate.

actix-codec/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "actix-codec"
+version = "0.5.2"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+description = "Codec utilities for working with framed protocols"
+keywords = ["network", "framework", "async", "futures"]
+repository = "https://github.com/actix/actix-net"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition.workspace = true
+rust-version.workspace = true
+
+[package.metadata.cargo_check_external_types]
+allowed_external_types = ["bytes::*", "futures_core::*", "futures_sink::*", "tokio::*", "tokio_util::*"]
+
+[dependencies]
+bitflags = "2"
+bytes = "1"
+futures-core = { version = "0.3.7", default-features = false }
+futures-sink = { version = "0.3.7", default-features = false }
+memchr = "2.3"
+pin-project-lite = "0.2"
+tokio = "1.23.1"
+tokio-util = { version = "0.7", features = ["codec", "io"] }
+tracing = { version = "0.1.30", default-features = false, features = ["log"] }
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
+tokio-test = "0.4.2"
+
+[[bench]]
+name = "lines"
+harness = false
+
+[lints]
+workspace = true

actix-codec/LICENSE-APACHE

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

actix-codec/LICENSE-MIT

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

actix-codec/benches/lines.rs

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

actix-codec/benches/lorem.txt

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

actix-codec/src/bcodec.rs

@@ -1,20 +1,19 @@
 use std::io;
 
-use bytes::{Bytes, BytesMut};
-use tokio_codec::{Decoder, Encoder};
+use bytes::{Buf, Bytes, BytesMut};
 
-/// Bytes codec.
-///
-/// Reads/Writes chunks of bytes from a stream.
+use super::{Decoder, Encoder};
+
+/// Bytes codec. Reads/writes chunks of bytes from a stream.
 #[derive(Debug, Copy, Clone)]
 pub struct BytesCodec;
 
-impl Encoder for BytesCodec {
-    type Item = Bytes;
+impl Encoder<Bytes> for BytesCodec {
     type Error = io::Error;
 
+    #[inline]
     fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.extend_from_slice(&item[..]);
+        dst.extend_from_slice(item.chunk());
         Ok(())
     }
 }
@@ -27,7 +26,7 @@ impl Decoder for BytesCodec {
         if src.is_empty() {
             Ok(None)
         } else {
-            Ok(Some(src.take()))
+            Ok(Some(src.split()))
         }
     }
 }

actix-codec/src/framed.rs

@@ -0,0 +1,412 @@
+use std::{
+    fmt, io,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bitflags::bitflags;
+use bytes::{Buf, BytesMut};
+use futures_core::{ready, Stream};
+use futures_sink::Sink;
+use pin_project_lite::pin_project;
+
+use crate::{AsyncRead, AsyncWrite, Decoder, Encoder};
+
+/// Low-water mark
+const LW: usize = 1024;
+/// High-water mark
+const HW: usize = 8 * 1024;
+
+bitflags! {
+    #[derive(Debug, Clone, Copy)]
+    struct Flags: u8 {
+        const EOF = 0b0001;
+        const READABLE = 0b0010;
+    }
+}
+
+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> Framed<T, U>
+where
+    T: AsyncRead + AsyncWrite,
+    U: Decoder,
+{
+    /// This function returns a *single* object that is both `Stream` and `Sink`; grouping this into
+    /// a single object is often useful for layering things like gzip or TLS, which require both
+    /// read and write access to the underlying object.
+    pub fn new(io: T, codec: U) -> Framed<T, U> {
+        Framed {
+            io,
+            codec,
+            flags: Flags::empty(),
+            read_buf: BytesMut::with_capacity(HW),
+            write_buf: BytesMut::with_capacity(HW),
+        }
+    }
+}
+
+impl<T, U> Framed<T, U> {
+    /// Returns a reference to the underlying codec.
+    pub fn codec_ref(&self) -> &U {
+        &self.codec
+    }
+
+    /// Returns a mutable reference to the underlying codec.
+    pub fn codec_mut(&mut self) -> &mut U {
+        &mut self.codec
+    }
+
+    /// Returns a reference to the underlying I/O stream wrapped by `Frame`.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
+    pub fn io_ref(&self) -> &T {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying I/O stream.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
+    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()
+    }
+
+    /// Check if write buffer is full.
+    pub fn is_write_buf_full(&self) -> bool {
+        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 replace_codec<U2>(self, codec: U2) -> Framed<T, U2> {
+        Framed {
+            codec,
+            io: self.io,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+
+    /// Consume the `Frame`, returning `Frame` with different io.
+    pub fn into_map_io<F, T2>(self, f: F) -> Framed<T2, U>
+    where
+        F: Fn(T) -> T2,
+    {
+        Framed {
+            io: f(self.io),
+            codec: self.codec,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+
+    /// Consume the `Frame`, returning `Frame` with different codec.
+    pub fn into_map_codec<F, U2>(self, f: F) -> Framed<T, U2>
+    where
+        F: Fn(U) -> U2,
+    {
+        Framed {
+            io: self.io,
+            codec: f(self.codec),
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+}
+
+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 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(this.read_buf) {
+                        Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
+                        Ok(None) => return Poll::Ready(None),
+                        Err(err) => return Poll::Ready(Some(Err(err))),
+                    }
+                }
+
+                tracing::trace!("attempting to decode a frame");
+
+                match this.codec.decode(this.read_buf) {
+                    Ok(Some(frame)) => {
+                        tracing::trace!("frame decoded from buffer");
+                        return Poll::Ready(Some(Ok(frame)));
+                    }
+                    Err(err) => return Poll::Ready(Some(Err(err))),
+                    _ => (), // 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(err)) => return Poll::Ready(Some(Err(err.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();
+        tracing::trace!("flushing framed transport");
+
+        while !this.write_buf.is_empty() {
+            tracing::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))?;
+
+        tracing::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>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.is_write_ready() {
+            Poll::Ready(Ok(()))
+        } else {
+            self.flush(cx)
+        }
+    }
+
+    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.
+    ///
+    /// Note that care should be taken to not tamper with the underlying stream of data coming in as
+    /// it may corrupt the stream of frames otherwise being worked with.
+    pub fn into_parts(self) -> FramedParts<T, U> {
+        FramedParts {
+            io: self.io,
+            codec: self.codec,
+            flags: self.flags,
+            read_buf: self.read_buf,
+            write_buf: self.write_buf,
+        }
+    }
+}
+
+/// `FramedParts` contains an export of the data of a Framed transport.
+///
+/// It can be used to construct a new `Framed` with a different codec. It contains all current
+/// buffers and the inner transport.
+#[derive(Debug)]
+pub struct FramedParts<T, U> {
+    /// The inner transport used to read bytes to and write bytes to.
+    pub io: T,
+
+    /// The codec object.
+    pub codec: U,
+
+    /// The buffer with read but unprocessed data.
+    pub read_buf: BytesMut,
+
+    /// A buffer with unprocessed data which are not written yet.
+    pub write_buf: BytesMut,
+
+    flags: Flags,
+}
+
+impl<T, U> FramedParts<T, U> {
+    /// Creates a new default `FramedParts`.
+    pub fn new(io: T, codec: U) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            flags: Flags::empty(),
+            read_buf: BytesMut::new(),
+            write_buf: BytesMut::new(),
+        }
+    }
+
+    /// Creates a new `FramedParts` with read buffer.
+    pub fn with_read_buf(io: T, codec: U, read_buf: BytesMut) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            read_buf,
+            flags: Flags::empty(),
+            write_buf: BytesMut::new(),
+        }
+    }
+}

actix-codec/src/lib.rs

@@ -0,0 +1,26 @@
+//! 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`.
+//!
+//! [`Sink`]: futures_sink::Sink
+//! [`Stream`]: futures_core::Stream
+
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+pub use tokio_util::{
+    codec::{Decoder, Encoder},
+    io::poll_read_buf,
+};
+
+mod bcodec;
+mod framed;
+mod lines;
+
+pub use self::{
+    bcodec::BytesCodec,
+    framed::{Framed, FramedParts},
+    lines::LinesCodec,
+};

actix-codec/src/lines.rs

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

actix-codec/tests/test_framed_sink.rs

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

actix-macros/.gitignore

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

actix-macros/CHANGES.md

@@ -0,0 +1,53 @@
+# Changes
+
+## Unreleased
+
+- Minimum supported Rust version (MSRV) is now 1.71.
+
+## 0.2.4
+
+- Update `syn` dependency to `2`.
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 0.2.3
+
+- Fix test macro in presence of other imports named "test". [#399]
+
+[#399]: https://github.com/actix/actix-net/pull/399
+
+## 0.2.2
+
+- Improve error recovery potential when macro input is invalid. [#391]
+- Allow custom `System`s on test macro. [#391]
+
+[#391]: https://github.com/actix/actix-net/pull/391
+
+## 0.2.1
+
+- Add optional argument `system` to `main` macro which can be used to specify the path to `actix_rt::System` (useful for re-exports). [#363]
+
+[#363]: https://github.com/actix/actix-net/pull/363
+
+## 0.2.0
+
+- Update to latest `actix_rt::System::new` signature. [#261]
+
+[#261]: https://github.com/actix/actix-net/pull/261
+
+## 0.2.0-beta.1
+
+- Remove `actix-reexport` feature. [#218]
+
+[#218]: https://github.com/actix/actix-net/pull/218
+
+## 0.1.3
+
+- Add `actix-reexport` feature. [#218]
+
+[#218]: https://github.com/actix/actix-net/pull/218
+
+## 0.1.2
+
+- Forward actix_rt::test arguments to test function [#127]
+
+[#127]: https://github.com/actix/actix-net/pull/127

actix-macros/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "actix-macros"
+version = "0.2.4"
+authors = [
+  "Nikolay Kim <fafhrd91@gmail.com>",
+  "Ibraheem Ahmed <ibrah1440@gmail.com>",
+  "Rob Ede <robjtede@icloud.com>",
+]
+description = "Macros for Actix system and runtime"
+repository = "https://github.com/actix/actix-net"
+categories = ["network-programming", "asynchronous"]
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = [
+  "proc_macro2", # specified for minimal versions compat
+]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1"
+syn = { version = "2", features = ["full"] }
+
+# minimal versions compat
+[target.'cfg(any())'.dependencies]
+proc-macro2 = "1.0.60"
+
+[dev-dependencies]
+actix-rt = "2"
+futures-util = { version = "0.3.17", default-features = false }
+rustversion-msrv = "0.100"
+trybuild = "1"
+
+[lints]
+workspace = true

actix-macros/LICENSE-APACHE

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

actix-macros/LICENSE-MIT

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

actix-macros/src/lib.rs

@@ -0,0 +1,219 @@
+//! Macros for Actix system and runtime.
+//!
+//! The [`actix-rt`](https://docs.rs/actix-rt) crate must be available for macro output to compile.
+//!
+//! # Entry-point
+//! See docs for the [`#[main]`](macro@main) macro.
+//!
+//! # Tests
+//! See docs for the [`#[test]`](macro@test) macro.
+
+#![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;
+use syn::parse::Parser as _;
+
+type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![,]>;
+
+/// Marks async entry-point function to be executed by Actix system.
+///
+/// # Examples
+/// ```
+/// #[actix_rt::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
+        Ok(input) => input,
+        // on parse err, make IDEs happy; see fn docs
+        Err(err) => return input_and_compile_error(item, err),
+    };
+
+    let parser = AttributeArgs::parse_terminated;
+    let args = match parser.parse(args.clone()) {
+        Ok(args) => args,
+        Err(err) => return input_and_compile_error(args, err),
+    };
+
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+    let sig = &mut input.sig;
+    let body = &input.block;
+
+    if sig.asyncness.is_none() {
+        return syn::Error::new_spanned(
+            sig.fn_token,
+            "the async keyword is missing from the function declaration",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let mut system = syn::parse_str::<syn::Path>("::actix_rt::System").unwrap();
+
+    for arg in &args {
+        match arg {
+            syn::Meta::NameValue(syn::MetaNameValue {
+                path,
+                value:
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }),
+                ..
+            }) => match path
+                .get_ident()
+                .map(|i| i.to_string().to_lowercase())
+                .as_deref()
+            {
+                Some("system") => match lit.parse() {
+                    Ok(path) => system = path,
+                    Err(_) => {
+                        return syn::Error::new_spanned(lit, "Expected path")
+                            .to_compile_error()
+                            .into();
+                    }
+                },
+                _ => {
+                    return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                        .to_compile_error()
+                        .into();
+                }
+            },
+
+            _ => {
+                return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                    .to_compile_error()
+                    .into();
+            }
+        }
+    }
+
+    sig.asyncness = None;
+
+    (quote! {
+        #(#attrs)*
+        #vis #sig {
+            <#system>::new().block_on(async move { #body })
+        }
+    })
+    .into()
+}
+
+/// Marks async test function to be executed in an Actix system.
+///
+/// # Examples
+/// ```
+/// #[actix_rt::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
+        Ok(input) => input,
+        // on parse err, make IDEs happy; see fn docs
+        Err(err) => return input_and_compile_error(item, err),
+    };
+
+    let parser = AttributeArgs::parse_terminated;
+    let args = match parser.parse(args.clone()) {
+        Ok(args) => args,
+        Err(err) => return input_and_compile_error(args, err),
+    };
+
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let mut has_test_attr = false;
+
+    for attr in attrs {
+        if attr.path().is_ident("test") {
+            has_test_attr = true;
+        }
+    }
+
+    if sig.asyncness.is_none() {
+        return syn::Error::new_spanned(
+            input.sig.fn_token,
+            "the async keyword is missing from the function declaration",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    sig.asyncness = None;
+
+    let missing_test_attr = if has_test_attr {
+        quote! {}
+    } else {
+        quote! { #[::core::prelude::v1::test] }
+    };
+
+    let mut system = syn::parse_str::<syn::Path>("::actix_rt::System").unwrap();
+
+    for arg in &args {
+        match arg {
+            syn::Meta::NameValue(syn::MetaNameValue {
+                path,
+                value:
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }),
+                ..
+            }) => match path
+                .get_ident()
+                .map(|i| i.to_string().to_lowercase())
+                .as_deref()
+            {
+                Some("system") => match lit.parse() {
+                    Ok(path) => system = path,
+                    Err(_) => {
+                        return syn::Error::new_spanned(lit, "Expected path")
+                            .to_compile_error()
+                            .into();
+                    }
+                },
+                _ => {
+                    return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                        .to_compile_error()
+                        .into();
+                }
+            },
+            _ => {
+                return syn::Error::new_spanned(arg, "Unknown attribute specified")
+                    .to_compile_error()
+                    .into();
+            }
+        }
+    }
+
+    (quote! {
+        #missing_test_attr
+        #(#attrs)*
+        #vis #sig {
+            <#system>::new().block_on(async { #body })
+        }
+    })
+    .into()
+}
+
+/// Converts the error to a token stream and appends it to the original input.
+///
+/// Returning the original input in addition to the error is good for IDEs which can gracefully
+/// recover and show more precise errors within the macro body.
+///
+/// See <https://github.com/rust-analyzer/rust-analyzer/issues/10468> for more info.
+fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> TokenStream {
+    let compile_err = TokenStream::from(err.to_compile_error());
+    item.extend(compile_err);
+    item
+}

actix-macros/tests/trybuild.rs

@@ -0,0 +1,21 @@
+#![allow(missing_docs)]
+
+#[rustversion_msrv::msrv]
+#[test]
+fn compile_macros() {
+    let t = trybuild::TestCases::new();
+
+    t.pass("tests/trybuild/main-01-basic.rs");
+    t.compile_fail("tests/trybuild/main-02-only-async.rs");
+    t.pass("tests/trybuild/main-03-fn-params.rs");
+    t.pass("tests/trybuild/main-04-system-path.rs");
+    t.compile_fail("tests/trybuild/main-05-system-expect-path.rs");
+    t.compile_fail("tests/trybuild/main-06-unknown-attr.rs");
+
+    t.pass("tests/trybuild/test-01-basic.rs");
+    t.pass("tests/trybuild/test-02-keep-attrs.rs");
+    t.compile_fail("tests/trybuild/test-03-only-async.rs");
+    t.pass("tests/trybuild/test-04-system-path.rs");
+    t.compile_fail("tests/trybuild/test-05-system-expect-path.rs");
+    t.compile_fail("tests/trybuild/test-06-unknown-attr.rs");
+}

actix-macros/tests/trybuild/main-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,11 @@
+error: the async keyword is missing from the function declaration
+ --> tests/trybuild/main-02-only-async.rs:2:1
+  |
+2 | fn main() {
+  | ^^
+
+error[E0601]: `main` function not found in crate `$CRATE`
+ --> tests/trybuild/main-02-only-async.rs:4:2
+  |
+4 | }
+  |  ^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs`

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

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

actix-macros/tests/trybuild/main-04-system-path.rs

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

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

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

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

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

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

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

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

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

actix-macros/tests/trybuild/test-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-macros/tests/trybuild/test-03-only-async.rs

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

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

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

actix-macros/tests/trybuild/test-04-system-path.rs

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

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

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

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

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

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

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

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

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

actix-rt/CHANGES.md

@@ -0,0 +1,174 @@
+# Changes
+
+## Unreleased
+
+- Minimum supported Rust version (MSRV) is now 1.71.
+
+## 2.10.0
+
+- Relax `F`'s bound (`Fn => FnOnce`) on `{Arbiter, System}::with_tokio_rt()` functions.
+- Update `tokio-uring` dependency to `0.5`.
+- Minimum supported Rust version (MSRV) is now 1.70.
+
+## 2.9.0
+
+- Add `actix_rt::System::runtime()` method to retrieve the underlying `actix_rt::Runtime` runtime.
+- Add `actix_rt::Runtime::tokio_runtime()` method to retrieve the underlying Tokio runtime.
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 2.8.0
+
+- Add `#[track_caller]` attribute to `spawn` functions and methods.
+- Update `tokio-uring` dependency to `0.4`.
+- Minimum supported Rust version (MSRV) is now 1.59.
+
+## 2.7.0
+
+- Update `tokio-uring` dependency to `0.3`.
+- Minimum supported Rust version (MSRV) is now 1.49.
+
+## 2.6.0
+
+- Update `tokio-uring` dependency to `0.2`.
+
+## 2.5.1
+
+- Expose `System::with_tokio_rt` and `Arbiter::with_tokio_rt`.
+
+## 2.5.0
+
+- Add `System::run_with_code` to allow retrieving the exit code on stop.
+
+## 2.4.0
+
+- Add `Arbiter::try_current` for situations where thread may or may not have Arbiter context.
+- Start io-uring with `System::new` when feature is enabled.
+
+## 2.3.0
+
+- The `spawn` method can now resolve with non-unit outputs.
+- Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux.
+
+## 2.2.0
+
+- **BREAKING** `ActixStream::{poll_read_ready, poll_write_ready}` methods now return `Ready` object in ok variant.
+  - Breakage is acceptable since `ActixStream` was not intended to be public.
+
+## 2.1.0
+
+- Add `ActixStream` extension trait to include readiness methods.
+- Re-export `tokio::net::TcpSocket` in `net` module
+
+## 2.0.2
+
+- Add `Arbiter::handle` to get a handle of an owned Arbiter.
+- Add `System::try_current` for situations where actix may or may not be running a System.
+
+## 2.0.1
+
+- Expose `JoinError` from Tokio.
+
+## 2.0.0
+
+- Remove all Arbiter-local storage methods.
+- Re-export `tokio::pin`.
+
+## 2.0.0-beta.3
+
+- Remove `run_in_tokio`, `attach_to_tokio` and `AsyncSystemRunner`.
+- Return `JoinHandle` from `actix_rt::spawn`.
+- Remove old `Arbiter::spawn`. Implementation is now inlined into `actix_rt::spawn`.
+- Rename `Arbiter::{send => spawn}` and `Arbiter::{exec_fn => spawn_fn}`.
+- Remove `Arbiter::exec`.
+- Remove deprecated `Arbiter::local_join` and `Arbiter::is_running`.
+- `Arbiter::spawn` now accepts !Unpin futures.
+- `System::new` no longer takes arguments.
+- Remove `System::with_current`.
+- Remove `Builder`.
+- Add `System::with_init` as replacement for `Builder::run`.
+- Rename `System::{is_set => is_registered}`.
+- Add `ArbiterHandle` for sending messages to non-current-thread arbiters.
+- `System::arbiter` now returns an `&ArbiterHandle`.
+- `Arbiter::current` now returns an `ArbiterHandle` instead.
+- `Arbiter::join` now takes self by value.
+
+## 2.0.0-beta.2
+
+- Add `task` mod with re-export of `tokio::task::{spawn_blocking, yield_now, JoinHandle}`
+- Add default "macros" feature to allow faster compile times when using `default-features=false`.
+
+## 2.0.0-beta.1
+
+- Add `System::attach_to_tokio` method.
+- Update `tokio` dependency to `1.0`.
+- Rename `time` module `delay_for` to `sleep`, `delay_until` to `sleep_until`, `Delay` to `Sleep` to stay aligned with Tokio's naming.
+- Remove `'static` lifetime requirement for `Runtime::block_on` and `SystemRunner::block_on`.
+  - These methods now accept `&self` when calling.
+- Remove `'static` lifetime requirement for `System::run` and `Builder::run`.
+- `Arbiter::spawn` now panics when `System` is not in scope.
+- Fix work load issue by removing `PENDING` thread local.
+
+## 1.1.1
+
+- Fix memory leak due to
+
+## 1.1.0 _(YANKED)_
+
+- Expose `System::is_set` to check if current system has ben started
+- Add `Arbiter::is_running` to check if event loop is running
+- Add `Arbiter::local_join` associated function to get be able to `await` for spawned futures
+
+## 1.0.0
+
+- Update dependencies
+
+## 1.0.0-alpha.3
+
+- Migrate to tokio 0.2
+- Fix compilation on non-unix platforms
+
+## 1.0.0-alpha.2
+
+- Export `main` and `test` attribute macros
+- Export `time` module (re-export of tokio-timer)
+- Export `net` module (re-export of tokio-net)
+
+## 1.0.0-alpha.1
+
+- Migrate to std::future and tokio 0.2
+
+## 0.2.6
+
+- Allow to join arbiter's thread. #60
+- Fix arbiter's thread panic message.
+
+## 0.2.5
+
+- Add arbiter specific storage
+
+## 0.2.4
+
+- Avoid a copy of the Future when initializing the Box. #29
+
+## 0.2.3
+
+- Allow to start System using existing CurrentThread Handle #22
+
+## 0.2.2
+
+- Moved `blocking` module to `actix-threadpool` crate
+
+## 0.2.1
+
+- Added `blocking` module
+- Added `Arbiter::exec_fn` - execute fn on the arbiter's thread
+- Added `Arbiter::exec` - execute fn on the arbiter's thread and wait result
+
+## 0.2.0
+
+- `run` method returns `io::Result<()>`
+- Removed `Handle`
+
+## 0.1.0
+
+- Initial release

actix-rt/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "actix-rt"
+version = "2.10.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+description = "Tokio-based single-threaded async runtime for the Actix ecosystem"
+keywords = ["async", "futures", "io", "runtime"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net"
+categories = ["network-programming", "asynchronous"]
+license = "MIT OR Apache-2.0"
+edition.workspace = true
+rust-version.workspace = true
+
+[package.metadata.cargo_check_external_types]
+allowed_external_types = ["actix_macros::*", "tokio::*"]
+
+[features]
+default = ["macros"]
+macros = ["actix-macros"]
+io-uring = ["tokio-uring"]
+
+[dependencies]
+actix-macros = { version = "0.2.3", optional = true }
+
+futures-core = { version = "0.3", default-features = false }
+tokio = { version = "1.23.1", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }
+
+# runtime for `io-uring` feature
+[target.'cfg(target_os = "linux")'.dependencies]
+tokio-uring = { version = "0.5", optional = true }
+
+[dev-dependencies]
+tokio = { version = "1.23.1", features = ["full"] }
+
+[lints]
+workspace = true

actix-rt/LICENSE-APACHE

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

actix-rt/LICENSE-MIT

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

actix-rt/README.md

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

actix-rt/examples/multi_thread_system.rs

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

actix-rt/src/arbiter.rs

@@ -0,0 +1,317 @@
+use std::{
+    cell::RefCell,
+    fmt,
+    future::Future,
+    pin::Pin,
+    sync::atomic::{AtomicUsize, Ordering},
+    task::{Context, Poll},
+    thread,
+};
+
+use futures_core::ready;
+use tokio::sync::mpsc;
+
+use crate::system::{System, SystemCommand};
+
+pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
+
+thread_local!(
+    static HANDLE: RefCell<Option<ArbiterHandle>> = const { RefCell::new(None) };
+);
+
+pub(crate) enum ArbiterCommand {
+    Stop,
+    Execute(Pin<Box<dyn Future<Output = ()> + Send>>),
+}
+
+impl fmt::Debug for ArbiterCommand {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
+            ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+        }
+    }
+}
+
+/// A handle for sending spawn and stop messages to an [Arbiter].
+#[derive(Debug, Clone)]
+pub struct ArbiterHandle {
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
+}
+
+impl ArbiterHandle {
+    pub(crate) fn new(tx: mpsc::UnboundedSender<ArbiterCommand>) -> Self {
+        Self { tx }
+    }
+
+    /// Send a future to the [Arbiter]'s thread and spawn it.
+    ///
+    /// If you require a result, include a response channel in the future.
+    ///
+    /// Returns true if future was sent successfully and false if the [Arbiter] has died.
+    pub fn spawn<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        self.tx
+            .send(ArbiterCommand::Execute(Box::pin(future)))
+            .is_ok()
+    }
+
+    /// Send a function to the [Arbiter]'s thread and execute it.
+    ///
+    /// Any result from the function is discarded. If you require a result, include a response
+    /// channel in the function.
+    ///
+    /// Returns true if function was sent successfully and false if the [Arbiter] has died.
+    pub fn spawn_fn<F>(&self, f: F) -> bool
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        self.spawn(async { f() })
+    }
+
+    /// Instruct [Arbiter] to stop processing it's event loop.
+    ///
+    /// Returns true if stop message was sent successfully and false if the [Arbiter] has
+    /// been dropped.
+    pub fn stop(&self) -> bool {
+        self.tx.send(ArbiterCommand::Stop).is_ok()
+    }
+}
+
+/// An Arbiter represents a thread that provides an asynchronous execution environment for futures
+/// and functions.
+///
+/// When an arbiter is created, it spawns a new [OS thread](thread), and hosts an event loop.
+#[derive(Debug)]
+pub struct Arbiter {
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
+    thread_handle: thread::JoinHandle<()>,
+}
+
+impl Arbiter {
+    /// Spawn a new Arbiter thread and start its event loop.
+    ///
+    /// # Panics
+    /// Panics if a [System] is not registered on the current thread.
+    #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Arbiter {
+        Self::with_tokio_rt(|| {
+            crate::runtime::default_tokio_runtime().expect("Cannot create new Arbiter's Runtime.")
+        })
+    }
+
+    /// Spawn a new Arbiter using the [Tokio Runtime](tokio-runtime) returned from a closure.
+    ///
+    /// [tokio-runtime]: tokio::runtime::Runtime
+    #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+    pub fn with_tokio_rt<F>(runtime_factory: F) -> Arbiter
+    where
+        F: FnOnce() -> tokio::runtime::Runtime + Send + 'static,
+    {
+        let sys = System::current();
+        let system_id = sys.id();
+        let arb_id = COUNT.fetch_add(1, Ordering::Relaxed);
+
+        let name = format!("actix-rt|system:{}|arbiter:{}", system_id, arb_id);
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel::<()>();
+
+        let thread_handle = thread::Builder::new()
+            .name(name.clone())
+            .spawn({
+                let tx = tx.clone();
+                move || {
+                    let rt = crate::runtime::Runtime::from(runtime_factory());
+                    let hnd = ArbiterHandle::new(tx);
+
+                    System::set_current(sys);
+
+                    HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+                    // register arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::RegisterArbiter(arb_id, hnd));
+
+                    ready_tx.send(()).unwrap();
+
+                    // run arbiter event processing loop
+                    rt.block_on(ArbiterRunner { rx });
+
+                    // deregister arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::DeregisterArbiter(arb_id));
+                }
+            })
+            .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}"));
+
+        ready_rx.recv().unwrap();
+
+        Arbiter { tx, thread_handle }
+    }
+
+    /// Spawn a new Arbiter thread and start its event loop with `tokio-uring` runtime.
+    ///
+    /// # Panics
+    /// Panics if a [System] is not registered on the current thread.
+    #[cfg(all(target_os = "linux", feature = "io-uring"))]
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Arbiter {
+        let sys = System::current();
+        let system_id = sys.id();
+        let arb_id = COUNT.fetch_add(1, Ordering::Relaxed);
+
+        let name = format!("actix-rt|system:{}|arbiter:{}", system_id, arb_id);
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel::<()>();
+
+        let thread_handle = thread::Builder::new()
+            .name(name.clone())
+            .spawn({
+                let tx = tx.clone();
+                move || {
+                    let hnd = ArbiterHandle::new(tx);
+
+                    System::set_current(sys);
+
+                    HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+                    // register arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::RegisterArbiter(arb_id, hnd));
+
+                    ready_tx.send(()).unwrap();
+
+                    // run arbiter event processing loop
+                    tokio_uring::start(ArbiterRunner { rx });
+
+                    // deregister arbiter
+                    let _ = System::current()
+                        .tx()
+                        .send(SystemCommand::DeregisterArbiter(arb_id));
+                }
+            })
+            .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}"));
+
+        ready_rx.recv().unwrap();
+
+        Arbiter { tx, thread_handle }
+    }
+
+    /// Sets up an Arbiter runner in a new System using the environment's local set.
+    pub(crate) fn in_new_system() -> ArbiterHandle {
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let hnd = ArbiterHandle::new(tx);
+
+        HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
+
+        crate::spawn(ArbiterRunner { rx });
+
+        hnd
+    }
+
+    /// Return a handle to the this Arbiter's message sender.
+    pub fn handle(&self) -> ArbiterHandle {
+        ArbiterHandle::new(self.tx.clone())
+    }
+
+    /// Return a handle to the current thread's Arbiter's message sender.
+    ///
+    /// # Panics
+    /// Panics if no Arbiter is running on the current thread.
+    pub fn current() -> ArbiterHandle {
+        HANDLE.with(|cell| match *cell.borrow() {
+            Some(ref hnd) => hnd.clone(),
+            None => panic!("Arbiter is not running."),
+        })
+    }
+
+    /// Try to get current running arbiter handle.
+    ///
+    /// Returns `None` if no Arbiter has been started.
+    ///
+    /// Unlike [`current`](Self::current), this never panics.
+    pub fn try_current() -> Option<ArbiterHandle> {
+        HANDLE.with(|cell| cell.borrow().clone())
+    }
+
+    /// Stop Arbiter from continuing it's event loop.
+    ///
+    /// Returns true if stop message was sent successfully and false if the Arbiter has been dropped.
+    pub fn stop(&self) -> bool {
+        self.tx.send(ArbiterCommand::Stop).is_ok()
+    }
+
+    /// Send a future to the Arbiter's thread and spawn it.
+    ///
+    /// If you require a result, include a response channel in the future.
+    ///
+    /// Returns true if future was sent successfully and false if the Arbiter has died.
+    #[track_caller]
+    pub fn spawn<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        self.tx
+            .send(ArbiterCommand::Execute(Box::pin(future)))
+            .is_ok()
+    }
+
+    /// Send a function to the Arbiter's thread and execute it.
+    ///
+    /// Any result from the function is discarded. If you require a result, include a response
+    /// channel in the function.
+    ///
+    /// Returns true if function was sent successfully and false if the Arbiter has died.
+    #[track_caller]
+    pub fn spawn_fn<F>(&self, f: F) -> bool
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        self.spawn(async { f() })
+    }
+
+    /// Wait for Arbiter's event loop to complete.
+    ///
+    /// Joins the underlying OS thread handle. See [`JoinHandle::join`](thread::JoinHandle::join).
+    pub fn join(self) -> thread::Result<()> {
+        self.thread_handle.join()
+    }
+}
+
+/// A persistent future that processes [Arbiter] commands.
+struct ArbiterRunner {
+    rx: mpsc::UnboundedReceiver<ArbiterCommand>,
+}
+
+impl Future for ArbiterRunner {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // process all items currently buffered in channel
+        loop {
+            match ready!(self.rx.poll_recv(cx)) {
+                // channel closed; no more messages can be received
+                None => return Poll::Ready(()),
+
+                // process arbiter command
+                Some(item) => match item {
+                    ArbiterCommand::Stop => {
+                        return Poll::Ready(());
+                    }
+                    ArbiterCommand::Execute(task_fut) => {
+                        tokio::task::spawn_local(task_fut);
+                    }
+                },
+            }
+        }
+    }
+}

actix-rt/src/lib.rs

@@ -0,0 +1,207 @@
+//! Tokio-based single-threaded async runtime for the Actix ecosystem.
+//!
+//! In most parts of the the Actix ecosystem, it has been chosen to use !Send futures. For this
+//! reason, a single-threaded runtime is appropriate since it is guaranteed that futures will not
+//! be moved between threads. This can result in small performance improvements over cases where
+//! atomics would otherwise be needed.
+//!
+//! To achieve similar performance to multi-threaded, work-stealing runtimes, applications
+//! using `actix-rt` will create multiple, mostly disconnected, single-threaded runtimes.
+//! This approach has good performance characteristics for workloads where the majority of tasks
+//! have similar runtime expense.
+//!
+//! The disadvantage is that idle threads will not steal work from very busy, stuck or otherwise
+//! backlogged threads. Tasks that are disproportionately expensive should be offloaded to the
+//! blocking task thread-pool using [`task::spawn_blocking`].
+//!
+//! # Examples
+//! ```no_run
+//! use std::sync::mpsc;
+//! use actix_rt::{Arbiter, System};
+//!
+//! let _ = System::new();
+//!
+//! let (tx, rx) = mpsc::channel::<u32>();
+//!
+//! let arbiter = Arbiter::new();
+//! arbiter.spawn_fn(move || tx.send(42).unwrap());
+//!
+//! let num = rx.recv().unwrap();
+//! assert_eq!(num, 42);
+//!
+//! arbiter.stop();
+//! arbiter.join().unwrap();
+//! ```
+//!
+//! # `io-uring` Support
+//!
+//! There is experimental support for using io-uring with this crate by enabling the
+//! `io-uring` feature. For now, it is semver exempt.
+//!
+//! Note that there are currently some unimplemented parts of using `actix-rt` with `io-uring`.
+//! In particular, when running a `System`, only `System::block_on` is supported.
+
+#![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+#[cfg(all(not(target_os = "linux"), feature = "io-uring"))]
+compile_error!("io_uring is a linux only feature.");
+
+use std::future::Future;
+
+// Cannot define a main macro when compiled into test harness.
+// Workaround for https://github.com/rust-lang/rust/issues/62127.
+#[cfg(all(feature = "macros", not(test)))]
+pub use actix_macros::main;
+#[cfg(feature = "macros")]
+pub use actix_macros::test;
+
+mod arbiter;
+mod runtime;
+mod system;
+
+pub use tokio::pin;
+use tokio::task::JoinHandle;
+
+pub use self::{
+    arbiter::{Arbiter, ArbiterHandle},
+    runtime::Runtime,
+    system::{System, SystemRunner},
+};
+
+pub mod signal {
+    //! Asynchronous signal handling (Tokio re-exports).
+
+    #[cfg(unix)]
+    pub mod unix {
+        //! Unix specific signals (Tokio re-exports).
+        pub use tokio::signal::unix::*;
+    }
+    pub use tokio::signal::ctrl_c;
+}
+
+pub mod net {
+    //! TCP/UDP/Unix bindings (mostly Tokio re-exports).
+
+    use std::{
+        future::Future,
+        io,
+        task::{Context, Poll},
+    };
+
+    use tokio::io::{AsyncRead, AsyncWrite, Interest};
+    #[cfg(unix)]
+    pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
+    pub use tokio::{
+        io::Ready,
+        net::{TcpListener, TcpSocket, TcpStream, UdpSocket},
+    };
+
+    /// Extension trait over async read+write types that can also signal readiness.
+    #[doc(hidden)]
+    pub trait ActixStream: AsyncRead + AsyncWrite + Unpin {
+        /// Poll stream and check read readiness of Self.
+        ///
+        /// See [tokio::net::TcpStream::poll_read_ready] for detail on intended use.
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>>;
+
+        /// Poll stream and check write readiness of Self.
+        ///
+        /// See [tokio::net::TcpStream::poll_write_ready] for detail on intended use.
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>>;
+    }
+
+    impl ActixStream for TcpStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::READABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::WRITABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+    }
+
+    #[cfg(unix)]
+    impl ActixStream for UnixStream {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::READABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            let ready = self.ready(Interest::WRITABLE);
+            tokio::pin!(ready);
+            ready.poll(cx)
+        }
+    }
+
+    impl<Io: ActixStream + ?Sized> ActixStream for Box<Io> {
+        fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            (**self).poll_read_ready(cx)
+        }
+
+        fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
+            (**self).poll_write_ready(cx)
+        }
+    }
+}
+
+pub mod time {
+    //! Utilities for tracking time (Tokio re-exports).
+
+    pub use tokio::time::{
+        interval, interval_at, sleep, sleep_until, timeout, Instant, Interval, Sleep, Timeout,
+    };
+}
+
+pub mod task {
+    //! Task management (Tokio re-exports).
+
+    pub use tokio::task::{spawn_blocking, yield_now, JoinError, JoinHandle};
+}
+
+/// Spawns a future on the current thread as a new task.
+///
+/// If not immediately awaited, the task can be cancelled using [`JoinHandle::abort`].
+///
+/// The provided future is spawned as a new task; therefore, panics are caught.
+///
+/// # Panics
+/// Panics if Actix system is not running.
+///
+/// # Examples
+/// ```
+/// # use std::time::Duration;
+/// # actix_rt::Runtime::new().unwrap().block_on(async {
+/// // task resolves successfully
+/// assert_eq!(actix_rt::spawn(async { 1 }).await.unwrap(), 1);
+///
+/// // task panics
+/// assert!(actix_rt::spawn(async {
+///     panic!("panic is caught at task boundary");
+/// })
+/// .await
+/// .unwrap_err()
+/// .is_panic());
+///
+/// // task is cancelled before completion
+/// let handle = actix_rt::spawn(actix_rt::time::sleep(Duration::from_secs(100)));
+/// handle.abort();
+/// assert!(handle.await.unwrap_err().is_cancelled());
+/// # });
+/// ```
+#[track_caller]
+#[inline]
+pub fn spawn<Fut>(f: Fut) -> JoinHandle<Fut::Output>
+where
+    Fut: Future + 'static,
+    Fut::Output: 'static,
+{
+    tokio::task::spawn_local(f)
+}

actix-rt/src/runtime.rs

@@ -0,0 +1,149 @@
+use std::{future::Future, io};
+
+use tokio::task::{JoinHandle, LocalSet};
+
+/// A Tokio-based runtime proxy.
+///
+/// All spawned futures will be executed on the current thread. Therefore, there is no `Send` bound
+/// on submitted futures.
+#[derive(Debug)]
+pub struct Runtime {
+    local: LocalSet,
+    rt: tokio::runtime::Runtime,
+}
+
+pub(crate) fn default_tokio_runtime() -> io::Result<tokio::runtime::Runtime> {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()
+}
+
+impl Runtime {
+    /// Returns a new runtime initialized with default configuration values.
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> io::Result<Self> {
+        let rt = default_tokio_runtime()?;
+
+        Ok(Runtime {
+            rt,
+            local: LocalSet::new(),
+        })
+    }
+
+    /// Offload a future onto the single-threaded runtime.
+    ///
+    /// The returned join handle can be used to await the future's result.
+    ///
+    /// See [crate root][crate] documentation for more details.
+    ///
+    /// # Examples
+    /// ```
+    /// let rt = actix_rt::Runtime::new().unwrap();
+    ///
+    /// // Spawn a future onto the runtime
+    /// let handle = rt.spawn(async {
+    ///     println!("running on the runtime");
+    ///     42
+    /// });
+    ///
+    /// assert_eq!(rt.block_on(handle).unwrap(), 42);
+    /// ```
+    ///
+    /// # Panics
+    /// This function panics if the spawn fails. Failure occurs if the executor is currently at
+    /// capacity and is unable to spawn a new future.
+    #[track_caller]
+    pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
+    where
+        F: Future + 'static,
+    {
+        self.local.spawn_local(future)
+    }
+
+    /// Retrieves a reference to the underlying Tokio runtime associated with this instance.
+    ///
+    /// The Tokio runtime is responsible for executing asynchronous tasks and managing
+    /// the event loop for an asynchronous Rust program. This method allows accessing
+    /// the runtime to interact with its features directly.
+    ///
+    /// In a typical use case, you might need to share the same runtime between different
+    /// modules of your project. For example, a module might require a `tokio::runtime::Handle`
+    /// to spawn tasks on the same runtime, or the runtime itself to configure more complex
+    /// behaviours.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use actix_rt::Runtime;
+    ///
+    /// mod module_a {
+    ///     pub fn do_something(handle: tokio::runtime::Handle) {
+    ///         handle.spawn(async {
+    ///             // Some asynchronous task here
+    ///         });
+    ///     }
+    /// }
+    ///
+    /// mod module_b {
+    ///     pub fn do_something_else(rt: &tokio::runtime::Runtime) {
+    ///         rt.spawn(async {
+    ///             // Another asynchronous task here
+    ///         });
+    ///     }
+    /// }
+    ///
+    /// let actix_runtime = actix_rt::Runtime::new().unwrap();
+    /// let tokio_runtime = actix_runtime.tokio_runtime();
+    ///
+    /// let handle = tokio_runtime.handle().clone();
+    ///
+    /// module_a::do_something(handle);
+    /// module_b::do_something_else(tokio_runtime);
+    /// ```
+    ///
+    /// # Returns
+    ///
+    /// An immutable reference to the `tokio::runtime::Runtime` instance associated with this
+    /// `Runtime` instance.
+    ///
+    /// # Note
+    ///
+    /// While this method provides an immutable reference to the Tokio runtime, which is safe to share across threads,
+    /// be aware that spawning blocking tasks on the Tokio runtime could potentially impact the execution
+    /// of the Actix runtime. This is because Tokio is responsible for driving the Actix system,
+    /// and blocking tasks could delay or deadlock other tasks in run loop.
+    pub fn tokio_runtime(&self) -> &tokio::runtime::Runtime {
+        &self.rt
+    }
+
+    /// Runs the provided future, blocking the current thread until the future completes.
+    ///
+    /// This function can be used to synchronously block the current thread until the provided
+    /// `future` has resolved either successfully or with an error. The result of the future is
+    /// then returned from this function call.
+    ///
+    /// Note that this function will also execute any spawned futures on the current thread, but
+    /// will not block until these other spawned futures have completed. Once the function returns,
+    /// any uncompleted futures remain pending in the `Runtime` instance. These futures will not run
+    /// until `block_on` or `run` is called again.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures complete execution by
+    /// calling `block_on` or `run`.
+    #[track_caller]
+    pub fn block_on<F>(&self, f: F) -> F::Output
+    where
+        F: Future,
+    {
+        self.local.block_on(&self.rt, f)
+    }
+}
+
+impl From<tokio::runtime::Runtime> for Runtime {
+    fn from(rt: tokio::runtime::Runtime) -> Self {
+        Self {
+            local: LocalSet::new(),
+            rt,
+        }
+    }
+}

actix-rt/src/system.rs

@@ -0,0 +1,357 @@
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    future::Future,
+    io,
+    pin::Pin,
+    sync::atomic::{AtomicUsize, Ordering},
+    task::{Context, Poll},
+};
+
+use futures_core::ready;
+use tokio::sync::{mpsc, oneshot};
+
+use crate::{arbiter::ArbiterHandle, Arbiter};
+
+static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+thread_local!(
+    static CURRENT: RefCell<Option<System>> = const { RefCell::new(None) };
+);
+
+/// A manager for a per-thread distributed async runtime.
+#[derive(Clone, Debug)]
+pub struct System {
+    id: usize,
+    sys_tx: mpsc::UnboundedSender<SystemCommand>,
+
+    /// Handle to the first [Arbiter] that is created with the System.
+    arbiter_handle: ArbiterHandle,
+}
+
+#[cfg(not(feature = "io-uring"))]
+impl System {
+    /// Create a new system.
+    ///
+    /// # Panics
+    /// Panics if underlying Tokio runtime can not be created.
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> SystemRunner {
+        Self::with_tokio_rt(|| {
+            crate::runtime::default_tokio_runtime()
+                .expect("Default Actix (Tokio) runtime could not be created.")
+        })
+    }
+
+    /// Create a new System using the [Tokio Runtime](tokio-runtime) returned from a closure.
+    ///
+    /// [tokio-runtime]: tokio::runtime::Runtime
+    pub fn with_tokio_rt<F>(runtime_factory: F) -> SystemRunner
+    where
+        F: FnOnce() -> tokio::runtime::Runtime,
+    {
+        let (stop_tx, stop_rx) = oneshot::channel();
+        let (sys_tx, sys_rx) = mpsc::unbounded_channel();
+
+        let rt = crate::runtime::Runtime::from(runtime_factory());
+        let sys_arbiter = rt.block_on(async { Arbiter::in_new_system() });
+        let system = System::construct(sys_tx, sys_arbiter.clone());
+
+        system
+            .tx()
+            .send(SystemCommand::RegisterArbiter(usize::MAX, sys_arbiter))
+            .unwrap();
+
+        // init background system arbiter
+        let sys_ctrl = SystemController::new(sys_rx, stop_tx);
+        rt.spawn(sys_ctrl);
+
+        SystemRunner { rt, stop_rx }
+    }
+}
+
+#[cfg(feature = "io-uring")]
+impl System {
+    /// Create a new system.
+    ///
+    /// # Panics
+    /// Panics if underlying Tokio runtime can not be created.
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> SystemRunner {
+        SystemRunner
+    }
+
+    /// Create a new System using the [Tokio Runtime](tokio-runtime) returned from a closure.
+    ///
+    /// [tokio-runtime]: tokio::runtime::Runtime
+    #[doc(hidden)]
+    pub fn with_tokio_rt<F>(_: F) -> SystemRunner
+    where
+        F: FnOnce() -> tokio::runtime::Runtime,
+    {
+        unimplemented!("System::with_tokio_rt is not implemented for io-uring feature yet")
+    }
+}
+
+impl System {
+    /// Constructs new system and registers it on the current thread.
+    pub(crate) fn construct(
+        sys_tx: mpsc::UnboundedSender<SystemCommand>,
+        arbiter_handle: ArbiterHandle,
+    ) -> Self {
+        let sys = System {
+            sys_tx,
+            arbiter_handle,
+            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
+        };
+
+        System::set_current(sys.clone());
+
+        sys
+    }
+
+    /// Get current running system.
+    ///
+    /// # Panics
+    /// Panics if no system is registered on the current thread.
+    pub fn current() -> System {
+        CURRENT.with(|cell| match *cell.borrow() {
+            Some(ref sys) => sys.clone(),
+            None => panic!("System is not running"),
+        })
+    }
+
+    /// Try to get current running system.
+    ///
+    /// Returns `None` if no System has been started.
+    ///
+    /// Unlike [`current`](Self::current), this never panics.
+    pub fn try_current() -> Option<System> {
+        CURRENT.with(|cell| cell.borrow().clone())
+    }
+
+    /// Get handle to a the System's initial [Arbiter].
+    pub fn arbiter(&self) -> &ArbiterHandle {
+        &self.arbiter_handle
+    }
+
+    /// Check if there is a System registered on the current thread.
+    pub fn is_registered() -> bool {
+        CURRENT.with(|sys| sys.borrow().is_some())
+    }
+
+    /// Register given system on current thread.
+    #[doc(hidden)]
+    pub fn set_current(sys: System) {
+        CURRENT.with(|cell| {
+            *cell.borrow_mut() = Some(sys);
+        })
+    }
+
+    /// Numeric system identifier.
+    ///
+    /// Useful when using multiple Systems.
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
+    /// Stop the system (with code 0).
+    pub fn stop(&self) {
+        self.stop_with_code(0)
+    }
+
+    /// Stop the system with a given exit code.
+    pub fn stop_with_code(&self, code: i32) {
+        let _ = self.sys_tx.send(SystemCommand::Exit(code));
+    }
+
+    pub(crate) fn tx(&self) -> &mpsc::UnboundedSender<SystemCommand> {
+        &self.sys_tx
+    }
+}
+
+/// Runner that keeps a [System]'s event loop alive until stop message is received.
+#[cfg(not(feature = "io-uring"))]
+#[must_use = "A SystemRunner does nothing unless `run` is called."]
+#[derive(Debug)]
+pub struct SystemRunner {
+    rt: crate::runtime::Runtime,
+    stop_rx: oneshot::Receiver<i32>,
+}
+
+#[cfg(not(feature = "io-uring"))]
+impl SystemRunner {
+    /// Starts event loop and will return once [System] is [stopped](System::stop).
+    pub fn run(self) -> io::Result<()> {
+        let exit_code = self.run_with_code()?;
+
+        match exit_code {
+            0 => Ok(()),
+            nonzero => Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("Non-zero exit code: {}", nonzero),
+            )),
+        }
+    }
+
+    /// Runs the event loop until [stopped](System::stop_with_code), returning the exit code.
+    pub fn run_with_code(self) -> io::Result<i32> {
+        let SystemRunner { rt, stop_rx, .. } = self;
+
+        // run loop
+        rt.block_on(stop_rx)
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
+    }
+
+    /// Retrieves a reference to the underlying [Actix runtime](crate::Runtime) associated with this
+    /// `SystemRunner` instance.
+    ///
+    /// The Actix runtime is responsible for managing the event loop for an Actix system and
+    /// executing asynchronous tasks. This method provides access to the runtime, allowing direct
+    /// interaction with its features.
+    ///
+    /// In a typical use case, you might need to share the same runtime between different
+    /// parts of your project. For example, some components might require a [`Runtime`] to spawn
+    /// tasks on the same runtime.
+    ///
+    /// Read more in the documentation for [`Runtime`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let system_runner = actix_rt::System::new();
+    /// let actix_runtime = system_runner.runtime();
+    ///
+    /// // Use the runtime to spawn an async task or perform other operations
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// While this method provides an immutable reference to the Actix runtime, which is safe to
+    /// share across threads, be aware that spawning blocking tasks on the Actix runtime could
+    /// potentially impact system performance. This is because the Actix runtime is responsible for
+    /// driving the system, and blocking tasks could delay other tasks in the run loop.
+    ///
+    /// [`Runtime`]: crate::Runtime
+    pub fn runtime(&self) -> &crate::runtime::Runtime {
+        &self.rt
+    }
+
+    /// Runs the provided future, blocking the current thread until the future completes.
+    #[track_caller]
+    #[inline]
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
+        self.rt.block_on(fut)
+    }
+}
+
+/// Runner that keeps a [System]'s event loop alive until stop message is received.
+#[cfg(feature = "io-uring")]
+#[must_use = "A SystemRunner does nothing unless `run` is called."]
+#[derive(Debug)]
+pub struct SystemRunner;
+
+#[cfg(feature = "io-uring")]
+impl SystemRunner {
+    /// Starts event loop and will return once [System] is [stopped](System::stop).
+    pub fn run(self) -> io::Result<()> {
+        unimplemented!("SystemRunner::run is not implemented for io-uring feature yet");
+    }
+
+    /// Runs the event loop until [stopped](System::stop_with_code), returning the exit code.
+    pub fn run_with_code(self) -> io::Result<i32> {
+        unimplemented!("SystemRunner::run_with_code is not implemented for io-uring feature yet");
+    }
+
+    /// Runs the provided future, blocking the current thread until the future completes.
+    #[inline]
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
+        tokio_uring::start(async move {
+            let (stop_tx, stop_rx) = oneshot::channel();
+            let (sys_tx, sys_rx) = mpsc::unbounded_channel();
+
+            let sys_arbiter = Arbiter::in_new_system();
+            let system = System::construct(sys_tx, sys_arbiter.clone());
+
+            system
+                .tx()
+                .send(SystemCommand::RegisterArbiter(usize::MAX, sys_arbiter))
+                .unwrap();
+
+            // init background system arbiter
+            let sys_ctrl = SystemController::new(sys_rx, stop_tx);
+            tokio_uring::spawn(sys_ctrl);
+
+            let res = fut.await;
+            drop(stop_rx);
+            res
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum SystemCommand {
+    Exit(i32),
+    RegisterArbiter(usize, ArbiterHandle),
+    DeregisterArbiter(usize),
+}
+
+/// There is one `SystemController` per [System]. It runs in the background, keeping track of
+/// [Arbiter]s and is able to distribute a system-wide stop command.
+#[derive(Debug)]
+pub(crate) struct SystemController {
+    stop_tx: Option<oneshot::Sender<i32>>,
+    cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+    arbiters: HashMap<usize, ArbiterHandle>,
+}
+
+impl SystemController {
+    pub(crate) fn new(
+        cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+        stop_tx: oneshot::Sender<i32>,
+    ) -> Self {
+        SystemController {
+            cmd_rx,
+            stop_tx: Some(stop_tx),
+            arbiters: HashMap::with_capacity(4),
+        }
+    }
+}
+
+impl Future for SystemController {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // process all items currently buffered in channel
+        loop {
+            match ready!(self.cmd_rx.poll_recv(cx)) {
+                // channel closed; no more messages can be received
+                None => return Poll::Ready(()),
+
+                // process system command
+                Some(cmd) => match cmd {
+                    SystemCommand::Exit(code) => {
+                        // stop all arbiters
+                        for arb in self.arbiters.values() {
+                            arb.stop();
+                        }
+
+                        // stop event loop
+                        // will only fire once
+                        if let Some(stop_tx) = self.stop_tx.take() {
+                            let _ = stop_tx.send(code);
+                        }
+                    }
+
+                    SystemCommand::RegisterArbiter(id, arb) => {
+                        self.arbiters.insert(id, arb);
+                    }
+
+                    SystemCommand::DeregisterArbiter(id) => {
+                        self.arbiters.remove(&id);
+                    }
+                },
+            }
+        }
+    }
+}

actix-rt/tests/test-macro-import-conflict.rs

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

actix-rt/tests/tests.rs

@@ -0,0 +1,378 @@
+#![allow(missing_docs)]
+
+use std::{
+    future::Future,
+    time::{Duration, Instant},
+};
+
+use actix_rt::{task::JoinError, Arbiter, System};
+#[cfg(not(feature = "io-uring"))]
+use {
+    std::{sync::mpsc::channel, thread},
+    tokio::sync::oneshot,
+};
+
+#[test]
+fn await_for_timer() {
+    let time = Duration::from_secs(1);
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        tokio::time::sleep(time).await;
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Block on should poll awaited future to completion"
+    );
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn run_with_code() {
+    let sys = System::new();
+    System::current().stop_with_code(42);
+    let exit_code = sys.run_with_code().expect("system stop should not error");
+    assert_eq!(exit_code, 42);
+}
+
+#[test]
+fn join_another_arbiter() {
+    let time = Duration::from_secs(1);
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn(Box::pin(async move {
+            tokio::time::sleep(time).await;
+            Arbiter::current().stop();
+        }));
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on another arbiter should complete only when it calls stop"
+    );
+
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn_fn(move || {
+            actix_rt::spawn(async move {
+                tokio::time::sleep(time).await;
+                Arbiter::current().stop();
+            });
+        });
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() >= time,
+        "Join on an arbiter that has used actix_rt::spawn should wait for said future"
+    );
+
+    let instant = Instant::now();
+    System::new().block_on(async move {
+        let arbiter = Arbiter::new();
+        arbiter.spawn(Box::pin(async move {
+            tokio::time::sleep(time).await;
+            Arbiter::current().stop();
+        }));
+        arbiter.stop();
+        arbiter.join().unwrap();
+    });
+    assert!(
+        instant.elapsed() < time,
+        "Premature stop of arbiter should conclude regardless of it's current state"
+    );
+}
+
+#[test]
+fn non_static_block_on() {
+    let string = String::from("test_str");
+    let string = string.as_str();
+
+    let sys = System::new();
+
+    sys.block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!("test_str", string);
+    });
+
+    let rt = actix_rt::Runtime::new().unwrap();
+
+    rt.block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!("test_str", string);
+    });
+}
+
+#[test]
+fn wait_for_spawns() {
+    let rt = actix_rt::Runtime::new().unwrap();
+
+    let handle = rt.spawn(async {
+        println!("running on the runtime");
+        // panic is caught at task boundary
+        panic!("intentional test panic");
+    });
+
+    assert!(rt.block_on(handle).is_err());
+}
+
+// Temporary disabled tests for io-uring feature.
+// They should be enabled when possible.
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_spawn_fn_runs() {
+    let _ = System::new();
+
+    let (tx, rx) = channel::<u32>();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn_fn(move || tx.send(42).unwrap());
+
+    let num = rx.recv().unwrap();
+    assert_eq!(num, 42);
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_handle_spawn_fn_runs() {
+    let sys = System::new();
+
+    let (tx, rx) = channel::<u32>();
+
+    let arbiter = Arbiter::new();
+    let handle = arbiter.handle();
+    drop(arbiter);
+
+    handle.spawn_fn(move || {
+        tx.send(42).unwrap();
+        System::current().stop()
+    });
+
+    let num = rx.recv_timeout(Duration::from_secs(2)).unwrap();
+    assert_eq!(num, 42);
+
+    handle.stop();
+    sys.run().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_drop_no_panic_fn() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn_fn(|| panic!("test"));
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn arbiter_drop_no_panic_fut() {
+    let _ = System::new();
+
+    let arbiter = Arbiter::new();
+    arbiter.spawn(async { panic!("test") });
+
+    arbiter.stop();
+    arbiter.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn system_arbiter_spawn() {
+    let runner = System::new();
+
+    let (tx, rx) = oneshot::channel();
+    let sys = System::current();
+
+    thread::spawn(|| {
+        // this thread will have no arbiter in it's thread local so call will panic
+        Arbiter::current();
+    })
+    .join()
+    .unwrap_err();
+
+    let thread = thread::spawn(|| {
+        // this thread will have no arbiter in it's thread local so use the system handle instead
+        System::set_current(sys);
+        let sys = System::current();
+
+        let arb = sys.arbiter();
+        arb.spawn(async move {
+            tx.send(42u32).unwrap();
+            System::current().stop();
+        });
+    });
+
+    assert_eq!(runner.block_on(rx).unwrap(), 42);
+    thread.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn system_stop_stops_arbiters() {
+    let sys = System::new();
+    let arb = Arbiter::new();
+
+    // arbiter should be alive to receive spawn msg
+    assert!(Arbiter::current().spawn_fn(|| {}));
+    assert!(arb.spawn_fn(|| {}));
+
+    System::current().stop();
+    sys.run().unwrap();
+
+    // account for slightly slow thread de-spawns
+    thread::sleep(Duration::from_millis(500));
+
+    // arbiter should be dead and return false
+    assert!(!Arbiter::current().spawn_fn(|| {}));
+    assert!(!arb.spawn_fn(|| {}));
+
+    arb.join().unwrap();
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn new_system_with_tokio() {
+    let (tx, rx) = channel();
+
+    let res = System::with_tokio_rt(move || {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_io()
+            .enable_time()
+            .thread_keep_alive(Duration::from_millis(1000))
+            .worker_threads(2)
+            .max_blocking_threads(2)
+            .on_thread_start(|| {})
+            .on_thread_stop(|| {})
+            .build()
+            .unwrap()
+    })
+    .block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+
+        tokio::task::spawn(async move {
+            tx.send(42).unwrap();
+        })
+        .await
+        .unwrap();
+
+        123usize
+    });
+
+    assert_eq!(res, 123);
+    assert_eq!(rx.recv().unwrap(), 42);
+}
+
+#[cfg(not(feature = "io-uring"))]
+#[test]
+fn new_arbiter_with_tokio() {
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    };
+
+    let _ = System::new();
+
+    let arb = Arbiter::with_tokio_rt(|| {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+    });
+
+    let counter = Arc::new(AtomicBool::new(true));
+
+    let counter1 = counter.clone();
+    let did_spawn = arb.spawn(async move {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        counter1.store(false, Ordering::SeqCst);
+        Arbiter::current().stop();
+    });
+
+    assert!(did_spawn);
+
+    arb.join().unwrap();
+
+    assert!(!counter.load(Ordering::SeqCst));
+}
+
+#[test]
+#[should_panic]
+fn no_system_current_panic() {
+    System::current();
+}
+
+#[test]
+#[should_panic]
+fn no_system_arbiter_new_panic() {
+    Arbiter::new();
+}
+
+#[test]
+fn try_current_no_system() {
+    assert!(System::try_current().is_none())
+}
+
+#[test]
+fn try_current_with_system() {
+    System::new().block_on(async { assert!(System::try_current().is_some()) });
+}
+
+#[allow(clippy::unit_cmp)]
+#[test]
+fn spawn_local() {
+    System::new().block_on(async {
+        // demonstrate that spawn -> R is strictly more capable than spawn -> ()
+
+        assert_eq!(actix_rt::spawn(async {}).await.unwrap(), ());
+        assert_eq!(actix_rt::spawn(async { 1 }).await.unwrap(), 1);
+        assert!(actix_rt::spawn(async { panic!("") }).await.is_err());
+
+        actix_rt::spawn(async { tokio::time::sleep(Duration::from_millis(50)).await })
+            .await
+            .unwrap();
+
+        fn g<F: Future<Output = Result<(), JoinError>>>(_f: F) {}
+        g(actix_rt::spawn(async {}));
+        // g(actix_rt::spawn(async { 1 })); // compile err
+
+        fn h<F: Future<Output = Result<R, JoinError>>, R>(_f: F) {}
+        h(actix_rt::spawn(async {}));
+        h(actix_rt::spawn(async { 1 }));
+    })
+}
+
+#[cfg(all(target_os = "linux", feature = "io-uring"))]
+#[test]
+fn tokio_uring_arbiter() {
+    System::new().block_on(async {
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        Arbiter::new().spawn(async move {
+            let handle = actix_rt::spawn(async move {
+                let f = tokio_uring::fs::File::create("test.txt").await.unwrap();
+                let buf = b"Hello World!";
+
+                let (res, _) = f.write_all_at(&buf[..], 0).await;
+                assert!(res.is_ok());
+
+                f.sync_all().await.unwrap();
+                f.close().await.unwrap();
+
+                std::fs::remove_file("test.txt").unwrap();
+            });
+
+            handle.await.unwrap();
+            tx.send(true).unwrap();
+        });
+
+        assert!(rx.recv().unwrap());
+    })
+}

actix-server/CHANGES.md

@@ -0,0 +1,232 @@
+# Changes
+
+## Unreleased
+
+## 2.5.1
+
+- Fix panic in test server.
+- Minimum supported Rust version (MSRV) is now 1.71.
+
+## 2.5.0
+
+- Update `mio` dependency to `1`.
+
+## 2.4.0
+
+- Update `tokio-uring` dependency to `0.5`.
+- Minimum supported Rust version (MSRV) is now 1.70.
+
+## 2.3.0
+
+- Add support for MultiPath TCP (MPTCP) with `MpTcp` enum and `ServerBuilder::mptcp()` method.
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 2.2.0
+
+- Minimum supported Rust version (MSRV) is now 1.59.
+- Update `tokio-uring` dependency to `0.4`.
+
+## 2.1.1
+
+- No significant changes since `2.1.0`.
+
+## 2.1.0
+
+- Update `tokio-uring` dependency to `0.3`.
+- Logs emitted now use the `tracing` crate with `log` compatibility.
+- Wait for accept thread to stop before sending completion signal.
+
+## 2.0.0
+
+- No significant changes since `2.0.0-rc.4`.
+
+## 2.0.0-rc.4
+
+- Update `tokio-uring` dependency to `0.2`.
+
+## 2.0.0-rc.3
+
+- No significant changes since `2.0.0-rc.2`.
+
+## 2.0.0-rc.2
+
+- Simplify `TestServer`.
+
+## 2.0.0-rc.1
+
+- Hide implementation details of `Server`.
+- `Server` now runs only after awaiting it.
+
+## 2.0.0-beta.9
+
+- Restore `Arbiter` support lost in `beta.8`.
+
+## 2.0.0-beta.8
+
+- Fix non-unix signal handler.
+
+## 2.0.0-beta.7
+
+- Server can be started in regular Tokio runtime.
+- Expose new `Server` type whose `Future` impl resolves when server stops.
+- Rename `Server` to `ServerHandle`.
+- Add `Server::handle` to obtain handle to server.
+- Rename `ServerBuilder::{maxconn => max_concurrent_connections}`.
+- Deprecate crate-level `new` shortcut for server builder.
+- Minimum supported Rust version (MSRV) is now 1.52.
+
+## 2.0.0-beta.6
+
+- Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux.
+- Server no long listens to `SIGHUP` signal. Previously, the received was not used but did block subsequent exit signals from working.
+- Remove `config` module. `ServiceConfig`, `ServiceRuntime` public types are removed due to this change.
+- Remove `ServerBuilder::configure`.
+
+## 2.0.0-beta.5
+
+- Server shutdown notifies all workers to exit regardless if shutdown is graceful. This causes all workers to shutdown immediately in force shutdown case.
+
+## 2.0.0-beta.4
+
+- Prevent panic when `shutdown_timeout` is very large. [f9262db]
+
+## 2.0.0-beta.3
+
+- Hidden `ServerBuilder::start` method has been removed. Use `ServerBuilder::run`.
+- Add retry for EINTR signal (`io::Interrupted`) in `Accept`'s poll loop.
+- Add `ServerBuilder::worker_max_blocking_threads` to customize blocking thread pool size.
+- Update `actix-rt` to `2.0.0`.
+
+## 2.0.0-beta.2
+
+- Merge `actix-testing` to `actix-server` as `test_server` mod.
+
+## 2.0.0-beta.1
+
+- Added explicit info log message on accept queue pause.
+- Prevent double registration of sockets when back-pressure is resolved.
+- Update `mio` dependency to `0.7.3`.
+- Remove `socket2` dependency.
+- `ServerBuilder::backlog` now accepts `u32` instead of `i32`.
+- Remove `AcceptNotify` type and pass `WakerQueue` to `Worker` to wake up `Accept`'s `Poll`.
+- Convert `mio::net::TcpStream` to `actix_rt::net::TcpStream`(`UnixStream` for uds) using `FromRawFd` and `IntoRawFd`(`FromRawSocket` and `IntoRawSocket` on windows).
+- Remove `AsyncRead` and `AsyncWrite` trait bound for `socket::FromStream` trait.
+
+## 1.0.4
+
+- Update actix-codec to 0.3.0.
+- Workers must be greater than 0.
+
+## 1.0.3
+
+- Replace deprecated `net2` crate with `socket2`.
+
+## 1.0.2
+
+- Avoid error by calling `reregister()` on Windows.
+
+## 1.0.1
+
+- Rename `.start()` method to `.run()`
+
+## 1.0.0
+
+- Use actix-net releases
+
+## 1.0.0-alpha.4
+
+- Use actix-service 1.0.0-alpha.4
+
+## 1.0.0-alpha.3
+
+- Migrate to tokio 0.2
+- Fix compilation on non-unix platforms
+- Better handling server configuration
+
+## 1.0.0-alpha.2
+
+- Simplify server service (remove actix-server-config)
+- Allow to wait on `Server` until server stops
+
+## 0.8.0-alpha.1
+
+- Migrate to `std::future`
+
+## 0.7.0
+
+- Update `rustls` to 0.16
+- Minimum required Rust version upped to 1.37.0
+
+## 0.6.1
+
+- Add UDS listening support to `ServerBuilder`
+
+## 0.6.0
+
+- Support Unix domain sockets #3
+
+## 0.5.1
+
+- ServerBuilder::shutdown_timeout() accepts u64
+
+## 0.5.0
+
+- Add `Debug` impl for `SslError`
+- Derive debug for `Server` and `ServerCommand`
+- Upgrade to actix-service 0.4
+
+## 0.4.3
+
+- Re-export `IoStream` trait
+- Depend on `ssl` and `rust-tls` features from actix-server-config
+
+## 0.4.2
+
+- Fix SIGINT force shutdown
+
+## 0.4.1
+
+- `SystemRuntime::on_start()` - allow to run future before server service initialization
+
+## 0.4.0
+
+- Use `ServerConfig` for service factory
+- Wrap tcp socket to `Io` type
+- Upgrade actix-service
+
+## 0.3.1
+
+- Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
+- Add helper ssl error `SslError`
+- Rename `StreamServiceFactory` to `ServiceFactory`
+- Deprecate `StreamServiceFactory`
+
+## 0.3.0
+
+- Use new `NewService` trait
+
+## 0.2.1
+
+- Drop service response
+
+## 0.2.0
+
+- Migrate to actix-service 0.2
+- Updated rustls dependency
+
+## 0.1.3
+
+- Fix max concurrent connections handling
+
+## 0.1.2
+
+- rename ServiceConfig::rt() to ServiceConfig::apply()
+- Fix back-pressure for concurrent ssl handshakes
+
+## 0.1.1
+
+- Fix signal handling on windows
+
+## 0.1.0
+
+- Move server to separate crate

actix-server/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "actix-server"
+version = "2.5.1"
+authors = [
+  "Nikolay Kim <fafhrd91@gmail.com>",
+  "Rob Ede <robjtede@icloud.com>",
+  "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
+]
+description = "General purpose TCP server built for the Actix ecosystem"
+keywords = ["network", "tcp", "server", "framework", "async"]
+categories = ["network-programming", "asynchronous"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net/tree/master/actix-server"
+license = "MIT OR Apache-2.0"
+edition.workspace = true
+rust-version.workspace = true
+
+[package.metadata.cargo_check_external_types]
+allowed_external_types = ["tokio::*"]
+
+[features]
+default = []
+io-uring = ["tokio-uring", "actix-rt/io-uring"]
+
+[dependencies]
+actix-rt = { version = "2.10", default-features = false }
+actix-service = "2"
+actix-utils = "3"
+futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
+futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
+mio = { version = "1", features = ["os-poll", "net"] }
+socket2 = "0.5"
+tokio = { version = "1.23.1", features = ["sync"] }
+tracing = { version = "0.1.30", default-features = false, features = ["log"] }
+
+# runtime for `io-uring` feature
+[target.'cfg(target_os = "linux")'.dependencies]
+tokio-uring = { version = "0.5", optional = true }
+
+[dev-dependencies]
+actix-codec = "0.5"
+actix-rt = "2.8"
+
+bytes = "1"
+futures-util = { version = "0.3.17", default-features = false, features = ["sink", "async-await-macro"] }
+pretty_env_logger = "0.5"
+tokio = { version = "1.23.1", features = ["io-util", "rt-multi-thread", "macros", "fs"] }
+
+[lints]
+workspace = true

actix-server/LICENSE-APACHE

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

actix-server/LICENSE-MIT

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

actix-server/README.md

@@ -0,0 +1,21 @@
+# actix-server
+
+> General purpose TCP server built for the Actix ecosystem.
+
+<!-- prettier-ignore-start -->
+
+[![crates.io](https://img.shields.io/crates/v/actix-server?label=latest)](https://crates.io/crates/actix-server)
+[![Documentation](https://docs.rs/actix-server/badge.svg?version=2.5.1)](https://docs.rs/actix-server/2.5.1)
+[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
+![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-server.svg)
+<br />
+[![Dependency Status](https://deps.rs/crate/actix-server/2.5.1/status.svg)](https://deps.rs/crate/actix-server/2.5.1)
+![Download](https://img.shields.io/crates/d/actix-server.svg)
+[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+
+<!-- prettier-ignore-end -->
+
+## Resources
+
+- [Library Documentation](https://docs.rs/actix-server)
+- [Examples](/actix-server/examples)

actix-server/examples/file-reader.rs

@@ -0,0 +1,98 @@
+//! Simple file-reader TCP server with framed stream.
+//!
+//! Using the following command:
+//!
+//! ```sh
+//! nc 127.0.0.1 8080
+//! ```
+//!
+//! Follow the prompt and enter a file path, relative or absolute.
+
+#![allow(missing_docs)]
+
+use std::io;
+
+use actix_codec::{Framed, LinesCodec};
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::{fn_service, ServiceFactoryExt as _};
+use futures_util::{SinkExt as _, StreamExt as _};
+use tokio::{fs::File, io::AsyncReadExt as _};
+
+async fn run() -> io::Result<()> {
+    pretty_env_logger::formatted_timed_builder()
+        .parse_env(pretty_env_logger::env_logger::Env::default().default_filter_or("info"));
+
+    let addr = ("127.0.0.1", 8080);
+    tracing::info!("starting server on port: {}", &addr.0);
+
+    // Bind socket address and start worker(s). By default, the server uses the number of physical
+    // 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("file-reader", addr, move || {
+            fn_service(move |stream: TcpStream| async move {
+                // set up codec to use with I/O resource
+                let mut framed = Framed::new(stream, LinesCodec::default());
+
+                loop {
+                    // prompt for file name
+                    framed.send("Type file name to return:").await?;
+
+                    // wait for next line
+                    match framed.next().await {
+                        Some(Ok(line)) => {
+                            match File::open(&line).await {
+                                Ok(mut file) => {
+                                    tracing::info!("reading file: {}", &line);
+
+                                    // read file into String buffer
+                                    let mut buf = String::new();
+                                    file.read_to_string(&mut buf).await?;
+
+                                    // send String into framed object
+                                    framed.send(buf).await?;
+
+                                    // break out of loop and
+                                    break;
+                                }
+                                Err(err) => {
+                                    tracing::error!("{}", err);
+                                    framed
+                                        .send("File not found or not readable. Try again.")
+                                        .await?;
+                                    continue;
+                                }
+                            };
+                        }
+
+                        // not being able to read a line from the stream is unrecoverable
+                        Some(Err(err)) => return Err(err),
+
+                        // This EOF won't be hit.
+                        None => continue,
+                    }
+                }
+
+                // close connection after file has been copied to TCP stream
+                Ok(())
+            })
+            .map_err(|err| tracing::error!("service error: {:?}", err))
+        })?
+        .workers(2)
+        .run()
+        .await
+}
+
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    run().await?;
+    Ok(())
+}
+
+// alternatively:
+// #[actix_rt::main]
+// async fn main() -> io::Result<()> {
+//     run().await?;
+//     Ok(())
+// }

actix-server/examples/tcp-echo.rs

@@ -0,0 +1,101 @@
+//! 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::{
+    io,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::{fn_service, ServiceFactoryExt as _};
+use bytes::BytesMut;
+use futures_util::future::ok;
+use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
+
+async fn run() -> io::Result<()> {
+    pretty_env_logger::formatted_timed_builder()
+        .parse_env(pretty_env_logger::env_logger::Env::default().default_filter_or("info"));
+
+    let count = Arc::new(AtomicUsize::new(0));
+
+    let addr = ("127.0.0.1", 8080);
+    tracing::info!("starting server on port: {}", &addr.0);
+
+    // Bind socket address and start worker(s). By default, the server uses the number of physical
+    // 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);
+
+            fn_service(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) => {
+                                tracing::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) => {
+                                tracing::error!("stream error: {:?}", err);
+                                return Err(());
+                            }
+                        }
+                    }
+
+                    // send data down service pipeline
+                    Ok((buf.freeze(), size))
+                }
+            })
+            .map_err(|err| tracing::error!("service error: {:?}", err))
+            .and_then(move |(_, size)| {
+                let num = num2.load(Ordering::SeqCst);
+                tracing::info!("[{}] total bytes read: {}", num, size);
+                ok(size)
+            })
+        })?
+        .workers(2)
+        .run()
+        .await
+}
+
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    run().await?;
+    Ok(())
+}
+
+// alternatively:
+// #[actix_rt::main]
+// async fn main() -> io::Result<()> {
+//     run().await?;
+//     Ok(())
+// }

actix-server/src/accept.rs

@@ -0,0 +1,462 @@
+use std::{io, thread, time::Duration};
+
+use actix_rt::time::Instant;
+use mio::{Interest, Poll, Token as MioToken};
+use tracing::{debug, error, info};
+
+use crate::{
+    availability::Availability,
+    socket::MioListener,
+    waker_queue::{WakerInterest, WakerQueue, WAKER_TOKEN},
+    worker::{Conn, ServerWorker, WorkerHandleAccept, WorkerHandleServer},
+    ServerBuilder, ServerHandle,
+};
+
+const TIMEOUT_DURATION_ON_ERROR: Duration = Duration::from_millis(510);
+
+struct ServerSocketInfo {
+    token: usize,
+
+    lst: MioListener,
+
+    /// Timeout is used to mark the deadline when this socket's listener should be registered again
+    /// after an error.
+    timeout: Option<actix_rt::time::Instant>,
+}
+
+/// Poll instance of the server.
+pub(crate) struct Accept {
+    poll: Poll,
+    waker_queue: WakerQueue,
+    handles: Vec<WorkerHandleAccept>,
+    srv: ServerHandle,
+    next: usize,
+    avail: Availability,
+    /// use the smallest duration from sockets timeout.
+    timeout: Option<Duration>,
+    paused: bool,
+}
+
+impl Accept {
+    pub(crate) fn start(
+        sockets: Vec<(usize, MioListener)>,
+        builder: &ServerBuilder,
+    ) -> io::Result<(WakerQueue, Vec<WorkerHandleServer>, thread::JoinHandle<()>)> {
+        let handle_server = ServerHandle::new(builder.cmd_tx.clone());
+
+        // construct poll instance and its waker
+        let poll = Poll::new()?;
+        let waker_queue = WakerQueue::new(poll.registry())?;
+
+        // start workers and collect handles
+        let (handles_accept, handles_server) = (0..builder.threads)
+            .map(|idx| {
+                // clone service factories
+                let factories = builder
+                    .factories
+                    .iter()
+                    .map(|f| f.clone_factory())
+                    .collect::<Vec<_>>();
+
+                // start worker using service factories
+                ServerWorker::start(idx, factories, waker_queue.clone(), builder.worker_config)
+            })
+            .collect::<io::Result<Vec<_>>>()?
+            .into_iter()
+            .unzip();
+
+        let (mut accept, mut sockets) = Accept::new_with_sockets(
+            poll,
+            waker_queue.clone(),
+            sockets,
+            handles_accept,
+            handle_server,
+        )?;
+
+        let accept_handle = thread::Builder::new()
+            .name("actix-server acceptor".to_owned())
+            .spawn(move || accept.poll_with(&mut sockets))
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+
+        Ok((waker_queue, handles_server, accept_handle))
+    }
+
+    fn new_with_sockets(
+        poll: Poll,
+        waker_queue: WakerQueue,
+        sockets: Vec<(usize, MioListener)>,
+        accept_handles: Vec<WorkerHandleAccept>,
+        server_handle: ServerHandle,
+    ) -> io::Result<(Accept, Box<[ServerSocketInfo]>)> {
+        let sockets = sockets
+            .into_iter()
+            .map(|(token, mut lst)| {
+                // Start listening for incoming connections
+                poll.registry()
+                    .register(&mut lst, MioToken(token), Interest::READABLE)?;
+
+                Ok(ServerSocketInfo {
+                    token,
+                    lst,
+                    timeout: None,
+                })
+            })
+            .collect::<io::Result<_>>()?;
+
+        let mut avail = Availability::default();
+
+        // Assume all handles are avail at construct time.
+        avail.set_available_all(&accept_handles);
+
+        let accept = Accept {
+            poll,
+            waker_queue,
+            handles: accept_handles,
+            srv: server_handle,
+            next: 0,
+            avail,
+            timeout: None,
+            paused: false,
+        };
+
+        Ok((accept, sockets))
+    }
+
+    /// blocking wait for readiness events triggered by mio
+    fn poll_with(&mut self, sockets: &mut [ServerSocketInfo]) {
+        let mut events = mio::Events::with_capacity(256);
+
+        loop {
+            if let Err(err) = self.poll.poll(&mut events, self.timeout) {
+                match err.kind() {
+                    io::ErrorKind::Interrupted => {}
+                    _ => panic!("Poll error: {}", err),
+                }
+            }
+
+            for event in events.iter() {
+                let token = event.token();
+                match token {
+                    WAKER_TOKEN => {
+                        let exit = self.handle_waker(sockets);
+                        if exit {
+                            info!("accept thread stopped");
+                            return;
+                        }
+                    }
+                    _ => {
+                        let token = usize::from(token);
+                        self.accept(sockets, token);
+                    }
+                }
+            }
+
+            // check for timeout and re-register sockets
+            self.process_timeout(sockets);
+        }
+    }
+
+    fn handle_waker(&mut self, sockets: &mut [ServerSocketInfo]) -> bool {
+        // This is a loop because interests for command from previous version was
+        // a loop that would try to drain the command channel. It's yet unknown
+        // if it's necessary/good practice to actively drain the waker queue.
+        loop {
+            // Take guard with every iteration so no new interests can be added until the current
+            // task is done. Take care not to take the guard again inside this loop.
+            let mut guard = self.waker_queue.guard();
+
+            #[allow(clippy::significant_drop_in_scrutinee)]
+            match guard.pop_front() {
+                // Worker notified it became available.
+                Some(WakerInterest::WorkerAvailable(idx)) => {
+                    drop(guard);
+
+                    self.avail.set_available(idx, true);
+
+                    if !self.paused {
+                        self.accept_all(sockets);
+                    }
+                }
+
+                // A new worker thread has been created so store its handle.
+                Some(WakerInterest::Worker(handle)) => {
+                    drop(guard);
+
+                    self.avail.set_available(handle.idx(), true);
+                    self.handles.push(handle);
+
+                    if !self.paused {
+                        self.accept_all(sockets);
+                    }
+                }
+
+                Some(WakerInterest::Pause) => {
+                    drop(guard);
+
+                    if !self.paused {
+                        self.paused = true;
+
+                        self.deregister_all(sockets);
+                    }
+                }
+
+                Some(WakerInterest::Resume) => {
+                    drop(guard);
+
+                    if self.paused {
+                        self.paused = false;
+
+                        sockets.iter_mut().for_each(|info| {
+                            self.register_logged(info);
+                        });
+
+                        self.accept_all(sockets);
+                    }
+                }
+
+                Some(WakerInterest::Stop) => {
+                    if !self.paused {
+                        self.deregister_all(sockets);
+                    }
+
+                    return true;
+                }
+
+                // waker queue is drained
+                None => {
+                    // Reset the WakerQueue before break so it does not grow infinitely
+                    WakerQueue::reset(&mut guard);
+
+                    return false;
+                }
+            }
+        }
+    }
+
+    fn process_timeout(&mut self, sockets: &mut [ServerSocketInfo]) {
+        // always remove old timeouts
+        if self.timeout.take().is_some() {
+            let now = Instant::now();
+
+            sockets
+                .iter_mut()
+                // Only sockets that had an associated timeout were deregistered.
+                .filter(|info| info.timeout.is_some())
+                .for_each(|info| {
+                    let inst = info.timeout.take().unwrap();
+
+                    if now < inst {
+                        // still timed out; try to set new timeout
+                        info.timeout = Some(inst);
+                        self.set_timeout(inst - now);
+                    } else if !self.paused {
+                        // timeout expired; register socket again
+                        self.register_logged(info);
+                    }
+
+                    // Drop the timeout if server is paused and socket timeout is expired.
+                    // When server recovers from pause it will register all sockets without
+                    // a timeout value so this socket register will be delayed till then.
+                });
+        }
+    }
+
+    /// Update accept timeout with `duration` if it is shorter than current timeout.
+    fn set_timeout(&mut self, duration: Duration) {
+        match self.timeout {
+            Some(ref mut timeout) => {
+                if *timeout > duration {
+                    *timeout = duration;
+                }
+            }
+            None => self.timeout = Some(duration),
+        }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn register(&self, info: &mut ServerSocketInfo) -> io::Result<()> {
+        let token = MioToken(info.token);
+        self.poll
+            .registry()
+            .register(&mut info.lst, token, Interest::READABLE)
+    }
+
+    #[cfg(target_os = "windows")]
+    fn register(&self, info: &mut ServerSocketInfo) -> io::Result<()> {
+        // On windows, calling register without deregister cause an error.
+        // See https://github.com/actix/actix-web/issues/905
+        // Calling reregister seems to fix the issue.
+        let token = MioToken(info.token);
+        self.poll
+            .registry()
+            .register(&mut info.lst, token, Interest::READABLE)
+            .or_else(|_| {
+                self.poll
+                    .registry()
+                    .reregister(&mut info.lst, token, Interest::READABLE)
+            })
+    }
+
+    fn register_logged(&self, info: &mut ServerSocketInfo) {
+        match self.register(info) {
+            Ok(_) => debug!("resume accepting connections on {}", info.lst.local_addr()),
+            Err(err) => error!("can not register server socket {}", err),
+        }
+    }
+
+    fn deregister_logged(&self, info: &mut ServerSocketInfo) {
+        match self.poll.registry().deregister(&mut info.lst) {
+            Ok(_) => debug!("paused accepting connections on {}", info.lst.local_addr()),
+            Err(err) => {
+                error!("can not deregister server socket {}", err)
+            }
+        }
+    }
+
+    fn deregister_all(&self, sockets: &mut [ServerSocketInfo]) {
+        // This is a best effort implementation with following limitation:
+        //
+        // Every ServerSocketInfo with associated timeout will be skipped and it's timeout is
+        // removed in the process.
+        //
+        // Therefore WakerInterest::Pause followed by WakerInterest::Resume in a very short gap
+        // (less than 500ms) would cause all timing out ServerSocketInfos be re-registered before
+        // expected timing.
+        sockets
+            .iter_mut()
+            // Take all timeout.
+            // This is to prevent Accept::process_timer method re-register a socket afterwards.
+            .map(|info| (info.timeout.take(), info))
+            // Socket info with a timeout is already deregistered so skip them.
+            .filter(|(timeout, _)| timeout.is_none())
+            .for_each(|(_, info)| self.deregister_logged(info));
+    }
+
+    // Send connection to worker and handle error.
+    fn send_connection(&mut self, conn: Conn) -> Result<(), Conn> {
+        let next = self.next();
+        match next.send(conn) {
+            Ok(_) => {
+                // Increment counter of WorkerHandle.
+                // Set worker to unavailable with it hit max (Return false).
+                if !next.inc_counter() {
+                    let idx = next.idx();
+                    self.avail.set_available(idx, false);
+                }
+                self.set_next();
+                Ok(())
+            }
+            Err(conn) => {
+                // Worker thread is error and could be gone.
+                // Remove worker handle and notify `ServerBuilder`.
+                self.remove_next();
+
+                if self.handles.is_empty() {
+                    error!("no workers");
+                    // All workers are gone and Conn is nowhere to be sent.
+                    // Treat this situation as Ok and drop Conn.
+                    return Ok(());
+                } else if self.handles.len() <= self.next {
+                    self.next = 0;
+                }
+
+                Err(conn)
+            }
+        }
+    }
+
+    fn accept_one(&mut self, mut conn: Conn) {
+        loop {
+            let next = self.next();
+            let idx = next.idx();
+
+            if self.avail.get_available(idx) {
+                match self.send_connection(conn) {
+                    Ok(_) => return,
+                    Err(c) => conn = c,
+                }
+            } else {
+                self.avail.set_available(idx, false);
+                self.set_next();
+
+                if !self.avail.available() {
+                    while let Err(c) = self.send_connection(conn) {
+                        conn = c;
+                    }
+                    return;
+                }
+            }
+        }
+    }
+
+    fn accept(&mut self, sockets: &mut [ServerSocketInfo], token: usize) {
+        while self.avail.available() {
+            let info = &mut sockets[token];
+
+            match info.lst.accept() {
+                Ok(io) => {
+                    let conn = Conn { io, token };
+                    self.accept_one(conn);
+                }
+                Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => return,
+                Err(ref err) if connection_error(err) => continue,
+                Err(err) => {
+                    error!("error accepting connection: {}", err);
+
+                    // deregister listener temporary
+                    self.deregister_logged(info);
+
+                    // sleep after error. write the timeout to socket info as later
+                    // the poll would need it mark which socket and when it's
+                    // listener should be registered
+                    info.timeout = Some(Instant::now() + Duration::from_millis(500));
+                    self.set_timeout(TIMEOUT_DURATION_ON_ERROR);
+
+                    return;
+                }
+            };
+        }
+    }
+
+    fn accept_all(&mut self, sockets: &mut [ServerSocketInfo]) {
+        sockets
+            .iter_mut()
+            .map(|info| info.token)
+            .collect::<Vec<_>>()
+            .into_iter()
+            .for_each(|idx| self.accept(sockets, idx))
+    }
+
+    #[inline(always)]
+    fn next(&self) -> &WorkerHandleAccept {
+        &self.handles[self.next]
+    }
+
+    /// Set next worker handle that would accept connection.
+    #[inline(always)]
+    fn set_next(&mut self) {
+        self.next = (self.next + 1) % self.handles.len();
+    }
+
+    /// Remove next worker handle that fail to accept connection.
+    fn remove_next(&mut self) {
+        let handle = self.handles.swap_remove(self.next);
+        let idx = handle.idx();
+        // A message is sent to `ServerBuilder` future to notify it a new worker
+        // should be made.
+        self.srv.worker_faulted(idx);
+        self.avail.set_available(idx, false);
+    }
+}
+
+/// This function defines errors that are per-connection; if we get this error from the `accept()`
+/// system call it means the next connection might be ready to be accepted.
+///
+/// All other errors will incur a timeout before next `accept()` call is attempted. The timeout is
+/// useful to handle resource exhaustion errors like `ENFILE` and `EMFILE`. Otherwise, it could
+/// enter into a temporary spin loop.
+fn connection_error(e: &io::Error) -> bool {
+    e.kind() == io::ErrorKind::ConnectionRefused
+        || e.kind() == io::ErrorKind::ConnectionAborted
+        || e.kind() == io::ErrorKind::ConnectionReset
+}

actix-server/src/availability.rs

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

actix-server/src/builder.rs

@@ -0,0 +1,378 @@
+use std::{io, num::NonZeroUsize, time::Duration};
+
+use actix_rt::net::TcpStream;
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
+
+use crate::{
+    server::ServerCommand,
+    service::{InternalServiceFactory, ServerServiceFactory, StreamNewService},
+    socket::{create_mio_tcp_listener, MioListener, MioTcpListener, StdTcpListener, ToSocketAddrs},
+    worker::ServerWorkerConfig,
+    Server,
+};
+
+/// Multipath TCP (MPTCP) preference.
+///
+/// Currently only useful on Linux.
+///
+#[cfg_attr(target_os = "linux", doc = "Also see [`ServerBuilder::mptcp()`].")]
+#[derive(Debug, Clone)]
+pub enum MpTcp {
+    /// MPTCP will not be used when binding sockets.
+    Disabled,
+
+    /// MPTCP will be attempted when binding sockets. If errors occur, regular TCP will be
+    /// attempted, too.
+    TcpFallback,
+
+    /// MPTCP will be used when binding sockets (with no fallback).
+    NoFallback,
+}
+
+/// [Server] builder.
+pub struct ServerBuilder {
+    pub(crate) threads: usize,
+    pub(crate) token: usize,
+    pub(crate) backlog: u32,
+    pub(crate) factories: Vec<Box<dyn InternalServiceFactory>>,
+    pub(crate) sockets: Vec<(usize, String, MioListener)>,
+    pub(crate) mptcp: MpTcp,
+    pub(crate) exit: bool,
+    pub(crate) listen_os_signals: bool,
+    pub(crate) cmd_tx: UnboundedSender<ServerCommand>,
+    pub(crate) cmd_rx: UnboundedReceiver<ServerCommand>,
+    pub(crate) worker_config: ServerWorkerConfig,
+}
+
+impl Default for ServerBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ServerBuilder {
+    /// Create new Server builder instance
+    pub fn new() -> ServerBuilder {
+        let (cmd_tx, cmd_rx) = unbounded_channel();
+
+        ServerBuilder {
+            threads: std::thread::available_parallelism().map_or(2, NonZeroUsize::get),
+            token: 0,
+            factories: Vec::new(),
+            sockets: Vec::new(),
+            backlog: 2048,
+            mptcp: MpTcp::Disabled,
+            exit: false,
+            listen_os_signals: true,
+            cmd_tx,
+            cmd_rx,
+            worker_config: ServerWorkerConfig::default(),
+        }
+    }
+
+    /// Sets number of workers to start.
+    ///
+    /// See [`bind()`](Self::bind()) for more details on how worker count affects the number of
+    /// server factory instantiations.
+    ///
+    /// The default worker count is the determined by [`std::thread::available_parallelism()`]. See
+    /// its documentation to determine what behavior you should expect when server is run.
+    ///
+    /// `num` must be greater than 0.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `num` is 0.
+    pub fn workers(mut self, num: usize) -> Self {
+        assert_ne!(num, 0, "workers must be greater than 0");
+        self.threads = num;
+        self
+    }
+
+    /// Set max number of threads for each worker's blocking task thread pool.
+    ///
+    /// One thread pool is set up **per worker**; not shared across workers.
+    ///
+    /// # Examples:
+    /// ```
+    /// # use actix_server::ServerBuilder;
+    /// let builder = ServerBuilder::new()
+    ///     .workers(4) // server has 4 worker thread.
+    ///     .worker_max_blocking_threads(4); // every worker has 4 max blocking threads.
+    /// ```
+    ///
+    /// See [tokio::runtime::Builder::max_blocking_threads] for behavior reference.
+    pub fn worker_max_blocking_threads(mut self, num: usize) -> Self {
+        self.worker_config.max_blocking_threads(num);
+        self
+    }
+
+    /// Set the maximum number of pending connections.
+    ///
+    /// This refers to the number of clients that can be waiting to be served. Exceeding this number
+    /// results in the client getting an error when attempting to connect. It should only affect
+    /// servers under significant load.
+    ///
+    /// 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: u32) -> Self {
+        self.backlog = num;
+        self
+    }
+
+    /// Sets MultiPath TCP (MPTCP) preference on bound sockets.
+    ///
+    /// Multipath TCP (MPTCP) builds on top of TCP to improve connection redundancy and performance
+    /// by sharing a network data stream across multiple underlying TCP sessions. See [mptcp.dev]
+    /// for more info about MPTCP itself.
+    ///
+    /// MPTCP is available on Linux kernel version 5.6 and higher. In addition, you'll also need to
+    /// ensure the kernel option is enabled using `sysctl net.mptcp.enabled=1`.
+    ///
+    /// This method will have no effect if called after a `bind()`.
+    ///
+    /// [mptcp.dev]: https://www.mptcp.dev
+    #[cfg(target_os = "linux")]
+    pub fn mptcp(mut self, mptcp_enabled: MpTcp) -> Self {
+        self.mptcp = mptcp_enabled;
+        self
+    }
+
+    /// Sets the maximum per-worker number of concurrent connections.
+    ///
+    /// All socket listeners will stop accepting connections when this limit is reached for
+    /// each worker.
+    ///
+    /// By default max connections is set to a 25k per worker.
+    pub fn max_concurrent_connections(mut self, num: usize) -> Self {
+        self.worker_config.max_concurrent_connections(num);
+        self
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "2.0.0", note = "Renamed to `max_concurrent_connections`.")]
+    pub fn maxconn(self, num: usize) -> Self {
+        self.max_concurrent_connections(num)
+    }
+
+    /// Sets flag to stop Actix `System` after server shutdown.
+    ///
+    /// This has no effect when server is running in a Tokio-only runtime.
+    pub fn system_exit(mut self) -> Self {
+        self.exit = true;
+        self
+    }
+
+    /// Disables OS signal handling.
+    pub fn disable_signals(mut self) -> Self {
+        self.listen_os_signals = false;
+        self
+    }
+
+    /// Timeout for graceful workers shutdown in seconds.
+    ///
+    /// After receiving a stop signal, workers have this much time to finish serving requests.
+    /// Workers still alive after the timeout are force dropped.
+    ///
+    /// By default shutdown timeout sets to 30 seconds.
+    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
+        self.worker_config
+            .shutdown_timeout(Duration::from_secs(sec));
+        self
+    }
+
+    /// Adds new service to the server.
+    ///
+    /// Note that, if a DNS lookup is required, resolving hostnames is a blocking operation.
+    ///
+    /// # Worker Count
+    ///
+    /// The `factory` will be instantiated multiple times in most scenarios. The number of
+    /// instantiations is number of [`workers`](Self::workers()) × number of sockets resolved by
+    /// `addrs`.
+    ///
+    /// For example, if you've manually set [`workers`](Self::workers()) to 2, and use `127.0.0.1`
+    /// as the bind `addrs`, then `factory` will be instantiated twice. However, using `localhost`
+    /// as the bind `addrs` can often resolve to both `127.0.0.1` (IPv4) _and_ `::1` (IPv6), causing
+    /// the `factory` to be instantiated 4 times (2 workers × 2 bind addresses).
+    ///
+    /// Using a bind address of `0.0.0.0`, which signals to use all interfaces, may also multiple
+    /// the number of instantiations in a similar way.
+    ///
+    /// # Errors
+    ///
+    /// Returns an `io::Error` if:
+    /// - `addrs` cannot be resolved into one or more socket addresses;
+    /// - all the resolved socket addresses are already bound.
+    pub fn bind<F, U, N>(mut self, name: N, addrs: U, factory: F) -> io::Result<Self>
+    where
+        F: ServerServiceFactory<TcpStream>,
+        U: ToSocketAddrs,
+        N: AsRef<str>,
+    {
+        let sockets = bind_addr(addrs, self.backlog, &self.mptcp)?;
+
+        tracing::trace!("binding server to: {sockets:?}");
+
+        for lst in sockets {
+            let token = self.next_token();
+
+            self.factories.push(StreamNewService::create(
+                name.as_ref().to_string(),
+                token,
+                factory.clone(),
+                lst.local_addr()?,
+            ));
+
+            self.sockets
+                .push((token, name.as_ref().to_string(), MioListener::Tcp(lst)));
+        }
+
+        Ok(self)
+    }
+
+    /// Adds service to the server using a socket listener already bound.
+    ///
+    /// # Worker Count
+    ///
+    /// The `factory` will be instantiated multiple times in most scenarios. The number of
+    /// instantiations is: number of [`workers`](Self::workers()).
+    pub fn listen<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: StdTcpListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServerServiceFactory<TcpStream>,
+    {
+        lst.set_nonblocking(true)?;
+        let addr = lst.local_addr()?;
+
+        let token = self.next_token();
+        self.factories.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+            addr,
+        ));
+
+        self.sockets
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
+
+        Ok(self)
+    }
+
+    /// Starts processing incoming connections and return server controller.
+    pub fn run(self) -> Server {
+        if self.sockets.is_empty() {
+            panic!("Server should have at least one bound socket");
+        } else {
+            tracing::info!("starting {} workers", self.threads);
+            Server::new(self)
+        }
+    }
+
+    fn next_token(&mut self) -> usize {
+        let token = self.token;
+        self.token += 1;
+        token
+    }
+}
+
+#[cfg(unix)]
+impl ServerBuilder {
+    /// Adds new service to the server using a UDS (unix domain socket) address.
+    ///
+    /// # Worker Count
+    ///
+    /// The `factory` will be instantiated multiple times in most scenarios. The number of
+    /// instantiations is: number of [`workers`](Self::workers()).
+    pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
+    where
+        F: ServerServiceFactory<actix_rt::net::UnixStream>,
+        N: AsRef<str>,
+        U: AsRef<std::path::Path>,
+    {
+        // The path must not exist when we try to bind.
+        // Try to remove it to avoid bind error.
+        if let Err(err) = std::fs::remove_file(addr.as_ref()) {
+            // NotFound is expected and not an issue. Anything else is.
+            if err.kind() != std::io::ErrorKind::NotFound {
+                return Err(err);
+            }
+        }
+
+        let lst = crate::socket::StdUnixListener::bind(addr)?;
+        self.listen_uds(name, lst, factory)
+    }
+
+    /// Adds new service to the server using a UDS (unix domain socket) listener already bound.
+    ///
+    /// Useful when running as a systemd service and a socket FD is acquired externally.
+    ///
+    /// # Worker Count
+    ///
+    /// The `factory` will be instantiated multiple times in most scenarios. The number of
+    /// instantiations is: number of [`workers`](Self::workers()).
+    pub fn listen_uds<F, N: AsRef<str>>(
+        mut self,
+        name: N,
+        lst: crate::socket::StdUnixListener,
+        factory: F,
+    ) -> io::Result<Self>
+    where
+        F: ServerServiceFactory<actix_rt::net::UnixStream>,
+    {
+        use std::net::{IpAddr, Ipv4Addr};
+
+        lst.set_nonblocking(true)?;
+
+        let token = self.next_token();
+        let addr = crate::socket::StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+
+        self.factories.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+            addr,
+        ));
+
+        self.sockets
+            .push((token, name.as_ref().to_string(), MioListener::from(lst)));
+
+        Ok(self)
+    }
+}
+
+pub(super) fn bind_addr<S: ToSocketAddrs>(
+    addr: S,
+    backlog: u32,
+    mptcp: &MpTcp,
+) -> io::Result<Vec<MioTcpListener>> {
+    let mut opt_err = None;
+    let mut success = false;
+    let mut sockets = Vec::new();
+
+    for addr in addr.to_socket_addrs()? {
+        match create_mio_tcp_listener(addr, backlog, mptcp) {
+            Ok(lst) => {
+                success = true;
+                sockets.push(lst);
+            }
+            Err(err) => opt_err = Some(err),
+        }
+    }
+
+    if success {
+        Ok(sockets)
+    } else if let Some(err) = opt_err.take() {
+        Err(err)
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::Other,
+            "Can not bind to address.",
+        ))
+    }
+}

actix-server/src/handle.rs

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

actix-server/src/join_all.rs

@@ -0,0 +1,78 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures_core::future::BoxFuture;
+
+// a poor man's join future. joined future is only used when starting/stopping the server.
+// pin_project and pinned futures are overkill for this task.
+pub(crate) struct JoinAll<T> {
+    fut: Vec<JoinFuture<T>>,
+}
+
+pub(crate) fn join_all<T>(fut: Vec<impl Future<Output = T> + Send + 'static>) -> JoinAll<T> {
+    let fut = fut
+        .into_iter()
+        .map(|f| JoinFuture::Future(Box::pin(f)))
+        .collect();
+
+    JoinAll { fut }
+}
+
+enum JoinFuture<T> {
+    Future(BoxFuture<'static, T>),
+    Result(Option<T>),
+}
+
+impl<T> Unpin for JoinAll<T> {}
+
+impl<T> Future for JoinAll<T> {
+    type Output = Vec<T>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut ready = true;
+
+        let this = self.get_mut();
+        for fut in this.fut.iter_mut() {
+            if let JoinFuture::Future(f) = fut {
+                match f.as_mut().poll(cx) {
+                    Poll::Ready(t) => {
+                        *fut = JoinFuture::Result(Some(t));
+                    }
+                    Poll::Pending => ready = false,
+                }
+            }
+        }
+
+        if ready {
+            let mut res = Vec::new();
+            for fut in this.fut.iter_mut() {
+                if let JoinFuture::Result(f) = fut {
+                    res.push(f.take().unwrap());
+                }
+            }
+
+            Poll::Ready(res)
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use actix_utils::future::ready;
+
+    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/lib.rs

@@ -0,0 +1,34 @@
+//! General purpose TCP server.
+
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+mod accept;
+mod availability;
+mod builder;
+mod handle;
+mod join_all;
+mod server;
+mod service;
+mod signals;
+mod socket;
+mod test_server;
+mod waker_queue;
+mod worker;
+
+#[doc(hidden)]
+pub use self::socket::FromStream;
+pub use self::{
+    builder::{MpTcp, ServerBuilder},
+    handle::ServerHandle,
+    server::Server,
+    service::ServerServiceFactory,
+    test_server::TestServer,
+};
+
+/// Start server building process
+#[doc(hidden)]
+#[deprecated(since = "2.0.0", note = "Use `Server::build()`.")]
+pub fn new() -> ServerBuilder {
+    ServerBuilder::default()
+}

actix-server/src/server.rs

@@ -0,0 +1,368 @@
+use std::{
+    future::Future,
+    io, mem,
+    pin::Pin,
+    task::{Context, Poll},
+    thread,
+    time::Duration,
+};
+
+use actix_rt::{time::sleep, System};
+use futures_core::{future::BoxFuture, Stream};
+use futures_util::stream::StreamExt as _;
+use tokio::sync::{mpsc::UnboundedReceiver, oneshot};
+use tracing::{error, info};
+
+use crate::{
+    accept::Accept,
+    builder::ServerBuilder,
+    join_all::join_all,
+    service::InternalServiceFactory,
+    signals::{SignalKind, Signals},
+    waker_queue::{WakerInterest, WakerQueue},
+    worker::{ServerWorker, ServerWorkerConfig, WorkerHandleServer},
+    ServerHandle,
+};
+
+#[derive(Debug)]
+pub(crate) enum ServerCommand {
+    /// Worker failed to accept connection, indicating a probable panic.
+    ///
+    /// Contains index of faulted worker.
+    WorkerFaulted(usize),
+
+    /// Pause accepting connections.
+    ///
+    /// Contains return channel to notify caller of successful state change.
+    Pause(oneshot::Sender<()>),
+
+    /// Resume accepting connections.
+    ///
+    /// Contains return channel to notify caller of successful state change.
+    Resume(oneshot::Sender<()>),
+
+    /// Stop accepting connections and begin shutdown procedure.
+    Stop {
+        /// True if shut down should be graceful.
+        graceful: bool,
+
+        /// Return channel to notify caller that shutdown is complete.
+        completion: Option<oneshot::Sender<()>>,
+
+        /// Force System exit when true, overriding `ServerBuilder::system_exit()` if it is false.
+        force_system_stop: bool,
+    },
+}
+
+/// General purpose TCP server that runs services receiving Tokio `TcpStream`s.
+///
+/// Handles creating worker threads, restarting faulted workers, connection accepting, and
+/// back-pressure logic.
+///
+/// Creates a worker per CPU core (or the number specified in [`ServerBuilder::workers`]) and
+/// distributes connections with a round-robin strategy.
+///
+/// The [Server] must be awaited or polled in order to start running. It will resolve when the
+/// server has fully shut down.
+///
+/// # Shutdown Signals
+/// On UNIX systems, `SIGTERM` will start a graceful shutdown and `SIGQUIT` or `SIGINT` will start a
+/// forced shutdown. On Windows, a Ctrl-C signal will start a forced shutdown.
+///
+/// A graceful shutdown will wait for all workers to stop first.
+///
+/// # Examples
+/// The following is a TCP echo server. Test using `telnet 127.0.0.1 8080`.
+///
+/// ```no_run
+/// use std::io;
+///
+/// use actix_rt::net::TcpStream;
+/// use actix_server::Server;
+/// use actix_service::{fn_service, ServiceFactoryExt as _};
+/// use bytes::BytesMut;
+/// use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     let bind_addr = ("127.0.0.1", 8080);
+///
+///     Server::build()
+///         .bind("echo", bind_addr, move || {
+///             fn_service(move |mut stream: TcpStream| {
+///                 async move {
+///                     let mut size = 0;
+///                     let mut buf = BytesMut::new();
+///
+///                     loop {
+///                         match stream.read_buf(&mut buf).await {
+///                             // end of stream; bail from loop
+///                             Ok(0) => break,
+///
+///                             // write bytes back to stream
+///                             Ok(bytes_read) => {
+///                                 stream.write_all(&buf[size..]).await.unwrap();
+///                                 size += bytes_read;
+///                             }
+///
+///                             Err(err) => {
+///                                 eprintln!("Stream Error: {:?}", err);
+///                                 return Err(());
+///                             }
+///                         }
+///                     }
+///
+///                     Ok(())
+///                 }
+///             })
+///             .map_err(|err| eprintln!("Service Error: {:?}", err))
+///         })?
+///         .run()
+///         .await
+/// }
+/// ```
+#[must_use = "Server does nothing unless you `.await` or poll it"]
+pub struct Server {
+    handle: ServerHandle,
+    fut: BoxFuture<'static, io::Result<()>>,
+}
+
+impl Server {
+    /// Create server build.
+    pub fn build() -> ServerBuilder {
+        ServerBuilder::default()
+    }
+
+    pub(crate) fn new(builder: ServerBuilder) -> Self {
+        Server {
+            handle: ServerHandle::new(builder.cmd_tx.clone()),
+            fut: Box::pin(ServerInner::run(builder)),
+        }
+    }
+
+    /// Get a `Server` handle that can be used issue commands and change it's state.
+    ///
+    /// See [ServerHandle](ServerHandle) for usage.
+    pub fn handle(&self) -> ServerHandle {
+        self.handle.clone()
+    }
+}
+
+impl Future for Server {
+    type Output = io::Result<()>;
+
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut Pin::into_inner(self).fut).poll(cx)
+    }
+}
+
+pub struct ServerInner {
+    worker_handles: Vec<WorkerHandleServer>,
+    accept_handle: Option<thread::JoinHandle<()>>,
+    worker_config: ServerWorkerConfig,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    waker_queue: WakerQueue,
+    system_stop: bool,
+    stopping: bool,
+}
+
+impl ServerInner {
+    async fn run(builder: ServerBuilder) -> io::Result<()> {
+        let (mut this, mut mux) = Self::run_sync(builder)?;
+
+        while let Some(cmd) = mux.next().await {
+            this.handle_cmd(cmd).await;
+
+            if this.stopping {
+                break;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn run_sync(mut builder: ServerBuilder) -> io::Result<(Self, ServerEventMultiplexer)> {
+        // Give log information on what runtime will be used.
+        let is_actix = actix_rt::System::try_current().is_some();
+        let is_tokio = tokio::runtime::Handle::try_current().is_ok();
+
+        match (is_actix, is_tokio) {
+            (true, _) => info!("Actix runtime found; starting in Actix runtime"),
+            (_, true) => info!("Tokio runtime found; starting in existing Tokio runtime"),
+            (_, false) => panic!("Actix or Tokio runtime not found; halting"),
+        }
+
+        for (_, name, lst) in &builder.sockets {
+            info!(
+                r#"starting service: "{}", workers: {}, listening on: {}"#,
+                name,
+                builder.threads,
+                lst.local_addr()
+            );
+        }
+
+        let sockets = mem::take(&mut builder.sockets)
+            .into_iter()
+            .map(|t| (t.0, t.2))
+            .collect();
+
+        let (waker_queue, worker_handles, accept_handle) = Accept::start(sockets, &builder)?;
+
+        let mux = ServerEventMultiplexer {
+            signal_fut: (builder.listen_os_signals).then(Signals::new),
+            cmd_rx: builder.cmd_rx,
+        };
+
+        let server = ServerInner {
+            waker_queue,
+            accept_handle: Some(accept_handle),
+            worker_handles,
+            worker_config: builder.worker_config,
+            services: builder.factories,
+            system_stop: builder.exit,
+            stopping: false,
+        };
+
+        Ok((server, mux))
+    }
+
+    async fn handle_cmd(&mut self, item: ServerCommand) {
+        match item {
+            ServerCommand::Pause(tx) => {
+                self.waker_queue.wake(WakerInterest::Pause);
+                let _ = tx.send(());
+            }
+
+            ServerCommand::Resume(tx) => {
+                self.waker_queue.wake(WakerInterest::Resume);
+                let _ = tx.send(());
+            }
+
+            ServerCommand::Stop {
+                graceful,
+                completion,
+                force_system_stop,
+            } => {
+                self.stopping = true;
+
+                // Signal accept thread to stop.
+                // Signal is non-blocking; we wait for thread to stop later.
+                self.waker_queue.wake(WakerInterest::Stop);
+
+                // send stop signal to workers
+                let workers_stop = self
+                    .worker_handles
+                    .iter()
+                    .map(|worker| worker.stop(graceful))
+                    .collect::<Vec<_>>();
+
+                if graceful {
+                    // wait for all workers to shut down
+                    let _ = join_all(workers_stop).await;
+                }
+
+                // wait for accept thread stop
+                self.accept_handle
+                    .take()
+                    .unwrap()
+                    .join()
+                    .expect("Accept thread must not panic in any case");
+
+                if let Some(tx) = completion {
+                    let _ = tx.send(());
+                }
+
+                if self.system_stop || force_system_stop {
+                    sleep(Duration::from_millis(300)).await;
+                    System::try_current().as_ref().map(System::stop);
+                }
+            }
+
+            ServerCommand::WorkerFaulted(idx) => {
+                // TODO: maybe just return with warning log if not found ?
+                assert!(self.worker_handles.iter().any(|wrk| wrk.idx == idx));
+
+                error!("worker {} has died; restarting", idx);
+
+                let factories = self
+                    .services
+                    .iter()
+                    .map(|service| service.clone_factory())
+                    .collect();
+
+                match ServerWorker::start(
+                    idx,
+                    factories,
+                    self.waker_queue.clone(),
+                    self.worker_config,
+                ) {
+                    Ok((handle_accept, handle_server)) => {
+                        *self
+                            .worker_handles
+                            .iter_mut()
+                            .find(|wrk| wrk.idx == idx)
+                            .unwrap() = handle_server;
+
+                        self.waker_queue.wake(WakerInterest::Worker(handle_accept));
+                    }
+
+                    Err(err) => error!("can not restart worker {}: {}", idx, err),
+                };
+            }
+        }
+    }
+
+    fn map_signal(signal: SignalKind) -> ServerCommand {
+        match signal {
+            SignalKind::Int => {
+                info!("SIGINT received; starting forced shutdown");
+                ServerCommand::Stop {
+                    graceful: false,
+                    completion: None,
+                    force_system_stop: true,
+                }
+            }
+
+            SignalKind::Term => {
+                info!("SIGTERM received; starting graceful shutdown");
+                ServerCommand::Stop {
+                    graceful: true,
+                    completion: None,
+                    force_system_stop: true,
+                }
+            }
+
+            SignalKind::Quit => {
+                info!("SIGQUIT received; starting forced shutdown");
+                ServerCommand::Stop {
+                    graceful: false,
+                    completion: None,
+                    force_system_stop: true,
+                }
+            }
+        }
+    }
+}
+
+struct ServerEventMultiplexer {
+    cmd_rx: UnboundedReceiver<ServerCommand>,
+    signal_fut: Option<Signals>,
+}
+
+impl Stream for ServerEventMultiplexer {
+    type Item = ServerCommand;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = Pin::into_inner(self);
+
+        if let Some(signal_fut) = &mut this.signal_fut {
+            if let Poll::Ready(signal) = Pin::new(signal_fut).poll(cx) {
+                this.signal_fut = None;
+                return Poll::Ready(Some(ServerInner::map_signal(signal)));
+            }
+        }
+
+        this.cmd_rx.poll_recv(cx)
+    }
+}

actix-server/src/service.rs

@@ -0,0 +1,162 @@
+use std::{
+    marker::PhantomData,
+    net::SocketAddr,
+    task::{Context, Poll},
+};
+
+use actix_service::{Service, ServiceFactory as BaseServiceFactory};
+use actix_utils::future::{ready, Ready};
+use futures_core::future::LocalBoxFuture;
+use tracing::error;
+
+use crate::{
+    socket::{FromStream, MioStream},
+    worker::WorkerCounterGuard,
+};
+
+#[doc(hidden)]
+pub trait ServerServiceFactory<Stream: FromStream>: Send + Clone + 'static {
+    type Factory: BaseServiceFactory<Stream, Config = ()>;
+
+    fn create(&self) -> Self::Factory;
+}
+
+pub(crate) trait InternalServiceFactory: Send {
+    fn name(&self, token: usize) -> &str;
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
+
+    fn create(&self) -> LocalBoxFuture<'static, Result<(usize, BoxedServerService), ()>>;
+}
+
+pub(crate) type BoxedServerService = Box<
+    dyn Service<
+        (WorkerCounterGuard, MioStream),
+        Response = (),
+        Error = (),
+        Future = Ready<Result<(), ()>>,
+    >,
+>;
+
+pub(crate) struct StreamService<S, I> {
+    service: S,
+    _phantom: PhantomData<I>,
+}
+
+impl<S, I> StreamService<S, I> {
+    pub(crate) fn new(service: S) -> Self {
+        StreamService {
+            service,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<S, I> Service<(WorkerCounterGuard, MioStream)> for StreamService<S, I>
+where
+    S: Service<I>,
+    S::Future: 'static,
+    S::Error: 'static,
+    I: FromStream,
+{
+    type Response = ();
+    type Error = ();
+    type Future = Ready<Result<(), ()>>;
+
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(ctx).map_err(|_| ())
+    }
+
+    fn call(&self, (guard, req): (WorkerCounterGuard, 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);
+                });
+                Ok(())
+            }
+            Err(err) => {
+                error!("can not convert to an async TCP stream: {err}");
+                Err(())
+            }
+        })
+    }
+}
+
+pub(crate) struct StreamNewService<F: ServerServiceFactory<Io>, Io: FromStream> {
+    name: String,
+    inner: F,
+    token: usize,
+    addr: SocketAddr,
+    _t: PhantomData<Io>,
+}
+
+impl<F, Io> StreamNewService<F, Io>
+where
+    F: ServerServiceFactory<Io>,
+    Io: FromStream + Send + 'static,
+{
+    pub(crate) fn create(
+        name: String,
+        token: usize,
+        inner: F,
+        addr: SocketAddr,
+    ) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            name,
+            token,
+            inner,
+            addr,
+            _t: PhantomData,
+        })
+    }
+}
+
+impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
+where
+    F: ServerServiceFactory<Io>,
+    Io: FromStream + Send + 'static,
+{
+    fn name(&self, _: usize) -> &str {
+        &self.name
+    }
+
+    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
+        Box::new(Self {
+            name: self.name.clone(),
+            inner: self.inner.clone(),
+            token: self.token,
+            addr: self.addr,
+            _t: PhantomData,
+        })
+    }
+
+    fn create(&self) -> LocalBoxFuture<'static, Result<(usize, BoxedServerService), ()>> {
+        let token = self.token;
+        let fut = self.inner.create().new_service(());
+        Box::pin(async move {
+            match fut.await {
+                Ok(inner) => {
+                    let service = Box::new(StreamService::new(inner)) as _;
+                    Ok((token, service))
+                }
+                Err(_) => Err(()),
+            }
+        })
+    }
+}
+
+impl<F, T, I> ServerServiceFactory<I> for F
+where
+    F: Fn() -> T + Send + Clone + 'static,
+    T: BaseServiceFactory<I, Config = ()>,
+    I: FromStream,
+{
+    type Factory = T;
+
+    fn create(&self) -> T {
+        (self)()
+    }
+}

actix-server/src/signals.rs

@@ -0,0 +1,108 @@
+use std::{
+    fmt,
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use tracing::trace;
+
+/// Types of process signals.
+// #[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[allow(dead_code)] // variants are never constructed on non-unix
+pub(crate) enum SignalKind {
+    /// `SIGINT`
+    Int,
+
+    /// `SIGTERM`
+    Term,
+
+    /// `SIGQUIT`
+    Quit,
+}
+
+impl fmt::Display for SignalKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            SignalKind::Int => "SIGINT",
+            SignalKind::Term => "SIGTERM",
+            SignalKind::Quit => "SIGQUIT",
+        })
+    }
+}
+
+/// Process signal listener.
+pub(crate) struct Signals {
+    #[cfg(not(unix))]
+    signals: futures_core::future::BoxFuture<'static, std::io::Result<()>>,
+
+    #[cfg(unix)]
+    signals: Vec<(SignalKind, actix_rt::signal::unix::Signal)>,
+}
+
+impl Signals {
+    /// Constructs an OS signal listening future.
+    pub(crate) fn new() -> Self {
+        trace!("setting up OS signal listener");
+
+        #[cfg(not(unix))]
+        {
+            Signals {
+                signals: Box::pin(actix_rt::signal::ctrl_c()),
+            }
+        }
+
+        #[cfg(unix)]
+        {
+            use actix_rt::signal::unix;
+
+            let sig_map = [
+                (unix::SignalKind::interrupt(), SignalKind::Int),
+                (unix::SignalKind::terminate(), SignalKind::Term),
+                (unix::SignalKind::quit(), SignalKind::Quit),
+            ];
+
+            let signals = sig_map
+                .iter()
+                .filter_map(|(kind, sig)| {
+                    unix::signal(*kind)
+                        .map(|tokio_sig| (*sig, tokio_sig))
+                        .map_err(|e| {
+                            tracing::error!(
+                                "can not initialize stream handler for {:?} err: {}",
+                                sig,
+                                e
+                            )
+                        })
+                        .ok()
+                })
+                .collect::<Vec<_>>();
+
+            Signals { signals }
+        }
+    }
+}
+
+impl Future for Signals {
+    type Output = SignalKind;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        #[cfg(not(unix))]
+        {
+            self.signals.as_mut().poll(cx).map(|_| SignalKind::Int)
+        }
+
+        #[cfg(unix)]
+        {
+            for (sig, fut) in self.signals.iter_mut() {
+                if fut.poll_recv(cx).is_ready() {
+                    trace!("{} received", sig);
+                    return Poll::Ready(*sig);
+                }
+            }
+
+            Poll::Pending
+        }
+    }
+}

actix-server/src/socket.rs

@@ -0,0 +1,294 @@
+pub(crate) use std::net::{
+    SocketAddr as StdSocketAddr, TcpListener as StdTcpListener, ToSocketAddrs,
+};
+use std::{fmt, io};
+
+use actix_rt::net::TcpStream;
+pub(crate) use mio::net::TcpListener as MioTcpListener;
+use mio::{event::Source, Interest, Registry, Token};
+#[cfg(unix)]
+pub(crate) use {
+    mio::net::UnixListener as MioUnixListener, std::os::unix::net::UnixListener as StdUnixListener,
+};
+
+use crate::builder::MpTcp;
+
+pub(crate) enum MioListener {
+    Tcp(MioTcpListener),
+    #[cfg(unix)]
+    Uds(MioUnixListener),
+}
+
+impl MioListener {
+    pub(crate) fn local_addr(&self) -> SocketAddr {
+        match *self {
+            MioListener::Tcp(ref lst) => lst
+                .local_addr()
+                .map(SocketAddr::Tcp)
+                .unwrap_or(SocketAddr::Unknown),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => lst
+                .local_addr()
+                .map(SocketAddr::Uds)
+                .unwrap_or(SocketAddr::Unknown),
+        }
+    }
+
+    pub(crate) fn accept(&self) -> io::Result<MioStream> {
+        match *self {
+            MioListener::Tcp(ref lst) => lst.accept().map(|(stream, _)| MioStream::Tcp(stream)),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => lst.accept().map(|(stream, _)| MioStream::Uds(stream)),
+        }
+    }
+}
+
+impl Source for MioListener {
+    fn register(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+    ) -> io::Result<()> {
+        match *self {
+            MioListener::Tcp(ref mut lst) => lst.register(registry, token, interests),
+            #[cfg(unix)]
+            MioListener::Uds(ref mut lst) => lst.register(registry, token, interests),
+        }
+    }
+
+    fn reregister(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+    ) -> io::Result<()> {
+        match *self {
+            MioListener::Tcp(ref mut lst) => lst.reregister(registry, token, interests),
+            #[cfg(unix)]
+            MioListener::Uds(ref mut lst) => lst.reregister(registry, token, interests),
+        }
+    }
+
+    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
+        match *self {
+            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() {
+                    if let Some(path) = addr.as_pathname() {
+                        let _ = std::fs::remove_file(path);
+                    }
+                }
+                res
+            }
+        }
+    }
+}
+
+impl From<StdTcpListener> for MioListener {
+    fn from(lst: StdTcpListener) -> Self {
+        MioListener::Tcp(MioTcpListener::from_std(lst))
+    }
+}
+
+#[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(unix)]
+            MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
+        }
+    }
+}
+
+impl fmt::Display for MioListener {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            MioListener::Tcp(ref lst) => write!(f, "{:?}", lst),
+            #[cfg(unix)]
+            MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
+        }
+    }
+}
+
+pub(crate) enum SocketAddr {
+    Unknown,
+    Tcp(StdSocketAddr),
+    #[cfg(unix)]
+    Uds(std::os::unix::net::SocketAddr),
+}
+
+impl fmt::Display for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::Unknown => write!(f, "Unknown SocketAddr"),
+            Self::Tcp(ref addr) => write!(f, "{}", addr),
+            #[cfg(unix)]
+            Self::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+impl fmt::Debug for SocketAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::Unknown => write!(f, "Unknown SocketAddr"),
+            Self::Tcp(ref addr) => write!(f, "{:?}", addr),
+            #[cfg(unix)]
+            Self::Uds(ref addr) => write!(f, "{:?}", addr),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum MioStream {
+    Tcp(mio::net::TcpStream),
+    #[cfg(unix)]
+    Uds(mio::net::UnixStream),
+}
+
+/// Helper trait for converting a Mio stream into a Tokio stream.
+pub trait FromStream: Sized {
+    /// Creates stream from a `mio` stream.
+    fn from_mio(sock: MioStream) -> io::Result<Self>;
+}
+
+#[cfg(windows)]
+mod win_impl {
+    use std::os::windows::io::{FromRawSocket, IntoRawSocket};
+
+    use super::*;
+
+    // TODO: This is a workaround and we need an efficient way to convert between Mio and Tokio stream
+    impl FromStream for TcpStream {
+        fn from_mio(sock: MioStream) -> io::Result<Self> {
+            match sock {
+                MioStream::Tcp(mio) => {
+                    let raw = IntoRawSocket::into_raw_socket(mio);
+                    // SAFETY: This is an in-place conversion from Mio stream to Tokio stream.
+                    TcpStream::from_std(unsafe { FromRawSocket::from_raw_socket(raw) })
+                }
+            }
+        }
+    }
+}
+
+#[cfg(unix)]
+mod unix_impl {
+    use std::os::unix::io::{FromRawFd, IntoRawFd};
+
+    use actix_rt::net::UnixStream;
+
+    use super::*;
+
+    // HACK: This is a workaround and we need an efficient way to convert between Mio and Tokio stream
+    impl FromStream for TcpStream {
+        fn from_mio(sock: MioStream) -> io::Result<Self> {
+            match sock {
+                MioStream::Tcp(mio) => {
+                    let raw = IntoRawFd::into_raw_fd(mio);
+                    // SAFETY: This is an 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");
+                }
+            }
+        }
+    }
+
+    // HACK: This is a workaround and we need an efficient way to convert between Mio and Tokio stream
+    impl FromStream for UnixStream {
+        fn from_mio(sock: MioStream) -> io::Result<Self> {
+            match sock {
+                MioStream::Tcp(_) => panic!("Should not happen, bug in server impl"),
+                MioStream::Uds(mio) => {
+                    let raw = IntoRawFd::into_raw_fd(mio);
+                    // SAFETY: This is an in-place conversion from Mio stream to Tokio stream.
+                    UnixStream::from_std(unsafe { FromRawFd::from_raw_fd(raw) })
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn create_mio_tcp_listener(
+    addr: StdSocketAddr,
+    backlog: u32,
+    mptcp: &MpTcp,
+) -> io::Result<MioTcpListener> {
+    use socket2::{Domain, Protocol, Socket, Type};
+
+    #[cfg(not(target_os = "linux"))]
+    let protocol = Protocol::TCP;
+    #[cfg(target_os = "linux")]
+    let protocol = if matches!(mptcp, MpTcp::Disabled) {
+        Protocol::TCP
+    } else {
+        Protocol::MPTCP
+    };
+
+    let socket = match Socket::new(Domain::for_address(addr), Type::STREAM, Some(protocol)) {
+        Ok(sock) => sock,
+
+        Err(err) if matches!(mptcp, MpTcp::TcpFallback) => {
+            tracing::warn!("binding socket as MPTCP failed: {err}");
+            tracing::warn!("falling back to TCP");
+            Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?
+        }
+
+        Err(err) => return Err(err),
+    };
+
+    socket.set_reuse_address(true)?;
+    socket.set_nonblocking(true)?;
+    socket.bind(&addr.into())?;
+    socket.listen(backlog as i32)?;
+
+    Ok(MioTcpListener::from_std(StdTcpListener::from(socket)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn socket_addr() {
+        let addr = SocketAddr::Tcp("127.0.0.1:8080".parse().unwrap());
+        assert!(format!("{:?}", addr).contains("127.0.0.1:8080"));
+        assert_eq!(format!("{}", addr), "127.0.0.1:8080");
+
+        let addr: StdSocketAddr = "127.0.0.1:0".parse().unwrap();
+        let lst = create_mio_tcp_listener(addr, 128, &MpTcp::Disabled).unwrap();
+        let lst = MioListener::Tcp(lst);
+        assert!(format!("{:?}", lst).contains("TcpListener"));
+        assert!(format!("{}", lst).contains("127.0.0.1"));
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn uds() {
+        let _ = std::fs::remove_file("/tmp/sock.xxxxx");
+        if let Ok(socket) = MioUnixListener::bind("/tmp/sock.xxxxx") {
+            let addr = socket.local_addr().expect("Couldn't get local address");
+            let a = SocketAddr::Uds(addr);
+            assert!(format!("{:?}", a).contains("/tmp/sock.xxxxx"));
+            assert!(format!("{}", a).contains("/tmp/sock.xxxxx"));
+
+            let lst = MioListener::Uds(socket);
+            assert!(format!("{:?}", lst).contains("/tmp/sock.xxxxx"));
+            assert!(format!("{}", lst).contains("/tmp/sock.xxxxx"));
+        }
+    }
+}

actix-server/src/test_server.rs

@@ -0,0 +1,155 @@
+use std::{io, net, sync::mpsc, thread};
+
+use actix_rt::{net::TcpStream, System};
+
+use crate::{Server, ServerBuilder, ServerHandle, ServerServiceFactory};
+
+/// A testing server.
+///
+/// `TestServer` is very simple test server that simplify process of writing integration tests for
+/// network applications.
+///
+/// # Examples
+/// ```
+/// use actix_service::fn_service;
+/// use actix_server::TestServer;
+///
+/// #[actix_rt::main]
+/// async fn main() {
+///     let srv = TestServer::start(|| fn_service(
+///         |sock| async move {
+///             println!("New connection: {:?}", sock);
+///             Ok::<_, ()>(())
+///         }
+///     ));
+///
+///     println!("SOCKET: {:?}", srv.connect());
+/// }
+/// ```
+pub struct TestServer;
+
+/// Test server handle.
+pub struct TestServerHandle {
+    addr: net::SocketAddr,
+    host: String,
+    port: u16,
+    server_handle: ServerHandle,
+    thread_handle: Option<thread::JoinHandle<io::Result<()>>>,
+}
+
+impl TestServer {
+    /// Start new `TestServer` using application factory and default server config.
+    pub fn start(factory: impl ServerServiceFactory<TcpStream>) -> TestServerHandle {
+        Self::start_with_builder(Server::build(), factory)
+    }
+
+    /// Start new `TestServer` using application factory and server builder.
+    pub fn start_with_builder(
+        server_builder: ServerBuilder,
+        factory: impl ServerServiceFactory<TcpStream>,
+    ) -> TestServerHandle {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        let thread_handle = thread::spawn(move || {
+            let lst = net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let local_addr = lst.local_addr().unwrap();
+
+            System::new().block_on(async {
+                let server = server_builder
+                    .listen("test", lst, factory)
+                    .unwrap()
+                    .workers(1)
+                    .disable_signals()
+                    .run();
+
+                tx.send((server.handle(), local_addr)).unwrap();
+                server.await
+            })
+        });
+
+        let (server_handle, addr) = rx.recv().unwrap();
+
+        let host = format!("{}", addr.ip());
+        let port = addr.port();
+
+        TestServerHandle {
+            addr,
+            host,
+            port,
+            server_handle,
+            thread_handle: Some(thread_handle),
+        }
+    }
+
+    /// Get first available unused local address.
+    pub fn unused_addr() -> net::SocketAddr {
+        use socket2::{Domain, Protocol, Socket, Type};
+
+        let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+        let domain = Domain::for_address(addr);
+        let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP)).unwrap();
+
+        socket.set_reuse_address(true).unwrap();
+        socket.set_nonblocking(true).unwrap();
+        socket.bind(&addr.into()).unwrap();
+        socket.listen(1024).unwrap();
+
+        net::TcpListener::from(socket).local_addr().unwrap()
+    }
+}
+
+impl TestServerHandle {
+    /// Test server host.
+    pub fn host(&self) -> &str {
+        &self.host
+    }
+
+    /// Test server port.
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    /// Get test server address.
+    pub fn addr(&self) -> net::SocketAddr {
+        self.addr
+    }
+
+    /// Stop server.
+    fn stop(&mut self) {
+        drop(self.server_handle.stop(false));
+        self.thread_handle.take().unwrap().join().unwrap().unwrap();
+    }
+
+    /// Connect to server, returning a Tokio `TcpStream`.
+    pub fn connect(&self) -> io::Result<TcpStream> {
+        let stream = net::TcpStream::connect(self.addr)?;
+        stream.set_nonblocking(true)?;
+        TcpStream::from_std(stream)
+    }
+}
+
+impl Drop for TestServerHandle {
+    fn drop(&mut self) {
+        self.stop()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_service::fn_service;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn connect_in_tokio_runtime() {
+        let srv = TestServer::start(|| fn_service(|_sock| async move { Ok::<_, ()>(()) }));
+        assert!(srv.connect().is_ok());
+    }
+
+    #[actix_rt::test]
+    async fn connect_in_actix_runtime() {
+        let srv = TestServer::start(|| fn_service(|_sock| async move { Ok::<_, ()>(()) }));
+        assert!(srv.connect().is_ok());
+    }
+}

actix-server/src/waker_queue.rs

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

actix-server/src/worker.rs

@@ -0,0 +1,731 @@
+use std::{
+    future::Future,
+    io, mem,
+    num::NonZeroUsize,
+    pin::Pin,
+    rc::Rc,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use actix_rt::{
+    spawn,
+    time::{sleep, Instant, Sleep},
+    Arbiter, ArbiterHandle, System,
+};
+use futures_core::{future::LocalBoxFuture, ready};
+use tokio::sync::{
+    mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
+    oneshot,
+};
+use tracing::{error, info, trace};
+
+use crate::{
+    service::{BoxedServerService, InternalServiceFactory},
+    socket::MioStream,
+    waker_queue::{WakerInterest, WakerQueue},
+};
+
+/// Stop worker message. Returns `true` on successful graceful shutdown
+/// and `false` if some connections still alive when shutdown execute.
+pub(crate) struct Stop {
+    graceful: bool,
+    tx: oneshot::Sender<bool>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Conn {
+    pub io: MioStream,
+    pub token: usize,
+}
+
+/// Create accept and server worker handles.
+fn handle_pair(
+    idx: usize,
+    conn_tx: UnboundedSender<Conn>,
+    stop_tx: UnboundedSender<Stop>,
+    counter: Counter,
+) -> (WorkerHandleAccept, WorkerHandleServer) {
+    let accept = WorkerHandleAccept {
+        idx,
+        conn_tx,
+        counter,
+    };
+
+    let server = WorkerHandleServer { idx, stop_tx };
+
+    (accept, server)
+}
+
+/// counter: Arc<AtomicUsize> field is owned by `Accept` thread and `ServerWorker` thread.
+///
+/// `Accept` would increment the counter and `ServerWorker` would decrement it.
+///
+/// # Atomic Ordering:
+///
+/// `Accept` always look into it's cached `Availability` field for `ServerWorker` state.
+/// It lazily increment counter after successful dispatching new work to `ServerWorker`.
+/// On reaching counter limit `Accept` update it's cached `Availability` and mark worker as
+/// unable to accept any work.
+///
+/// `ServerWorker` always decrement the counter when every work received from `Accept` is done.
+/// On reaching counter limit worker would use `mio::Waker` and `WakerQueue` to wake up `Accept`
+/// and notify it to update cached `Availability` again to mark worker as able to accept work again.
+///
+/// Hence, a wake up would only happen after `Accept` increment it to limit.
+/// And a decrement to limit always wake up `Accept`.
+#[derive(Clone)]
+pub(crate) struct Counter {
+    counter: Arc<AtomicUsize>,
+    limit: usize,
+}
+
+impl Counter {
+    pub(crate) fn new(limit: usize) -> Self {
+        Self {
+            counter: Arc::new(AtomicUsize::new(1)),
+            limit,
+        }
+    }
+
+    /// Increment counter by 1 and return true when hitting limit
+    #[inline(always)]
+    pub(crate) fn inc(&self) -> bool {
+        self.counter.fetch_add(1, Ordering::Relaxed) != self.limit
+    }
+
+    /// Decrement counter by 1 and return true if crossing limit.
+    #[inline(always)]
+    pub(crate) fn dec(&self) -> bool {
+        self.counter.fetch_sub(1, Ordering::Relaxed) == self.limit
+    }
+
+    pub(crate) fn total(&self) -> usize {
+        self.counter.load(Ordering::SeqCst) - 1
+    }
+}
+
+pub(crate) struct WorkerCounter {
+    idx: usize,
+    inner: Rc<(WakerQueue, Counter)>,
+}
+
+impl Clone for WorkerCounter {
+    fn clone(&self) -> Self {
+        Self {
+            idx: self.idx,
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl WorkerCounter {
+    pub(crate) fn new(idx: usize, waker_queue: WakerQueue, counter: Counter) -> Self {
+        Self {
+            idx,
+            inner: Rc::new((waker_queue, counter)),
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn guard(&self) -> WorkerCounterGuard {
+        WorkerCounterGuard(self.clone())
+    }
+
+    fn total(&self) -> usize {
+        self.inner.1.total()
+    }
+}
+
+pub(crate) struct WorkerCounterGuard(WorkerCounter);
+
+impl Drop for WorkerCounterGuard {
+    fn drop(&mut self) {
+        let (waker_queue, counter) = &*self.0.inner;
+        if counter.dec() {
+            waker_queue.wake(WakerInterest::WorkerAvailable(self.0.idx));
+        }
+    }
+}
+
+/// Handle to worker that can send connection message to worker and share the availability of worker
+/// to other threads.
+///
+/// Held by [Accept](crate::accept::Accept).
+pub(crate) struct WorkerHandleAccept {
+    idx: usize,
+    conn_tx: UnboundedSender<Conn>,
+    counter: Counter,
+}
+
+impl WorkerHandleAccept {
+    #[inline(always)]
+    pub(crate) fn idx(&self) -> usize {
+        self.idx
+    }
+
+    #[inline(always)]
+    pub(crate) fn send(&self, conn: Conn) -> Result<(), Conn> {
+        self.conn_tx.send(conn).map_err(|msg| msg.0)
+    }
+
+    #[inline(always)]
+    pub(crate) fn inc_counter(&self) -> bool {
+        self.counter.inc()
+    }
+}
+
+/// Handle to worker than can send stop message to worker.
+///
+/// Held by [ServerBuilder](crate::builder::ServerBuilder).
+#[derive(Debug)]
+pub(crate) struct WorkerHandleServer {
+    pub(crate) idx: usize,
+    stop_tx: UnboundedSender<Stop>,
+}
+
+impl WorkerHandleServer {
+    pub(crate) fn stop(&self, graceful: bool) -> oneshot::Receiver<bool> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.stop_tx.send(Stop { graceful, tx });
+        rx
+    }
+}
+
+/// Service worker.
+///
+/// Worker accepts Socket objects via unbounded channel and starts stream processing.
+pub(crate) struct ServerWorker {
+    // UnboundedReceiver<Conn> should always be the first field.
+    // It must be dropped as soon as ServerWorker dropping.
+    conn_rx: UnboundedReceiver<Conn>,
+    stop_rx: UnboundedReceiver<Stop>,
+    counter: WorkerCounter,
+    services: Box<[WorkerService]>,
+    factories: Box<[Box<dyn InternalServiceFactory>]>,
+    state: WorkerState,
+    shutdown_timeout: Duration,
+}
+
+struct WorkerService {
+    factory_idx: usize,
+    status: WorkerServiceStatus,
+    service: BoxedServerService,
+}
+
+impl WorkerService {
+    fn created(&mut self, service: BoxedServerService) {
+        self.service = service;
+        self.status = WorkerServiceStatus::Unavailable;
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WorkerServiceStatus {
+    Available,
+    Unavailable,
+    Failed,
+    Restarting,
+    Stopping,
+    Stopped,
+}
+
+impl Default for WorkerServiceStatus {
+    fn default() -> Self {
+        Self::Unavailable
+    }
+}
+
+/// Config for worker behavior passed down from server builder.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct ServerWorkerConfig {
+    shutdown_timeout: Duration,
+    max_blocking_threads: usize,
+    max_concurrent_connections: usize,
+}
+
+impl Default for ServerWorkerConfig {
+    fn default() -> Self {
+        let parallelism = std::thread::available_parallelism().map_or(2, NonZeroUsize::get);
+
+        // 512 is the default max blocking thread count of a Tokio runtime.
+        let max_blocking_threads = std::cmp::max(512 / parallelism, 1);
+
+        Self {
+            shutdown_timeout: Duration::from_secs(30),
+            max_blocking_threads,
+            max_concurrent_connections: 25600,
+        }
+    }
+}
+
+impl ServerWorkerConfig {
+    pub(crate) fn max_blocking_threads(&mut self, num: usize) {
+        self.max_blocking_threads = num;
+    }
+
+    pub(crate) fn max_concurrent_connections(&mut self, num: usize) {
+        self.max_concurrent_connections = num;
+    }
+
+    pub(crate) fn shutdown_timeout(&mut self, dur: Duration) {
+        self.shutdown_timeout = dur;
+    }
+}
+
+impl ServerWorker {
+    pub(crate) fn start(
+        idx: usize,
+        factories: Vec<Box<dyn InternalServiceFactory>>,
+        waker_queue: WakerQueue,
+        config: ServerWorkerConfig,
+    ) -> io::Result<(WorkerHandleAccept, WorkerHandleServer)> {
+        trace!("starting server worker {}", idx);
+
+        let (tx1, conn_rx) = unbounded_channel();
+        let (tx2, stop_rx) = unbounded_channel();
+
+        let counter = Counter::new(config.max_concurrent_connections);
+        let pair = handle_pair(idx, tx1, tx2, counter.clone());
+
+        // get actix system context if it is set
+        let actix_system = System::try_current();
+
+        // get tokio runtime handle if it is set
+        let tokio_handle = tokio::runtime::Handle::try_current().ok();
+
+        // service factories initialization channel
+        let (factory_tx, factory_rx) = std::sync::mpsc::sync_channel::<io::Result<()>>(1);
+
+        // outline of following code:
+        //
+        // if system exists
+        //   if uring enabled
+        //     start arbiter using uring method
+        //   else
+        //     start arbiter with regular tokio
+        // else
+        //   if uring enabled
+        //     start uring in spawned thread
+        //   else
+        //     start regular tokio in spawned thread
+
+        // every worker runs in it's own thread and tokio runtime.
+        // use a custom tokio runtime builder to change the settings of runtime.
+
+        match (actix_system, tokio_handle) {
+            (None, None) => {
+                panic!("No runtime detected. Start a Tokio (or Actix) runtime.");
+            }
+
+            // no actix system
+            (None, Some(rt_handle)) => {
+                std::thread::Builder::new()
+                    .name(format!("actix-server worker {}", idx))
+                    .spawn(move || {
+                        let (worker_stopped_tx, worker_stopped_rx) = oneshot::channel();
+
+                        // local set for running service init futures and worker services
+                        let ls = tokio::task::LocalSet::new();
+
+                        // init services using existing Tokio runtime (so probably on main thread)
+                        let services = rt_handle.block_on(ls.run_until(async {
+                            let mut services = Vec::new();
+
+                            for (idx, factory) in factories.iter().enumerate() {
+                                match factory.create().await {
+                                    Ok((token, svc)) => services.push((idx, token, svc)),
+
+                                    Err(err) => {
+                                        error!("can not start worker: {:?}", err);
+                                        return Err(io::Error::new(
+                                            io::ErrorKind::Other,
+                                            format!("can not start server service {}", idx),
+                                        ));
+                                    }
+                                }
+                            }
+
+                            Ok(services)
+                        }));
+
+                        let services = match services {
+                            Ok(services) => {
+                                factory_tx.send(Ok(())).unwrap();
+                                services
+                            }
+                            Err(err) => {
+                                factory_tx.send(Err(err)).unwrap();
+                                return;
+                            }
+                        };
+
+                        let worker_services = wrap_worker_services(services);
+
+                        let worker_fut = async move {
+                            // spawn to make sure ServerWorker runs as non boxed future.
+                            spawn(async move {
+                                ServerWorker {
+                                    conn_rx,
+                                    stop_rx,
+                                    services: worker_services.into_boxed_slice(),
+                                    counter: WorkerCounter::new(idx, waker_queue, counter),
+                                    factories: factories.into_boxed_slice(),
+                                    state: WorkerState::default(),
+                                    shutdown_timeout: config.shutdown_timeout,
+                                }
+                                .await;
+
+                                // wake up outermost task waiting for shutdown
+                                worker_stopped_tx.send(()).unwrap();
+                            });
+
+                            worker_stopped_rx.await.unwrap();
+                        };
+
+                        #[cfg(all(target_os = "linux", feature = "io-uring"))]
+                        {
+                            // TODO: pass max blocking thread config when tokio-uring enable configuration
+                            // on building runtime.
+                            let _ = config.max_blocking_threads;
+                            tokio_uring::start(worker_fut);
+                        }
+
+                        #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+                        {
+                            let rt = tokio::runtime::Builder::new_current_thread()
+                                .enable_all()
+                                .max_blocking_threads(config.max_blocking_threads)
+                                .build()
+                                .unwrap();
+
+                            rt.block_on(ls.run_until(worker_fut));
+                        }
+                    })
+                    .expect("cannot spawn server worker thread");
+            }
+
+            // with actix system
+            (Some(_sys), _) => {
+                #[cfg(all(target_os = "linux", feature = "io-uring"))]
+                let arbiter = {
+                    // TODO: pass max blocking thread config when tokio-uring enable configuration
+                    // on building runtime.
+                    let _ = config.max_blocking_threads;
+                    Arbiter::new()
+                };
+
+                #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+                let arbiter = {
+                    Arbiter::with_tokio_rt(move || {
+                        tokio::runtime::Builder::new_current_thread()
+                            .enable_all()
+                            .max_blocking_threads(config.max_blocking_threads)
+                            .build()
+                            .unwrap()
+                    })
+                };
+
+                arbiter.spawn(async move {
+                    // spawn_local to run !Send future tasks.
+                    spawn(async move {
+                        let mut services = Vec::new();
+
+                        for (idx, factory) in factories.iter().enumerate() {
+                            match factory.create().await {
+                                Ok((token, svc)) => services.push((idx, token, svc)),
+
+                                Err(err) => {
+                                    error!("can not start worker: {:?}", err);
+                                    Arbiter::current().stop();
+                                    factory_tx
+                                        .send(Err(io::Error::new(
+                                            io::ErrorKind::Other,
+                                            format!("can not start server service {}", idx),
+                                        )))
+                                        .unwrap();
+                                    return;
+                                }
+                            }
+                        }
+
+                        factory_tx.send(Ok(())).unwrap();
+
+                        let worker_services = wrap_worker_services(services);
+
+                        // spawn to make sure ServerWorker runs as non boxed future.
+                        spawn(ServerWorker {
+                            conn_rx,
+                            stop_rx,
+                            services: worker_services.into_boxed_slice(),
+                            counter: WorkerCounter::new(idx, waker_queue, counter),
+                            factories: factories.into_boxed_slice(),
+                            state: Default::default(),
+                            shutdown_timeout: config.shutdown_timeout,
+                        });
+                    });
+                });
+            }
+        };
+
+        // wait for service factories initialization
+        factory_rx.recv().unwrap()?;
+
+        Ok(pair)
+    }
+
+    fn restart_service(&mut self, idx: usize, factory_id: usize) {
+        let factory = &self.factories[factory_id];
+        trace!("service {:?} failed, restarting", factory.name(idx));
+        self.services[idx].status = WorkerServiceStatus::Restarting;
+        self.state = WorkerState::Restarting(Restart {
+            factory_id,
+            token: idx,
+            fut: factory.create(),
+        });
+    }
+
+    fn shutdown(&mut self, force: bool) {
+        self.services
+            .iter_mut()
+            .filter(|srv| srv.status == WorkerServiceStatus::Available)
+            .for_each(|srv| {
+                srv.status = if force {
+                    WorkerServiceStatus::Stopped
+                } else {
+                    WorkerServiceStatus::Stopping
+                };
+            });
+    }
+
+    fn check_readiness(&mut self, cx: &mut Context<'_>) -> Result<bool, (usize, usize)> {
+        let mut ready = true;
+        for (idx, srv) in self.services.iter_mut().enumerate() {
+            if srv.status == WorkerServiceStatus::Available
+                || srv.status == WorkerServiceStatus::Unavailable
+            {
+                match srv.service.poll_ready(cx) {
+                    Poll::Ready(Ok(_)) => {
+                        if srv.status == WorkerServiceStatus::Unavailable {
+                            trace!(
+                                "service {:?} is available",
+                                self.factories[srv.factory_idx].name(idx)
+                            );
+                            srv.status = WorkerServiceStatus::Available;
+                        }
+                    }
+                    Poll::Pending => {
+                        ready = false;
+
+                        if srv.status == WorkerServiceStatus::Available {
+                            trace!(
+                                "service {:?} is unavailable",
+                                self.factories[srv.factory_idx].name(idx)
+                            );
+                            srv.status = WorkerServiceStatus::Unavailable;
+                        }
+                    }
+                    Poll::Ready(Err(_)) => {
+                        error!(
+                            "service {:?} readiness check returned error, restarting",
+                            self.factories[srv.factory_idx].name(idx)
+                        );
+                        srv.status = WorkerServiceStatus::Failed;
+                        return Err((idx, srv.factory_idx));
+                    }
+                }
+            }
+        }
+
+        Ok(ready)
+    }
+}
+
+enum WorkerState {
+    Available,
+    Unavailable,
+    Restarting(Restart),
+    Shutdown(Shutdown),
+}
+
+struct Restart {
+    factory_id: usize,
+    token: usize,
+    fut: LocalBoxFuture<'static, Result<(usize, BoxedServerService), ()>>,
+}
+
+/// State necessary for server shutdown.
+struct Shutdown {
+    // Interval for checking the shutdown progress.
+    timer: Pin<Box<Sleep>>,
+
+    /// Start time of shutdown.
+    start_from: Instant,
+
+    /// Notify caller of the shutdown outcome (graceful/force).
+    tx: oneshot::Sender<bool>,
+}
+
+impl Default for WorkerState {
+    fn default() -> Self {
+        Self::Unavailable
+    }
+}
+
+impl Drop for ServerWorker {
+    fn drop(&mut self) {
+        Arbiter::try_current().as_ref().map(ArbiterHandle::stop);
+    }
+}
+
+impl Future for ServerWorker {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.as_mut().get_mut();
+
+        // `StopWorker` message handler
+        if let Poll::Ready(Some(Stop { graceful, tx })) = this.stop_rx.poll_recv(cx) {
+            let num = this.counter.total();
+            if num == 0 {
+                info!("shutting down idle worker");
+                let _ = tx.send(true);
+                return Poll::Ready(());
+            } else if graceful {
+                info!("graceful worker shutdown; finishing {} connections", num);
+                this.shutdown(false);
+
+                this.state = WorkerState::Shutdown(Shutdown {
+                    timer: Box::pin(sleep(Duration::from_secs(1))),
+                    start_from: Instant::now(),
+                    tx,
+                });
+            } else {
+                info!("force shutdown worker, closing {} connections", num);
+                this.shutdown(true);
+
+                let _ = tx.send(false);
+                return Poll::Ready(());
+            }
+        }
+
+        match this.state {
+            WorkerState::Unavailable => match this.check_readiness(cx) {
+                Ok(true) => {
+                    this.state = WorkerState::Available;
+                    self.poll(cx)
+                }
+                Ok(false) => Poll::Pending,
+                Err((token, idx)) => {
+                    this.restart_service(token, idx);
+                    self.poll(cx)
+                }
+            },
+
+            WorkerState::Restarting(ref mut restart) => {
+                let factory_id = restart.factory_id;
+                let token = restart.token;
+
+                let (token_new, service) =
+                    ready!(restart.fut.as_mut().poll(cx)).unwrap_or_else(|_| {
+                        panic!(
+                            "Can not restart {:?} service",
+                            this.factories[factory_id].name(token)
+                        )
+                    });
+
+                assert_eq!(token, token_new);
+
+                trace!(
+                    "service {:?} has been restarted",
+                    this.factories[factory_id].name(token)
+                );
+
+                this.services[token].created(service);
+                this.state = WorkerState::Unavailable;
+
+                self.poll(cx)
+            }
+
+            WorkerState::Shutdown(ref mut shutdown) => {
+                // drop all pending connections in rx channel.
+                while let Poll::Ready(Some(conn)) = this.conn_rx.poll_recv(cx) {
+                    // WorkerCounterGuard is needed as Accept thread has incremented counter.
+                    // It's guard's job to decrement the counter together with drop of Conn.
+                    let guard = this.counter.guard();
+                    drop((conn, guard));
+                }
+
+                // wait for 1 second
+                ready!(shutdown.timer.as_mut().poll(cx));
+
+                if this.counter.total() == 0 {
+                    // graceful shutdown
+                    if let WorkerState::Shutdown(shutdown) = mem::take(&mut this.state) {
+                        let _ = shutdown.tx.send(true);
+                    }
+
+                    Poll::Ready(())
+                } else if shutdown.start_from.elapsed() >= this.shutdown_timeout {
+                    // timeout forceful shutdown
+                    if let WorkerState::Shutdown(shutdown) = mem::take(&mut this.state) {
+                        let _ = shutdown.tx.send(false);
+                    }
+
+                    Poll::Ready(())
+                } else {
+                    // reset timer and wait for 1 second
+                    let time = Instant::now() + Duration::from_secs(1);
+                    shutdown.timer.as_mut().reset(time);
+                    shutdown.timer.as_mut().poll(cx)
+                }
+            }
+
+            // actively poll stream and handle worker command
+            WorkerState::Available => loop {
+                match this.check_readiness(cx) {
+                    Ok(true) => {}
+                    Ok(false) => {
+                        trace!("worker is unavailable");
+                        this.state = WorkerState::Unavailable;
+                        return self.poll(cx);
+                    }
+                    Err((token, idx)) => {
+                        this.restart_service(token, idx);
+                        return self.poll(cx);
+                    }
+                }
+
+                // handle incoming io stream
+                match ready!(this.conn_rx.poll_recv(cx)) {
+                    Some(msg) => {
+                        let guard = this.counter.guard();
+                        let _ = this.services[msg.token]
+                            .service
+                            .call((guard, msg.io))
+                            .into_inner();
+                    }
+                    None => return Poll::Ready(()),
+                };
+            },
+        }
+    }
+}
+
+fn wrap_worker_services(services: Vec<(usize, usize, BoxedServerService)>) -> Vec<WorkerService> {
+    services
+        .into_iter()
+        .fold(Vec::new(), |mut services, (idx, token, service)| {
+            assert_eq!(token, services.len());
+            services.push(WorkerService {
+                factory_idx: idx,
+                service,
+                status: WorkerServiceStatus::Unavailable,
+            });
+            services
+        })
+}

actix-server/tests/server.rs

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

actix-server/tests/testing_server.rs

@@ -0,0 +1,77 @@
+#![allow(missing_docs)]
+
+use std::net;
+
+use actix_rt::net::TcpStream;
+use actix_server::{Server, TestServer};
+use actix_service::fn_service;
+use bytes::BytesMut;
+use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
+
+macro_rules! await_timeout_ms {
+    ($fut:expr, $limit:expr) => {
+        ::actix_rt::time::timeout(::std::time::Duration::from_millis($limit), $fut)
+            .await
+            .unwrap()
+            .unwrap();
+    };
+}
+
+#[tokio::test]
+async fn testing_server_echo() {
+    let srv = TestServer::start(|| {
+        fn_service(move |mut stream: TcpStream| async move {
+            let mut size = 0;
+            let mut buf = BytesMut::new();
+
+            match stream.read_buf(&mut buf).await {
+                Ok(0) => return Err(()),
+
+                Ok(bytes_read) => {
+                    stream.write_all(&buf[size..]).await.unwrap();
+                    size += bytes_read;
+                }
+
+                Err(_) => return Err(()),
+            }
+
+            Ok((buf.freeze(), size))
+        })
+    });
+
+    let mut conn = srv.connect().unwrap();
+
+    await_timeout_ms!(conn.write_all(b"test"), 200);
+
+    let mut buf = Vec::new();
+    await_timeout_ms!(conn.read_to_end(&mut buf), 200);
+
+    assert_eq!(&buf, b"test".as_ref());
+}
+
+#[tokio::test]
+async fn new_with_builder() {
+    let alt_addr = TestServer::unused_addr();
+
+    let srv = TestServer::start_with_builder(
+        Server::build()
+            .bind("alt", alt_addr, || {
+                fn_service(|_| async { Ok::<_, ()>(()) })
+            })
+            .unwrap(),
+        || {
+            fn_service(|mut sock: TcpStream| async move {
+                let mut buf = [0u8; 16];
+                sock.read_exact(&mut buf).await
+            })
+        },
+    );
+
+    // connect to test server
+    srv.connect().unwrap();
+
+    // connect to alt service defined in custom ServerBuilder
+    let stream = net::TcpStream::connect(alt_addr).unwrap();
+    stream.set_nonblocking(true).unwrap();
+    TcpStream::from_std(stream).unwrap();
+}

actix-service/CHANGES.md

@@ -1,12 +1,226 @@
 # Changes
 
-## [0.1.1] - 2018-12-09
+## Unreleased
 
-### Added
+## 2.0.3
 
-* Added Service impl for Box<S: Service>
+- Minimum supported Rust version (MSRV) is now 1.71.
 
+## 2.0.2
 
-## [0.1.0] - 2018-12-09
+- Service types can now be `Send` and `'static` regardless of request, response, and config types, etc. [#397]
 
-* Initial import
+[#397]: https://github.com/actix/actix-net/pull/397
+
+## 2.0.1
+
+- Documentation fix. [#388]
+
+[#388]: https://github.com/actix/actix-net/pull/388
+
+## 2.0.0
+
+- Removed pipeline and related structs/functions. [#335]
+
+[#335]: https://github.com/actix/actix-net/pull/335
+
+## 2.0.0-beta.5
+
+- Add default `Service` trait impl for `Rc<S: Service>` and `&S: Service`. [#288]
+- Add `boxed::rc_service` function for constructing `boxed::RcService` type [#290]
+
+[#288]: https://github.com/actix/actix-net/pull/288
+[#290]: https://github.com/actix/actix-net/pull/290
+
+## 2.0.0-beta.4
+
+- `Service::poll_ready` and `Service::call` receive `&self`. [#247]
+- `apply_fn` and `apply_fn_factory` now receive `Fn(Req, &Service)` function type. [#247]
+- `apply_cfg` and `apply_cfg_factory` now receive `Fn(Req, &Service)` function type. [#247]
+- `fn_service` and friends now receive `Fn(Req)` function type. [#247]
+
+[#247]: https://github.com/actix/actix-net/pull/247
+
+## 2.0.0-beta.3
+
+- The `forward_ready!` macro converts errors. [#246]
+
+[#246]: https://github.com/actix/actix-net/pull/246
+
+## 2.0.0-beta.2
+
+- Remove redundant type parameter from `map_config`.
+
+## 2.0.0-beta.1
+
+- `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
+
+- 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
+
+- Fixed unsoundness in .and_then()/.then() service combinators.
+
+## 1.0.4
+
+- Revert 1.0.3 change
+
+## 1.0.3
+
+- Fixed unsoundness in `AndThenService` impl.
+
+## 1.0.2
+
+- Add `into_service` helper function.
+
+## 1.0.1
+
+- `map_config()` and `unit_config()` now accept `IntoServiceFactory` type.
+
+## 1.0.0
+
+- Add Clone impl for Apply service
+
+## 1.0.0-alpha.4
+
+- Renamed `service_fn` to `fn_service`
+- Renamed `factory_fn` to `fn_factory`
+- Renamed `factory_fn_cfg` to `fn_factory_with_config`
+
+## 1.0.0-alpha.3
+
+- Add missing Clone impls
+- Restore `Transform::map_init_err()` combinator
+- Restore `Service/Factory::apply_fn()` in form of `Pipeline/Factory::and_then_apply_fn()`
+- Optimize service combinators and futures memory layout
+
+## 1.0.0-alpha.2
+
+- Use owned config value for service factory
+- Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
+
+## 1.0.0-alpha.1
+
+- Migrated to `std::future`
+- `NewService` renamed to `ServiceFactory`
+- Added `pipeline` and `pipeline_factory` function
+
+## 0.4.2
+
+- Check service readiness for `new_apply_cfg` combinator
+
+## 0.4.1
+
+- Add `new_apply_cfg` function
+
+## 0.4.0
+
+- Add `NewService::map_config` and `NewService::unit_config` combinators.
+- Use associated type for `NewService` config.
+- Change `apply_cfg` function.
+- Renamed helper functions.
+
+## 0.3.6
+
+- Poll boxed service call result immediately
+
+## 0.3.5
+
+- Add `impl<S: Service> Service for Rc<RefCell<S>>`.
+
+## 0.3.4
+
+- Add `Transform::from_err()` combinator
+- Add `apply_fn` helper
+- Add `apply_fn_factory` helper
+- Add `apply_transform` helper
+- Add `apply_cfg` helper
+
+## 0.3.3
+
+- Add `ApplyTransform` new service for transform and new service.
+- Add `NewService::apply_cfg()` combinator, allows to use nested `NewService` with different config parameter.
+- Revert IntoFuture change
+
+## 0.3.2
+
+- Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+- Export `AndThenTransform` type
+
+## 0.3.1
+
+- Simplify Transform trait
+
+## 0.3.0
+
+- Added boxed NewService and Service.
+- Added `Config` parameter to `NewService` trait.
+- Added `Config` parameter to `NewTransform` trait.
+
+## 0.2.2
+
+- Added `NewService` impl for `Rc<S> where S: NewService`
+- Added `NewService` impl for `Arc<S> where S: NewService`
+
+## 0.2.1
+
+- Generalize `.apply` combinator with Transform trait
+
+## 0.2.0
+
+- Use associated type instead of generic for Service definition.
+  - Before:
+    ```rust
+    impl Service<Request> for Client {
+        type Response = Response;
+        // ...
+    }
+    ```
+  - After:
+    ```rust
+    impl Service for Client {
+        type Request = Request;
+        type Response = Response;
+        // ...
+    }
+    ```
+
+## 0.1.6
+
+- Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
+- Change `.apply()` error semantic, new service's error is `From<Self::Error>`
+
+## 0.1.5
+
+- Make `Out::Error` convertible from `T::Error` for apply combinator
+
+## 0.1.4
+
+- Use `FnMut` instead of `Fn` for `FnService`
+
+## 0.1.3
+
+- Split service combinators to separate trait
+
+## 0.1.2
+
+- Release future early for `.and_then()` and `.then()` combinators
+
+## 0.1.1
+
+- Added Service impl for `Box<S: Service>`
+
+## 0.1.0
+
+- Initial import

actix-service/Cargo.toml

@@ -1,26 +1,23 @@
 [package]
 name = "actix-service"
-version = "0.1.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Service"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-service/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-workspace = "../"
-
-[badges]
-travis-ci = { repository = "actix/actix-service", branch = "master" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
-codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
-
-[lib]
-name = "actix_service"
-path = "src/lib.rs"
+version = "2.0.3"
+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"]
+categories = ["network-programming", "asynchronous", "no-std"]
+repository = "https://github.com/actix/actix-net"
+license = "MIT OR Apache-2.0"
+edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
-futures = "0.1.24"
+futures-core = { version = "0.3.17", default-features = false }
+pin-project-lite = "0.2"
+
+[dev-dependencies]
+actix-rt = "2"
+actix-utils = "3"
+futures-util = { version = "0.3.17", default-features = false }
+
+[lints]
+workspace = true

actix-service/LICENSE-APACHE

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

actix-service/LICENSE-MIT

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

actix-service/README.md

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

actix-service/examples/clone.rs

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

actix-service/src/and_then.rs

@@ -1,175 +1,207 @@
-use futures::{try_ready, Async, Future, Poll};
+use alloc::rc::Rc;
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
-use super::{IntoNewService, NewService, Service};
-use crate::cell::Cell;
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
-/// Service for the `and_then` combinator, chaining a computation onto the end
-/// of another service which completes successfully.
+use super::{Service, ServiceFactory};
+
+/// Service for the `and_then` combinator, chaining a computation onto the end of another service
+/// which completes successfully.
 ///
-/// This is created by the `ServiceExt::and_then` method.
-pub struct AndThen<A, B> {
-    a: A,
-    b: Cell<B>,
-}
+/// This is created by the `Pipeline::and_then` method.
+pub struct AndThenService<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
-impl<A, B> AndThen<A, B> {
+impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
-    pub fn new<Request>(a: A, b: B) -> Self
+    pub(crate) fn new(a: A, b: B) -> Self
     where
-        A: Service<Request>,
+        A: Service<Req>,
         B: Service<A::Response, Error = A::Error>,
     {
-        Self { a, b: Cell::new(b) }
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
-impl<A, B> Clone for AndThen<A, B>
-where
-    A: Clone,
-{
+impl<A, B, Req> Clone for AndThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        AndThen {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
+        AndThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B, Request> Service<Request> for AndThen<A, B>
+impl<A, B, Req> Service<Req> for AndThenService<A, B, Req>
 where
-    A: Service<Request>,
+    A: Service<Req>,
     B: Service<A::Response, Error = A::Error>,
 {
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B, Request>;
+    type Future = AndThenServiceResponse<A, B, Req>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.a.poll_ready());
-        self.b.get_mut().poll_ready()
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let (a, b) = &*self.0;
+        let not_ready = !a.poll_ready(cx)?.is_ready();
+        if !b.poll_ready(cx)?.is_ready() || not_ready {
+            Poll::Pending
+        } else {
+            Poll::Ready(Ok(()))
+        }
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
-        AndThenFuture::new(self.a.call(req), self.b.clone())
-    }
-}
-
-pub struct AndThenFuture<A, B, Request>
-where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
-{
-    b: Cell<B>,
-    fut_b: Option<B::Future>,
-    fut_a: A::Future,
-}
-
-impl<A, B, Request> AndThenFuture<A, B, Request>
-where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
-{
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
-        AndThenFuture {
-            b,
-            fut_a,
-            fut_b: None,
+    fn call(&self, req: Req) -> Self::Future {
+        AndThenServiceResponse {
+            state: State::A {
+                fut: self.0 .0.call(req),
+                b: Some(self.0.clone()),
+            },
         }
     }
 }
 
-impl<A, B, Request> Future for AndThenFuture<A, B, Request>
-where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
-{
-    type Item = B::Response;
-    type Error = A::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut_b {
-            return fut.poll();
-        }
-
-        match self.fut_a.poll() {
-            Ok(Async::Ready(resp)) => {
-                self.fut_b = Some(self.b.get_mut().call(resp));
-                self.poll()
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(err) => Err(err),
-        }
-    }
-}
-
-/// `AndThenNewService` new service combinator
-pub struct AndThenNewService<A, B> {
-    a: A,
-    b: B,
-}
-
-impl<A, B> AndThenNewService<A, B> {
-    /// Create new `AndThen` combinator
-    pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
+pin_project! {
+    pub struct AndThenServiceResponse<A, B, Req>
     where
-        A: NewService<Request>,
-        B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+        A: Service<Req>,
+        B: Service<A::Response, Error = A::Error>,
     {
-        Self {
-            a,
-            b: f.into_new_service(),
+        #[pin]
+        state: State<A, B, Req>,
+    }
+}
+
+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<(A, B)>>,
+        },
+        B {
+            #[pin]
+            fut: B::Future,
+        },
+    }
+}
+
+impl<A, B, Req> Future for AndThenServiceResponse<A, B, Req>
+where
+    A: Service<Req>,
+    B: Service<A::Response, Error = A::Error>,
+{
+    type Output = Result<B::Response, A::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        match this.state.as_mut().project() {
+            StateProj::A { fut, b } => {
+                let res = ready!(fut.poll(cx))?;
+                let b = b.take().unwrap();
+                let fut = b.1.call(res);
+                this.state.set(State::B { fut });
+                self.poll(cx)
+            }
+            StateProj::B { fut } => fut.poll(cx),
         }
     }
 }
 
-impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
+/// `.and_then()` service factory combinator
+pub struct AndThenServiceFactory<A, B, Req>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<A::Response, Config = A::Config, Error = A::Error, InitError = A::InitError>,
+{
+    inner: Rc<(A, B)>,
+    _phantom: PhantomData<Req>,
+}
+
+impl<A, B, Req> AndThenServiceFactory<A, B, Req>
+where
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<A::Response, Config = A::Config, Error = A::Error, InitError = A::InitError>,
+{
+    /// Create new `AndThenFactory` combinator
+    pub(crate) fn new(a: A, b: B) -> Self {
+        Self {
+            inner: Rc::new((a, b)),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<A, B, Req> ServiceFactory<Req> for AndThenServiceFactory<A, B, Req>
+where
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<A::Response, Config = A::Config, Error = A::Error, InitError = A::InitError>,
 {
     type Response = B::Response;
     type Error = A::Error;
-    type Service = AndThen<A::Service, B::Service>;
 
+    type Config = A::Config;
+    type Service = AndThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B, Request>;
+    type Future = AndThenServiceFactoryResponse<A, B, Req>;
 
-    fn new_service(&self) -> Self::Future {
-        AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        let inner = &*self.inner;
+        AndThenServiceFactoryResponse::new(
+            inner.0.new_service(cfg.clone()),
+            inner.1.new_service(cfg),
+        )
     }
 }
 
-impl<A, B> Clone for AndThenNewService<A, B>
+impl<A, B, Req> Clone for AndThenServiceFactory<A, B, Req>
 where
-    A: Clone,
-    B: Clone,
+    A: ServiceFactory<Req>,
+    A::Config: Clone,
+    B: ServiceFactory<A::Response, Config = A::Config, Error = A::Error, InitError = A::InitError>,
 {
     fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
+            inner: self.inner.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B, Request>
-where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
-{
-    fut_b: B::Future,
-    fut_a: A::Future,
-    a: Option<A::Service>,
-    b: Option<B::Service>,
+pin_project! {
+    pub 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, Request> AndThenNewServiceFuture<A, B, Request>
+impl<A, B, Req> AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
-        AndThenNewServiceFuture {
+        AndThenServiceFactoryResponse {
             fut_a,
             fut_b,
             a: None,
@@ -178,60 +210,66 @@ where
     }
 }
 
-impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
+impl<A, B, Req> Future for AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: ServiceFactory<Req>,
+    B: ServiceFactory<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Item = AndThen<A::Service, B::Service>;
-    type Error = A::InitError;
+    type Output = Result<AndThenService<A::Service, B::Service, Req>, A::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if self.a.is_none() {
-            if let Async::Ready(service) = self.fut_a.poll()? {
-                self.a = Some(service);
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        if this.a.is_none() {
+            if let Poll::Ready(service) = this.fut_a.poll(cx)? {
+                *this.a = Some(service);
             }
         }
-
-        if self.b.is_none() {
-            if let Async::Ready(service) = self.fut_b.poll()? {
-                self.b = Some(service);
+        if this.b.is_none() {
+            if let Poll::Ready(service) = this.fut_b.poll(cx)? {
+                *this.b = Some(service);
             }
         }
-
-        if self.a.is_some() && self.b.is_some() {
-            Ok(Async::Ready(AndThen::new(
-                self.a.take().unwrap(),
-                self.b.take().unwrap(),
+        if this.a.is_some() && this.b.is_some() {
+            Poll::Ready(Ok(AndThenService::new(
+                this.a.take().unwrap(),
+                this.b.take().unwrap(),
             )))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Poll};
-    use std::cell::Cell;
-    use std::rc::Rc;
+    use alloc::rc::Rc;
+    use core::{
+        cell::Cell,
+        task::{Context, Poll},
+    };
 
-    use super::*;
-    use crate::{NewService, Service};
+    use futures_util::future::lazy;
+
+    use crate::{
+        fn_factory, ok,
+        pipeline::{pipeline, pipeline_factory},
+        ready, Ready, Service, ServiceFactory,
+    };
 
     struct Srv1(Rc<Cell<usize>>);
+
     impl Service<&'static str> for Srv1 {
         type Response = &'static str;
         type Error = ();
-        type Future = FutureResult<Self::Response, ()>;
+        type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             self.0.set(self.0.get() + 1);
-            Ok(Async::Ready(()))
+            Poll::Ready(Ok(()))
         }
 
-        fn call(&mut self, req: &'static str) -> Self::Future {
+        fn call(&self, req: &'static str) -> Self::Future {
             ok(req)
         }
     }
@@ -242,51 +280,46 @@ mod tests {
     impl Service<&'static str> for Srv2 {
         type Response = (&'static str, &'static str);
         type Error = ();
-        type Future = FutureResult<Self::Response, ()>;
+        type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             self.0.set(self.0.get() + 1);
-            Ok(Async::Ready(()))
+            Poll::Ready(Ok(()))
         }
 
-        fn call(&mut self, req: &'static str) -> Self::Future {
+        fn call(&self, req: &'static str) -> Self::Future {
             ok((req, "srv2"))
         }
     }
 
-    #[test]
-    fn test_poll_ready() {
+    #[actix_rt::test]
+    async fn test_poll_ready() {
         let cnt = Rc::new(Cell::new(0));
-        let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt.clone()));
-        let res = srv.poll_ready();
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(()));
+        let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone()));
+        let res = lazy(|cx| srv.poll_ready(cx)).await;
+        assert_eq!(res, Poll::Ready(Ok(())));
         assert_eq!(cnt.get(), 2);
     }
 
-    #[test]
-    fn test_call() {
+    #[actix_rt::test]
+    async fn test_call() {
         let cnt = Rc::new(Cell::new(0));
-        let mut srv = Srv1(cnt.clone()).and_then(Srv2(cnt));
-        let res = srv.call("srv1").poll();
+        let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
+        let res = srv.call("srv1").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));
+        assert_eq!(res.unwrap(), ("srv1", "srv2"));
     }
 
-    #[test]
-    fn test_new_service() {
+    #[actix_rt::test]
+    async fn test_new_service() {
         let cnt = Rc::new(Cell::new(0));
         let cnt2 = cnt.clone();
-        let blank = move || Ok::<_, ()>(Srv1(cnt2.clone()));
-        let new_srv = blank
-            .into_new_service()
-            .and_then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            let res = srv.call("srv1").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));
-        } else {
-            panic!()
-        }
+        let new_srv = pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
+            .and_then(move || ready(Ok(Srv2(cnt.clone()))));
+
+        let srv = new_srv.new_service(()).await.unwrap();
+        let res = srv.call("srv1").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv1", "srv2"));
     }
 }

actix-service/src/apply.rs

@@ -1,222 +1,273 @@
-use std::marker::PhantomData;
+use core::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
-use futures::{Async, Future, IntoFuture, Poll};
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// `Apply` service combinator
-pub struct Apply<T, F, In, Out, Request>
+/// 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<Request>,
+    I: IntoService<S, In>,
+    S: Service<In, Error = Err>,
+    F: Fn(Req, &S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out, Request)>,
+    Apply::new(service.into_service(), wrap_fn)
 }
 
-impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
+/// 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,
+) -> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: Service<Request>,
-    F: Fn(In, &mut T) -> Out,
-    Out: IntoFuture,
+    I: IntoServiceFactory<SF, In>,
+    SF: ServiceFactory<In, Error = Err>,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    ApplyFactory::new(service.into_factory(), f)
+}
+
+/// `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
+    S: Service<In, Error = Err>,
+{
+    service: S,
+    wrap_fn: F,
+    _phantom: PhantomData<fn(Req) -> (In, Res, Err)>,
+}
+
+impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
+where
+    S: Service<In, Error = Err>,
+    F: Fn(Req, &S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
+    fn new(service: S, wrap_fn: F) -> Self {
         Self {
-            service: service.into_service(),
-            f,
-            r: PhantomData,
+            service,
+            wrap_fn,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
+impl<S, F, Fut, Req, In, Res, Err> Clone for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Request> + Clone,
-    F: Clone,
+    S: Service<In, Error = Err> + Clone,
+    F: Fn(Req, &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, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
+impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Request, Error = Out::Error>,
-    F: Fn(In, &mut T) -> Out,
-    Out: IntoFuture,
+    S: Service<In, Error = Err>,
+    F: Fn(Req, &S) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Future = Out::Future;
+    type Response = Res;
+    type Error = Err;
+    type Future = Fut;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
-    }
+    crate::forward_ready!(service);
 
-    fn call(&mut self, req: In) -> Self::Future {
-        (self.f)(req, &mut self.service).into_future()
+    fn call(&self, req: Req) -> Self::Future {
+        (self.wrap_fn)(req, &self.service)
     }
 }
 
-/// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out, Request>
-where
-    T: NewService<Request>,
-{
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out, Request)>,
+/// `ApplyFactory` service factory combinator.
+pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
+    factory: SF,
+    wrap_fn: F,
+    _phantom: PhantomData<fn(Req) -> (In, Res, Err)>,
 }
 
-impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
+    SF: ServiceFactory<In, Error = Err>,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
+    /// Create new `ApplyFactory` new service instance
+    fn new(factory: SF, wrap_fn: F) -> Self {
         Self {
-            f,
-            service: service.into_new_service(),
-            r: PhantomData,
+            factory,
+            wrap_fn,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
+impl<SF, F, Fut, Req, In, Res, Err> Clone for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: NewService<Request> + Clone,
-    F: Fn(Out, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    SF: ServiceFactory<In, Error = Err> + Clone,
+    F: Fn(Req, &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, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
+impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req> for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: NewService<Request, Error = Out::Error>,
-    F: Fn(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    SF: ServiceFactory<In, Error = Err>,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Service = Apply<T::Service, F, In, Out, Request>;
+    type Response = Res;
+    type Error = Err;
 
-    type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
+    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) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(), 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())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
-where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
-{
-    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: Fn(Req, &SF::Service) -> Fut,
+        Fut: Future<Output = Result<Res, Err>>,
+    {
+        #[pin]
+        fut: SF::Future,
+        wrap_fn: Option<F>,
+        _phantom: PhantomData<fn(Req) -> Res>,
+    }
 }
 
-impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
+    SF: ServiceFactory<In, Error = Err>,
+    F: Fn(Req, &SF::Service) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    fn new(fut: T::Future, f: F) -> Self {
-        ApplyNewServiceFuture {
-            f: Some(f),
+    fn new(fut: SF::Future, wrap_fn: F) -> Self {
+        Self {
             fut,
-            r: PhantomData,
+            wrap_fn: Some(wrap_fn),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
+impl<SF, F, Fut, Req, In, Res, Err> Future
+    for ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
+    SF: ServiceFactory<In, Error = Err>,
+    F: Fn(Req, &SF::Service) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Item = Apply<T::Service, F, In, Out, Request>;
-    type Error = T::InitError;
+    type Output = Result<Apply<SF::Service, F, Req, In, Res, Err>, SF::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(Apply::new(service, self.f.take().unwrap())))
-        } else {
-            Ok(Async::NotReady)
-        }
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        let svc = ready!(this.fut.poll(cx))?;
+        Poll::Ready(Ok(Apply::new(svc, this.wrap_fn.take().unwrap())))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Future, Poll};
+    use futures_util::future::lazy;
 
-    use crate::{IntoNewService, IntoService, NewService, Service};
+    use super::*;
+    use crate::{
+        ok,
+        pipeline::{pipeline, pipeline_factory},
+        Ready,
+    };
 
     #[derive(Clone)]
     struct Srv;
+
     impl Service<()> for Srv {
         type Response = ();
         type Error = ();
-        type Future = FutureResult<(), ()>;
+        type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Ok(Async::Ready(()))
-        }
+        crate::always_ready!();
 
-        fn call(&mut self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future {
             ok(())
         }
     }
 
-    #[test]
-    fn test_call() {
-        let blank = |req| Ok(req);
+    #[actix_rt::test]
+    async fn test_call() {
+        let srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
+            let fut = srv.call(());
+            async move {
+                fut.await.unwrap();
+                Ok((req, ()))
+            }
+        }));
 
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
-            srv.call(()).map(move |res| (req, res))
-        });
-        assert!(srv.poll_ready().is_ok());
-        let res = srv.call("srv").poll();
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+        assert_eq!(res.unwrap(), ("srv", ()));
     }
 
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
+    #[actix_rt::test]
+    async fn test_new_service() {
+        let new_srv = pipeline_factory(apply_fn_factory(
+            || ok::<_, ()>(Srv),
+            |req: &'static str, srv| {
+                let fut = srv.call(());
+                async move {
+                    fut.await.unwrap();
+                    Ok((req, ()))
+                }
+            },
+        ));
 
-        let new_srv = blank.into_new_service().apply(
-            || Ok(Srv),
-            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
-        );
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
-            assert!(srv.poll_ready().is_ok());
-            let res = srv.call("srv").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-        } else {
-            panic!()
-        }
+        let srv = new_srv.new_service(()).await.unwrap();
+
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+
+        let res = srv.call("srv").await;
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv", ()));
     }
 }

actix-service/src/apply_cfg.rs

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

actix-service/src/boxed.rs

@@ -0,0 +1,140 @@
+//! Trait object forms of services and service factories.
+
+use alloc::{boxed::Box, rc::Rc};
+use core::{future::Future, pin::Pin};
+
+use crate::{Service, ServiceFactory};
+
+/// A boxed future with no send bound or lifetime parameters.
+pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
+/// Type alias for service trait object using [`Box`].
+pub type BoxService<Req, Res, Err> =
+    Box<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>>;
+
+/// Wraps service as a trait object using [`BoxService`].
+pub fn service<S, Req>(service: S) -> BoxService<Req, S::Response, S::Error>
+where
+    S: Service<Req> + 'static,
+    Req: 'static,
+    S::Future: 'static,
+{
+    Box::new(ServiceWrapper::new(service))
+}
+
+/// Type alias for service trait object using [`Rc`].
+pub type RcService<Req, Res, Err> =
+    Rc<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>>;
+
+/// Wraps service as a trait object using [`RcService`].
+pub fn rc_service<S, Req>(service: S) -> RcService<Req, S::Response, S::Error>
+where
+    S: Service<Req> + 'static,
+    Req: 'static,
+    S::Future: 'static,
+{
+    Rc::new(ServiceWrapper::new(service))
+}
+
+struct ServiceWrapper<S> {
+    inner: S,
+}
+
+impl<S> ServiceWrapper<S> {
+    fn new(inner: S) -> Self {
+        Self { inner }
+    }
+}
+
+impl<S, Req, Res, Err> Service<Req> for ServiceWrapper<S>
+where
+    S: Service<Req, Response = Res, Error = Err>,
+    S::Future: 'static,
+{
+    type Response = Res;
+    type Error = Err;
+    type Future = BoxFuture<Result<Res, Err>>;
+
+    crate::forward_ready!(inner);
+
+    fn call(&self, req: Req) -> Self::Future {
+        Box::pin(self.inner.call(req))
+    }
+}
+
+/// Wrapper for a service factory that will map it's services to boxed trait object services.
+pub struct BoxServiceFactory<Cfg, Req, Res, Err, InitErr>(Inner<Cfg, Req, Res, Err, InitErr>);
+
+/// Wraps a service factory that returns service trait objects.
+pub fn factory<SF, Req>(
+    factory: SF,
+) -> BoxServiceFactory<SF::Config, Req, SF::Response, SF::Error, SF::InitError>
+where
+    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)))
+}
+
+type Inner<C, Req, Res, Err, InitErr> = Box<
+    dyn ServiceFactory<
+        Req,
+        Config = C,
+        Response = Res,
+        Error = Err,
+        InitError = InitErr,
+        Service = BoxService<Req, Res, Err>,
+        Future = BoxFuture<Result<BoxService<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 Response = Res;
+    type Error = Err;
+    type Config = C;
+    type Service = BoxService<Req, Res, Err>;
+    type InitError = InitErr;
+
+    type Future = BoxFuture<Result<Self::Service, InitErr>>;
+
+    fn new_service(&self, cfg: C) -> Self::Future {
+        self.0.new_service(cfg)
+    }
+}
+
+struct FactoryWrapper<SF>(SF);
+
+impl<SF, Req, Cfg, Res, Err, InitErr> ServiceFactory<Req> for FactoryWrapper<SF>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: '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 Response = Res;
+    type Error = Err;
+    type Config = Cfg;
+    type Service = BoxService<Req, Res, Err>;
+    type InitError = InitErr;
+    type Future = BoxFuture<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
+        let f = self.0.new_service(cfg);
+        Box::pin(async { f.await.map(|s| Box::new(ServiceWrapper::new(s)) as _) })
+    }
+}