.cargo/config.toml

@@ -2,14 +2,25 @@
 lint = "clippy --workspace --tests --examples --bins -- -Dclippy::todo"
 lint-all = "clippy --workspace --all-features --tests --examples --bins -- -Dclippy::todo"
 
+ci-doctest = "test --workspace --all-features --doc --no-fail-fast -- --nocapture"
+
 # just check the library (without dev deps)
 ci-check-min = "hack --workspace check --no-default-features"
-ci-check-lib = "hack --workspace --feature-powerset --depth=2 --exclude-features=io-uring check"
+ci-check-lib = "hack --workspace --feature-powerset --exclude-features=io-uring check"
-ci-check-lib-linux = "hack --workspace --feature-powerset --depth=2 check"
+ci-check-lib-linux = "hack --workspace --feature-powerset check"
 
 # check everything
-ci-check = "hack --workspace --feature-powerset --depth=2 --exclude-features=io-uring check --tests --examples"
+ci-check = "hack --workspace --feature-powerset --exclude-features=io-uring check --tests --examples"
-ci-check-linux = "hack --workspace --feature-powerset --depth=2 check --tests --examples"
+ci-check-linux = "hack --workspace --feature-powerset 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"
+ci-test = "       hack --feature-powerset --exclude=actix-rt --exclude=actix-server --exclude-features=io-uring test --workspace --lib --tests --no-fail-fast -- --nocapture"
+ci-test-rt = "    hack --feature-powerset --exclude-features=io-uring test --package=actix-rt     --lib --tests --no-fail-fast -- --nocapture"
+ci-test-server = "hack --feature-powerset --exclude-features=io-uring test --package=actix-server --lib --tests --no-fail-fast -- --nocapture"
+
+# test with io-uring feature
+ci-test-rt-linux = "    hack --feature-powerset test --package=actix-rt     --lib --tests --no-fail-fast -- --nocapture"
+ci-test-server-linux = "hack --feature-powerset test --package=actix-server --lib --tests --no-fail-fast -- --nocapture"
+
+# test lower msrv
+ci-test-lower-msrv = "hack --workspace --exclude=actix-server --exclude=actix-tls --feature-powerset test --lib --tests --no-fail-fast -- --nocapture"

.envrc

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,10 @@
 ## PR Type
-
 <!-- What kind of change does this PR make? -->
 <!-- Bug Fix / Feature / Refactor / Code Style / Other -->
-
 INSERT_PR_TYPE
 
-## PR Checklist
 
+## PR Checklist
 Check your PR fulfills the following:
 
 <!-- For draft PRs check the boxes as you complete them. -->
@@ -16,10 +14,11 @@ Check your PR fulfills the following:
 - [ ] A changelog entry has been made for the appropriate packages.
 - [ ] Format code with the latest stable rustfmt
 
-## Overview
 
+## 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

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

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

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

@@ -1,133 +1,201 @@
 name: CI
 
 on:
-  pull_request: {}
+  pull_request:
-  merge_group: { types: [checks_requested] }
+    types: [opened, synchronize, reopened]
-  push: { branches: [master] }
+  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 }
+          - { name: Windows (32-bit), os: windows-latest, triple: i686-pc-windows-msvc }
         version:
-          - { name: msrv, version: "${{ needs.read_msrv.outputs.msrv }}" }
+          - 1.52.0 # MSRV for -server and -tls
-          - { name: stable, version: stable }
+          - stable
+          - nightly
 
-    name: ${{ matrix.target.name }} / ${{ matrix.version.name }}
+    name: ${{ matrix.target.name }} / ${{ matrix.version }}
     runs-on: ${{ matrix.target.os }}
 
-    env: {}
+    env:
+      VCPKGRS_DYNAMIC: 1
 
     steps:
       - name: Setup Routing
         if: matrix.target.os == 'macos-latest'
         run: sudo ifconfig lo0 alias 127.0.0.3
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
-
-      - 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
 
+      # install OpenSSL on Windows
+      - name: Set vcpkg root
+        if: matrix.target.triple == 'x86_64-pc-windows-msvc' || matrix.target.triple == 'i686-pc-windows-msvc'
+        run: echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append
       - name: Install OpenSSL
-        if: matrix.target.os == 'windows-latest'
+        if: matrix.target.triple == 'x86_64-pc-windows-msvc'
-        shell: bash
+        run: vcpkg install openssl:x64-windows
-        run: |
+      - name: Install OpenSSL
-          set -e
+        if: matrix.target.triple == 'i686-pc-windows-msvc'
-          choco install openssl --version=1.1.1.2100 -y --no-progress
+        run: vcpkg install openssl:x86-windows
-          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' >> $GITHUB_ENV
-          echo "RUSTFLAGS=-C target-feature=+crt-static" >> $GITHUB_ENV
 
-      - name: Install Rust (${{ matrix.version.name }})
+      - name: Install ${{ matrix.version }}
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ matrix.version.version }}
+          toolchain: ${{ matrix.version }}-${{ matrix.target.triple }}
+          profile: minimal
+          override: true
 
-      - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
+      # - name: Install MSYS2
-        uses: taiki-e/install-action@v2.49.40
+      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+      #   uses: msys2/setup-msys2@v2
+      # - name: Install MinGW Packages
+      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
+      #   run: |
+      #     msys2 -c 'pacman -Sy --noconfirm pacman'
+      #     msys2 -c 'pacman --noconfirm -S base-devel pkg-config'
+
+      # - name: Generate Cargo.lock
+      #   uses: actions-rs/cargo@v1
+      #   with: { command: generate-lockfile }
+      # - name: Cache Dependencies
+      #   uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
         with:
-          tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
+          command: install
-
+          args: cargo-hack
-      - 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
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-lib }
       - name: check lib
         if: matrix.target.os == 'ubuntu-latest'
-        run: cargo ci-check-lib-linux
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-lib-linux }
       - name: check lib
-        if: matrix.target.triple != 'x86_64-pc-windows-gnu'
+        if: matrix.target.triple == 'x86_64-pc-windows-gnu'
-        run: cargo ci-check-min
+        uses: actions-rs/cargo@v1
-
+        with: { command: ci-check-min }
+      
       - name: check full
         # TODO: compile OpenSSL and run tests on MinGW
         if: >
           matrix.target.os != 'ubuntu-latest'
           && matrix.target.triple != 'x86_64-pc-windows-gnu'
-        run: cargo ci-check
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check }
       - name: check all
         if: matrix.target.os == 'ubuntu-latest'
-        run: cargo ci-check-linux
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-linux }
 
       - name: tests
-        run: just test
+        if: >
+          matrix.target.os != 'ubuntu-latest'
+          && matrix.target.triple != 'x86_64-pc-windows-gnu'
+        run: |
+          cargo ci-test
+          cargo ci-test-rt
+          cargo ci-test-server
+      - name: tests
+        if: matrix.target.os == 'ubuntu-latest'
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rt-linux && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-server-linux"
 
-      - name: CI cache clean
+      - name: Clear the cargo caches
-        run: cargo-ci-cache-clean
+        run: |
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
+          cargo-cache
+  
+  build_and_test_lower_msrv:
+    name: Linux / 1.46 (lower MSRV)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
 
-  docs:
+      - name: Install 1.46.0 # MSRV for all but -server and -tls
-    name: Documentation
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.46.0-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: tests
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=1.46 cargo ci-test-lower-msrv"
+
+      - name: Clear the cargo caches
+        run: |
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
+          cargo-cache
+  
+  coverage:
+    name: coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust (nightly)
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.3.0
+    
+      - name: Generate coverage file
+        if: github.ref == 'refs/heads/master'
+        run: |
+          cargo install cargo-tarpaulin
+          cargo tarpaulin --out Xml --verbose
+      - name: Upload to Codecov
+        if: github.ref == 'refs/heads/master'
+        uses: codecov/codecov-action@v1
+        with: { file: cobertura.xml }
+
+  rustdoc:
+    name: rustdoc
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       - name: Install Rust (nightly)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly
+          toolchain: nightly-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
 
-      - name: Install just
+      - name: Generate Cargo.lock
-        uses: taiki-e/install-action@v2.49.40
+        uses: actions-rs/cargo@v1
-        with:
+        with: { command: generate-lockfile }
-          tool: just
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.3.0
 
-      - name: doc tests
+      - name: doc tests io-uring
-        run: just test-docs
+        run: |
+          sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=nightly cargo ci-doctest"

.github/workflows/clippy-fmt.yml

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

.github/workflows/coverage.yml

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

@@ -1,69 +0,0 @@
-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 }}

.github/workflows/upload-doc.yml

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

.gitignore

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

.rustfmt.toml

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

.taplo.toml

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

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
+* Using welcoming and inclusive language
-- Being respectful of differing viewpoints and experiences
+* Being respectful of differing viewpoints and experiences
-- Gracefully accepting constructive criticism
+* Gracefully accepting constructive criticism
-- Focusing on what is best for the community
+* Focusing on what is best for the community
-- Showing empathy towards other community members
+* 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
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
-- Trolling, insulting/derogatory comments, and personal or political attacks
+* Trolling, insulting/derogatory comments, and personal or political attacks
-- Public or private harassment
+* Public or private harassment
-- Publishing others' private information, such as a physical or electronic address, without explicit permission
+* 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
+* Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 
@@ -39,7 +39,7 @@ Instances of abusive, harassing, or otherwise unacceptable behavior may be repor
 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
+[@JohnTitor]: https://github.com/JohnTitor
 
 ## Attribution
 

Cargo.toml

@@ -1,5 +1,4 @@
 [workspace]
-resolver = "2"
 members = [
   "actix-codec",
   "actix-macros",
@@ -14,11 +13,6 @@ members = [
   "local-waker",
 ]
 
-[workspace.package]
-license = "MIT OR Apache-2.0"
-edition = "2021"
-rust-version = "1.71.1"
-
 [patch.crates-io]
 actix-codec = { path = "actix-codec" }
 actix-macros = { path = "actix-macros" }
@@ -36,9 +30,3 @@ local-waker = { path = "local-waker" }
 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 }

README.md

@@ -2,25 +2,29 @@
 
 > A collection of lower-level libraries for composable network services.
 
-[![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)
+![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/actix-server)
-[![codecov](https://codecov.io/gh/actix/actix-net/graph/badge.svg?token=8rKIZKtLLm)](https://codecov.io/gh/actix/actix-net)
+[![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
-[![Dependency Status](https://deps.rs/repo/github/actix/actix-net/status.svg)](https://deps.rs/repo/github/actix/actix-net)
 
-## Examples
+## Build statuses
+| Platform         | Build Status |
+| ---------------- | ------------ |
+| Linux            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Linux)") |
+| macOS            | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28macOS%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(macOS)") |
+| Windows          | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows)") |
+| Windows (MinGW)  | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows-mingw%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows-mingw)") |
 
-See example folders for [`actix-server`](./actix-server/examples) and [`actix-tls`](./actix-tls/examples).
+## Example
+See `actix-server/examples` and `actix-tls/examples` for some basic examples.
 
-## MSRV
+### MSRV
-
+This repo's Minimum Supported Rust Version (MSRV) is 1.46.0.
-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.
 

actix-codec/CHANGES.md

@@ -1,85 +1,71 @@
 # Changes
 
-## Unreleased
+## Unreleased - 2021-xx-xx
 
-- Minimum supported Rust version (MSRV) is now 1.71.
 
-## 0.5.2
+## 0.4.1 - 2021-11-05
+* Added `LinesCodec.` [#338]
+* `Framed::poll_ready` flushes when the buffer is full. [#409]
 
-- Minimum supported Rust version (MSRV) is now 1.65.
+[#338]: https://github.com/actix/actix-net/pull/338
+[#409]: https://github.com/actix/actix-net/pull/409
 
-## 0.5.1
 
-- Logs emitted now use the `tracing` crate with `log` compatibility.
+## 0.4.0 - 2021-04-20
-- Minimum supported Rust version (MSRV) is now 1.49.
+* No significant changes since v0.4.0-beta.1.
 
-## 0.5.0
 
-- Updated `tokio-util` dependency to `0.7.0`.
+## 0.4.0-beta.1 - 2020-12-28
+* Replace `pin-project` with `pin-project-lite`. [#237]
+* Upgrade `tokio` dependency to `1`. [#237]
+* Upgrade `tokio-util` dependency to `0.6`. [#237]
+* Upgrade `bytes` dependency to `1`. [#237]
 
-## 0.4.2
+[#237]: https://github.com/actix/actix-net/pull/237
 
-- No significant changes since `0.4.1`.
 
-## 0.4.1
+## 0.3.0 - 2020-08-23
+* No changes from beta 2.
 
-- Added `LinesCodec`.
-- `Framed::poll_ready` flushes when the buffer is full.
 
-## 0.4.0
+## 0.3.0-beta.2 - 2020-08-19
+* Remove unused type parameter from `Framed::replace_codec`.
 
-- No significant changes since v0.4.0-beta.1.
 
-## 0.4.0-beta.1
+## 0.3.0-beta.1 - 2020-08-19
+* Use `.advance()` instead of `.split_to()`.
+* Upgrade `tokio-util` to `0.3`.
+* Improve `BytesCodec::encode()` performance.
+* Simplify `BytesCodec::decode()`.
+* Rename methods on `Framed` to better describe their use.
+* Add method on `Framed` to get a pinned reference to the underlying I/O.
+* Add method on `Framed` check emptiness of read buffer.
 
-- 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
+## 0.2.0 - 2019-12-10
+* Use specific futures dependencies.
 
-- 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.
 
-- Fix buffer remaining capacity calculation.
 
 ## 0.2.0-alpha.3
+* Use tokio 0.2.
+* Fix low/high watermark for write/read buffers.
 
-- Use tokio 0.2.
-- Fix low/high watermark for write/read buffers.
 
 ## 0.2.0-alpha.2
+* Migrated to `std::future`.
 
-- Migrated to `std::future`.
 
-## 0.1.2
+## 0.1.2 - 2019-03-27
+* Added `Framed::map_io()` method.
 
-- Added `Framed::map_io()` method.
 
-## 0.1.1
+## 0.1.1 - 2019-03-06
+* Added `FramedParts::with_read_buffer()` method.
 
-- Added `FramedParts::with_read_buffer()` method.
 
-## 0.1.0
+## 0.1.0 - 2018-12-09
-
+* Move codec to separate crate.
-- Move codec to separate crate.

actix-codec/Cargo.toml

@@ -1,36 +1,36 @@
 [package]
 name = "actix-codec"
-version = "0.5.2"
+version = "0.4.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+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
+edition = "2018"
-rust-version.workspace = true
 
-[package.metadata.cargo_check_external_types]
+[lib]
-allowed_external_types = ["bytes::*", "futures_core::*", "futures_sink::*", "tokio::*", "tokio_util::*"]
+name = "actix_codec"
+path = "src/lib.rs"
 
 [dependencies]
-bitflags = "2"
+bitflags = "1.2.1"
 bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
 futures-sink = { version = "0.3.7", default-features = false }
+log = "0.4"
 memchr = "2.3"
 pin-project-lite = "0.2"
-tokio = "1.23.1"
+tokio = "1.5.1"
-tokio-util = { version = "0.7", features = ["codec", "io"] }
+tokio-util = { version = "0.6", features = ["codec", "io"] }
-tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 
 [dev-dependencies]
-criterion = { version = "0.5", features = ["html_reports"] }
+criterion = { version = "0.3", features = ["html_reports"] }
 tokio-test = "0.4.2"
 
 [[bench]]
 name = "lines"
 harness = false
-
-[lints]
-workspace = true

actix-codec/benches/lines.rs

@@ -1,5 +1,3 @@
-#![allow(missing_docs)]
-
 use bytes::BytesMut;
 use criterion::{criterion_group, criterion_main, Criterion};
 

actix-codec/src/framed.rs

@@ -1,14 +1,10 @@
-use std::{
+use std::pin::Pin;
-    fmt, io,
+use std::task::{Context, Poll};
-    pin::Pin,
+use std::{fmt, io};
-    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};
 
@@ -17,15 +13,14 @@ const LW: usize = 1024;
 /// High-water mark
 const HW: usize = 8 * 1024;
 
-bitflags! {
+bitflags::bitflags! {
-    #[derive(Debug, Clone, Copy)]
     struct Flags: u8 {
         const EOF = 0b0001;
         const READABLE = 0b0010;
     }
 }
 
-pin_project! {
+pin_project_lite::pin_project! {
     /// A unified `Stream` and `Sink` interface to an underlying I/O object, using the `Encoder` and
     /// `Decoder` traits to encode and decode frames.
     ///
@@ -157,7 +152,7 @@ impl<T, U> Framed<T, U> {
 }
 
 impl<T, U> Framed<T, U> {
-    /// Serialize item and write to the inner buffer
+    /// 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,
@@ -194,18 +189,18 @@ impl<T, U> Framed<T, U> {
                     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))),
+                        Err(e) => return Poll::Ready(Some(Err(e))),
                     }
                 }
 
-                tracing::trace!("attempting to decode a frame");
+                log::trace!("attempting to decode a frame");
 
                 match this.codec.decode(this.read_buf) {
                     Ok(Some(frame)) => {
-                        tracing::trace!("frame decoded from buffer");
+                        log::trace!("frame decoded from buffer");
                         return Poll::Ready(Some(Ok(frame)));
                     }
-                    Err(err) => return Poll::Ready(Some(Err(err))),
+                    Err(e) => return Poll::Ready(Some(Err(e))),
                     _ => (), // Need more data
                 }
 
@@ -222,7 +217,7 @@ impl<T, U> Framed<T, U> {
 
             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(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
                 Poll::Ready(Ok(cnt)) => cnt,
             };
 
@@ -234,16 +229,19 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Flush write buffer to underlying I/O stream.
-    pub fn flush<I>(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    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");
+        log::trace!("flushing framed transport");
 
         while !this.write_buf.is_empty() {
-            tracing::trace!("writing; remaining={}", this.write_buf.len());
+            log::trace!("writing; remaining={}", this.write_buf.len());
 
             let n = ready!(this.io.as_mut().poll_write(cx, this.write_buf))?;
 
@@ -262,12 +260,15 @@ impl<T, U> Framed<T, U> {
         // Try flushing the underlying IO
         ready!(this.io.poll_flush(cx))?;
 
-        tracing::trace!("framed transport flushed");
+        log::trace!("framed transport flushed");
         Poll::Ready(Ok(()))
     }
 
     /// Flush write buffer and shutdown underlying I/O stream.
-    pub fn close<I>(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    pub fn close<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
     where
         T: AsyncWrite,
         U: Encoder<I>,

actix-codec/src/lib.rs

@@ -1,26 +1,25 @@
 //! Codec utilities for working with framed protocols.
 //!
-//! Contains adapters to go from streams of bytes, [`AsyncRead`] and [`AsyncWrite`], to framed
+//! Contains adapters to go from streams of bytes, [`AsyncRead`] and
-//! streams implementing [`Sink`] and [`Stream`]. Framed streams are also known as `transports`.
+//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
+//! Framed streams are also known as `transports`.
 //!
 //! [`Sink`]: futures_sink::Sink
 //! [`Stream`]: futures_core::Stream
 
+#![deny(rust_2018_idioms, nonstandard_style, future_incompatible)]
+#![warn(missing_docs)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
-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::{
+pub use self::bcodec::BytesCodec;
-    bcodec::BytesCodec,
+pub use self::framed::{Framed, FramedParts};
-    framed::{Framed, FramedParts},
+pub use self::lines::LinesCodec;
-    lines::LinesCodec,
+
-};
+pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+pub use tokio_util::codec::{Decoder, Encoder};
+pub use tokio_util::io::poll_read_buf;

actix-codec/src/lines.rs

@@ -7,8 +7,8 @@ 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
+/// Will split input up by LF or CRLF delimiters. I.e. carriage return characters at the end of
-/// not preserved.
+/// lines are not preserved.
 #[derive(Debug, Copy, Clone, Default)]
 #[non_exhaustive]
 pub struct LinesCodec;

actix-codec/tests/test_framed_sink.rs

@@ -1,18 +1,12 @@
-#![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 bytes::Buf;
+use bytes::{BufMut, BytesMut};
 use futures_sink::Sink;
+use std::collections::VecDeque;
+use std::io::{self, Write};
+use std::pin::Pin;
+use std::task::Poll::{Pending, Ready};
+use std::task::{Context, Poll};
 use tokio_test::{assert_ready, task};
 
 macro_rules! bilateral {
@@ -56,7 +50,7 @@ impl Write for Bilateral {
                 assert_eq!(&data[..], &src[..data.len()]);
                 Ok(data.len())
             }
-            Some(Err(err)) => Err(err),
+            Some(Err(e)) => Err(e),
             None => panic!("unexpected write; {:?}", src),
         }
     }
@@ -73,17 +67,20 @@ impl AsyncWrite for Bilateral {
         buf: &[u8],
     ) -> Poll<Result<usize, io::Error>> {
         match Pin::get_mut(self).write(buf) {
-            Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => Pending,
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Pending,
             other => Ready(other),
         }
     }
     fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
         match Pin::get_mut(self).flush() {
-            Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => Pending,
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Pending,
             other => Ready(other),
         }
     }
-    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
         unimplemented!()
     }
 }
@@ -102,8 +99,8 @@ impl AsyncRead for Bilateral {
                 buf.put_slice(&data);
                 Ready(Ok(()))
             }
-            Some(Err(ref err)) if err.kind() == WouldBlock => Pending,
+            Some(Err(ref e)) if e.kind() == WouldBlock => Pending,
-            Some(Err(err)) => Ready(Err(err)),
+            Some(Err(e)) => Ready(Err(e)),
             None => Ready(Ok(())),
         }
     }

actix-macros/CHANGES.md

@@ -1,53 +1,46 @@
 # Changes
 
-## Unreleased
+## Unreleased - 2021-xx-xx
 
-- Minimum supported Rust version (MSRV) is now 1.71.
 
-## 0.2.4
+## 0.2.3 - 2021-10-19
-
+* Fix test macro in presence of other imports named "test". [#399]
-- 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]
+## 0.2.2 - 2021-10-14
-- Allow custom `System`s on test macro. [#391]
+* 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]
+## 0.2.1 - 2021-02-02
+* Add optional argument `system` to `main` macro which can be used to specify the path to `actix_rt::System` (useful for re-exports). [#363]
 
 [#363]: https://github.com/actix/actix-net/pull/363
 
-## 0.2.0
 
-- Update to latest `actix_rt::System::new` signature. [#261]
+## 0.2.0 - 2021-02-02
+* Update to latest `actix_rt::System::new` signature. [#261]
 
 [#261]: https://github.com/actix/actix-net/pull/261
 
-## 0.2.0-beta.1
 
-- Remove `actix-reexport` feature. [#218]
+## 0.2.0-beta.1 - 2021-01-09
+* Remove `actix-reexport` feature. [#218]
 
 [#218]: https://github.com/actix/actix-net/pull/218
 
-## 0.1.3
 
-- Add `actix-reexport` feature. [#218]
+## 0.1.3 - 2020-12-03
+* 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]
+## 0.1.2 - 2020-05-18
+* Forward actix_rt::test arguments to test function [#127]
 
 [#127]: https://github.com/actix/actix-net/pull/127

actix-macros/Cargo.toml

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

actix-macros/src/lib.rs

@@ -8,14 +8,12 @@
 //! # Tests
 //! See docs for the [`#[test]`](macro@test) macro.
 
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![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.
 ///
@@ -26,7 +24,9 @@ type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![,]>;
 ///     println!("Hello world");
 /// }
 /// ```
+#[allow(clippy::needless_doctest_main)]
 #[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
     let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
         Ok(input) => input,
@@ -34,11 +34,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
         Err(err) => return input_and_compile_error(item, err),
     };
 
-    let parser = AttributeArgs::parse_terminated;
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
-    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;
@@ -58,15 +54,11 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 
     for arg in &args {
         match arg {
-            syn::Meta::NameValue(syn::MetaNameValue {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
+                lit: syn::Lit::Str(lit),
                 path,
-                value:
-                    syn::Expr::Lit(syn::ExprLit {
-                        lit: syn::Lit::Str(lit),
-                        ..
-                    }),
                 ..
-            }) => match path
+            })) => match path
                 .get_ident()
                 .map(|i| i.to_string().to_lowercase())
                 .as_deref()
@@ -85,7 +77,6 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
                         .into();
                 }
             },
-
             _ => {
                 return syn::Error::new_spanned(arg, "Unknown attribute specified")
                     .to_compile_error()
@@ -122,11 +113,7 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
         Err(err) => return input_and_compile_error(item, err),
     };
 
-    let parser = AttributeArgs::parse_terminated;
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
-    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;
@@ -135,7 +122,7 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
     let mut has_test_attr = false;
 
     for attr in attrs {
-        if attr.path().is_ident("test") {
+        if attr.path.is_ident("test") {
             has_test_attr = true;
         }
     }
@@ -161,15 +148,11 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
 
     for arg in &args {
         match arg {
-            syn::Meta::NameValue(syn::MetaNameValue {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
+                lit: syn::Lit::Str(lit),
                 path,
-                value:
-                    syn::Expr::Lit(syn::ExprLit {
-                        lit: syn::Lit::Str(lit),
-                        ..
-                    }),
                 ..
-            }) => match path
+            })) => match path
                 .get_ident()
                 .map(|i| i.to_string().to_lowercase())
                 .as_deref()

actix-macros/tests/trybuild.rs

@@ -1,10 +1,7 @@
-#![allow(missing_docs)]
+#[rustversion::stable(1.46)] // MSRV
-
-#[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");

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

@@ -1,11 +1,14 @@
 error: the async keyword is missing from the function declaration
- --> tests/trybuild/main-02-only-async.rs:2:1
+ --> $DIR/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
+ --> $DIR/main-02-only-async.rs:1:1
   |
-4 | }
+1 | / #[actix_rt::main]
-  |  ^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs`
+2 | | fn main() {
+3 | |     futures_util::future::ready(()).await
+4 | | }
+  | |_^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs`

actix-rt/CHANGES.md

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

actix-rt/Cargo.toml

@@ -1,18 +1,22 @@
 [package]
 name = "actix-rt"
-version = "2.10.0"
+version = "2.5.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+    "fakeshadow <24548779@qq.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"
+repository = "https://github.com/actix/actix-net.git"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-edition.workspace = true
+edition = "2018"
-rust-version.workspace = true
 
-[package.metadata.cargo_check_external_types]
+[lib]
-allowed_external_types = ["actix_macros::*", "tokio::*"]
+name = "actix_rt"
+path = "src/lib.rs"
 
 [features]
 default = ["macros"]
@@ -23,14 +27,11 @@ io-uring = ["tokio-uring"]
 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"] }
+tokio = { version = "1.5.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 }
+tokio-uring = { version = "0.1", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.23.1", features = ["full"] }
+tokio = { version = "1.5.1", features = ["full"] }
-
+hyper = { version = "0.14", default-features = false, features = ["server", "tcp", "http1"] }
-[lints]
-workspace = true

actix-rt/README.md

@@ -3,11 +3,11 @@
 > 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)
+[![Documentation](https://docs.rs/actix-rt/badge.svg?version=2.5.0)](https://docs.rs/actix-rt/2.5.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)
+[![dependency status](https://deps.rs/crate/actix-rt/2.5.0/status.svg)](https://deps.rs/crate/actix-rt/2.5.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)
 

actix-rt/examples/hyper.rs

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

actix-rt/src/arbiter.rs

@@ -16,7 +16,7 @@ use crate::system::{System, SystemCommand};
 pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 
 thread_local!(
-    static HANDLE: RefCell<Option<ArbiterHandle>> = const { RefCell::new(None) };
+    static HANDLE: RefCell<Option<ArbiterHandle>> = RefCell::new(None);
 );
 
 pub(crate) enum ArbiterCommand {
@@ -99,7 +99,8 @@ impl Arbiter {
     #[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.")
+            crate::runtime::default_tokio_runtime()
+                .expect("Cannot create new Arbiter's Runtime.")
         })
     }
 
@@ -107,9 +108,10 @@ impl Arbiter {
     ///
     /// [tokio-runtime]: tokio::runtime::Runtime
     #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+    #[doc(hidden)]
     pub fn with_tokio_rt<F>(runtime_factory: F) -> Arbiter
     where
-        F: FnOnce() -> tokio::runtime::Runtime + Send + 'static,
+        F: Fn() -> tokio::runtime::Runtime + Send + 'static,
     {
         let sys = System::current();
         let system_id = sys.id();
@@ -148,7 +150,9 @@ impl Arbiter {
                         .send(SystemCommand::DeregisterArbiter(arb_id));
                 }
             })
-            .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}"));
+            .unwrap_or_else(|err| {
+                panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err)
+            });
 
         ready_rx.recv().unwrap();
 
@@ -198,7 +202,9 @@ impl Arbiter {
                         .send(SystemCommand::DeregisterArbiter(arb_id));
                 }
             })
-            .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}"));
+            .unwrap_or_else(|err| {
+                panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err)
+            });
 
         ready_rx.recv().unwrap();
 
@@ -255,7 +261,6 @@ impl Arbiter {
     /// 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,
@@ -271,7 +276,6 @@ impl Arbiter {
     /// 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,
@@ -298,7 +302,7 @@ impl Future for ArbiterRunner {
     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)) {
+            match ready!(Pin::new(&mut self.rx).poll_recv(cx)) {
                 // channel closed; no more messages can be received
                 None => return Poll::Ready(()),
 

actix-rt/src/lib.rs

@@ -34,13 +34,14 @@
 //! ```
 //!
 //! # `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.
 
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![warn(missing_docs)]
 #![allow(clippy::type_complexity)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
@@ -50,10 +51,13 @@ compile_error!("io_uring is a linux only feature.");
 
 use std::future::Future;
 
+use tokio::task::JoinHandle;
+
 // Cannot define a main macro when compiled into test harness.
 // Workaround for https://github.com/rust-lang/rust/issues/62127.
 #[cfg(all(feature = "macros", not(test)))]
 pub use actix_macros::main;
+
 #[cfg(feature = "macros")]
 pub use actix_macros::test;
 
@@ -61,14 +65,11 @@ mod arbiter;
 mod runtime;
 mod system;
 
-pub use tokio::pin;
+pub use self::arbiter::{Arbiter, ArbiterHandle};
-use tokio::task::JoinHandle;
+pub use self::runtime::Runtime;
+pub use self::system::{System, SystemRunner};
 
-pub use self::{
+pub use tokio::pin;
-    arbiter::{Arbiter, ArbiterHandle},
-    runtime::Runtime,
-    system::{System, SystemRunner},
-};
 
 pub mod signal {
     //! Asynchronous signal handling (Tokio re-exports).
@@ -90,13 +91,13 @@ pub mod net {
         task::{Context, Poll},
     };
 
+    pub use tokio::io::Ready;
     use tokio::io::{AsyncRead, AsyncWrite, Interest};
+    pub use tokio::net::UdpSocket;
+    pub use tokio::net::{TcpListener, TcpSocket, TcpStream};
+
     #[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)]
@@ -155,9 +156,10 @@ pub mod net {
 pub mod time {
     //! Utilities for tracking time (Tokio re-exports).
 
-    pub use tokio::time::{
+    pub use tokio::time::Instant;
-        interval, interval_at, sleep, sleep_until, timeout, Instant, Interval, Sleep, Timeout,
+    pub use tokio::time::{interval, interval_at, Interval};
-    };
+    pub use tokio::time::{sleep, sleep_until, Sleep};
+    pub use tokio::time::{timeout, Timeout};
 }
 
 pub mod task {
@@ -196,7 +198,6 @@ pub mod task {
 /// assert!(handle.await.unwrap_err().is_cancelled());
 /// # });
 /// ```
-#[track_caller]
 #[inline]
 pub fn spawn<Fut>(f: Fut) -> JoinHandle<Fut::Output>
 where

actix-rt/src/runtime.rs

@@ -53,7 +53,6 @@ impl Runtime {
     /// # 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,
@@ -61,62 +60,6 @@ impl Runtime {
         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
@@ -130,7 +73,6 @@ impl Runtime {
     ///
     /// 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,

actix-rt/src/system.rs

@@ -16,7 +16,7 @@ use crate::{arbiter::ArbiterHandle, Arbiter};
 static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 thread_local!(
-    static CURRENT: RefCell<Option<System>> = const { RefCell::new(None) };
+    static CURRENT: RefCell<Option<System>> = RefCell::new(None);
 );
 
 /// A manager for a per-thread distributed async runtime.
@@ -46,9 +46,10 @@ impl System {
     /// Create a new System using the [Tokio Runtime](tokio-runtime) returned from a closure.
     ///
     /// [tokio-runtime]: tokio::runtime::Runtime
+    #[doc(hidden)]
     pub fn with_tokio_rt<F>(runtime_factory: F) -> SystemRunner
     where
-        F: FnOnce() -> tokio::runtime::Runtime,
+        F: Fn() -> tokio::runtime::Runtime,
     {
         let (stop_tx, stop_rx) = oneshot::channel();
         let (sys_tx, sys_rx) = mpsc::unbounded_channel();
@@ -87,7 +88,7 @@ impl System {
     #[doc(hidden)]
     pub fn with_tokio_rt<F>(_: F) -> SystemRunner
     where
-        F: FnOnce() -> tokio::runtime::Runtime,
+        F: Fn() -> tokio::runtime::Runtime,
     {
         unimplemented!("System::with_tokio_rt is not implemented for io-uring feature yet")
     }
@@ -203,42 +204,7 @@ impl SystemRunner {
             .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)
@@ -260,7 +226,9 @@ impl SystemRunner {
 
     /// 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");
+        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.
@@ -324,7 +292,7 @@ impl Future for SystemController {
     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)) {
+            match ready!(Pin::new(&mut self.cmd_rx).poll_recv(cx)) {
                 // channel closed; no more messages can be received
                 None => return Poll::Ready(()),
 

actix-rt/tests/tests.rs

@@ -1,11 +1,10 @@
-#![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},
@@ -360,7 +359,7 @@ fn tokio_uring_arbiter() {
                 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;
+                let (res, _) = f.write_at(&buf[..], 0).await;
                 assert!(res.is_ok());
 
                 f.sync_all().await.unwrap();

actix-server/CHANGES.md

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

@@ -1,50 +1,46 @@
 [package]
 name = "actix-server"
-version = "2.5.1"
+version = "2.0.0-beta.9"
 authors = [
-  "Nikolay Kim <fafhrd91@gmail.com>",
+    "Nikolay Kim <fafhrd91@gmail.com>",
-  "Rob Ede <robjtede@icloud.com>",
+    "fakeshadow <24548779@qq.com>",
-  "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
 ]
 description = "General purpose TCP server built for the Actix ecosystem"
-keywords = ["network", "tcp", "server", "framework", "async"]
+keywords = ["network", "framework", "async", "futures"]
+repository = "https://github.com/actix/actix-net.git"
 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
+edition = "2018"
-rust-version.workspace = true
 
-[package.metadata.cargo_check_external_types]
+[lib]
-allowed_external_types = ["tokio::*"]
+name = "actix_server"
+path = "src/lib.rs"
 
 [features]
 default = []
 io-uring = ["tokio-uring", "actix-rt/io-uring"]
 
 [dependencies]
-actix-rt = { version = "2.10", default-features = false }
+actix-rt = { version = "2.4.0", default-features = false }
-actix-service = "2"
+actix-service = "2.0.0"
-actix-utils = "3"
+actix-utils = "3.0.0"
-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
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-[target.'cfg(target_os = "linux")'.dependencies]
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
-tokio-uring = { version = "0.5", optional = true }
+log = "0.4"
+mio = { version = "0.8", features = ["os-poll", "net"] }
+num_cpus = "1.13"
+socket2 = "0.4.2"
+tokio = { version = "1.5.1", features = ["sync"] }
+
+# runtime for io-uring feature
+tokio-uring = { version = "0.1", optional = true }
 
 [dev-dependencies]
-actix-codec = "0.5"
+actix-codec = "0.4.0"
-actix-rt = "2.8"
+actix-rt = "2.4.0"
 
 bytes = "1"
-futures-util = { version = "0.3.17", default-features = false, features = ["sink", "async-await-macro"] }
+env_logger = "0.9"
-pretty_env_logger = "0.5"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
-tokio = { version = "1.23.1", features = ["io-util", "rt-multi-thread", "macros", "fs"] }
+tokio = { version = "1.5.1", features = ["io-util", "rt-multi-thread", "macros"] }
-
-[lints]
-workspace = true

actix-server/README.md

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

@@ -1,98 +0,0 @@
-//! 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

@@ -22,20 +22,20 @@ use actix_server::Server;
 use actix_service::{fn_service, ServiceFactoryExt as _};
 use bytes::BytesMut;
 use futures_util::future::ok;
+use log::{error, info};
 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
 
 async fn run() -> io::Result<()> {
-    pretty_env_logger::formatted_timed_builder()
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
-        .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);
+    info!("starting server on port: {}", &addr.0);
 
-    // Bind socket address and start worker(s). By default, the server uses the number of physical
+    // Bind socket address and start worker(s). By default, the server uses the number of available
-    // CPU cores as the worker count. For this reason, the closure passed to bind needs to return
+    // logical CPU cores as the worker count. For this reason, the closure passed to bind needs
-    // a service *factory*; so it can be created once per worker.
+    // to return a service *factory*; so it can be created once per worker.
     Server::build()
         .bind("echo", addr, move || {
             let count = Arc::clone(&count);
@@ -58,14 +58,14 @@ async fn run() -> io::Result<()> {
 
                             // more bytes to process
                             Ok(bytes_read) => {
-                                tracing::info!("[{}] read {} bytes", num, bytes_read);
+                                info!("[{}] read {} bytes", num, bytes_read);
                                 stream.write_all(&buf[size..]).await.unwrap();
                                 size += bytes_read;
                             }
 
                             // stream error; bail from loop with error
                             Err(err) => {
-                                tracing::error!("stream error: {:?}", err);
+                                error!("Stream Error: {:?}", err);
                                 return Err(());
                             }
                         }
@@ -75,14 +75,14 @@ async fn run() -> io::Result<()> {
                     Ok((buf.freeze(), size))
                 }
             })
-            .map_err(|err| tracing::error!("service error: {:?}", err))
+            .map_err(|err| error!("Service Error: {:?}", err))
             .and_then(move |(_, size)| {
                 let num = num2.load(Ordering::SeqCst);
-                tracing::info!("[{}] total bytes read: {}", num, size);
+                info!("[{}] total bytes read: {}", num, size);
                 ok(size)
             })
         })?
-        .workers(2)
+        .workers(1)
         .run()
         .await
 }

actix-server/src/accept.rs

@@ -1,8 +1,8 @@
 use std::{io, thread, time::Duration};
 
 use actix_rt::time::Instant;
+use log::{debug, error, info};
 use mio::{Interest, Poll, Token as MioToken};
-use tracing::{debug, error, info};
 
 use crate::{
     availability::Availability,
@@ -24,7 +24,7 @@ struct ServerSocketInfo {
     timeout: Option<actix_rt::time::Instant>,
 }
 
-/// Poll instance of the server.
+/// poll instance of the server.
 pub(crate) struct Accept {
     poll: Poll,
     waker_queue: WakerQueue,
@@ -41,7 +41,7 @@ impl Accept {
     pub(crate) fn start(
         sockets: Vec<(usize, MioListener)>,
         builder: &ServerBuilder,
-    ) -> io::Result<(WakerQueue, Vec<WorkerHandleServer>, thread::JoinHandle<()>)> {
+    ) -> io::Result<(WakerQueue, Vec<WorkerHandleServer>)> {
         let handle_server = ServerHandle::new(builder.cmd_tx.clone());
 
         // construct poll instance and its waker
@@ -73,12 +73,12 @@ impl Accept {
             handle_server,
         )?;
 
-        let accept_handle = thread::Builder::new()
+        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))
+        Ok((waker_queue, handles_server))
     }
 
     fn new_with_sockets(
@@ -127,10 +127,10 @@ impl Accept {
         let mut events = mio::Events::with_capacity(256);
 
         loop {
-            if let Err(err) = self.poll.poll(&mut events, self.timeout) {
+            if let Err(e) = self.poll.poll(&mut events, self.timeout) {
-                match err.kind() {
+                match e.kind() {
                     io::ErrorKind::Interrupted => {}
-                    _ => panic!("Poll error: {}", err),
+                    _ => panic!("Poll error: {}", e),
                 }
             }
 
@@ -140,7 +140,7 @@ impl Accept {
                     WAKER_TOKEN => {
                         let exit = self.handle_waker(sockets);
                         if exit {
-                            info!("accept thread stopped");
+                            info!("Accept thread stopped");
                             return;
                         }
                     }
@@ -161,13 +161,11 @@ impl Accept {
         // 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
+            // take guard with every iteration so no new interest can be added
-            // task is done. Take care not to take the guard again inside this loop.
+            // until the current task is done.
             let mut guard = self.waker_queue.guard();
-
-            #[allow(clippy::significant_drop_in_scrutinee)]
             match guard.pop_front() {
-                // Worker notified it became available.
+                // worker notify it becomes available.
                 Some(WakerInterest::WorkerAvailable(idx)) => {
                     drop(guard);
 
@@ -178,7 +176,7 @@ impl Accept {
                     }
                 }
 
-                // A new worker thread has been created so store its handle.
+                // a new worker thread is made and it's handle would be added to Accept
                 Some(WakerInterest::Worker(handle)) => {
                     drop(guard);
 
@@ -299,16 +297,16 @@ impl Accept {
 
     fn register_logged(&self, info: &mut ServerSocketInfo) {
         match self.register(info) {
-            Ok(_) => debug!("resume accepting connections on {}", info.lst.local_addr()),
+            Ok(_) => debug!("Resume accepting connections on {}", info.lst.local_addr()),
-            Err(err) => error!("can not register server socket {}", err),
+            Err(e) => error!("Can not register server socket {}", e),
         }
     }
 
     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()),
+            Ok(_) => debug!("Paused accepting connections on {}", info.lst.local_addr()),
-            Err(err) => {
+            Err(e) => {
-                error!("can not deregister server socket {}", err)
+                error!("Can not deregister server socket {}", e)
             }
         }
     }
@@ -352,7 +350,7 @@ impl Accept {
                 self.remove_next();
 
                 if self.handles.is_empty() {
-                    error!("no workers");
+                    error!("No workers");
                     // All workers are gone and Conn is nowhere to be sent.
                     // Treat this situation as Ok and drop Conn.
                     return Ok(());
@@ -398,10 +396,10 @@ impl Accept {
                     let conn = Conn { io, token };
                     self.accept_one(conn);
                 }
-                Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => return,
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return,
-                Err(ref err) if connection_error(err) => continue,
+                Err(ref e) if connection_error(e) => continue,
-                Err(err) => {
+                Err(e) => {
-                    error!("error accepting connection: {}", err);
+                    error!("Error accepting connection: {}", e);
 
                     // deregister listener temporary
                     self.deregister_logged(info);

actix-server/src/builder.rs

@@ -1,34 +1,19 @@
-use std::{io, num::NonZeroUsize, time::Duration};
+use std::{io, time::Duration};
 
 use actix_rt::net::TcpStream;
+use log::{info, trace};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 
 use crate::{
     server::ServerCommand,
-    service::{InternalServiceFactory, ServerServiceFactory, StreamNewService},
+    service::{InternalServiceFactory, ServiceFactory, StreamNewService},
-    socket::{create_mio_tcp_listener, MioListener, MioTcpListener, StdTcpListener, ToSocketAddrs},
+    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,
@@ -36,7 +21,6 @@ pub struct ServerBuilder {
     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>,
@@ -56,12 +40,11 @@ impl ServerBuilder {
         let (cmd_tx, cmd_rx) = unbounded_channel();
 
         ServerBuilder {
-            threads: std::thread::available_parallelism().map_or(2, NonZeroUsize::get),
+            threads: num_cpus::get(),
             token: 0,
             factories: Vec::new(),
             sockets: Vec::new(),
             backlog: 2048,
-            mptcp: MpTcp::Disabled,
             exit: false,
             listen_os_signals: true,
             cmd_tx,
@@ -70,19 +53,10 @@ impl ServerBuilder {
         }
     }
 
-    /// Sets number of workers to start.
+    /// Set number of workers to start.
     ///
-    /// See [`bind()`](Self::bind()) for more details on how worker count affects the number of
+    /// By default server uses number of available logical CPU as workers count. Workers must be
-    /// server factory instantiations.
+    /// greater than 0.
-    ///
-    /// 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;
@@ -121,24 +95,6 @@ impl ServerBuilder {
         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
@@ -156,15 +112,13 @@ impl ServerBuilder {
         self.max_concurrent_connections(num)
     }
 
-    /// Sets flag to stop Actix `System` after server shutdown.
+    /// 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.
+    /// Disable OS signal handling.
     pub fn disable_signals(mut self) -> Self {
         self.listen_os_signals = false;
         self
@@ -182,49 +136,24 @@ impl ServerBuilder {
         self
     }
 
-    /// Adds new service to the server.
+    /// Add new service to the server.
-    ///
+    pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
-    /// 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>,
+        F: ServiceFactory<TcpStream>,
         U: ToSocketAddrs,
-        N: AsRef<str>,
     {
-        let sockets = bind_addr(addrs, self.backlog, &self.mptcp)?;
+        let sockets = bind_addr(addr, self.backlog)?;
 
-        tracing::trace!("binding server to: {sockets:?}");
+        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)));
         }
@@ -232,12 +161,7 @@ impl ServerBuilder {
         Ok(self)
     }
 
-    /// Adds service to the server using a socket listener already bound.
+    /// Add new service to the server.
-    ///
-    /// # 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,
@@ -245,7 +169,7 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServerServiceFactory<TcpStream>,
+        F: ServiceFactory<TcpStream>,
     {
         lst.set_nonblocking(true)?;
         let addr = lst.local_addr()?;
@@ -269,7 +193,7 @@ impl ServerBuilder {
         if self.sockets.is_empty() {
             panic!("Server should have at least one bound socket");
         } else {
-            tracing::info!("starting {} workers", self.threads);
+            info!("Starting {} workers", self.threads);
             Server::new(self)
         }
     }
@@ -283,24 +207,19 @@ impl ServerBuilder {
 
 #[cfg(unix)]
 impl ServerBuilder {
-    /// Adds new service to the server using a UDS (unix domain socket) address.
+    /// Add new unix domain service to the server.
-    ///
-    /// # 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>,
+        F: ServiceFactory<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()) {
+        if let Err(e) = std::fs::remove_file(addr.as_ref()) {
             // NotFound is expected and not an issue. Anything else is.
-            if err.kind() != std::io::ErrorKind::NotFound {
+            if e.kind() != std::io::ErrorKind::NotFound {
-                return Err(err);
+                return Err(e);
             }
         }
 
@@ -308,14 +227,9 @@ impl ServerBuilder {
         self.listen_uds(name, lst, factory)
     }
 
-    /// Adds new service to the server using a UDS (unix domain socket) listener already bound.
+    /// Add new unix domain service to the server.
     ///
     /// 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,
@@ -323,25 +237,21 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServerServiceFactory<actix_rt::net::UnixStream>,
+        F: ServiceFactory<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);
+        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)
     }
 }
@@ -349,25 +259,23 @@ impl ServerBuilder {
 pub(super) fn bind_addr<S: ToSocketAddrs>(
     addr: S,
     backlog: u32,
-    mptcp: &MpTcp,
 ) -> io::Result<Vec<MioTcpListener>> {
-    let mut opt_err = None;
+    let mut 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) {
+        match create_mio_tcp_listener(addr, backlog) {
             Ok(lst) => {
                 success = true;
                 sockets.push(lst);
             }
-            Err(err) => opt_err = Some(err),
+            Err(e) => err = Some(e),
         }
     }
 
     if success {
         Ok(sockets)
-    } else if let Some(err) = opt_err.take() {
+    } else if let Some(err) = err.take() {
         Err(err)
     } else {
         Err(io::Error::new(

actix-server/src/handle.rs

@@ -46,7 +46,6 @@ impl ServerHandle {
         let _ = self.cmd_tx.send(ServerCommand::Stop {
             graceful,
             completion: Some(tx),
-            force_system_stop: false,
         });
 
         async {

actix-server/src/join_all.rs

@@ -63,10 +63,10 @@ impl<T> Future for JoinAll<T> {
 
 #[cfg(test)]
 mod test {
-    use actix_utils::future::ready;
-
     use super::*;
 
+    use actix_utils::future::ready;
+
     #[actix_rt::test]
     async fn test_join_all() {
         let futs = vec![ready(Ok(1)), ready(Err(3)), ready(Ok(9))];

actix-server/src/lib.rs

@@ -1,5 +1,6 @@
 //! General purpose TCP server.
 
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
@@ -16,15 +17,14 @@ mod test_server;
 mod waker_queue;
 mod worker;
 
+pub use self::builder::ServerBuilder;
+pub use self::handle::ServerHandle;
+pub use self::server::Server;
+pub use self::service::ServiceFactory;
+pub use self::test_server::TestServer;
+
 #[doc(hidden)]
 pub use self::socket::FromStream;
-pub use self::{
-    builder::{MpTcp, ServerBuilder},
-    handle::ServerHandle,
-    server::Server,
-    service::ServerServiceFactory,
-    test_server::TestServer,
-};
 
 /// Start server building process
 #[doc(hidden)]

actix-server/src/server.rs

@@ -3,15 +3,16 @@ use std::{
     io, mem,
     pin::Pin,
     task::{Context, Poll},
-    thread,
     time::Duration,
 };
 
 use actix_rt::{time::sleep, System};
-use futures_core::{future::BoxFuture, Stream};
+use futures_core::future::BoxFuture;
-use futures_util::stream::StreamExt as _;
+use log::{error, info};
-use tokio::sync::{mpsc::UnboundedReceiver, oneshot};
+use tokio::sync::{
-use tracing::{error, info};
+    mpsc::{UnboundedReceiver, UnboundedSender},
+    oneshot,
+};
 
 use crate::{
     accept::Accept,
@@ -48,9 +49,6 @@ pub(crate) enum ServerCommand {
 
         /// 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,
     },
 }
 
@@ -62,11 +60,11 @@ pub(crate) enum ServerCommand {
 /// 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
+/// The [Server] must be awaited to process stop commands and listen for OS signals. It will resolve
-/// server has fully shut down.
+/// 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
+/// On UNIX systems, `SIGQUIT` will start a graceful shutdown and `SIGTERM` or `SIGINT` will start a
 /// forced shutdown. On Windows, a Ctrl-C signal will start a forced shutdown.
 ///
 /// A graceful shutdown will wait for all workers to stop first.
@@ -121,10 +119,10 @@ pub(crate) enum ServerCommand {
 ///         .await
 /// }
 /// ```
-#[must_use = "Server does nothing unless you `.await` or poll it"]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct Server {
+pub enum Server {
-    handle: ServerHandle,
+    Server(ServerInner),
-    fut: BoxFuture<'static, io::Result<()>>,
+    Error(Option<io::Error>),
 }
 
 impl Server {
@@ -133,56 +131,12 @@ impl Server {
         ServerBuilder::default()
     }
 
-    pub(crate) fn new(builder: ServerBuilder) -> Self {
+    pub(crate) fn new(mut builder: ServerBuilder) -> Self {
-        Server {
+        let sockets = mem::take(&mut builder.sockets)
-            handle: ServerHandle::new(builder.cmd_tx.clone()),
+            .into_iter()
-            fut: Box::pin(ServerInner::run(builder)),
+            .map(|t| (t.0, t.2))
-        }
+            .collect();
-    }
 
-    /// 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();
@@ -195,95 +149,156 @@ impl ServerInner {
 
         for (_, name, lst) in &builder.sockets {
             info!(
-                r#"starting service: "{}", workers: {}, listening on: {}"#,
+                r#"Starting service: "{}", workers: {}, listening on: {}"#,
                 name,
                 builder.threads,
                 lst.local_addr()
             );
         }
 
-        let sockets = mem::take(&mut builder.sockets)
+        match Accept::start(sockets, &builder) {
-            .into_iter()
+            Ok((waker_queue, worker_handles)) => {
-            .map(|t| (t.0, t.2))
+                // construct OS signals listener future
-            .collect();
+                let signals = (builder.listen_os_signals).then(Signals::new);
 
-        let (waker_queue, worker_handles, accept_handle) = Accept::start(sockets, &builder)?;
+                Self::Server(ServerInner {
+                    cmd_tx: builder.cmd_tx.clone(),
+                    cmd_rx: builder.cmd_rx,
+                    signals,
+                    waker_queue,
+                    worker_handles,
+                    worker_config: builder.worker_config,
+                    services: builder.factories,
+                    exit: builder.exit,
+                    stop_task: None,
+                })
+            }
 
-        let mux = ServerEventMultiplexer {
+            Err(err) => Self::Error(Some(err)),
-            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) {
+    /// Get a handle for ServerFuture that can be used to change state of actix server.
+    ///
+    /// See [ServerHandle](ServerHandle) for usage.
+    pub fn handle(&self) -> ServerHandle {
+        match self {
+            Server::Server(inner) => ServerHandle::new(inner.cmd_tx.clone()),
+            Server::Error(err) => {
+                // TODO: i don't think this is the best way to handle server startup fail
+                panic!(
+                    "server handle can not be obtained because server failed to start up: {}",
+                    err.as_ref().unwrap()
+                );
+            }
+        }
+    }
+}
+
+impl Future for Server {
+    type Output = io::Result<()>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.as_mut().get_mut() {
+            Self::Error(err) => Poll::Ready(Err(err
+                .take()
+                .expect("Server future cannot be polled after error"))),
+
+            Self::Server(inner) => {
+                // poll Signals
+                if let Some(ref mut signals) = inner.signals {
+                    if let Poll::Ready(signal) = Pin::new(signals).poll(cx) {
+                        inner.stop_task = inner.handle_signal(signal);
+                        // drop signals listener
+                        inner.signals = None;
+                    }
+                }
+
+                // handle stop tasks and eager drain command channel
+                loop {
+                    if let Some(ref mut fut) = inner.stop_task {
+                        // only resolve stop task and exit
+                        return fut.as_mut().poll(cx).map(|_| Ok(()));
+                    }
+
+                    match Pin::new(&mut inner.cmd_rx).poll_recv(cx) {
+                        Poll::Ready(Some(cmd)) => {
+                            // if stop task is required, set it and loop
+                            inner.stop_task = inner.handle_cmd(cmd);
+                        }
+                        _ => return Poll::Pending,
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub struct ServerInner {
+    worker_handles: Vec<WorkerHandleServer>,
+    worker_config: ServerWorkerConfig,
+    services: Vec<Box<dyn InternalServiceFactory>>,
+    exit: bool,
+    cmd_tx: UnboundedSender<ServerCommand>,
+    cmd_rx: UnboundedReceiver<ServerCommand>,
+    signals: Option<Signals>,
+    waker_queue: WakerQueue,
+    stop_task: Option<BoxFuture<'static, ()>>,
+}
+
+impl ServerInner {
+    fn handle_cmd(&mut self, item: ServerCommand) -> Option<BoxFuture<'static, ()>> {
         match item {
             ServerCommand::Pause(tx) => {
                 self.waker_queue.wake(WakerInterest::Pause);
                 let _ = tx.send(());
+                None
             }
 
             ServerCommand::Resume(tx) => {
                 self.waker_queue.wake(WakerInterest::Resume);
                 let _ = tx.send(());
+                None
             }
 
             ServerCommand::Stop {
                 graceful,
                 completion,
-                force_system_stop,
             } => {
-                self.stopping = true;
+                let exit = self.exit;
 
-                // Signal accept thread to stop.
+                // stop accept thread
-                // Signal is non-blocking; we wait for thread to stop later.
                 self.waker_queue.wake(WakerInterest::Stop);
 
-                // send stop signal to workers
+                // stop workers
                 let workers_stop = self
                     .worker_handles
                     .iter()
                     .map(|worker| worker.stop(graceful))
                     .collect::<Vec<_>>();
 
-                if graceful {
+                Some(Box::pin(async move {
-                    // wait for all workers to shut down
+                    if graceful {
-                    let _ = join_all(workers_stop).await;
+                        // wait for all workers to shut down
-                }
+                        let _ = join_all(workers_stop).await;
+                    }
 
-                // wait for accept thread stop
+                    if let Some(tx) = completion {
-                self.accept_handle
+                        let _ = tx.send(());
-                    .take()
+                    }
-                    .unwrap()
-                    .join()
-                    .expect("Accept thread must not panic in any case");
 
-                if let Some(tx) = completion {
+                    if exit {
-                    let _ = tx.send(());
+                        sleep(Duration::from_millis(300)).await;
-                }
+                        System::try_current().as_ref().map(System::stop);
-
+                    }
-                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);
+                error!("Worker {} has died; restarting", idx);
 
                 let factories = self
                     .services
@@ -309,60 +324,40 @@ impl ServerInner {
 
                     Err(err) => error!("can not restart worker {}: {}", idx, err),
                 };
+
+                None
             }
         }
     }
 
-    fn map_signal(signal: SignalKind) -> ServerCommand {
+    fn handle_signal(&mut self, signal: SignalKind) -> Option<BoxFuture<'static, ()>> {
         match signal {
             SignalKind::Int => {
                 info!("SIGINT received; starting forced shutdown");
-                ServerCommand::Stop {
+                self.exit = true;
+                self.handle_cmd(ServerCommand::Stop {
                     graceful: false,
                     completion: None,
-                    force_system_stop: true,
+                })
-                }
             }
 
             SignalKind::Term => {
                 info!("SIGTERM received; starting graceful shutdown");
-                ServerCommand::Stop {
+                self.exit = true;
+                self.handle_cmd(ServerCommand::Stop {
                     graceful: true,
                     completion: None,
-                    force_system_stop: true,
+                })
-                }
             }
 
             SignalKind::Quit => {
                 info!("SIGQUIT received; starting forced shutdown");
-                ServerCommand::Stop {
+                self.exit = true;
+                self.handle_cmd(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

@@ -1,21 +1,16 @@
-use std::{
+use std::marker::PhantomData;
-    marker::PhantomData,
+use std::net::SocketAddr;
-    net::SocketAddr,
+use std::task::{Context, Poll};
-    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 log::error;
 
-use crate::{
+use crate::socket::{FromStream, MioStream};
-    socket::{FromStream, MioStream},
+use crate::worker::WorkerCounterGuard;
-    worker::WorkerCounterGuard,
-};
 
-#[doc(hidden)]
+pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
-pub trait ServerServiceFactory<Stream: FromStream>: Send + Clone + 'static {
     type Factory: BaseServiceFactory<Stream, Config = ()>;
 
     fn create(&self) -> Self::Factory;
@@ -77,15 +72,15 @@ where
                 });
                 Ok(())
             }
-            Err(err) => {
+            Err(e) => {
-                error!("can not convert to an async TCP stream: {err}");
+                error!("Can not convert to an async tcp stream: {}", e);
                 Err(())
             }
         })
     }
 }
 
-pub(crate) struct StreamNewService<F: ServerServiceFactory<Io>, Io: FromStream> {
+pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
     name: String,
     inner: F,
     token: usize,
@@ -95,7 +90,7 @@ pub(crate) struct StreamNewService<F: ServerServiceFactory<Io>, Io: FromStream>
 
 impl<F, Io> StreamNewService<F, Io>
 where
-    F: ServerServiceFactory<Io>,
+    F: ServiceFactory<Io>,
     Io: FromStream + Send + 'static,
 {
     pub(crate) fn create(
@@ -116,7 +111,7 @@ where
 
 impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
 where
-    F: ServerServiceFactory<Io>,
+    F: ServiceFactory<Io>,
     Io: FromStream + Send + 'static,
 {
     fn name(&self, _: usize) -> &str {
@@ -148,7 +143,7 @@ where
     }
 }
 
-impl<F, T, I> ServerServiceFactory<I> for F
+impl<F, T, I> ServiceFactory<I> for F
 where
     F: Fn() -> T + Send + Clone + 'static,
     T: BaseServiceFactory<I, Config = ()>,

actix-server/src/signals.rs

@@ -5,7 +5,7 @@ use std::{
     task::{Context, Poll},
 };
 
-use tracing::trace;
+use log::trace;
 
 /// Types of process signals.
 // #[allow(dead_code)]
@@ -69,8 +69,8 @@ impl Signals {
                     unix::signal(*kind)
                         .map(|tokio_sig| (*sig, tokio_sig))
                         .map_err(|e| {
-                            tracing::error!(
+                            log::error!(
-                                "can not initialize stream handler for {:?} err: {}",
+                                "Can not initialize stream handler for {:?} err: {}",
                                 sig,
                                 e
                             )
@@ -96,7 +96,7 @@ impl Future for Signals {
         #[cfg(unix)]
         {
             for (sig, fut) in self.signals.iter_mut() {
-                if fut.poll_recv(cx).is_ready() {
+                if Pin::new(fut).poll_recv(cx).is_ready() {
                     trace!("{} received", sig);
                     return Poll::Ready(*sig);
                 }

actix-server/src/socket.rs

@@ -1,17 +1,18 @@
 pub(crate) use std::net::{
     SocketAddr as StdSocketAddr, TcpListener as StdTcpListener, ToSocketAddrs,
 };
+
+pub(crate) use mio::net::TcpListener as MioTcpListener;
+#[cfg(unix)]
+pub(crate) use {
+    mio::net::UnixListener as MioUnixListener,
+    std::os::unix::net::UnixListener as StdUnixListener,
+};
+
 use std::{fmt, io};
 
 use actix_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),
@@ -106,7 +107,7 @@ 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)]
+            #[cfg(all(unix))]
             MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
         }
     }
@@ -126,7 +127,7 @@ pub(crate) enum SocketAddr {
     Unknown,
     Tcp(StdSocketAddr),
     #[cfg(unix)]
-    Uds(std::os::unix::net::SocketAddr),
+    Uds(mio::net::SocketAddr),
 }
 
 impl fmt::Display for SocketAddr {
@@ -160,7 +161,6 @@ pub enum MioStream {
 
 /// 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>;
 }
 
@@ -226,30 +226,10 @@ mod unix_impl {
 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 socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
-    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)?;
@@ -270,7 +250,7 @@ mod tests {
         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 = create_mio_tcp_listener(addr, 128).unwrap();
         let lst = MioListener::Tcp(lst);
         assert!(format!("{:?}", lst).contains("TcpListener"));
         assert!(format!("{}", lst).contains("127.0.0.1"));

actix-server/src/test_server.rs

@@ -2,7 +2,7 @@ use std::{io, net, sync::mpsc, thread};
 
 use actix_rt::{net::TcpStream, System};
 
-use crate::{Server, ServerBuilder, ServerHandle, ServerServiceFactory};
+use crate::{Server, ServerBuilder, ServerHandle, ServiceFactory};
 
 /// A testing server.
 ///
@@ -16,7 +16,7 @@ use crate::{Server, ServerBuilder, ServerHandle, ServerServiceFactory};
 ///
 /// #[actix_rt::main]
 /// async fn main() {
-///     let srv = TestServer::start(|| fn_service(
+///     let srv = TestServer::with(|| fn_service(
 ///         |sock| async move {
 ///             println!("New connection: {:?}", sock);
 ///             Ok::<_, ()>(())
@@ -28,8 +28,8 @@ use crate::{Server, ServerBuilder, ServerHandle, ServerServiceFactory};
 /// ```
 pub struct TestServer;
 
-/// Test server handle.
+/// Test server runtime
-pub struct TestServerHandle {
+pub struct TestServerRuntime {
     addr: net::SocketAddr,
     host: String,
     port: u16,
@@ -38,26 +38,46 @@ pub struct TestServerHandle {
 }
 
 impl TestServer {
-    /// Start new `TestServer` using application factory and default server config.
+    /// Start new server with server builder.
-    pub fn start(factory: impl ServerServiceFactory<TcpStream>) -> TestServerHandle {
+    pub fn start<F>(mut factory: F) -> TestServerRuntime
-        Self::start_with_builder(Server::build(), factory)
+    where
-    }
+        F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static,
-
+    {
-    /// 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
+                let server = factory(Server::build()).workers(1).disable_signals().run();
-                    .listen("test", lst, factory)
+                tx.send(server.handle()).unwrap();
+                server.await
+            })
+        });
+
+        let server_handle = rx.recv().unwrap();
+
+        TestServerRuntime {
+            addr: "127.0.0.1:0".parse().unwrap(),
+            host: "127.0.0.1".to_string(),
+            port: 0,
+            server_handle,
+            thread_handle: Some(thread_handle),
+        }
+    }
+
+    /// Start new test server with application factory.
+    pub fn with<F: ServiceFactory<TcpStream>>(factory: F) -> TestServerRuntime {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        let thread_handle = thread::spawn(move || {
+            let sys = System::new();
+            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let local_addr = tcp.local_addr().unwrap();
+
+            sys.block_on(async {
+                let server = Server::build()
+                    .listen("test", tcp, factory)
                     .unwrap()
                     .workers(1)
                     .disable_signals()
@@ -73,7 +93,7 @@ impl TestServer {
         let host = format!("{}", addr.ip());
         let port = addr.port();
 
-        TestServerHandle {
+        TestServerRuntime {
             addr,
             host,
             port,
@@ -87,19 +107,17 @@ impl TestServer {
         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 =
-        let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP)).unwrap();
+            Socket::new(Domain::for_address(addr), 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 {
+impl TestServerRuntime {
     /// Test server host.
     pub fn host(&self) -> &str {
         &self.host
@@ -117,19 +135,17 @@ impl TestServerHandle {
 
     /// Stop server.
     fn stop(&mut self) {
-        drop(self.server_handle.stop(false));
+        let _ = 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> {
+    pub fn connect(&self) -> std::io::Result<TcpStream> {
-        let stream = net::TcpStream::connect(self.addr)?;
+        TcpStream::from_std(net::TcpStream::connect(self.addr)?)
-        stream.set_nonblocking(true)?;
-        TcpStream::from_std(stream)
     }
 }
 
-impl Drop for TestServerHandle {
+impl Drop for TestServerRuntime {
     fn drop(&mut self) {
         self.stop()
     }
@@ -142,14 +158,8 @@ mod tests {
     use super::*;
 
     #[tokio::test]
-    async fn connect_in_tokio_runtime() {
+    async fn plain_tokio_runtime() {
-        let srv = TestServer::start(|| fn_service(|_sock| async move { Ok::<_, ()>(()) }));
+        let srv = TestServer::with(|| 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/worker.rs

@@ -1,7 +1,6 @@
 use std::{
     future::Future,
     io, mem,
-    num::NonZeroUsize,
     pin::Pin,
     rc::Rc,
     sync::{
@@ -18,11 +17,11 @@ use actix_rt::{
     Arbiter, ArbiterHandle, System,
 };
 use futures_core::{future::LocalBoxFuture, ready};
+use log::{error, info, trace};
 use tokio::sync::{
     mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
     oneshot,
 };
-use tracing::{error, info, trace};
 
 use crate::{
     service::{BoxedServerService, InternalServiceFactory},
@@ -250,11 +249,8 @@ pub(crate) struct ServerWorkerConfig {
 
 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 tokio runtime.
-
+        let max_blocking_threads = std::cmp::max(512 / num_cpus::get(), 1);
-        // 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,
@@ -341,7 +337,7 @@ impl ServerWorker {
                                     Ok((token, svc)) => services.push((idx, token, svc)),
 
                                     Err(err) => {
-                                        error!("can not start worker: {:?}", err);
+                                        error!("Can not start worker: {:?}", err);
                                         return Err(io::Error::new(
                                             io::ErrorKind::Other,
                                             format!("can not start server service {}", idx),
@@ -440,7 +436,7 @@ impl ServerWorker {
                                 Ok((token, svc)) => services.push((idx, token, svc)),
 
                                 Err(err) => {
-                                    error!("can not start worker: {:?}", err);
+                                    error!("Can not start worker: {:?}", err);
                                     Arbiter::current().stop();
                                     factory_tx
                                         .send(Err(io::Error::new(
@@ -480,7 +476,7 @@ impl ServerWorker {
 
     fn restart_service(&mut self, idx: usize, factory_id: usize) {
         let factory = &self.factories[factory_id];
-        trace!("service {:?} failed, restarting", factory.name(idx));
+        trace!("Service {:?} failed, restarting", factory.name(idx));
         self.services[idx].status = WorkerServiceStatus::Restarting;
         self.state = WorkerState::Restarting(Restart {
             factory_id,
@@ -512,7 +508,7 @@ impl ServerWorker {
                     Poll::Ready(Ok(_)) => {
                         if srv.status == WorkerServiceStatus::Unavailable {
                             trace!(
-                                "service {:?} is available",
+                                "Service {:?} is available",
                                 self.factories[srv.factory_idx].name(idx)
                             );
                             srv.status = WorkerServiceStatus::Available;
@@ -523,7 +519,7 @@ impl ServerWorker {
 
                         if srv.status == WorkerServiceStatus::Available {
                             trace!(
-                                "service {:?} is unavailable",
+                                "Service {:?} is unavailable",
                                 self.factories[srv.factory_idx].name(idx)
                             );
                             srv.status = WorkerServiceStatus::Unavailable;
@@ -531,7 +527,7 @@ impl ServerWorker {
                     }
                     Poll::Ready(Err(_)) => {
                         error!(
-                            "service {:?} readiness check returned error, restarting",
+                            "Service {:?} readiness check returned error, restarting",
                             self.factories[srv.factory_idx].name(idx)
                         );
                         srv.status = WorkerServiceStatus::Failed;
@@ -589,14 +585,16 @@ impl Future for ServerWorker {
         let this = self.as_mut().get_mut();
 
         // `StopWorker` message handler
-        if let Poll::Ready(Some(Stop { graceful, tx })) = this.stop_rx.poll_recv(cx) {
+        if let Poll::Ready(Some(Stop { graceful, tx })) =
+            Pin::new(&mut this.stop_rx).poll_recv(cx)
+        {
             let num = this.counter.total();
             if num == 0 {
-                info!("shutting down idle worker");
+                info!("Shutting down idle worker");
                 let _ = tx.send(true);
                 return Poll::Ready(());
             } else if graceful {
-                info!("graceful worker shutdown; finishing {} connections", num);
+                info!("Graceful worker shutdown; finishing {} connections", num);
                 this.shutdown(false);
 
                 this.state = WorkerState::Shutdown(Shutdown {
@@ -605,7 +603,7 @@ impl Future for ServerWorker {
                     tx,
                 });
             } else {
-                info!("force shutdown worker, closing {} connections", num);
+                info!("Force shutdown worker, closing {} connections", num);
                 this.shutdown(true);
 
                 let _ = tx.send(false);
@@ -625,13 +623,12 @@ impl Future for ServerWorker {
                     self.poll(cx)
                 }
             },
-
             WorkerState::Restarting(ref mut restart) => {
                 let factory_id = restart.factory_id;
                 let token = restart.token;
 
-                let (token_new, service) =
+                let (token_new, service) = ready!(restart.fut.as_mut().poll(cx))
-                    ready!(restart.fut.as_mut().poll(cx)).unwrap_or_else(|_| {
+                    .unwrap_or_else(|_| {
                         panic!(
                             "Can not restart {:?} service",
                             this.factories[factory_id].name(token)
@@ -641,7 +638,7 @@ impl Future for ServerWorker {
                 assert_eq!(token, token_new);
 
                 trace!(
-                    "service {:?} has been restarted",
+                    "Service {:?} has been restarted",
                     this.factories[factory_id].name(token)
                 );
 
@@ -650,10 +647,9 @@ impl Future for ServerWorker {
 
                 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) {
+                while let Poll::Ready(Some(conn)) = Pin::new(&mut 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();
@@ -684,13 +680,12 @@ impl Future for ServerWorker {
                     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");
+                        trace!("Worker is unavailable");
                         this.state = WorkerState::Unavailable;
                         return self.poll(cx);
                     }
@@ -701,13 +696,10 @@ impl Future for ServerWorker {
                 }
 
                 // handle incoming io stream
-                match ready!(this.conn_rx.poll_recv(cx)) {
+                match ready!(Pin::new(&mut this.conn_rx).poll_recv(cx)) {
                     Some(msg) => {
                         let guard = this.counter.guard();
-                        let _ = this.services[msg.token]
+                        let _ = this.services[msg.token].service.call((guard, msg.io));
-                            .service
-                            .call((guard, msg.io))
-                            .into_inner();
                     }
                     None => return Poll::Ready(()),
                 };
@@ -716,7 +708,9 @@ impl Future for ServerWorker {
     }
 }
 
-fn wrap_worker_services(services: Vec<(usize, usize, BoxedServerService)>) -> Vec<WorkerService> {
+fn wrap_worker_services(
+    services: Vec<(usize, usize, BoxedServerService)>,
+) -> Vec<WorkerService> {
     services
         .into_iter()
         .fold(Vec::new(), |mut services, (idx, token, service)| {

actix-server/tests/test_server.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::let_underscore_future, missing_docs)]
-
 use std::{
     net,
     sync::{
@@ -28,54 +26,20 @@ fn test_bind() {
             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();
+            let _ = tx.send(srv.handle());
+
             srv.await
         })
     });
-
     let srv = rx.recv().unwrap();
 
     thread::sleep(Duration::from_millis(500));
-
+    assert!(net::TcpStream::connect(addr).is_ok());
-    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();
@@ -116,6 +80,38 @@ fn plain_tokio_runtime() {
     h.join().unwrap().unwrap();
 }
 
+#[test]
+fn test_listen() {
+    let addr = unused_addr();
+    let lst = net::TcpListener::bind(addr).unwrap();
+
+    let (tx, rx) = mpsc::channel();
+
+    let h = thread::spawn(move || {
+        actix_rt::System::new().block_on(async {
+            let srv = Server::build()
+                .disable_signals()
+                .workers(1)
+                .listen("test", lst, move || {
+                    fn_service(|_| async { Ok::<_, ()>(()) })
+                })?
+                .run();
+
+            let _ = tx.send(srv.handle());
+
+            srv.await
+        })
+    });
+
+    let srv = rx.recv().unwrap();
+
+    thread::sleep(Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+
+    let _ = srv.stop(true);
+    h.join().unwrap().unwrap();
+}
+
 #[test]
 #[cfg(unix)]
 fn test_start() {
@@ -188,9 +184,9 @@ fn test_start() {
 #[actix_rt::test]
 async fn test_max_concurrent_connections() {
     // Note:
-    // A TCP listener would accept connects based on it's backlog setting.
+    // 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
+    // The limit test on the other hand is only for concurrent tcp stream limiting a work
     // thread accept.
 
     use tokio::io::AsyncWriteExt;
@@ -256,7 +252,6 @@ async fn test_max_concurrent_connections() {
     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};
@@ -492,46 +487,27 @@ async fn worker_restart() {
 }
 
 #[test]
-fn no_runtime_on_init() {
+#[should_panic]
-    use std::{thread::sleep, time::Duration};
+fn no_runtime() {
+    // test set up in a way that would prevent time out if support for runtime-less init was added
 
     let addr = unused_addr();
-    let counter = Arc::new(AtomicUsize::new(0));
 
-    let mut srv = Server::build()
+    let srv = Server::build()
-        .workers(2)
+        .workers(1)
         .disable_signals()
-        .bind("test", addr, {
+        .bind("test", addr, move || {
-            let counter = counter.clone();
+            fn_service(|_| async { Ok::<_, ()>(()) })
-            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 _ = srv.handle().stop(true);
-        let _ = futures_util::poll!(&mut srv);
 
-        // available after the first poll
+    rt.block_on(async { srv.await }).unwrap();
-        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

@@ -1,77 +0,0 @@
-#![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,193 +1,186 @@
 # Changes
 
-## Unreleased
+## Unreleased - 2021-xx-xx
 
-## 2.0.3
 
-- Minimum supported Rust version (MSRV) is now 1.71.
+## 2.0.1 - 2021-10-11
+* Documentation fix.
 
-## 2.0.2
 
-- Service types can now be `Send` and `'static` regardless of request, response, and config types, etc. [#397]
+## 2.0.0 - 2021-04-16
-
+* Removed pipeline and related structs/functions. [#335]
-[#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]
+## 2.0.0-beta.5 - 2021-03-15
-- Add `boxed::rc_service` function for constructing `boxed::RcService` type [#290]
+* 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]
+## 2.0.0-beta.4 - 2021-02-04
-- `apply_fn` and `apply_fn_factory` now receive `Fn(Req, &Service)` function type. [#247]
+* `Service::poll_ready` and `Service::call` receive `&self`. [#247]
-- `apply_cfg` and `apply_cfg_factory` now receive `Fn(Req, &Service)` function type. [#247]
+* `apply_fn` and `apply_fn_factory` now receive `Fn(Req, &Service)` function type. [#247]
-- `fn_service` and friends now receive `Fn(Req)` 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]
+## 2.0.0-beta.3 - 2021-01-09
+* The `forward_ready!` macro converts errors. [#246]
 
 [#246]: https://github.com/actix/actix-net/pull/246
 
-## 2.0.0-beta.2
 
-- Remove redundant type parameter from `map_config`.
+## 2.0.0-beta.2 - 2021-01-03
+* 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]
+## 2.0.0-beta.1 - 2020-12-28
-- Add `always_ready!` and `forward_ready!` macros. [#233]
+* `Service`, other traits, and many type signatures now take the the request type as a type
-- Crate is now `no_std`. [#233]
+  parameter instead of an associated type. [#232]
-- Migrate pin projections to `pin-project-lite`. [#233]
+* Add `always_ready!` and `forward_ready!` macros. [#233]
-- Remove `AndThenApplyFn` and Pipeline `and_then_apply_fn`. Use the `.and_then(apply_fn(...))` construction. [#233]
+* Crate is now `no_std`. [#233]
-- Move non-vital methods to `ServiceExt` and `ServiceFactoryExt` extension traits. [#235]
+* 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.6 - 2020-08-09
+* 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.5 - 2020-01-16
+* Fixed unsoundness in .and_then()/.then() service combinators.
 
-## 1.0.4
 
-- Revert 1.0.3 change
+## 1.0.4 - 2020-01-15
+* Revert 1.0.3 change
 
-## 1.0.3
 
-- Fixed unsoundness in `AndThenService` impl.
+## 1.0.3 - 2020-01-15
+* Fixed unsoundness in `AndThenService` impl.
 
-## 1.0.2
 
-- Add `into_service` helper function.
+## 1.0.2 - 2020-01-08
+* Add `into_service` helper function.
 
-## 1.0.1
 
-- `map_config()` and `unit_config()` now accept `IntoServiceFactory` type.
+## 1.0.1 - 2019-12-22
+* `map_config()` and `unit_config()` now accept `IntoServiceFactory` type.
 
-## 1.0.0
 
-- Add Clone impl for Apply service
+## 1.0.0 - 2019-12-11
+* Add Clone impl for Apply service
 
-## 1.0.0-alpha.4
 
-- Renamed `service_fn` to `fn_service`
+## 1.0.0-alpha.4 - 2019-12-08
-- Renamed `factory_fn` to `fn_factory`
+* Renamed `service_fn` to `fn_service`
-- Renamed `factory_fn_cfg` to `fn_factory_with_config`
+* Renamed `factory_fn` to `fn_factory`
+* Renamed `factory_fn_cfg` to `fn_factory_with_config`
 
-## 1.0.0-alpha.3
 
-- Add missing Clone impls
+## 1.0.0-alpha.3 - 2019-12-06
-- Restore `Transform::map_init_err()` combinator
+* Add missing Clone impls
-- Restore `Service/Factory::apply_fn()` in form of `Pipeline/Factory::and_then_apply_fn()`
+* Restore `Transform::map_init_err()` combinator
-- Optimize service combinators and futures memory layout
+* 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
+## 1.0.0-alpha.2 - 2019-12-02
-- Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
+* Use owned config value for service factory
+* Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
 
-## 1.0.0-alpha.1
 
-- Migrated to `std::future`
+## 1.0.0-alpha.1 - 2019-11-25
-- `NewService` renamed to `ServiceFactory`
+* Migrated to `std::future`
-- Added `pipeline` and `pipeline_factory` function
+* `NewService` renamed to `ServiceFactory`
+* Added `pipeline` and `pipeline_factory` function
 
-## 0.4.2
 
-- Check service readiness for `new_apply_cfg` combinator
+## 0.4.2 - 2019-08-27
+* Check service readiness for `new_apply_cfg` combinator
 
-## 0.4.1
 
-- Add `new_apply_cfg` function
+## 0.4.1 - 2019-06-06
+* Add `new_apply_cfg` function
 
-## 0.4.0
 
-- Add `NewService::map_config` and `NewService::unit_config` combinators.
+## 0.4.0 - 2019-05-12
-- Use associated type for `NewService` config.
+* Add `NewService::map_config` and `NewService::unit_config` combinators.
-- Change `apply_cfg` function.
+* Use associated type for `NewService` config.
-- Renamed helper functions.
+* Change `apply_cfg` function.
+* Renamed helper functions.
 
-## 0.3.6
 
-- Poll boxed service call result immediately
+## 0.3.6 - 2019-04-07
+* Poll boxed service call result immediately
 
-## 0.3.5
 
-- Add `impl<S: Service> Service for Rc<RefCell<S>>`.
+## 0.3.5 - 2019-03-29
+* Add `impl<S: Service> Service for Rc<RefCell<S>>`.
 
-## 0.3.4
 
-- Add `Transform::from_err()` combinator
+## 0.3.4 - 2019-03-12
-- Add `apply_fn` helper
+* Add `Transform::from_err()` combinator
-- Add `apply_fn_factory` helper
+* Add `apply_fn` helper
-- Add `apply_transform` helper
+* Add `apply_fn_factory` helper
-- Add `apply_cfg` helper
+* Add `apply_transform` helper
+* Add `apply_cfg` helper
 
-## 0.3.3
 
-- Add `ApplyTransform` new service for transform and new service.
+## 0.3.3 - 2019-03-09
-- Add `NewService::apply_cfg()` combinator, allows to use nested `NewService` with different config parameter.
+* Add `ApplyTransform` new service for transform and new service.
-- Revert IntoFuture change
+* 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.
+## 0.3.2 - 2019-03-04
-- Export `AndThenTransform` type
+* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+* Export `AndThenTransform` type
 
-## 0.3.1
 
-- Simplify Transform trait
+## 0.3.1 - 2019-03-04
+* Simplify Transform trait
 
-## 0.3.0
 
-- Added boxed NewService and Service.
+## 0.3.0 - 2019-03-02
-- Added `Config` parameter to `NewService` trait.
+* Added boxed NewService and Service.
-- Added `Config` parameter to `NewTransform` trait.
+* Added `Config` parameter to `NewService` trait.
+* Added `Config` parameter to `NewTransform` trait.
 
-## 0.2.2
 
-- Added `NewService` impl for `Rc<S> where S: NewService`
+## 0.2.2 - 2019-02-19
-- Added `NewService` impl for `Arc<S> where S: NewService`
+* 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.1 - 2019-02-03
+* Generalize `.apply` combinator with Transform trait
 
-## 0.2.0
 
-- Use associated type instead of generic for Service definition.
+## 0.2.0 - 2019-02-01
-  - Before:
+* Use associated type instead of generic for Service definition.
+  * Before:
     ```rust
     impl Service<Request> for Client {
         type Response = Response;
         // ...
     }
     ```
-  - After:
+  * After:
     ```rust
     impl Service for Client {
         type Request = Request;
@@ -196,31 +189,31 @@
     }
     ```
 
-## 0.1.6
 
-- Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
+## 0.1.6 - 2019-01-24
-- Change `.apply()` error semantic, new service's error is `From<Self::Error>`
+* 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.5 - 2019-01-13
+* Make `Out::Error` convertible from `T::Error` for apply combinator
 
-## 0.1.4
 
-- Use `FnMut` instead of `Fn` for `FnService`
+## 0.1.4 - 2019-01-11
+* Use `FnMut` instead of `Fn` for `FnService`
 
-## 0.1.3
 
-- Split service combinators to separate trait
+## 0.1.3 - 2018-12-12
+* Split service combinators to separate trait
 
-## 0.1.2
 
-- Release future early for `.and_then()` and `.then()` combinators
+## 0.1.2 - 2018-12-12
+* Release future early for `.and_then()` and `.then()` combinators
 
-## 0.1.1
 
-- Added Service impl for `Box<S: Service>`
+## 0.1.1 - 2018-12-09
+* Added Service impl for `Box<S: Service>`
 
-## 0.1.0
 
-- Initial import
+## 0.1.0 - 2018-12-09
+* Initial import

actix-service/Cargo.toml

@@ -1,23 +1,28 @@
 [package]
 name = "actix-service"
-version = "2.0.3"
+version = "2.0.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+    "fakeshadow <24548779@qq.com>",
+]
 description = "Service trait and combinators for representing asynchronous request/response operations."
 keywords = ["network", "framework", "async", "futures", "service"]
 categories = ["network-programming", "asynchronous", "no-std"]
 repository = "https://github.com/actix/actix-net"
 license = "MIT OR Apache-2.0"
-edition.workspace = true
+edition = "2018"
-rust-version.workspace = true
+
+[lib]
+name = "actix_service"
+path = "src/lib.rs"
 
 [dependencies]
-futures-core = { version = "0.3.17", default-features = false }
+futures-core = { version = "0.3.7", default-features = false }
+paste = "1"
 pin-project-lite = "0.2"
 
 [dev-dependencies]
-actix-rt = "2"
+actix-rt = "2.0.0"
-actix-utils = "3"
+actix-utils = "3.0.0"
-futures-util = { version = "0.3.17", default-features = false }
+futures-util = { version = "0.3.7", default-features = false }
-
-[lints]
-workspace = true

actix-service/README.md

@@ -3,10 +3,10 @@
 > 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)
+[![Documentation](https://docs.rs/actix-service/badge.svg?version=2.0.1)](https://docs.rs/actix-service/2.0.1)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-service.svg)
+![License](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)
+[![Dependency Status](https://deps.rs/crate/actix-service/2.0.1/status.svg)](https://deps.rs/crate/actix-service/2.0.1)
 ![Download](https://img.shields.io/crates/d/actix-service.svg)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-service/examples/clone.rs

@@ -1,5 +1,3 @@
-#![allow(missing_docs)]
-
 use std::{future::Future, sync::mpsc, time::Duration};
 
 async fn oracle<F, Fut>(f: F) -> (u32, u32)

actix-service/src/and_then.rs

@@ -121,7 +121,12 @@ pub struct AndThenServiceFactory<A, B, Req>
 where
     A: ServiceFactory<Req>,
     A::Config: Clone,
-    B: ServiceFactory<A::Response, Config = A::Config, Error = A::Error, InitError = A::InitError>,
+    B: ServiceFactory<
+        A::Response,
+        Config = A::Config,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     inner: Rc<(A, B)>,
     _phantom: PhantomData<Req>,
@@ -131,7 +136,12 @@ 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>,
+    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 {
@@ -146,7 +156,12 @@ 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>,
+    B: ServiceFactory<
+        A::Response,
+        Config = A::Config,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     type Response = B::Response;
     type Error = A::Error;
@@ -169,7 +184,12 @@ impl<A, B, Req> Clone 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>,
+    B: ServiceFactory<
+        A::Response,
+        Config = A::Config,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fn clone(&self) -> Self {
         Self {
@@ -314,8 +334,9 @@ mod tests {
     async fn test_new_service() {
         let cnt = Rc::new(Cell::new(0));
         let cnt2 = cnt.clone();
-        let new_srv = pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
+        let new_srv =
-            .and_then(move || ready(Ok(Srv2(cnt.clone()))));
+            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;

actix-service/src/apply.rs

@@ -51,7 +51,7 @@ where
 {
     service: S,
     wrap_fn: F,
-    _phantom: PhantomData<fn(Req) -> (In, Res, Err)>,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
 }
 
 impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
@@ -106,7 +106,7 @@ where
 pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
     factory: SF,
     wrap_fn: F,
-    _phantom: PhantomData<fn(Req) -> (In, Res, Err)>,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
 }
 
 impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
@@ -140,7 +140,8 @@ where
     }
 }
 
-impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req> for ApplyFactory<SF, F, Req, In, Res, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req>
+    for ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
     F: Fn(Req, &SF::Service) -> Fut + Clone,
@@ -170,7 +171,7 @@ pin_project! {
         #[pin]
         fut: SF::Future,
         wrap_fn: Option<F>,
-        _phantom: PhantomData<fn(Req) -> Res>,
+        _phantom: PhantomData<(Req, Res)>,
     }
 }
 
@@ -208,13 +209,15 @@ where
 
 #[cfg(test)]
 mod tests {
+    use core::task::Poll;
+
     use futures_util::future::lazy;
 
     use super::*;
     use crate::{
         ok,
         pipeline::{pipeline, pipeline_factory},
-        Ready,
+        Ready, Service, ServiceFactory,
     };
 
     #[derive(Clone)]

actix-service/src/apply_cfg.rs

@@ -198,7 +198,8 @@ pin_project! {
     }
 }
 
-impl<SF, Req, F, Cfg, Fut, S> Future for ApplyConfigServiceFactoryResponse<SF, Req, F, Cfg, Fut, S>
+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>,

actix-service/src/boxed.rs

@@ -3,38 +3,36 @@
 use alloc::{boxed::Box, rc::Rc};
 use core::{future::Future, pin::Pin};
 
+use paste::paste;
+
 use crate::{Service, ServiceFactory};
 
 /// A boxed future with no send bound or lifetime parameters.
 pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
-/// Type alias for service trait object using [`Box`].
+macro_rules! service_object {
-pub type BoxService<Req, Res, Err> =
+    ($name: ident, $type: tt, $fn_name: ident) => {
-    Box<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>>;
+        paste! {
+            #[doc = "Type alias for service trait object using `" $type "`."]
+            pub type $name<Req, Res, Err> = $type<
+                dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>,
+            >;
 
-/// Wraps service as a trait object using [`BoxService`].
+            #[doc = "Wraps service as a trait object using [`" $name "`]."]
-pub fn service<S, Req>(service: S) -> BoxService<Req, S::Response, S::Error>
+            pub fn $fn_name<S, Req>(service: S) -> $name<Req, S::Response, S::Error>
-where
+            where
-    S: Service<Req> + 'static,
+                S: Service<Req> + 'static,
-    Req: 'static,
+                Req: 'static,
-    S::Future: 'static,
+                S::Future: 'static,
-{
+            {
-    Box::new(ServiceWrapper::new(service))
+                $type::new(ServiceWrapper::new(service))
+            }
+        }
+    };
 }
 
-/// Type alias for service trait object using [`Rc`].
+service_object!(BoxService, Box, service);
-pub type RcService<Req, Res, Err> =
+service_object!(RcService, Rc, rc_service);
-    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,
@@ -93,7 +91,8 @@ type Inner<C, Req, Res, Err, InitErr> = Box<
     >,
 >;
 
-impl<C, Req, Res, Err, InitErr> ServiceFactory<Req> for BoxServiceFactory<C, Req, Res, Err, InitErr>
+impl<C, Req, Res, Err, InitErr> ServiceFactory<Req>
+    for BoxServiceFactory<C, Req, Res, Err, InitErr>
 where
     Req: 'static,
     Res: 'static,

actix-service/src/ext.rs

@@ -44,7 +44,7 @@ pub trait ServiceExt<Req>: Service<Req> {
     /// Call another service after call to this one has resolved successfully.
     ///
     /// This function can be used to chain two services together and ensure that the second service
-    /// isn't called until call to the first service have finished. Result of the call to the first
+    /// isn't called until call to the fist service have finished. Result of the call to the first
     /// service is used as an input parameter for the second service's call.
     ///
     /// Note that this function consumes the receiving service and returns a wrapped version of it.

actix-service/src/fn_service.rs

@@ -3,7 +3,9 @@ use core::{future::Future, marker::PhantomData};
 use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory};
 
 /// Create `ServiceFactory` for function that can act as a `Service`
-pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(f: F) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
+    f: F,
+) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
     F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
@@ -46,7 +48,9 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
+pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(
+    f: F,
+) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
     F: Fn() -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
@@ -101,7 +105,7 @@ where
     Fut: Future<Output = Result<Res, Err>>,
 {
     f: F,
-    _t: PhantomData<fn(Req)>,
+    _t: PhantomData<Req>,
 }
 
 impl<F, Fut, Req, Res, Err> FnService<F, Fut, Req, Res, Err>
@@ -156,7 +160,7 @@ where
     Fut: Future<Output = Result<Res, Err>>,
 {
     f: F,
-    _t: PhantomData<fn(Req, Cfg)>,
+    _t: PhantomData<(Req, Cfg)>,
 }
 
 impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
@@ -233,7 +237,7 @@ where
     Srv: Service<Req>,
 {
     f: F,
-    _t: PhantomData<fn(Cfg, Req) -> (Fut, Srv, Err)>,
+    _t: PhantomData<(Fut, Cfg, Req, Srv, Err)>,
 }
 
 impl<F, Fut, Cfg, Srv, Req, Err> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
@@ -261,7 +265,8 @@ where
     }
 }
 
-impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req> for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req>
+    for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
@@ -288,7 +293,7 @@ where
     Fut: Future<Output = Result<Srv, Err>>,
 {
     f: F,
-    _t: PhantomData<fn(Cfg, Req)>,
+    _t: PhantomData<(Cfg, Req)>,
 }
 
 impl<F, Cfg, Srv, Req, Fut, Err> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
@@ -351,6 +356,7 @@ mod tests {
     use futures_util::future::lazy;
 
     use super::*;
+    use crate::{ok, Service, ServiceFactory};
 
     #[actix_rt::test]
     async fn test_fn_service() {
@@ -385,40 +391,4 @@ mod tests {
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", 1));
     }
-
-    #[actix_rt::test]
-    async fn test_auto_impl_send() {
-        use alloc::rc::Rc;
-
-        use crate::{map_config, ServiceExt, ServiceFactoryExt};
-
-        let srv_1 = fn_service(|_: Rc<u8>| ok::<_, Rc<u8>>(Rc::new(0u8)));
-
-        let fac_1 = fn_factory_with_config(|_: Rc<u8>| {
-            ok::<_, Rc<u8>>(fn_service(|_: Rc<u8>| ok::<_, Rc<u8>>(Rc::new(0u8))))
-        });
-
-        let fac_2 =
-            fn_factory(|| ok::<_, Rc<u8>>(fn_service(|_: Rc<u8>| ok::<_, Rc<u8>>(Rc::new(0u8)))));
-
-        fn is_send<T: Send + Sync + Clone>(_: &T) {}
-
-        is_send(&fac_1);
-        is_send(&map_config(fac_1.clone(), |_: Rc<u8>| Rc::new(0u8)));
-        is_send(&fac_1.clone().map_err(|_| Rc::new(0u8)));
-        is_send(&fac_1.clone().map(|_| Rc::new(0u8)));
-        is_send(&fac_1.clone().map_init_err(|_| Rc::new(0u8)));
-        // `and_then` is always !Send
-        // is_send(&fac_1.clone().and_then(fac_1.clone()));
-        is_send(&fac_1.new_service(Rc::new(0u8)).await.unwrap());
-
-        is_send(&fac_2);
-        is_send(&fac_2.new_service(Rc::new(0u8)).await.unwrap());
-
-        is_send(&srv_1);
-        is_send(&ServiceExt::map(srv_1.clone(), |_| Rc::new(0u8)));
-        is_send(&ServiceExt::map_err(srv_1.clone(), |_| Rc::new(0u8)));
-        // `and_then` is always !Send
-        // is_send(&ServiceExt::and_then(srv_1.clone(), srv_1.clone()));
-    }
 }

actix-service/src/lib.rs

@@ -1,6 +1,8 @@
 //! See [`Service`] docs for information on this crate's foundational trait.
 
 #![no_std]
+#![deny(rust_2018_idioms, nonstandard_style, future_incompatible)]
+#![warn(missing_docs)]
 #![allow(clippy::type_complexity)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
@@ -31,16 +33,15 @@ mod then;
 mod transform;
 mod transform_err;
 
+pub use self::apply::{apply_fn, apply_fn_factory};
+pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
+pub use self::ext::{ServiceExt, ServiceFactoryExt, TransformExt};
+pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
+pub use self::map_config::{map_config, unit_config};
+pub use self::transform::{apply, ApplyTransform, Transform};
+
 #[allow(unused_imports)]
 use self::ready::{err, ok, ready, Ready};
-pub use self::{
-    apply::{apply_fn, apply_fn_factory},
-    apply_cfg::{apply_cfg, apply_cfg_factory},
-    ext::{ServiceExt, ServiceFactoryExt, TransformExt},
-    fn_service::{fn_factory, fn_factory_with_config, fn_service},
-    map_config::{map_config, unit_config},
-    transform::{apply, ApplyTransform, Transform},
-};
 
 /// An asynchronous operation from `Request` to a `Response`.
 ///

actix-service/src/macros.rs

@@ -25,8 +25,6 @@
 ///     }
 /// }
 /// ```
-///
-/// [`forward_ready!`]: crate::forward_ready
 #[macro_export]
 macro_rules! always_ready {
     () => {

actix-service/src/map.rs

@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 pub struct Map<A, F, Req, Res> {
     service: A,
     f: F,
-    _t: PhantomData<fn(Req) -> Res>,
+    _t: PhantomData<(Req, Res)>,
 }
 
 impl<A, F, Req, Res> Map<A, F, Req, Res> {
@@ -97,7 +97,7 @@ where
 
         match this.fut.poll(cx) {
             Poll::Ready(Ok(resp)) => Poll::Ready(Ok((this.f)(resp))),
-            Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
             Poll::Pending => Poll::Pending,
         }
     }
@@ -107,7 +107,7 @@ where
 pub struct MapServiceFactory<A, F, Req, Res> {
     a: A,
     f: F,
-    r: PhantomData<fn(Req) -> Res>,
+    r: PhantomData<(Res, Req)>,
 }
 
 impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> {
@@ -202,7 +202,9 @@ mod tests {
     use futures_util::future::lazy;
 
     use super::*;
-    use crate::{ok, IntoServiceFactory, Ready, ServiceExt, ServiceFactoryExt};
+    use crate::{
+        ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt,
+    };
 
     struct Srv;
 

actix-service/src/map_config.rs

@@ -28,7 +28,7 @@ where
 pub struct MapConfig<SF, Req, F, Cfg> {
     factory: SF,
     cfg_mapper: F,
-    e: PhantomData<fn(Cfg, Req)>,
+    e: PhantomData<(Cfg, Req)>,
 }
 
 impl<SF, Req, F, Cfg> MapConfig<SF, Req, F, Cfg> {
@@ -82,7 +82,7 @@ where
 /// `unit_config()` config combinator
 pub struct UnitConfig<SF, Cfg, Req> {
     factory: SF,
-    _phantom: PhantomData<fn(Cfg, Req)>,
+    _phantom: PhantomData<(Cfg, Req)>,
 }
 
 impl<SF, Cfg, Req> UnitConfig<SF, Cfg, Req>

actix-service/src/map_err.rs

@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 pub struct MapErr<S, Req, F, E> {
     service: S,
     mapper: F,
-    _t: PhantomData<fn(Req) -> E>,
+    _t: PhantomData<(E, Req)>,
 }
 
 impl<S, Req, F, E> MapErr<S, Req, F, E> {
@@ -111,7 +111,7 @@ where
 {
     a: SF,
     f: F,
-    e: PhantomData<fn(Req) -> E>,
+    e: PhantomData<(E, Req)>,
 }
 
 impl<SF, Req, F, E> MapErrServiceFactory<SF, Req, F, E>
@@ -205,7 +205,10 @@ mod tests {
     use futures_util::future::lazy;
 
     use super::*;
-    use crate::{err, ok, IntoServiceFactory, Ready, ServiceExt, ServiceFactoryExt};
+    use crate::{
+        err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory,
+        ServiceFactoryExt,
+    };
 
     struct Srv;
 

actix-service/src/map_init_err.rs

@@ -13,7 +13,7 @@ use super::ServiceFactory;
 pub struct MapInitErr<A, F, Req, Err> {
     a: A,
     f: F,
-    e: PhantomData<fn(Req) -> Err>,
+    e: PhantomData<(Req, Err)>,
 }
 
 impl<A, F, Req, Err> MapInitErr<A, F, Req, Err>

actix-service/src/pipeline.rs

@@ -6,14 +6,12 @@ use core::{
     task::{Context, Poll},
 };
 
-use crate::{
+use crate::and_then::{AndThenService, AndThenServiceFactory};
-    and_then::{AndThenService, AndThenServiceFactory},
+use crate::map::{Map, MapServiceFactory};
-    map::{Map, MapServiceFactory},
+use crate::map_err::{MapErr, MapErrServiceFactory};
-    map_err::{MapErr, MapErrServiceFactory},
+use crate::map_init_err::MapInitErr;
-    map_init_err::MapInitErr,
+use crate::then::{ThenService, ThenServiceFactory};
-    then::{ThenService, ThenServiceFactory},
+use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
-    IntoService, IntoServiceFactory, Service, ServiceFactory,
-};
 
 /// Construct new pipeline with one service in pipeline chain.
 pub(crate) fn pipeline<I, S, Req>(service: I) -> Pipeline<S, Req>
@@ -42,7 +40,7 @@ where
 /// Pipeline service - pipeline allows to compose multiple service into one service.
 pub(crate) struct Pipeline<S, Req> {
     service: S,
-    _phantom: PhantomData<fn(Req)>,
+    _phantom: PhantomData<Req>,
 }
 
 impl<S, Req> Pipeline<S, Req>
@@ -52,7 +50,7 @@ where
     /// Call another service after call to this one has resolved successfully.
     ///
     /// This function can be used to chain two services together and ensure that
-    /// the second service isn't called until call to the first service have
+    /// the second service isn't called until call to the fist service have
     /// finished. Result of the call to the first service is used as an
     /// input parameter for the second service's call.
     ///
@@ -164,7 +162,7 @@ impl<S: Service<Req>, Req> Service<Req> for Pipeline<S, Req> {
 /// Pipeline factory
 pub(crate) struct PipelineFactory<SF, Req> {
     factory: SF,
-    _phantom: PhantomData<fn(Req)>,
+    _phantom: PhantomData<Req>,
 }
 
 impl<SF, Req> PipelineFactory<SF, Req>
@@ -254,7 +252,10 @@ where
     }
 
     /// Map this service's error to a different error, returning a new service.
-    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<SF, Req, F, E>, Req>
+    pub fn map_err<F, E>(
+        self,
+        f: F,
+    ) -> PipelineFactory<MapErrServiceFactory<SF, Req, F, E>, Req>
     where
         Self: Sized,
         F: Fn(SF::Error) -> E + Clone,

actix-service/src/transform.rs

@@ -226,9 +226,9 @@ mod tests {
     use actix_utils::future::{ready, Ready};
 
     use super::*;
+    use crate::Service;
 
     // pseudo-doctest for Transform trait
-    #[allow(unused)]
     pub struct TimeoutTransform {
         timeout: Duration,
     }
@@ -250,7 +250,6 @@ mod tests {
     }
 
     // pseudo-doctest for Transform trait
-    #[allow(unused)]
     pub struct Timeout<S> {
         service: S,
         _timeout: Duration,

actix-service/src/transform_err.rs

@@ -14,7 +14,7 @@ use super::Transform;
 pub struct TransformMapInitErr<T, S, Req, F, E> {
     transform: T,
     mapper: F,
-    _phantom: PhantomData<fn(Req) -> (S, E)>,
+    _phantom: PhantomData<(S, Req, E)>,
 }
 
 impl<T, S, F, E, Req> TransformMapInitErr<T, S, Req, F, E> {

actix-tls/CHANGES.md

@@ -1,215 +1,186 @@
 # Changes
 
-## Unreleased
+## Unreleased - 2021-xx-xx
 
-- Minimum supported Rust version (MSRV) is now 1.71.
-
-## 3.4.0
-
-- Add `rustls-0_23`, `rustls-0_23-webpki-roots`, and `rustls-0_23-native-roots` crate features.
-- Minimum supported Rust version (MSRV) is now 1.70.
-
-## 3.3.0
-
-- Add `rustls-0_22` crate feature which excludes any root certificate methods or re-exports.
-
-## 3.2.0
-
-- Support Rustls v0.22.
-- Add `{accept, connect}::rustls_0_22` modules.
-- Add `rustls-0_21-native-roots` and `rustls-0_20-native-roots` crate features which utilize the `rustls-native-certs` crate to enable a `native_roots_cert_store()` functions in each rustls-based `connect` module.
-- Implement `Host` for `http::Uri` (`http` crate version `1`).
-
-## 3.1.1
-
-- Fix `rustls` v0.21 version requirement.
-
-## 3.1.0
-
-- Support Rustls v0.21.
-- Add `{accept, connect}::rustls_0_21` modules.
-- Add `{accept, connect}::rustls_0_20` alias for `{accept, connect}::rustls` modules.
-- Minimum supported Rust version (MSRV) is now 1.65.
-
-## 3.0.4
-
-- Logs emitted now use the `tracing` crate with `log` compatibility. [#451]
-
-[#451]: https://github.com/actix/actix-net/pull/451
-
-## 3.0.3
-
-- No significant changes since `3.0.2`.
-
-## 3.0.2
-
-- Expose `connect::Connection::new`. [#439]
-
-[#439]: https://github.com/actix/actix-net/pull/439
-
-## 3.0.1
-
-- No significant changes since `3.0.0`.
-
-## 3.0.0
-
-- No significant changes since `3.0.0-rc.2`.
-
-## 3.0.0-rc.2
-
-- Re-export `openssl::SslConnectorBuilder` in `connect::openssl::reexports`. [#429]
-
-[#429]: https://github.com/actix/actix-net/pull/429
-
-## 3.0.0-rc.1
 
+## 3.0.0-rc.1 - 2021-11-29
 ### Added
-
+* Derive `Debug` for `connect::Connection`. [#422]
-- Derive `Debug` for `connect::Connection`. [#422]
+* Implement `Display` for `accept::TlsError`. [#422]
-- Implement `Display` for `accept::TlsError`. [#422]
+* Implement `Error` for `accept::TlsError` where both types also implement `Error`. [#422]
-- Implement `Error` for `accept::TlsError` where both types also implement `Error`. [#422]
+* Implement `Default` for `connect::Resolver`. [#422]
-- Implement `Default` for `connect::Resolver`. [#422]
+* Implement `Error` for `connect::ConnectError`. [#422]
-- Implement `Error` for `connect::ConnectError`. [#422]
+* Implement `Default` for `connect::tcp::{TcpConnector, TcpConnectorService}`. [#423]
-- Implement `Default` for `connect::tcp::{TcpConnector, TcpConnectorService}`. [#423]
+* Implement `Default` for `connect::ConnectorService`. [#423]
-- Implement `Default` for `connect::ConnectorService`. [#423]
 
 ### Changed
-
+* The crate's default features flags no longer include `uri`. [#422]
-- The crate's default features flags no longer include `uri`. [#422]
+* Useful re-exports from underlying TLS crates are exposed in a `reexports` modules in all acceptors and connectors.
-- Useful re-exports from underlying TLS crates are exposed in a `reexports` modules in all acceptors and connectors.
+* Convert `connect::ResolverService` from enum to struct. [#422]
-- Convert `connect::ResolverService` from enum to struct. [#422]
+* Make `ConnectAddrsIter` private. [#422]
-- Make `ConnectAddrsIter` private. [#422]
+* Mark `tcp::{TcpConnector, TcpConnectorService}` structs `#[non_exhaustive]`. [#423]
-- Mark `tcp::{TcpConnector, TcpConnectorService}` structs `#[non_exhaustive]`. [#423]
+* Rename `accept::native_tls::{NativeTlsAcceptorService => AcceptorService}`. [#422]
-- Rename `accept::native_tls::{NativeTlsAcceptorService => AcceptorService}`. [#422]
+* Rename `connect::{Address => Host}` trait. [#422]
-- Rename `connect::{Address => Host}` trait. [#422]
+* Rename method `connect::Connection::{host => hostname}`. [#422]
-- Rename method `connect::Connection::{host => hostname}`. [#422]
+* Rename struct `connect::{Connect => ConnectInfo}`. [#422]
-- Rename struct `connect::{Connect => ConnectInfo}`. [#422]
+* Rename struct `connect::{ConnectService => ConnectorService}`. [#422]
-- Rename struct `connect::{ConnectService => ConnectorService}`. [#422]
+* Rename struct `connect::{ConnectServiceFactory => Connector}`. [#422]
-- Rename struct `connect::{ConnectServiceFactory => Connector}`. [#422]
+* Rename TLS acceptor service future types and hide from docs. [#422]
-- Rename TLS acceptor service future types and hide from docs. [#422]
+* Unbox some service futures types. [#422]
-- Unbox some service futures types. [#422]
+* Inline modules in `connect::tls` to `connect` module. [#422]
-- Inline modules in `connect::tls` to `connect` module. [#422]
 
 ### Removed
-
+* Remove `connect::{new_connector, new_connector_factory, default_connector, default_connector_factory}` methods. [#422]
-- Remove `connect::{new_connector, new_connector_factory, default_connector, default_connector_factory}` methods. [#422]
+* Remove `connect::native_tls::Connector::service` method. [#422]
-- Remove `connect::native_tls::Connector::service` method. [#422]
+* Remove redundant `connect::Connection::from_parts` method. [#422]
-- Remove redundant `connect::Connection::from_parts` method. [#422]
 
 [#422]: https://github.com/actix/actix-net/pull/422
 [#423]: https://github.com/actix/actix-net/pull/423
 
-## 3.0.0-beta.9
 
-- Add configurable timeout for accepting TLS connection. [#393]
+### Added
-- Added `TlsError::Timeout` variant. [#393]
+* Derive `Debug` for `connect::Connection`. [#422]
-- All TLS acceptor services now use `TlsError` for their error types. [#393]
+* Implement `Display` for `accept::TlsError`. [#422]
-- Added `TlsError::into_service_error`. [#420]
+* Implement `Error` for `accept::TlsError` where both types also implement `Error`. [#422]
+* Implement `Default` for `connect::Resolver`. [#422]
+* Implement `Error` for `connect::ConnectError`. [#422]
+
+### Changed
+* The crate's default features flags no longer include `uri`. [#422]
+* Useful re-exports from underlying TLS crates are exposed in a `reexports` modules in all acceptors and connectors.
+* Convert `connect::ResolverService` from enum to struct. [#422]
+* Make `ConnectAddrsIter` private. [#422]
+* Rename `accept::native_tls::{NativeTlsAcceptorService => AcceptorService}`. [#422]
+* Rename `connect::{Address => Host}` trait. [#422]
+* Rename method `connect::Connection::{host => hostname}`. [#422]
+* Rename struct `connect::{Connect => ConnectInfo}`. [#422]
+* Rename struct `connect::{ConnectService => ConnectorService}`. [#422]
+* Rename struct `connect::{ConnectServiceFactory => Connector}`. [#422]
+* Rename TLS acceptor service future types and hide from docs. [#422]
+* Unbox some service futures types. [#422]
+* Inline modules in `connect::tls` to `connect` module. [#422]
+
+### Removed
+* Remove `connect::{new_connector, new_connector_factory, default_connector, default_connector_factory}` methods. [#422]
+* Remove `connect::native_tls::Connector::service` method. [#422]
+* Remove redundant `connect::Connection::from_parts` method. [#422]
+
+[#422]: https://github.com/actix/actix-net/pull/422
+
+
+## 3.0.0-beta.9 - 2021-11-22
+* Add configurable timeout for accepting TLS connection. [#393]
+* Added `TlsError::Timeout` variant. [#393]
+* All TLS acceptor services now use `TlsError` for their error types. [#393]
+* Added `TlsError::into_service_error`. [#420]
 
 [#393]: https://github.com/actix/actix-net/pull/393
 [#420]: https://github.com/actix/actix-net/pull/420
 
-## 3.0.0-beta.8
 
-- Add `Connect::request` for getting a reference to the connection request. [#415]
+## 3.0.0-beta.8 - 2021-11-15
+* Add `Connect::request` for getting a reference to the connection request. [#415]
 
 [#415]: https://github.com/actix/actix-net/pull/415
 
-## 3.0.0-beta.7
 
-- Add `webpki_roots_cert_store()` to get rustls compatible webpki roots cert store. [#401]
+## 3.0.0-beta.7 - 2021-10-20
-- Alias `connect::ssl` to `connect::tls`. [#401]
+* Add `webpki_roots_cert_store()` to get rustls compatible webpki roots cert store. [#401]
+* Alias `connect::ssl` to `connect::tls`. [#401]
 
 [#401]: https://github.com/actix/actix-net/pull/401
 
-## 3.0.0-beta.6
 
-- Update `tokio-rustls` to `0.23` which uses `rustls` `0.20`. [#396]
+## 3.0.0-beta.6 - 2021-10-19
-- Removed a re-export of `Session` from `rustls` as it no longer exist. [#396]
+* Update `tokio-rustls` to `0.23` which uses `rustls` `0.20`. [#396]
-- Minimum supported Rust version (MSRV) is now 1.52.
+* Removed a re-export of `Session` from `rustls` as it no longer exist. [#396]
+* Minimum supported Rust version (MSRV) is now 1.52.
 
 [#396]: https://github.com/actix/actix-net/pull/396
 
-## 3.0.0-beta.5
 
-- Changed `connect::ssl::rustls::RustlsConnectorService` to return error when `DNSNameRef` generation failed instead of panic. [#296]
+## 3.0.0-beta.5 - 2021-03-29
-- Remove `connect::ssl::openssl::OpensslConnectServiceFactory`. [#297]
+* Changed `connect::ssl::rustls::RustlsConnectorService` to return error when `DNSNameRef`
-- Remove `connect::ssl::openssl::OpensslConnectService`. [#297]
+  generation failed instead of panic. [#296]
-- Add `connect::ssl::native_tls` module for native tls support. [#295]
+* Remove `connect::ssl::openssl::OpensslConnectServiceFactory`. [#297]
-- Rename `accept::{nativetls => native_tls}`. [#295]
+* Remove `connect::ssl::openssl::OpensslConnectService`. [#297]
-- Remove `connect::TcpConnectService` type. Service caller expecting a `TcpStream` should use `connect::ConnectService` instead and call `Connection<T, TcpStream>::into_parts`. [#299]
+* Add `connect::ssl::native_tls` module for native tls support. [#295]
+* Rename `accept::{nativetls => native_tls}`. [#295]
+* Remove `connect::TcpConnectService` type. Service caller expecting a `TcpStream` should use `connect::ConnectService` instead and call `Connection<T, TcpStream>::into_parts`. [#299]
 
 [#295]: https://github.com/actix/actix-net/pull/295
 [#296]: https://github.com/actix/actix-net/pull/296
 [#297]: https://github.com/actix/actix-net/pull/297
 [#299]: https://github.com/actix/actix-net/pull/299
 
-## 3.0.0-beta.4
 
-- Rename `accept::openssl::{SslStream => TlsStream}`.
+## 3.0.0-beta.4 - 2021-02-24
-- Add `connect::Connect::set_local_addr` to attach local `IpAddr`. [#282]
+* Rename `accept::openssl::{SslStream => TlsStream}`.
-- `connector::TcpConnector` service will try to bind to local_addr of `IpAddr` when given. [#282]
+* Add `connect::Connect::set_local_addr` to attach local `IpAddr`. [#282]
+* `connector::TcpConnector` service will try to bind to local_addr of `IpAddr` when given. [#282]
 
 [#282]: https://github.com/actix/actix-net/pull/282
 
-## 3.0.0-beta.3
 
-- Remove `trust-dns-proto` and `trust-dns-resolver`. [#248]
+## 3.0.0-beta.3 - 2021-02-06
-- Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248]
+* Remove `trust-dns-proto` and `trust-dns-resolver`. [#248]
-- Add `Resolve` trait for custom DNS resolvers. [#248]
+* Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248]
-- Add `Resolver::new_custom` function to construct custom resolvers. [#248]
+* Add `Resolve` trait for custom DNS resolvers. [#248]
-- Export `webpki_roots::TLS_SERVER_ROOTS` in `actix_tls::connect` mod and remove the export from `actix_tls::accept` [#248]
+* Add `Resolver::new_custom` function to construct custom resolvers. [#248]
-- Remove `ConnectTakeAddrsIter`. `Connect::take_addrs` now returns `ConnectAddrsIter<'static>` as owned iterator. [#248]
+* Export `webpki_roots::TLS_SERVER_ROOTS` in `actix_tls::connect` mod and remove
-- Rename `Address::{host => hostname}` to more accurately describe which URL segment is returned.
+  the export from `actix_tls::accept` [#248]
-- Update `actix-rt` to `2.0.0`. [#273]
+* Remove `ConnectTakeAddrsIter`. `Connect::take_addrs` now returns `ConnectAddrsIter<'static>`
+  as owned iterator. [#248]
+* Rename `Address::{host => hostname}` to more accurately describe which URL segment is returned.
+* Update `actix-rt` to `2.0.0`. [#273]
 
 [#248]: https://github.com/actix/actix-net/pull/248
 [#273]: https://github.com/actix/actix-net/pull/273
 
-## 3.0.0-beta.2
 
-- Depend on stable trust-dns packages. [#204]
+## 3.0.0-beta.2 - 2021-xx-xx
+* Depend on stable trust-dns packages. [#204]
 
 [#204]: https://github.com/actix/actix-net/pull/204
 
-## 3.0.0-beta.1
 
-- Move acceptors under `accept` module. [#238]
+## 3.0.0-beta.1 - 2020-12-29
-- Merge `actix-connect` crate under `connect` module. [#238]
+* Move acceptors under `accept` module. [#238]
-- Add feature flags to enable acceptors and/or connectors individually. [#238]
+* Merge `actix-connect` crate under `connect` module. [#238]
+* Add feature flags to enable acceptors and/or connectors individually. [#238]
 
 [#238]: https://github.com/actix/actix-net/pull/238
 
-## 2.0.0
 
-- `nativetls::NativeTlsAcceptor` is renamed to `nativetls::Acceptor`.
+## 2.0.0 - 2020-09-03
-- Where possible, "SSL" terminology is replaced with "TLS".
+* `nativetls::NativeTlsAcceptor` is renamed to `nativetls::Acceptor`.
-  - `SslError` is renamed to `TlsError`.
+* Where possible, "SSL" terminology is replaced with "TLS".
-  - `TlsError::Ssl` enum variant is renamed to `TlsError::Tls`.
+    * `SslError` is renamed to `TlsError`.
-  - `max_concurrent_ssl_connect` is renamed to `max_concurrent_tls_connect`.
+    * `TlsError::Ssl` enum variant is renamed to `TlsError::Tls`.
+    * `max_concurrent_ssl_connect` is renamed to `max_concurrent_tls_connect`.
 
-## 2.0.0-alpha.2
 
-- Update `rustls` dependency to 0.18
+## 2.0.0-alpha.2 - 2020-08-17
-- Update `tokio-rustls` dependency to 0.14
+* Update `rustls` dependency to 0.18
-- Update `webpki-roots` dependency to 0.20
+* Update `tokio-rustls` dependency to 0.14
+* Update `webpki-roots` dependency to 0.20
 
-## [2.0.0-alpha.1]
 
-- Update `rustls` dependency to 0.17
+## [2.0.0-alpha.1] - 2020-03-03
-- Update `tokio-rustls` dependency to 0.13
+* Update `rustls` dependency to 0.17
-- Update `webpki-roots` dependency to 0.19
+* Update `tokio-rustls` dependency to 0.13
+* Update `webpki-roots` dependency to 0.19
 
-## [1.0.0]
 
-- 1.0.0 release
+## [1.0.0] - 2019-12-11
+* 1.0.0 release
 
-## [1.0.0-alpha.3]
 
-- Migrate to tokio 0.2
+## [1.0.0-alpha.3] - 2019-12-07
-- Enable rustls acceptor service
+* Migrate to tokio 0.2
-- Enable native-tls acceptor service
+* Enable rustls acceptor service
+* Enable native-tls acceptor service
 
-## [1.0.0-alpha.1]
 
-- Split openssl acceptor from actix-server package
+## [1.0.0-alpha.1] - 2019-12-02
+* Split openssl acceptor from actix-server package

actix-tls/Cargo.toml

@@ -1,27 +1,24 @@
 [package]
 name = "actix-tls"
-version = "3.4.0"
+version = "3.0.0-rc.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
 description = "TLS acceptor and connector services for Actix ecosystem"
 keywords = ["network", "tls", "ssl", "async", "transport"]
 repository = "https://github.com/actix/actix-net.git"
-categories = ["network-programming", "asynchronous", "cryptography"]
+categories = ["network-programming", "asynchronous"]
-license.workspace = true
+license = "MIT OR Apache-2.0"
-edition.workspace = true
+edition = "2018"
-rust-version.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[package.metadata.cargo_check_external_types]
+[lib]
-allowed_external_types = ["actix_service::*", "actix_utils::*", "futures_core::*", "tokio::*"]
+name = "actix_tls"
-
+path = "src/lib.rs"
-[package.metadata.cargo-machete]
-ignored = [
-  "rustls_021",         # specified to force version with add_trust_anchors method
-  "rustls_webpki_0101", # specified to force secure version
-]
 
 [features]
 default = ["accept", "connect"]
@@ -33,103 +30,55 @@ accept = []
 connect = []
 
 # use openssl impls
-openssl = ["dep:tls-openssl", "dep:tokio-openssl"]
+openssl = ["tls-openssl", "tokio-openssl"]
 
-# alias for backwards compat
+# use rustls impls
-rustls = ["rustls-0_20"]
+rustls = ["tokio-rustls", "webpki-roots"]
-
-# use rustls v0.20 impls
-rustls-0_20 = ["rustls-0_20-webpki-roots"]
-rustls-0_20-webpki-roots = ["tokio-rustls-023", "webpki-roots-022"]
-rustls-0_20-native-roots = ["tokio-rustls-023", "dep:rustls-native-certs-06"]
-
-# use rustls v0.21 impls
-rustls-0_21 = ["rustls-0_21-webpki-roots"]
-rustls-0_21-webpki-roots = ["tokio-rustls-024", "webpki-roots-025"]
-rustls-0_21-native-roots = ["tokio-rustls-024", "dep:rustls-native-certs-06"]
-
-# use rustls v0.22 impls
-rustls-0_22 = ["dep:tokio-rustls-025", "dep:rustls-pki-types-1"]
-rustls-0_22-webpki-roots = ["rustls-0_22", "dep:webpki-roots-026"]
-rustls-0_22-native-roots = ["rustls-0_22", "dep:rustls-native-certs-07"]
-
-# use rustls v0.23 impls
-rustls-0_23 = ["dep:tokio-rustls-026", "dep:rustls-pki-types-1"]
-rustls-0_23-webpki-roots = ["rustls-0_23", "dep:webpki-roots-026"]
-rustls-0_23-native-roots = ["rustls-0_23", "dep:rustls-native-certs-07"]
 
 # use native-tls impls
-native-tls = ["dep:tokio-native-tls"]
+native-tls = ["tokio-native-tls"]
 
 # support http::Uri as connect address
-uri = ["dep:http-0_2", "dep:http-1"]
+uri = ["http"]
 
 [dependencies]
-actix-rt = { version = "2.2", default-features = false }
+actix-codec = "0.4.0"
-actix-service = "2"
+actix-rt = { version = "2.2.0", default-features = false }
-actix-utils = "3"
+actix-service = "2.0.0"
+actix-utils = "3.0.0"
+
+derive_more = "0.99.5"
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-impl-more = "0.1"
+log = "0.4"
 pin-project-lite = "0.2.7"
-tokio = "1.23.1"
+tokio-util = { version = "0.6.3", default-features = false }
-tokio-util = "0.7"
-tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 
 # uri
-http-0_2 = { package = "http", version = "0.2.3", optional = true }
+http = { version = "0.2.3", optional = true }
-http-1 = { package = "http", version = "1", optional = true }
 
 # openssl
-tls-openssl = { package = "openssl", version = "0.10.55", optional = true }
+tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
 tokio-openssl = { version = "0.6", optional = true }
 
-# rustls PKI types
+# rustls
-rustls-pki-types-1 = { package = "rustls-pki-types", version = "1", optional = true }
+tokio-rustls = { version = "0.23", optional = true }
-
+webpki-roots = { version = "0.22", optional = true }
-# rustls v0.20
-tokio-rustls-023 = { package = "tokio-rustls", version = "0.23", optional = true }
-
-# rustls v0.21
-tokio-rustls-024 = { package = "tokio-rustls", version = "0.24", optional = true }
-
-# rustls v0.22
-tokio-rustls-025 = { package = "tokio-rustls", version = "0.25", optional = true }
-
-# rustls v0.23
-tokio-rustls-026 = { package = "tokio-rustls", version = "0.26", default-features = false, optional = true }
-
-# webpki-roots used with rustls features
-webpki-roots-022 = { package = "webpki-roots", version = "0.22", optional = true }
-webpki-roots-025 = { package = "webpki-roots", version = "0.25", optional = true }
-webpki-roots-026 = { package = "webpki-roots", version = "0.26", optional = true }
-
-# native root certificates for rustls impls
-rustls-native-certs-06 = { package = "rustls-native-certs", version = "0.6", optional = true }
-rustls-native-certs-07 = { package = "rustls-native-certs", version = "0.7", optional = true }
 
 # native-tls
 tokio-native-tls = { version = "0.3", optional = true }
 
-[target.'cfg(any())'.dependencies]
-rustls-021 = { package = "rustls", version = "0.21.6", optional = true }                 # force version with add_trust_anchors method
-rustls-webpki-0101 = { package = "rustls-webpki", version = "0.101.4", optional = true } # force secure version
-
 [dev-dependencies]
-actix-codec = "0.5"
+actix-rt = "2.2.0"
-actix-rt = "2.2"
+actix-server = "2.0.0-beta.9"
-actix-server = "2"
 bytes = "1"
-futures-util = { version = "0.3.17", default-features = false, features = ["sink"] }
+env_logger = "0.9"
-itertools = "0.14"
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
-pretty_env_logger = "0.5"
+log = "0.4"
-rcgen = "0.13"
+rcgen = "0.8"
-rustls-pemfile = "2"
+rustls-pemfile = "0.2.1"
-tokio-rustls-026 = { package = "tokio-rustls", version = "0.26" }
+tokio-rustls = { version = "0.23", features = ["dangerous_configuration"] }
-trust-dns-resolver = "0.23"
+trust-dns-resolver = "0.20.0"
 
 [[example]]
 name = "accept-rustls"
-required-features = ["accept", "rustls-0_23"]
+required-features = ["accept", "rustls"]
-
-[lints]
-workspace = true

actix-tls/README.md

@@ -1,21 +0,0 @@
-# `actix-tls`
-
-> TLS acceptor and connector services for the Actix ecosystem.
-
-<!-- prettier-ignore-start -->
-
-[![crates.io](https://img.shields.io/crates/v/actix-tls?label=latest)](https://crates.io/crates/actix-tls)
-[![Documentation](https://docs.rs/actix-tls/badge.svg?version=3.4.0)](https://docs.rs/actix-tls/3.4.0)
-[![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-tls.svg)
-<br />
-[![Dependency Status](https://deps.rs/crate/actix-tls/3.4.0/status.svg)](https://deps.rs/crate/actix-tls/3.4.0)
-![Download](https://img.shields.io/crates/d/actix-tls.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-tls)
-- [Examples](/actix-tls/examples)

actix-tls/examples/accept-rustls.rs

@@ -15,12 +15,14 @@
 //! http --verify=false https://127.0.0.1:8443
 //! ```
 
-// this `use` is only exists because of how we have organised the crate
+// this use only exists because of how we have organised the crate
-// it is not necessary for your actual code; you should import from `rustls` normally
+// it is not necessary for your actual code
+use tokio_rustls::rustls;
+
 use std::{
+    env,
     fs::File,
     io::{self, BufReader},
-    path::PathBuf,
     sync::{
         atomic::{AtomicUsize, Ordering},
         Arc,
@@ -30,40 +32,32 @@ use std::{
 use actix_rt::net::TcpStream;
 use actix_server::Server;
 use actix_service::ServiceFactoryExt as _;
-use actix_tls::accept::rustls_0_23::{Acceptor as RustlsAcceptor, TlsStream};
+use actix_tls::accept::rustls::{Acceptor as RustlsAcceptor, TlsStream};
 use futures_util::future::ok;
-use itertools::Itertools as _;
+use log::info;
-use rustls::server::ServerConfig;
+use rustls::{server::ServerConfig, Certificate, PrivateKey};
 use rustls_pemfile::{certs, rsa_private_keys};
-use rustls_pki_types_1::PrivateKeyDer;
-use tokio_rustls_026::rustls;
-use tracing::info;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    pretty_env_logger::formatted_timed_builder()
+    env::set_var("RUST_LOG", "info");
-        .parse_env(pretty_env_logger::env_logger::Env::default().default_filter_or("info"));
+    env_logger::init();
-
-    let root_path = env!("CARGO_MANIFEST_DIR")
-        .parse::<PathBuf>()
-        .unwrap()
-        .join("examples");
-    let cert_path = root_path.clone().join("cert.pem");
-    let key_path = root_path.clone().join("key.pem");
 
     // Load TLS key and cert files
-    let cert_file = &mut BufReader::new(File::open(cert_path).unwrap());
+    let cert_file = &mut BufReader::new(File::open("./examples/cert.pem").unwrap());
-    let key_file = &mut BufReader::new(File::open(key_path).unwrap());
+    let key_file = &mut BufReader::new(File::open("./examples/key.pem").unwrap());
 
-    let cert_chain = certs(cert_file);
+    let cert_chain = certs(cert_file)
-    let mut keys = rsa_private_keys(key_file);
+        .unwrap()
+        .into_iter()
+        .map(Certificate)
+        .collect();
+    let mut keys = rsa_private_keys(key_file).unwrap();
 
     let tls_config = ServerConfig::builder()
+        .with_safe_defaults()
         .with_no_client_auth()
-        .with_single_cert(
+        .with_single_cert(cert_chain, PrivateKey(keys.remove(0)))
-            cert_chain.try_collect::<_, Vec<_>, _>()?,
-            PrivateKeyDer::Pkcs1(keys.next().unwrap()?),
-        )
         .unwrap();
 
     let tls_acceptor = RustlsAcceptor::new(tls_config);
@@ -71,7 +65,7 @@ async fn main() -> io::Result<()> {
     let count = Arc::new(AtomicUsize::new(0));
 
     let addr = ("127.0.0.1", 8443);
-    info!("starting server at: {addr:?}");
+    info!("starting server on port: {}", &addr.0);
 
     Server::build()
         .bind("tls-example", addr, move || {

actix-tls/src/accept/mod.rs

@@ -2,45 +2,27 @@
 
 use std::{
     convert::Infallible,
-    error::Error,
-    fmt,
     sync::atomic::{AtomicUsize, Ordering},
 };
 
 use actix_utils::counter::Counter;
+use derive_more::{Display, Error};
 
 #[cfg(feature = "openssl")]
+#[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
 pub mod openssl;
 
-#[cfg(feature = "rustls-0_20")]
+#[cfg(feature = "rustls")]
-pub mod rustls_0_20;
+#[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
-
+pub mod rustls;
-#[doc(hidden)]
-#[cfg(feature = "rustls-0_20")]
-pub use rustls_0_20 as rustls;
-
-#[cfg(feature = "rustls-0_21")]
-pub mod rustls_0_21;
-
-#[cfg(feature = "rustls-0_22")]
-pub mod rustls_0_22;
-
-#[cfg(feature = "rustls-0_23")]
-pub mod rustls_0_23;
 
 #[cfg(feature = "native-tls")]
+#[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
 pub mod native_tls;
 
 pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256);
 
-#[cfg(any(
+#[cfg(any(feature = "openssl", feature = "rustls", feature = "native-tls"))]
-    feature = "openssl",
-    feature = "rustls-0_20",
-    feature = "rustls-0_21",
-    feature = "rustls-0_22",
-    feature = "rustls-0_23",
-    feature = "native-tls",
-))]
 pub(crate) const DEFAULT_TLS_HANDSHAKE_TIMEOUT: std::time::Duration =
     std::time::Duration::from_secs(3);
 
@@ -61,18 +43,20 @@ pub fn max_concurrent_tls_connect(num: usize) {
 /// TLS handshake error, TLS timeout, or inner service error.
 ///
 /// All TLS acceptors from this crate will return the `SvcErr` type parameter as [`Infallible`],
-/// which can be cast to your own service type, inferred or otherwise, using [`into_service_error`].
+/// which can be cast to your own service type, inferred or otherwise,
-///
+/// using [`into_service_error`](Self::into_service_error).
-/// [`into_service_error`]: Self::into_service_error
+#[derive(Debug, Display, Error)]
-#[derive(Debug)]
 pub enum TlsError<TlsErr, SvcErr> {
     /// TLS handshake has timed-out.
+    #[display(fmt = "TLS handshake has timed-out")]
     Timeout,
 
     /// Wraps TLS service errors.
+    #[display(fmt = "TLS handshake error")]
     Tls(TlsErr),
 
     /// Wraps service errors.
+    #[display(fmt = "Service error")]
     Service(SvcErr),
 }
 
@@ -95,30 +79,6 @@ impl<TlsErr> TlsError<TlsErr, Infallible> {
     }
 }
 
-impl<TlsErr, SvcErr> fmt::Display for TlsError<TlsErr, SvcErr> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Timeout => f.write_str("TLS handshake has timed-out"),
-            Self::Tls(_) => f.write_str("TLS handshake error"),
-            Self::Service(_) => f.write_str("Service error"),
-        }
-    }
-}
-
-impl<TlsErr, SvcErr> Error for TlsError<TlsErr, SvcErr>
-where
-    TlsErr: Error + 'static,
-    SvcErr: Error + 'static,
-{
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            TlsError::Tls(err) => Some(err),
-            TlsError::Service(err) => Some(err),
-            TlsError::Timeout => None,
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

actix-tls/src/accept/native_tls.rs

@@ -10,6 +10,7 @@ use std::{
     time::Duration,
 };
 
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use actix_rt::{
     net::{ActixStream, Ready},
     time::timeout,
@@ -19,8 +20,8 @@ use actix_utils::{
     counter::Counter,
     future::{ready, Ready as FutReady},
 };
+use derive_more::{Deref, DerefMut, From};
 use futures_core::future::LocalBoxFuture;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 use tokio_native_tls::{native_tls::Error, TlsAcceptor};
 
 use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
@@ -32,11 +33,9 @@ pub mod reexports {
 }
 
 /// Wraps a `native-tls` based async TLS stream in order to implement [`ActixStream`].
+#[derive(Deref, DerefMut, From)]
 pub struct TlsStream<IO>(tokio_native_tls::TlsStream<IO>);
 
-impl_more::impl_from!(<IO> in tokio_native_tls::TlsStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_native_tls::TlsStream<IO>);
-
 impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
     fn poll_read(
         self: Pin<&mut Self>,
@@ -73,17 +72,17 @@ impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
     }
 
     fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
+        (&**self).is_write_vectored()
     }
 }
 
 impl<IO: ActixStream> ActixStream for TlsStream<IO> {
     fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref().get_ref().get_ref(), cx)
+        IO::poll_read_ready((&**self).get_ref().get_ref().get_ref(), cx)
     }
 
     fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref().get_ref().get_ref(), cx)
+        IO::poll_write_ready((&**self).get_ref().get_ref().get_ref(), cx)
     }
 }
 

actix-tls/src/accept/openssl.rs

@@ -11,6 +11,7 @@ use std::{
     time::Duration,
 };
 
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use actix_rt::{
     net::{ActixStream, Ready},
     time::{sleep, Sleep},
@@ -20,9 +21,9 @@ use actix_utils::{
     counter::{Counter, CounterGuard},
     future::{ready, Ready as FutReady},
 };
+use derive_more::{Deref, DerefMut, From};
 use openssl::ssl::{Error, Ssl, SslAcceptor};
 use pin_project_lite::pin_project;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
 
@@ -35,11 +36,9 @@ pub mod reexports {
 }
 
 /// Wraps an `openssl` based async TLS stream in order to implement [`ActixStream`].
+#[derive(Deref, DerefMut, From)]
 pub struct TlsStream<IO>(tokio_openssl::SslStream<IO>);
 
-impl_more::impl_from!(<IO> in tokio_openssl::SslStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_openssl::SslStream<IO>);
-
 impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
     fn poll_read(
         self: Pin<&mut Self>,
@@ -76,17 +75,17 @@ impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
     }
 
     fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
+        (&**self).is_write_vectored()
     }
 }
 
 impl<IO: ActixStream> ActixStream for TlsStream<IO> {
     fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref(), cx)
+        IO::poll_read_ready((&**self).get_ref(), cx)
     }
 
     fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref(), cx)
+        IO::poll_write_ready((&**self).get_ref(), cx)
     }
 }
 

actix-tls/src/accept/rustls.rs

@@ -1,4 +1,4 @@
-//! `rustls` v0.23 based TLS connection acceptor service.
+//! `rustls` based TLS connection acceptor service.
 //!
 //! See [`Acceptor`] for main service factory docs.
 
@@ -12,6 +12,7 @@ use std::{
     time::Duration,
 };
 
+use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use actix_rt::{
     net::{ActixStream, Ready},
     time::{sleep, Sleep},
@@ -21,25 +22,23 @@ use actix_utils::{
     counter::{Counter, CounterGuard},
     future::{ready, Ready as FutReady},
 };
+use derive_more::{Deref, DerefMut, From};
 use pin_project_lite::pin_project;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_rustls::rustls::ServerConfig;
 use tokio_rustls::{Accept, TlsAcceptor};
-use tokio_rustls_026 as tokio_rustls;
 
 use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
 
 pub mod reexports {
     //! Re-exports from `rustls` that are useful for acceptors.
 
-    pub use tokio_rustls_026::rustls::ServerConfig;
+    pub use tokio_rustls::rustls::ServerConfig;
 }
 
 /// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`].
+#[derive(Deref, DerefMut, From)]
 pub struct TlsStream<IO>(tokio_rustls::server::TlsStream<IO>);
 
-impl_more::impl_from!(<IO> in tokio_rustls::server::TlsStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_rustls::server::TlsStream<IO>);
-
 impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
     fn poll_read(
         self: Pin<&mut Self>,
@@ -76,29 +75,29 @@ impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
     }
 
     fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
+        (&**self).is_write_vectored()
     }
 }
 
 impl<IO: ActixStream> ActixStream for TlsStream<IO> {
     fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref().0, cx)
+        IO::poll_read_ready((&**self).get_ref().0, cx)
     }
 
     fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref().0, cx)
+        IO::poll_write_ready((&**self).get_ref().0, cx)
     }
 }
 
 /// Accept TLS connections via the `rustls` crate.
 pub struct Acceptor {
-    config: Arc<reexports::ServerConfig>,
+    config: Arc<ServerConfig>,
     handshake_timeout: Duration,
 }
 
 impl Acceptor {
     /// Constructs `rustls` based acceptor service factory.
-    pub fn new(config: reexports::ServerConfig) -> Self {
+    pub fn new(config: ServerConfig) -> Self {
         Acceptor {
             config: Arc::new(config),
             handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,

actix-tls/src/accept/rustls_0_20.rs

@@ -1,198 +0,0 @@
-//! `rustls` v0.20 based TLS connection acceptor service.
-//!
-//! See [`Acceptor`] for main service factory docs.
-
-use std::{
-    convert::Infallible,
-    future::Future,
-    io::{self, IoSlice},
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use actix_rt::{
-    net::{ActixStream, Ready},
-    time::{sleep, Sleep},
-};
-use actix_service::{Service, ServiceFactory};
-use actix_utils::{
-    counter::{Counter, CounterGuard},
-    future::{ready, Ready as FutReady},
-};
-use pin_project_lite::pin_project;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tokio_rustls::{Accept, TlsAcceptor};
-use tokio_rustls_023 as tokio_rustls;
-
-use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
-
-pub mod reexports {
-    //! Re-exports from `rustls` that are useful for acceptors.
-
-    pub use tokio_rustls_023::rustls::ServerConfig;
-}
-
-/// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`].
-pub struct TlsStream<IO>(tokio_rustls::server::TlsStream<IO>);
-
-impl_more::impl_from!(<IO> in tokio_rustls::server::TlsStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_rustls::server::TlsStream<IO>);
-
-impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
-    }
-}
-
-impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_flush(cx)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-}
-
-impl<IO: ActixStream> ActixStream for TlsStream<IO> {
-    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref().0, cx)
-    }
-
-    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref().0, cx)
-    }
-}
-
-/// Accept TLS connections via the `rustls` crate.
-pub struct Acceptor {
-    config: Arc<reexports::ServerConfig>,
-    handshake_timeout: Duration,
-}
-
-impl Acceptor {
-    /// Constructs `rustls` based acceptor service factory.
-    pub fn new(config: reexports::ServerConfig) -> Self {
-        Acceptor {
-            config: Arc::new(config),
-            handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,
-        }
-    }
-
-    /// Limit the amount of time that the acceptor will wait for a TLS handshake to complete.
-    ///
-    /// Default timeout is 3 seconds.
-    pub fn set_handshake_timeout(&mut self, handshake_timeout: Duration) -> &mut Self {
-        self.handshake_timeout = handshake_timeout;
-        self
-    }
-}
-
-impl Clone for Acceptor {
-    fn clone(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            handshake_timeout: self.handshake_timeout,
-        }
-    }
-}
-
-impl<IO: ActixStream> ServiceFactory<IO> for Acceptor {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Config = ();
-    type Service = AcceptorService;
-    type InitError = ();
-    type Future = FutReady<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let res = MAX_CONN_COUNTER.with(|conns| {
-            Ok(AcceptorService {
-                acceptor: self.config.clone().into(),
-                conns: conns.clone(),
-                handshake_timeout: self.handshake_timeout,
-            })
-        });
-
-        ready(res)
-    }
-}
-
-/// Rustls based acceptor service.
-pub struct AcceptorService {
-    acceptor: TlsAcceptor,
-    conns: Counter,
-    handshake_timeout: Duration,
-}
-
-impl<IO: ActixStream> Service<IO> for AcceptorService {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Future = AcceptFut<IO>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.conns.available(cx) {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&self, req: IO) -> Self::Future {
-        AcceptFut {
-            fut: self.acceptor.accept(req),
-            timeout: sleep(self.handshake_timeout),
-            _guard: self.conns.get(),
-        }
-    }
-}
-
-pin_project! {
-    /// Accept future for Rustls service.
-    #[doc(hidden)]
-    pub struct AcceptFut<IO: ActixStream> {
-        fut: Accept<IO>,
-        #[pin]
-        timeout: Sleep,
-        _guard: CounterGuard,
-    }
-}
-
-impl<IO: ActixStream> Future for AcceptFut<IO> {
-    type Output = Result<TlsStream<IO>, TlsError<io::Error, Infallible>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
-        match Pin::new(&mut this.fut).poll(cx) {
-            Poll::Ready(Ok(stream)) => Poll::Ready(Ok(TlsStream(stream))),
-            Poll::Ready(Err(err)) => Poll::Ready(Err(TlsError::Tls(err))),
-            Poll::Pending => this.timeout.poll(cx).map(|_| Err(TlsError::Timeout)),
-        }
-    }
-}

actix-tls/src/accept/rustls_0_21.rs

@@ -1,198 +0,0 @@
-//! `rustls` v0.21 based TLS connection acceptor service.
-//!
-//! See [`Acceptor`] for main service factory docs.
-
-use std::{
-    convert::Infallible,
-    future::Future,
-    io::{self, IoSlice},
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use actix_rt::{
-    net::{ActixStream, Ready},
-    time::{sleep, Sleep},
-};
-use actix_service::{Service, ServiceFactory};
-use actix_utils::{
-    counter::{Counter, CounterGuard},
-    future::{ready, Ready as FutReady},
-};
-use pin_project_lite::pin_project;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tokio_rustls::{Accept, TlsAcceptor};
-use tokio_rustls_024 as tokio_rustls;
-
-use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
-
-pub mod reexports {
-    //! Re-exports from `rustls` that are useful for acceptors.
-
-    pub use tokio_rustls_024::rustls::ServerConfig;
-}
-
-/// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`].
-pub struct TlsStream<IO>(tokio_rustls::server::TlsStream<IO>);
-
-impl_more::impl_from!(<IO> in tokio_rustls::server::TlsStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_rustls::server::TlsStream<IO>);
-
-impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
-    }
-}
-
-impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_flush(cx)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-}
-
-impl<IO: ActixStream> ActixStream for TlsStream<IO> {
-    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref().0, cx)
-    }
-
-    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref().0, cx)
-    }
-}
-
-/// Accept TLS connections via the `rustls` crate.
-pub struct Acceptor {
-    config: Arc<reexports::ServerConfig>,
-    handshake_timeout: Duration,
-}
-
-impl Acceptor {
-    /// Constructs `rustls` based acceptor service factory.
-    pub fn new(config: reexports::ServerConfig) -> Self {
-        Acceptor {
-            config: Arc::new(config),
-            handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,
-        }
-    }
-
-    /// Limit the amount of time that the acceptor will wait for a TLS handshake to complete.
-    ///
-    /// Default timeout is 3 seconds.
-    pub fn set_handshake_timeout(&mut self, handshake_timeout: Duration) -> &mut Self {
-        self.handshake_timeout = handshake_timeout;
-        self
-    }
-}
-
-impl Clone for Acceptor {
-    fn clone(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            handshake_timeout: self.handshake_timeout,
-        }
-    }
-}
-
-impl<IO: ActixStream> ServiceFactory<IO> for Acceptor {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Config = ();
-    type Service = AcceptorService;
-    type InitError = ();
-    type Future = FutReady<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let res = MAX_CONN_COUNTER.with(|conns| {
-            Ok(AcceptorService {
-                acceptor: self.config.clone().into(),
-                conns: conns.clone(),
-                handshake_timeout: self.handshake_timeout,
-            })
-        });
-
-        ready(res)
-    }
-}
-
-/// Rustls based acceptor service.
-pub struct AcceptorService {
-    acceptor: TlsAcceptor,
-    conns: Counter,
-    handshake_timeout: Duration,
-}
-
-impl<IO: ActixStream> Service<IO> for AcceptorService {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Future = AcceptFut<IO>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.conns.available(cx) {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&self, req: IO) -> Self::Future {
-        AcceptFut {
-            fut: self.acceptor.accept(req),
-            timeout: sleep(self.handshake_timeout),
-            _guard: self.conns.get(),
-        }
-    }
-}
-
-pin_project! {
-    /// Accept future for Rustls service.
-    #[doc(hidden)]
-    pub struct AcceptFut<IO: ActixStream> {
-        fut: Accept<IO>,
-        #[pin]
-        timeout: Sleep,
-        _guard: CounterGuard,
-    }
-}
-
-impl<IO: ActixStream> Future for AcceptFut<IO> {
-    type Output = Result<TlsStream<IO>, TlsError<io::Error, Infallible>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
-        match Pin::new(&mut this.fut).poll(cx) {
-            Poll::Ready(Ok(stream)) => Poll::Ready(Ok(TlsStream(stream))),
-            Poll::Ready(Err(err)) => Poll::Ready(Err(TlsError::Tls(err))),
-            Poll::Pending => this.timeout.poll(cx).map(|_| Err(TlsError::Timeout)),
-        }
-    }
-}

actix-tls/src/accept/rustls_0_22.rs

@@ -1,198 +0,0 @@
-//! `rustls` v0.22 based TLS connection acceptor service.
-//!
-//! See [`Acceptor`] for main service factory docs.
-
-use std::{
-    convert::Infallible,
-    future::Future,
-    io::{self, IoSlice},
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use actix_rt::{
-    net::{ActixStream, Ready},
-    time::{sleep, Sleep},
-};
-use actix_service::{Service, ServiceFactory};
-use actix_utils::{
-    counter::{Counter, CounterGuard},
-    future::{ready, Ready as FutReady},
-};
-use pin_project_lite::pin_project;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tokio_rustls::{Accept, TlsAcceptor};
-use tokio_rustls_025 as tokio_rustls;
-
-use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER};
-
-pub mod reexports {
-    //! Re-exports from `rustls` that are useful for acceptors.
-
-    pub use tokio_rustls_025::rustls::ServerConfig;
-}
-
-/// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`].
-pub struct TlsStream<IO>(tokio_rustls::server::TlsStream<IO>);
-
-impl_more::impl_from!(<IO> in tokio_rustls::server::TlsStream<IO> => TlsStream<IO>);
-impl_more::impl_deref_and_mut!(<IO> in TlsStream<IO> => tokio_rustls::server::TlsStream<IO>);
-
-impl<IO: ActixStream> AsyncRead for TlsStream<IO> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_read(cx, buf)
-    }
-}
-
-impl<IO: ActixStream> AsyncWrite for TlsStream<IO> {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write(cx, buf)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_flush(cx)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut **self.get_mut()).poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-}
-
-impl<IO: ActixStream> ActixStream for TlsStream<IO> {
-    fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_read_ready((**self).get_ref().0, cx)
-    }
-
-    fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Ready>> {
-        IO::poll_write_ready((**self).get_ref().0, cx)
-    }
-}
-
-/// Accept TLS connections via the `rustls` crate.
-pub struct Acceptor {
-    config: Arc<reexports::ServerConfig>,
-    handshake_timeout: Duration,
-}
-
-impl Acceptor {
-    /// Constructs `rustls` based acceptor service factory.
-    pub fn new(config: reexports::ServerConfig) -> Self {
-        Acceptor {
-            config: Arc::new(config),
-            handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,
-        }
-    }
-
-    /// Limit the amount of time that the acceptor will wait for a TLS handshake to complete.
-    ///
-    /// Default timeout is 3 seconds.
-    pub fn set_handshake_timeout(&mut self, handshake_timeout: Duration) -> &mut Self {
-        self.handshake_timeout = handshake_timeout;
-        self
-    }
-}
-
-impl Clone for Acceptor {
-    fn clone(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            handshake_timeout: self.handshake_timeout,
-        }
-    }
-}
-
-impl<IO: ActixStream> ServiceFactory<IO> for Acceptor {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Config = ();
-    type Service = AcceptorService;
-    type InitError = ();
-    type Future = FutReady<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let res = MAX_CONN_COUNTER.with(|conns| {
-            Ok(AcceptorService {
-                acceptor: self.config.clone().into(),
-                conns: conns.clone(),
-                handshake_timeout: self.handshake_timeout,
-            })
-        });
-
-        ready(res)
-    }
-}
-
-/// Rustls based acceptor service.
-pub struct AcceptorService {
-    acceptor: TlsAcceptor,
-    conns: Counter,
-    handshake_timeout: Duration,
-}
-
-impl<IO: ActixStream> Service<IO> for AcceptorService {
-    type Response = TlsStream<IO>;
-    type Error = TlsError<io::Error, Infallible>;
-    type Future = AcceptFut<IO>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.conns.available(cx) {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&self, req: IO) -> Self::Future {
-        AcceptFut {
-            fut: self.acceptor.accept(req),
-            timeout: sleep(self.handshake_timeout),
-            _guard: self.conns.get(),
-        }
-    }
-}
-
-pin_project! {
-    /// Accept future for Rustls service.
-    #[doc(hidden)]
-    pub struct AcceptFut<IO: ActixStream> {
-        fut: Accept<IO>,
-        #[pin]
-        timeout: Sleep,
-        _guard: CounterGuard,
-    }
-}
-
-impl<IO: ActixStream> Future for AcceptFut<IO> {
-    type Output = Result<TlsStream<IO>, TlsError<io::Error, Infallible>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
-        match Pin::new(&mut this.fut).poll(cx) {
-            Poll::Ready(Ok(stream)) => Poll::Ready(Ok(TlsStream(stream))),
-            Poll::Ready(Err(err)) => Poll::Ready(Err(TlsError::Tls(err))),
-            Poll::Pending => this.timeout.poll(cx).map(|_| Err(TlsError::Timeout)),
-        }
-    }
-}

actix-tls/src/connect/connection.rs

@@ -1,17 +1,20 @@
+use derive_more::{Deref, DerefMut};
+
 use super::Host;
 
 /// Wraps underlying I/O and the connection request that initiated it.
-#[derive(Debug)]
+#[derive(Debug, Deref, DerefMut)]
 pub struct Connection<R, IO> {
     pub(crate) req: R,
+
+    #[deref]
+    #[deref_mut]
     pub(crate) io: IO,
 }
 
-impl_more::impl_deref_and_mut!(<R, IO> in Connection<R, IO> => io: IO);
-
 impl<R, IO> Connection<R, IO> {
     /// Construct new `Connection` from request and IO parts.
-    pub fn new(req: R, io: IO) -> Self {
+    pub(crate) fn new(req: R, io: IO) -> Self {
         Self { req, io }
     }
 }

actix-tls/src/connect/error.rs

@@ -1,38 +1,30 @@
-use std::{error::Error, fmt, io};
+use std::{error::Error, io};
+
+use derive_more::Display;
 
 /// Errors that can result from using a connector service.
-#[derive(Debug)]
+#[derive(Debug, Display)]
 pub enum ConnectError {
-    /// Failed to resolve the hostname.
+    /// Failed to resolve the hostname
+    #[display(fmt = "Failed resolving hostname")]
     Resolver(Box<dyn std::error::Error>),
 
-    /// No DNS records.
+    /// No DNS records
+    #[display(fmt = "No DNS records found for the input")]
     NoRecords,
 
-    /// Invalid input.
+    /// Invalid input
     InvalidInput,
 
-    /// Unresolved host name.
+    /// Unresolved host name
+    #[display(fmt = "Connector received `Connect` method with unresolved host")]
     Unresolved,
 
-    /// Connection IO error.
+    /// Connection IO error
+    #[display(fmt = "{}", _0)]
     Io(io::Error),
 }
 
-impl fmt::Display for ConnectError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::NoRecords => f.write_str("No DNS records found for the input"),
-            Self::InvalidInput => f.write_str("Invalid input"),
-            Self::Unresolved => {
-                f.write_str("Connector received `Connect` method with unresolved host")
-            }
-            Self::Resolver(_) => f.write_str("Failed to resolve hostname"),
-            Self::Io(_) => f.write_str("I/O error"),
-        }
-    }
-}
-
 impl Error for ConnectError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match self {

actix-tls/src/connect/info.rs

@@ -118,7 +118,6 @@ impl<R: Host> ConnectInfo<R> {
     /// let mut addrs = conn.addrs();
     /// assert_eq!(addrs.next().unwrap(), addr);
     /// ```
-    #[allow(clippy::implied_bounds_in_impls)]
     pub fn addrs(
         &self,
     ) -> impl Iterator<Item = SocketAddr>
@@ -150,7 +149,6 @@ impl<R: Host> ConnectInfo<R> {
     /// let mut addrs = conn.take_addrs();
     /// assert_eq!(addrs.next().unwrap(), addr);
     /// ```
-    #[allow(clippy::implied_bounds_in_impls)]
     pub fn take_addrs(
         &mut self,
     ) -> impl Iterator<Item = SocketAddr>

actix-tls/src/connect/mod.rs

@@ -22,45 +22,25 @@ mod resolver;
 pub mod tcp;
 
 #[cfg(feature = "uri")]
+#[cfg_attr(docsrs, doc(cfg(feature = "uri")))]
 mod uri;
 
 #[cfg(feature = "openssl")]
+#[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
 pub mod openssl;
 
-#[cfg(any(
+#[cfg(feature = "rustls")]
-    feature = "rustls-0_20-webpki-roots",
+#[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
-    feature = "rustls-0_20-native-roots",
+pub mod rustls;
-))]
-pub mod rustls_0_20;
-
-#[doc(hidden)]
-#[cfg(any(
-    feature = "rustls-0_20-webpki-roots",
-    feature = "rustls-0_20-native-roots",
-))]
-pub use rustls_0_20 as rustls;
-
-#[cfg(any(
-    feature = "rustls-0_21-webpki-roots",
-    feature = "rustls-0_21-native-roots",
-))]
-pub mod rustls_0_21;
-
-#[cfg(feature = "rustls-0_22")]
-pub mod rustls_0_22;
-
-#[cfg(feature = "rustls-0_23")]
-pub mod rustls_0_23;
 
 #[cfg(feature = "native-tls")]
+#[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
 pub mod native_tls;
 
-pub use self::{
+pub use self::connection::Connection;
-    connection::Connection,
+pub use self::connector::{Connector, ConnectorService};
-    connector::{Connector, ConnectorService},
+pub use self::error::ConnectError;
-    error::ConnectError,
+pub use self::host::Host;
-    host::Host,
+pub use self::info::ConnectInfo;
-    info::ConnectInfo,
+pub use self::resolve::Resolve;
-    resolve::Resolve,
+pub use self::resolver::{Resolver, ResolverService};
-    resolver::{Resolver, ResolverService},
-};

actix-tls/src/connect/native_tls.rs

@@ -8,18 +8,20 @@ use actix_rt::net::ActixStream;
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::future::LocalBoxFuture;
+use log::trace;
 use tokio_native_tls::{
     native_tls::TlsConnector as NativeTlsConnector, TlsConnector as AsyncNativeTlsConnector,
     TlsStream as AsyncTlsStream,
 };
-use tracing::trace;
 
 use crate::connect::{Connection, Host};
 
 pub mod reexports {
     //! Re-exports from `native-tls` and `tokio-native-tls` that are useful for connectors.
 
-    pub use tokio_native_tls::{native_tls::TlsConnector, TlsStream as AsyncTlsStream};
+    pub use tokio_native_tls::native_tls::TlsConnector;
+
+    pub use tokio_native_tls::TlsStream as AsyncTlsStream;
 }
 
 /// Connector service and factory using `native-tls`.
@@ -73,16 +75,16 @@ where
         let connector = self.connector.clone();
 
         Box::pin(async move {
-            trace!("TLS handshake start for: {:?}", stream.hostname());
+            trace!("SSL Handshake start for: {:?}", stream.hostname());
             connector
                 .connect(stream.hostname(), io)
                 .await
                 .map(|res| {
-                    trace!("TLS handshake success: {:?}", stream.hostname());
+                    trace!("SSL Handshake success: {:?}", stream.hostname());
                     stream.replace_io(res).1
                 })
                 .map_err(|e| {
-                    trace!("TLS handshake error: {:?}", e);
+                    trace!("SSL Handshake error: {:?}", e);
                     io::Error::new(io::ErrorKind::Other, format!("{}", e))
                 })
         })

actix-tls/src/connect/openssl.rs

@@ -13,16 +13,17 @@ use actix_rt::net::ActixStream;
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::ready;
+use log::trace;
 use openssl::ssl::SslConnector;
 use tokio_openssl::SslStream as AsyncSslStream;
-use tracing::trace;
 
 use crate::connect::{Connection, Host};
 
 pub mod reexports {
     //! Re-exports from `openssl` and `tokio-openssl` that are useful for connectors.
 
-    pub use openssl::ssl::{Error, HandshakeError, SslConnector, SslConnectorBuilder, SslMethod};
+    pub use openssl::ssl::{Error, HandshakeError, SslConnector, SslMethod};
+
     pub use tokio_openssl::SslStream as AsyncSslStream;
 }
 
@@ -95,8 +96,7 @@ where
     actix_service::always_ready!();
 
     fn call(&self, stream: Connection<R, IO>) -> Self::Future {
-        trace!("TLS handshake start for: {:?}", stream.hostname());
+        trace!("SSL Handshake start for: {:?}", stream.hostname());
-
         let (io, stream) = stream.replace_io(());
         let host = stream.hostname();
 
@@ -136,15 +136,12 @@ where
         match ready!(Pin::new(this.io.as_mut().unwrap()).poll_connect(cx)) {
             Ok(_) => {
                 let stream = this.stream.take().unwrap();
-                trace!("TLS handshake success: {:?}", stream.hostname());
+                trace!("SSL Handshake success: {:?}", stream.hostname());
                 Poll::Ready(Ok(stream.replace_io(this.io.take().unwrap()).1))
             }
-            Err(err) => {
+            Err(e) => {
-                trace!("TLS handshake error: {:?}", err);
+                trace!("SSL Handshake error: {:?}", e);
-                Poll::Ready(Err(io::Error::new(
+                Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, format!("{}", e))))
-                    io::ErrorKind::Other,
-                    format!("{}", err),
-                )))
             }
         }
     }

actix-tls/src/connect/resolver.rs

@@ -12,7 +12,7 @@ use actix_rt::task::{spawn_blocking, JoinHandle};
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::{future::LocalBoxFuture, ready};
-use tracing::trace;
+use log::trace;
 
 use super::{ConnectError, ConnectInfo, Host, Resolve};
 
@@ -164,8 +164,8 @@ impl<R: Host> Future for ResolverFut<R> {
             Self::LookUp(fut, req) => {
                 let res = match ready!(Pin::new(fut).poll(cx)) {
                     Ok(Ok(res)) => Ok(res),
-                    Ok(Err(err)) => Err(ConnectError::Resolver(Box::new(err))),
+                    Ok(Err(e)) => Err(ConnectError::Resolver(Box::new(e))),
-                    Err(err) => Err(ConnectError::Io(err.into())),
+                    Err(e) => Err(ConnectError::Io(e.into())),
                 };
 
                 let req = req.take().unwrap();

actix-tls/src/connect/rustls.rs

@@ -3,6 +3,7 @@
 //! See [`TlsConnector`] for main connector service factory docs.
 
 use std::{
+    convert::TryFrom,
     future::Future,
     io,
     pin::Pin,
@@ -14,50 +15,29 @@ use actix_rt::net::ActixStream;
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::ready;
-use tokio_rustls::{
+use log::trace;
-    client::TlsStream as AsyncTlsStream,
+use tokio_rustls::rustls::{client::ServerName, OwnedTrustAnchor, RootCertStore};
-    rustls::{client::ServerName, ClientConfig, RootCertStore},
+use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
-    Connect as RustlsConnect, TlsConnector as RustlsTlsConnector,
+use tokio_rustls::{Connect as RustlsConnect, TlsConnector as RustlsTlsConnector};
-};
+use webpki_roots::TLS_SERVER_ROOTS;
-use tokio_rustls_023 as tokio_rustls;
 
 use crate::connect::{Connection, Host};
 
 pub mod reexports {
-    //! Re-exports from the `rustls` v0.20 ecosystem that are useful for connectors.
+    //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors.
 
-    pub use tokio_rustls_023::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
+    pub use tokio_rustls::rustls::ClientConfig;
-    #[cfg(feature = "rustls-0_20-webpki-roots")]
-    pub use webpki_roots_022::TLS_SERVER_ROOTS;
-}
 
-/// Returns root certificates via `rustls-native-certs` crate as a rustls certificate store.
+    pub use tokio_rustls::client::TlsStream as AsyncTlsStream;
-///
-/// See [`rustls_native_certs::load_native_certs()`] for more info on behavior and errors.
-///
-/// [`rustls_native_certs::load_native_certs()`]: rustls_native_certs_06::load_native_certs()
-#[cfg(feature = "rustls-0_20-native-roots")]
-pub fn native_roots_cert_store() -> io::Result<RootCertStore> {
-    let mut root_certs = RootCertStore::empty();
 
-    for cert in rustls_native_certs_06::load_native_certs()? {
+    pub use webpki_roots::TLS_SERVER_ROOTS;
-        root_certs
-            .add(&tokio_rustls_023::rustls::Certificate(cert.0))
-            .unwrap();
-    }
-
-    Ok(root_certs)
 }
 
 /// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
-#[cfg(feature = "rustls-0_20-webpki-roots")]
 pub fn webpki_roots_cert_store() -> RootCertStore {
-    use tokio_rustls_023::rustls;
-
     let mut root_certs = RootCertStore::empty();
-
+    for cert in TLS_SERVER_ROOTS.0 {
-    for cert in webpki_roots_022::TLS_SERVER_ROOTS.0 {
+        let cert = OwnedTrustAnchor::from_subject_spki_name_constraints(
-        let cert = rustls::OwnedTrustAnchor::from_subject_spki_name_constraints(
             cert.subject,
             cert.spki,
             cert.name_constraints,
@@ -65,7 +45,6 @@ pub fn webpki_roots_cert_store() -> RootCertStore {
         let certs = vec![cert].into_iter();
         root_certs.add_server_trust_anchors(certs);
     }
-
     root_certs
 }
 
@@ -124,13 +103,12 @@ where
     actix_service::always_ready!();
 
     fn call(&self, connection: Connection<R, IO>) -> Self::Future {
-        tracing::trace!("TLS handshake start for: {:?}", connection.hostname());
+        trace!("SSL Handshake start for: {:?}", connection.hostname());
         let (stream, connection) = connection.replace_io(());
 
         match ServerName::try_from(connection.hostname()) {
             Ok(host) => ConnectFut::Future {
-                connect: RustlsTlsConnector::from(Arc::clone(&self.connector))
+                connect: RustlsTlsConnector::from(self.connector.clone()).connect(host, stream),
-                    .connect(host, stream),
                 connection: Some(connection),
             },
             Err(_) => ConnectFut::InvalidDns,
@@ -140,7 +118,6 @@ where
 
 /// Connect future for Rustls service.
 #[doc(hidden)]
-#[allow(clippy::large_enum_variant)]
 pub enum ConnectFut<R, IO> {
     /// See issue <https://github.com/briansmith/webpki/issues/54>
     InvalidDns,
@@ -155,23 +132,17 @@ where
     R: Host,
     IO: ActixStream,
 {
-    type Output = io::Result<Connection<R, AsyncTlsStream<IO>>>;
+    type Output = Result<Connection<R, AsyncTlsStream<IO>>, io::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.get_mut() {
-            Self::InvalidDns => Poll::Ready(Err(io::Error::new(
+            Self::InvalidDns => Poll::Ready(Err(
-                io::ErrorKind::Other,
+                io::Error::new(io::ErrorKind::Other, "rustls currently only handles hostname-based connections. See https://github.com/briansmith/webpki/issues/54")
-                "Rustls v0.20 can only handle hostname-based connections. Enable the `rustls-0_21` \
+            )),
-                feature and use the Rustls v0.21 utilities to gain this feature.",
+            Self::Future { connect, connection } => {
-            ))),
-
-            Self::Future {
-                connect,
-                connection,
-            } => {
                 let stream = ready!(Pin::new(connect).poll(cx))?;
                 let connection = connection.take().unwrap();
-                tracing::trace!("TLS handshake success: {:?}", connection.hostname());
+                trace!("SSL Handshake success: {:?}", connection.hostname());
                 Poll::Ready(Ok(connection.replace_io(stream).1))
             }
         }

actix-tls/src/connect/rustls_0_21.rs

@@ -1,177 +0,0 @@
-//! Rustls based connector service.
-//!
-//! See [`TlsConnector`] for main connector service factory docs.
-
-use std::{
-    future::Future,
-    io,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-use actix_rt::net::ActixStream;
-use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ok, Ready};
-use futures_core::ready;
-use tokio_rustls::{
-    client::TlsStream as AsyncTlsStream,
-    rustls::{client::ServerName, ClientConfig, RootCertStore},
-    Connect as RustlsConnect, TlsConnector as RustlsTlsConnector,
-};
-use tokio_rustls_024 as tokio_rustls;
-
-use crate::connect::{Connection, Host};
-
-pub mod reexports {
-    //! Re-exports from the `rustls` v0.21 ecosystem that are useful for connectors.
-
-    pub use tokio_rustls_024::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
-    #[cfg(feature = "rustls-0_21-webpki-roots")]
-    pub use webpki_roots_025::TLS_SERVER_ROOTS;
-}
-
-/// Returns root certificates via `rustls-native-certs` crate as a rustls certificate store.
-///
-/// See [`rustls_native_certs::load_native_certs()`] for more info on behavior and errors.
-///
-/// [`rustls_native_certs::load_native_certs()`]: rustls_native_certs_06::load_native_certs()
-#[cfg(feature = "rustls-0_21-native-roots")]
-pub fn native_roots_cert_store() -> io::Result<RootCertStore> {
-    let mut root_certs = RootCertStore::empty();
-
-    for cert in rustls_native_certs_06::load_native_certs()? {
-        root_certs
-            .add(&tokio_rustls_024::rustls::Certificate(cert.0))
-            .unwrap();
-    }
-
-    Ok(root_certs)
-}
-
-/// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
-#[cfg(feature = "rustls-0_21-webpki-roots")]
-pub fn webpki_roots_cert_store() -> RootCertStore {
-    use tokio_rustls_024::rustls;
-
-    let mut root_certs = RootCertStore::empty();
-
-    for cert in webpki_roots_025::TLS_SERVER_ROOTS {
-        let cert = rustls::OwnedTrustAnchor::from_subject_spki_name_constraints(
-            cert.subject,
-            cert.spki,
-            cert.name_constraints,
-        );
-        let certs = vec![cert].into_iter();
-        root_certs.add_trust_anchors(certs);
-    }
-
-    root_certs
-}
-
-/// Connector service factory using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnector {
-    connector: Arc<ClientConfig>,
-}
-
-impl TlsConnector {
-    /// Constructs new connector service factory from a `rustls` client configuration.
-    pub fn new(connector: Arc<ClientConfig>) -> Self {
-        TlsConnector { connector }
-    }
-
-    /// Constructs new connector service from a `rustls` client configuration.
-    pub fn service(connector: Arc<ClientConfig>) -> TlsConnectorService {
-        TlsConnectorService { connector }
-    }
-}
-
-impl<R, IO> ServiceFactory<Connection<R, IO>> for TlsConnector
-where
-    R: Host,
-    IO: ActixStream + 'static,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Config = ();
-    type Service = TlsConnectorService;
-    type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(TlsConnectorService {
-            connector: self.connector.clone(),
-        })
-    }
-}
-
-/// Connector service using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnectorService {
-    connector: Arc<ClientConfig>,
-}
-
-impl<R, IO> Service<Connection<R, IO>> for TlsConnectorService
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Future = ConnectFut<R, IO>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, connection: Connection<R, IO>) -> Self::Future {
-        tracing::trace!("TLS handshake start for: {:?}", connection.hostname());
-        let (stream, connection) = connection.replace_io(());
-
-        match ServerName::try_from(connection.hostname()) {
-            Ok(host) => ConnectFut::Future {
-                connect: RustlsTlsConnector::from(Arc::clone(&self.connector))
-                    .connect(host, stream),
-                connection: Some(connection),
-            },
-            Err(_) => ConnectFut::InvalidServerName,
-        }
-    }
-}
-
-/// Connect future for Rustls service.
-#[doc(hidden)]
-#[allow(clippy::large_enum_variant)]
-pub enum ConnectFut<R, IO> {
-    InvalidServerName,
-    Future {
-        connect: RustlsConnect<IO>,
-        connection: Option<Connection<R, ()>>,
-    },
-}
-
-impl<R, IO> Future for ConnectFut<R, IO>
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Output = io::Result<Connection<R, AsyncTlsStream<IO>>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.get_mut() {
-            Self::InvalidServerName => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "connection parameters specified invalid server name",
-            ))),
-
-            Self::Future {
-                connect,
-                connection,
-            } => {
-                let stream = ready!(Pin::new(connect).poll(cx))?;
-                let connection = connection.take().unwrap();
-                tracing::trace!("TLS handshake success: {:?}", connection.hostname());
-                Poll::Ready(Ok(connection.replace_io(stream).1))
-            }
-        }
-    }
-}

actix-tls/src/connect/rustls_0_22.rs

@@ -1,163 +0,0 @@
-//! Rustls based connector service.
-//!
-//! See [`TlsConnector`] for main connector service factory docs.
-
-use std::{
-    future::Future,
-    io,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-use actix_rt::net::ActixStream;
-use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ok, Ready};
-use futures_core::ready;
-use rustls_pki_types_1::ServerName;
-use tokio_rustls::{
-    client::TlsStream as AsyncTlsStream, rustls::ClientConfig, Connect as RustlsConnect,
-    TlsConnector as RustlsTlsConnector,
-};
-use tokio_rustls_025 as tokio_rustls;
-
-use crate::connect::{Connection, Host};
-
-pub mod reexports {
-    //! Re-exports from the `rustls` v0.22 ecosystem that are useful for connectors.
-
-    pub use tokio_rustls_025::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
-    #[cfg(feature = "rustls-0_22-webpki-roots")]
-    pub use webpki_roots_026::TLS_SERVER_ROOTS;
-}
-
-/// Returns root certificates via `rustls-native-certs` crate as a rustls certificate store.
-///
-/// See [`rustls_native_certs::load_native_certs()`] for more info on behavior and errors.
-///
-/// [`rustls_native_certs::load_native_certs()`]: rustls_native_certs_07::load_native_certs()
-#[cfg(feature = "rustls-0_22-native-roots")]
-pub fn native_roots_cert_store() -> io::Result<tokio_rustls::rustls::RootCertStore> {
-    let mut root_certs = tokio_rustls::rustls::RootCertStore::empty();
-
-    for cert in rustls_native_certs_07::load_native_certs()? {
-        root_certs.add(cert).unwrap();
-    }
-
-    Ok(root_certs)
-}
-
-/// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
-#[cfg(feature = "rustls-0_22-webpki-roots")]
-pub fn webpki_roots_cert_store() -> tokio_rustls::rustls::RootCertStore {
-    let mut root_certs = tokio_rustls::rustls::RootCertStore::empty();
-    root_certs.extend(webpki_roots_026::TLS_SERVER_ROOTS.to_owned());
-    root_certs
-}
-
-/// Connector service factory using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnector {
-    connector: Arc<ClientConfig>,
-}
-
-impl TlsConnector {
-    /// Constructs new connector service factory from a `rustls` client configuration.
-    pub fn new(connector: Arc<ClientConfig>) -> Self {
-        TlsConnector { connector }
-    }
-
-    /// Constructs new connector service from a `rustls` client configuration.
-    pub fn service(connector: Arc<ClientConfig>) -> TlsConnectorService {
-        TlsConnectorService { connector }
-    }
-}
-
-impl<R, IO> ServiceFactory<Connection<R, IO>> for TlsConnector
-where
-    R: Host,
-    IO: ActixStream + 'static,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Config = ();
-    type Service = TlsConnectorService;
-    type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(TlsConnectorService {
-            connector: self.connector.clone(),
-        })
-    }
-}
-
-/// Connector service using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnectorService {
-    connector: Arc<ClientConfig>,
-}
-
-impl<R, IO> Service<Connection<R, IO>> for TlsConnectorService
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Future = ConnectFut<R, IO>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, connection: Connection<R, IO>) -> Self::Future {
-        tracing::trace!("TLS handshake start for: {:?}", connection.hostname());
-        let (stream, conn) = connection.replace_io(());
-
-        match ServerName::try_from(conn.hostname()) {
-            Ok(host) => ConnectFut::Future {
-                connect: RustlsTlsConnector::from(Arc::clone(&self.connector))
-                    .connect(host.to_owned(), stream),
-                connection: Some(conn),
-            },
-            Err(_) => ConnectFut::InvalidServerName,
-        }
-    }
-}
-
-/// Connect future for Rustls service.
-#[doc(hidden)]
-#[allow(clippy::large_enum_variant)]
-pub enum ConnectFut<R, IO> {
-    InvalidServerName,
-    Future {
-        connect: RustlsConnect<IO>,
-        connection: Option<Connection<R, ()>>,
-    },
-}
-
-impl<R, IO> Future for ConnectFut<R, IO>
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Output = io::Result<Connection<R, AsyncTlsStream<IO>>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.get_mut() {
-            Self::InvalidServerName => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "connection parameters specified invalid server name",
-            ))),
-
-            Self::Future {
-                connect,
-                connection,
-            } => {
-                let stream = ready!(Pin::new(connect).poll(cx))?;
-                let connection = connection.take().unwrap();
-                tracing::trace!("TLS handshake success: {:?}", connection.hostname());
-                Poll::Ready(Ok(connection.replace_io(stream).1))
-            }
-        }
-    }
-}

actix-tls/src/connect/rustls_0_23.rs

@@ -1,163 +0,0 @@
-//! Rustls based connector service.
-//!
-//! See [`TlsConnector`] for main connector service factory docs.
-
-use std::{
-    future::Future,
-    io,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-use actix_rt::net::ActixStream;
-use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ok, Ready};
-use futures_core::ready;
-use rustls_pki_types_1::ServerName;
-use tokio_rustls::{
-    client::TlsStream as AsyncTlsStream, rustls::ClientConfig, Connect as RustlsConnect,
-    TlsConnector as RustlsTlsConnector,
-};
-use tokio_rustls_026 as tokio_rustls;
-
-use crate::connect::{Connection, Host};
-
-pub mod reexports {
-    //! Re-exports from the `rustls` v0.23 ecosystem that are useful for connectors.
-
-    pub use tokio_rustls_026::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
-    #[cfg(feature = "rustls-0_23-webpki-roots")]
-    pub use webpki_roots_026::TLS_SERVER_ROOTS;
-}
-
-/// Returns root certificates via `rustls-native-certs` crate as a rustls certificate store.
-///
-/// See [`rustls_native_certs::load_native_certs()`] for more info on behavior and errors.
-///
-/// [`rustls_native_certs::load_native_certs()`]: rustls_native_certs_07::load_native_certs()
-#[cfg(feature = "rustls-0_23-native-roots")]
-pub fn native_roots_cert_store() -> io::Result<tokio_rustls::rustls::RootCertStore> {
-    let mut root_certs = tokio_rustls::rustls::RootCertStore::empty();
-
-    for cert in rustls_native_certs_07::load_native_certs()? {
-        root_certs.add(cert).unwrap();
-    }
-
-    Ok(root_certs)
-}
-
-/// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
-#[cfg(feature = "rustls-0_23-webpki-roots")]
-pub fn webpki_roots_cert_store() -> tokio_rustls::rustls::RootCertStore {
-    let mut root_certs = tokio_rustls::rustls::RootCertStore::empty();
-    root_certs.extend(webpki_roots_026::TLS_SERVER_ROOTS.to_owned());
-    root_certs
-}
-
-/// Connector service factory using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnector {
-    connector: Arc<ClientConfig>,
-}
-
-impl TlsConnector {
-    /// Constructs new connector service factory from a `rustls` client configuration.
-    pub fn new(connector: Arc<ClientConfig>) -> Self {
-        TlsConnector { connector }
-    }
-
-    /// Constructs new connector service from a `rustls` client configuration.
-    pub fn service(connector: Arc<ClientConfig>) -> TlsConnectorService {
-        TlsConnectorService { connector }
-    }
-}
-
-impl<R, IO> ServiceFactory<Connection<R, IO>> for TlsConnector
-where
-    R: Host,
-    IO: ActixStream + 'static,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Config = ();
-    type Service = TlsConnectorService;
-    type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(TlsConnectorService {
-            connector: self.connector.clone(),
-        })
-    }
-}
-
-/// Connector service using `rustls`.
-#[derive(Clone)]
-pub struct TlsConnectorService {
-    connector: Arc<ClientConfig>,
-}
-
-impl<R, IO> Service<Connection<R, IO>> for TlsConnectorService
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Response = Connection<R, AsyncTlsStream<IO>>;
-    type Error = io::Error;
-    type Future = ConnectFut<R, IO>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, connection: Connection<R, IO>) -> Self::Future {
-        tracing::trace!("TLS handshake start for: {:?}", connection.hostname());
-        let (stream, conn) = connection.replace_io(());
-
-        match ServerName::try_from(conn.hostname()) {
-            Ok(host) => ConnectFut::Future {
-                connect: RustlsTlsConnector::from(Arc::clone(&self.connector))
-                    .connect(host.to_owned(), stream),
-                connection: Some(conn),
-            },
-            Err(_) => ConnectFut::InvalidServerName,
-        }
-    }
-}
-
-/// Connect future for Rustls service.
-#[doc(hidden)]
-#[allow(clippy::large_enum_variant)]
-pub enum ConnectFut<R, IO> {
-    InvalidServerName,
-    Future {
-        connect: RustlsConnect<IO>,
-        connection: Option<Connection<R, ()>>,
-    },
-}
-
-impl<R, IO> Future for ConnectFut<R, IO>
-where
-    R: Host,
-    IO: ActixStream,
-{
-    type Output = io::Result<Connection<R, AsyncTlsStream<IO>>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.get_mut() {
-            Self::InvalidServerName => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "connection parameters specified invalid server name",
-            ))),
-
-            Self::Future {
-                connect,
-                connection,
-            } => {
-                let stream = ready!(Pin::new(connect).poll(cx))?;
-                let connection = connection.take().unwrap();
-                tracing::trace!("TLS handshake success: {:?}", connection.hostname());
-                Poll::Ready(Ok(connection.replace_io(stream).1))
-            }
-        }
-    }
-}

actix-tls/src/connect/tcp.rs

@@ -15,8 +15,8 @@ use actix_rt::net::{TcpSocket, TcpStream};
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::ready;
+use log::{error, trace};
 use tokio_util::sync::ReusableBoxFuture;
-use tracing::{error, trace};
 
 use super::{connect_addrs::ConnectAddrs, error::ConnectError, ConnectInfo, Connection, Host};
 
@@ -79,7 +79,7 @@ pub enum TcpConnectorFut<R> {
         port: u16,
         local_addr: Option<IpAddr>,
         addrs: Option<VecDeque<SocketAddr>>,
-        stream: ReusableBoxFuture<'static, Result<TcpStream, io::Error>>,
+        stream: ReusableBoxFuture<Result<TcpStream, io::Error>>,
     },
 
     Error(Option<ConnectError>),
@@ -114,8 +114,8 @@ impl<R: Host> TcpConnectorFut<R> {
                 stream: ReusableBoxFuture::new(connect(addr, local_addr)),
             },
 
-            // When resolver returns multiple socket addr for request they would be popped from
+            // when resolver returns multiple socket addr for request they would be popped from
-            // front end of queue and returns with the first successful TCP connection.
+            // front end of queue and returns with the first successful tcp connection.
             ConnectAddrs::Multi(mut addrs) => {
                 let addr = addrs.pop_front().unwrap();
 

actix-tls/src/connect/uri.rs

@@ -1,19 +1,8 @@
+use http::Uri;
+
 use super::Host;
 
-impl Host for http_0_2::Uri {
+impl Host for Uri {
-    fn hostname(&self) -> &str {
-        self.host().unwrap_or("")
-    }
-
-    fn port(&self) -> Option<u16> {
-        match self.port_u16() {
-            Some(port) => Some(port),
-            None => scheme_to_port(self.scheme_str()),
-        }
-    }
-}
-
-impl Host for http_1::Uri {
     fn hostname(&self) -> &str {
         self.host().unwrap_or("")
     }

actix-tls/src/lib.rs

@@ -1,15 +1,19 @@
 //! TLS acceptor and connector services for the Actix ecosystem.
 
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![warn(missing_docs)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(feature = "openssl")]
 #[allow(unused_extern_crates)]
 extern crate tls_openssl as openssl;
 
 #[cfg(feature = "accept")]
+#[cfg_attr(docsrs, doc(cfg(feature = "accept")))]
 pub mod accept;
 
 #[cfg(feature = "connect")]
+#[cfg_attr(docsrs, doc(cfg(feature = "connect")))]
 pub mod connect;