chore(local-channel): prepare release 0.1.4

local-channel: drop futures-util by using future::poll_fn from std (#490 )
chore: force secure rustls-webpki
2025-08-18 15:05:31 +02:00 · 2023-09-17 19:32:01 +01:00 · 2023-09-17 11:45:55 +00:00 · 2023-08-29 18:45:11 +01:00 · 2023-08-29 18:41:48 +01:00 · 2023-08-29 18:40:55 +01:00
83 changed files with 1245 additions and 617 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -15,9 +15,11 @@ ci-check-linux = "hack --workspace --feature-powerset check --tests --examples"

 # tests avoiding io-uring feature
 ci-test = "hack --feature-powerset --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture"
+ci-test-rustls-020 = "hack --feature-powerset --exclude-features=io-uring,rustls-0_21 test --lib --tests --no-fail-fast -- --nocapture"
+ci-test-rustls-021 = "hack --feature-powerset --exclude-features=io-uring,rustls-0_20 test --lib --tests --no-fail-fast -- --nocapture"

 # tests avoiding io-uring feature on Windows
-ci-test-win = "hack --feature-powerset --depth 2 --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture"
+ci-test-win = "hack --feature-powerset --depth=2 --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture"

 # test with io-uring feature
-ci-test-linux = "hack --feature-powerset test --lib --tests --no-fail-fast -- --nocapture"
+ci-test-linux = "hack --feature-powerset --exclude-features=rustls-0_20 test --lib --tests --no-fail-fast -- --nocapture"
--- a/.github/workflows/ci-post-merge.yml
+++ b/.github/workflows/ci-post-merge.yml
@@ -4,11 +4,19 @@ 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 }
@@ -21,8 +29,7 @@ jobs:
    name: ${{ matrix.target.name }} / ${{ matrix.version }}
    runs-on: ${{ matrix.target.os }}

-    env:
-      VCPKGRS_DYNAMIC: 1
+    env: {}

    steps:
      - name: Setup Routing
@@ -31,39 +38,26 @@ jobs:

      - uses: actions/checkout@v3

-      # install OpenSSL on Windows
-      - name: Set vcpkg root
-        if: matrix.target.triple == 'x86_64-pc-windows-msvc' || matrix.target.triple == 'i686-pc-windows-msvc'
-        run: echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append
-      - name: Install OpenSSL
-        if: matrix.target.triple == 'x86_64-pc-windows-msvc'
-        run: vcpkg install openssl:x64-windows
-      - name: Install OpenSSL
-        if: matrix.target.triple == 'i686-pc-windows-msvc'
-        run: vcpkg install openssl:x86-windows
+      - name: Free Disk Space
+        if: matrix.target.os == 'ubuntu-latest'
+        run: ./scripts/free-disk-space.sh

-      - name: Install ${{ matrix.version }}
+      - name: Install OpenSSL
+        if: matrix.target.os == 'windows-latest'
+        run: choco install openssl -y --forcex64 --no-progress
+      - name: Set OpenSSL dir in env
+        if: matrix.target.os == 'windows-latest'
        run: |
-          rustup set profile minimal
-          rustup install ${{ matrix.version }}-${{ matrix.target.triple }}
-          rustup override set ${{ matrix.version }}-${{ matrix.target.triple }}
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' | Out-File -FilePath $env:GITHUB_ENV -Append

-      # - name: Install MSYS2
-      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
-      #   uses: msys2/setup-msys2@v2
-      # - name: Install MinGW Packages
-      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
-      #   run: |
-      #     msys2 -c 'pacman -Sy --noconfirm pacman'
-      #     msys2 -c 'pacman --noconfirm -S base-devel pkg-config'
+      - name: Install Rust (${{ matrix.version }})
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}

-      # - name: Generate Cargo.lock
-      #   run: cargo generate-lockfile
-      # - name: Cache Dependencies
-      #   uses: Swatinem/rust-cache@v2.2.0
-
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
+      - uses: taiki-e/install-action@v2
+        with: { tool: cargo-hack }

      - name: check lib
        if: >
@@ -94,8 +88,15 @@ jobs:
        run: cargo ci-test
      - 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-linux"
+        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: Clear the cargo caches
        run: |
@@ -109,21 +110,16 @@ jobs:
      - uses: actions/checkout@v3

      - name: Install Rust (nightly)
-        run: |
-          rustup set profile minimal
-          rustup install nightly
-          rustup override set nightly
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: { toolchain: nightly }

-      - name: Generate Cargo.lock
-        run: cargo generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+      - name: Install cargo-tarpaulin
+        uses: taiki-e/install-action@v1
+        with: { tool: cargo-tarpaulin }

      - name: Generate coverage file
        if: github.ref == 'refs/heads/master'
-        run: |
-          cargo install cargo-tarpaulin
-          cargo tarpaulin --out Xml --verbose
+        run: cargo tarpaulin --out Xml --verbose
      - name: Upload to Codecov
        if: github.ref == 'refs/heads/master'
        uses: codecov/codecov-action@v3
@@ -136,21 +132,12 @@ jobs:
      - uses: actions/checkout@v3

      - name: Install Rust (nightly)
-        run: |
-          rustup set profile minimal
-          rustup install nightly
-          rustup override set nightly
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: { toolchain: nightly }

-      - name: Generate Cargo.lock
-        run: cargo generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v2.2.0
-
-      - name: Install cargo-minimal-versions
-        run: cargo install cargo-minimal-versions
-
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
+      - name: Install cargo-hack & cargo-minimal-versions
+        uses: taiki-e/install-action@v1
+        with: { tool: 'cargo-hack,cargo-minimal-versions' }

      - name: Check With Minimal Versions
        run: cargo minimal-versions check
@@ -162,18 +149,11 @@ jobs:
      - uses: actions/checkout@v3

      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup install stable
-          rustup override set stable
-
-      - name: Generate Cargo.lock
-        run: cargo generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1

      - name: Install cargo-nextest
-        run: cargo install cargo-nextest
+        uses: taiki-e/install-action@v1
+        with: { tool: cargo-nextest }

      - name: Test with cargo-nextest
        run: cargo nextest run
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,16 +1,22 @@
 name: CI

 on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches: [master]
+  pull_request: {}
+  push: { branches: [master] }
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true

 jobs:
  build_and_test:
    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 }
@@ -18,14 +24,13 @@ jobs:
          - { name: Windows (MinGW), os: windows-latest, triple: x86_64-pc-windows-gnu }
          - { name: Windows (32-bit), os: windows-latest, triple: i686-pc-windows-msvc }
        version:
-          - 1.59.0
+          - 1.65.0 # MSRV
          - stable

    name: ${{ matrix.target.name }} / ${{ matrix.version }}
    runs-on: ${{ matrix.target.os }}

-    env:
-      VCPKGRS_DYNAMIC: 1
+    env: {}

    steps:
      - name: Setup Routing
@@ -34,52 +39,26 @@ jobs:

      - uses: actions/checkout@v3

-      # 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: Free Disk Space
+        if: matrix.target.os == 'ubuntu-latest'
+        run: ./scripts/free-disk-space.sh
+
      - name: Install OpenSSL
-        if: matrix.target.triple == 'x86_64-pc-windows-msvc'
-        run: vcpkg install openssl:x64-windows
-      - name: Install OpenSSL
-        if: matrix.target.triple == 'i686-pc-windows-msvc'
-        run: vcpkg install openssl:x86-windows
-
-      - name: Install ${{ matrix.version }}
+        if: matrix.target.os == 'windows-latest'
+        run: choco install openssl -y --forcex64 --no-progress
+      - name: Set OpenSSL dir in env
+        if: matrix.target.os == 'windows-latest'
        run: |
-          rustup set profile minimal
-          rustup install ${{ matrix.version }}-${{ matrix.target.triple }}
-          rustup override set ${{ matrix.version }}-${{ matrix.target.triple }}
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append
+          echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' | Out-File -FilePath $env:GITHUB_ENV -Append

-      # - name: Install MSYS2
-      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
-      #   uses: msys2/setup-msys2@v2
-      # - name: Install MinGW Packages
-      #   if: matrix.target.triple == 'x86_64-pc-windows-gnu'
-      #   run: |
-      #     msys2 -c 'pacman -Sy --noconfirm pacman'
-      #     msys2 -c 'pacman --noconfirm -S base-devel pkg-config'
+      - name: Install Rust (${{ matrix.version }})
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}

-      # - name: Generate Cargo.lock
-      #   run: cargo generate-lockfile
-      # - name: Cache Dependencies
-      #   uses: Swatinem/rust-cache@v2.2.0
-
-      - name: Install cargo-hack
-        if: matrix.version != '1.59.0'
-        run: cargo install cargo-hack
-
-      # newer cargo-hack versions require 1.60 or above
-      - name: Install cargo-hack (1.59.0)
-        if: matrix.version == '1.59.0'
-        run: cargo install cargo-hack --version=0.5.21
-
-      - name: workaround MSRV issues
-        if: matrix.version == '1.59.0'
-        run: |
-          cargo install cargo-edit --version=0.8.0
-          cargo add env_logger@0.9 --dev -p=actix-tls
-          cargo add env_logger@0.9 --dev -p=actix-server
+      - uses: taiki-e/install-action@v1
+        with: { tool: cargo-hack }

      - name: Generate Cargo.lock
        run: cargo generate-lockfile
@@ -87,7 +66,7 @@ jobs:
      - name: workaround MSRV issues
        if: matrix.version != 'stable'
        run: |
-          cargo update -p=time --precise=0.3.13  # time is only a dev dep so shouldn't affect msrv
+          cargo update -p=time --precise=0.3.16  # time is only a dev dep so shouldn't affect msrv

      - name: check lib
        if: >
@@ -121,11 +100,17 @@ jobs:
        run: cargo ci-test-win
      - 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-linux"
+        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: Clear the cargo caches
-        if: matrix.version == 'stable' # MSRV(1.58) cargo-cache now fails to install on 1.59
        run: |
          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
          cargo-cache
@@ -138,15 +123,8 @@ jobs:
      - uses: actions/checkout@v3

      - name: Install Rust (nightly)
-        run: |
-          rustup set profile minimal
-          rustup install nightly
-          rustup override set nightly
-
-      - name: Generate Cargo.lock
-        run: cargo generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v2.2.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: { toolchain: nightly }

      - name: doc tests io-uring
        run: |
--- a/.github/workflows/clippy-fmt.yml
+++ b/.github/workflows/clippy-fmt.yml
@@ -1,37 +1,43 @@
 name: Lint

-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
+on: [pull_request]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true

 jobs:
  fmt:
    runs-on: ubuntu-latest
+
    steps:
      - uses: actions/checkout@v3

-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup install stable
-          rustup override set stable
-          rustup component add rustfmt
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        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@v3

-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup install stable
-          rustup override set stable
-          rustup component add clippy
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: { components: clippy }
+
      - uses: giraffate/clippy-action@v1
        with:
-          reporter: "github-pr-check"
+          reporter: 'github-pr-check'
          github_token: ${{ secrets.GITHUB_TOKEN }}
          clippy_flags: --workspace --all-features --tests --examples --bins -- -Dclippy::todo
--- a/.github/workflows/upload-doc.yml
+++ b/.github/workflows/upload-doc.yml
@@ -1,21 +1,27 @@
 name: Upload documentation

 on:
-  push:
-    branches: [master]
+  push: { branches: [master] }
+
+permissions:
+  contents: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true

 jobs:
  build:
+    permissions:
+      contents: write
+
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup install nightly
-          rustup override set nightly
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: { toolchain: nightly }

      - name: Build Docs
        run: cargo doc --workspace --all-features --no-deps
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -0,0 +1,3 @@
+group_imports = "StdExternalCrate"
+imports_granularity = "Crate"
+use_field_init_shorthand = true
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,12 @@ members = [
  "local-channel",
  "local-waker",
 ]
+resolver = "2"
+
+[workspace.package]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+rust-version = "1.65"

 [patch.crates-io]
 actix-codec = { path = "actix-codec" }
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ See example folders for [`actix-server`](./actix-server/examples) and [`actix-tl

 ## MSRV

-Crates in this repo currently have a Minimum Supported Rust Version (MSRV) of 1.59. As a policy, we permit MSRV increases in non-breaking releases.
+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

--- a/actix-codec/CHANGES.md
+++ b/actix-codec/CHANGES.md
@@ -1,8 +1,8 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

- Minimum supported Rust version (MSRV) is now 1.59.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 0.5.1 - 2022-03-15

--- a/actix-codec/Cargo.toml
+++ b/actix-codec/Cargo.toml
@@ -10,20 +10,17 @@ keywords = ["network", "framework", "async", "futures"]
 repository = "https://github.com/actix/actix-net"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_codec"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
-bitflags = "1.2"
+bitflags = "2"
 bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
 futures-sink = { version = "0.3.7", default-features = false }
 memchr = "2.3"
 pin-project-lite = "0.2"
-tokio = "1.18.4"
+tokio = "1.23.1"
 tokio-util = { version = "0.7", features = ["codec", "io"] }
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }

--- a/actix-codec/src/framed.rs
+++ b/actix-codec/src/framed.rs
@@ -18,6 +18,7 @@ const LW: usize = 1024;
 const HW: usize = 8 * 1024;

 bitflags! {
+    #[derive(Debug, Clone, Copy)]
    struct Flags: u8 {
        const EOF = 0b0001;
        const READABLE = 0b0010;
@@ -233,10 +234,7 @@ 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>,
@@ -269,10 +267,7 @@ impl<T, U> Framed<T, U> {
    }

    /// 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>,
--- a/actix-codec/src/lib.rs
+++ b/actix-codec/src/lib.rs
@@ -11,14 +11,18 @@
 #![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 tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-pub use tokio_util::codec::{Decoder, Encoder};
-pub use tokio_util::io::poll_read_buf;
-
-pub use self::bcodec::BytesCodec;
-pub use self::framed::{Framed, FramedParts};
-pub use self::lines::LinesCodec;
+pub use self::{
+    bcodec::BytesCodec,
+    framed::{Framed, FramedParts},
+    lines::LinesCodec,
+};
--- a/actix-codec/tests/test_framed_sink.rs
+++ b/actix-codec/tests/test_framed_sink.rs
@@ -81,10 +81,7 @@ impl AsyncWrite for Bilateral {
            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!()
    }
 }
--- a/actix-macros/CHANGES.md
+++ b/actix-macros/CHANGES.md
@@ -1,47 +1,50 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased

- Minimum supported Rust version (MSRV) is now 1.59.
+## 0.2.4

-## 0.2.3 - 2021-10-19
+- 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 - 2021-10-14
+## 0.2.2

 - Improve error recovery potential when macro input is invalid. [#391]
 - Allow custom `System`s on test macro. [#391]

 [#391]: https://github.com/actix/actix-net/pull/391

-## 0.2.1 - 2021-02-02
+## 0.2.1

 - Add optional argument `system` to `main` macro which can be used to specify the path to `actix_rt::System` (useful for re-exports). [#363]

 [#363]: https://github.com/actix/actix-net/pull/363

-## 0.2.0 - 2021-02-02
+## 0.2.0

 - Update to latest `actix_rt::System::new` signature. [#261]

 [#261]: https://github.com/actix/actix-net/pull/261

-## 0.2.0-beta.1 - 2021-01-09
+## 0.2.0-beta.1

 - Remove `actix-reexport` feature. [#218]

 [#218]: https://github.com/actix/actix-net/pull/218

-## 0.1.3 - 2020-12-03
+## 0.1.3

 - Add `actix-reexport` feature. [#218]

 [#218]: https://github.com/actix/actix-net/pull/218

-## 0.1.2 - 2020-05-18
+## 0.1.2

 - Forward actix_rt::test arguments to test function [#127]

--- a/actix-macros/Cargo.toml
+++ b/actix-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-macros"
-version = "0.2.3"
+version = "0.2.4"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Ibraheem Ahmed <ibrah1440@gmail.com>",
@@ -10,14 +10,15 @@ description = "Macros for Actix system and runtime"
 repository = "https://github.com/actix/actix-net.git"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-edition = "2018"
+edition.workspace = true
+rust-version.workspace = true

 [lib]
 proc-macro = true

 [dependencies]
 quote = "1"
-syn = { version = "1", features = ["full"] }
+syn = { version = "2", features = ["full"] }

 [dev-dependencies]
 actix-rt = "2"
--- a/actix-macros/src/lib.rs
+++ b/actix-macros/src/lib.rs
@@ -15,6 +15,9 @@

 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.
 ///
@@ -25,9 +28,7 @@ use quote::quote;
 ///     println!("Hello world");
 /// }
 /// ```
-#[allow(clippy::needless_doctest_main)]
 #[proc_macro_attribute]
-#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
    let mut input = match syn::parse::<syn::ItemFn>(item.clone()) {
        Ok(input) => input,
@@ -35,7 +36,11 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
        Err(err) => return input_and_compile_error(item, err),
    };

-    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+    let parser = AttributeArgs::parse_terminated;
+    let args = match parser.parse(args.clone()) {
+        Ok(args) => args,
+        Err(err) => return input_and_compile_error(args, err),
+    };

    let attrs = &input.attrs;
    let vis = &input.vis;
@@ -55,11 +60,15 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {

    for arg in &args {
        match arg {
-            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
-                lit: syn::Lit::Str(lit),
+            syn::Meta::NameValue(syn::MetaNameValue {
                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()
@@ -78,6 +87,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
                        .into();
                }
            },
+
            _ => {
                return syn::Error::new_spanned(arg, "Unknown attribute specified")
                    .to_compile_error()
@@ -114,7 +124,11 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
        Err(err) => return input_and_compile_error(item, err),
    };

-    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+    let parser = AttributeArgs::parse_terminated;
+    let args = match parser.parse(args.clone()) {
+        Ok(args) => args,
+        Err(err) => return input_and_compile_error(args, err),
+    };

    let attrs = &input.attrs;
    let vis = &input.vis;
@@ -123,7 +137,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;
        }
    }
@@ -149,11 +163,15 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {

    for arg in &args {
        match arg {
-            syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
-                lit: syn::Lit::Str(lit),
+            syn::Meta::NameValue(syn::MetaNameValue {
                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()
--- a/actix-macros/tests/trybuild.rs
+++ b/actix-macros/tests/trybuild.rs
@@ -1,7 +1,8 @@
-#[rustversion::stable(1.59)] // MSRV
+#[rustversion::stable(1.65)] // 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");
--- a/actix-macros/tests/trybuild/main-02-only-async.stderr
+++ b/actix-macros/tests/trybuild/main-02-only-async.stderr
@@ -1,14 +1,11 @@
 error: the async keyword is missing from the function declaration
- --> $DIR/main-02-only-async.rs:2:1
+ --> tests/trybuild/main-02-only-async.rs:2:1
  |
 2 | fn main() {
  | ^^

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

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx
+
+## 2.9.0
+
+- Add `actix_rt::System::runtime()` method to retrieve the underlying `actix_rt::Runtime` runtime.
+- Add `actix_rt::Runtime::tokio_runtime()` method to retrieve the underlying Tokio runtime.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 2.8.0 - 2022-12-21

--- a/actix-rt/Cargo.toml
+++ b/actix-rt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "2.8.0"
+version = "2.9.0"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
@@ -11,11 +11,8 @@ homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_rt"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [features]
 default = ["macros"]
@@ -26,12 +23,12 @@ io-uring = ["tokio-uring"]
 actix-macros = { version = "0.2.3", optional = true }

 futures-core = { version = "0.3", default-features = false }
-tokio = { version = "1.18.4", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }
+tokio = { version = "1.23.1", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }

 # runtime for `io-uring` feature
 [target.'cfg(target_os = "linux")'.dependencies]
 tokio-uring = { version = "0.4", optional = true }

 [dev-dependencies]
-tokio = { version = "1.18.4", features = ["full"] }
+tokio = { version = "1.23.1", features = ["full"] }
 hyper = { version = "0.14.10", default-features = false, features = ["server", "tcp", "http1"] }
--- a/actix-rt/README.md
+++ b/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.8.0)](https://docs.rs/actix-rt/2.8.0)
+[![Documentation](https://docs.rs/actix-rt/badge.svg?version=2.9.0)](https://docs.rs/actix-rt/2.9.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.8.0/status.svg)](https://deps.rs/crate/actix-rt/2.8.0)
+[![dependency status](https://deps.rs/crate/actix-rt/2.9.0/status.svg)](https://deps.rs/crate/actix-rt/2.9.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)

--- a/actix-rt/examples/hyper.rs
+++ b/actix-rt/examples/hyper.rs
@@ -20,8 +20,7 @@ fn main() {
        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);
+        let server = Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000))).serve(make_service);

        if let Err(err) = server.await {
            eprintln!("server error: {}", err);
--- a/actix-rt/src/arbiter.rs
+++ b/actix-rt/src/arbiter.rs
@@ -99,8 +99,7 @@ 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.")
        })
    }

@@ -149,9 +148,7 @@ 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();

@@ -201,9 +198,7 @@ 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();

--- a/actix-rt/src/lib.rs
+++ b/actix-rt/src/lib.rs
@@ -65,9 +65,11 @@ mod system;
 pub use tokio::pin;
 use tokio::task::JoinHandle;

-pub use self::arbiter::{Arbiter, ArbiterHandle};
-pub use self::runtime::Runtime;
-pub use self::system::{System, SystemRunner};
+pub use self::{
+    arbiter::{Arbiter, ArbiterHandle},
+    runtime::Runtime,
+    system::{System, SystemRunner},
+};

 pub mod signal {
    //! Asynchronous signal handling (Tokio re-exports).
@@ -89,12 +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)]
@@ -153,10 +156,9 @@ pub mod net {
 pub mod time {
    //! Utilities for tracking time (Tokio re-exports).

-    pub use tokio::time::Instant;
-    pub use tokio::time::{interval, interval_at, Interval};
-    pub use tokio::time::{sleep, sleep_until, Sleep};
-    pub use tokio::time::{timeout, Timeout};
+    pub use tokio::time::{
+        interval, interval_at, sleep, sleep_until, timeout, Instant, Interval, Sleep, Timeout,
+    };
 }

 pub mod task {
--- a/actix-rt/src/runtime.rs
+++ b/actix-rt/src/runtime.rs
@@ -61,6 +61,62 @@ 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
--- a/actix-rt/src/system.rs
+++ b/actix-rt/src/system.rs
@@ -203,6 +203,41 @@ impl SystemRunner {
            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
    }

+    /// Retrieves a reference to the underlying Actix 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 [`actix_rt::Runtime`] to spawn tasks on
+    /// the same runtime.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// 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
+    /// ```
+    ///
+    /// Read more in the documentation for [`actix_rt::Runtime`]
+    ///
+    /// # Returns
+    ///
+    /// An immutable reference to the [`actix_rt::Runtime`] instance associated with this
+    /// [`actix_rt::SystemRunner`] instance.
+    ///
+    /// # 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.
+    pub fn runtime(&self) -> &crate::runtime::Runtime {
+        &self.rt
+    }
+
    /// Runs the provided future, blocking the current thread until the future completes.
    #[track_caller]
    #[inline]
@@ -226,9 +261,7 @@ 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.
--- a/actix-server/CHANGES.md
+++ b/actix-server/CHANGES.md
@@ -1,19 +1,24 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased

-## 2.2.0 - 2022-12-21
+## 2.3.0
+
+- Add support for MultiPath TCP (MPTCP) with `MpTcp` enum and `ServerBuilder::mptcp()` method.
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 2.2.0

 - Minimum supported Rust version (MSRV) is now 1.59.
 - Update `tokio-uring` dependency to `0.4`. [#473]

 [#473]: https://github.com/actix/actix-net/pull/473

-## 2.1.1 - 2022-03-09
+## 2.1.1

 - No significant changes since `2.1.0`.

-## 2.1.0 - 2022-03-08
+## 2.1.0

 - Update `tokio-uring` dependency to `0.3`. [#448]
 - Logs emitted now use the `tracing` crate with `log` compatibility. [#448]
@@ -22,27 +27,27 @@
 [#443]: https://github.com/actix/actix-net/pull/443
 [#448]: https://github.com/actix/actix-net/pull/448

-## 2.0.0 - 2022-01-19
+## 2.0.0

 - No significant changes since `2.0.0-rc.4`.

-## 2.0.0-rc.4 - 2022-01-12
+## 2.0.0-rc.4

 - Update `tokio-uring` dependency to `0.2`. [#436]

 [#436]: https://github.com/actix/actix-net/pull/436

-## 2.0.0-rc.3 - 2021-12-31
+## 2.0.0-rc.3

 - No significant changes since `2.0.0-rc.2`.

-## 2.0.0-rc.2 - 2021-12-27
+## 2.0.0-rc.2

 - Simplify `TestServer`. [#431]

 [#431]: https://github.com/actix/actix-net/pull/431

-## 2.0.0-rc.1 - 2021-12-05
+## 2.0.0-rc.1

 - Hide implementation details of `Server`. [#424]
 - `Server` now runs only after awaiting it. [#425]
@@ -50,19 +55,19 @@
 [#424]: https://github.com/actix/actix-net/pull/424
 [#425]: https://github.com/actix/actix-net/pull/425

-## 2.0.0-beta.9 - 2021-11-15
+## 2.0.0-beta.9

 - Restore `Arbiter` support lost in `beta.8`. [#417]

 [#417]: https://github.com/actix/actix-net/pull/417

-## 2.0.0-beta.8 - 2021-11-05 _(YANKED)_
+## 2.0.0-beta.8

 - Fix non-unix signal handler. [#410]

 [#410]: https://github.com/actix/actix-net/pull/410

-## 2.0.0-beta.7 - 2021-11-05 _(YANKED)_
+## 2.0.0-beta.7

 - Server can be started in regular Tokio runtime. [#408]
 - Expose new `Server` type whose `Future` impl resolves when server stops. [#408]
@@ -75,7 +80,7 @@
 [#407]: https://github.com/actix/actix-net/pull/407
 [#408]: https://github.com/actix/actix-net/pull/408

-## 2.0.0-beta.6 - 2021-10-11
+## 2.0.0-beta.6

 - 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]
@@ -86,19 +91,19 @@
 [#349]: https://github.com/actix/actix-net/pull/349
 [#389]: https://github.com/actix/actix-net/pull/389

-## 2.0.0-beta.5 - 2021-04-20
+## 2.0.0-beta.5

 - Server shutdown notifies all workers to exit regardless if shutdown is graceful. This causes all workers to shutdown immediately in force shutdown case. [#333]

 [#333]: https://github.com/actix/actix-net/pull/333

-## 2.0.0-beta.4 - 2021-04-01
+## 2.0.0-beta.4

 - Prevent panic when `shutdown_timeout` is very large. [f9262db]

 [f9262db]: https://github.com/actix/actix-net/commit/f9262db

-## 2.0.0-beta.3 - 2021-02-06
+## 2.0.0-beta.3

 - Hidden `ServerBuilder::start` method has been removed. Use `ServerBuilder::run`. [#246]
 - Add retry for EINTR signal (`io::Interrupted`) in `Accept`'s poll loop. [#264]
@@ -110,13 +115,13 @@
 [#265]: https://github.com/actix/actix-net/pull/265
 [#273]: https://github.com/actix/actix-net/pull/273

-## 2.0.0-beta.2 - 2021-01-03
+## 2.0.0-beta.2

 - Merge `actix-testing` to `actix-server` as `test_server` mod. [#242]

 [#242]: https://github.com/actix/actix-net/pull/242

-## 2.0.0-beta.1 - 2020-12-28
+## 2.0.0-beta.1

 - Added explicit info log message on accept queue pause. [#215]
 - Prevent double registration of sockets when back-pressure is resolved. [#223]
@@ -131,127 +136,127 @@
 [#223]: https://github.com/actix/actix-net/pull/223
 [#239]: https://github.com/actix/actix-net/pull/239

-## 1.0.4 - 2020-09-12
+## 1.0.4

 - Update actix-codec to 0.3.0.
 - Workers must be greater than 0. [#167]

 [#167]: https://github.com/actix/actix-net/pull/167

-## 1.0.3 - 2020-05-19
+## 1.0.3

 - Replace deprecated `net2` crate with `socket2` [#140]

 [#140]: https://github.com/actix/actix-net/pull/140

-## 1.0.2 - 2020-02-26
+## 1.0.2

 - Avoid error by calling `reregister()` on Windows [#103]

 [#103]: https://github.com/actix/actix-net/pull/103

-## 1.0.1 - 2019-12-29
+## 1.0.1

 - Rename `.start()` method to `.run()`

-## 1.0.0 - 2019-12-11
+## 1.0.0

 - Use actix-net releases

-## 1.0.0-alpha.4 - 2019-12-08
+## 1.0.0-alpha.4

 - Use actix-service 1.0.0-alpha.4

-## 1.0.0-alpha.3 - 2019-12-07
+## 1.0.0-alpha.3

 - Migrate to tokio 0.2
 - Fix compilation on non-unix platforms
 - Better handling server configuration

-## 1.0.0-alpha.2 - 2019-12-02
+## 1.0.0-alpha.2

 - Simplify server service (remove actix-server-config)
 - Allow to wait on `Server` until server stops

-## 0.8.0-alpha.1 - 2019-11-22
+## 0.8.0-alpha.1

 - Migrate to `std::future`

-## 0.7.0 - 2019-10-04
+## 0.7.0

 - Update `rustls` to 0.16
 - Minimum required Rust version upped to 1.37.0

-## 0.6.1 - 2019-09-25
+## 0.6.1

 - Add UDS listening support to `ServerBuilder`

-## 0.6.0 - 2019-07-18
+## 0.6.0

 - Support Unix domain sockets #3

-## 0.5.1 - 2019-05-18
+## 0.5.1

 - ServerBuilder::shutdown_timeout() accepts u64

-## 0.5.0 - 2019-05-12
+## 0.5.0

 - Add `Debug` impl for `SslError`
 - Derive debug for `Server` and `ServerCommand`
 - Upgrade to actix-service 0.4

-## 0.4.3 - 2019-04-16
+## 0.4.3

 - Re-export `IoStream` trait
 - Depend on `ssl` and `rust-tls` features from actix-server-config

-## 0.4.2 - 2019-03-30
+## 0.4.2

 - Fix SIGINT force shutdown

-## 0.4.1 - 2019-03-14
+## 0.4.1

 - `SystemRuntime::on_start()` - allow to run future before server service initialization

-## 0.4.0 - 2019-03-12
+## 0.4.0

 - Use `ServerConfig` for service factory
 - Wrap tcp socket to `Io` type
 - Upgrade actix-service

-## 0.3.1 - 2019-03-04
+## 0.3.1

 - Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
 - Add helper ssl error `SslError`
 - Rename `StreamServiceFactory` to `ServiceFactory`
 - Deprecate `StreamServiceFactory`

-## 0.3.0 - 2019-03-02
+## 0.3.0

 - Use new `NewService` trait

-## 0.2.1 - 2019-02-09
+## 0.2.1

 - Drop service response

-## 0.2.0 - 2019-02-01
+## 0.2.0

 - Migrate to actix-service 0.2
 - Updated rustls dependency

-## 0.1.3 - 2018-12-21
+## 0.1.3

 - Fix max concurrent connections handling

-## 0.1.2 - 2018-12-12
+## 0.1.2

 - rename ServiceConfig::rt() to ServiceConfig::apply()
 - Fix back-pressure for concurrent ssl handshakes

-## 0.1.1 - 2018-12-11
+## 0.1.1

 - Fix signal handling on windows

-## 0.1.0 - 2018-12-09
+## 0.1.0

 - Move server to separate crate
--- a/actix-server/Cargo.toml
+++ b/actix-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "2.2.0"
+version = "2.3.0"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
@@ -12,11 +12,8 @@ categories = ["network-programming", "asynchronous"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_server"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [features]
 default = []
@@ -30,9 +27,8 @@ actix-utils = "3"
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
 mio = { version = "0.8", features = ["os-poll", "net"] }
-num_cpus = "1.13"
-socket2 = "0.4.2"
-tokio = { version = "1.18.4", features = ["sync"] }
+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
@@ -46,4 +42,4 @@ actix-rt = "2.8"
 bytes = "1"
 env_logger = "0.10"
 futures-util = { version = "0.3.17", default-features = false, features = ["sink", "async-await-macro"] }
-tokio = { version = "1.18.4", features = ["io-util", "rt-multi-thread", "macros", "fs"] }
+tokio = { version = "1.23.1", features = ["io-util", "rt-multi-thread", "macros", "fs"] }
--- a/actix-server/README.md
+++ b/actix-server/README.md
@@ -3,10 +3,10 @@
 > General purpose TCP server built for the Actix ecosystem.

 [![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.2.0)](https://docs.rs/actix-server/2.2.0)
+[![Documentation](https://docs.rs/actix-server/badge.svg?version=2.3.0)](https://docs.rs/actix-server/2.3.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)
 ![License](https://img.shields.io/crates/l/actix-server.svg)
-[![Dependency Status](https://deps.rs/crate/actix-server/2.2.0/status.svg)](https://deps.rs/crate/actix-server/2.2.0)
+[![Dependency Status](https://deps.rs/crate/actix-server/2.3.0/status.svg)](https://deps.rs/crate/actix-server/2.3.0)
 ![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)

--- a/actix-server/src/builder.rs
+++ b/actix-server/src/builder.rs
@@ -1,4 +1,4 @@
-use std::{io, time::Duration};
+use std::{io, num::NonZeroUsize, time::Duration};

 use actix_rt::net::TcpStream;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
@@ -7,13 +7,27 @@ use tracing::{info, trace};
 use crate::{
    server::ServerCommand,
    service::{InternalServiceFactory, ServerServiceFactory, 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.
+///
+/// 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,
@@ -21,6 +35,7 @@ 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>,
@@ -40,11 +55,12 @@ impl ServerBuilder {
        let (cmd_tx, cmd_rx) = unbounded_channel();

        ServerBuilder {
-            threads: num_cpus::get_physical(),
+            threads: std::thread::available_parallelism().map_or(2, NonZeroUsize::get),
            token: 0,
            factories: Vec::new(),
            sockets: Vec::new(),
            backlog: 2048,
+            mptcp: MpTcp::Disabled,
            exit: false,
            listen_os_signals: true,
            cmd_tx,
@@ -60,6 +76,12 @@ impl ServerBuilder {
    /// The default worker count is the number of physical CPU cores available. If your benchmark
    /// testing indicates that simultaneous multi-threading is beneficial to your app, you can use
    /// the [`num_cpus`] crate to acquire the _logical_ core count instead.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `num` is 0.
+    ///
+    /// [`num_cpus`]: https://docs.rs/num_cpus
    pub fn workers(mut self, num: usize) -> Self {
        assert_ne!(num, 0, "workers must be greater than 0");
        self.threads = num;
@@ -98,6 +120,24 @@ 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
@@ -146,7 +186,7 @@ impl ServerBuilder {
        U: ToSocketAddrs,
        N: AsRef<str>,
    {
-        let sockets = bind_addr(addr, self.backlog)?;
+        let sockets = bind_addr(addr, self.backlog, &self.mptcp)?;

        trace!("binding server to: {:?}", &sockets);

@@ -246,8 +286,7 @@ impl ServerBuilder {
        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,
@@ -263,13 +302,14 @@ 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 success = false;
    let mut sockets = Vec::new();

    for addr in addr.to_socket_addrs()? {
-        match create_mio_tcp_listener(addr, backlog) {
+        match create_mio_tcp_listener(addr, backlog, mptcp) {
            Ok(lst) => {
                success = true;
                sockets.push(lst);
--- a/actix-server/src/lib.rs
+++ b/actix-server/src/lib.rs
@@ -18,13 +18,15 @@ 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::ServerServiceFactory;
 #[doc(hidden)]
 pub use self::socket::FromStream;
-pub use self::test_server::TestServer;
+pub use self::{
+    builder::{MpTcp, ServerBuilder},
+    handle::ServerHandle,
+    server::Server,
+    service::ServerServiceFactory,
+    test_server::TestServer,
+};

 /// Start server building process
 #[doc(hidden)]
--- a/actix-server/src/service.rs
+++ b/actix-server/src/service.rs
@@ -78,7 +78,7 @@ where
                Ok(())
            }
            Err(err) => {
-                error!("can not convert to an async TCP stream: {}", err);
+                error!("can not convert to an async TCP stream: {err}");
                Err(())
            }
        })
--- a/actix-server/src/socket.rs
+++ b/actix-server/src/socket.rs
@@ -8,10 +8,11 @@ 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,
+    mio::net::UnixListener as MioUnixListener, std::os::unix::net::UnixListener as StdUnixListener,
 };

+use crate::builder::MpTcp;
+
 pub(crate) enum MioListener {
    Tcp(MioTcpListener),
    #[cfg(unix)]
@@ -105,7 +106,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(all(unix))]
+            #[cfg(unix)]
            MioListener::Uds(ref lst) => write!(f, "{:?}", lst),
        }
    }
@@ -224,10 +225,30 @@ 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};

-    let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
+    #[cfg(not(target_os = "linux"))]
+    let protocol = Protocol::TCP;
+    #[cfg(target_os = "linux")]
+    let protocol = if matches!(mptcp, MpTcp::Disabled) {
+        Protocol::TCP
+    } else {
+        Protocol::MPTCP
+    };
+
+    let socket = match Socket::new(Domain::for_address(addr), Type::STREAM, Some(protocol)) {
+        Ok(sock) => sock,
+
+        Err(err) if matches!(mptcp, MpTcp::TcpFallback) => {
+            tracing::warn!("binding socket as MPTCP failed: {err}");
+            tracing::warn!("falling back to TCP");
+            Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?
+        }
+
+        Err(err) => return Err(err),
+    };

    socket.set_reuse_address(true)?;
    socket.set_nonblocking(true)?;
@@ -248,7 +269,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).unwrap();
+        let lst = create_mio_tcp_listener(addr, 128, &MpTcp::Disabled).unwrap();
        let lst = MioListener::Tcp(lst);
        assert!(format!("{:?}", lst).contains("TcpListener"));
        assert!(format!("{}", lst).contains("127.0.0.1"));
--- a/actix-server/src/test_server.rs
+++ b/actix-server/src/test_server.rs
@@ -117,7 +117,7 @@ impl TestServerHandle {

    /// Stop server.
    fn stop(&mut self) {
-        let _ = self.server_handle.stop(false);
+        drop(self.server_handle.stop(false));
        self.thread_handle.take().unwrap().join().unwrap().unwrap();
    }

--- a/actix-server/src/worker.rs
+++ b/actix-server/src/worker.rs
@@ -1,6 +1,7 @@
 use std::{
    future::Future,
    io, mem,
+    num::NonZeroUsize,
    pin::Pin,
    rc::Rc,
    sync::{
@@ -249,8 +250,11 @@ pub(crate) struct ServerWorkerConfig {

 impl Default for ServerWorkerConfig {
    fn default() -> Self {
-        // 512 is the default max blocking thread count of tokio runtime.
-        let max_blocking_threads = std::cmp::max(512 / num_cpus::get_physical(), 1);
+        let parallelism = std::thread::available_parallelism().map_or(2, NonZeroUsize::get);
+
+        // 512 is the default max blocking thread count of a Tokio runtime.
+        let max_blocking_threads = std::cmp::max(512 / parallelism, 1);
+
        Self {
            shutdown_timeout: Duration::from_secs(30),
            max_blocking_threads,
@@ -621,12 +625,13 @@ 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) = ready!(restart.fut.as_mut().poll(cx))
-                    .unwrap_or_else(|_| {
+                let (token_new, service) =
+                    ready!(restart.fut.as_mut().poll(cx)).unwrap_or_else(|_| {
                        panic!(
                            "Can not restart {:?} service",
                            this.factories[factory_id].name(token)
@@ -645,6 +650,7 @@ 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) {
@@ -678,6 +684,7 @@ 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) {
@@ -697,7 +704,10 @@ impl Future for ServerWorker {
                match ready!(this.conn_rx.poll_recv(cx)) {
                    Some(msg) => {
                        let guard = this.counter.guard();
-                        let _ = this.services[msg.token].service.call((guard, msg.io));
+                        let _ = this.services[msg.token]
+                            .service
+                            .call((guard, msg.io))
+                            .into_inner();
                    }
                    None => return Poll::Ready(()),
                };
@@ -706,9 +716,7 @@ 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)| {
--- a/actix-server/tests/server.rs
+++ b/actix-server/tests/server.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::let_underscore_future)]
+
 use std::{
    net,
    sync::{
--- a/actix-service/CHANGES.md
+++ b/actix-service/CHANGES.md
@@ -1,8 +1,8 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

- Minimum supported Rust version (MSRV) is now 1.59.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 2.0.2 - 2021-12-18

--- a/actix-service/Cargo.toml
+++ b/actix-service/Cargo.toml
@@ -10,11 +10,8 @@ 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 = "2018"
-
-[lib]
-name = "actix_service"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
 futures-core = { version = "0.3.17", default-features = false }
--- a/actix-service/src/and_then.rs
+++ b/actix-service/src/and_then.rs
@@ -121,12 +121,7 @@ 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>,
@@ -136,12 +131,7 @@ 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 {
@@ -156,12 +146,7 @@ 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;
@@ -184,12 +169,7 @@ 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 {
@@ -334,9 +314,8 @@ 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())))))
-                .and_then(move || ready(Ok(Srv2(cnt.clone()))));
+        let new_srv = pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
+            .and_then(move || ready(Ok(Srv2(cnt.clone()))));

        let srv = new_srv.new_service(()).await.unwrap();
        let res = srv.call("srv1").await;
--- a/actix-service/src/apply.rs
+++ b/actix-service/src/apply.rs
@@ -140,8 +140,7 @@ 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,
--- a/actix-service/src/apply_cfg.rs
+++ b/actix-service/src/apply_cfg.rs
@@ -198,8 +198,7 @@ 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>,
--- a/actix-service/src/boxed.rs
+++ b/actix-service/src/boxed.rs
@@ -91,8 +91,7 @@ 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,
--- a/actix-service/src/fn_service.rs
+++ b/actix-service/src/fn_service.rs
@@ -3,9 +3,7 @@ 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>>,
@@ -48,9 +46,7 @@ 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>>,
@@ -265,8 +261,7 @@ 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>>,
@@ -404,9 +399,8 @@ mod tests {
            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))))
-        });
+        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) {}

--- a/actix-service/src/lib.rs
+++ b/actix-service/src/lib.rs
@@ -33,14 +33,16 @@ 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};
 #[allow(unused_imports)]
 use self::ready::{err, ok, ready, Ready};
-pub use self::transform::{apply, ApplyTransform, Transform};
+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`.
 ///
--- a/actix-service/src/map_err.rs
+++ b/actix-service/src/map_err.rs
@@ -206,8 +206,7 @@ mod tests {

    use super::*;
    use crate::{
-        err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory,
-        ServiceFactoryExt,
+        err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt,
    };

    struct Srv;
--- a/actix-service/src/pipeline.rs
+++ b/actix-service/src/pipeline.rs
@@ -6,12 +6,14 @@ use core::{
    task::{Context, Poll},
 };

-use crate::and_then::{AndThenService, AndThenServiceFactory};
-use crate::map::{Map, MapServiceFactory};
-use crate::map_err::{MapErr, MapErrServiceFactory};
-use crate::map_init_err::MapInitErr;
-use crate::then::{ThenService, ThenServiceFactory};
-use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
+use crate::{
+    and_then::{AndThenService, AndThenServiceFactory},
+    map::{Map, MapServiceFactory},
+    map_err::{MapErr, MapErrServiceFactory},
+    map_init_err::MapInitErr,
+    then::{ThenService, ThenServiceFactory},
+    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>
@@ -252,10 +254,7 @@ 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,
--- a/actix-tls/CHANGES.md
+++ b/actix-tls/CHANGES.md
@@ -1,40 +1,49 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased

- Minimum supported Rust version (MSRV) is now 1.59.
+## 3.1.1

-## 3.0.4 - 2022-03-15
+- Fix `rustls` v0.21 version requirement.
+
+## 3.1.0
+
+- Support Rustls v0.21.
+- Added `{accept, connect}::rustls_0_21` modules.
+- Added `{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 - 2022-02-15
+## 3.0.3

 - No significant changes since `3.0.2`.

-## 3.0.2 - 2022-01-28
+## 3.0.2

 - Expose `connect::Connection::new`. [#439]

 [#439]: https://github.com/actix/actix-net/pull/439

-## 3.0.1 - 2022-01-11
+## 3.0.1

 - No significant changes since `3.0.0`.

-## 3.0.0 - 2021-12-26
+## 3.0.0

 - No significant changes since `3.0.0-rc.2`.

-## 3.0.0-rc.2 - 2021-12-10
+## 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 - 2021-11-29
+## 3.0.0-rc.1

 ### Added

@@ -72,7 +81,7 @@
 [#422]: https://github.com/actix/actix-net/pull/422
 [#423]: https://github.com/actix/actix-net/pull/423

-## 3.0.0-beta.9 - 2021-11-22
+## 3.0.0-beta.9

 - Add configurable timeout for accepting TLS connection. [#393]
 - Added `TlsError::Timeout` variant. [#393]
@@ -82,20 +91,20 @@
 [#393]: https://github.com/actix/actix-net/pull/393
 [#420]: https://github.com/actix/actix-net/pull/420

-## 3.0.0-beta.8 - 2021-11-15
+## 3.0.0-beta.8

 - 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 - 2021-10-20
+## 3.0.0-beta.7

 - 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 - 2021-10-19
+## 3.0.0-beta.6

 - Update `tokio-rustls` to `0.23` which uses `rustls` `0.20`. [#396]
 - Removed a re-export of `Session` from `rustls` as it no longer exist. [#396]
@@ -103,7 +112,7 @@

 [#396]: https://github.com/actix/actix-net/pull/396

-## 3.0.0-beta.5 - 2021-03-29
+## 3.0.0-beta.5

 - Changed `connect::ssl::rustls::RustlsConnectorService` to return error when `DNSNameRef` generation failed instead of panic. [#296]
 - Remove `connect::ssl::openssl::OpensslConnectServiceFactory`. [#297]
@@ -117,7 +126,7 @@
 [#297]: https://github.com/actix/actix-net/pull/297
 [#299]: https://github.com/actix/actix-net/pull/299

-## 3.0.0-beta.4 - 2021-02-24
+## 3.0.0-beta.4

 - Rename `accept::openssl::{SslStream => TlsStream}`.
 - Add `connect::Connect::set_local_addr` to attach local `IpAddr`. [#282]
@@ -125,7 +134,7 @@

 [#282]: https://github.com/actix/actix-net/pull/282

-## 3.0.0-beta.3 - 2021-02-06
+## 3.0.0-beta.3

 - Remove `trust-dns-proto` and `trust-dns-resolver`. [#248]
 - Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248]
@@ -139,13 +148,13 @@
 [#248]: https://github.com/actix/actix-net/pull/248
 [#273]: https://github.com/actix/actix-net/pull/273

-## 3.0.0-beta.2 - 2022-xx-xx
+## 3.0.0-beta.2

 - Depend on stable trust-dns packages. [#204]

 [#204]: https://github.com/actix/actix-net/pull/204

-## 3.0.0-beta.1 - 2020-12-29
+## 3.0.0-beta.1

 - Move acceptors under `accept` module. [#238]
 - Merge `actix-connect` crate under `connect` module. [#238]
@@ -153,7 +162,7 @@

 [#238]: https://github.com/actix/actix-net/pull/238

-## 2.0.0 - 2020-09-03
+## 2.0.0

 - `nativetls::NativeTlsAcceptor` is renamed to `nativetls::Acceptor`.
 - Where possible, "SSL" terminology is replaced with "TLS".
@@ -161,28 +170,28 @@
  - `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 - 2020-08-17
+## 2.0.0-alpha.2

 - Update `rustls` dependency to 0.18
 - Update `tokio-rustls` dependency to 0.14
 - Update `webpki-roots` dependency to 0.20

-## [2.0.0-alpha.1] - 2020-03-03
+## [2.0.0-alpha.1]

 - Update `rustls` dependency to 0.17
 - Update `tokio-rustls` dependency to 0.13
 - Update `webpki-roots` dependency to 0.19

-## [1.0.0] - 2019-12-11
+## [1.0.0]

 - 1.0.0 release

-## [1.0.0-alpha.3] - 2019-12-07
+## [1.0.0-alpha.3]

 - Migrate to tokio 0.2
 - Enable rustls acceptor service
 - Enable native-tls acceptor service

-## [1.0.0-alpha.1] - 2019-12-02
+## [1.0.0-alpha.1]

 - Split openssl acceptor from actix-server package
--- a/actix-tls/Cargo.toml
+++ b/actix-tls/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-tls"
-version = "3.0.4"
+version = "3.1.1"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
@@ -9,16 +9,19 @@ 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"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true

 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

-[lib]
-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"]
@@ -32,8 +35,14 @@ connect = []
 # use openssl impls
 openssl = ["tls-openssl", "tokio-openssl"]

-# use rustls impls
-rustls = ["tokio-rustls", "webpki-roots"]
+# alias for backwards compat
+rustls = ["rustls-0_20"]
+
+# use rustls v0.20 impls
+rustls-0_20 = ["tokio-rustls-023", "webpki-roots-022"]
+
+# use rustls v0.21 impls
+rustls-0_21 = ["tokio-rustls-024", "webpki-roots-025"]

 # use native-tls impls
 native-tls = ["tokio-native-tls"]
@@ -42,14 +51,14 @@ native-tls = ["tokio-native-tls"]
 uri = ["http"]

 [dependencies]
-actix-rt = { version = "2.2.0", default-features = false }
+actix-rt = { version = "2.2", default-features = false }
 actix-service = "2"
 actix-utils = "3"

 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 impl-more = "0.1"
 pin-project-lite = "0.2.7"
-tokio = "1.18.4"
+tokio = "1.23.1"
 tokio-util = "0.7"
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }

@@ -57,12 +66,18 @@ tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 http = { version = "0.2.3", optional = true }

 # openssl
-tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
+tls-openssl = { package = "openssl", version = "0.10.55", optional = true }
 tokio-openssl = { version = "0.6", optional = true }

-# rustls
-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 }
+webpki-roots-022 = { package = "webpki-roots", version = "0.22", optional = true }
+
+# rustls v0.21
+rustls-021 = { package = "rustls", version = "0.21.6" }
+rustls-webpki-0101 = { package = "rustls-webpki", version = "0.101.4" }
+tokio-rustls-024 = { package = "tokio-rustls", version = "0.24", optional = true }
+webpki-roots-025 = { package = "webpki-roots", version = "0.25", optional = true }

 # native-tls
 tokio-native-tls = { version = "0.3", optional = true }
@@ -74,12 +89,11 @@ actix-server = "2"
 bytes = "1"
 env_logger = "0.10"
 futures-util = { version = "0.3.17", default-features = false, features = ["sink"] }
-log = "0.4"
-rcgen = "0.10"
+rcgen = "0.11"
 rustls-pemfile = "1"
-tokio-rustls = { version = "0.23", features = ["dangerous_configuration"] }
-trust-dns-resolver = "0.22"
+tokio-rustls-024 = { package = "tokio-rustls", version = "0.24", features = ["dangerous_configuration"] }
+trust-dns-resolver = "0.23"

 [[example]]
 name = "accept-rustls"
-required-features = ["accept", "rustls"]
+required-features = ["accept", "rustls-0_21"]
--- a/actix-tls/examples/accept-rustls.rs
+++ b/actix-tls/examples/accept-rustls.rs
@@ -17,13 +17,13 @@

 #[rustfmt::skip]
 // this `use` is only exists because of how we have organised the crate
-// it is not necessary for your actual code; you should import from `rustls` directly
-use tokio_rustls::rustls;
+// it is not necessary for your actual code; you should import from `rustls` normally
+use tokio_rustls_024::rustls;

 use std::{
-    env,
    fs::File,
    io::{self, BufReader},
+    path::PathBuf,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc,
@@ -33,7 +33,7 @@ use std::{
 use actix_rt::net::TcpStream;
 use actix_server::Server;
 use actix_service::ServiceFactoryExt as _;
-use actix_tls::accept::rustls::{Acceptor as RustlsAcceptor, TlsStream};
+use actix_tls::accept::rustls_0_21::{Acceptor as RustlsAcceptor, TlsStream};
 use futures_util::future::ok;
 use rustls::{server::ServerConfig, Certificate, PrivateKey};
 use rustls_pemfile::{certs, rsa_private_keys};
@@ -43,9 +43,16 @@ use tracing::info;
 async fn main() -> io::Result<()> {
    env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));

+    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("./examples/cert.pem").unwrap());
-    let key_file = &mut BufReader::new(File::open("./examples/key.pem").unwrap());
+    let cert_file = &mut BufReader::new(File::open(cert_path).unwrap());
+    let key_file = &mut BufReader::new(File::open(key_path).unwrap());

    let cert_chain = certs(cert_file)
        .unwrap()
@@ -65,7 +72,7 @@ async fn main() -> io::Result<()> {
    let count = Arc::new(AtomicUsize::new(0));

    let addr = ("127.0.0.1", 8443);
-    info!("starting server on port: {}", &addr.0);
+    info!("starting server at: {addr:?}");

    Server::build()
        .bind("tls-example", addr, move || {
--- a/actix-tls/src/accept/mod.rs
+++ b/actix-tls/src/accept/mod.rs
@@ -10,20 +10,29 @@ use std::{
 use actix_utils::counter::Counter;

 #[cfg(feature = "openssl")]
-#[cfg_attr(docsrs, doc(cfg(feature = "openssl")))]
 pub mod openssl;

-#[cfg(feature = "rustls")]
-#[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
-pub mod rustls;
+#[cfg(feature = "rustls-0_20")]
+pub mod rustls_0_20;
+
+#[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 = "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(feature = "openssl", feature = "rustls", feature = "native-tls"))]
+#[cfg(any(
+    feature = "openssl",
+    feature = "rustls-0_20",
+    feature = "rustls-0_21",
+    feature = "native-tls",
+))]
 pub(crate) const DEFAULT_TLS_HANDSHAKE_TIMEOUT: std::time::Duration =
    std::time::Duration::from_secs(3);

@@ -59,6 +68,25 @@ pub enum TlsError<TlsErr, SvcErr> {
    Service(SvcErr),
 }

+impl<TlsErr> TlsError<TlsErr, Infallible> {
+    /// Casts the infallible service error type returned from acceptors into caller's type.
+    ///
+    /// # Examples
+    /// ```
+    /// # use std::convert::Infallible;
+    /// # use actix_tls::accept::TlsError;
+    /// let a: TlsError<u32, Infallible> = TlsError::Tls(42);
+    /// let _b: TlsError<u32, u64> = a.into_service_error();
+    /// ```
+    pub fn into_service_error<SvcErr>(self) -> TlsError<TlsErr, SvcErr> {
+        match self {
+            Self::Timeout => TlsError::Timeout,
+            Self::Tls(err) => TlsError::Tls(err),
+            Self::Service(err) => match err {},
+        }
+    }
+}
+
 impl<TlsErr, SvcErr> fmt::Display for TlsError<TlsErr, SvcErr> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
@@ -83,25 +111,6 @@ where
    }
 }

-impl<TlsErr> TlsError<TlsErr, Infallible> {
-    /// Casts the infallible service error type returned from acceptors into caller's type.
-    ///
-    /// # Examples
-    /// ```
-    /// # use std::convert::Infallible;
-    /// # use actix_tls::accept::TlsError;
-    /// let a: TlsError<u32, Infallible> = TlsError::Tls(42);
-    /// let _b: TlsError<u32, u64> = a.into_service_error();
-    /// ```
-    pub fn into_service_error<SvcErr>(self) -> TlsError<TlsErr, SvcErr> {
-        match self {
-            Self::Timeout => TlsError::Timeout,
-            Self::Tls(err) => TlsError::Tls(err),
-            Self::Service(err) => match err {},
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/actix-tls/src/accept/native_tls.rs
+++ b/actix-tls/src/accept/native_tls.rs
@@ -73,17 +73,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)
    }
 }

--- a/actix-tls/src/accept/openssl.rs
+++ b/actix-tls/src/accept/openssl.rs
@@ -76,17 +76,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)
    }
 }

--- a/actix-tls/src/accept/rustls_0_20.rs
+++ b/actix-tls/src/accept/rustls_0_20.rs
@@ -1,4 +1,4 @@
-//! `rustls` based TLS connection acceptor service.
+//! `rustls` v0.20 based TLS connection acceptor service.
 //!
 //! See [`Acceptor`] for main service factory docs.

@@ -23,15 +23,15 @@ use actix_utils::{
 };
 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::{rustls::ServerConfig, 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::rustls::ServerConfig;
+    pub use tokio_rustls_023::rustls::ServerConfig;
 }

 /// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`].
@@ -76,17 +76,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().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)
    }
 }

--- a/actix-tls/src/accept/rustls_0_21.rs
+++ b/actix-tls/src/accept/rustls_0_21.rs
@@ -0,0 +1,198 @@
+//! `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::{rustls::ServerConfig, 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<ServerConfig>,
+    handshake_timeout: Duration,
+}
+
+impl Acceptor {
+    /// Constructs `rustls` based acceptor service factory.
+    pub fn new(config: 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)),
+        }
+    }
+}
--- a/actix-tls/src/connect/mod.rs
+++ b/actix-tls/src/connect/mod.rs
@@ -22,25 +22,30 @@ 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(feature = "rustls")]
-#[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
-pub mod rustls;
+#[cfg(feature = "rustls-0_20")]
+pub mod rustls_0_20;
+
+#[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 = "native-tls")]
-#[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
 pub mod native_tls;

-pub use self::connection::Connection;
-pub use self::connector::{Connector, ConnectorService};
-pub use self::error::ConnectError;
-pub use self::host::Host;
-pub use self::info::ConnectInfo;
-pub use self::resolve::Resolve;
-pub use self::resolver::{Resolver, ResolverService};
+pub use self::{
+    connection::Connection,
+    connector::{Connector, ConnectorService},
+    error::ConnectError,
+    host::Host,
+    info::ConnectInfo,
+    resolve::Resolve,
+    resolver::{Resolver, ResolverService},
+};
--- a/actix-tls/src/connect/native_tls.rs
+++ b/actix-tls/src/connect/native_tls.rs
@@ -19,8 +19,7 @@ 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;
-    pub use tokio_native_tls::TlsStream as AsyncTlsStream;
+    pub use tokio_native_tls::{native_tls::TlsConnector, TlsStream as AsyncTlsStream};
 }

 /// Connector service and factory using `native-tls`.
--- a/actix-tls/src/connect/openssl.rs
+++ b/actix-tls/src/connect/openssl.rs
@@ -22,9 +22,7 @@ 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, SslConnectorBuilder, SslMethod};
    pub use tokio_openssl::SslStream as AsyncSslStream;
 }

--- a/actix-tls/src/connect/rustls_0_20.rs
+++ b/actix-tls/src/connect/rustls_0_20.rs
@@ -15,26 +15,26 @@ use actix_rt::net::ActixStream;
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ok, Ready};
 use futures_core::ready;
-use tokio_rustls::rustls::{client::ServerName, OwnedTrustAnchor, RootCertStore};
-use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
-use tokio_rustls::{Connect as RustlsConnect, TlsConnector as RustlsTlsConnector};
-use tracing::trace;
-use webpki_roots::TLS_SERVER_ROOTS;
+use tokio_rustls::{
+    client::TlsStream as AsyncTlsStream,
+    rustls::{client::ServerName, ClientConfig, OwnedTrustAnchor, RootCertStore},
+    Connect as RustlsConnect, TlsConnector as RustlsTlsConnector,
+};
+use tokio_rustls_023 as tokio_rustls;

 use crate::connect::{Connection, Host};

 pub mod reexports {
    //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors.

-    pub use tokio_rustls::client::TlsStream as AsyncTlsStream;
-    pub use tokio_rustls::rustls::ClientConfig;
-    pub use webpki_roots::TLS_SERVER_ROOTS;
+    pub use tokio_rustls_023::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
+    pub use webpki_roots_022::TLS_SERVER_ROOTS;
 }

 /// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
 pub fn webpki_roots_cert_store() -> RootCertStore {
    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(
            cert.subject,
            cert.spki,
@@ -101,12 +101,13 @@ where
    actix_service::always_ready!();

    fn call(&self, connection: Connection<R, IO>) -> Self::Future {
-        trace!("TLS handshake start for: {:?}", connection.hostname());
+        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(self.connector.clone()).connect(host, stream),
+                connect: RustlsTlsConnector::from(Arc::clone(&self.connector))
+                    .connect(host, stream),
                connection: Some(connection),
            },
            Err(_) => ConnectFut::InvalidDns,
@@ -116,6 +117,7 @@ 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,
@@ -130,17 +132,23 @@ where
    R: Host,
    IO: ActixStream,
 {
-    type Output = Result<Connection<R, AsyncTlsStream<IO>>, io::Error>;
+    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::InvalidDns => Poll::Ready(Err(
-                io::Error::new(io::ErrorKind::Other, "rustls currently only handles hostname-based connections. See https://github.com/briansmith/webpki/issues/54")
-            )),
-            Self::Future { connect, connection } => {
+            Self::InvalidDns => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::Other,
+                "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,
+            } => {
                let stream = ready!(Pin::new(connect).poll(cx))?;
                let connection = connection.take().unwrap();
-                trace!("TLS handshake success: {:?}", connection.hostname());
+                tracing::trace!("TLS handshake success: {:?}", connection.hostname());
                Poll::Ready(Ok(connection.replace_io(stream).1))
            }
        }
--- a/actix-tls/src/connect/rustls_0_21.rs
+++ b/actix-tls/src/connect/rustls_0_21.rs
@@ -0,0 +1,154 @@
+//! Rustls based connector service.
+//!
+//! See [`TlsConnector`] for main connector service factory docs.
+
+use std::{
+    convert::TryFrom,
+    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, OwnedTrustAnchor, 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 `rustls` and `webpki_roots` that are useful for connectors.
+
+    pub use tokio_rustls_024::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig};
+    pub use webpki_roots_025::TLS_SERVER_ROOTS;
+}
+
+/// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store.
+pub fn webpki_roots_cert_store() -> RootCertStore {
+    let mut root_certs = RootCertStore::empty();
+    for cert in webpki_roots_025::TLS_SERVER_ROOTS {
+        let cert = 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))
+            }
+        }
+    }
+}
--- a/actix-tls/src/lib.rs
+++ b/actix-tls/src/lib.rs
@@ -4,17 +4,14 @@
 #![warn(future_incompatible, missing_docs)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-// enable unstable doc_cfg feature only on on docs.rs where nightly compiler is used
-#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(doc_auto_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;
--- a/actix-tls/tests/accept-openssl.rs
+++ b/actix-tls/tests/accept-openssl.rs
@@ -3,7 +3,7 @@
 #![cfg(all(
    feature = "accept",
    feature = "connect",
-    feature = "rustls",
+    feature = "rustls-0_21",
    feature = "openssl"
 ))]

@@ -15,13 +15,12 @@ use actix_service::ServiceFactoryExt as _;
 use actix_tls::accept::openssl::{Acceptor, TlsStream};
 use actix_utils::future::ok;
 use tokio_rustls::rustls::{Certificate, ClientConfig, RootCertStore, ServerName};
+use tokio_rustls_024 as tokio_rustls;

 fn new_cert_and_key() -> (String, String) {
-    let cert = rcgen::generate_simple_self_signed(vec![
-        "127.0.0.1".to_owned(),
-        "localhost".to_owned(),
-    ])
-    .unwrap();
+    let cert =
+        rcgen::generate_simple_self_signed(vec!["127.0.0.1".to_owned(), "localhost".to_owned()])
+            .unwrap();

    let key = cert.serialize_private_key_pem();
    let cert = cert.serialize_pem().unwrap();
@@ -51,7 +50,7 @@ fn openssl_acceptor(cert: String, key: String) -> tls_openssl::ssl::SslAcceptor
 mod danger {
    use std::time::SystemTime;

-    use tokio_rustls::rustls::{
+    use tokio_rustls_024::rustls::{
        self,
        client::{ServerCertVerified, ServerCertVerifier},
    };
--- a/actix-tls/tests/accept-rustls.rs
+++ b/actix-tls/tests/accept-rustls.rs
@@ -3,7 +3,7 @@
 #![cfg(all(
    feature = "accept",
    feature = "connect",
-    feature = "rustls",
+    feature = "rustls-0_21",
    feature = "openssl"
 ))]

@@ -14,19 +14,20 @@ use std::io::{BufReader, Write};
 use actix_rt::net::TcpStream;
 use actix_server::TestServer;
 use actix_service::ServiceFactoryExt as _;
-use actix_tls::accept::rustls::{Acceptor, TlsStream};
-use actix_tls::connect::openssl::reexports::SslConnector;
+use actix_tls::{
+    accept::rustls_0_21::{Acceptor, TlsStream},
+    connect::openssl::reexports::SslConnector,
+};
 use actix_utils::future::ok;
 use rustls_pemfile::{certs, pkcs8_private_keys};
 use tls_openssl::ssl::SslVerifyMode;
 use tokio_rustls::rustls::{self, Certificate, PrivateKey, ServerConfig};
+use tokio_rustls_024 as tokio_rustls;

 fn new_cert_and_key() -> (String, String) {
-    let cert = rcgen::generate_simple_self_signed(vec![
-        "127.0.0.1".to_owned(),
-        "localhost".to_owned(),
-    ])
-    .unwrap();
+    let cert =
+        rcgen::generate_simple_self_signed(vec!["127.0.0.1".to_owned(), "localhost".to_owned()])
+            .unwrap();

    let key = cert.serialize_private_key_pem();
    let cert = cert.serialize_pem().unwrap();
--- a/actix-tls/tests/test_connect.rs
+++ b/actix-tls/tests/test_connect.rs
@@ -30,7 +30,7 @@ async fn test_string() {
    assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }

-#[cfg(feature = "rustls")]
+#[cfg(feature = "rustls-0_21")]
 #[actix_rt::test]
 async fn test_rustls_string() {
    let srv = TestServer::start(|| {
@@ -114,7 +114,7 @@ async fn test_openssl_uri() {
    assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }

-#[cfg(all(feature = "rustls", feature = "uri"))]
+#[cfg(all(feature = "rustls-0_21", feature = "uri"))]
 #[actix_rt::test]
 async fn test_rustls_uri() {
    use std::convert::TryFrom;
--- a/actix-tls/tests/test_resolvers.rs
+++ b/actix-tls/tests/test_resolvers.rs
@@ -51,8 +51,7 @@ async fn custom_resolver_connect() {

    use trust_dns_resolver::TokioAsyncResolver;

-    let srv =
-        TestServer::start(|| fn_service(|_io: TcpStream| async { Ok::<_, io::Error>(()) }));
+    let srv = TestServer::start(|| fn_service(|_io: TcpStream| async { Ok::<_, io::Error>(()) }));

    struct MyResolver {
        trust_dns: TokioAsyncResolver,
--- a/actix-tracing/CHANGES.md
+++ b/actix-tracing/CHANGES.md
@@ -1,8 +1,8 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

- Minimum supported Rust version (MSRV) is now 1.59.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 0.1.0 - 2020-01-15

--- a/actix-tracing/Cargo.toml
+++ b/actix-tracing/Cargo.toml
@@ -9,11 +9,8 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-tracing"
 categories = ["network-programming", "asynchronous"]
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_tracing"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
 actix-service = "2"
--- a/actix-tracing/src/lib.rs
+++ b/actix-tracing/src/lib.rs
@@ -118,9 +118,11 @@ where

 #[cfg(test)]
 mod test {
-    use std::cell::RefCell;
-    use std::collections::{BTreeMap, BTreeSet};
-    use std::sync::{Arc, RwLock};
+    use std::{
+        cell::RefCell,
+        collections::{BTreeMap, BTreeSet},
+        sync::{Arc, RwLock},
+    };

    use actix_service::{fn_factory, fn_service};
    use slab::Slab;
--- a/actix-utils/CHANGES.md
+++ b/actix-utils/CHANGES.md
@@ -1,8 +1,8 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

- Minimum supported Rust version (MSRV) is now 1.59.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 3.0.1 - 2022-10-21

--- a/actix-utils/Cargo.toml
+++ b/actix-utils/Cargo.toml
@@ -10,11 +10,8 @@ keywords = ["network", "framework", "async", "futures"]
 categories = ["network-programming", "asynchronous"]
 repository = "https://github.com/actix/actix-net"
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_utils"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
 pin-project-lite = "0.2"
--- a/actix-utils/src/counter.rs
+++ b/actix-utils/src/counter.rs
@@ -29,7 +29,7 @@ impl Counter {

    /// Returns true if counter is below capacity. Otherwise, register to wake task when it is.
    #[inline]
-    pub fn available(&self, cx: &mut task::Context<'_>) -> bool {
+    pub fn available(&self, cx: &task::Context<'_>) -> bool {
        self.0.available(cx)
    }

@@ -59,7 +59,7 @@ impl CounterInner {
        }
    }

-    fn available(&self, cx: &mut task::Context<'_>) -> bool {
+    fn available(&self, cx: &task::Context<'_>) -> bool {
        if self.count.get() < self.capacity {
            true
        } else {
--- a/actix-utils/src/future/mod.rs
+++ b/actix-utils/src/future/mod.rs
@@ -4,6 +4,8 @@ mod either;
 mod poll_fn;
 mod ready;

-pub use self::either::Either;
-pub use self::poll_fn::{poll_fn, PollFn};
-pub use self::ready::{err, ok, ready, Ready};
+pub use self::{
+    either::Either,
+    poll_fn::{poll_fn, PollFn},
+    ready::{err, ok, ready, Ready},
+};
--- a/actix-utils/src/future/poll_fn.rs
+++ b/actix-utils/src/future/poll_fn.rs
@@ -62,6 +62,7 @@ where
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // SAFETY: we are not moving out of the pinned field
        // see https://github.com/rust-lang/rust/pull/102737
+        #[allow(clippy::needless_borrow)]
        (unsafe { &mut self.get_unchecked_mut().f })(cx)
    }
 }
--- a/bytestring/CHANGES.md
+++ b/bytestring/CHANGES.md
@@ -1,6 +1,6 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

 ## 1.3.0 - 2023-03-03

--- a/bytestring/Cargo.toml
+++ b/bytestring/Cargo.toml
@@ -11,11 +11,8 @@ categories = ["no-std", "web-programming"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
 license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "bytestring"
-path = "src/lib.rs"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
 bytes = { version = "1.2", default-features = false }
@@ -25,4 +22,3 @@ serde = { version = "1.0", optional = true }
 ahash = { version = "0.8", default-features = false }
 serde_json = "1.0"
 static_assertions = "1.1"
-rustversion = "1"
--- a/bytestring/src/lib.rs
+++ b/bytestring/src/lib.rs
@@ -11,7 +11,7 @@ use alloc::{
    string::{String, ToString},
    vec::Vec,
 };
-use core::{borrow, convert::TryFrom, fmt, hash, ops, str};
+use core::{borrow::Borrow, convert::TryFrom, fmt, hash, ops, str};

 use bytes::Bytes;

@@ -132,13 +132,12 @@ impl ops::Deref for ByteString {
    #[inline]
    fn deref(&self) -> &str {
        let bytes = self.0.as_ref();
-        // SAFETY:
-        // UTF-8 validity is guaranteed at during construction.
+        // SAFETY: UTF-8 validity is guaranteed during construction.
        unsafe { str::from_utf8_unchecked(bytes) }
    }
 }

-impl borrow::Borrow<str> for ByteString {
+impl Borrow<str> for ByteString {
    fn borrow(&self) -> &str {
        self
    }
@@ -254,8 +253,10 @@ impl fmt::Display for ByteString {
 mod serde {
    use alloc::string::String;

-    use serde::de::{Deserialize, Deserializer};
-    use serde::ser::{Serialize, Serializer};
+    use serde::{
+        de::{Deserialize, Deserializer},
+        ser::{Serialize, Serializer},
+    };

    use super::ByteString;

@@ -292,7 +293,7 @@ mod serde {

 #[cfg(test)]
 mod test {
-    use alloc::borrow::ToOwned;
+    use alloc::{borrow::ToOwned, format, vec};
    use core::{
        hash::{Hash, Hasher},
        panic::{RefUnwindSafe, UnwindSafe},
@@ -309,7 +310,7 @@ mod test {
    assert_impl_all!(ByteString: UnwindSafe, RefUnwindSafe);

    #[test]
-    fn test_partial_eq() {
+    fn eq() {
        let s: ByteString = ByteString::from_static("test");
        assert_eq!(s, "test");
        assert_eq!(s, *"test");
@@ -317,12 +318,45 @@ mod test {
    }

    #[test]
-    fn test_new() {
+    fn new() {
        let _: ByteString = ByteString::new();
    }

    #[test]
-    fn test_hash() {
+    fn as_bytes() {
+        let buf = ByteString::new();
+        assert!(buf.as_bytes().is_empty());
+
+        let buf = ByteString::from("hello");
+        assert_eq!(buf.as_bytes(), "hello");
+    }
+
+    #[test]
+    fn from_bytes_unchecked() {
+        let buf = unsafe { ByteString::from_bytes_unchecked(Bytes::new()) };
+        assert!(buf.is_empty());
+
+        let buf = unsafe { ByteString::from_bytes_unchecked(Bytes::from("hello")) };
+        assert_eq!(buf, "hello");
+    }
+
+    #[test]
+    fn as_ref() {
+        let buf = ByteString::new();
+
+        let _: &ByteString = buf.as_ref();
+        let _: &[u8] = buf.as_ref();
+    }
+
+    #[test]
+    fn borrow() {
+        let buf = ByteString::new();
+
+        let _: &str = buf.borrow();
+    }
+
+    #[test]
+    fn hash() {
        let mut hasher1 = AHasher::default();
        "str".hash(&mut hasher1);

@@ -333,7 +367,7 @@ mod test {
    }

    #[test]
-    fn test_from_string() {
+    fn from_string() {
        let s: ByteString = "hello".to_owned().into();
        assert_eq!(&s, "hello");
        let t: &str = s.as_ref();
@@ -341,23 +375,30 @@ mod test {
    }

    #[test]
-    fn test_from_str() {
+    fn from_str() {
        let _: ByteString = "str".into();
+        let _: ByteString = "str".to_owned().into_boxed_str().into();
    }

    #[test]
-    fn test_from_static_str() {
+    fn to_string() {
+        let buf = ByteString::from("foo");
+        assert_eq!(String::from(buf), "foo");
+    }
+
+    #[test]
+    fn from_static_str() {
        static _S: ByteString = ByteString::from_static("hello");
        let _ = ByteString::from_static("str");
    }

    #[test]
-    fn test_try_from_slice() {
+    fn try_from_slice() {
        let _ = ByteString::try_from(b"nice bytes").unwrap();
    }

    #[test]
-    fn test_try_from_array() {
+    fn try_from_array() {
        assert_eq!(
            ByteString::try_from([b'h', b'i']).unwrap(),
            ByteString::from_static("hi")
@@ -365,25 +406,43 @@ mod test {
    }

    #[test]
-    fn test_try_from_bytes() {
+    fn try_from_vec() {
+        let _ = ByteString::try_from(vec![b'f', b'o', b'o']).unwrap();
+        ByteString::try_from(vec![0, 159, 146, 150]).unwrap_err();
+    }
+
+    #[test]
+    fn try_from_bytes() {
        let _ = ByteString::try_from(Bytes::from_static(b"nice bytes")).unwrap();
    }

    #[test]
-    fn test_try_from_bytes_mut() {
+    fn try_from_bytes_mut() {
        let _ = ByteString::try_from(bytes::BytesMut::from(&b"nice bytes"[..])).unwrap();
    }

+    #[test]
+    fn display() {
+        let buf = ByteString::from("bar");
+        assert_eq!(format!("{buf}"), "bar");
+    }
+
+    #[test]
+    fn debug() {
+        let buf = ByteString::from("baz");
+        assert_eq!(format!("{buf:?}"), r#""baz""#);
+    }
+
    #[cfg(feature = "serde")]
    #[test]
-    fn test_serialize() {
+    fn serialize() {
        let s: ByteString = serde_json::from_str(r#""nice bytes""#).unwrap();
        assert_eq!(s, "nice bytes");
    }

    #[cfg(feature = "serde")]
    #[test]
-    fn test_deserialize() {
+    fn deserialize() {
        let s = serde_json::to_string(&ByteString::from_static("nice bytes")).unwrap();
        assert_eq!(s, r#""nice bytes""#);
    }
@@ -399,7 +458,7 @@ mod test {

    #[test]
    #[should_panic]
-    fn test_slice_ref_catches_not_a_subset() {
+    fn slice_ref_catches_not_a_subset() {
        // panics because the given slice is not derived from the original byte string, despite
        // being a logical subset of the string
        ByteString::from_static("foo bar").slice_ref("foo");
--- a/clippy.toml
+++ b/clippy.toml
@@ -1 +0,0 @@
-msrv = "1.59"
--- a/local-channel/CHANGES.md
+++ b/local-channel/CHANGES.md
@@ -1,17 +1,19 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased

- Minimum supported Rust version (MSRV) is now 1.59.
+## 0.1.4

-## 0.1.3 - 2022-05-03
+- Minimum supported Rust version (MSRV) is now 1.65.
+
+## 0.1.3

 - Minimum supported Rust version (MSRV) is now 1.49.

-## 0.1.2 - 2021-04-01
+## 0.1.2

 - No significant changes from `0.1.1`.

-## 0.1.1 - 2021-03-29
+## 0.1.1

- Move local mpsc channel to it's own crate.
+- Move local MPSC channel to it's own crate.
--- a/local-channel/Cargo.toml
+++ b/local-channel/Cargo.toml
@@ -1,21 +1,22 @@
 [package]
 name = "local-channel"
-version = "0.1.3"
+version = "0.1.4"
 description = "A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "Rob Ede <robjtede@icloud.com>",
 ]
-repository = "https://github.com/actix/actix-net.git"
+repository = "https://github.com/actix/actix-net"
 keywords = ["channel", "local", "futures"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
 futures-core = "0.3.17"
 futures-sink = "0.3.17"
-futures-util = { version = "0.3.17", default-features = false }
 local-waker = "0.1"

 [dev-dependencies]
-tokio = { version = "1.18.4", features = ["rt", "macros"] }
+futures-util = { version = "0.3.17", default-features = false }
+tokio = { version = "1.23.1", features = ["rt", "macros"] }
--- a/local-channel/src/mpsc.rs
+++ b/local-channel/src/mpsc.rs
@@ -4,6 +4,7 @@ use alloc::{collections::VecDeque, rc::Rc};
 use core::{
    cell::RefCell,
    fmt,
+    future::poll_fn,
    pin::Pin,
    task::{Context, Poll},
 };
@@ -11,7 +12,6 @@ use std::error::Error;

 use futures_core::stream::Stream;
 use futures_sink::Sink;
-use futures_util::future::poll_fn;
 use local_waker::LocalWaker;

 /// Creates a unbounded in-memory channel with buffered storage.
--- a/local-waker/CHANGES.md
+++ b/local-waker/CHANGES.md
@@ -1,8 +1,8 @@
 # Changes

-## Unreleased - 2022-xx-xx
+## Unreleased - 2023-xx-xx

- Minimum supported Rust version (MSRV) is now 1.59.
+- Minimum supported Rust version (MSRV) is now 1.65.

 ## 0.1.3 - 2022-05-03

--- a/local-waker/Cargo.toml
+++ b/local-waker/Cargo.toml
@@ -10,6 +10,7 @@ repository = "https://github.com/actix/actix-net.git"
 keywords = ["waker", "local", "futures", "no-std"]
 categories = ["asynchronous", "no-std"]
 license = "MIT OR Apache-2.0"
-edition = "2018"
+edition.workspace = true
+rust-version.workspace = true

 [dependencies]
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,2 +0,0 @@
-max_width = 96
-group_imports = "StdExternalCrate"
--- a/scripts/free-disk-space.sh
+++ b/scripts/free-disk-space.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The Azure provided machines typically have the following disk allocation:
+# Total space: 85GB
+# Allocated: 67 GB
+# Free: 17 GB
+# This script frees up 28 GB of disk space by deleting unneeded packages and 
+# large directories.
+# The Flink end to end tests download and generate more than 17 GB of files,
+# causing unpredictable behavior and build failures.
+
+echo "=============================================================================="
+echo "Freeing up disk space on CI system"
+echo "=============================================================================="
+
+echo "Listing 100 largest packages"
+dpkg-query -Wf '${Installed-Size}\t${Package}\n' | sort -n | tail -n 100
+df -h
+
+echo "Removing large packages"
+sudo apt-get remove -y '^dotnet-.*'
+sudo apt-get remove -y 'php.*'
+sudo apt-get remove -y '^mongodb-.*'
+sudo apt-get remove -y '^mysql-.*'
+sudo apt-get remove -y azure-cli google-cloud-sdk hhvm google-chrome-stable firefox powershell mono-devel libgl1-mesa-dri
+sudo apt-get autoremove -y
+sudo apt-get clean
+df -h
+
+echo "Removing large directories"
+sudo rm -rf /usr/share/dotnet/
+sudo rm -rf /usr/local/graalvm/
+sudo rm -rf /usr/local/.ghcup/
+sudo rm -rf /usr/local/share/powershell
+sudo rm -rf /usr/local/share/chromium
+sudo rm -rf /usr/local/lib/android
+sudo rm -rf /usr/local/lib/node_modules
+df -h
Author	SHA1	Message	Date
Rob Ede	9f59093adc	chore(local-channel): prepare release 0.1.4	2023-09-17 19:32:01 +01:00
Paolo Barbolini	bfeb4cd9e7	local-channel: drop futures-util by using future::poll_fn from std (#490 )	2023-09-17 11:45:55 +00:00
Rob Ede	14272a1762	chore: force secure rustls-webpki	2023-08-29 18:45:11 +01:00
Rob Ede	7e043048a0	chore(actix-tls): prepare release 3.1.1	2023-08-29 18:41:48 +01:00
Rob Ede	45a7dcba90	chore(tls): fix min rustls version	2023-08-29 18:40:55 +01:00
Rob Ede	5029beb866	prepare actix-tls release 3.1.0	2023-08-26 18:05:39 +01:00
Rob Ede	910c181251	prepare actix-server release 2.3.0	2023-08-26 18:04:22 +01:00
Rob Ede	150d2c05d3	prepare actix-rt release 2.9.0	2023-08-26 18:02:48 +01:00
Alik Aslanyan	3b5716c23e	Add getter methods for actix_rt::Runtime and tokio::runtime::Runtime (#484 ) Co-authored-by: Alik Aslanyan <inline0@pm.me> Co-authored-by: Rob Ede <robjtede@icloud.com>	2023-08-26 15:04:08 +00:00
Rob Ede	0bc310a656	Rustls v0.21 support (#480 )	2023-08-26 14:59:51 +01:00
Rob Ede	6ce8307060	remove num_cpus dependency (#488 )	2023-08-24 00:56:31 +01:00
Rob Ede	9cb8a1fadc	remove lint exception	2023-07-24 03:27:44 +01:00
Rob Ede	9017de439f	ci: fix post-merge tool installs	2023-07-20 00:22:55 +01:00
Rob Ede	3eba5b152e	prepare actix-macros release 0.2.4	2023-07-19 23:52:56 +01:00
Rob Ede	3c4b0c2755	ci: rename post-merge workflow	2023-07-19 23:49:31 +01:00
Rob Ede	462ab6a4f0	ci: try to fix master jobs on windows	2023-07-18 02:06:01 +01:00
Rob Ede	e539f83615	attempt windows CI fix	2023-07-18 01:47:37 +01:00
Martin André	755b231e00	add MPTCP socket protocol (optional) (#466 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2023-07-17 04:10:36 +01:00
Rob Ede	8d5d1dbf6f	bump MSRV to 1.65 (#485 )	2023-07-17 03:05:39 +01:00
Rob Ede	177590a7d8	increase bytestring test coverage	2023-04-01 22:45:18 +01:00
Rob Ede	4cbe741230	use secure openssl version	2023-04-01 22:26:08 +01:00
Rob Ede	80320a0325	use secure tokio version range	2023-04-01 22:24:10 +01:00
Rob Ede	6d0dc9628b	install cargo-hack faster	2023-04-01 22:21:57 +01:00
Rob Ede	dbce150993	update syn to v2 (#481 * update syn to v2 * update changelog	2023-04-01 22:21:14 +01:00
Rob Ede	54ec06cd23	update bitflags to v2	2023-04-01 21:57:10 +01:00
Rob Ede	c0693da9ba	update msrv to 1.60 (#482 * update msrv to 1.60 * inherit workspace msrv	2023-04-01 21:39:19 +01:00
Rob Ede	28f36e4e30	update unreleased sections date	2023-04-01 05:24:40 +01:00
Rob Ede	c6ebbcf21b	clippy run on -tls	2023-04-01 05:24:00 +01:00
Rob Ede	c60d2f9ddb	use doc_auto_cfg	2023-04-01 05:18:22 +01:00