soft-deprecate NormalizePath::default in v3 (#2529)

.cargo/config.toml

@@ -1,14 +0,0 @@
-[alias]
-chk = "check --workspace --all-features --tests --examples --bins"
-lint = "clippy --workspace --all-features --tests --examples --bins"
-ci-min = "hack check --workspace --no-default-features"
-ci-min-test = "hack check --workspace --no-default-features --tests --examples"
-ci-default = "check --workspace --bins --tests --examples"
-ci-full = "check --workspace --all-features --bins --tests --examples"
-ci-test = "test --workspace --all-features --lib --tests --no-fail-fast -- --nocapture"
-ci-doctest = "test --workspace --all-features --doc --no-fail-fast -- --nocapture"
-
-ci-feature-powerset-check-no-tls="hack --workspace --feature-powerset --skip=__compress,rustls,openssl check"
-ci-feature-powerset-check-rustls="hack --workspace --feature-powerset --features=rustls --skip=__compress,openssl check"
-ci-feature-powerset-check-openssl="hack --workspace --feature-powerset --features=openssl --skip=__compress,rustls check"
-ci-feature-powerset-check-all="hack --workspace --feature-powerset --skip=__compress check"

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,15 @@
 blank_issues_enabled: true
 contact_links:
-  - name: Actix Discord
-    url: https://discord.gg/NWpN5mmg3x
-    about: Actix developer discussion and community chat
   - name: GitHub Discussions
     url: https://github.com/actix/actix-web/discussions
     about: Actix Web Q&A
+  - name: Gitter chat (actix-web)
+    url: https://gitter.im/actix/actix-web
+    about: Actix Web Q&A
+  - name: Gitter chat (actix)
+    url: https://gitter.im/actix/actix
+    about: Actix (actor framework) Q&A
+  - name: Actix Discord
+    url: https://discord.gg/NWpN5mmg3x
+    about: Actix developer discussion and community chat
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,21 +1,21 @@
 <!-- Thanks for considering contributing actix! -->
-<!-- Please fill out the following to get your PR reviewed quicker. -->
+<!-- Please fill out the following to make our reviews easy. -->
 
 ## PR Type
 <!-- What kind of change does this PR make? -->
 <!-- Bug Fix / Feature / Refactor / Code Style / Other -->
-PR_TYPE
+INSERT_PR_TYPE
 
 
 ## PR Checklist
-<!-- Check your PR fulfills the following items. -->
+Check your PR fulfills the following:
+
 <!-- For draft PRs check the boxes as you complete them. -->
 
 - [ ] Tests for the changes have been added / updated.
 - [ ] Documentation comments have been added / updated.
 - [ ] A changelog entry has been made for the appropriate packages.
-- [ ] Format code with the latest stable rustfmt.
-- [ ] (Team) Label with affected crates and semver status.
+- [ ] Format code with the latest stable rustfmt
 
 
 ## Overview

.github/workflows/bench.yml

@@ -1,4 +1,4 @@
-name: Benchmark
+name: Benchmark (Linux)
 
 on:
   pull_request:

.github/workflows/ci.yml

@@ -1,178 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches: [master]
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        target:
-          - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
-          - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
-          - { name: Windows, os: windows-2022, triple: x86_64-pc-windows-msvc }
-        version:
-          - 1.52.0 # MSRV
-          - stable
-          - nightly
-
-    name: ${{ matrix.target.name }} / ${{ matrix.version }}
-    runs-on: ${{ matrix.target.os }}
-
-    env:
-      CI: 1
-      CARGO_INCREMENTAL: 0
-      VCPKGRS_DYNAMIC: 1
-
-    steps:
-      - uses: actions/checkout@v2
-
-      # install OpenSSL on Windows
-      # TODO: GitHub actions docs state that OpenSSL is
-      # already installed on these Windows machines somewhere
-      - name: Set vcpkg root
-        if: matrix.target.triple == 'x86_64-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 ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-${{ matrix.target.triple }}
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.2.0
-
-      - name: Install cargo-hack
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-hack
-
-      - name: check minimal
-        uses: actions-rs/cargo@v1
-        with: { command: ci-min }
-
-      - name: check minimal + tests
-        uses: actions-rs/cargo@v1
-        with: { command: ci-min-test }
-
-      - name: check default
-        uses: actions-rs/cargo@v1
-        with: { command: ci-default }
-      
-      - name: check full
-        uses: actions-rs/cargo@v1
-        with: { command: ci-full }
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with:
-          command: ci-test
-          args: --skip=test_reading_deflate_encoding_large_random_rustls
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --version 0.6.3 --no-default-features --features ci-autoclean
-          cargo-cache
-
-  ci_feature_powerset_check:
-    name: Verify Feature Combinations
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.2.0
-
-      - name: Install cargo-hack
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-hack
-
-      - name: check feature combinations
-        # if: github.ref == 'refs/heads/master'
-        uses: actions-rs/cargo@v1
-        with: { command: ci-feature-powerset-check-all }
-
-  coverage:
-    name: coverage
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.2.0
-
-      - name: Generate coverage file
-        if: github.ref == 'refs/heads/master'
-        run: |
-          cargo install cargo-tarpaulin --vers "^0.13"
-          cargo tarpaulin --out Xml --verbose
-      - name: Upload to Codecov
-        if: github.ref == 'refs/heads/master'
-        uses: codecov/codecov-action@v1
-        with: { file: cobertura.xml }
-
-  rustdoc:
-    name: rustdoc
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install Rust (nightly)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.3.0
-
-      - name: Install cargo-hack
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-hack
-
-      - name: doc tests
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with: { command: ci-doctest }

.github/workflows/clippy-fmt.yml

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

.github/workflows/linux.yml

@@ -0,0 +1,69 @@
+name: CI (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - 1.42.0 # MSRV
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-unknown-linux-gnu
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+
+      - name: tests (actix-http)
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --package=actix-http --no-default-features --features=rustls -- --nocapture
+
+      - name: tests (awc)
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --package=awc --no-default-features --features=rustls -- --nocapture
+
+      - name: Generate coverage file
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        run: |
+          cargo install cargo-tarpaulin --vers "^0.13"
+          cargo tarpaulin --out Xml
+      - name: Upload to Codecov
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        uses: codecov/codecov-action@v1
+        with:
+          file: cobertura.xml

.github/workflows/macos.yml

@@ -0,0 +1,44 @@
+name: CI (macOS)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-apple-darwin
+    runs-on: macOS-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-apple-darwin
+          profile: minimal
+          override: true
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+                --skip=test_h2_content_length
+                --skip=test_reading_deflate_encoding_large_random_rustls

.github/workflows/upload-doc.yml

@@ -1,12 +1,14 @@
-name: Upload Documentation
+name: Upload documentation
 
 on:
   push:
-    branches: [master]
+    branches:
+      - master
 
 jobs:
   build:
     runs-on: ubuntu-latest
+    if: github.repository == 'actix/actix-web'
 
     steps:
       - uses: actions/checkout@v2
@@ -18,14 +20,14 @@ jobs:
           profile: minimal
           override: true
 
-      - name: Build Docs
+      - name: check build
         uses: actions-rs/cargo@v1
         with:
           command: doc
-          args: --workspace --all-features --no-deps
+          args: --no-deps --workspace --all-features
 
       - name: Tweak HTML
-        run: echo '<meta http-equiv="refresh" content="0;url=actix_web/index.html">' > target/doc/index.html
+        run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
 
       - name: Deploy to GitHub Pages
         uses: JamesIves/github-pages-deploy-action@3.7.1

.github/workflows/windows.yml

@@ -0,0 +1,64 @@
+name: CI (Windows)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+env:
+  VCPKGRS_DYNAMIC: 1
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-pc-windows-msvc
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-pc-windows-msvc
+          profile: minimal
+          override: true
+
+      - name: Install OpenSSL
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:x64-windows
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libcrypto-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libcrypto.dll
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libssl-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libssl.dll
+          Get-ChildItem C:\vcpkg\installed\x64-windows\bin
+          Get-ChildItem C:\vcpkg\installed\x64-windows\lib
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+                --skip=test_h2_content_length
+                --skip=test_reading_deflate_encoding_large_random_rustls
+                --skip=test_params
+                --skip=test_simple
+                --skip=test_expect_continue
+                --skip=test_http10_keepalive
+                --skip=test_slow_request
+                --skip=test_connection_force_close
+                --skip=test_connection_server_close
+                --skip=test_connection_wait_queue_force_close

.gitignore

@@ -16,6 +16,3 @@ guide/build/
 
 # Configuration directory generated by CLion
 .idea
-
-# Configuration directory generated by VSCode
-.vscode

CHANGES.md

@@ -1,223 +1,14 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## Unreleased - 2020-xx-xx
 
 
-## 4.0.0-beta.10 - 2021-10-20
-### Added
-* Option to allow `Json` extractor to work without a `Content-Type` header present. [#2362]
-* `#[actix_web::test]` macro for setting up tests with a runtime. [#2409]
-
+## 3.3.3 - 2021-12-18
 ### Changed
-* Associated type `FromRequest::Config` was removed. [#2233]
-* Inner field made private on `web::Payload`. [#2384]
-* `Data::into_inner` and `Data::get_ref` no longer require T: Sized. [#2403]
-* Updated rustls to v0.20. [#2414]
-* Minimum supported Rust version (MSRV) is now 1.52.
+* Soft-deprecate `NormalizePath::default()`, noting upcoming behavior change in v4. [#2529]
 
-### Removed
-* Useless `ServiceResponse::checked_expr` method. [#2401]
+[#2529]: https://github.com/actix/actix-web/pull/2529
 
-[#2233]: https://github.com/actix/actix-web/pull/2233
-[#2362]: https://github.com/actix/actix-web/pull/2362
-[#2384]: https://github.com/actix/actix-web/pull/2384
-[#2401]: https://github.com/actix/actix-web/pull/2401
-[#2403]: https://github.com/actix/actix-web/pull/2403
-[#2409]: https://github.com/actix/actix-web/pull/2409
-[#2414]: https://github.com/actix/actix-web/pull/2414
-
-
-## 4.0.0-beta.9 - 2021-09-09
-### Added
-* Re-export actix-service `ServiceFactory` in `dev` module. [#2325]
-
-### Changed
-* Compress middleware will return 406 Not Acceptable when no content encoding is acceptable to the client. [#2344]
-* Move `BaseHttpResponse` to `dev::Response`. [#2379]
-* Enable `TestRequest::param` to accept more than just static strings. [#2172]
-* Minimum supported Rust version (MSRV) is now 1.51.
-
-### Fixed
-* Fix quality parse error in Accept-Encoding header. [#2344]
-* Re-export correct type at `web::HttpResponse`. [#2379]
-
-[#2172]: https://github.com/actix/actix-web/pull/2172
-[#2325]: https://github.com/actix/actix-web/pull/2325
-[#2344]: https://github.com/actix/actix-web/pull/2344
-[#2379]: https://github.com/actix/actix-web/pull/2379
-
-
-## 4.0.0-beta.8 - 2021-06-26
-### Added
-* Add `ServiceRequest::parts_mut`. [#2177]
-* Add extractors for `Uri` and `Method`. [#2263]
-* Add extractors for `ConnectionInfo` and `PeerAddr`. [#2263]
-* Add `Route::service` for using hand-written services as handlers. [#2262]
-
-### Changed
-* Change compression algorithm features flags. [#2250]
-* Deprecate `App::data` and `App::data_factory`. [#2271]
-* Smarter extraction of `ConnectionInfo` parts. [#2282]
-
-### Fixed
-* Scope and Resource middleware can access data items set on their own layer. [#2288]
-
-[#2177]: https://github.com/actix/actix-web/pull/2177
-[#2250]: https://github.com/actix/actix-web/pull/2250
-[#2271]: https://github.com/actix/actix-web/pull/2271
-[#2262]: https://github.com/actix/actix-web/pull/2262
-[#2263]: https://github.com/actix/actix-web/pull/2263
-[#2282]: https://github.com/actix/actix-web/pull/2282
-[#2288]: https://github.com/actix/actix-web/pull/2288
-
-
-## 4.0.0-beta.7 - 2021-06-17
-### Added
-* `HttpServer::worker_max_blocking_threads` for setting block thread pool. [#2200]
-
-### Changed
-* Adjusted default JSON payload limit to 2MB (from 32kb) and included size and limits in the `JsonPayloadError::Overflow` error variant. [#2162]
-[#2162]: (https://github.com/actix/actix-web/pull/2162)
-* `ServiceResponse::error_response` now uses body type of `Body`. [#2201]
-* `ServiceResponse::checked_expr` now returns a `Result`. [#2201]
-* Update `language-tags` to `0.3`.
-* `ServiceResponse::take_body`. [#2201]
-* `ServiceResponse::map_body` closure receives and returns `B` instead of `ResponseBody<B>` types. [#2201]
-* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
-* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
-* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
-* `middleware::normalize` now will not try to normalize URIs with no valid path [#2246]
-
-### Removed
-* `HttpResponse::take_body` and old `HttpResponse::into_body` method that casted body type. [#2201]
-
-[#2200]: https://github.com/actix/actix-web/pull/2200
-[#2201]: https://github.com/actix/actix-web/pull/2201
-[#2253]: https://github.com/actix/actix-web/pull/2253
-[#2246]: https://github.com/actix/actix-web/pull/2246
-
-
-## 4.0.0-beta.6 - 2021-04-17
-### Added
-* `HttpResponse` and `HttpResponseBuilder` structs. [#2065]
-
-### Changed
-* Most error types are now marked `#[non_exhaustive]`. [#2148]
-* Methods on `ContentDisposition` that took `T: AsRef<str>` now take `impl AsRef<str>`.
-
-[#2065]: https://github.com/actix/actix-web/pull/2065
-[#2148]: https://github.com/actix/actix-web/pull/2148
-
-
-## 4.0.0-beta.5 - 2021-04-02
-### Added
-* `Header` extractor for extracting common HTTP headers in handlers. [#2094]
-* Added `TestServer::client_headers` method. [#2097]
-
-### Fixed
-* Double ampersand in Logger format is escaped correctly. [#2067]
-
-### Changed
-* `CustomResponder` would return error as `HttpResponse` when `CustomResponder::with_header` failed
-  instead of skipping. (Only the first error is kept when multiple error occur) [#2093]
-
-### Removed
-* The `client` mod was removed. Clients should now use `awc` directly.
-  [871ca5e4](https://github.com/actix/actix-web/commit/871ca5e4ae2bdc22d1ea02701c2992fa8d04aed7)
-* Integration testing was moved to new `actix-test` crate. Namely these items from the `test`
-  module: `TestServer`, `TestServerConfig`, `start`, `start_with`, and `unused_addr`. [#2112]
-
-[#2067]: https://github.com/actix/actix-web/pull/2067
-[#2093]: https://github.com/actix/actix-web/pull/2093
-[#2094]: https://github.com/actix/actix-web/pull/2094
-[#2097]: https://github.com/actix/actix-web/pull/2097
-[#2112]: https://github.com/actix/actix-web/pull/2112
-
-
-## 4.0.0-beta.4 - 2021-03-09
-### Changed
-* Feature `cookies` is now optional and enabled by default. [#1981]
-* `JsonBody::new` returns a default limit of 32kB to be consistent with `JsonConfig` and the default
-  behaviour of the `web::Json<T>` extractor. [#2010]
-
-[#1981]: https://github.com/actix/actix-web/pull/1981
-[#2010]: https://github.com/actix/actix-web/pull/2010
-
-
-## 4.0.0-beta.3 - 2021-02-10
-* Update `actix-web-codegen` to `0.5.0-beta.1`.
-
-
-## 4.0.0-beta.2 - 2021-02-10
-### Added
-* The method `Either<web::Json<T>, web::Form<T>>::into_inner()` which returns the inner type for
-  whichever variant was created. Also works for `Either<web::Form<T>, web::Json<T>>`. [#1894]
-* Add `services!` macro for helping register multiple services to `App`. [#1933]
-* Enable registering a vec of services of the same type to `App` [#1933]
-
-### Changed
-* Rework `Responder` trait to be sync and returns `Response`/`HttpResponse` directly.
-  Making it simpler and more performant. [#1891]
-* `ServiceRequest::into_parts` and `ServiceRequest::from_parts` can no longer fail. [#1893]
-* `ServiceRequest::from_request` can no longer fail. [#1893]
-* Our `Either` type now uses `Left`/`Right` variants (instead of `A`/`B`) [#1894]
-* `test::{call_service, read_response, read_response_json, send_request}` take `&Service`
-  in argument [#1905]
-* `App::wrap_fn`, `Resource::wrap_fn` and `Scope::wrap_fn` provide `&Service` in closure
-  argument. [#1905]
-* `web::block` no longer requires the output is a Result. [#1957]
-
-### Fixed
-* Multiple calls to `App::data` with the same type now keeps the latest call's data. [#1906]
-
-### Removed
-* Public field of `web::Path` has been made private. [#1894]
-* Public field of `web::Query` has been made private. [#1894]
-* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
-* `AppService::set_service_data`; for custom HTTP service factories adding application data, use the
-  layered data model by calling `ServiceRequest::add_data_container` when handling
-  requests instead. [#1906]
-
-[#1891]: https://github.com/actix/actix-web/pull/1891
-[#1893]: https://github.com/actix/actix-web/pull/1893
-[#1894]: https://github.com/actix/actix-web/pull/1894
-[#1869]: https://github.com/actix/actix-web/pull/1869
-[#1905]: https://github.com/actix/actix-web/pull/1905
-[#1906]: https://github.com/actix/actix-web/pull/1906
-[#1933]: https://github.com/actix/actix-web/pull/1933
-[#1957]: https://github.com/actix/actix-web/pull/1957
-
-
-## 4.0.0-beta.1 - 2021-01-07
-### Added
-* `Compat` middleware enabling generic response body/error type of middlewares like `Logger` and
-  `Compress` to be used in `middleware::Condition` and `Resource`, `Scope` services. [#1865]
-
-### Changed
-* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
-* Bumped `rand` to `0.8`.
-* Update `rust-tls` to `0.19`. [#1813]
-* Rename `Handler` to `HandlerService` and rename `Factory` to `Handler`. [#1852]
-* The default `TrailingSlash` is now `Trim`, in line with existing documentation. See migration
-  guide for implications. [#1875]
-* Rename `DefaultHeaders::{content_type => add_content_type}`. [#1875]
-* MSRV is now 1.46.0.
-
-### Fixed
-* Added the underlying parse error to `test::read_body_json`'s panic message. [#1812]
-
-### Removed
-* Public modules `middleware::{normalize, err_handlers}`. All necessary middleware structs are now
-  exposed directly by the `middleware` module.
-* Remove `actix-threadpool` as dependency. `actix_threadpool::BlockingError` error type can be imported 
-  from `actix_web::error` module. [#1878]
-
-[#1812]: https://github.com/actix/actix-web/pull/1812
-[#1813]: https://github.com/actix/actix-web/pull/1813
-[#1852]: https://github.com/actix/actix-web/pull/1852
-[#1865]: https://github.com/actix/actix-web/pull/1865
-[#1875]: https://github.com/actix/actix-web/pull/1875
-[#1878]: https://github.com/actix/actix-web/pull/1878
 
 ## 3.3.2 - 2020-12-01
 ### Fixed
@@ -302,7 +93,7 @@
 
 ## 3.0.0-beta.4 - 2020-09-09
 ### Added
-* `middleware::NormalizePath` now has configurable behavior for either always having a trailing 
+* `middleware::NormalizePath` now has configurable behaviour for either always having a trailing
   slash, or as the new addition, always trimming trailing slashes. [#1639]
 
 ### Changed
@@ -630,7 +421,7 @@
 
 ## [1.0.0-rc] - 2019-05-18
 
-### Added
+### Add
 
 * Add `Query<T>::from_query()` to extract parameters from a query string. #846
 * `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
@@ -646,7 +437,7 @@
 
 ## [1.0.0-beta.4] - 2019-05-12
 
-### Added
+### Add
 
 * Allow to set/override app data on scope level
 
@@ -672,7 +463,7 @@
 
 * CORS handling without headers #702
 
-* Allow constructing `Data` instances to avoid double `Arc` for `Send + Sync` types.
+* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
 
 ### Fixed
 
@@ -736,7 +527,7 @@
 
 ### Changed
 
-* Allow using any service as default service.
+* Allow to use any service as default service.
 
 * Remove generic type for request payload, always use default.
 
@@ -799,13 +590,13 @@
 
 ### Added
 
-* Rustls support
+* rustls support
 
 ### Changed
 
-* Use forked cookie
+* use forked cookie
 
-* Multipart::Field renamed to MultipartField
+* multipart::Field renamed to MultipartField
 
 ## [1.0.0-alpha.1] - 2019-03-28
 

Cargo.toml

@@ -1,127 +1,123 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.10"
+version = "3.3.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
+readme = "README.md"
 keywords = ["actix", "http", "web", "framework", "async"]
-categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket"
-]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-web/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server",
+              "web-programming::websocket"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-# features that docs.rs will build with
-features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd", "cookies", "secure-cookies"]
-rustdoc-args = ["--cfg", "docsrs"]
+features = ["openssl", "rustls", "compress", "secure-cookies"]
+
+[badges]
+travis-ci = { repository = "actix/actix-web", branch = "master" }
+codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
 
 [lib]
 name = "actix_web"
 path = "src/lib.rs"
 
 [workspace]
-resolver = "2"
 members = [
-    ".",
-    "awc",
-    "actix-http",
-    "actix-files",
-    "actix-multipart",
-    "actix-web-actors",
-    "actix-web-codegen",
-    "actix-http-test",
-    "actix-test",
-    "actix-router",
+  ".",
+  "awc",
+  "actix-http",
+  "actix-files",
+  "actix-multipart",
+  "actix-web-actors",
+  "actix-web-codegen",
+  "test-server",
 ]
 
 [features]
-default = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
+default = ["compress"]
 
-# Brotli algorithm content-encoding support
-compress-brotli = ["actix-http/compress-brotli", "__compress"]
-# Gzip and deflate algorithms content-encoding support
-compress-gzip = ["actix-http/compress-gzip", "__compress"]
-# Zstd algorithm content-encoding support
-compress-zstd = ["actix-http/compress-zstd", "__compress"]
+# content-encoding support
+compress = ["actix-http/compress", "awc/compress"]
 
-# support for cookies
-cookies = ["cookie"]
-
-# secure cookies feature
-secure-cookies = ["cookie/secure"]
+# sessions feature
+secure-cookies = ["actix-http/secure-cookies"]
 
 # openssl
-openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
+openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
 
 # rustls
-rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]
+rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
 
-# Internal (PRIVATE!) features used to aid testing and checking feature status.
-# Don't rely on these whatsoever. They may disappear at anytime.
-__compress = []
+[[example]]
+name = "basic"
+required-features = ["compress"]
+
+[[example]]
+name = "uds"
+required-features = ["compress"]
+
+[[test]]
+name = "test_server"
+required-features = ["compress"]
+
+[[example]]
+name = "on_connect"
+required-features = []
+
+[[example]]
+name = "client"
+required-features = ["rustls"]
 
 [dependencies]
-actix-codec = "0.4.0"
-actix-macros = "0.2.3"
-actix-rt = "2.2"
-actix-server = "2.0.0-beta.3"
-actix-service = "2.0.0"
-actix-utils = "3.0.0"
-actix-tls = { version = "3.0.0-beta.7", default-features = false, optional = true }
+actix-codec = "0.3.0"
+actix-service = "1.0.6"
+actix-utils = "2.0.0"
+actix-router = "0.2.4"
+actix-rt = "1.1.1"
+actix-server = "1.0.0"
+actix-testing = "1.0.0"
+actix-macros = "0.1.0"
+actix-threadpool = "0.3.1"
+actix-tls = "2.0.0"
 
-actix-http = "3.0.0-beta.11"
-actix-router = "0.5.0-beta.2"
-actix-web-codegen = "0.5.0-beta.5"
+actix-web-codegen = "0.4.0"
+actix-http = "2.2.0"
+awc = { version = "2.0.3", default-features = false }
 
-ahash = "0.7"
-bytes = "1"
-cfg-if = "1"
-cookie = { version = "0.15", features = ["percent-encode"], optional = true }
+bytes = "0.5.3"
 derive_more = "0.99.5"
-either = "1.5.3"
 encoding_rs = "0.8"
-futures-core = { version = "0.3.7", default-features = false }
-futures-util = { version = "0.3.7", default-features = false }
-itoa = "0.4"
-language-tags = "0.3"
-once_cell = "1.5"
+futures-channel = { version = "0.3.5", default-features = false }
+futures-core = { version = "0.3.5", default-features = false }
+futures-util = { version = "0.3.5", default-features = false }
+fxhash = "0.2.1"
 log = "0.4"
 mime = "0.3"
-paste = "1"
+socket2 = "0.3.16"
 pin-project = "1.0.0"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.7"
-smallvec = "1.6.1"
-socket2 = "0.4.0"
-time = { version = "0.3", default-features = false, features = ["formatting"] }
+time = { version = "0.2.7", default-features = false, features = ["std"] }
 url = "2.1"
+open-ssl = { package = "openssl", version = "0.10", optional = true }
+rust-tls = { package = "rustls", version = "0.18.0", optional = true }
+tinyvec = { version = "1", features = ["alloc"] }
 
 [dev-dependencies]
-actix-test = { version = "0.1.0-beta.3", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.9", features = ["openssl"] }
-
-brotli2 = "0.3.2"
-criterion = { version = "0.3", features = ["html_reports"] }
+actix = "0.10.0"
+actix-http = { version = "2.1.0", features = ["actors"] }
+rand = "0.7"
 env_logger = "0.8"
+serde_derive = "1.0"
+brotli2 = "0.3.2"
 flate2 = "1.0.13"
-futures-util = { version = "0.3.7", default-features = false, features = ["std"] }
-rand = "0.8"
-rcgen = "0.8"
-rustls-pemfile = "0.2"
-tls-openssl = { package = "openssl", version = "0.10.9" }
-tls-rustls = { package = "rustls", version = "0.20.0" }
-zstd = "0.7"
-
-[profile.dev]
-# Disabling debug info speeds up builds a bunch and we don't rely on it for debugging that much.
-debug = 0
+criterion = "0.3"
 
 [profile.release]
 lto = true
@@ -129,33 +125,14 @@ opt-level = 3
 codegen-units = 1
 
 [patch.crates-io]
-actix-files = { path = "actix-files" }
-actix-http = { path = "actix-http" }
-actix-http-test = { path = "actix-http-test" }
-actix-multipart = { path = "actix-multipart" }
-actix-router = { path = "actix-router" }
-actix-test = { path = "actix-test" }
 actix-web = { path = "." }
-actix-web-actors = { path = "actix-web-actors" }
+actix-http = { path = "actix-http" }
+actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
+actix-files = { path = "actix-files" }
+actix-multipart = { path = "actix-multipart" }
 awc = { path = "awc" }
 
-[[test]]
-name = "test_server"
-required-features = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
-
-[[example]]
-name = "basic"
-required-features = ["compress-gzip"]
-
-[[example]]
-name = "uds"
-required-features = ["compress-gzip"]
-
-[[example]]
-name = "on_connect"
-required-features = []
-
 [[bench]]
 name = "server"
 harness = false
@@ -163,7 +140,3 @@ harness = false
 [[bench]]
 name = "service"
 harness = false
-
-[[bench]]
-name = "responder"
-harness = false

LICENSE-MIT

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

MIGRATION.md

@@ -1,30 +1,5 @@
 ## Unreleased
 
-* The default `NormalizePath` behavior now strips trailing slashes by default. This was
-  previously documented to be the case in v3 but the behavior now matches. The effect is that
-  routes defined with trailing slashes will become inaccessible when
-  using `NormalizePath::default()`. As such, calling `NormalizePath::default()` will log a warning.
-  It is advised that the `new` method be used instead.
-  
-  Before: `#[get("/test/")]`  
-  After:  `#[get("/test")]`  
-
-  Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
-
-* The `type Config` of `FromRequest` was removed.
-
-* Feature flag `compress` has been split into its supported algorithm (brotli, gzip, zstd).
-  By default all compression algorithms are enabled.
-  To select algorithm you want to include with `middleware::Compress` use following flags:
-  - `compress-brotli`
-  - `compress-gzip`
-  - `compress-zstd`
-  If you have set in your `Cargo.toml` dedicated `actix-web` features and you still want
-  to have compression enabled. Please change features selection like bellow:
-
-  Before: `"compress"`
-  After: `"compress-brotli", "compress-gzip", "compress-zstd"`
-
 
 ## 3.0.0
 

README.md

@@ -1,19 +1,20 @@
 <div align="center">
-  <h1>Actix Web</h1>
+  <h1>Actix web</h1>
   <p>
     <strong>Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust</strong>
   </p>
   <p>
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.10)](https://docs.rs/actix-web/4.0.0-beta.10)
-[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.10/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.10)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=3.3.3)](https://docs.rs/actix-web/3.3.3)
+[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
+![License](https://img.shields.io/crates/l/actix-web.svg)
+[![Dependency Status](https://deps.rs/crate/actix-web/3.3.3/status.svg)](https://deps.rs/crate/actix-web/3.3.3)
 <br />
-[![build status](https://github.com/actix/actix-web/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-web/actions)
+[![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) 
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
-![downloads](https://img.shields.io/crates/d/actix-web.svg)
+[![Download](https://img.shields.io/crates/d/actix-web.svg)](https://crates.io/crates/actix-web)
+[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
   </p>
@@ -25,14 +26,15 @@
 * Streaming and pipelining
 * Keep-alive and slow requests handling
 * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
-* Transparent content compression/decompression (br, gzip, deflate, zstd)
+* Transparent content compression/decompression (br, gzip, deflate)
 * Powerful [request routing](https://actix.rs/docs/url-dispatch/)
 * Multipart streams
 * Static assets
 * SSL support using OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://docs.rs/awc/)
-* Runs on stable Rust 1.52+
+* Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
+* Supports [Actix actor framework](https://github.com/actix/actix)
+* Runs on stable Rust 1.42+
 
 ## Documentation
 
@@ -71,18 +73,18 @@ async fn main() -> std::io::Result<()> {
 
 ### More examples
 
-* [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
-* [Application State](https://github.com/actix/examples/tree/master/basics/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
+* [Basic Setup](https://github.com/actix/examples/tree/master/basics/)
+* [Application State](https://github.com/actix/examples/tree/master/state/)
+* [JSON Handling](https://github.com/actix/examples/tree/master/json/)
+* [Multipart Streams](https://github.com/actix/examples/tree/master/multipart/)
+* [Diesel Integration](https://github.com/actix/examples/tree/master/diesel/)
+* [r2d2 Integration](https://github.com/actix/examples/tree/master/r2d2/)
+* [Simple WebSocket](https://github.com/actix/examples/tree/master/websocket/)
+* [Tera Templates](https://github.com/actix/examples/tree/master/template_tera/)
+* [Askama Templates](https://github.com/actix/examples/tree/master/template_askama/)
+* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/rustls/)
+* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
+* [WebSocket Chat](https://github.com/actix/examples/tree/master/websocket-chat/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.
@@ -90,20 +92,20 @@ You may consider checking out
 ## Benchmarks
 
 One of the fastest web frameworks available according to the
-[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r20&test=composite).
+[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r19).
 
 ## License
 
 This project is licensed under either of
 
 * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-  [http://www.apache.org/licenses/LICENSE-2.0])
+  [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-  [http://opensource.org/licenses/MIT])
+  [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-web repo is organized under the terms of the Contributor Covenant.
-The Actix team promises to intervene to uphold that code of conduct.
+Contribution to the actix-web crate is organized under the terms of the Contributor Covenant, the
+maintainers of Actix web, promises to intervene to uphold that code of conduct.

actix-files/CHANGES.md

@@ -1,65 +1,6 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
-
-
-## 0.6.0-beta.8 - 2021-10-20
-* Minimum supported Rust version (MSRV) is now 1.52.
-
-
-## 0.6.0-beta.7 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
-
-
-## 0.6.0-beta.6 - 2021-06-26
-* Added `Files::path_filter()`. [#2274]
-* `Files::show_files_listing()` can now be used with `Files::index_file()` to show files listing as a fallback when the index file is not found. [#2228]
-
-[#2274]: https://github.com/actix/actix-web/pull/2274
-[#2228]: https://github.com/actix/actix-web/pull/2228
-
-
-## 0.6.0-beta.5 - 2021-06-17
-* `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
-* For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
-* `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
-* `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
-
-[#2135]: https://github.com/actix/actix-web/pull/2135
-[#2156]: https://github.com/actix/actix-web/pull/2156
-[#2225]: https://github.com/actix/actix-web/pull/2225
-[#2257]: https://github.com/actix/actix-web/pull/2257
-
-
-## 0.6.0-beta.4 - 2021-04-02
-* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
-
-[#2046]: https://github.com/actix/actix-web/pull/2046
-
-
-## 0.6.0-beta.3 - 2021-03-09
-* No notable changes.
-
-
-## 0.6.0-beta.2 - 2021-02-10
-* Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
-* Replace `v_htmlescape` with `askama_escape`. [#1953]
-
-[#1887]: https://github.com/actix/actix-web/pull/1887
-[#1953]: https://github.com/actix/actix-web/pull/1953
-
-
-## 0.6.0-beta.1 - 2021-01-07
-* `HttpRange::parse` now has its own error type.
-* Update `bytes` to `1.0`. [#1813]
-
-[#1813]: https://github.com/actix/actix-web/pull/1813
-
-
-## 0.5.0 - 2020-12-26
-* Optionally support hidden files/directories. [#1811]
-
-[#1811]: https://github.com/actix/actix-web/pull/1811
+## Unreleased - 2020-xx-xx
 
 
 ## 0.4.1 - 2020-11-24

actix-files/Cargo.toml

@@ -1,11 +1,13 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.8"
+version = "0.4.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static file serving for Actix Web"
+readme = "README.md"
 keywords = ["actix", "http", "async", "futures"]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-files/"
 categories = ["asynchronous", "web-programming::http-server"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
@@ -15,23 +17,19 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "4.0.0-beta.10", default-features = false }
-actix-http = "3.0.0-beta.11"
-actix-service = "2.0.0"
-actix-utils = "3.0.0"
-
-askama_escape = "0.10"
+actix-web = { version = "3.0.0", default-features = false }
+actix-service = "1.0.6"
 bitflags = "1"
-bytes = "1"
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-http-range = "0.1.4"
-derive_more = "0.99.5"
+bytes = "0.5.3"
+futures-core = { version = "0.3.7", default-features = false }
+futures-util = { version = "0.3.7", default-features = false }
+derive_more = "0.99.2"
 log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.1"
 percent-encoding = "2.1"
+v_htmlescape = "0.11"
 
 [dev-dependencies]
-actix-rt = "2.2"
-actix-web = "4.0.0-beta.10"
-actix-test = "0.1.0-beta.5"
+actix-rt = "1.0.0"
+actix-web = { version = "3.0.0", features = ["openssl"] }

actix-files/README.md

@@ -3,16 +3,17 @@
 > Static file serving for Actix Web
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.8)](https://docs.rs/actix-files/0.6.0-beta.8)
-[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.4.1)](https://docs.rs/actix-files/0.4.1)
+[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.8/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.8)
+[![dependency status](https://deps.rs/crate/actix-files/0.4.1/status.svg)](https://deps.rs/crate/actix-files/0.4.1)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
-[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-files/)
-- [Example Project](https://github.com/actix/examples/tree/master/basics/static_index)
-- Minimum Supported Rust Version (MSRV): 1.52
+- [Example Project](https://github.com/actix/examples/tree/master/static_index)
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Minimum supported Rust version: 1.42 or later

actix-files/src/chunked.rs

@@ -9,35 +9,26 @@ use std::{
 
 use actix_web::{
     error::{BlockingError, Error},
-    rt::task::{spawn_blocking, JoinHandle},
+    web,
 };
 use bytes::Bytes;
 use futures_core::{ready, Stream};
+use futures_util::future::{FutureExt, LocalBoxFuture};
+
+use crate::handle_error;
+
+type ChunkedBoxFuture =
+    LocalBoxFuture<'static, Result<(File, Bytes), BlockingError<io::Error>>>;
 
 #[doc(hidden)]
 /// A helper created from a `std::fs::File` which reads the file
 /// chunk-by-chunk on a `ThreadPool`.
 pub struct ChunkedReadFile {
-    size: u64,
-    offset: u64,
-    state: ChunkedReadFileState,
-    counter: u64,
-}
-
-enum ChunkedReadFileState {
-    File(Option<File>),
-    Future(JoinHandle<Result<(File, Bytes), io::Error>>),
-}
-
-impl ChunkedReadFile {
-    pub(crate) fn new(size: u64, offset: u64, file: File) -> Self {
-        Self {
-            size,
-            offset,
-            state: ChunkedReadFileState::File(Some(file)),
-            counter: 0,
-        }
-    }
+    pub(crate) size: u64,
+    pub(crate) offset: u64,
+    pub(crate) file: Option<File>,
+    pub(crate) fut: Option<ChunkedBoxFuture>,
+    pub(crate) counter: u64,
 }
 
 impl fmt::Debug for ChunkedReadFile {
@@ -49,50 +40,55 @@ impl fmt::Debug for ChunkedReadFile {
 impl Stream for ChunkedReadFile {
     type Item = Result<Bytes, Error>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.as_mut().get_mut();
-        match this.state {
-            ChunkedReadFileState::File(ref mut file) => {
-                let size = this.size;
-                let offset = this.offset;
-                let counter = this.counter;
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if let Some(ref mut fut) = self.fut {
+            return match ready!(Pin::new(fut).poll(cx)) {
+                Ok((file, bytes)) => {
+                    self.fut.take();
+                    self.file = Some(file);
 
-                if size == counter {
-                    Poll::Ready(None)
-                } else {
-                    let mut file = file
-                        .take()
-                        .expect("ChunkedReadFile polled after completion");
+                    self.offset += bytes.len() as u64;
+                    self.counter += bytes.len() as u64;
 
-                    let fut = spawn_blocking(move || {
-                        let max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
-
-                        let mut buf = Vec::with_capacity(max_bytes);
-                        file.seek(io::SeekFrom::Start(offset))?;
-
-                        let n_bytes =
-                            file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
-
-                        if n_bytes == 0 {
-                            return Err(io::ErrorKind::UnexpectedEof.into());
-                        }
-
-                        Ok((file, Bytes::from(buf)))
-                    });
-                    this.state = ChunkedReadFileState::Future(fut);
-                    self.poll_next(cx)
+                    Poll::Ready(Some(Ok(bytes)))
                 }
-            }
-            ChunkedReadFileState::Future(ref mut fut) => {
-                let (file, bytes) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-                this.state = ChunkedReadFileState::File(Some(file));
+                Err(e) => Poll::Ready(Some(Err(handle_error(e)))),
+            };
+        }
 
-                this.offset += bytes.len() as u64;
-                this.counter += bytes.len() as u64;
+        let size = self.size;
+        let offset = self.offset;
+        let counter = self.counter;
 
-                Poll::Ready(Some(Ok(bytes)))
-            }
+        if size == counter {
+            Poll::Ready(None)
+        } else {
+            let mut file = self.file.take().expect("Use after completion");
+
+            self.fut = Some(
+                web::block(move || {
+                    let max_bytes =
+                        cmp::min(size.saturating_sub(counter), 65_536) as usize;
+
+                    let mut buf = Vec::with_capacity(max_bytes);
+                    file.seek(io::SeekFrom::Start(offset))?;
+
+                    let n_bytes =
+                        file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
+
+                    if n_bytes == 0 {
+                        return Err(io::ErrorKind::UnexpectedEof.into());
+                    }
+
+                    Ok((file, Bytes::from(buf)))
+                })
+                .boxed_local(),
+            );
+
+            self.poll_next(cx)
         }
     }
 }

actix-files/src/directory.rs

@@ -1,8 +1,8 @@
 use std::{fmt::Write, fs::DirEntry, io, path::Path, path::PathBuf};
 
 use actix_web::{dev::ServiceResponse, HttpRequest, HttpResponse};
-use askama_escape::{escape as escape_html_entity, Html};
 use percent_encoding::{utf8_percent_encode, CONTROLS};
+use v_htmlescape::escape as escape_html_entity;
 
 /// A directory; responds with the generated directory listing.
 #[derive(Debug)]
@@ -50,7 +50,7 @@ macro_rules! encode_file_url {
 // " -- &quot;  & -- &amp;  ' -- &#x27;  < -- &lt;  > -- &gt;  / -- &#x2f;
 macro_rules! encode_file_name {
     ($entry:ident) => {
-        escape_html_entity(&$entry.file_name().to_string_lossy(), Html)
+        escape_html_entity(&$entry.file_name().to_string_lossy())
     };
 }
 
@@ -66,7 +66,9 @@ pub(crate) fn directory_listing(
         if dir.is_visible(&entry) {
             let entry = entry.unwrap();
             let p = match entry.path().strip_prefix(&dir.path) {
-                Ok(p) if cfg!(windows) => base.join(p).to_string_lossy().replace("\\", "/"),
+                Ok(p) if cfg!(windows) => {
+                    base.join(p).to_string_lossy().replace("\\", "/")
+                }
                 Ok(p) => base.join(p).to_string_lossy().into_owned(),
                 Err(_) => continue,
             };

actix-files/src/error.rs

@@ -1,4 +1,4 @@
-use actix_web::{http::StatusCode, ResponseError};
+use actix_web::{http::StatusCode, HttpResponse, ResponseError};
 use derive_more::Display;
 
 /// Errors which can occur when serving static files.
@@ -16,12 +16,11 @@ pub enum FilesError {
 
 /// Return `NotFound` for `FilesError`
 impl ResponseError for FilesError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::NOT_FOUND
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::NOT_FOUND)
     }
 }
 
-#[allow(clippy::enum_variant_names)]
 #[derive(Display, Debug, PartialEq)]
 pub enum UriSegmentError {
     /// The segment started with the wrapped invalid character.

actix-files/src/files.rs

@@ -1,34 +1,27 @@
-use std::{
-    cell::RefCell,
-    fmt, io,
-    path::{Path, PathBuf},
-    rc::Rc,
-};
+use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
 
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
-use actix_utils::future::ok;
+use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
 use actix_web::{
     dev::{
-        AppService, HttpServiceFactory, RequestHead, ResourceDef, ServiceRequest,
-        ServiceResponse,
+        AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
     },
     error::Error,
     guard::Guard,
     http::header::DispositionType,
     HttpRequest,
 };
-use futures_core::future::LocalBoxFuture;
+use futures_util::future::{ok, FutureExt, LocalBoxFuture};
 
 use crate::{
-    directory_listing, named, Directory, DirectoryRenderer, FilesService, HttpNewService,
-    MimeOverride, PathFilter,
+    directory_listing, named, Directory, DirectoryRenderer, FilesService,
+    HttpNewService, MimeOverride,
 };
 
 /// Static files handling service.
 ///
 /// `Files` service must be registered with `App::service()` method.
 ///
-/// ```
+/// ```rust
 /// use actix_web::App;
 /// use actix_files::Files;
 ///
@@ -44,11 +37,8 @@ pub struct Files {
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
-    path_filter: Option<Rc<PathFilter>>,
     file_flags: named::Flags,
-    use_guards: Option<Rc<dyn Guard>>,
-    guards: Vec<Rc<dyn Guard>>,
-    hidden_files: bool,
+    guards: Option<Rc<dyn Guard>>,
 }
 
 impl fmt::Debug for Files {
@@ -69,10 +59,7 @@ impl Clone for Files {
             file_flags: self.file_flags,
             path: self.path.clone(),
             mime_override: self.mime_override.clone(),
-            path_filter: self.path_filter.clone(),
-            use_guards: self.use_guards.clone(),
             guards: self.guards.clone(),
-            hidden_files: self.hidden_files,
         }
     }
 }
@@ -92,9 +79,9 @@ impl Files {
     /// If the mount path is set as the root path `/`, services registered after this one will
     /// be inaccessible. Register more specific handlers and services first.
     ///
-    /// `Files` utilizes the existing Tokio thread-pool for blocking filesystem operations.
-    /// The number of running threads is adjusted over time as needed, up to a maximum of 512 times
-    /// the number of server [workers](actix_web::HttpServer::workers), by default.
+    /// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
+    /// number of threads equal to 5x the number of available logical CPUs. Pool size can be changed
+    /// by setting ACTIX_THREADPOOL environment variable.
     pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
         let orig_dir = serve_from.into();
         let dir = match orig_dir.canonicalize() {
@@ -106,7 +93,7 @@ impl Files {
         };
 
         Files {
-            path: mount_path.trim_end_matches('/').to_owned(),
+            path: mount_path.to_owned(),
             directory: dir,
             index: None,
             show_index: false,
@@ -114,20 +101,14 @@ impl Files {
             default: Rc::new(RefCell::new(None)),
             renderer: Rc::new(directory_listing),
             mime_override: None,
-            path_filter: None,
             file_flags: named::Flags::default(),
-            use_guards: None,
-            guards: Vec::new(),
-            hidden_files: false,
+            guards: None,
         }
     }
 
     /// Show files listing for directories.
     ///
     /// By default show files listing is disabled.
-    ///
-    /// When used with [`Files::index_file()`], files listing is shown as a fallback
-    /// when the index file is not found.
     pub fn show_files_listing(mut self) -> Self {
         self.show_index = true;
         self
@@ -144,8 +125,8 @@ impl Files {
     /// Set custom directory renderer
     pub fn files_listing_renderer<F>(mut self, f: F) -> Self
     where
-        for<'r, 's> F:
-            Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error> + 'static,
+        for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
+            + 'static,
     {
         self.renderer = Rc::new(f);
         self
@@ -160,45 +141,10 @@ impl Files {
         self
     }
 
-    /// Sets path filtering closure.
-    ///
-    /// The path provided to the closure is relative to `serve_from` path.
-    /// You can safely join this path with the `serve_from` path to get the real path.
-    /// However, the real path may not exist since the filter is called before checking path existence.
-    ///
-    /// When a path doesn't pass the filter, [`Files::default_handler`] is called if set, otherwise,
-    /// `404 Not Found` is returned.
-    ///
-    /// # Examples
-    /// ```
-    /// use std::path::Path;
-    /// use actix_files::Files;
-    ///
-    /// // prevent searching subdirectories and following symlinks
-    /// let files_service = Files::new("/", "./static").path_filter(|path, _| {
-    ///     path.components().count() == 1
-    ///         && Path::new("./static")
-    ///             .join(path)
-    ///             .symlink_metadata()
-    ///             .map(|m| !m.file_type().is_symlink())
-    ///             .unwrap_or(false)
-    /// });
-    /// ```
-    pub fn path_filter<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&Path, &RequestHead) -> bool + 'static,
-    {
-        self.path_filter = Some(Rc::new(f));
-        self
-    }
-
     /// Set index file
     ///
-    /// Shows specific index file for directories instead of
+    /// Shows specific index file for directory "/" instead of
     /// showing files listing.
-    ///
-    /// If the index file is not found, files listing is shown as a fallback if
-    /// [`Files::show_files_listing()`] is set.
     pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
         self.index = Some(index.into());
         self
@@ -207,6 +153,7 @@ impl Files {
     /// Specifies whether to use ETag or not.
     ///
     /// Default is true.
+    #[inline]
     pub fn use_etag(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::ETAG, value);
         self
@@ -215,6 +162,7 @@ impl Files {
     /// Specifies whether to use Last-Modified or not.
     ///
     /// Default is true.
+    #[inline]
     pub fn use_last_modified(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::LAST_MD, value);
         self
@@ -223,80 +171,37 @@ impl Files {
     /// Specifies whether text responses should signal a UTF-8 encoding.
     ///
     /// Default is false (but will default to true in a future version).
+    #[inline]
     pub fn prefer_utf8(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::PREFER_UTF8, value);
         self
     }
 
-    /// Adds a routing guard.
+    /// Specifies custom guards to use for directory listings and files.
     ///
-    /// Use this to allow multiple chained file services that respond to strictly different
-    /// properties of a request. Due to the way routing works, if a guard check returns true and the
-    /// request starts being handled by the file service, it will not be able to back-out and try
-    /// the next service, you will simply get a 404 (or 405) error response.
-    ///
-    /// To allow `POST` requests to retrieve files, see [`Files::use_guards`].
-    ///
-    /// # Examples
-    /// ```
-    /// use actix_web::{guard::Header, App};
-    /// use actix_files::Files;
-    ///
-    /// App::new().service(
-    ///     Files::new("/","/my/site/files")
-    ///         .guard(Header("Host", "example.com"))
-    /// );
-    /// ```
-    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
-        self.guards.push(Rc::new(guard));
+    /// Default behaviour allows GET and HEAD.
+    #[inline]
+    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
+        self.guards = Some(Rc::new(guards));
         self
     }
 
-    /// Specifies guard to check before fetching directory listings or files.
-    ///
-    /// Note that this guard has no effect on routing; it's main use is to guard on the request's
-    /// method just before serving the file, only allowing `GET` and `HEAD` requests by default.
-    /// See [`Files::guard`] for routing guards.
-    pub fn method_guard<G: Guard + 'static>(mut self, guard: G) -> Self {
-        self.use_guards = Some(Rc::new(guard));
-        self
-    }
-
-    #[doc(hidden)]
-    #[deprecated(since = "0.6.0", note = "Renamed to `method_guard`.")]
-    /// See [`Files::method_guard`].
-    pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
-        self.method_guard(guard)
-    }
-
     /// Disable `Content-Disposition` header.
     ///
     /// By default Content-Disposition` header is enabled.
+    #[inline]
     pub fn disable_content_disposition(mut self) -> Self {
         self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
         self
     }
 
     /// Sets default handler which is used when no matched file could be found.
-    ///
-    /// # Examples
-    /// Setting a fallback static file handler:
-    /// ```
-    /// use actix_files::{Files, NamedFile};
-    ///
-    /// # fn run() -> Result<(), actix_web::Error> {
-    /// let files = Files::new("/", "./static")
-    ///     .index_file("index.html")
-    ///     .default_handler(NamedFile::open("./static/404.html")?);
-    /// # Ok(())
-    /// # }
-    /// ```
     pub fn default_handler<F, U>(mut self, f: F) -> Self
     where
-        F: IntoServiceFactory<U, ServiceRequest>,
+        F: IntoServiceFactory<U>,
         U: ServiceFactory<
-                ServiceRequest,
                 Config = (),
+                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
             > + 'static,
@@ -308,28 +213,10 @@ impl Files {
 
         self
     }
-
-    /// Enables serving hidden files and directories, allowing a leading dots in url fragments.
-    pub fn use_hidden_files(mut self) -> Self {
-        self.hidden_files = true;
-        self
-    }
 }
 
 impl HttpServiceFactory for Files {
-    fn register(mut self, config: &mut AppService) {
-        let guards = if self.guards.is_empty() {
-            None
-        } else {
-            let guards = std::mem::take(&mut self.guards);
-            Some(
-                guards
-                    .into_iter()
-                    .map(|guard| -> Box<dyn Guard> { Box::new(guard) })
-                    .collect::<Vec<_>>(),
-            )
-        };
-
+    fn register(self, config: &mut AppService) {
         if self.default.borrow().is_none() {
             *self.default.borrow_mut() = Some(config.default_service());
         }
@@ -340,11 +227,12 @@ impl HttpServiceFactory for Files {
             ResourceDef::prefix(&self.path)
         };
 
-        config.register_service(rdef, guards, self, None)
+        config.register_service(rdef, None, self, None)
     }
 }
 
-impl ServiceFactory<ServiceRequest> for Files {
+impl ServiceFactory for Files {
+    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Config = ();
@@ -361,25 +249,23 @@ impl ServiceFactory<ServiceRequest> for Files {
             default: None,
             renderer: self.renderer.clone(),
             mime_override: self.mime_override.clone(),
-            path_filter: self.path_filter.clone(),
             file_flags: self.file_flags,
-            guards: self.use_guards.clone(),
-            hidden_files: self.hidden_files,
+            guards: self.guards.clone(),
         };
 
         if let Some(ref default) = *self.default.borrow() {
-            let fut = default.new_service(());
-            Box::pin(async {
-                match fut.await {
+            default
+                .new_service(())
+                .map(move |result| match result {
                     Ok(default) => {
                         srv.default = Some(default);
                         Ok(srv)
                     }
                     Err(_) => Err(()),
-                }
-            })
+                })
+                .boxed_local()
         } else {
-            Box::pin(ok(srv))
+            ok(srv).boxed_local()
         }
     }
 }

actix-files/src/lib.rs

@@ -3,7 +3,7 @@
 //! Provides a non-blocking service for serving static files from disk.
 //!
 //! # Example
-//! ```
+//! ```rust
 //! use actix_web::App;
 //! use actix_files::Files;
 //!
@@ -14,14 +14,15 @@
 #![deny(rust_2018_idioms)]
 #![warn(missing_docs, missing_debug_implementations)]
 
+use std::io;
+
 use actix_service::boxed::{BoxService, BoxServiceFactory};
 use actix_web::{
-    dev::{RequestHead, ServiceRequest, ServiceResponse},
-    error::Error,
+    dev::{ServiceRequest, ServiceResponse},
+    error::{BlockingError, Error, ErrorInternalServerError},
     http::header::DispositionType,
 };
 use mime_guess::from_ext;
-use std::path::Path;
 
 mod chunked;
 mod directory;
@@ -55,9 +56,14 @@ pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
     from_ext(ext).first_or_octet_stream()
 }
 
-type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
+pub(crate) fn handle_error(err: BlockingError<io::Error>) -> Error {
+    match err {
+        BlockingError::Error(err) => err.into(),
+        BlockingError::Canceled => ErrorInternalServerError("Unexpected error"),
+    }
+}
 
-type PathFilter = dyn Fn(&Path, &RequestHead) -> bool;
+type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
 
 #[cfg(test)]
 mod tests {
@@ -68,7 +74,6 @@ mod tests {
     };
 
     use actix_service::ServiceFactory;
-    use actix_utils::future::ok;
     use actix_web::{
         guard,
         http::{
@@ -77,13 +82,13 @@ mod tests {
         },
         middleware::Compress,
         test::{self, TestRequest},
-        web::{self, Bytes},
-        App, HttpResponse, Responder,
+        web, App, HttpResponse, Responder,
     };
+    use futures_util::future::ok;
 
     use super::*;
 
-    #[actix_web::test]
+    #[actix_rt::test]
     async fn test_file_extension_to_mime() {
         let m = file_extension_to_mime("");
         assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
@@ -101,22 +106,11 @@ mod tests {
     #[actix_rt::test]
     async fn test_if_modified_since_without_if_none_match() {
         let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+        let since =
+            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
-            .insert_header((header::IF_MODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_modified_since_without_if_none_match_same() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = file.last_modified().unwrap();
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_MODIFIED_SINCE, since))
+            .header(header::IF_MODIFIED_SINCE, since)
             .to_http_request();
         let resp = file.respond_to(&req).await.unwrap();
         assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
@@ -125,40 +119,17 @@ mod tests {
     #[actix_rt::test]
     async fn test_if_modified_since_with_if_none_match() {
         let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+        let since =
+            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
-            .insert_header((header::IF_NONE_MATCH, "miss_etag"))
-            .insert_header((header::IF_MODIFIED_SINCE, since))
+            .header(header::IF_NONE_MATCH, "miss_etag")
+            .header(header::IF_MODIFIED_SINCE, since)
             .to_http_request();
         let resp = file.respond_to(&req).await.unwrap();
         assert_ne!(resp.status(), StatusCode::NOT_MODIFIED);
     }
 
-    #[actix_rt::test]
-    async fn test_if_unmodified_since() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = file.last_modified().unwrap();
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_UNMODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_unmodified_since_failed() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = header::HttpDate::from(SystemTime::UNIX_EPOCH);
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_UNMODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::PRECONDITION_FAILED);
-    }
-
     #[actix_rt::test]
     async fn test_named_file_text() {
         assert!(NamedFile::open("test--").is_err());
@@ -213,7 +184,8 @@ mod tests {
     #[actix_rt::test]
     async fn test_named_file_non_ascii_file_name() {
         let mut file =
-            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml").unwrap();
+            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml")
+                .unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -282,22 +254,6 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
-    async fn test_named_file_javascript() {
-        let file = NamedFile::open("tests/test.js").unwrap();
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "application/javascript"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"test.js\""
-        );
-    }
-
     #[actix_rt::test]
     async fn test_named_file_image_attachment() {
         let cd = ContentDisposition {
@@ -382,7 +338,7 @@ mod tests {
             DispositionType::Attachment
         }
 
-        let srv = test::init_service(
+        let mut srv = test::init_service(
             App::new().service(
                 Files::new("/", ".")
                     .mime_override(all_attachment)
@@ -392,7 +348,7 @@ mod tests {
         .await;
 
         let request = TestRequest::get().uri("/").to_request();
-        let response = test::call_service(&srv, request).await;
+        let response = test::call_service(&mut srv, request).await;
         assert_eq!(response.status(), StatusCode::OK);
 
         let content_disposition = response
@@ -407,7 +363,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_ranges_status_code() {
-        let srv = test::init_service(
+        let mut srv = test::init_service(
             App::new().service(Files::new("/test", ".").index_file("Cargo.toml")),
         )
         .await;
@@ -415,29 +371,29 @@ mod tests {
         // Valid range header
         let request = TestRequest::get()
             .uri("/t%65st/Cargo.toml")
-            .insert_header((header::RANGE, "bytes=10-20"))
+            .header(header::RANGE, "bytes=10-20")
             .to_request();
-        let response = test::call_service(&srv, request).await;
+        let response = test::call_service(&mut srv, request).await;
         assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
 
         // Invalid range header
         let request = TestRequest::get()
             .uri("/t%65st/Cargo.toml")
-            .insert_header((header::RANGE, "bytes=1-0"))
+            .header(header::RANGE, "bytes=1-0")
             .to_request();
-        let response = test::call_service(&srv, request).await;
+        let response = test::call_service(&mut srv, request).await;
 
         assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
     }
 
     #[actix_rt::test]
     async fn test_named_file_content_range_headers() {
-        let srv = actix_test::start(|| App::new().service(Files::new("/", ".")));
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
         // Valid range header
         let response = srv
             .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
+            .header(header::RANGE, "bytes=10-20")
             .send()
             .await
             .unwrap();
@@ -447,7 +403,7 @@ mod tests {
         // Invalid range header
         let response = srv
             .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-5"))
+            .header(header::RANGE, "bytes=10-5")
             .send()
             .await
             .unwrap();
@@ -457,12 +413,12 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_content_length_headers() {
-        let srv = actix_test::start(|| App::new().service(Files::new("/", ".")));
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
         // Valid range header
         let response = srv
             .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
+            .header(header::RANGE, "bytes=10-20")
             .send()
             .await
             .unwrap();
@@ -472,7 +428,7 @@ mod tests {
         // Valid range header, starting from 0
         let response = srv
             .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=0-20"))
+            .header(header::RANGE, "bytes=0-20")
             .send()
             .await
             .unwrap();
@@ -496,7 +452,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_head_content_length_headers() {
-        let srv = actix_test::start(|| App::new().service(Files::new("/", ".")));
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
         let response = srv.head("/tests/test.binary").send().await.unwrap();
 
@@ -512,14 +468,14 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_static_files_with_spaces() {
-        let srv = test::init_service(
+        let mut srv = test::init_service(
             App::new().service(Files::new("/", ".").index_file("Cargo.toml")),
         )
         .await;
         let request = TestRequest::get()
             .uri("/tests/test%20space.binary")
             .to_request();
-        let response = test::call_service(&srv, request).await;
+        let response = test::call_service(&mut srv, request).await;
         assert_eq!(response.status(), StatusCode::OK);
 
         let bytes = test::read_body(response).await;
@@ -529,29 +485,29 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_files_not_allowed() {
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+        let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
 
         let req = TestRequest::default()
             .uri("/Cargo.toml")
             .method(Method::POST)
             .to_request();
 
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
 
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+        let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
         let req = TestRequest::default()
             .method(Method::PUT)
             .uri("/Cargo.toml")
             .to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
     }
 
     #[actix_rt::test]
     async fn test_files_guards() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").method_guard(guard::Post())),
+        let mut srv = test::init_service(
+            App::new().service(Files::new("/", ".").use_guards(guard::Post())),
         )
         .await;
 
@@ -560,13 +516,13 @@ mod tests {
             .method(Method::POST)
             .to_request();
 
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[actix_rt::test]
     async fn test_named_file_content_encoding() {
-        let srv = test::init_service(App::new().wrap(Compress::default()).service(
+        let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
             web::resource("/").to(|| async {
                 NamedFile::open("Cargo.toml")
                     .unwrap()
@@ -577,16 +533,16 @@ mod tests {
 
         let request = TestRequest::get()
             .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
+            .header(header::ACCEPT_ENCODING, "gzip")
             .to_request();
-        let res = test::call_service(&srv, request).await;
+        let res = test::call_service(&mut srv, request).await;
         assert_eq!(res.status(), StatusCode::OK);
         assert!(!res.headers().contains_key(header::CONTENT_ENCODING));
     }
 
     #[actix_rt::test]
     async fn test_named_file_content_encoding_gzip() {
-        let srv = test::init_service(App::new().wrap(Compress::default()).service(
+        let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
             web::resource("/").to(|| async {
                 NamedFile::open("Cargo.toml")
                     .unwrap()
@@ -597,9 +553,9 @@ mod tests {
 
         let request = TestRequest::get()
             .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
+            .header(header::ACCEPT_ENCODING, "gzip")
             .to_request();
-        let res = test::call_service(&srv, request).await;
+        let res = test::call_service(&mut srv, request).await;
         assert_eq!(res.status(), StatusCode::OK);
         assert_eq!(
             res.headers()
@@ -621,25 +577,27 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_static_files() {
-        let srv =
-            test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
-                .await;
+        let mut srv = test::init_service(
+            App::new().service(Files::new("/", ".").show_files_listing()),
+        )
+        .await;
         let req = TestRequest::with_uri("/missing").to_request();
 
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+        let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
 
         let req = TestRequest::default().to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
-        let srv =
-            test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
-                .await;
+        let mut srv = test::init_service(
+            App::new().service(Files::new("/", ".").show_files_listing()),
+        )
+        .await;
         let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(
             resp.headers().get(header::CONTENT_TYPE).unwrap(),
             "text/html; charset=utf-8"
@@ -651,17 +609,17 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_redirect_to_slash_directory() {
-        // should not redirect if no index and files listing is disabled
-        let srv = test::init_service(
+        // should not redirect if no index
+        let mut srv = test::init_service(
             App::new().service(Files::new("/", ".").redirect_to_slash_directory()),
         )
         .await;
         let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
         // should redirect if index present
-        let srv = test::init_service(
+        let mut srv = test::init_service(
             App::new().service(
                 Files::new("/", ".")
                     .index_file("test.png")
@@ -670,41 +628,24 @@ mod tests {
         )
         .await;
         let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::FOUND);
-
-        // should redirect if files listing is enabled
-        let srv = test::init_service(
-            App::new().service(
-                Files::new("/", ".")
-                    .show_files_listing()
-                    .redirect_to_slash_directory(),
-            ),
-        )
-        .await;
-        let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::FOUND);
 
         // should not redirect if the path is wrong
         let req = TestRequest::with_uri("/not_existing").to_request();
-        let resp = test::call_service(&srv, req).await;
+        let resp = test::call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
     #[actix_rt::test]
     async fn test_static_files_bad_directory() {
-        let service = Files::new("/", "./missing").new_service(()).await.unwrap();
-
-        let req = TestRequest::with_uri("/").to_srv_request();
-        let resp = test::call_service(&service, req).await;
-
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        let _st: Files = Files::new("/", "missing");
+        let _st: Files = Files::new("/", "Cargo.toml");
     }
 
     #[actix_rt::test]
     async fn test_default_handler_file_missing() {
-        let st = Files::new("/", ".")
+        let mut st = Files::new("/", ".")
             .default_handler(|req: ServiceRequest| {
                 ok(req.into_response(HttpResponse::Ok().body("default content")))
             })
@@ -712,232 +653,124 @@ mod tests {
             .await
             .unwrap();
         let req = TestRequest::with_uri("/missing").to_srv_request();
-        let resp = test::call_service(&st, req).await;
 
+        let resp = test::call_service(&mut st, req).await;
         assert_eq!(resp.status(), StatusCode::OK);
         let bytes = test::read_body(resp).await;
         assert_eq!(bytes, web::Bytes::from_static(b"default content"));
     }
 
-    #[actix_rt::test]
-    async fn test_serve_index_nested() {
-        let service = Files::new(".", ".")
-            .index_file("lib.rs")
-            .new_service(())
-            .await
-            .unwrap();
+    //     #[actix_rt::test]
+    //     async fn test_serve_index() {
+    //         let st = Files::new(".").index_file("test.binary");
+    //         let req = TestRequest::default().uri("/tests").finish();
 
-        let req = TestRequest::default().uri("/src").to_srv_request();
-        let resp = test::call_service(&service, req).await;
+    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+    //         let resp = resp.as_msg();
+    //         assert_eq!(resp.status(), StatusCode::OK);
+    //         assert_eq!(
+    //             resp.headers()
+    //                 .get(header::CONTENT_TYPE)
+    //                 .expect("content type"),
+    //             "application/octet-stream"
+    //         );
+    //         assert_eq!(
+    //             resp.headers()
+    //                 .get(header::CONTENT_DISPOSITION)
+    //                 .expect("content disposition"),
+    //             "attachment; filename=\"test.binary\""
+    //         );
 
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-rust"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"lib.rs\""
-        );
-    }
+    //         let req = TestRequest::default().uri("/tests/").finish();
+    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+    //         let resp = resp.as_msg();
+    //         assert_eq!(resp.status(), StatusCode::OK);
+    //         assert_eq!(
+    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
+    //             "application/octet-stream"
+    //         );
+    //         assert_eq!(
+    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+    //             "attachment; filename=\"test.binary\""
+    //         );
 
-    #[actix_rt::test]
-    async fn integration_serve_index() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
+    //         // nonexistent index file
+    //         let req = TestRequest::default().uri("/tests/unknown").finish();
+    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+    //         let resp = resp.as_msg();
+    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
-        let req = TestRequest::get().uri("/test").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
+    //         let req = TestRequest::default().uri("/tests/unknown/").finish();
+    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+    //         let resp = resp.as_msg();
+    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    //     }
 
-        let bytes = test::read_body(res).await;
+    //     #[actix_rt::test]
+    //     async fn test_serve_index_nested() {
+    //         let st = Files::new(".").index_file("mod.rs");
+    //         let req = TestRequest::default().uri("/src/client").finish();
+    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+    //         let resp = resp.as_msg();
+    //         assert_eq!(resp.status(), StatusCode::OK);
+    //         assert_eq!(
+    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
+    //             "text/x-rust"
+    //         );
+    //         assert_eq!(
+    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+    //             "inline; filename=\"mod.rs\""
+    //         );
+    //     }
 
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
+    //     #[actix_rt::test]
+    //     fn integration_serve_index() {
+    //         let mut srv = test::TestServer::with_factory(|| {
+    //             App::new().handler(
+    //                 "test",
+    //                 Files::new(".").index_file("Cargo.toml"),
+    //             )
+    //         });
 
-        let req = TestRequest::get().uri("/test/").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
+    //         let request = srv.get().uri(srv.url("/test")).finish().unwrap();
+    //         let response = srv.execute(request.send()).unwrap();
+    //         assert_eq!(response.status(), StatusCode::OK);
+    //         let bytes = srv.execute(response.body()).unwrap();
+    //         let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+    //         assert_eq!(bytes, data);
 
-        let bytes = test::read_body(res).await;
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
+    //         let request = srv.get().uri(srv.url("/test/")).finish().unwrap();
+    //         let response = srv.execute(request.send()).unwrap();
+    //         assert_eq!(response.status(), StatusCode::OK);
+    //         let bytes = srv.execute(response.body()).unwrap();
+    //         let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+    //         assert_eq!(bytes, data);
 
-        // nonexistent index file
-        let req = TestRequest::get().uri("/test/unknown").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    //         // nonexistent index file
+    //         let request = srv.get().uri(srv.url("/test/unknown")).finish().unwrap();
+    //         let response = srv.execute(request.send()).unwrap();
+    //         assert_eq!(response.status(), StatusCode::NOT_FOUND);
 
-        let req = TestRequest::get().uri("/test/unknown/").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-    }
+    //         let request = srv.get().uri(srv.url("/test/unknown/")).finish().unwrap();
+    //         let response = srv.execute(request.send()).unwrap();
+    //         assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    //     }
 
-    #[actix_rt::test]
-    async fn integration_percent_encoded() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
+    //     #[actix_rt::test]
+    //     fn integration_percent_encoded() {
+    //         let mut srv = test::TestServer::with_factory(|| {
+    //             App::new().handler(
+    //                 "test",
+    //                 Files::new(".").index_file("Cargo.toml"),
+    //             )
+    //         });
 
-        let req = TestRequest::get().uri("/test/%43argo.toml").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_serve_named_file() {
-        let srv =
-            test::init_service(App::new().service(NamedFile::open("Cargo.toml").unwrap()))
-                .await;
-
-        let req = TestRequest::get().uri("/Cargo.toml").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-
-        let bytes = test::read_body(res).await;
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
-
-        let req = TestRequest::get().uri("/test/unknown").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_serve_named_file_prefix() {
-        let srv = test::init_service(
-            App::new()
-                .service(web::scope("/test").service(NamedFile::open("Cargo.toml").unwrap())),
-        )
-        .await;
-
-        let req = TestRequest::get().uri("/test/Cargo.toml").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-
-        let bytes = test::read_body(res).await;
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
-
-        let req = TestRequest::get().uri("/Cargo.toml").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_default_service() {
-        let srv = test::init_service(
-            App::new().default_service(NamedFile::open("Cargo.toml").unwrap()),
-        )
-        .await;
-
-        for route in ["/foobar", "/baz", "/"].iter() {
-            let req = TestRequest::get().uri(route).to_request();
-            let res = test::call_service(&srv, req).await;
-            assert_eq!(res.status(), StatusCode::OK);
-
-            let bytes = test::read_body(res).await;
-            let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-            assert_eq!(bytes, data);
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_default_handler_named_file() {
-        let st = Files::new("/", ".")
-            .default_handler(NamedFile::open("Cargo.toml").unwrap())
-            .new_service(())
-            .await
-            .unwrap();
-        let req = TestRequest::with_uri("/missing").to_srv_request();
-        let resp = test::call_service(&st, req).await;
-
-        assert_eq!(resp.status(), StatusCode::OK);
-        let bytes = test::read_body(resp).await;
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
-    }
-
-    #[actix_rt::test]
-    async fn test_symlinks() {
-        let srv = test::init_service(App::new().service(Files::new("test", "."))).await;
-
-        let req = TestRequest::get()
-            .uri("/test/tests/symlink-test.png")
-            .to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-        assert_eq!(
-            res.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"symlink-test.png\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_index_with_show_files_listing() {
-        let service = Files::new(".", ".")
-            .index_file("lib.rs")
-            .show_files_listing()
-            .new_service(())
-            .await
-            .unwrap();
-
-        // Serve the index if exists
-        let req = TestRequest::default().uri("/src").to_srv_request();
-        let resp = test::call_service(&service, req).await;
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-rust"
-        );
-
-        // Show files listing, otherwise.
-        let req = TestRequest::default().uri("/tests").to_srv_request();
-        let resp = test::call_service(&service, req).await;
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/html; charset=utf-8"
-        );
-        let bytes = test::read_body(resp).await;
-        assert!(format!("{:?}", bytes).contains("/tests/test.png"));
-    }
-
-    #[actix_rt::test]
-    async fn test_path_filter() {
-        // prevent searching subdirectories
-        let st = Files::new("/", ".")
-            .path_filter(|path, _| path.components().count() == 1)
-            .new_service(())
-            .await
-            .unwrap();
-
-        let req = TestRequest::with_uri("/Cargo.toml").to_srv_request();
-        let resp = test::call_service(&st, req).await;
-        assert_eq!(resp.status(), StatusCode::OK);
-
-        let req = TestRequest::with_uri("/src/lib.rs").to_srv_request();
-        let resp = test::call_service(&st, req).await;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_default_handler_filter() {
-        let st = Files::new("/", ".")
-            .default_handler(|req: ServiceRequest| {
-                ok(req.into_response(HttpResponse::Ok().body("default content")))
-            })
-            .path_filter(|path, _| path.extension() == Some("png".as_ref()))
-            .new_service(())
-            .await
-            .unwrap();
-        let req = TestRequest::with_uri("/Cargo.toml").to_srv_request();
-        let resp = test::call_service(&st, req).await;
-
-        assert_eq!(resp.status(), StatusCode::OK);
-        let bytes = test::read_body(resp).await;
-        assert_eq!(bytes, web::Bytes::from_static(b"default content"));
-    }
+    //         let request = srv
+    //             .get()
+    //             .uri(srv.url("/test/%43argo.toml"))
+    //             .finish()
+    //             .unwrap();
+    //         let response = srv.execute(request.send()).unwrap();
+    //         assert_eq!(response.status(), StatusCode::OK);
+    //     }
 }

actix-files/src/named.rs

@@ -1,6 +1,3 @@
-use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ok, ready, Ready};
-use actix_web::dev::{AppService, HttpServiceFactory, ResourceDef};
 use std::fs::{File, Metadata};
 use std::io;
 use std::ops::{Deref, DerefMut};
@@ -11,16 +8,18 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use std::os::unix::fs::MetadataExt;
 
 use actix_web::{
-    dev::{BodyEncoding, ServiceRequest, ServiceResponse, SizedStream},
+    dev::{BodyEncoding, SizedStream},
     http::{
         header::{
-            self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
+            self, Charset, ContentDisposition, DispositionParam, DispositionType,
+            ExtendedValue,
         },
         ContentEncoding, StatusCode,
     },
     Error, HttpMessage, HttpRequest, HttpResponse, Responder,
 };
 use bitflags::bitflags;
+use futures_util::future::{ready, Ready};
 use mime_guess::from_path;
 
 use crate::ChunkedReadFile;
@@ -42,29 +41,6 @@ impl Default for Flags {
 }
 
 /// A file with an associated name.
-///
-/// `NamedFile` can be registered as services:
-/// ```
-/// use actix_web::App;
-/// use actix_files::NamedFile;
-///
-/// # fn run() -> Result<(), Box<dyn std::error::Error>> {
-/// let app = App::new()
-///     .service(NamedFile::open("./static/index.html")?);
-/// # Ok(())
-/// # }
-/// ```
-///
-/// They can also be returned from handlers:
-/// ```
-/// use actix_web::{Responder, get};
-/// use actix_files::NamedFile;
-///
-/// #[get("/")]
-/// async fn index() -> impl Responder {
-///     NamedFile::open("./static/index.html")
-/// }
-/// ```
 #[derive(Debug)]
 pub struct NamedFile {
     path: PathBuf,
@@ -86,7 +62,7 @@ impl NamedFile {
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust
     /// use actix_files::NamedFile;
     /// use std::io::{self, Write};
     /// use std::env;
@@ -120,11 +96,6 @@ impl NamedFile {
 
             let disposition = match ct.type_() {
                 mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
-                mime::APPLICATION => match ct.subtype() {
-                    mime::JAVASCRIPT | mime::JSON => DispositionType::Inline,
-                    name if name == "wasm" => DispositionType::Inline,
-                    _ => DispositionType::Attachment,
-                },
                 _ => DispositionType::Attachment,
             };
 
@@ -168,7 +139,7 @@ impl NamedFile {
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust
     /// use actix_files::NamedFile;
     ///
     /// let file = NamedFile::open("foo.txt");
@@ -187,7 +158,7 @@ impl NamedFile {
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust
     /// # use std::io;
     /// use actix_files::NamedFile;
     ///
@@ -218,11 +189,9 @@ impl NamedFile {
 
     /// Set the Content-Disposition for serving this file. This allows
     /// changing the inline/attachment disposition as well as the filename
-    /// sent to the peer.
-    ///
-    /// By default the disposition is `inline` for `text/*`, `image/*`, `video/*` and
-    /// `application/{javascript, json, wasm}` mime types, and `attachment` otherwise,
-    /// and the filename is taken from the path provided in the `open` method
+    /// sent to the peer. By default the disposition is `inline` for text,
+    /// image, and video content types, and `attachment` otherwise, and
+    /// the filename is taken from the path provided in the `open` method
     /// after converting it to UTF-8 using.
     /// [`std::ffi::OsStr::to_string_lossy`]
     #[inline]
@@ -242,8 +211,6 @@ impl NamedFile {
     }
 
     /// Set content encoding for serving this file
-    ///
-    /// Must be used with [`actix_web::middleware::Compress`] to take effect.
     #[inline]
     pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
         self.encoding = Some(enc);
@@ -310,31 +277,37 @@ impl NamedFile {
     }
 
     /// Creates an `HttpResponse` with file as a streaming body.
-    pub fn into_response(self, req: &HttpRequest) -> HttpResponse {
+    pub fn into_response(self, req: &HttpRequest) -> Result<HttpResponse, Error> {
         if self.status_code != StatusCode::OK {
             let mut res = HttpResponse::build(self.status_code);
 
             if self.flags.contains(Flags::PREFER_UTF8) {
                 let ct = equiv_utf8_text(self.content_type.clone());
-                res.insert_header((header::CONTENT_TYPE, ct.to_string()));
+                res.header(header::CONTENT_TYPE, ct.to_string());
             } else {
-                res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
+                res.header(header::CONTENT_TYPE, self.content_type.to_string());
             }
 
             if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-                res.insert_header((
+                res.header(
                     header::CONTENT_DISPOSITION,
                     self.content_disposition.to_string(),
-                ));
+                );
             }
 
             if let Some(current_encoding) = self.encoding {
                 res.encoding(current_encoding);
             }
 
-            let reader = ChunkedReadFile::new(self.md.len(), 0, self.file);
+            let reader = ChunkedReadFile {
+                size: self.md.len(),
+                offset: 0,
+                file: Some(self.file),
+                fut: None,
+                counter: 0,
+            };
 
-            return res.streaming(reader);
+            return Ok(res.streaming(reader));
         }
 
         let etag = if self.flags.contains(Flags::ETAG) {
@@ -355,11 +328,11 @@ impl NamedFile {
         } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
             (last_modified, req.get_header())
         {
-            let t1: SystemTime = (*m).into();
-            let t2: SystemTime = (*since).into();
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
 
             match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1.as_secs() > t2.as_secs(),
+                (Ok(t1), Ok(t2)) => t1 > t2,
                 _ => false,
             }
         } else {
@@ -374,11 +347,11 @@ impl NamedFile {
         } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
             (last_modified, req.get_header())
         {
-            let t1: SystemTime = (*m).into();
-            let t2: SystemTime = (*since).into();
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
 
             match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1.as_secs() <= t2.as_secs(),
+                (Ok(t1), Ok(t2)) => t1 <= t2,
                 _ => false,
             }
         } else {
@@ -389,16 +362,16 @@ impl NamedFile {
 
         if self.flags.contains(Flags::PREFER_UTF8) {
             let ct = equiv_utf8_text(self.content_type.clone());
-            resp.insert_header((header::CONTENT_TYPE, ct.to_string()));
+            resp.header(header::CONTENT_TYPE, ct.to_string());
         } else {
-            resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
+            resp.header(header::CONTENT_TYPE, self.content_type.to_string());
         }
 
         if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-            resp.insert_header((
+            resp.header(
                 header::CONTENT_DISPOSITION,
                 self.content_disposition.to_string(),
-            ));
+            );
         }
 
         // default compressing
@@ -407,14 +380,14 @@ impl NamedFile {
         }
 
         if let Some(lm) = last_modified {
-            resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
+            resp.header(header::LAST_MODIFIED, lm.to_string());
         }
 
         if let Some(etag) = etag {
-            resp.insert_header((header::ETAG, etag.to_string()));
+            resp.header(header::ETAG, etag.to_string());
         }
 
-        resp.insert_header((header::ACCEPT_RANGES, "bytes"));
+        resp.header(header::ACCEPT_RANGES, "bytes");
 
         let mut length = self.md.len();
         let mut offset = 0;
@@ -427,32 +400,43 @@ impl NamedFile {
                     offset = ranges[0].start;
 
                     resp.encoding(ContentEncoding::Identity);
-                    resp.insert_header((
+                    resp.header(
                         header::CONTENT_RANGE,
-                        format!("bytes {}-{}/{}", offset, offset + length - 1, self.md.len()),
-                    ));
+                        format!(
+                            "bytes {}-{}/{}",
+                            offset,
+                            offset + length - 1,
+                            self.md.len()
+                        ),
+                    );
                 } else {
-                    resp.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
-                    return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
+                    resp.header(header::CONTENT_RANGE, format!("bytes */{}", length));
+                    return Ok(resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish());
                 };
             } else {
-                return resp.status(StatusCode::BAD_REQUEST).finish();
+                return Ok(resp.status(StatusCode::BAD_REQUEST).finish());
             };
         };
 
         if precondition_failed {
-            return resp.status(StatusCode::PRECONDITION_FAILED).finish();
+            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish());
         } else if not_modified {
-            return resp.status(StatusCode::NOT_MODIFIED).finish();
+            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
         }
 
-        let reader = ChunkedReadFile::new(length, offset, self.file);
+        let reader = ChunkedReadFile {
+            offset,
+            size: length,
+            file: Some(self.file),
+            fut: None,
+            counter: 0,
+        };
 
         if offset != 0 || length != self.md.len() {
             resp.status(StatusCode::PARTIAL_CONTENT);
         }
 
-        resp.body(SizedStream::new(length, reader))
+        Ok(resp.body(SizedStream::new(length, reader)))
     }
 }
 
@@ -511,57 +495,10 @@ fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
 }
 
 impl Responder for NamedFile {
-    fn respond_to(self, req: &HttpRequest) -> HttpResponse {
-        self.into_response(req)
-    }
-}
-
-impl ServiceFactory<ServiceRequest> for NamedFile {
-    type Response = ServiceResponse;
     type Error = Error;
-    type Config = ();
-    type InitError = ();
-    type Service = NamedFileService;
-    type Future = Ready<Result<Self::Service, ()>>;
+    type Future = Ready<Result<HttpResponse, Error>>;
 
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(NamedFileService {
-            path: self.path.clone(),
-        })
-    }
-}
-
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct NamedFileService {
-    path: PathBuf,
-}
-
-impl Service<ServiceRequest> for NamedFileService {
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, req: ServiceRequest) -> Self::Future {
-        let (req, _) = req.into_parts();
-        ready(
-            NamedFile::open(&self.path)
-                .map_err(|e| e.into())
-                .map(|f| f.into_response(&req))
-                .map(|res| ServiceResponse::new(req, res)),
-        )
-    }
-}
-
-impl HttpServiceFactory for NamedFile {
-    fn register(self, config: &mut AppService) {
-        config.register_service(
-            ResourceDef::root_prefix(self.path.to_string_lossy().as_ref()),
-            None,
-            self,
-            None,
-        )
+    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+        ready(self.into_response(req))
     }
 }

actix-files/src/path_buf.rs

@@ -3,8 +3,8 @@ use std::{
     str::FromStr,
 };
 
-use actix_utils::future::{ready, Ready};
 use actix_web::{dev::Payload, FromRequest, HttpRequest};
+use futures_util::future::{ready, Ready};
 
 use crate::error::UriSegmentError;
 
@@ -15,19 +15,12 @@ impl FromStr for PathBufWrap {
     type Err = UriSegmentError;
 
     fn from_str(path: &str) -> Result<Self, Self::Err> {
-        Self::parse_path(path, false)
-    }
-}
-
-impl PathBufWrap {
-    /// Parse a path, giving the choice of allowing hidden files to be considered valid segments.
-    pub fn parse_path(path: &str, hidden_files: bool) -> Result<Self, UriSegmentError> {
         let mut buf = PathBuf::new();
 
         for segment in path.split('/') {
             if segment == ".." {
                 buf.pop();
-            } else if !hidden_files && segment.starts_with('.') {
+            } else if segment.starts_with('.') {
                 return Err(UriSegmentError::BadStart('.'));
             } else if segment.starts_with('*') {
                 return Err(UriSegmentError::BadStart('*'));
@@ -59,6 +52,7 @@ impl AsRef<Path> for PathBufWrap {
 impl FromRequest for PathBufWrap {
     type Error = UriSegmentError;
     type Future = Ready<Result<Self, Self::Error>>;
+    type Config = ();
 
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         ready(req.match_info().path().parse())
@@ -102,17 +96,4 @@ mod tests {
             PathBuf::from_iter(vec!["seg2"])
         );
     }
-
-    #[test]
-    fn test_parse_path() {
-        assert_eq!(
-            PathBufWrap::parse_path("/test/.tt", false).map(|t| t.0),
-            Err(UriSegmentError::BadStart('.'))
-        );
-
-        assert_eq!(
-            PathBufWrap::parse_path("/test/.tt", true).unwrap().0,
-            PathBuf::from_iter(vec!["test", ".tt"])
-        );
-    }
 }

actix-files/src/range.rs

@@ -1,5 +1,3 @@
-use derive_more::{Display, Error};
-
 /// HTTP Range header representation.
 #[derive(Debug, Clone, Copy)]
 pub struct HttpRange {
@@ -10,26 +8,91 @@ pub struct HttpRange {
     pub length: u64,
 }
 
-#[derive(Debug, Clone, Display, Error)]
-#[display(fmt = "Parse HTTP Range failed")]
-pub struct ParseRangeErr(#[error(not(source))] ());
+const PREFIX: &str = "bytes=";
+const PREFIX_LEN: usize = 6;
 
 impl HttpRange {
     /// Parses Range HTTP header string as per RFC 2616.
     ///
     /// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
     /// `size` is full size of response (file).
-    pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ParseRangeErr> {
-        match http_range::HttpRange::parse(header, size) {
-            Ok(ranges) => Ok(ranges
-                .iter()
-                .map(|range| HttpRange {
-                    start: range.start,
-                    length: range.length,
-                })
-                .collect()),
-            Err(_) => Err(ParseRangeErr(())),
+    pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ()> {
+        if header.is_empty() {
+            return Ok(Vec::new());
         }
+        if !header.starts_with(PREFIX) {
+            return Err(());
+        }
+
+        let size_sig = size as i64;
+        let mut no_overlap = false;
+
+        let all_ranges: Vec<Option<HttpRange>> = header[PREFIX_LEN..]
+            .split(',')
+            .map(|x| x.trim())
+            .filter(|x| !x.is_empty())
+            .map(|ra| {
+                let mut start_end_iter = ra.split('-');
+
+                let start_str = start_end_iter.next().ok_or(())?.trim();
+                let end_str = start_end_iter.next().ok_or(())?.trim();
+
+                if start_str.is_empty() {
+                    // If no start is specified, end specifies the
+                    // range start relative to the end of the file.
+                    let mut length: i64 = end_str.parse().map_err(|_| ())?;
+
+                    if length > size_sig {
+                        length = size_sig;
+                    }
+
+                    Ok(Some(HttpRange {
+                        start: (size_sig - length) as u64,
+                        length: length as u64,
+                    }))
+                } else {
+                    let start: i64 = start_str.parse().map_err(|_| ())?;
+
+                    if start < 0 {
+                        return Err(());
+                    }
+                    if start >= size_sig {
+                        no_overlap = true;
+                        return Ok(None);
+                    }
+
+                    let length = if end_str.is_empty() {
+                        // If no end is specified, range extends to end of the file.
+                        size_sig - start
+                    } else {
+                        let mut end: i64 = end_str.parse().map_err(|_| ())?;
+
+                        if start > end {
+                            return Err(());
+                        }
+
+                        if end >= size_sig {
+                            end = size_sig - 1;
+                        }
+
+                        end - start + 1
+                    };
+
+                    Ok(Some(HttpRange {
+                        start: start as u64,
+                        length: length as u64,
+                    }))
+                }
+            })
+            .collect::<Result<_, _>>()?;
+
+        let ranges: Vec<HttpRange> = all_ranges.into_iter().filter_map(|x| x).collect();
+
+        if no_overlap && ranges.is_empty() {
+            return Err(());
+        }
+
+        Ok(ranges)
     }
 }
 
@@ -270,7 +333,8 @@ mod tests {
                 if expected.is_empty() {
                     continue;
                 } else {
-                    panic!(
+                    assert!(
+                        false,
                         "parse({}, {}) returned error {:?}",
                         header,
                         size,
@@ -282,24 +346,28 @@ mod tests {
             let got = res.unwrap();
 
             if got.len() != expected.len() {
-                panic!(
+                assert!(
+                    false,
                     "len(parseRange({}, {})) = {}, want {}",
                     header,
                     size,
                     got.len(),
                     expected.len()
                 );
+                continue;
             }
 
             for i in 0..expected.len() {
                 if got[i].start != expected[i].start {
-                    panic!(
+                    assert!(
+                        false,
                         "parseRange({}, {})[{}].start = {}, want {}",
                         header, size, i, got[i].start, expected[i].start
                     )
                 }
                 if got[i].length != expected[i].length {
-                    panic!(
+                    assert!(
+                        false,
                         "parseRange({}, {})[{}].length = {}, want {}",
                         header, size, i, got[i].length, expected[i].length
                     )

actix-files/src/service.rs

@@ -1,7 +1,11 @@
-use std::{fmt, io, path::PathBuf, rc::Rc};
+use std::{
+    fmt, io,
+    path::PathBuf,
+    rc::Rc,
+    task::{Context, Poll},
+};
 
 use actix_service::Service;
-use actix_utils::future::ok;
 use actix_web::{
     dev::{ServiceRequest, ServiceResponse},
     error::Error,
@@ -9,11 +13,11 @@ use actix_web::{
     http::{header, Method},
     HttpResponse,
 };
-use futures_core::future::LocalBoxFuture;
+use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
 
 use crate::{
-    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
-    PathBufWrap, PathFilter,
+    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride,
+    NamedFile, PathBufWrap,
 };
 
 /// Assembled file serving service.
@@ -25,24 +29,23 @@ pub struct FilesService {
     pub(crate) default: Option<HttpService>,
     pub(crate) renderer: Rc<DirectoryRenderer>,
     pub(crate) mime_override: Option<Rc<MimeOverride>>,
-    pub(crate) path_filter: Option<Rc<PathFilter>>,
     pub(crate) file_flags: named::Flags,
     pub(crate) guards: Option<Rc<dyn Guard>>,
-    pub(crate) hidden_files: bool,
 }
 
-impl FilesService {
-    fn handle_err(
-        &self,
-        err: io::Error,
-        req: ServiceRequest,
-    ) -> LocalBoxFuture<'static, Result<ServiceResponse, Error>> {
-        log::debug!("error handling {}: {}", req.path(), err);
+type FilesServiceFuture = Either<
+    Ready<Result<ServiceResponse, Error>>,
+    LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
+>;
 
-        if let Some(ref default) = self.default {
-            Box::pin(default.call(req))
+impl FilesService {
+    fn handle_err(&mut self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
+        log::debug!("Failed to handle {}: {}", req.path(), e);
+
+        if let Some(ref mut default) = self.default {
+            Either::Right(default.call(req))
         } else {
-            Box::pin(ok(req.error_response(err)))
+            Either::Left(ok(req.error_response(e)))
         }
     }
 }
@@ -53,14 +56,17 @@ impl fmt::Debug for FilesService {
     }
 }
 
-impl Service<ServiceRequest> for FilesService {
+impl Service for FilesService {
+    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
+    type Future = FilesServiceFuture;
 
-    actix_service::always_ready!();
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
 
-    fn call(&self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
         let is_method_valid = if let Some(guard) = &self.guards {
             // execute user defined guards
             (**guard).check(req.head())
@@ -70,101 +76,91 @@ impl Service<ServiceRequest> for FilesService {
         };
 
         if !is_method_valid {
-            return Box::pin(ok(req.into_response(
+            return Either::Left(ok(req.into_response(
                 actix_web::HttpResponse::MethodNotAllowed()
-                    .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
+                    .header(header::CONTENT_TYPE, "text/plain")
                     .body("Request did not meet this resource's requirements."),
             )));
         }
 
-        let real_path =
-            match PathBufWrap::parse_path(req.match_info().path(), self.hidden_files) {
-                Ok(item) => item,
-                Err(e) => return Box::pin(ok(req.error_response(e))),
-            };
-
-        if let Some(filter) = &self.path_filter {
-            if !filter(real_path.as_ref(), req.head()) {
-                if let Some(ref default) = self.default {
-                    return Box::pin(default.call(req));
-                } else {
-                    return Box::pin(ok(
-                        req.into_response(actix_web::HttpResponse::NotFound().finish())
-                    ));
-                }
-            }
-        }
+        let real_path: PathBufWrap = match req.match_info().path().parse() {
+            Ok(item) => item,
+            Err(e) => return Either::Left(ok(req.error_response(e))),
+        };
 
         // full file path
-        let path = self.directory.join(&real_path);
-        if let Err(err) = path.canonicalize() {
-            return Box::pin(self.handle_err(err, req));
-        }
+        let path = match self.directory.join(&real_path).canonicalize() {
+            Ok(path) => path,
+            Err(e) => return self.handle_err(e, req),
+        };
 
         if path.is_dir() {
-            if self.redirect_to_slash
-                && !req.path().ends_with('/')
-                && (self.index.is_some() || self.show_index)
-            {
-                let redirect_to = format!("{}/", req.path());
+            if let Some(ref redir_index) = self.index {
+                if self.redirect_to_slash && !req.path().ends_with('/') {
+                    let redirect_to = format!("{}/", req.path());
 
-                return Box::pin(ok(req.into_response(
-                    HttpResponse::Found()
-                        .insert_header((header::LOCATION, redirect_to))
-                        .finish(),
-                )));
-            }
-
-            let serve_named_file = |req: ServiceRequest, mut named_file: NamedFile| {
-                if let Some(ref mime_override) = self.mime_override {
-                    let new_disposition = mime_override(&named_file.content_type.type_());
-                    named_file.content_disposition.disposition = new_disposition;
+                    return Either::Left(ok(req.into_response(
+                        HttpResponse::Found()
+                            .header(header::LOCATION, redirect_to)
+                            .body("")
+                            .into_body(),
+                    )));
                 }
-                named_file.flags = self.file_flags;
 
-                let (req, _) = req.into_parts();
-                let res = named_file.into_response(&req);
-                Box::pin(ok(ServiceResponse::new(req, res)))
-            };
+                let path = path.join(redir_index);
 
-            let show_index = |req: ServiceRequest| {
-                let dir = Directory::new(self.directory.clone(), path.clone());
+                match NamedFile::open(path) {
+                    Ok(mut named_file) => {
+                        if let Some(ref mime_override) = self.mime_override {
+                            let new_disposition =
+                                mime_override(&named_file.content_type.type_());
+                            named_file.content_disposition.disposition = new_disposition;
+                        }
+                        named_file.flags = self.file_flags;
+
+                        let (req, _) = req.into_parts();
+                        Either::Left(ok(match named_file.into_response(&req) {
+                            Ok(item) => ServiceResponse::new(req, item),
+                            Err(e) => ServiceResponse::from_err(e, req),
+                        }))
+                    }
+                    Err(e) => self.handle_err(e, req),
+                }
+            } else if self.show_index {
+                let dir = Directory::new(self.directory.clone(), path);
 
                 let (req, _) = req.into_parts();
                 let x = (self.renderer)(&dir, &req);
 
-                Box::pin(match x {
-                    Ok(resp) => ok(resp),
-                    Err(err) => ok(ServiceResponse::from_err(err, req)),
-                })
-            };
-
-            match self.index {
-                Some(ref index) => match NamedFile::open(path.join(index)) {
-                    Ok(named_file) => serve_named_file(req, named_file),
-                    Err(_) if self.show_index => show_index(req),
-                    Err(err) => self.handle_err(err, req),
-                },
-                None if self.show_index => show_index(req),
-                _ => Box::pin(ok(ServiceResponse::from_err(
+                match x {
+                    Ok(resp) => Either::Left(ok(resp)),
+                    Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
+                }
+            } else {
+                Either::Left(ok(ServiceResponse::from_err(
                     FilesError::IsDirectory,
                     req.into_parts().0,
-                ))),
+                )))
             }
         } else {
             match NamedFile::open(path) {
                 Ok(mut named_file) => {
                     if let Some(ref mime_override) = self.mime_override {
-                        let new_disposition = mime_override(&named_file.content_type.type_());
+                        let new_disposition =
+                            mime_override(&named_file.content_type.type_());
                         named_file.content_disposition.disposition = new_disposition;
                     }
                     named_file.flags = self.file_flags;
 
                     let (req, _) = req.into_parts();
-                    let res = named_file.into_response(&req);
-                    Box::pin(ok(ServiceResponse::new(req, res)))
+                    match named_file.into_response(&req) {
+                        Ok(item) => {
+                            Either::Left(ok(ServiceResponse::new(req.clone(), item)))
+                        }
+                        Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
+                    }
                 }
-                Err(err) => self.handle_err(err, req),
+                Err(e) => self.handle_err(e, req),
             }
         }
     }

actix-files/tests/encoding.rs

@@ -8,13 +8,14 @@ use actix_web::{
     App,
 };
 
-#[actix_web::test]
+#[actix_rt::test]
 async fn test_utf8_file_contents() {
     // use default ISO-8859-1 encoding
-    let srv = test::init_service(App::new().service(Files::new("/", "./tests"))).await;
+    let mut srv =
+        test::init_service(App::new().service(Files::new("/", "./tests"))).await;
 
     let req = TestRequest::with_uri("/utf8.txt").to_request();
-    let res = test::call_service(&srv, req).await;
+    let res = test::call_service(&mut srv, req).await;
 
     assert_eq!(res.status(), StatusCode::OK);
     assert_eq!(
@@ -23,12 +24,13 @@ async fn test_utf8_file_contents() {
     );
 
     // prefer UTF-8 encoding
-    let srv =
-        test::init_service(App::new().service(Files::new("/", "./tests").prefer_utf8(true)))
-            .await;
+    let mut srv = test::init_service(
+        App::new().service(Files::new("/", "./tests").prefer_utf8(true)),
+    )
+    .await;
 
     let req = TestRequest::with_uri("/utf8.txt").to_request();
-    let res = test::call_service(&srv, req).await;
+    let res = test::call_service(&mut srv, req).await;
 
     assert_eq!(res.status(), StatusCode::OK);
     assert_eq!(

actix-files/tests/fixtures/guards/first/index.txt

@@ -1 +0,0 @@
-first

actix-files/tests/fixtures/guards/second/index.txt

@@ -1 +0,0 @@
-second

actix-files/tests/guard.rs

@@ -1,36 +0,0 @@
-use actix_files::Files;
-use actix_web::{
-    guard::Host,
-    http::StatusCode,
-    test::{self, TestRequest},
-    App,
-};
-use bytes::Bytes;
-
-#[actix_web::test]
-async fn test_guard_filter() {
-    let srv = test::init_service(
-        App::new()
-            .service(Files::new("/", "./tests/fixtures/guards/first").guard(Host("first.com")))
-            .service(
-                Files::new("/", "./tests/fixtures/guards/second").guard(Host("second.com")),
-            ),
-    )
-    .await;
-
-    let req = TestRequest::with_uri("/index.txt")
-        .append_header(("Host", "first.com"))
-        .to_request();
-    let res = test::call_service(&srv, req).await;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(test::read_body(res).await, Bytes::from("first"));
-
-    let req = TestRequest::with_uri("/index.txt")
-        .append_header(("Host", "second.com"))
-        .to_request();
-    let res = test::call_service(&srv, req).await;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(test::read_body(res).await, Bytes::from("second"));
-}

actix-files/tests/symlink-test.png

@@ -1 +0,0 @@
-test.png

actix-files/tests/test.js

@@ -1 +0,0 @@
-// this file is empty.

actix-http-test/Cargo.toml

@@ -1,54 +0,0 @@
-[package]
-name = "actix-http-test"
-version = "3.0.0-beta.5"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Various helpers for Actix applications to use during testing"
-keywords = ["http", "web", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket",
-]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[package.metadata.docs.rs]
-features = []
-
-[lib]
-name = "actix_http_test"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# openssl
-openssl = ["tls-openssl", "awc/openssl"]
-
-[dependencies]
-actix-service = "2.0.0"
-actix-codec = "0.4.0"
-actix-tls = "3.0.0-beta.7"
-actix-utils = "3.0.0"
-actix-rt = "2.2"
-actix-server = "2.0.0-beta.3"
-awc = { version = "3.0.0-beta.9", default-features = false }
-
-base64 = "0.13"
-bytes = "1"
-futures-core = { version = "0.3.7", default-features = false }
-http = "0.2.2"
-log = "0.4"
-socket2 = "0.4"
-serde = "1.0"
-serde_json = "1.0"
-slab = "0.4"
-serde_urlencoded = "0.7"
-tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
-
-[dev-dependencies]
-actix-web = { version = "4.0.0-beta.10", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.11"

actix-http-test/README.md

@@ -1,17 +0,0 @@
-# actix-http-test
-
-> Various helpers for Actix applications to use during testing.
-
-[![crates.io](https://img.shields.io/crates/v/actix-http-test?label=latest)](https://crates.io/crates/actix-http-test)
-[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0-beta.5)](https://docs.rs/actix-http-test/3.0.0-beta.5)
-[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-<br>
-[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.5/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.5)
-[![Download](https://img.shields.io/crates/d/actix-http-test.svg)](https://crates.io/crates/actix-http-test)
-[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
-
-## Documentation & Resources
-
-- [API Documentation](https://docs.rs/actix-http-test)
-- Minimum Supported Rust Version (MSRV): 1.52

actix-http/CHANGES.md

@@ -1,247 +1,6 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
-
-
-## 3.0.0-beta.11 - 2021-10-20
-### Changed
-* Updated rustls to v0.20. [#2414]
-* Minimum supported Rust version (MSRV) is now 1.52.
-
-[#2414]: https://github.com/actix/actix-web/pull/2414
-
-
-## 3.0.0-beta.10 - 2021-09-09
-### Changed
-* `ContentEncoding` is now marked `#[non_exhaustive]`. [#2377]
-* Minimum supported Rust version (MSRV) is now 1.51.
-
-### Fixed
-* Remove slice creation pointing to potential uninitialized data on h1 encoder. [#2364]
-* Remove `Into<Error>` bound on `Encoder` body types. [#2375]
-* Fix quality parse error in Accept-Encoding header. [#2344]
-
-[#2364]: https://github.com/actix/actix-web/pull/2364
-[#2375]: https://github.com/actix/actix-web/pull/2375
-[#2344]: https://github.com/actix/actix-web/pull/2344
-[#2377]: https://github.com/actix/actix-web/pull/2377
-
-
-## 3.0.0-beta.9 - 2021-08-09
-### Fixed
-* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
-
-
-## 3.0.0-beta.8 - 2021-06-26
-### Changed
-* Change compression algorithm features flags. [#2250]
-
-### Removed
-* `downcast` and `downcast_get_type_id` macros. [#2291]
-
-[#2291]: https://github.com/actix/actix-web/pull/2291
-[#2250]: https://github.com/actix/actix-web/pull/2250
-
-
-## 3.0.0-beta.7 - 2021-06-17
-### Added
-* Alias `body::Body` as `body::AnyBody`. [#2215]
-* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
-* Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
-* Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
-* Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
-* `Response::into_body` that consumes response and returns body type. [#2201]
-* `impl Default` for `Response`. [#2201]
-* Add zstd support for `ContentEncoding`. [#2244]
-
-### Changed
-* The `MessageBody` trait now has an associated `Error` type. [#2183]
-* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
-* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
-* Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
-* `header` mod is now public. [#2171]
-* `uri` mod is now public. [#2171]
-* Update `language-tags` to `0.3`.
-* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
-* `ResponseBuilder::message_body` now returns a `Result`. [#2201]
-* Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
-* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
-
-### Removed
-* Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
-* Down-casting for `MessageBody` types. [#2183]
-* `error::Result` alias. [#2201]
-* Error field from `Response` and `Response::error`. [#2205]
-* `impl Future` for `Response`. [#2201]
-* `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
-* `InternalError` and all the error types it constructed. [#2215]
-* Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
-
-[#2171]: https://github.com/actix/actix-web/pull/2171
-[#2183]: https://github.com/actix/actix-web/pull/2183
-[#2196]: https://github.com/actix/actix-web/pull/2196
-[#2201]: https://github.com/actix/actix-web/pull/2201
-[#2205]: https://github.com/actix/actix-web/pull/2205
-[#2215]: https://github.com/actix/actix-web/pull/2215
-[#2253]: https://github.com/actix/actix-web/pull/2253
-[#2244]: https://github.com/actix/actix-web/pull/2244
-
-
-
-## 3.0.0-beta.6 - 2021-04-17
-### Added
-* `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
-* `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
-* Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
-
-### Changes
-* The type parameter of `Response` no longer has a default. [#2152]
-* The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
-* `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
-* Error enum types are marked `#[non_exhaustive]`. [#2161]
-
-### Removed
-* `cookies` feature flag. [#2065]
-* Top-level `cookies` mod (re-export). [#2065]
-* `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
-* `impl ResponseError for CookieParseError`. [#2065]
-* Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
-* `ResponseBuilder::json`. [#2148]
-* `ResponseBuilder::{set_header, header}`. [#2148]
-* `impl From<serde_json::Value> for Body`. [#2148]
-* `Response::build_from`. [#2159]
-* Most of the status code builders on `Response`. [#2159]
-
-[#2065]: https://github.com/actix/actix-web/pull/2065
-[#2148]: https://github.com/actix/actix-web/pull/2148
-[#2152]: https://github.com/actix/actix-web/pull/2152
-[#2159]: https://github.com/actix/actix-web/pull/2159
-[#2158]: https://github.com/actix/actix-web/pull/2158
-[#2161]: https://github.com/actix/actix-web/pull/2161
-
-
-## 3.0.0-beta.5 - 2021-04-02
-### Added
-* `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
-* `client::ConnectorService` as `client::Connector::finish` method's return type [#2081]
-* `client::ConnectionIo` trait alias [#2081]
-
-### Changed
-* `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
-
-### Removed
-* Common typed HTTP headers were moved to actix-web. [2094]
-* `ResponseError` impl for `actix_utils::timeout::TimeoutError`. [#2127]
-
-[#2063]: https://github.com/actix/actix-web/pull/2063
-[#2081]: https://github.com/actix/actix-web/pull/2081
-[#2094]: https://github.com/actix/actix-web/pull/2094
-[#2127]: https://github.com/actix/actix-web/pull/2127
-
-
-## 3.0.0-beta.4 - 2021-03-08
-### Changed
-* Feature `cookies` is now optional and disabled by default. [#1981]
-* `ws::hash_key` now returns array. [#2035]
-* `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
-
-### Removed
-* Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
-* `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
-
-[#1981]: https://github.com/actix/actix-web/pull/1981
-[#1994]: https://github.com/actix/actix-web/pull/1994
-[#2035]: https://github.com/actix/actix-web/pull/2035
-[#2052]: https://github.com/actix/actix-web/pull/2052
-
-
-## 3.0.0-beta.3 - 2021-02-10
-* No notable changes.
-
-
-## 3.0.0-beta.2 - 2021-02-10
-### Added
-* `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
-* `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
-* `ResponseBuilder::append_header` method which allows using typed headers. [#1869]
-* `TestRequest::insert_header` method which allows using typed headers. [#1869]
-* `ContentEncoding` implements all necessary header traits. [#1912]
-* `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
-* `HeaderMap::drain` as an efficient draining iterator. [#1964]
-* Implement `IntoIterator` for owned `HeaderMap`. [#1964]
-* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
-
-### Changed
-* `ResponseBuilder::content_type` now takes an `impl IntoHeaderValue` to support using typed
-  `mime` types. [#1894]
-* Renamed `IntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
-  `TryInto` trait. [#1894]
-* `Extensions::insert` returns Option of replaced item. [#1904]
-* Remove `HttpResponseBuilder::json2()`. [#1903]
-* Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#1903]
-* `client::error::ConnectError` Resolver variant contains `Box<dyn std::error::Error>` type. [#1905]
-* `client::ConnectorConfig` default timeout changed to 5 seconds. [#1905]
-* Simplify `BlockingError` type to a unit struct. It's now only triggered when blocking thread pool
-  is dead. [#1957]
-* `HeaderMap::len` now returns number of values instead of number of keys. [#1964]
-* `HeaderMap::insert` now returns iterator of removed values. [#1964]
-* `HeaderMap::remove` now returns iterator of removed values. [#1964]
-
-### Removed
-* `ResponseBuilder::set`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
-* `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
-* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
-* `actors` optional feature. [#1969]
-* `ResponseError` impl for `actix::MailboxError`. [#1969]
-
-### Documentation
-* Vastly improve docs and add examples for `HeaderMap`. [#1964]
-
-[#1869]: https://github.com/actix/actix-web/pull/1869
-[#1894]: https://github.com/actix/actix-web/pull/1894
-[#1903]: https://github.com/actix/actix-web/pull/1903
-[#1904]: https://github.com/actix/actix-web/pull/1904
-[#1905]: https://github.com/actix/actix-web/pull/1905
-[#1912]: https://github.com/actix/actix-web/pull/1912
-[#1957]: https://github.com/actix/actix-web/pull/1957
-[#1964]: https://github.com/actix/actix-web/pull/1964
-[#1969]: https://github.com/actix/actix-web/pull/1969
-
-
-## 3.0.0-beta.1 - 2021-01-07
-### Added
-* Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
-
-### Changed
-* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
-* Bumped `rand` to `0.8`.
-* Update `bytes` to `1.0`. [#1813]
-* Update `h2` to `0.3`. [#1813]
-* The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
-
-### Removed
-* Deprecated `on_connect` methods have been removed. Prefer the new
-  `on_connect_ext` technique. [#1857]
-* Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
-  due to deprecate of resolver actor. [#1813]
-* Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
-  due to the removal of this type from `tokio-openssl` crate. openssl handshake 
-  error would return as `ConnectError::SslError`. [#1813]
-* Remove `actix-threadpool` dependency. Use `actix_rt::task::spawn_blocking`.
-  Due to this change `actix_threadpool::BlockingError` type is moved into 
-  `actix_http::error` module. [#1878]
-
-[#1813]: https://github.com/actix/actix-web/pull/1813
-[#1857]: https://github.com/actix/actix-web/pull/1857
-[#1864]: https://github.com/actix/actix-web/pull/1864
-[#1878]: https://github.com/actix/actix-web/pull/1878
-
-
-## 2.2.1 - 2021-08-09
-### Fixed
-* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+## Unreleased - 2020-xx-xx
 
 
 ## 2.2.0 - 2020-11-25
@@ -288,14 +47,15 @@
 * Update actix-connect and actix-tls dependencies.
 
 
-## 2.0.0-beta.3 - 2020-08-14
+## [2.0.0-beta.3] - 2020-08-14
+
 ### Fixed
 * Memory leak of `client::pool::ConnectorPoolSupport`. [#1626]
 
 [#1626]: https://github.com/actix/actix-web/pull/1626
 
 
-## 2.0.0-beta.2 - 2020-07-21
+## [2.0.0-beta.2] - 2020-07-21
 ### Fixed
 * Potential UB in h1 decoder using uninitialized memory. [#1614]
 
@@ -306,8 +66,10 @@
 [#1615]: https://github.com/actix/actix-web/pull/1615
 
 
-## 2.0.0-beta.1 - 2020-07-11
+## [2.0.0-beta.1] - 2020-07-11
+
 ### Changed
+
 * Migrate cookie handling to `cookie` crate. [#1558]
 * Update `sha-1` to 0.9. [#1586]
 * Fix leak in client pool. [#1580]
@@ -317,30 +79,33 @@
 [#1586]: https://github.com/actix/actix-web/pull/1586
 [#1580]: https://github.com/actix/actix-web/pull/1580
 
+## [2.0.0-alpha.4] - 2020-05-21
 
-## 2.0.0-alpha.4 - 2020-05-21
 ### Changed
+
 * Bump minimum supported Rust version to 1.40
-* content_length function is removed, and you can set Content-Length by calling
-  no_chunking function [#1439]
+* content_length function is removed, and you can set Content-Length by calling no_chunking function [#1439]
 * `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
   `u64` instead of a `usize`.
 * Update `base64` dependency to 0.12
 
 ### Fixed
+
 * Support parsing of `SameSite=None` [#1503]
 
 [#1439]: https://github.com/actix/actix-web/pull/1439
 [#1503]: https://github.com/actix/actix-web/pull/1503
 
+## [2.0.0-alpha.3] - 2020-05-08
 
-## 2.0.0-alpha.3 - 2020-05-08
 ### Fixed
+
 * Correct spelling of ConnectError::Unresolved [#1487]
 * Fix a mistake in the encoding of websocket continuation messages wherein
   Item::FirstText and Item::FirstBinary are each encoded as the other.
 
 ### Changed
+
 * Implement `std::error::Error` for our custom errors [#1422]
 * Remove `failure` support for `ResponseError` since that crate
   will be deprecated in the near future.
@@ -348,247 +113,338 @@
 [#1422]: https://github.com/actix/actix-web/pull/1422
 [#1487]: https://github.com/actix/actix-web/pull/1487
 
+## [2.0.0-alpha.2] - 2020-03-07
 
-## 2.0.0-alpha.2 - 2020-03-07
 ### Changed
+
 * Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
-* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB
-  respectively to improve download speed for awc when downloading large objects. [#1394]
-* client::Connector accepts initial_window_size and initial_connection_window_size
-  HTTP2 configuration. [#1394]
+
+* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB respectively
+  to improve download speed for awc when downloading large objects. [#1394]
+
+* client::Connector accepts initial_window_size and initial_connection_window_size HTTP2 configuration. [#1394]
+
 * client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
 
 [#1394]: https://github.com/actix/actix-web/pull/1394
 [#1395]: https://github.com/actix/actix-web/pull/1395
 
+## [2.0.0-alpha.1] - 2020-02-27
 
-## 2.0.0-alpha.1 - 2020-02-27
 ### Changed
+
 * Update the `time` dependency to 0.2.7.
 * Moved actors messages support from actix crate, enabled with feature `actors`.
-* Breaking change: trait MessageBody requires Unpin and accepting `Pin<&mut Self>` instead of
-  `&mut self` in the poll_next().
+* Breaking change: trait MessageBody requires Unpin and accepting Pin<&mut Self> instead of &mut self in the poll_next().
 * MessageBody is not implemented for &'static [u8] anymore.
 
 ### Fixed
+
 * Allow `SameSite=None` cookies to be sent in a response.
 
+## [1.0.1] - 2019-12-20
 
-## 1.0.1 - 2019-12-20
 ### Fixed
+
 * Poll upgrade service's readiness from HTTP service handlers
+
 * Replace brotli with brotli2 #1224
 
+## [1.0.0] - 2019-12-13
 
-## 1.0.0 - 2019-12-13
 ### Added
+
 * Add websockets continuation frame support
 
 ### Changed
+
 * Replace `flate2-xxx` features with `compress`
 
+## [1.0.0-alpha.5] - 2019-12-09
 
-## 1.0.0-alpha.5 - 2019-12-09
 ### Fixed
+
 * Check `Upgrade` service readiness before calling it
-* Fix buffer remaining capacity calculation
+
+* Fix buffer remaining capacity calcualtion
 
 ### Changed
+
 * Websockets: Ping and Pong should have binary data #1049
 
+## [1.0.0-alpha.4] - 2019-12-08
 
-## 1.0.0-alpha.4 - 2019-12-08
 ### Added
+
 * Add impl ResponseBuilder for Error
 
 ### Changed
+
 * Use rust based brotli compression library
 
-## 1.0.0-alpha.3 - 2019-12-07
+## [1.0.0-alpha.3] - 2019-12-07
+
 ### Changed
+
 * Migrate to tokio 0.2
+
 * Migrate to `std::future`
 
 
-## 0.2.11 - 2019-11-06
+## [0.2.11] - 2019-11-06
+
 ### Added
+
 * Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-* Add an additional `filename*` param in the `Content-Disposition` header of
-  `actix_files::NamedFile` to be more compatible. (#1151)
+
+* Add an additional `filename*` param in the `Content-Disposition` header of `actix_files::NamedFile` to be more compatible. (#1151)
+
 * Allow to use `std::convert::Infallible` as `actix_http::error::Error`
 
 ### Fixed
-* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain;
-  charset=utf-8` header [#1118]
 
-[#1878]: https://github.com/actix/actix-web/pull/1878
+* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain; charset=utf-8` header #1118
 
 
-## 0.2.10 - 2019-09-11
+## [0.2.10] - 2019-09-11
+
 ### Added
-* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
-  with `RequestHead`
+
+* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests with `RequestHead`
 
 ### Fixed
+
 * h2 will use error response #1080
+
 * on_connect result isn't added to request extensions for http2 requests #1009
 
 
-## 0.2.9 - 2019-08-13
+## [0.2.9] - 2019-08-13
+
 ### Changed
+
 * Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
+
 * Update percent-encoding to 2.1
+
 * Update serde_urlencoded to 0.6.1
 
 ### Fixed
+
 * Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
 
 
-## 0.2.8 - 2019-08-01
+## [0.2.8] - 2019-08-01
+
 ### Added
+
 * Add `rustls` support
+
 * Add `Clone` impl for `HeaderMap`
 
 ### Fixed
+
 * awc client panic #1016
-* Invalid response with compression middleware enabled, but compression-related features
-  disabled #997
+
+* Invalid response with compression middleware enabled, but compression-related features disabled #997
 
 
-## 0.2.7 - 2019-07-18
+## [0.2.7] - 2019-07-18
+
 ### Added
+
 * Add support for downcasting response errors #986
 
 
-## 0.2.6 - 2019-07-17
+## [0.2.6] - 2019-07-17
+
 ### Changed
+
 * Replace `ClonableService` with local copy
+
 * Upgrade `rand` dependency version to 0.7
 
 
-## 0.2.5 - 2019-06-28
+## [0.2.5] - 2019-06-28
+
 ### Added
+
 * Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
 
 ### Changed
+
 * Use `encoding_rs` crate instead of unmaintained `encoding` crate
+
 * Add `Copy` and `Clone` impls for `ws::Codec`
 
 
-## 0.2.4 - 2019-06-16
+## [0.2.4] - 2019-06-16
+
 ### Fixed
+
 * Do not compress NoContent (204) responses #918
 
 
-## 0.2.3 - 2019-06-02
+## [0.2.3] - 2019-06-02
+
 ### Added
+
 * Debug impl for ResponseBuilder
+
 * From SizedStream and BodyStream for Body
 
 ### Changed
+
 * SizedStream uses u64
 
 
-## 0.2.2 - 2019-05-29
+## [0.2.2] - 2019-05-29
+
 ### Fixed
+
 * Parse incoming stream before closing stream on disconnect #868
 
 
-## 0.2.1 - 2019-05-25
+## [0.2.1] - 2019-05-25
+
 ### Fixed
+
 * Handle socket read disconnect
 
 
-## 0.2.0 - 2019-05-12
+## [0.2.0] - 2019-05-12
+
 ### Changed
+
 * Update actix-service to 0.4
+
 * Expect and upgrade services accept `ServerConfig` config.
 
 ### Deleted
+
 * `OneRequest` service
 
 
-## 0.1.5 - 2019-05-04
+## [0.1.5] - 2019-05-04
+
 ### Fixed
+
 * Clean up response extensions in response pool #817
 
 
-## 0.1.4 - 2019-04-24
+## [0.1.4] - 2019-04-24
+
 ### Added
+
 * Allow to render h1 request headers in `Camel-Case`
 
 ### Fixed
+
 * Read until eof for http/1.0 responses #771
 
 
-## 0.1.3 - 2019-04-23
+## [0.1.3] - 2019-04-23
+
 ### Fixed
+
 * Fix http client pool management
+
 * Fix http client wait queue management #794
 
 
-## 0.1.2 - 2019-04-23
+## [0.1.2] - 2019-04-23
+
 ### Fixed
+
 * Fix BorrowMutError panic in client connector #793
 
 
-## 0.1.1 - 2019-04-19
+## [0.1.1] - 2019-04-19
+
 ### Changed
+
 * Cookie::max_age() accepts value in seconds
+
 * Cookie::max_age_time() accepts value in time::Duration
+
 * Allow to specify server address for client connector
 
 
-## 0.1.0 - 2019-04-16
+## [0.1.0] - 2019-04-16
+
 ### Added
+
 * Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
 
 ### Changed
+
 * `actix_http::encoding` always available
+
 * use trust-dns-resolver 0.11.0
 
 
-## 0.1.0-alpha.5 - 2019-04-12
+## [0.1.0-alpha.5] - 2019-04-12
+
 ### Added
+
 * Allow to use custom service for upgrade requests
+
 * Added `h1::SendResponse` future.
 
 ### Changed
+
 * MessageBody::length() renamed to MessageBody::size() for consistency
+
 * ws handshake verification functions take RequestHead instead of Request
 
 
-## 0.1.0-alpha.4 - 2019-04-08
+## [0.1.0-alpha.4] - 2019-04-08
+
 ### Added
+
 * Allow to use custom `Expect` handler
+
 * Add minimal `std::error::Error` impl for `Error`
 
 ### Changed
+
 * Export IntoHeaderValue
+
 * Render error and return as response body
-* Use thread pool for response body compression
+
+* Use thread pool for response body comression
 
 ### Deleted
+
 * Removed PayloadBuffer
 
 
-## 0.1.0-alpha.3 - 2019-04-02
+## [0.1.0-alpha.3] - 2019-04-02
+
 ### Added
+
 * Warn when an unsealed private cookie isn't valid UTF-8
 
 ### Fixed
+
 * Rust 1.31.0 compatibility
+
 * Preallocate read buffer for h1 codec
+
 * Detect socket disconnection during protocol selection
 
 
-## 0.1.0-alpha.2 - 2019-03-29
+## [0.1.0-alpha.2] - 2019-03-29
+
 ### Added
+
 * Added ws::Message::Nop, no-op websockets message
 
 ### Changed
-* Do not use thread pool for decompression if chunk size is smaller than 2048.
+
+* Do not use thread pool for decomression if chunk size is smaller than 2048.
 
 
-## 0.1.0-alpha.1 - 2019-03-28
+## [0.1.0-alpha.1] - 2019-03-28
+
 * Initial impl

actix-http/Cargo.toml

@@ -1,23 +1,21 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.11"
+version = "2.2.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
+readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
-categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket",
-]
+documentation = "https://docs.rs/actix-http/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server",
+              "web-programming::websocket"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-# features that docs.rs will build with
-features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd"]
+features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
 
 [lib]
 name = "actix_http"
@@ -27,85 +25,79 @@ path = "src/lib.rs"
 default = []
 
 # openssl
-openssl = ["actix-tls/openssl"]
+openssl = ["actix-tls/openssl", "actix-connect/openssl"]
 
 # rustls support
-rustls = ["actix-tls/rustls"]
+rustls = ["actix-tls/rustls", "actix-connect/rustls"]
 
-# enable compression support
-compress-brotli = ["brotli2", "__compress"]
-compress-gzip = ["flate2", "__compress"]
-compress-zstd = ["zstd", "__compress"]
+# enable compressison support
+compress = ["flate2", "brotli2"]
 
-# trust-dns as client dns resolver
-trust-dns = ["trust-dns-resolver"]
+# support for secure cookies
+secure-cookies = ["cookie/secure"]
 
-# Internal (PRIVATE!) features used to aid testing and cheking feature status.
-# Don't rely on these whatsoever. They may disappear at anytime.
-__compress = []
+# support for actix Actor messages
+actors = ["actix"]
 
 [dependencies]
-actix-service = "2.0.0"
-actix-codec = "0.4.0"
-actix-utils = "3.0.0"
-actix-rt = "2.2"
-actix-tls = { version = "3.0.0-beta.7", features = ["accept", "connect"] }
+actix-service = "1.0.6"
+actix-codec = "0.3.0"
+actix-connect = "2.0.0"
+actix-utils = "2.0.0"
+actix-rt = "1.0.0"
+actix-threadpool = "0.3.1"
+actix-tls = { version = "2.0.0", optional = true }
+actix = { version = "0.10.0", optional = true }
 
-ahash = "0.7"
 base64 = "0.13"
 bitflags = "1.2"
-bytes = "1"
-bytestring = "1"
-derive_more = "0.99.5"
+bytes = "0.5.3"
+cookie = { version = "0.14.1", features = ["percent-encode"] }
+copyless = "0.1.4"
+derive_more = "0.99.2"
+either = "1.5.3"
 encoding_rs = "0.8"
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
-h2 = "0.3.1"
-http = "0.2.2"
-httparse = "1.5.1"
-httpdate = "1.0.1"
+futures-channel = { version = "0.3.5", default-features = false }
+futures-core = { version = "0.3.5", default-features = false }
+futures-util = { version = "0.3.5", default-features = false }
+fxhash = "0.2.1"
+h2 = "0.2.1"
+http = "0.2.0"
+httparse = "1.3"
+indexmap = "1.3"
 itoa = "0.4"
-language-tags = "0.3"
-local-channel = "0.1"
-once_cell = "1.5"
+lazy_static = "1.4"
+language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
 pin-project = "1.0.0"
-pin-project-lite = "0.2"
-rand = "0.8"
+rand = "0.7"
+regex = "1.3"
+serde = "1.0"
+serde_json = "1.0"
 sha-1 = "0.9"
-smallvec = "1.6.1"
-tokio = { version = "1.2", features = ["sync"] }
+slab = "0.4"
+serde_urlencoded = "0.7"
+time = { version = "0.2.7", default-features = false, features = ["std"] }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
-zstd = { version = "0.7", optional = true }
-
-trust-dns-resolver = { version = "0.20.0", optional = true }
 
 [dev-dependencies]
-actix-server = "2.0.0-beta.3"
-actix-http-test = { version = "3.0.0-beta.5", features = ["openssl"] }
-actix-tls = { version = "3.0.0-beta.7", features = ["openssl"] }
-async-stream = "0.3"
-criterion = { version = "0.3", features = ["html_reports"] }
-env_logger = "0.8"
-rcgen = "0.8"
-regex = "1.3"
-rustls-pemfile = "0.2"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-tls-openssl = { package = "openssl", version = "0.10.9" }
-tls-rustls = { package = "rustls", version = "0.20.0" }
-
-[[example]]
-name = "ws"
-required-features = ["rustls"]
+actix-server = "1.0.1"
+actix-connect = { version = "2.0.0", features = ["openssl"] }
+actix-http-test = { version = "2.0.0", features = ["openssl"] }
+actix-tls = { version = "2.0.0", features = ["openssl"] }
+criterion = "0.3"
+env_logger = "0.7"
+serde_derive = "1.0"
+open-ssl = { version="0.10", package = "openssl" }
+rust-tls = { version="0.18", package = "rustls" }
 
 [[bench]]
-name = "write-camel-case"
+name = "content-length"
 harness = false
 
 [[bench]]

actix-http/README.md

@@ -3,18 +3,16 @@
 > HTTP primitives for the Actix ecosystem.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.11)](https://docs.rs/actix-http/3.0.0-beta.11)
-[![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
-<br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.11/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.11)
-[![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
-[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=2.2.1)](https://docs.rs/actix-http/2.2.1)
+![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/actix-http)
+[![Dependency Status](https://deps.rs/crate/actix-http/2.2.1/status.svg)](https://deps.rs/crate/actix-http/2.2.1)
+[![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-http)
-- Minimum Supported Rust Version (MSRV): 1.52
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Minimum Supported Rust Version (MSRV): 1.42.0
 
 ## Example
 

actix-http/benches/content-length.rs

@@ -0,0 +1,291 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+use bytes::BytesMut;
+
+// benchmark sending all requests at the same time
+fn bench_write_content_length(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_content_length");
+
+    let sizes = [
+        0, 1, 11, 83, 101, 653, 1001, 6323, 10001, 56329, 100001, 123456, 98724245,
+        4294967202,
+    ];
+
+    for i in sizes.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_content_length(i, &mut b)
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_content_length(i, &mut b)
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("itoa", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _itoa::write_content_length(i, &mut b)
+            })
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_write_content_length);
+criterion_main!(benches);
+
+mod _itoa {
+    use bytes::{BufMut, BytesMut};
+
+    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
+        if n == 0 {
+            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
+            return;
+        }
+
+        let mut buf = itoa::Buffer::new();
+
+        bytes.put_slice(b"\r\ncontent-length: ");
+        bytes.put_slice(buf.format(n).as_bytes());
+        bytes.put_slice(b"\r\n");
+    }
+}
+
+mod _new {
+    use bytes::{BufMut, BytesMut};
+
+    const DIGITS_START: u8 = b'0';
+
+    /// NOTE: bytes object has to contain enough space
+    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
+        if n == 0 {
+            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
+            return;
+        }
+
+        bytes.put_slice(b"\r\ncontent-length: ");
+
+        if n < 10 {
+            bytes.put_u8(DIGITS_START + (n as u8));
+        } else if n < 100 {
+            let n = n as u8;
+
+            let d10 = n / 10;
+            let d1 = n % 10;
+
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 1000 {
+            let n = n as u16;
+
+            let d100 = (n / 100) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 10_000 {
+            let n = n as u16;
+
+            let d1000 = (n / 1000) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 100_000 {
+            let n = n as u32;
+
+            let d10000 = (n / 10000) as u8;
+            let d1000 = ((n / 1000) % 10) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d10000);
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 1_000_000 {
+            let n = n as u32;
+
+            let d100000 = (n / 100000) as u8;
+            let d10000 = ((n / 10000) % 10) as u8;
+            let d1000 = ((n / 1000) % 10) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d100000);
+            bytes.put_u8(DIGITS_START + d10000);
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else {
+            write_usize(n, bytes);
+        }
+
+        bytes.put_slice(b"\r\n");
+    }
+
+    fn write_usize(n: usize, bytes: &mut BytesMut) {
+        let mut n = n;
+
+        // 20 chars is max length of a usize (2^64)
+        // digits will be added to the buffer from lsd to msd
+        let mut buf = BytesMut::with_capacity(20);
+
+        while n > 9 {
+            // "pop" the least-significant digit
+            let lsd = (n % 10) as u8;
+
+            // remove the lsd from n
+            n = n / 10;
+
+            buf.put_u8(DIGITS_START + lsd);
+        }
+
+        // put msd to result buffer
+        bytes.put_u8(DIGITS_START + (n as u8));
+
+        // put, in reverse (msd to lsd), remaining digits to buffer
+        for i in (0..buf.len()).rev() {
+            bytes.put_u8(buf[i]);
+        }
+    }
+}
+
+mod _original {
+    use std::{mem, ptr, slice};
+
+    use bytes::{BufMut, BytesMut};
+
+    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
+          2021222324252627282930313233343536373839\
+          4041424344454647484950515253545556575859\
+          6061626364656667686970717273747576777879\
+          8081828384858687888990919293949596979899";
+
+    /// NOTE: bytes object has to contain enough space
+    pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
+        if n < 10 {
+            let mut buf: [u8; 21] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
+            ];
+            buf[18] = (n as u8) + b'0';
+            bytes.put_slice(&buf);
+        } else if n < 100 {
+            let mut buf: [u8; 22] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
+            ];
+            let d1 = n << 1;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    DEC_DIGITS_LUT.as_ptr().add(d1),
+                    buf.as_mut_ptr().offset(18),
+                    2,
+                );
+            }
+            bytes.put_slice(&buf);
+        } else if n < 1000 {
+            let mut buf: [u8; 23] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r',
+                b'\n',
+            ];
+            // decode 2 more chars, if > 2 chars
+            let d1 = (n % 100) << 1;
+            n /= 100;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    DEC_DIGITS_LUT.as_ptr().add(d1),
+                    buf.as_mut_ptr().offset(19),
+                    2,
+                )
+            };
+
+            // decode last 1
+            buf[18] = (n as u8) + b'0';
+
+            bytes.put_slice(&buf);
+        } else {
+            bytes.put_slice(b"\r\ncontent-length: ");
+            convert_usize(n, bytes);
+        }
+    }
+
+    pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
+        let mut curr: isize = 39;
+        let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
+        buf[39] = b'\r';
+        buf[40] = b'\n';
+        let buf_ptr = buf.as_mut_ptr();
+        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+
+        // eagerly decode 4 characters at a time
+        while n >= 10_000 {
+            let rem = (n % 10_000) as isize;
+            n /= 10_000;
+
+            let d1 = (rem / 100) << 1;
+            let d2 = (rem % 100) << 1;
+            curr -= 4;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+                ptr::copy_nonoverlapping(
+                    lut_ptr.offset(d2),
+                    buf_ptr.offset(curr + 2),
+                    2,
+                );
+            }
+        }
+
+        // if we reach here numbers are <= 9999, so at most 4 chars long
+        let mut n = n as isize; // possibly reduce 64bit math
+
+        // decode 2 more chars, if > 2 chars
+        if n >= 100 {
+            let d1 = (n % 100) << 1;
+            n /= 100;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            }
+        }
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            unsafe {
+                *buf_ptr.offset(curr) = (n as u8) + b'0';
+            }
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            }
+        }
+
+        unsafe {
+            bytes.extend_from_slice(slice::from_raw_parts(
+                buf_ptr.offset(curr),
+                41 - curr as usize,
+            ));
+        }
+    }
+}

actix-http/benches/status-line.rs

@@ -176,7 +176,7 @@ mod _original {
                 buf[5] = b'0';
                 buf[7] = b'9';
             }
-            _ => {}
+            _ => (),
         }
 
         let mut curr: isize = 12;

actix-http/benches/uninit-headers.rs

@@ -78,12 +78,12 @@ impl HeaderIndex {
 // test cases taken from:
 // https://github.com/seanmonstar/httparse/blob/master/benches/parse.rs
 
-const REQ_SHORT: &[u8] = b"\
+const REQ_SHORT: &'static [u8] = b"\
 GET / HTTP/1.0\r\n\
 Host: example.com\r\n\
 Cookie: session=60; user_id=1\r\n\r\n";
 
-const REQ: &[u8] = b"\
+const REQ: &'static [u8] = b"\
 GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n\
 Host: www.kittyhell.com\r\n\
 User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\n\
@@ -119,8 +119,6 @@ mod _original {
     use std::mem::MaybeUninit;
 
     pub fn parse_headers(src: &mut BytesMut) -> usize {
-        #![allow(clippy::uninit_assumed_init)]
-
         let mut headers: [HeaderIndex; MAX_HEADERS] =
             unsafe { MaybeUninit::uninit().assume_init() };
 

actix-http/benches/write-camel-case.rs

@@ -1,93 +0,0 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-
-fn bench_write_camel_case(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_camel_case");
-
-    let names = ["connection", "Transfer-Encoding", "transfer-encoding"];
-
-    for &i in &names {
-        let bts = i.as_bytes();
-
-        group.bench_with_input(BenchmarkId::new("Original", i), bts, |b, bts| {
-            b.iter(|| {
-                let mut buf = black_box([0; 24]);
-                _original::write_camel_case(black_box(bts), &mut buf)
-            });
-        });
-
-        group.bench_with_input(BenchmarkId::new("New", i), bts, |b, bts| {
-            b.iter(|| {
-                let mut buf = black_box([0; 24]);
-                let len = black_box(bts.len());
-                _new::write_camel_case(black_box(bts), buf.as_mut_ptr(), len)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-criterion_group!(benches, bench_write_camel_case);
-criterion_main!(benches);
-
-mod _new {
-    pub fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
-        // first copy entire (potentially wrong) slice to output
-        let buffer = unsafe {
-            std::ptr::copy_nonoverlapping(value.as_ptr(), buf, len);
-            std::slice::from_raw_parts_mut(buf, len)
-        };
-
-        let mut iter = value.iter();
-
-        // first character should be uppercase
-        if let Some(c @ b'a'..=b'z') = iter.next() {
-            buffer[0] = c & 0b1101_1111;
-        }
-
-        // track 1 ahead of the current position since that's the location being assigned to
-        let mut index = 2;
-
-        // remaining characters after hyphens should also be uppercase
-        while let Some(&c) = iter.next() {
-            if c == b'-' {
-                // advance iter by one and uppercase if needed
-                if let Some(c @ b'a'..=b'z') = iter.next() {
-                    buffer[index] = c & 0b1101_1111;
-                }
-            }
-
-            index += 1;
-        }
-    }
-}
-
-mod _original {
-    pub fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
-        let mut index = 0;
-        let key = value;
-        let mut key_iter = key.iter();
-
-        if let Some(c) = key_iter.next() {
-            if *c >= b'a' && *c <= b'z' {
-                buffer[index] = *c ^ b' ';
-                index += 1;
-            }
-        } else {
-            return;
-        }
-
-        while let Some(c) = key_iter.next() {
-            buffer[index] = *c;
-            index += 1;
-            if *c == b'-' {
-                if let Some(c) = key_iter.next() {
-                    if *c >= b'a' && *c <= b'z' {
-                        buffer[index] = *c ^ b' ';
-                        index += 1;
-                    }
-                }
-            }
-        }
-    }
-}

actix-http/examples/echo.rs

@@ -1,17 +1,19 @@
-use std::io;
+use std::{env, io};
 
-use actix_http::{http::StatusCode, Error, HttpService, Request, Response};
+use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt as _;
+use futures_util::StreamExt;
 use http::header::HeaderValue;
+use log::info;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+    env::set_var("RUST_LOG", "echo=info");
+    env_logger::init();
 
     Server::build()
-        .bind("echo", ("127.0.0.1", 8080), || {
+        .bind("echo", "127.0.0.1:8080", || {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
@@ -21,14 +23,10 @@ async fn main() -> io::Result<()> {
                         body.extend_from_slice(&item?);
                     }
 
-                    log::info!("request body: {:?}", body);
-
+                    info!("request body: {:?}", body);
                     Ok::<_, Error>(
-                        Response::build(StatusCode::OK)
-                            .insert_header((
-                                "x-head",
-                                HeaderValue::from_static("dummy value!"),
-                            ))
+                        Response::Ok()
+                            .header("x-head", HeaderValue::from_static("dummy value!"))
                             .body(body),
                     )
                 })

actix-http/examples/echo2.rs

@@ -1,30 +1,31 @@
-use std::io;
+use std::{env, io};
 
-use actix_http::{body::Body, http::HeaderValue, http::StatusCode};
+use actix_http::http::HeaderValue;
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt as _;
+use futures_util::StreamExt;
+use log::info;
 
-async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
+async fn handle_request(mut req: Request) -> Result<Response, Error> {
     let mut body = BytesMut::new();
     while let Some(item) = req.payload().next().await {
         body.extend_from_slice(&item?)
     }
 
-    log::info!("request body: {:?}", body);
-
-    Ok(Response::build(StatusCode::OK)
-        .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
+    info!("request body: {:?}", body);
+    Ok(Response::Ok()
+        .header("x-head", HeaderValue::from_static("dummy value!"))
         .body(body))
 }
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+    env::set_var("RUST_LOG", "echo=info");
+    env_logger::init();
 
     Server::build()
-        .bind("echo", ("127.0.0.1", 8080), || {
+        .bind("echo", "127.0.0.1:8080", || {
             HttpService::build().finish(handle_request).tcp()
         })?
         .run()

actix-http/examples/hello-world.rs

@@ -1,28 +1,26 @@
-use std::{convert::Infallible, io};
+use std::{env, io};
 
-use actix_http::{http::StatusCode, HttpService, Response};
+use actix_http::{HttpService, Response};
 use actix_server::Server;
+use futures_util::future;
 use http::header::HeaderValue;
+use log::info;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+    env::set_var("RUST_LOG", "hello_world=info");
+    env_logger::init();
 
     Server::build()
-        .bind("hello-world", ("127.0.0.1", 8080), || {
+        .bind("hello-world", "127.0.0.1:8080", || {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
-                .finish(|req| async move {
-                    log::info!("{:?}", req);
-
-                    let mut res = Response::build(StatusCode::OK);
-                    res.insert_header((
-                        "x-head",
-                        HeaderValue::from_static("dummy value!"),
-                    ));
-
-                    Ok::<_, Infallible>(res.body("Hello world!"))
+                .finish(|_req| {
+                    info!("{:?}", _req);
+                    let mut res = Response::Ok();
+                    res.header("x-head", HeaderValue::from_static("dummy value!"));
+                    future::ok::<_, ()>(res.body("Hello world!"))
                 })
                 .tcp()
         })?

actix-http/examples/streaming-error.rs

@@ -1,40 +0,0 @@
-//! Example showing response body (chunked) stream erroring.
-//!
-//! Test using `nc` or `curl`.
-//! ```sh
-//! $ curl -vN 127.0.0.1:8080
-//! $ echo 'GET / HTTP/1.1\n\n' | nc 127.0.0.1 8080
-//! ```
-
-use std::{convert::Infallible, io, time::Duration};
-
-use actix_http::{body::BodyStream, HttpService, Response};
-use actix_server::Server;
-use async_stream::stream;
-use bytes::Bytes;
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
-
-    Server::build()
-        .bind("streaming-error", ("127.0.0.1", 8080), || {
-            HttpService::build()
-                .finish(|req| async move {
-                    log::info!("{:?}", req);
-                    let res = Response::ok();
-
-                    Ok::<_, Infallible>(res.set_body(BodyStream::new(stream! {
-                        yield Ok(Bytes::from("123"));
-                        yield Ok(Bytes::from("456"));
-
-                        actix_rt::time::sleep(Duration::from_millis(1000)).await;
-
-                        yield Err(io::Error::new(io::ErrorKind::Other, ""));
-                    })))
-                })
-                .tcp()
-        })?
-        .run()
-        .await
-}

actix-http/examples/ws.rs

@@ -1,115 +0,0 @@
-//! Sets up a WebSocket server over TCP and TLS.
-//! Sends a heartbeat message every 4 seconds but does not respond to any incoming frames.
-
-extern crate tls_rustls as rustls;
-
-use std::{
-    io,
-    pin::Pin,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use actix_codec::Encoder;
-use actix_http::{body::BodyStream, error::Error, ws, HttpService, Request, Response};
-use actix_rt::time::{interval, Interval};
-use actix_server::Server;
-use bytes::{Bytes, BytesMut};
-use bytestring::ByteString;
-use futures_core::{ready, Stream};
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
-
-    Server::build()
-        .bind("tcp", ("127.0.0.1", 8080), || {
-            HttpService::build().h1(handler).tcp()
-        })?
-        .bind("tls", ("127.0.0.1", 8443), || {
-            HttpService::build().finish(handler).rustls(tls_config())
-        })?
-        .run()
-        .await
-}
-
-async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>, Error> {
-    log::info!("handshaking");
-    let mut res = ws::handshake(req.head())?;
-
-    // handshake will always fail under HTTP/2
-
-    log::info!("responding");
-    Ok(res.message_body(BodyStream::new(Heartbeat::new(ws::Codec::new())))?)
-}
-
-struct Heartbeat {
-    codec: ws::Codec,
-    interval: Interval,
-}
-
-impl Heartbeat {
-    fn new(codec: ws::Codec) -> Self {
-        Self {
-            codec,
-            interval: interval(Duration::from_secs(4)),
-        }
-    }
-}
-
-impl Stream for Heartbeat {
-    type Item = Result<Bytes, Error>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        log::trace!("poll");
-
-        ready!(self.as_mut().interval.poll_tick(cx));
-
-        let mut buffer = BytesMut::new();
-
-        self.as_mut()
-            .codec
-            .encode(
-                ws::Message::Text(ByteString::from_static("hello world")),
-                &mut buffer,
-            )
-            .unwrap();
-
-        Poll::Ready(Some(Ok(buffer.freeze())))
-    }
-}
-
-fn tls_config() -> rustls::ServerConfig {
-    use std::io::BufReader;
-
-    use rustls::{Certificate, PrivateKey};
-    use rustls_pemfile::{certs, pkcs8_private_keys};
-
-    let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
-    let cert_file = cert.serialize_pem().unwrap();
-    let key_file = cert.serialize_private_key_pem();
-
-    let cert_file = &mut BufReader::new(cert_file.as_bytes());
-    let key_file = &mut BufReader::new(key_file.as_bytes());
-
-    let cert_chain = certs(cert_file)
-        .unwrap()
-        .into_iter()
-        .map(Certificate)
-        .collect();
-    let mut keys = pkcs8_private_keys(key_file).unwrap();
-
-    let mut config = rustls::ServerConfig::builder()
-        .with_safe_defaults()
-        .with_no_client_auth()
-        .with_single_cert(cert_chain, PrivateKey(keys.remove(0)))
-        .unwrap();
-
-    config.alpn_protocols.push(b"http/1.1".to_vec());
-    config.alpn_protocols.push(b"h2".to_vec());
-
-    config
-}

actix-http/src/body.rs

@@ -0,0 +1,723 @@
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{fmt, mem};
+
+use bytes::{Bytes, BytesMut};
+use futures_core::Stream;
+use futures_util::ready;
+use pin_project::pin_project;
+
+use crate::error::Error;
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+/// Body size hint
+pub enum BodySize {
+    None,
+    Empty,
+    Sized(u64),
+    Stream,
+}
+
+impl BodySize {
+    pub fn is_eof(&self) -> bool {
+        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
+    }
+}
+
+/// Type that provides this trait can be streamed to a peer.
+pub trait MessageBody {
+    fn size(&self) -> BodySize;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>>;
+
+    downcast_get_type_id!();
+}
+
+downcast!(MessageBody);
+
+impl MessageBody for () {
+    fn size(&self) -> BodySize {
+        BodySize::Empty
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        Poll::Ready(None)
+    }
+}
+
+impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+    fn size(&self) -> BodySize {
+        self.as_ref().size()
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        Pin::new(self.get_mut().as_mut()).poll_next(cx)
+    }
+}
+
+#[pin_project(project = ResponseBodyProj)]
+pub enum ResponseBody<B> {
+    Body(#[pin] B),
+    Other(#[pin] Body),
+}
+
+impl ResponseBody<Body> {
+    pub fn into_body<B>(self) -> ResponseBody<B> {
+        match self {
+            ResponseBody::Body(b) => ResponseBody::Other(b),
+            ResponseBody::Other(b) => ResponseBody::Other(b),
+        }
+    }
+}
+
+impl<B> ResponseBody<B> {
+    pub fn take_body(&mut self) -> ResponseBody<B> {
+        std::mem::replace(self, ResponseBody::Other(Body::None))
+    }
+}
+
+impl<B: MessageBody> ResponseBody<B> {
+    pub fn as_ref(&self) -> Option<&B> {
+        if let ResponseBody::Body(ref b) = self {
+            Some(b)
+        } else {
+            None
+        }
+    }
+}
+
+impl<B: MessageBody> MessageBody for ResponseBody<B> {
+    fn size(&self) -> BodySize {
+        match self {
+            ResponseBody::Body(ref body) => body.size(),
+            ResponseBody::Other(ref body) => body.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => body.poll_next(cx),
+        }
+    }
+}
+
+impl<B: MessageBody> Stream for ResponseBody<B> {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        match self.project() {
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => body.poll_next(cx),
+        }
+    }
+}
+
+#[pin_project(project = BodyProj)]
+/// Represents various types of http message body.
+pub enum Body {
+    /// Empty response. `Content-Length` header is not set.
+    None,
+    /// Zero sized response body. `Content-Length` header is set to `0`.
+    Empty,
+    /// Specific response body.
+    Bytes(Bytes),
+    /// Generic message body.
+    Message(Box<dyn MessageBody + Unpin>),
+}
+
+impl Body {
+    /// Create body from slice (copy)
+    pub fn from_slice(s: &[u8]) -> Body {
+        Body::Bytes(Bytes::copy_from_slice(s))
+    }
+
+    /// Create body from generic message body.
+    pub fn from_message<B: MessageBody + Unpin + 'static>(body: B) -> Body {
+        Body::Message(Box::new(body))
+    }
+}
+
+impl MessageBody for Body {
+    fn size(&self) -> BodySize {
+        match self {
+            Body::None => BodySize::None,
+            Body::Empty => BodySize::Empty,
+            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+            Body::Message(ref body) => body.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            BodyProj::None => Poll::Ready(None),
+            BodyProj::Empty => Poll::Ready(None),
+            BodyProj::Bytes(ref mut bin) => {
+                let len = bin.len();
+                if len == 0 {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Ready(Some(Ok(mem::take(bin))))
+                }
+            }
+            BodyProj::Message(ref mut body) => Pin::new(body.as_mut()).poll_next(cx),
+        }
+    }
+}
+
+impl PartialEq for Body {
+    fn eq(&self, other: &Body) -> bool {
+        match *self {
+            Body::None => matches!(*other, Body::None),
+            Body::Empty => matches!(*other, Body::Empty),
+            Body::Bytes(ref b) => match *other {
+                Body::Bytes(ref b2) => b == b2,
+                _ => false,
+            },
+            Body::Message(_) => false,
+        }
+    }
+}
+
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Body::None => write!(f, "Body::None"),
+            Body::Empty => write!(f, "Body::Empty"),
+            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
+            Body::Message(_) => write!(f, "Body::Message(_)"),
+        }
+    }
+}
+
+impl From<&'static str> for Body {
+    fn from(s: &'static str) -> Body {
+        Body::Bytes(Bytes::from_static(s.as_ref()))
+    }
+}
+
+impl From<&'static [u8]> for Body {
+    fn from(s: &'static [u8]) -> Body {
+        Body::Bytes(Bytes::from_static(s))
+    }
+}
+
+impl From<Vec<u8>> for Body {
+    fn from(vec: Vec<u8>) -> Body {
+        Body::Bytes(Bytes::from(vec))
+    }
+}
+
+impl From<String> for Body {
+    fn from(s: String) -> Body {
+        s.into_bytes().into()
+    }
+}
+
+impl<'a> From<&'a String> for Body {
+    fn from(s: &'a String) -> Body {
+        Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
+    }
+}
+
+impl From<Bytes> for Body {
+    fn from(s: Bytes) -> Body {
+        Body::Bytes(s)
+    }
+}
+
+impl From<BytesMut> for Body {
+    fn from(s: BytesMut) -> Body {
+        Body::Bytes(s.freeze())
+    }
+}
+
+impl From<serde_json::Value> for Body {
+    fn from(v: serde_json::Value) -> Body {
+        Body::Bytes(v.to_string().into())
+    }
+}
+
+impl<S> From<SizedStream<S>> for Body
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
+{
+    fn from(s: SizedStream<S>) -> Body {
+        Body::from_message(s)
+    }
+}
+
+impl<S, E> From<BodyStream<S, E>> for Body
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+    E: Into<Error> + 'static,
+{
+    fn from(s: BodyStream<S, E>) -> Body {
+        Body::from_message(s)
+    }
+}
+
+impl MessageBody for Bytes {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+        }
+    }
+}
+
+impl MessageBody for BytesMut {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+        }
+    }
+}
+
+impl MessageBody for &'static str {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from_static(
+                mem::take(self.get_mut()).as_ref(),
+            ))))
+        }
+    }
+}
+
+impl MessageBody for Vec<u8> {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+        }
+    }
+}
+
+impl MessageBody for String {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from(
+                mem::take(self.get_mut()).into_bytes(),
+            ))))
+        }
+    }
+}
+
+/// Type represent streaming body.
+/// Response does not contain `content-length` header and appropriate transfer encoding is used.
+#[pin_project]
+pub struct BodyStream<S: Unpin, E> {
+    #[pin]
+    stream: S,
+    _t: PhantomData<E>,
+}
+
+impl<S, E> BodyStream<S, E>
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    E: Into<Error>,
+{
+    pub fn new(stream: S) -> Self {
+        BodyStream {
+            stream,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<S, E> MessageBody for BodyStream<S, E>
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    E: Into<Error>,
+{
+    fn size(&self) -> BodySize {
+        BodySize::Stream
+    }
+
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut stream = self.project().stream;
+        loop {
+            let stream = stream.as_mut();
+            return Poll::Ready(match ready!(stream.poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                opt => opt.map(|res| res.map_err(Into::into)),
+            });
+        }
+    }
+}
+
+/// Type represent streaming body. This body implementation should be used
+/// if total size of stream is known. Data get sent as is without using transfer encoding.
+#[pin_project]
+pub struct SizedStream<S: Unpin> {
+    size: u64,
+    #[pin]
+    stream: S,
+}
+
+impl<S> SizedStream<S>
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+{
+    pub fn new(size: u64, stream: S) -> Self {
+        SizedStream { size, stream }
+    }
+}
+
+impl<S> MessageBody for SizedStream<S>
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+{
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.size as u64)
+    }
+
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut stream: Pin<&mut S> = self.project().stream;
+        loop {
+            let stream = stream.as_mut();
+            return Poll::Ready(match ready!(stream.poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                val => val,
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures_util::future::poll_fn;
+    use futures_util::pin_mut;
+    use futures_util::stream;
+
+    impl Body {
+        pub(crate) fn get_ref(&self) -> &[u8] {
+            match *self {
+                Body::Bytes(ref bin) => &bin,
+                _ => panic!(),
+            }
+        }
+    }
+
+    impl ResponseBody<Body> {
+        pub(crate) fn get_ref(&self) -> &[u8] {
+            match *self {
+                ResponseBody::Body(ref b) => b.get_ref(),
+                ResponseBody::Other(ref b) => b.get_ref(),
+            }
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_static_str() {
+        assert_eq!(Body::from("").size(), BodySize::Sized(0));
+        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
+        assert_eq!(Body::from("test").get_ref(), b"test");
+
+        assert_eq!("test".size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_static_bytes() {
+        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
+        assert_eq!(
+            Body::from_slice(b"test".as_ref()).size(),
+            BodySize::Sized(4)
+        );
+        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
+        let sb = Bytes::from(&b"test"[..]);
+        pin_mut!(sb);
+
+        assert_eq!(sb.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_vec() {
+        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
+        let test_vec = Vec::from("test");
+        pin_mut!(test_vec);
+
+        assert_eq!(test_vec.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes() {
+        let b = Bytes::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin_mut!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes_mut() {
+        let b = BytesMut::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin_mut!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_string() {
+        let b = "test".to_owned();
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(&b).get_ref(), b"test");
+        pin_mut!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_unit() {
+        assert_eq!(().size(), BodySize::Empty);
+        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
+            .await
+            .is_none());
+    }
+
+    #[actix_rt::test]
+    async fn test_box() {
+        let val = Box::new(());
+        pin_mut!(val);
+        assert_eq!(val.size(), BodySize::Empty);
+        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
+    }
+
+    #[actix_rt::test]
+    async fn test_body_eq() {
+        assert!(
+            Body::Bytes(Bytes::from_static(b"1"))
+                == Body::Bytes(Bytes::from_static(b"1"))
+        );
+        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
+    }
+
+    #[actix_rt::test]
+    async fn test_body_debug() {
+        assert!(format!("{:?}", Body::None).contains("Body::None"));
+        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
+        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
+    }
+
+    #[actix_rt::test]
+    async fn test_serde_json() {
+        use serde_json::json;
+        assert_eq!(
+            Body::from(serde_json::Value::String("test".into())).size(),
+            BodySize::Sized(6)
+        );
+        assert_eq!(
+            Body::from(json!({"test-key":"test-value"})).size(),
+            BodySize::Sized(25)
+        );
+    }
+
+    mod body_stream {
+        use super::*;
+        //use futures::task::noop_waker;
+        //use futures::stream::once;
+
+        #[actix_rt::test]
+        async fn skips_empty_chunks() {
+            let body = BodyStream::new(stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
+            ));
+            pin_mut!(body);
+
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("1")),
+            );
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("2")),
+            );
+        }
+
+        /* Now it does not compile as it should
+        #[actix_rt::test]
+        async fn move_pinned_pointer() {
+            let (sender, receiver) = futures::channel::oneshot::channel();
+            let mut body_stream = Ok(BodyStream::new(once(async {
+                let x = Box::new(0i32);
+                let y = &x;
+                receiver.await.unwrap();
+                let _z = **y;
+                Ok::<_, ()>(Bytes::new())
+            })));
+
+            let waker = noop_waker();
+            let mut context = Context::from_waker(&waker);
+            pin_mut!(body_stream);
+
+            let _ = body_stream.as_mut().unwrap().poll_next(&mut context);
+            sender.send(()).unwrap();
+            let _ = std::mem::replace(&mut body_stream, Err([0; 32])).unwrap().poll_next(&mut context);
+        }*/
+    }
+
+    mod sized_stream {
+        use super::*;
+
+        #[actix_rt::test]
+        async fn skips_empty_chunks() {
+            let body = SizedStream::new(
+                2,
+                stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+            );
+            pin_mut!(body);
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("1")),
+            );
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("2")),
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_body_casting() {
+        let mut body = String::from("hello cast");
+        let resp_body: &mut dyn MessageBody = &mut body;
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast");
+        let body = &mut resp_body.downcast_mut::<String>().unwrap();
+        body.push('!');
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast!");
+        let not_body = resp_body.downcast_ref::<()>();
+        assert!(not_body.is_none());
+    }
+}

actix-http/src/body/body.rs

@@ -1,227 +0,0 @@
-use std::{
-    borrow::Cow,
-    error::Error as StdError,
-    fmt, mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
-
-use crate::error::Error;
-
-use super::{BodySize, BodyStream, MessageBody, MessageBodyMapErr, SizedStream};
-
-pub type Body = AnyBody;
-
-/// Represents various types of HTTP message body.
-pub enum AnyBody {
-    /// Empty response. `Content-Length` header is not set.
-    None,
-
-    /// Zero sized response body. `Content-Length` header is set to `0`.
-    Empty,
-
-    /// Specific response body.
-    Bytes(Bytes),
-
-    /// Generic message body.
-    Message(BoxAnyBody),
-}
-
-impl AnyBody {
-    /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Self {
-        Self::Bytes(Bytes::copy_from_slice(s))
-    }
-
-    /// Create body from generic message body.
-    pub fn from_message<B>(body: B) -> Self
-    where
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError + 'static>>,
-    {
-        Self::Message(BoxAnyBody::from_body(body))
-    }
-}
-
-impl MessageBody for AnyBody {
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        match self {
-            AnyBody::None => BodySize::None,
-            AnyBody::Empty => BodySize::Empty,
-            AnyBody::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
-            AnyBody::Message(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        match self.get_mut() {
-            AnyBody::None => Poll::Ready(None),
-            AnyBody::Empty => Poll::Ready(None),
-            AnyBody::Bytes(ref mut bin) => {
-                let len = bin.len();
-                if len == 0 {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
-                }
-            }
-
-            AnyBody::Message(body) => body
-                .as_pin_mut()
-                .poll_next(cx)
-                .map_err(|err| Error::new_body().with_cause(err)),
-        }
-    }
-}
-
-impl PartialEq for AnyBody {
-    fn eq(&self, other: &Body) -> bool {
-        match *self {
-            AnyBody::None => matches!(*other, AnyBody::None),
-            AnyBody::Empty => matches!(*other, AnyBody::Empty),
-            AnyBody::Bytes(ref b) => match *other {
-                AnyBody::Bytes(ref b2) => b == b2,
-                _ => false,
-            },
-            AnyBody::Message(_) => false,
-        }
-    }
-}
-
-impl fmt::Debug for AnyBody {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            AnyBody::None => write!(f, "AnyBody::None"),
-            AnyBody::Empty => write!(f, "AnyBody::Empty"),
-            AnyBody::Bytes(ref b) => write!(f, "AnyBody::Bytes({:?})", b),
-            AnyBody::Message(_) => write!(f, "AnyBody::Message(_)"),
-        }
-    }
-}
-
-impl From<&'static str> for AnyBody {
-    fn from(s: &'static str) -> Body {
-        AnyBody::Bytes(Bytes::from_static(s.as_ref()))
-    }
-}
-
-impl From<&'static [u8]> for AnyBody {
-    fn from(s: &'static [u8]) -> Body {
-        AnyBody::Bytes(Bytes::from_static(s))
-    }
-}
-
-impl From<Vec<u8>> for AnyBody {
-    fn from(vec: Vec<u8>) -> Body {
-        AnyBody::Bytes(Bytes::from(vec))
-    }
-}
-
-impl From<String> for AnyBody {
-    fn from(s: String) -> Body {
-        s.into_bytes().into()
-    }
-}
-
-impl From<&'_ String> for AnyBody {
-    fn from(s: &String) -> Body {
-        AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
-    }
-}
-
-impl From<Cow<'_, str>> for AnyBody {
-    fn from(s: Cow<'_, str>) -> Body {
-        match s {
-            Cow::Owned(s) => AnyBody::from(s),
-            Cow::Borrowed(s) => {
-                AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)))
-            }
-        }
-    }
-}
-
-impl From<Bytes> for AnyBody {
-    fn from(s: Bytes) -> Body {
-        AnyBody::Bytes(s)
-    }
-}
-
-impl From<BytesMut> for AnyBody {
-    fn from(s: BytesMut) -> Body {
-        AnyBody::Bytes(s.freeze())
-    }
-}
-
-impl<S, E> From<SizedStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    fn from(s: SizedStream<S>) -> Body {
-        AnyBody::from_message(s)
-    }
-}
-
-impl<S, E> From<BodyStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    fn from(s: BodyStream<S>) -> Body {
-        AnyBody::from_message(s)
-    }
-}
-
-/// A boxed message body with boxed errors.
-pub struct BoxAnyBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError + 'static>>>>);
-
-impl BoxAnyBody {
-    /// Boxes a `MessageBody` and any errors it generates.
-    pub fn from_body<B>(body: B) -> Self
-    where
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError + 'static>>,
-    {
-        let body = MessageBodyMapErr::new(body, Into::into);
-        Self(Box::pin(body))
-    }
-
-    /// Returns a mutable pinned reference to the inner message body type.
-    pub fn as_pin_mut(
-        &mut self,
-    ) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError + 'static>>)> {
-        self.0.as_mut()
-    }
-}
-
-impl fmt::Debug for BoxAnyBody {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("BoxAnyBody(dyn MessageBody)")
-    }
-}
-
-impl MessageBody for BoxAnyBody {
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        self.0.size()
-    }
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        self.0
-            .as_mut()
-            .poll_next(cx)
-            .map_err(|err| Error::new_body().with_cause(err))
-    }
-}

actix-http/src/body/body_stream.rs

@@ -1,171 +0,0 @@
-use std::{
-    error::Error as StdError,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-use pin_project_lite::pin_project;
-
-use super::{BodySize, MessageBody};
-
-pin_project! {
-    /// Streaming response wrapper.
-    ///
-    /// Response does not contain `Content-Length` header and appropriate transfer encoding is used.
-    pub struct BodyStream<S> {
-        #[pin]
-        stream: S,
-    }
-}
-
-impl<S, E> BodyStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    pub fn new(stream: S) -> Self {
-        BodyStream { stream }
-    }
-}
-
-impl<S, E> MessageBody for BodyStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    type Error = E;
-
-    fn size(&self) -> BodySize {
-        BodySize::Stream
-    }
-
-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        loop {
-            let stream = self.as_mut().project().stream;
-
-            let chunk = match ready!(stream.poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                opt => opt,
-            };
-
-            return Poll::Ready(chunk);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{convert::Infallible, time::Duration};
-
-    use actix_rt::{
-        pin,
-        time::{sleep, Sleep},
-    };
-    use actix_utils::future::poll_fn;
-    use derive_more::{Display, Error};
-    use futures_core::ready;
-    use futures_util::{stream, FutureExt as _};
-
-    use super::*;
-    use crate::body::to_bytes;
-
-    #[actix_rt::test]
-    async fn skips_empty_chunks() {
-        let body = BodyStream::new(stream::iter(
-            ["1", "", "2"]
-                .iter()
-                .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
-        ));
-        pin!(body);
-
-        assert_eq!(
-            poll_fn(|cx| body.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("1")),
-        );
-        assert_eq!(
-            poll_fn(|cx| body.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("2")),
-        );
-    }
-
-    #[actix_rt::test]
-    async fn read_to_bytes() {
-        let body = BodyStream::new(stream::iter(
-            ["1", "", "2"]
-                .iter()
-                .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
-        ));
-
-        assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
-    }
-    #[derive(Debug, Display, Error)]
-    #[display(fmt = "stream error")]
-    struct StreamErr;
-
-    #[actix_rt::test]
-    async fn stream_immediate_error() {
-        let body = BodyStream::new(stream::once(async { Err(StreamErr) }));
-        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
-    }
-
-    #[actix_rt::test]
-    async fn stream_delayed_error() {
-        let body =
-            BodyStream::new(stream::iter(vec![Ok(Bytes::from("1")), Err(StreamErr)]));
-        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
-
-        #[pin_project::pin_project(project = TimeDelayStreamProj)]
-        #[derive(Debug)]
-        enum TimeDelayStream {
-            Start,
-            Sleep(Pin<Box<Sleep>>),
-            Done,
-        }
-
-        impl Stream for TimeDelayStream {
-            type Item = Result<Bytes, StreamErr>;
-
-            fn poll_next(
-                mut self: Pin<&mut Self>,
-                cx: &mut Context<'_>,
-            ) -> Poll<Option<Self::Item>> {
-                match self.as_mut().get_mut() {
-                    TimeDelayStream::Start => {
-                        let sleep = sleep(Duration::from_millis(1));
-                        self.as_mut().set(TimeDelayStream::Sleep(Box::pin(sleep)));
-                        cx.waker().wake_by_ref();
-                        Poll::Pending
-                    }
-
-                    TimeDelayStream::Sleep(ref mut delay) => {
-                        ready!(delay.poll_unpin(cx));
-                        self.set(TimeDelayStream::Done);
-                        cx.waker().wake_by_ref();
-                        Poll::Pending
-                    }
-
-                    TimeDelayStream::Done => Poll::Ready(Some(Err(StreamErr))),
-                }
-            }
-        }
-
-        let body = BodyStream::new(TimeDelayStream::Start);
-        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
-    }
-}

actix-http/src/body/message_body.rs

@@ -1,228 +0,0 @@
-//! [`MessageBody`] trait and foreign implementations.
-
-use std::{
-    convert::Infallible,
-    mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::ready;
-use pin_project_lite::pin_project;
-
-use super::BodySize;
-
-/// An interface for response bodies.
-pub trait MessageBody {
-    type Error;
-
-    /// Body size hint.
-    fn size(&self) -> BodySize;
-
-    /// Attempt to pull out the next chunk of body bytes.
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>>;
-}
-
-impl MessageBody for () {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Empty
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Poll::Ready(None)
-    }
-}
-
-impl<B> MessageBody for Box<B>
-where
-    B: MessageBody + Unpin,
-{
-    type Error = B::Error;
-
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Pin::new(self.get_mut().as_mut()).poll_next(cx)
-    }
-}
-
-impl<B> MessageBody for Pin<Box<B>>
-where
-    B: MessageBody,
-{
-    type Error = B::Error;
-
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        self.as_mut().poll_next(cx)
-    }
-}
-
-impl MessageBody for Bytes {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
-        }
-    }
-}
-
-impl MessageBody for BytesMut {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
-        }
-    }
-}
-
-impl MessageBody for &'static str {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::take(self.get_mut()).as_ref(),
-            ))))
-        }
-    }
-}
-
-impl MessageBody for Vec<u8> {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
-        }
-    }
-}
-
-impl MessageBody for String {
-    type Error = Infallible;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(
-                mem::take(self.get_mut()).into_bytes(),
-            ))))
-        }
-    }
-}
-
-pin_project! {
-    pub(crate) struct MessageBodyMapErr<B, F> {
-        #[pin]
-        body: B,
-        mapper: Option<F>,
-    }
-}
-
-impl<B, F, E> MessageBodyMapErr<B, F>
-where
-    B: MessageBody,
-    F: FnOnce(B::Error) -> E,
-{
-    pub(crate) fn new(body: B, mapper: F) -> Self {
-        Self {
-            body,
-            mapper: Some(mapper),
-        }
-    }
-}
-
-impl<B, F, E> MessageBody for MessageBodyMapErr<B, F>
-where
-    B: MessageBody,
-    F: FnOnce(B::Error) -> E,
-{
-    type Error = E;
-
-    fn size(&self) -> BodySize {
-        self.body.size()
-    }
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        let this = self.as_mut().project();
-
-        match ready!(this.body.poll_next(cx)) {
-            Some(Err(err)) => {
-                let f = self.as_mut().project().mapper.take().unwrap();
-                let mapped_err = (f)(err);
-                Poll::Ready(Some(Err(mapped_err)))
-            }
-            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-            None => Poll::Ready(None),
-        }
-    }
-}

actix-http/src/body/mod.rs

@@ -1,263 +0,0 @@
-//! Traits and structures to aid consuming and writing HTTP payloads.
-
-use std::task::Poll;
-
-use actix_rt::pin;
-use actix_utils::future::poll_fn;
-use bytes::{Bytes, BytesMut};
-use futures_core::ready;
-
-#[allow(clippy::module_inception)]
-mod body;
-mod body_stream;
-mod message_body;
-mod response_body;
-mod size;
-mod sized_stream;
-
-pub use self::body::{AnyBody, Body, BoxAnyBody};
-pub use self::body_stream::BodyStream;
-pub use self::message_body::MessageBody;
-pub(crate) use self::message_body::MessageBodyMapErr;
-pub use self::response_body::ResponseBody;
-pub use self::size::BodySize;
-pub use self::sized_stream::SizedStream;
-
-/// Collects the body produced by a `MessageBody` implementation into `Bytes`.
-///
-/// Any errors produced by the body stream are returned immediately.
-///
-/// # Examples
-/// ```
-/// use actix_http::body::{Body, to_bytes};
-/// use bytes::Bytes;
-///
-/// # async fn test_to_bytes() {
-/// let body = Body::Empty;
-/// let bytes = to_bytes(body).await.unwrap();
-/// assert!(bytes.is_empty());
-///
-/// let body = Body::Bytes(Bytes::from_static(b"123"));
-/// let bytes = to_bytes(body).await.unwrap();
-/// assert_eq!(bytes, b"123"[..]);
-/// # }
-/// ```
-pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
-    let cap = match body.size() {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => return Ok(Bytes::new()),
-        BodySize::Sized(size) => size as usize,
-        BodySize::Stream => 32_768,
-    };
-
-    let mut buf = BytesMut::with_capacity(cap);
-
-    pin!(body);
-
-    poll_fn(|cx| loop {
-        let body = body.as_mut();
-
-        match ready!(body.poll_next(cx)) {
-            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
-            None => return Poll::Ready(Ok(())),
-            Some(Err(err)) => return Poll::Ready(Err(err)),
-        }
-    })
-    .await?;
-
-    Ok(buf.freeze())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::pin::Pin;
-
-    use actix_rt::pin;
-    use actix_utils::future::poll_fn;
-    use bytes::{Bytes, BytesMut};
-
-    use super::*;
-
-    impl Body {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                Body::Bytes(ref bin) => bin,
-                _ => panic!(),
-            }
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_static_str() {
-        assert_eq!(Body::from("").size(), BodySize::Sized(0));
-        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
-        assert_eq!(Body::from("test").get_ref(), b"test");
-
-        assert_eq!("test".size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_static_bytes() {
-        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
-        assert_eq!(
-            Body::from_slice(b"test".as_ref()).size(),
-            BodySize::Sized(4)
-        );
-        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
-        let sb = Bytes::from(&b"test"[..]);
-        pin!(sb);
-
-        assert_eq!(sb.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_vec() {
-        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
-        let test_vec = Vec::from("test");
-        pin!(test_vec);
-
-        assert_eq!(test_vec.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes() {
-        let b = Bytes::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        pin!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes_mut() {
-        let b = BytesMut::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        pin!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_string() {
-        let b = "test".to_owned();
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(&b).get_ref(), b"test");
-        pin!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_unit() {
-        assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_box_and_pin() {
-        let val = Box::new(());
-        pin!(val);
-        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-
-        let mut val = Box::pin(());
-        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_body_eq() {
-        assert!(
-            Body::Bytes(Bytes::from_static(b"1"))
-                == Body::Bytes(Bytes::from_static(b"1"))
-        );
-        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
-    }
-
-    #[actix_rt::test]
-    async fn test_body_debug() {
-        assert!(format!("{:?}", Body::None).contains("Body::None"));
-        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
-        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
-    }
-
-    #[actix_rt::test]
-    async fn test_serde_json() {
-        use serde_json::{json, Value};
-        assert_eq!(
-            Body::from(serde_json::to_vec(&Value::String("test".to_owned())).unwrap())
-                .size(),
-            BodySize::Sized(6)
-        );
-        assert_eq!(
-            Body::from(serde_json::to_vec(&json!({"test-key":"test-value"})).unwrap())
-                .size(),
-            BodySize::Sized(25)
-        );
-    }
-
-    // down-casting used to be done with a method on MessageBody trait
-    // test is kept to demonstrate equivalence of Any trait
-    #[actix_rt::test]
-    async fn test_body_casting() {
-        let mut body = String::from("hello cast");
-        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
-        let resp_body: &mut dyn std::any::Any = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push('!');
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_to_bytes() {
-        let body = Body::Empty;
-        let bytes = to_bytes(body).await.unwrap();
-        assert!(bytes.is_empty());
-
-        let body = Body::Bytes(Bytes::from_static(b"123"));
-        let bytes = to_bytes(body).await.unwrap();
-        assert_eq!(bytes, b"123"[..]);
-    }
-}

actix-http/src/body/response_body.rs

@@ -1,84 +0,0 @@
-use std::{
-    mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::Stream;
-use pin_project::pin_project;
-
-use crate::error::Error;
-
-use super::{Body, BodySize, MessageBody};
-
-#[pin_project(project = ResponseBodyProj)]
-pub enum ResponseBody<B> {
-    Body(#[pin] B),
-    Other(Body),
-}
-
-impl ResponseBody<Body> {
-    pub fn into_body<B>(self) -> ResponseBody<B> {
-        match self {
-            ResponseBody::Body(b) => ResponseBody::Other(b),
-            ResponseBody::Other(b) => ResponseBody::Other(b),
-        }
-    }
-}
-
-impl<B> ResponseBody<B> {
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        mem::replace(self, ResponseBody::Other(Body::None))
-    }
-}
-
-impl<B: MessageBody> ResponseBody<B> {
-    pub fn as_ref(&self) -> Option<&B> {
-        if let ResponseBody::Body(ref b) = self {
-            Some(b)
-        } else {
-            None
-        }
-    }
-}
-
-impl<B> MessageBody for ResponseBody<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Error = Error;
-
-    fn size(&self) -> BodySize {
-        match self {
-            ResponseBody::Body(ref body) => body.size(),
-            ResponseBody::Other(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        Stream::poll_next(self, cx)
-    }
-}
-
-impl<B> Stream for ResponseBody<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Item = Result<Bytes, Error>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx).map_err(Into::into),
-            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
-        }
-    }
-}

actix-http/src/body/size.rs

@@ -1,40 +0,0 @@
-/// Body size hint.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum BodySize {
-    /// Absence of body can be assumed from method or status code.
-    ///
-    /// Will skip writing Content-Length header.
-    None,
-
-    /// Zero size body.
-    ///
-    /// Will write `Content-Length: 0` header.
-    Empty,
-
-    /// Known size body.
-    ///
-    /// Will write `Content-Length: N` header. `Sized(0)` is treated the same as `Empty`.
-    Sized(u64),
-
-    /// Unknown size body.
-    ///
-    /// Will not write Content-Length header. Can be used with chunked Transfer-Encoding.
-    Stream,
-}
-
-impl BodySize {
-    /// Returns true if size hint indicates no or empty body.
-    ///
-    /// ```
-    /// # use actix_http::body::BodySize;
-    /// assert!(BodySize::None.is_eof());
-    /// assert!(BodySize::Empty.is_eof());
-    /// assert!(BodySize::Sized(0).is_eof());
-    ///
-    /// assert!(!BodySize::Sized(64).is_eof());
-    /// assert!(!BodySize::Stream.is_eof());
-    /// ```
-    pub fn is_eof(&self) -> bool {
-        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
-    }
-}

actix-http/src/body/sized_stream.rs

@@ -1,122 +0,0 @@
-use std::{
-    error::Error as StdError,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-use pin_project_lite::pin_project;
-
-use super::{BodySize, MessageBody};
-
-pin_project! {
-    /// Known sized streaming response wrapper.
-    ///
-    /// This body implementation should be used if total size of stream is known. Data is sent as-is
-    /// without using chunked transfer encoding.
-    pub struct SizedStream<S> {
-        size: u64,
-        #[pin]
-        stream: S,
-    }
-}
-
-impl<S, E> SizedStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    pub fn new(size: u64, stream: S) -> Self {
-        SizedStream { size, stream }
-    }
-}
-
-impl<S, E> MessageBody for SizedStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Box<dyn StdError>> + 'static,
-{
-    type Error = E;
-
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.size as u64)
-    }
-
-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        loop {
-            let stream = self.as_mut().project().stream;
-
-            let chunk = match ready!(stream.poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                val => val,
-            };
-
-            return Poll::Ready(chunk);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::convert::Infallible;
-
-    use actix_rt::pin;
-    use actix_utils::future::poll_fn;
-    use futures_util::stream;
-
-    use super::*;
-    use crate::body::to_bytes;
-
-    #[actix_rt::test]
-    async fn skips_empty_chunks() {
-        let body = SizedStream::new(
-            2,
-            stream::iter(
-                ["1", "", "2"]
-                    .iter()
-                    .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
-            ),
-        );
-
-        pin!(body);
-
-        assert_eq!(
-            poll_fn(|cx| body.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("1")),
-        );
-
-        assert_eq!(
-            poll_fn(|cx| body.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("2")),
-        );
-    }
-
-    #[actix_rt::test]
-    async fn read_to_bytes() {
-        let body = SizedStream::new(
-            2,
-            stream::iter(
-                ["1", "", "2"]
-                    .iter()
-                    .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
-            ),
-        );
-
-        assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
-    }
-}

actix-http/src/builder.rs

@@ -1,22 +1,26 @@
-use std::{error::Error as StdError, fmt, marker::PhantomData, net, rc::Rc};
+use std::marker::PhantomData;
+use std::rc::Rc;
+use std::{fmt, net};
 
 use actix_codec::Framed;
 use actix_service::{IntoServiceFactory, Service, ServiceFactory};
 
-use crate::{
-    body::{AnyBody, MessageBody},
-    config::{KeepAlive, ServiceConfig},
-    h1::{self, ExpectHandler, H1Service, UpgradeHandler},
-    h2::H2Service,
-    service::HttpService,
-    ConnectCallback, Extensions, Request, Response,
-};
+use crate::body::MessageBody;
+use crate::config::{KeepAlive, ServiceConfig};
+use crate::error::Error;
+use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
+use crate::h2::H2Service;
+use crate::helpers::{Data, DataFactory};
+use crate::request::Request;
+use crate::response::Response;
+use crate::service::HttpService;
+use crate::{ConnectCallback, Extensions};
 
 /// A HTTP service builder
 ///
 /// This type can be used to construct an instance of [`HttpService`] through a
 /// builder-like pattern.
-pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
+pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
     keep_alive: KeepAlive,
     client_timeout: u64,
     client_disconnect: u64,
@@ -24,16 +28,18 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
     local_addr: Option<net::SocketAddr>,
     expect: X,
     upgrade: Option<U>,
+    // DEPRECATED: in favor of on_connect_ext
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<S>,
+    _t: PhantomData<(T, S)>,
 }
 
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
+impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
+    <S::Service as Service>::Future: 'static,
 {
     /// Create instance of `ServiceConfigBuilder`
     pub fn new() -> Self {
@@ -45,24 +51,27 @@ where
             local_addr: None,
             expect: ExpectHandler,
             upgrade: None,
+            on_connect: None,
             on_connect_ext: None,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 }
 
 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Response<AnyBody>>,
+    <S::Service as Service>::Future: 'static,
+    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
+    <X::Service as Service>::Future: 'static,
+    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
+    <U::Service as Service>::Future: 'static,
 {
     /// Set server keep-alive setting.
     ///
@@ -118,10 +127,11 @@ where
     /// request will be forwarded to main service.
     pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
     where
-        F: IntoServiceFactory<X1, Request>,
-        X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Response<AnyBody>>,
+        F: IntoServiceFactory<X1>,
+        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X1::Error: Into<Error>,
         X1::InitError: fmt::Debug,
+        <X1::Service as Service>::Future: 'static,
     {
         HttpServiceBuilder {
             keep_alive: self.keep_alive,
@@ -131,8 +141,9 @@ where
             local_addr: self.local_addr,
             expect: expect.into_factory(),
             upgrade: self.upgrade,
+            on_connect: self.on_connect,
             on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 
@@ -142,10 +153,15 @@ where
     /// and this service get called with original request and framed object.
     pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
     where
-        F: IntoServiceFactory<U1, (Request, Framed<T, h1::Codec>)>,
-        U1: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
+        F: IntoServiceFactory<U1>,
+        U1: ServiceFactory<
+            Config = (),
+            Request = (Request, Framed<T, Codec>),
+            Response = (),
+        >,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
+        <U1::Service as Service>::Future: 'static,
     {
         HttpServiceBuilder {
             keep_alive: self.keep_alive,
@@ -155,11 +171,26 @@ where
             local_addr: self.local_addr,
             expect: self.expect,
             upgrade: Some(upgrade.into_factory()),
+            on_connect: self.on_connect,
             on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 
+    /// Set on-connect callback.
+    ///
+    /// Called once per connection. Return value of the call is stored in request extensions.
+    ///
+    /// *SOFT DEPRECATED*: Prefer the `on_connect_ext` style callback.
+    pub fn on_connect<F, I>(mut self, f: F) -> Self
+    where
+        F: Fn(&T) -> I + 'static,
+        I: Clone + 'static,
+    {
+        self.on_connect = Some(Rc::new(move |io| Box::new(Data(f(io)))));
+        self
+    }
+
     /// Sets the callback to be run on connection establishment.
     ///
     /// Has mutable access to a data container that will be merged into request extensions.
@@ -177,8 +208,8 @@ where
     pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
     where
         B: MessageBody,
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>>,
+        F: IntoServiceFactory<S>,
+        S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
     {
@@ -193,19 +224,19 @@ where
         H1Service::with_config(cfg, service.into_factory())
             .expect(self.expect)
             .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
             .on_connect_ext(self.on_connect_ext)
     }
 
     /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
     pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
     where
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        B: MessageBody + 'static,
+        F: IntoServiceFactory<S>,
+        S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
+        <S::Service as Service>::Future: 'static,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -216,19 +247,19 @@ where
         );
 
         H2Service::with_config(cfg, service.into_factory())
+            .on_connect(self.on_connect)
             .on_connect_ext(self.on_connect_ext)
     }
 
     /// Finish service configuration and create `HttpService` instance.
     pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
     where
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        B: MessageBody + 'static,
+        F: IntoServiceFactory<S>,
+        S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
+        <S::Service as Service>::Future: 'static,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -241,6 +272,7 @@ where
         HttpService::with_config(cfg, service.into_factory())
             .expect(self.expect)
             .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
             .on_connect_ext(self.on_connect_ext)
     }
 }

actix-http/src/client/config.rs

@@ -1,35 +1,31 @@
-use std::net::IpAddr;
 use std::time::Duration;
 
-const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2MB
-const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1MB
+// These values are taken from hyper/src/proto/h2/client.rs
+const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
+const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
 
 /// Connector configuration
 #[derive(Clone)]
 pub(crate) struct ConnectorConfig {
     pub(crate) timeout: Duration,
-    pub(crate) handshake_timeout: Duration,
     pub(crate) conn_lifetime: Duration,
     pub(crate) conn_keep_alive: Duration,
     pub(crate) disconnect_timeout: Option<Duration>,
     pub(crate) limit: usize,
     pub(crate) conn_window_size: u32,
     pub(crate) stream_window_size: u32,
-    pub(crate) local_address: Option<IpAddr>,
 }
 
 impl Default for ConnectorConfig {
     fn default() -> Self {
         Self {
-            timeout: Duration::from_secs(5),
-            handshake_timeout: Duration::from_secs(5),
+            timeout: Duration::from_secs(1),
             conn_lifetime: Duration::from_secs(75),
             conn_keep_alive: Duration::from_secs(15),
             disconnect_timeout: Some(Duration::from_millis(3000)),
             limit: 100,
             conn_window_size: DEFAULT_H2_CONN_WINDOW,
             stream_window_size: DEFAULT_H2_STREAM_WINDOW,
-            local_address: None,
         }
     }
 }

actix-http/src/client/connection.rs

@@ -1,365 +1,267 @@
-use std::{
-    io,
-    ops::{Deref, DerefMut},
-    pin::Pin,
-    task::{Context, Poll},
-    time,
-};
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{fmt, io, mem, time};
 
-use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
-use actix_rt::task::JoinHandle;
-use bytes::Bytes;
-use futures_core::future::LocalBoxFuture;
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use bytes::{Buf, Bytes};
+use futures_util::future::{err, Either, FutureExt, LocalBoxFuture, Ready};
 use h2::client::SendRequest;
+use pin_project::pin_project;
 
+use crate::body::MessageBody;
 use crate::h1::ClientCodec;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
-use crate::{body::MessageBody, Error};
 
 use super::error::SendRequestError;
-use super::pool::Acquired;
+use super::pool::{Acquired, Protocol};
 use super::{h1proto, h2proto};
 
-/// Trait alias for types impl [tokio::io::AsyncRead] and [tokio::io::AsyncWrite].
-pub trait ConnectionIo: AsyncRead + AsyncWrite + Unpin + 'static {}
+pub(crate) enum ConnectionType<Io> {
+    H1(Io),
+    H2(SendRequest<Bytes>),
+}
 
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static> ConnectionIo for T {}
+pub trait Connection {
+    type Io: AsyncRead + AsyncWrite + Unpin;
+    type Future: Future<Output = Result<(ResponseHead, Payload), SendRequestError>>;
 
+    fn protocol(&self) -> Protocol;
+
+    /// Send request and body
+    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
+        self,
+        head: H,
+        body: B,
+    ) -> Self::Future;
+
+    type TunnelFuture: Future<
+        Output = Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+    >;
+
+    /// Send request, returns Response and Framed
+    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture;
+}
+
+pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
+    /// Close connection
+    fn close(self: Pin<&mut Self>);
+
+    /// Release connection to the connection pool
+    fn release(self: Pin<&mut Self>);
+}
+
+#[doc(hidden)]
 /// HTTP client connection
-pub struct H1Connection<Io: ConnectionIo> {
-    io: Option<Io>,
+pub struct IoConnection<T> {
+    io: Option<ConnectionType<T>>,
     created: time::Instant,
-    acquired: Acquired<Io>,
+    pool: Option<Acquired<T>>,
 }
 
-impl<Io: ConnectionIo> H1Connection<Io> {
-    /// close or release the connection to pool based on flag input
-    pub(super) fn on_release(&mut self, keep_alive: bool) {
-        if keep_alive {
-            self.release();
-        } else {
-            self.close();
+impl<T> fmt::Debug for IoConnection<T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.io {
+            Some(ConnectionType::H1(ref io)) => write!(f, "H1Connection({:?})", io),
+            Some(ConnectionType::H2(_)) => write!(f, "H2Connection"),
+            None => write!(f, "Connection(Empty)"),
         }
     }
-
-    /// Close connection
-    fn close(&mut self) {
-        let io = self.io.take().unwrap();
-        self.acquired.close(ConnectionInnerType::H1(io));
-    }
-
-    /// Release this connection to the connection pool
-    fn release(&mut self) {
-        let io = self.io.take().unwrap();
-        self.acquired
-            .release(ConnectionInnerType::H1(io), self.created);
-    }
-
-    fn io_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Io> {
-        Pin::new(self.get_mut().io.as_mut().unwrap())
-    }
 }
 
-impl<Io: ConnectionIo> AsyncRead for H1Connection<Io> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        self.io_pin_mut().poll_read(cx, buf)
-    }
-}
-
-impl<Io: ConnectionIo> AsyncWrite for H1Connection<Io> {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        self.io_pin_mut().poll_write(cx, buf)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.io_pin_mut().poll_flush(cx)
-    }
-
-    fn poll_shutdown(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), io::Error>> {
-        self.io_pin_mut().poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[io::IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        self.io_pin_mut().poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.io.as_ref().unwrap().is_write_vectored()
-    }
-}
-
-/// HTTP2 client connection
-pub struct H2Connection<Io: ConnectionIo> {
-    io: Option<H2ConnectionInner>,
-    created: time::Instant,
-    acquired: Acquired<Io>,
-}
-
-impl<Io: ConnectionIo> Deref for H2Connection<Io> {
-    type Target = SendRequest<Bytes>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.io.as_ref().unwrap().sender
-    }
-}
-
-impl<Io: ConnectionIo> DerefMut for H2Connection<Io> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.io.as_mut().unwrap().sender
-    }
-}
-
-impl<Io: ConnectionIo> H2Connection<Io> {
-    /// close or release the connection to pool based on flag input
-    pub(super) fn on_release(&mut self, close: bool) {
-        if close {
-            self.close();
-        } else {
-            self.release();
-        }
-    }
-
-    /// Close connection
-    fn close(&mut self) {
-        let io = self.io.take().unwrap();
-        self.acquired.close(ConnectionInnerType::H2(io));
-    }
-
-    /// Release this connection to the connection pool
-    fn release(&mut self) {
-        let io = self.io.take().unwrap();
-        self.acquired
-            .release(ConnectionInnerType::H2(io), self.created);
-    }
-}
-
-/// `H2ConnectionInner` has two parts: `SendRequest` and `Connection`.
-///
-/// `Connection` is spawned as an async task on runtime and `H2ConnectionInner` holds a handle
-/// for this task. Therefore, it can wake up and quit the task when SendRequest is dropped.
-pub(super) struct H2ConnectionInner {
-    handle: JoinHandle<()>,
-    sender: SendRequest<Bytes>,
-}
-
-impl H2ConnectionInner {
-    pub(super) fn new<Io: ConnectionIo>(
-        sender: SendRequest<Bytes>,
-        connection: h2::client::Connection<Io>,
+impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
+    pub(crate) fn new(
+        io: ConnectionType<T>,
+        created: time::Instant,
+        pool: Option<Acquired<T>>,
     ) -> Self {
-        let handle = actix_rt::spawn(async move {
-            let _ = connection.await;
-        });
+        IoConnection {
+            pool,
+            created,
+            io: Some(io),
+        }
+    }
 
-        Self { handle, sender }
+    pub(crate) fn into_inner(self) -> (ConnectionType<T>, time::Instant) {
+        (self.io.unwrap(), self.created)
     }
 }
 
-/// Cancel spawned connection task on drop.
-impl Drop for H2ConnectionInner {
-    fn drop(&mut self) {
-        if self
-            .sender
-            .send_request(http::Request::new(()), true)
-            .is_err()
-        {
-            self.handle.abort();
+impl<T> Connection for IoConnection<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    type Io = T;
+    type Future =
+        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
+
+    fn protocol(&self) -> Protocol {
+        match self.io {
+            Some(ConnectionType::H1(_)) => Protocol::Http1,
+            Some(ConnectionType::H2(_)) => Protocol::Http2,
+            None => Protocol::Http1,
+        }
+    }
+
+    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
+        mut self,
+        head: H,
+        body: B,
+    ) -> Self::Future {
+        match self.io.take().unwrap() {
+            ConnectionType::H1(io) => {
+                h1proto::send_request(io, head.into(), body, self.created, self.pool)
+                    .boxed_local()
+            }
+            ConnectionType::H2(io) => {
+                h2proto::send_request(io, head.into(), body, self.created, self.pool)
+                    .boxed_local()
+            }
+        }
+    }
+
+    type TunnelFuture = Either<
+        LocalBoxFuture<
+            'static,
+            Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+        >,
+        Ready<Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>>,
+    >;
+
+    /// Send request, returns Response and Framed
+    fn open_tunnel<H: Into<RequestHeadType>>(mut self, head: H) -> Self::TunnelFuture {
+        match self.io.take().unwrap() {
+            ConnectionType::H1(io) => {
+                Either::Left(h1proto::open_tunnel(io, head.into()).boxed_local())
+            }
+            ConnectionType::H2(io) => {
+                if let Some(mut pool) = self.pool.take() {
+                    pool.release(IoConnection::new(
+                        ConnectionType::H2(io),
+                        self.created,
+                        None,
+                    ));
+                }
+                Either::Right(err(SendRequestError::TunnelNotSupported))
+            }
         }
     }
 }
 
 #[allow(dead_code)]
-/// Unified connection type cover Http1 Plain/Tls and Http2 protocols
-pub enum Connection<A, B = Box<dyn ConnectionIo>>
+pub(crate) enum EitherConnection<A, B> {
+    A(IoConnection<A>),
+    B(IoConnection<B>),
+}
+
+impl<A, B> Connection for EitherConnection<A, B>
 where
-    A: ConnectionIo,
-    B: ConnectionIo,
+    A: AsyncRead + AsyncWrite + Unpin + 'static,
+    B: AsyncRead + AsyncWrite + Unpin + 'static,
 {
-    Tcp(ConnectionType<A>),
-    Tls(ConnectionType<B>),
-}
+    type Io = EitherIo<A, B>;
+    type Future =
+        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
 
-/// Unified connection type cover Http1/2 protocols
-pub enum ConnectionType<Io: ConnectionIo> {
-    H1(H1Connection<Io>),
-    H2(H2Connection<Io>),
-}
-
-/// Helper type for storing connection types in pool.
-pub(super) enum ConnectionInnerType<Io> {
-    H1(Io),
-    H2(H2ConnectionInner),
-}
-
-impl<Io: ConnectionIo> ConnectionType<Io> {
-    pub(super) fn from_pool(
-        inner: ConnectionInnerType<Io>,
-        created: time::Instant,
-        acquired: Acquired<Io>,
-    ) -> Self {
-        match inner {
-            ConnectionInnerType::H1(io) => Self::from_h1(io, created, acquired),
-            ConnectionInnerType::H2(io) => Self::from_h2(io, created, acquired),
+    fn protocol(&self) -> Protocol {
+        match self {
+            EitherConnection::A(con) => con.protocol(),
+            EitherConnection::B(con) => con.protocol(),
         }
     }
 
-    pub(super) fn from_h1(
-        io: Io,
-        created: time::Instant,
-        acquired: Acquired<Io>,
-    ) -> Self {
-        Self::H1(H1Connection {
-            io: Some(io),
-            created,
-            acquired,
-        })
-    }
-
-    pub(super) fn from_h2(
-        io: H2ConnectionInner,
-        created: time::Instant,
-        acquired: Acquired<Io>,
-    ) -> Self {
-        Self::H2(H2Connection {
-            io: Some(io),
-            created,
-            acquired,
-        })
-    }
-}
-
-impl<A, B> Connection<A, B>
-where
-    A: ConnectionIo,
-    B: ConnectionIo,
-{
-    /// Send a request through connection.
-    pub fn send_request<RB, H>(
+    fn send_request<RB: MessageBody + 'static, H: Into<RequestHeadType>>(
         self,
         head: H,
         body: RB,
-    ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
-    where
-        H: Into<RequestHeadType> + 'static,
-        RB: MessageBody + 'static,
-        RB::Error: Into<Error>,
-    {
-        Box::pin(async move {
-            match self {
-                Connection::Tcp(ConnectionType::H1(conn)) => {
-                    h1proto::send_request(conn, head.into(), body).await
-                }
-                Connection::Tls(ConnectionType::H1(conn)) => {
-                    h1proto::send_request(conn, head.into(), body).await
-                }
-                Connection::Tls(ConnectionType::H2(conn)) => {
-                    h2proto::send_request(conn, head.into(), body).await
-                }
-                _ => unreachable!(
-                    "Plain Tcp connection can be used only in Http1 protocol"
-                ),
-            }
-        })
+    ) -> Self::Future {
+        match self {
+            EitherConnection::A(con) => con.send_request(head, body),
+            EitherConnection::B(con) => con.send_request(head, body),
+        }
     }
 
-    /// Send request, returns Response and Framed tunnel.
-    pub fn open_tunnel<H: Into<RequestHeadType> + 'static>(
-        self,
-        head: H,
-    ) -> LocalBoxFuture<
+    type TunnelFuture = LocalBoxFuture<
         'static,
-        Result<(ResponseHead, Framed<Connection<A, B>, ClientCodec>), SendRequestError>,
-    > {
-        Box::pin(async move {
-            match self {
-                Connection::Tcp(ConnectionType::H1(ref _conn)) => {
-                    let (head, framed) = h1proto::open_tunnel(self, head.into()).await?;
-                    Ok((head, framed))
-                }
-                Connection::Tls(ConnectionType::H1(ref _conn)) => {
-                    let (head, framed) = h1proto::open_tunnel(self, head.into()).await?;
-                    Ok((head, framed))
-                }
-                Connection::Tls(ConnectionType::H2(mut conn)) => {
-                    conn.release();
-                    Err(SendRequestError::TunnelNotSupported)
-                }
-                Connection::Tcp(ConnectionType::H2(_)) => {
-                    unreachable!(
-                        "Plain Tcp connection can be used only in Http1 protocol"
-                    )
-                }
-            }
-        })
+        Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+    >;
+
+    /// Send request, returns Response and Framed
+    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture {
+        match self {
+            EitherConnection::A(con) => con
+                .open_tunnel(head)
+                .map(|res| {
+                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::A)))
+                })
+                .boxed_local(),
+            EitherConnection::B(con) => con
+                .open_tunnel(head)
+                .map(|res| {
+                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::B)))
+                })
+                .boxed_local(),
+        }
     }
 }
 
-impl<A, B> AsyncRead for Connection<A, B>
+#[pin_project(project = EitherIoProj)]
+pub enum EitherIo<A, B> {
+    A(#[pin] A),
+    B(#[pin] B),
+}
+
+impl<A, B> AsyncRead for EitherIo<A, B>
 where
-    A: ConnectionIo,
-    B: ConnectionIo,
+    A: AsyncRead,
+    B: AsyncRead,
 {
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        match self.get_mut() {
-            Connection::Tcp(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_read(cx, buf)
-            }
-            Connection::Tls(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_read(cx, buf)
-            }
-            _ => unreachable!("H2Connection can not impl AsyncRead trait"),
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        match self.project() {
+            EitherIoProj::A(val) => val.poll_read(cx, buf),
+            EitherIoProj::B(val) => val.poll_read(cx, buf),
+        }
+    }
+
+    unsafe fn prepare_uninitialized_buffer(
+        &self,
+        buf: &mut [mem::MaybeUninit<u8>],
+    ) -> bool {
+        match self {
+            EitherIo::A(ref val) => val.prepare_uninitialized_buffer(buf),
+            EitherIo::B(ref val) => val.prepare_uninitialized_buffer(buf),
         }
     }
 }
 
-const H2_UNREACHABLE_WRITE: &str = "H2Connection can not impl AsyncWrite trait";
-
-impl<A, B> AsyncWrite for Connection<A, B>
+impl<A, B> AsyncWrite for EitherIo<A, B>
 where
-    A: ConnectionIo,
-    B: ConnectionIo,
+    A: AsyncWrite,
+    B: AsyncWrite,
 {
     fn poll_write(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        match self.get_mut() {
-            Connection::Tcp(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_write(cx, buf)
-            }
-            Connection::Tls(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_write(cx, buf)
-            }
-            _ => unreachable!(H2_UNREACHABLE_WRITE),
+        match self.project() {
+            EitherIoProj::A(val) => val.poll_write(cx, buf),
+            EitherIoProj::B(val) => val.poll_write(cx, buf),
         }
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        match self.get_mut() {
-            Connection::Tcp(ConnectionType::H1(conn)) => Pin::new(conn).poll_flush(cx),
-            Connection::Tls(ConnectionType::H1(conn)) => Pin::new(conn).poll_flush(cx),
-            _ => unreachable!(H2_UNREACHABLE_WRITE),
+        match self.project() {
+            EitherIoProj::A(val) => val.poll_flush(cx),
+            EitherIoProj::B(val) => val.poll_flush(cx),
         }
     }
 
@@ -367,109 +269,23 @@ where
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<io::Result<()>> {
-        match self.get_mut() {
-            Connection::Tcp(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_shutdown(cx)
-            }
-            Connection::Tls(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_shutdown(cx)
-            }
-            _ => unreachable!(H2_UNREACHABLE_WRITE),
+        match self.project() {
+            EitherIoProj::A(val) => val.poll_shutdown(cx),
+            EitherIoProj::B(val) => val.poll_shutdown(cx),
         }
     }
 
-    fn poll_write_vectored(
+    fn poll_write_buf<U: Buf>(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-        bufs: &[io::IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        match self.get_mut() {
-            Connection::Tcp(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_write_vectored(cx, bufs)
-            }
-            Connection::Tls(ConnectionType::H1(conn)) => {
-                Pin::new(conn).poll_write_vectored(cx, bufs)
-            }
-            _ => unreachable!(H2_UNREACHABLE_WRITE),
-        }
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        match *self {
-            Connection::Tcp(ConnectionType::H1(ref conn)) => conn.is_write_vectored(),
-            Connection::Tls(ConnectionType::H1(ref conn)) => conn.is_write_vectored(),
-            _ => unreachable!(H2_UNREACHABLE_WRITE),
+        buf: &mut U,
+    ) -> Poll<Result<usize, io::Error>>
+    where
+        Self: Sized,
+    {
+        match self.project() {
+            EitherIoProj::A(val) => val.poll_write_buf(cx, buf),
+            EitherIoProj::B(val) => val.poll_write_buf(cx, buf),
         }
     }
 }
-
-#[cfg(test)]
-mod test {
-    use std::{
-        future::Future,
-        net,
-        pin::Pin,
-        task::{Context, Poll},
-        time::{Duration, Instant},
-    };
-
-    use actix_rt::{
-        net::TcpStream,
-        time::{interval, Interval},
-    };
-
-    use super::*;
-
-    #[actix_rt::test]
-    async fn test_h2_connection_drop() {
-        let addr = "127.0.0.1:0".parse::<net::SocketAddr>().unwrap();
-        let listener = net::TcpListener::bind(addr).unwrap();
-        let local = listener.local_addr().unwrap();
-
-        std::thread::spawn(move || while listener.accept().is_ok() {});
-
-        let tcp = TcpStream::connect(local).await.unwrap();
-        let (sender, connection) = h2::client::handshake(tcp).await.unwrap();
-        let conn = H2ConnectionInner::new(sender.clone(), connection);
-
-        assert!(sender.clone().ready().await.is_ok());
-        assert!(h2::client::SendRequest::clone(&conn.sender)
-            .ready()
-            .await
-            .is_ok());
-
-        drop(conn);
-
-        struct DropCheck {
-            sender: h2::client::SendRequest<Bytes>,
-            interval: Interval,
-            start_from: Instant,
-        }
-
-        impl Future for DropCheck {
-            type Output = ();
-
-            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-                let this = self.get_mut();
-                match futures_core::ready!(this.sender.poll_ready(cx)) {
-                    Ok(()) => {
-                        if this.start_from.elapsed() > Duration::from_secs(10) {
-                            panic!("connection should be gone and can not be ready");
-                        } else {
-                            let _ = this.interval.poll_tick(cx);
-                            Poll::Pending
-                        }
-                    }
-                    Err(_) => Poll::Ready(()),
-                }
-            }
-        }
-
-        DropCheck {
-            sender,
-            interval: interval(Duration::from_millis(100)),
-            start_from: Instant::now(),
-        }
-        .await;
-    }
-}

actix-http/src/client/error.rs

@@ -1,16 +1,16 @@
-use std::{error::Error as StdError, fmt, io};
+use std::io;
 
+use actix_connect::resolver::ResolveError;
 use derive_more::{Display, From};
 
 #[cfg(feature = "openssl")]
-use actix_tls::accept::openssl::SslError;
+use actix_connect::ssl::openssl::{HandshakeError, SslError};
 
-use crate::error::{Error, ParseError};
-use crate::http::Error as HttpError;
+use crate::error::{Error, ParseError, ResponseError};
+use crate::http::{Error as HttpError, StatusCode};
 
 /// A set of errors that can occur while connecting to an HTTP host
 #[derive(Debug, Display, From)]
-#[non_exhaustive]
 pub enum ConnectError {
     /// SSL feature is not enabled
     #[display(fmt = "SSL is not supported")]
@@ -21,12 +21,17 @@ pub enum ConnectError {
     #[display(fmt = "{}", _0)]
     SslError(SslError),
 
+    /// SSL Handshake error
+    #[cfg(feature = "openssl")]
+    #[display(fmt = "{}", _0)]
+    SslHandshakeError(String),
+
     /// Failed to resolve the hostname
     #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(Box<dyn std::error::Error>),
+    Resolver(ResolveError),
 
     /// No dns records
-    #[display(fmt = "No DNS records found for the input")]
+    #[display(fmt = "No dns records found for the input")]
     NoRecords,
 
     /// Http2 error
@@ -52,31 +57,34 @@ pub enum ConnectError {
 
 impl std::error::Error for ConnectError {}
 
-impl From<actix_tls::connect::ConnectError> for ConnectError {
-    fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
+impl From<actix_connect::ConnectError> for ConnectError {
+    fn from(err: actix_connect::ConnectError) -> ConnectError {
         match err {
-            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
-            actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
-            actix_tls::connect::ConnectError::InvalidInput => panic!(),
-            actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
+            actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
+            actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
+            actix_connect::ConnectError::InvalidInput => panic!(),
+            actix_connect::ConnectError::Unresolved => ConnectError::Unresolved,
+            actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
         }
     }
 }
 
+#[cfg(feature = "openssl")]
+impl<T: std::fmt::Debug> From<HandshakeError<T>> for ConnectError {
+    fn from(err: HandshakeError<T>) -> ConnectError {
+        ConnectError::SslHandshakeError(format!("{:?}", err))
+    }
+}
+
 #[derive(Debug, Display, From)]
-#[non_exhaustive]
 pub enum InvalidUrl {
-    #[display(fmt = "Missing URL scheme")]
+    #[display(fmt = "Missing url scheme")]
     MissingScheme,
-
-    #[display(fmt = "Unknown URL scheme")]
+    #[display(fmt = "Unknown url scheme")]
     UnknownScheme,
-
     #[display(fmt = "Missing host name")]
     MissingHost,
-
-    #[display(fmt = "URL parse error: {}", _0)]
+    #[display(fmt = "Url parse error: {}", _0)]
     HttpError(http::Error),
 }
 
@@ -84,73 +92,66 @@ impl std::error::Error for InvalidUrl {}
 
 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
-#[non_exhaustive]
 pub enum SendRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
     Url(InvalidUrl),
-
     /// Failed to connect to host
     #[display(fmt = "Failed to connect to host: {}", _0)]
     Connect(ConnectError),
-
     /// Error sending request
     Send(io::Error),
-
     /// Error parsing response
     Response(ParseError),
-
     /// Http error
     #[display(fmt = "{}", _0)]
     Http(HttpError),
-
     /// Http2 error
     #[display(fmt = "{}", _0)]
     H2(h2::Error),
-
     /// Response took too long
     #[display(fmt = "Timeout while waiting for response")]
     Timeout,
-
-    /// Tunnels are not supported for HTTP/2 connection
+    /// Tunnels are not supported for http2 connection
     #[display(fmt = "Tunnels are not supported for http2 connection")]
     TunnelNotSupported,
-
     /// Error sending request body
     Body(Error),
-
-    /// Other errors that can occur after submitting a request.
-    #[display(fmt = "{:?}: {}", _1, _0)]
-    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }
 
 impl std::error::Error for SendRequestError {}
 
+/// Convert `SendRequestError` to a server `Response`
+impl ResponseError for SendRequestError {
+    fn status_code(&self) -> StatusCode {
+        match *self {
+            SendRequestError::Connect(ConnectError::Timeout) => {
+                StatusCode::GATEWAY_TIMEOUT
+            }
+            SendRequestError::Connect(_) => StatusCode::BAD_REQUEST,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
 /// A set of errors that can occur during freezing a request
 #[derive(Debug, Display, From)]
-#[non_exhaustive]
 pub enum FreezeRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
     Url(InvalidUrl),
-
-    /// HTTP error
+    /// Http error
     #[display(fmt = "{}", _0)]
     Http(HttpError),
-
-    /// Other errors that can occur after submitting a request.
-    #[display(fmt = "{:?}: {}", _1, _0)]
-    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }
 
 impl std::error::Error for FreezeRequestError {}
 
 impl From<FreezeRequestError> for SendRequestError {
-    fn from(err: FreezeRequestError) -> Self {
-        match err {
-            FreezeRequestError::Url(err) => err.into(),
-            FreezeRequestError::Http(err) => err.into(),
-            FreezeRequestError::Custom(err, msg) => SendRequestError::Custom(err, msg),
+    fn from(e: FreezeRequestError) -> Self {
+        match e {
+            FreezeRequestError::Url(e) => e.into(),
+            FreezeRequestError::Http(e) => e.into(),
         }
     }
 }

actix-http/src/client/h1proto.rs

@@ -1,38 +1,37 @@
-use std::{
-    io::Write,
-    pin::Pin,
-    task::{Context, Poll},
-};
+use std::io::Write;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{io, mem, time};
 
-use actix_codec::Framed;
-use actix_utils::future::poll_fn;
-use bytes::buf::BufMut;
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use bytes::buf::BufMutExt;
 use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
-use futures_util::SinkExt as _;
+use futures_core::Stream;
+use futures_util::future::poll_fn;
+use futures_util::{pin_mut, SinkExt, StreamExt};
 
+use crate::error::PayloadError;
 use crate::h1;
-use crate::http::{
-    header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
-    StatusCode,
-};
+use crate::header::HeaderMap;
+use crate::http::header::{IntoHeaderValue, HOST};
 use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-use crate::{error::PayloadError, Error};
+use crate::payload::{Payload, PayloadStream};
 
-use super::connection::{ConnectionIo, H1Connection};
+use super::connection::{ConnectionLifetime, ConnectionType, IoConnection};
 use super::error::{ConnectError, SendRequestError};
+use super::pool::Acquired;
 use crate::body::{BodySize, MessageBody};
 
-pub(crate) async fn send_request<Io, B>(
-    io: H1Connection<Io>,
+pub(crate) async fn send_request<T, B>(
+    io: T,
     mut head: RequestHeadType,
     body: B,
+    created: time::Instant,
+    pool: Option<Acquired<T>>,
 ) -> Result<(ResponseHead, Payload), SendRequestError>
 where
-    Io: ConnectionIo,
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     // set request host header
     if !head.as_ref().headers.contains_key(HOST)
@@ -41,19 +40,19 @@ where
         if let Some(host) = head.as_ref().uri.host() {
             let mut wrt = BytesMut::with_capacity(host.len() + 5).writer();
 
-            match head.as_ref().uri.port_u16() {
-                None | Some(80) | Some(443) => write!(wrt, "{}", host)?,
-                Some(port) => write!(wrt, "{}:{}", host, port)?,
+            let _ = match head.as_ref().uri.port_u16() {
+                None | Some(80) | Some(443) => write!(wrt, "{}", host),
+                Some(port) => write!(wrt, "{}:{}", host, port),
             };
 
-            match wrt.get_mut().split().freeze().try_into_value() {
+            match wrt.get_mut().split().freeze().try_into() {
                 Ok(value) => match head {
                     RequestHeadType::Owned(ref mut head) => {
-                        head.headers.insert(HOST, value);
+                        head.headers.insert(HOST, value)
                     }
                     RequestHeadType::Rc(_, ref mut extra_headers) => {
                         let headers = extra_headers.get_or_insert(HeaderMap::new());
-                        headers.insert(HOST, value);
+                        headers.insert(HOST, value)
                     }
                 },
                 Err(e) => log::error!("Can not set HOST header {}", e),
@@ -61,112 +60,82 @@ where
         }
     }
 
-    // create Framed and prepare sending request
-    let mut framed = Framed::new(io, h1::ClientCodec::default());
-
-    // Check EXPECT header and enable expect handle flag accordingly.
-    //
-    // RFC: https://tools.ietf.org/html/rfc7231#section-5.1.1
-    let is_expect = if head.as_ref().headers.contains_key(EXPECT) {
-        match body.size() {
-            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {
-                let keep_alive = framed.codec_ref().keepalive();
-                framed.io_mut().on_release(keep_alive);
-
-                // TODO: use a new variant or a new type better describing error violate
-                // `Requirements for clients` session of above RFC
-                return Err(SendRequestError::Connect(ConnectError::Disconnected));
-            }
-            _ => true,
-        }
-    } else {
-        false
+    let io = H1Connection {
+        created,
+        pool,
+        io: Some(io),
     };
 
-    framed.send((head, body.size()).into()).await?;
+    // create Framed and send request
+    let mut framed_inner = Framed::new(io, h1::ClientCodec::default());
+    framed_inner.send((head, body.size()).into()).await?;
 
-    let mut pin_framed = Pin::new(&mut framed);
-
-    // special handle for EXPECT request.
-    let (do_send, mut res_head) = if is_expect {
-        let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
-            .await
-            .ok_or(ConnectError::Disconnected)??;
-
-        // return response head in case status code is not continue
-        // and current head would be used as final response head.
-        (head.status == StatusCode::CONTINUE, Some(head))
-    } else {
-        (true, None)
+    // send request body
+    match body.size() {
+        BodySize::None | BodySize::Empty | BodySize::Sized(0) => (),
+        _ => send_body(body, Pin::new(&mut framed_inner)).await?,
     };
 
-    if do_send {
-        // send request body
-        match body.size() {
-            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {}
-            _ => send_body(body, pin_framed.as_mut()).await?,
-        };
+    // read response and init read body
+    let res = Pin::new(&mut framed_inner).into_future().await;
+    let (head, framed) = if let (Some(result), framed) = res {
+        let item = result.map_err(SendRequestError::from)?;
+        (item, framed)
+    } else {
+        return Err(SendRequestError::from(ConnectError::Disconnected));
+    };
 
-        // read response and init read body
-        let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
-            .await
-            .ok_or(ConnectError::Disconnected)??;
-
-        res_head = Some(head);
-    }
-
-    let head = res_head.unwrap();
-
-    match pin_framed.codec_ref().message_type() {
+    match framed.codec_ref().message_type() {
         h1::MessageType::None => {
-            let keep_alive = pin_framed.codec_ref().keepalive();
-            pin_framed.io_mut().on_release(keep_alive);
-
+            let force_close = !framed.codec_ref().keepalive();
+            release_connection(framed, force_close);
             Ok((head, Payload::None))
         }
-        _ => Ok((head, Payload::Stream(Box::pin(PlStream::new(framed))))),
+        _ => {
+            let pl: PayloadStream = PlStream::new(framed_inner).boxed_local();
+            Ok((head, pl.into()))
+        }
     }
 }
 
-pub(crate) async fn open_tunnel<Io>(
-    io: Io,
+pub(crate) async fn open_tunnel<T>(
+    io: T,
     head: RequestHeadType,
-) -> Result<(ResponseHead, Framed<Io, h1::ClientCodec>), SendRequestError>
+) -> Result<(ResponseHead, Framed<T, h1::ClientCodec>), SendRequestError>
 where
-    Io: ConnectionIo,
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
 {
-    // create Framed and send request.
+    // create Framed and send request
     let mut framed = Framed::new(io, h1::ClientCodec::default());
     framed.send((head, BodySize::None).into()).await?;
 
-    // read response head.
-    let head = poll_fn(|cx| Pin::new(&mut framed).poll_next(cx))
-        .await
-        .ok_or(ConnectError::Disconnected)??;
-
-    Ok((head, framed))
+    // read response
+    if let (Some(result), framed) = framed.into_future().await {
+        let head = result.map_err(SendRequestError::from)?;
+        Ok((head, framed))
+    } else {
+        Err(SendRequestError::from(ConnectError::Disconnected))
+    }
 }
 
 /// send request body to the peer
-pub(crate) async fn send_body<Io, B>(
+pub(crate) async fn send_body<T, B>(
     body: B,
-    mut framed: Pin<&mut Framed<Io, h1::ClientCodec>>,
+    mut framed: Pin<&mut Framed<T, h1::ClientCodec>>,
 ) -> Result<(), SendRequestError>
 where
-    Io: ConnectionIo,
+    T: ConnectionLifetime + Unpin,
     B: MessageBody,
-    B::Error: Into<Error>,
 {
-    actix_rt::pin!(body);
+    pin_mut!(body);
 
     let mut eof = false;
     while !eof {
         while !eof && !framed.as_ref().is_write_buf_full() {
             match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(Ok(chunk)) => {
-                    framed.as_mut().write(h1::Message::Chunk(Some(chunk)))?;
+                Some(result) => {
+                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
                 }
-                Some(Err(err)) => return Err(err.into().into()),
                 None => {
                     eof = true;
                     framed.as_mut().write(h1::Message::Chunk(None))?;
@@ -190,25 +159,108 @@ where
         }
     }
 
-    framed.get_mut().flush().await?;
+    SinkExt::flush(Pin::into_inner(framed)).await?;
     Ok(())
 }
 
-#[pin_project::pin_project]
-pub(crate) struct PlStream<Io: ConnectionIo> {
-    #[pin]
-    framed: Framed<H1Connection<Io>, h1::ClientPayloadCodec>,
+#[doc(hidden)]
+/// HTTP client connection
+pub struct H1Connection<T> {
+    /// T should be `Unpin`
+    io: Option<T>,
+    created: time::Instant,
+    pool: Option<Acquired<T>>,
 }
 
-impl<Io: ConnectionIo> PlStream<Io> {
-    fn new(framed: Framed<H1Connection<Io>, h1::ClientCodec>) -> Self {
-        let framed = framed.into_map_codec(|codec| codec.into_payload_codec());
+impl<T> ConnectionLifetime for H1Connection<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    /// Close connection
+    fn close(mut self: Pin<&mut Self>) {
+        if let Some(mut pool) = self.pool.take() {
+            if let Some(io) = self.io.take() {
+                pool.close(IoConnection::new(
+                    ConnectionType::H1(io),
+                    self.created,
+                    None,
+                ));
+            }
+        }
+    }
 
-        PlStream { framed }
+    /// Release this connection to the connection pool
+    fn release(mut self: Pin<&mut Self>) {
+        if let Some(mut pool) = self.pool.take() {
+            if let Some(io) = self.io.take() {
+                pool.release(IoConnection::new(
+                    ConnectionType::H1(io),
+                    self.created,
+                    None,
+                ));
+            }
+        }
     }
 }
 
-impl<Io: ConnectionIo> Stream for PlStream<Io> {
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncRead for H1Connection<T> {
+    unsafe fn prepare_uninitialized_buffer(
+        &self,
+        buf: &mut [mem::MaybeUninit<u8>],
+    ) -> bool {
+        self.io.as_ref().unwrap().prepare_uninitialized_buffer(buf)
+    }
+
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io.as_mut().unwrap()).poll_read(cx, buf)
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncWrite for H1Connection<T> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io.as_mut().unwrap()).poll_write(cx, buf)
+    }
+
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(self.io.as_mut().unwrap()).poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        Pin::new(self.io.as_mut().unwrap()).poll_shutdown(cx)
+    }
+}
+
+#[pin_project::pin_project]
+pub(crate) struct PlStream<Io> {
+    #[pin]
+    framed: Option<Framed<Io, h1::ClientPayloadCodec>>,
+}
+
+impl<Io: ConnectionLifetime> PlStream<Io> {
+    fn new(framed: Framed<Io, h1::ClientCodec>) -> Self {
+        let framed = framed.into_map_codec(|codec| codec.into_payload_codec());
+
+        PlStream {
+            framed: Some(framed),
+        }
+    }
+}
+
+impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
     type Item = Result<Bytes, PayloadError>;
 
     fn poll_next(
@@ -217,14 +269,30 @@ impl<Io: ConnectionIo> Stream for PlStream<Io> {
     ) -> Poll<Option<Self::Item>> {
         let mut this = self.project();
 
-        match ready!(this.framed.as_mut().next_item(cx)?) {
-            Some(Some(chunk)) => Poll::Ready(Some(Ok(chunk))),
-            Some(None) => {
-                let keep_alive = this.framed.codec_ref().keepalive();
-                this.framed.io_mut().on_release(keep_alive);
-                Poll::Ready(None)
+        match this.framed.as_mut().as_pin_mut().unwrap().next_item(cx)? {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Some(chunk)) => {
+                if let Some(chunk) = chunk {
+                    Poll::Ready(Some(Ok(chunk)))
+                } else {
+                    let framed = this.framed.as_mut().as_pin_mut().unwrap();
+                    let force_close = !framed.codec_ref().keepalive();
+                    release_connection(framed, force_close);
+                    Poll::Ready(None)
+                }
             }
-            None => Poll::Ready(None),
+            Poll::Ready(None) => Poll::Ready(None),
         }
     }
 }
+
+fn release_connection<T, U>(framed: Pin<&mut Framed<T, U>>, force_close: bool)
+where
+    T: ConnectionLifetime,
+{
+    if !force_close && framed.is_read_buf_empty() && framed.is_write_buf_empty() {
+        framed.io_pin().release()
+    } else {
+        framed.io_pin().close()
+    }
+}

actix-http/src/client/h2proto.rs

@@ -1,7 +1,11 @@
+use std::convert::TryFrom;
 use std::future::Future;
+use std::time;
 
-use actix_utils::future::poll_fn;
+use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
+use futures_util::future::poll_fn;
+use futures_util::pin_mut;
 use h2::{
     client::{Builder, Connection, SendRequest},
     SendStream,
@@ -9,32 +13,28 @@ use h2::{
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
-use crate::{
-    body::{BodySize, MessageBody},
-    header::HeaderMap,
-    message::{RequestHeadType, ResponseHead},
-    payload::Payload,
-    Error,
-};
+use crate::body::{BodySize, MessageBody};
+use crate::header::HeaderMap;
+use crate::message::{RequestHeadType, ResponseHead};
+use crate::payload::Payload;
 
-use super::{
-    config::ConnectorConfig,
-    connection::{ConnectionIo, H2Connection},
-    error::SendRequestError,
-};
+use super::config::ConnectorConfig;
+use super::connection::{ConnectionType, IoConnection};
+use super::error::SendRequestError;
+use super::pool::Acquired;
 
-pub(crate) async fn send_request<Io, B>(
-    mut io: H2Connection<Io>,
+pub(crate) async fn send_request<T, B>(
+    mut io: SendRequest<Bytes>,
     head: RequestHeadType,
     body: B,
+    created: time::Instant,
+    pool: Option<Acquired<T>>,
 ) -> Result<(ResponseHead, Payload), SendRequestError>
 where
-    Io: ConnectionIo,
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     trace!("Sending client request: {:?} {:?}", head, body.size());
-
     let head_req = head.as_ref().method == Method::HEAD;
     let length = body.size();
     let eof = matches!(
@@ -60,14 +60,10 @@ where
         BodySize::Empty => req
             .headers_mut()
             .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-        BodySize::Sized(len) => {
-            let mut buf = itoa::Buffer::new();
-
-            req.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::from_str(buf.format(len)).unwrap(),
-            )
-        }
+        BodySize::Sized(len) => req.headers_mut().insert(
+            CONTENT_LENGTH,
+            HeaderValue::try_from(format!("{}", len)).unwrap(),
+        ),
     };
 
     // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
@@ -90,26 +86,23 @@ where
     // copy headers
     for (key, value) in headers {
         match *key {
-            // TODO: consider skipping other headers according to:
-            //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
-            // omit HTTP/1.x only headers
-            CONNECTION | TRANSFER_ENCODING => continue,
+            CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
             CONTENT_LENGTH if skip_len => continue,
             // DATE => has_date = true,
-            _ => {}
+            _ => (),
         }
         req.headers_mut().append(key, value.clone());
     }
 
     let res = poll_fn(|cx| io.poll_ready(cx)).await;
     if let Err(e) = res {
-        io.on_release(e.is_io());
+        release(io, pool, created, e.is_io());
         return Err(SendRequestError::from(e));
     }
 
     let resp = match io.send_request(req, eof) {
         Ok((fut, send)) => {
-            io.on_release(false);
+            release(io, pool, created, false);
 
             if !eof {
                 send_body(body, send).await?;
@@ -117,7 +110,7 @@ where
             fut.await.map_err(SendRequestError::from)?
         }
         Err(e) => {
-            io.on_release(e.is_io());
+            release(io, pool, created, e.is_io());
             return Err(e.into());
         }
     };
@@ -131,16 +124,12 @@ where
     Ok((head, payload))
 }
 
-async fn send_body<B>(
+async fn send_body<B: MessageBody>(
     body: B,
     mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
+) -> Result<(), SendRequestError> {
     let mut buf = None;
-    actix_rt::pin!(body);
+    pin_mut!(body);
     loop {
         if buf.is_none() {
             match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
@@ -148,7 +137,7 @@ where
                     send.reserve_capacity(b.len());
                     buf = Some(b);
                 }
-                Some(Err(e)) => return Err(e.into().into()),
+                Some(Err(e)) => return Err(e.into()),
                 None => {
                     if let Err(e) = send.send_data(Bytes::new(), true) {
                         return Err(e.into());
@@ -168,23 +157,42 @@ where
 
                 if let Err(e) = send.send_data(bytes, false) {
                     return Err(e.into());
-                }
-                if !b.is_empty() {
-                    send.reserve_capacity(b.len());
                 } else {
-                    buf = None;
+                    if !b.is_empty() {
+                        send.reserve_capacity(b.len());
+                    } else {
+                        buf = None;
+                    }
+                    continue;
                 }
-                continue;
             }
             Some(Err(e)) => return Err(e.into()),
         }
     }
 }
 
-pub(crate) fn handshake<Io: ConnectionIo>(
+// release SendRequest object
+fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
+    io: SendRequest<Bytes>,
+    pool: Option<Acquired<T>>,
+    created: time::Instant,
+    close: bool,
+) {
+    if let Some(mut pool) = pool {
+        if close {
+            pool.close(IoConnection::new(ConnectionType::H2(io), created, None));
+        } else {
+            pool.release(IoConnection::new(ConnectionType::H2(io), created, None));
+        }
+    }
+}
+
+pub(crate) fn handshake<Io>(
     io: Io,
     config: &ConnectorConfig,
 ) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
+where
+    Io: AsyncRead + AsyncWrite + Unpin + 'static,
 {
     let mut builder = Builder::new();
     builder

actix-http/src/client/mod.rs

@@ -1,5 +1,4 @@
-//! HTTP client.
-
+//! Http client api
 use http::Uri;
 
 mod config;
@@ -10,14 +9,10 @@ mod h1proto;
 mod h2proto;
 mod pool;
 
-pub use actix_tls::connect::{
-    Connect as TcpConnect, ConnectError as TcpConnectError, Connection as TcpConnection,
-};
-
-pub use self::connection::{Connection, ConnectionIo};
-pub use self::connector::{Connector, ConnectorService};
+pub use self::connection::Connection;
+pub use self::connector::Connector;
 pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
-pub use crate::Protocol;
+pub use self::pool::Protocol;
 
 #[derive(Clone)]
 pub struct Connect {

actix-http/src/cloneable.rs

@@ -0,0 +1,40 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+
+use actix_service::Service;
+
+#[doc(hidden)]
+/// Service that allows to turn non-clone service to a service with `Clone` impl
+///
+/// # Panics
+/// CloneableService might panic with some creative use of thread local storage.
+/// See https://github.com/actix/actix-web/issues/1295 for example
+pub(crate) struct CloneableService<T: Service>(Rc<RefCell<T>>);
+
+impl<T: Service> CloneableService<T> {
+    pub(crate) fn new(service: T) -> Self {
+        Self(Rc::new(RefCell::new(service)))
+    }
+}
+
+impl<T: Service> Clone for CloneableService<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T: Service> Service for CloneableService<T> {
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.0.borrow_mut().poll_ready(cx)
+    }
+
+    fn call(&mut self, req: T::Request) -> Self::Future {
+        self.0.borrow_mut().call(req)
+    }
+}

actix-http/src/config.rs

@@ -1,19 +1,16 @@
-use std::{
-    cell::Cell,
-    fmt::{self, Write},
-    net,
-    rc::Rc,
-    time::{Duration, SystemTime},
-};
+use std::cell::Cell;
+use std::fmt::Write;
+use std::rc::Rc;
+use std::time::Duration;
+use std::{fmt, net};
 
-use actix_rt::{
-    task::JoinHandle,
-    time::{interval, sleep_until, Instant, Sleep},
-};
+use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
+use futures_util::{future, FutureExt};
+use time::OffsetDateTime;
 
-/// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-pub(crate) const DATE_VALUE_LENGTH: usize = 29;
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+const DATE_VALUE_LENGTH: usize = 29;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 /// Server keep-alive setting
@@ -52,7 +49,7 @@ struct Inner {
     ka_enabled: bool,
     secure: bool,
     local_addr: Option<std::net::SocketAddr>,
-    date_service: DateService,
+    timer: DateService,
 }
 
 impl Clone for ServiceConfig {
@@ -94,42 +91,42 @@ impl ServiceConfig {
             client_disconnect,
             secure,
             local_addr,
-            date_service: DateService::new(),
+            timer: DateService::new(),
         }))
     }
 
-    /// Returns true if connection is secure (HTTPS)
     #[inline]
+    /// Returns true if connection is secure(https)
     pub fn secure(&self) -> bool {
         self.0.secure
     }
 
-    /// Returns the local address that this server is bound to.
-    ///
-    /// Returns `None` for connections via UDS (Unix Domain Socket).
     #[inline]
+    /// Returns the local address that this server is bound to.
     pub fn local_addr(&self) -> Option<net::SocketAddr> {
         self.0.local_addr
     }
 
-    /// Keep alive duration if configured.
     #[inline]
+    /// Keep alive duration if configured.
     pub fn keep_alive(&self) -> Option<Duration> {
         self.0.keep_alive
     }
 
-    /// Return state of connection keep-alive functionality
     #[inline]
+    /// Return state of connection keep-alive functionality
     pub fn keep_alive_enabled(&self) -> bool {
         self.0.ka_enabled
     }
 
-    /// Client timeout for first request.
     #[inline]
-    pub fn client_timer(&self) -> Option<Sleep> {
+    /// Client timeout for first request.
+    pub fn client_timer(&self) -> Option<Delay> {
         let delay_time = self.0.client_timeout;
         if delay_time != 0 {
-            Some(sleep_until(self.now() + Duration::from_millis(delay_time)))
+            Some(delay_until(
+                self.0.timer.now() + Duration::from_millis(delay_time),
+            ))
         } else {
             None
         }
@@ -139,7 +136,7 @@ impl ServiceConfig {
     pub fn client_timer_expire(&self) -> Option<Instant> {
         let delay = self.0.client_timeout;
         if delay != 0 {
-            Some(self.now() + Duration::from_millis(delay))
+            Some(self.0.timer.now() + Duration::from_millis(delay))
         } else {
             None
         }
@@ -149,26 +146,34 @@ impl ServiceConfig {
     pub fn client_disconnect_timer(&self) -> Option<Instant> {
         let delay = self.0.client_disconnect;
         if delay != 0 {
-            Some(self.now() + Duration::from_millis(delay))
+            Some(self.0.timer.now() + Duration::from_millis(delay))
         } else {
             None
         }
     }
 
-    /// Return keep-alive timer delay is configured.
     #[inline]
-    pub fn keep_alive_timer(&self) -> Option<Sleep> {
-        self.keep_alive().map(|ka| sleep_until(self.now() + ka))
+    /// Return keep-alive timer delay is configured.
+    pub fn keep_alive_timer(&self) -> Option<Delay> {
+        if let Some(ka) = self.0.keep_alive {
+            Some(delay_until(self.0.timer.now() + ka))
+        } else {
+            None
+        }
     }
 
     /// Keep-alive expire time
     pub fn keep_alive_expire(&self) -> Option<Instant> {
-        self.keep_alive().map(|ka| self.now() + ka)
+        if let Some(ka) = self.0.keep_alive {
+            Some(self.0.timer.now() + ka)
+        } else {
+            None
+        }
     }
 
     #[inline]
     pub(crate) fn now(&self) -> Instant {
-        self.0.date_service.now()
+        self.0.timer.now()
     }
 
     #[doc(hidden)]
@@ -176,7 +181,7 @@ impl ServiceConfig {
         let mut buf: [u8; 39] = [0; 39];
         buf[..6].copy_from_slice(b"date: ");
         self.0
-            .date_service
+            .timer
             .set_date(|date| buf[6..35].copy_from_slice(&date.bytes));
         buf[35..].copy_from_slice(b"\r\n\r\n");
         dst.extend_from_slice(&buf);
@@ -184,7 +189,7 @@ impl ServiceConfig {
 
     pub(crate) fn set_date_header(&self, dst: &mut BytesMut) {
         self.0
-            .date_service
+            .timer
             .set_date(|date| dst.extend_from_slice(&date.bytes));
     }
 }
@@ -207,7 +212,12 @@ impl Date {
 
     fn update(&mut self) {
         self.pos = 0;
-        write!(self, "{}", httpdate::fmt_http_date(SystemTime::now())).unwrap();
+        write!(
+            self,
+            "{}",
+            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
+        )
+        .unwrap();
     }
 }
 
@@ -220,102 +230,57 @@ impl fmt::Write for Date {
     }
 }
 
-/// Service for update Date and Instant periodically at 500 millis interval.
-struct DateService {
-    current: Rc<Cell<(Date, Instant)>>,
-    handle: JoinHandle<()>,
+#[derive(Clone)]
+struct DateService(Rc<DateServiceInner>);
+
+struct DateServiceInner {
+    current: Cell<Option<(Date, Instant)>>,
 }
 
-impl Drop for DateService {
-    fn drop(&mut self) {
-        // stop the timer update async task on drop.
-        self.handle.abort();
+impl DateServiceInner {
+    fn new() -> Self {
+        DateServiceInner {
+            current: Cell::new(None),
+        }
+    }
+
+    fn reset(&self) {
+        self.current.take();
+    }
+
+    fn update(&self) {
+        let now = Instant::now();
+        let date = Date::new();
+        self.current.set(Some((date, now)));
     }
 }
 
 impl DateService {
     fn new() -> Self {
-        // shared date and timer for DateService and update async task.
-        let current = Rc::new(Cell::new((Date::new(), Instant::now())));
-        let current_clone = Rc::clone(&current);
-        // spawn an async task sleep for 500 milli and update current date/timer in a loop.
-        // handle is used to stop the task on DateService drop.
-        let handle = actix_rt::spawn(async move {
-            #[cfg(test)]
-            let _notify = notify_on_drop::NotifyOnDrop::new();
+        DateService(Rc::new(DateServiceInner::new()))
+    }
 
-            let mut interval = interval(Duration::from_millis(500));
-            loop {
-                let now = interval.tick().await;
-                let date = Date::new();
-                current_clone.set((date, now));
-            }
-        });
+    fn check_date(&self) {
+        if self.0.current.get().is_none() {
+            self.0.update();
 
-        DateService { current, handle }
+            // periodic date update
+            let s = self.clone();
+            actix_rt::spawn(delay_for(Duration::from_millis(500)).then(move |_| {
+                s.0.reset();
+                future::ready(())
+            }));
+        }
     }
 
     fn now(&self) -> Instant {
-        self.current.get().1
+        self.check_date();
+        self.0.current.get().unwrap().1
     }
 
     fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
-        f(&self.current.get().0);
-    }
-}
-
-// TODO: move to a util module for testing all spawn handle drop style tasks.
-/// Test Module for checking the drop state of certain async tasks that are spawned
-/// with `actix_rt::spawn`
-///
-/// The target task must explicitly generate `NotifyOnDrop` when spawn the task
-#[cfg(test)]
-mod notify_on_drop {
-    use std::cell::RefCell;
-
-    thread_local! {
-        static NOTIFY_DROPPED: RefCell<Option<bool>> = RefCell::new(None);
-    }
-
-    /// Check if the spawned task is dropped.
-    ///
-    /// # Panics
-    /// Panics when there was no `NotifyOnDrop` instance on current thread.
-    pub(crate) fn is_dropped() -> bool {
-        NOTIFY_DROPPED.with(|bool| {
-            bool.borrow()
-                .expect("No NotifyOnDrop existed on current thread")
-        })
-    }
-
-    pub(crate) struct NotifyOnDrop;
-
-    impl NotifyOnDrop {
-        /// # Panic:
-        ///
-        /// When construct multiple instances on any given thread.
-        pub(crate) fn new() -> Self {
-            NOTIFY_DROPPED.with(|bool| {
-                let mut bool = bool.borrow_mut();
-                if bool.is_some() {
-                    panic!("NotifyOnDrop existed on current thread");
-                } else {
-                    *bool = Some(false);
-                }
-            });
-
-            NotifyOnDrop
-        }
-    }
-
-    impl Drop for NotifyOnDrop {
-        fn drop(&mut self) {
-            NOTIFY_DROPPED.with(|bool| {
-                if let Some(b) = bool.borrow_mut().as_mut() {
-                    *b = true;
-                }
-            });
-        }
+        self.check_date();
+        f(&self.0.current.get().unwrap().0);
     }
 }
 
@@ -323,67 +288,14 @@ mod notify_on_drop {
 mod tests {
     use super::*;
 
-    use actix_rt::{task::yield_now, time::sleep};
-
-    #[actix_rt::test]
-    async fn test_date_service_update() {
-        let settings = ServiceConfig::new(KeepAlive::Os, 0, 0, false, None);
-
-        yield_now().await;
-
-        let mut buf1 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-        settings.set_date(&mut buf1);
-        let now1 = settings.now();
-
-        sleep_until(Instant::now() + Duration::from_secs(2)).await;
-        yield_now().await;
-
-        let now2 = settings.now();
-        let mut buf2 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-        settings.set_date(&mut buf2);
-
-        assert_ne!(now1, now2);
-
-        assert_ne!(buf1, buf2);
-
-        drop(settings);
-
-        // Ensure the task will drop eventually
-        let mut times = 0;
-        while !notify_on_drop::is_dropped() {
-            sleep(Duration::from_millis(100)).await;
-            times += 1;
-            assert!(times < 10, "Timeout waiting for task drop");
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_date_service_drop() {
-        let service = Rc::new(DateService::new());
-
-        // yield so date service have a chance to register the spawned timer update task.
-        yield_now().await;
-
-        let clone1 = service.clone();
-        let clone2 = service.clone();
-        let clone3 = service.clone();
-
-        drop(clone1);
-        assert!(!notify_on_drop::is_dropped());
-        drop(clone2);
-        assert!(!notify_on_drop::is_dropped());
-        drop(clone3);
-        assert!(!notify_on_drop::is_dropped());
-
-        drop(service);
-
-        // Ensure the task will drop eventually
-        let mut times = 0;
-        while !notify_on_drop::is_dropped() {
-            sleep(Duration::from_millis(100)).await;
-            times += 1;
-            assert!(times < 10, "Timeout waiting for task drop");
-        }
+    // Test modifying the date from within the closure
+    // passed to `set_date`
+    #[test]
+    fn test_evil_date() {
+        let service = DateService::new();
+        // Make sure that `check_date` doesn't try to spawn a task
+        service.0.update();
+        service.set_date(|_| service.0.reset());
     }
 
     #[test]

actix-http/src/encoding/decoder.rs

@@ -1,38 +1,25 @@
-//! Stream decoders.
+use std::future::Future;
+use std::io::{self, Write};
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use std::{
-    future::Future,
-    io::{self, Write as _},
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use actix_rt::task::{spawn_blocking, JoinHandle};
+use actix_threadpool::{run, CpuFuture};
+use brotli2::write::BrotliDecoder;
 use bytes::Bytes;
+use flate2::write::{GzDecoder, ZlibDecoder};
 use futures_core::{ready, Stream};
 
-#[cfg(feature = "compress-brotli")]
-use brotli2::write::BrotliDecoder;
+use super::Writer;
+use crate::error::PayloadError;
+use crate::http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING};
 
-#[cfg(feature = "compress-gzip")]
-use flate2::write::{GzDecoder, ZlibDecoder};
-
-#[cfg(feature = "compress-zstd")]
-use zstd::stream::write::Decoder as ZstdDecoder;
-
-use crate::{
-    encoding::Writer,
-    error::{BlockingError, PayloadError},
-    http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING},
-};
-
-const MAX_CHUNK_SIZE_DECODE_IN_PLACE: usize = 2049;
+const INPLACE: usize = 2049;
 
 pub struct Decoder<S> {
     decoder: Option<ContentDecoder>,
     stream: S,
     eof: bool,
-    fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
+    fut: Option<CpuFuture<(Option<Bytes>, ContentDecoder), io::Error>>,
 }
 
 impl<S> Decoder<S>
@@ -43,28 +30,17 @@ where
     #[inline]
     pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
         let decoder = match encoding {
-            #[cfg(feature = "compress-brotli")]
             ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
                 BrotliDecoder::new(Writer::new()),
             ))),
-            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
                 ZlibDecoder::new(Writer::new()),
             ))),
-            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
                 GzDecoder::new(Writer::new()),
             ))),
-            #[cfg(feature = "compress-zstd")]
-            ContentEncoding::Zstd => Some(ContentDecoder::Zstd(Box::new(
-                ZstdDecoder::new(Writer::new()).expect(
-                    "Failed to create zstd decoder. This is a bug. \
-                         Please report it to the actix-web repository.",
-                ),
-            ))),
             _ => None,
         };
-
         Decoder {
             decoder,
             stream,
@@ -77,11 +53,15 @@ where
     #[inline]
     pub fn from_headers(stream: S, headers: &HeaderMap) -> Decoder<S> {
         // check content-encoding
-        let encoding = headers
-            .get(&CONTENT_ENCODING)
-            .and_then(|val| val.to_str().ok())
-            .and_then(|x| x.parse().ok())
-            .unwrap_or(ContentEncoding::Identity);
+        let encoding = if let Some(enc) = headers.get(&CONTENT_ENCODING) {
+            if let Ok(enc) = enc.to_str() {
+                ContentEncoding::from(enc)
+            } else {
+                ContentEncoding::Identity
+            }
+        } else {
+            ContentEncoding::Identity
+        };
 
         Self::new(stream, encoding)
     }
@@ -99,12 +79,12 @@ where
     ) -> Poll<Option<Self::Item>> {
         loop {
             if let Some(ref mut fut) = self.fut {
-                let (chunk, decoder) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-
+                let (chunk, decoder) = match ready!(Pin::new(fut).poll(cx)) {
+                    Ok(item) => item,
+                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                };
                 self.decoder = Some(decoder);
                 self.fut.take();
-
                 if let Some(chunk) = chunk {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
@@ -114,34 +94,29 @@ where
                 return Poll::Ready(None);
             }
 
-            match ready!(Pin::new(&mut self.stream).poll_next(cx)) {
-                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
-
-                Some(Ok(chunk)) => {
+            match Pin::new(&mut self.stream).poll_next(cx) {
+                Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
+                Poll::Ready(Some(Ok(chunk))) => {
                     if let Some(mut decoder) = self.decoder.take() {
-                        if chunk.len() < MAX_CHUNK_SIZE_DECODE_IN_PLACE {
+                        if chunk.len() < INPLACE {
                             let chunk = decoder.feed_data(chunk)?;
                             self.decoder = Some(decoder);
-
                             if let Some(chunk) = chunk {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
                         } else {
-                            self.fut = Some(spawn_blocking(move || {
+                            self.fut = Some(run(move || {
                                 let chunk = decoder.feed_data(chunk)?;
                                 Ok((chunk, decoder))
                             }));
                         }
-
                         continue;
                     } else {
                         return Poll::Ready(Some(Ok(chunk)));
                     }
                 }
-
-                None => {
+                Poll::Ready(None) => {
                     self.eof = true;
-
                     return if let Some(mut decoder) = self.decoder.take() {
                         match decoder.feed_eof() {
                             Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
@@ -152,32 +127,25 @@ where
                         Poll::Ready(None)
                     };
                 }
+                Poll::Pending => break,
             }
         }
+        Poll::Pending
     }
 }
 
 enum ContentDecoder {
-    #[cfg(feature = "compress-gzip")]
     Deflate(Box<ZlibDecoder<Writer>>),
-    #[cfg(feature = "compress-gzip")]
     Gzip(Box<GzDecoder<Writer>>),
-    #[cfg(feature = "compress-brotli")]
     Br(Box<BrotliDecoder<Writer>>),
-    // We need explicit 'static lifetime here because ZstdDecoder need lifetime
-    // argument, and we use `spawn_blocking` in `Decoder::poll_next` that require `FnOnce() -> R + Send + 'static`
-    #[cfg(feature = "compress-zstd")]
-    Zstd(Box<ZstdDecoder<'static, Writer>>),
 }
 
 impl ContentDecoder {
     fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
         match self {
-            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.flush() {
                 Ok(()) => {
                     let b = decoder.get_mut().take();
-
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -186,12 +154,9 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
-
-            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
-
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -200,8 +165,6 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
-
-            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -213,30 +176,15 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
-
-            #[cfg(feature = "compress-zstd")]
-            ContentDecoder::Zstd(ref mut decoder) => match decoder.flush() {
-                Ok(_) => {
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
         }
     }
 
     fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
         match self {
-            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
                     let b = decoder.get_mut().take();
-
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -245,13 +193,10 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
-
-            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
                     let b = decoder.get_mut().take();
-
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -260,27 +205,9 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
-
-            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
-
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-
-            #[cfg(feature = "compress-zstd")]
-            ContentDecoder::Zstd(ref mut decoder) => match decoder.write_all(&data) {
-                Ok(_) => {
-                    decoder.flush()?;
-
                     let b = decoder.get_mut().take();
                     if !b.is_empty() {
                         Ok(Some(b))

actix-http/src/encoding/encoder.rs

@@ -1,41 +1,24 @@
-//! Stream encoders.
+//! Stream encoder
+use std::future::Future;
+use std::io::{self, Write};
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
-use std::{
-    error::Error as StdError,
-    future::Future,
-    io::{self, Write as _},
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use actix_rt::task::{spawn_blocking, JoinHandle};
+use actix_threadpool::{run, CpuFuture};
+use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
-use derive_more::Display;
+use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
 use pin_project::pin_project;
 
-#[cfg(feature = "compress-brotli")]
-use brotli2::write::BrotliEncoder;
-
-#[cfg(feature = "compress-gzip")]
-use flate2::write::{GzEncoder, ZlibEncoder};
-
-#[cfg(feature = "compress-zstd")]
-use zstd::stream::write::Encoder as ZstdEncoder;
-
-use crate::{
-    body::{Body, BodySize, BoxAnyBody, MessageBody, ResponseBody},
-    http::{
-        header::{ContentEncoding, CONTENT_ENCODING},
-        HeaderValue, StatusCode,
-    },
-    ResponseHead,
-};
+use crate::body::{Body, BodySize, MessageBody, ResponseBody};
+use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
+use crate::http::{HeaderValue, StatusCode};
+use crate::{Error, ResponseHead};
 
 use super::Writer;
-use crate::error::BlockingError;
 
-const MAX_CHUNK_SIZE_ENCODE_IN_PLACE: usize = 1024;
+const INPLACE: usize = 1024;
 
 #[pin_project]
 pub struct Encoder<B> {
@@ -43,7 +26,7 @@ pub struct Encoder<B> {
     #[pin]
     body: EncoderBody<B>,
     encoder: Option<ContentEncoder>,
-    fut: Option<JoinHandle<Result<ContentEncoder, io::Error>>>,
+    fut: Option<CpuFuture<ContentEncoder, io::Error>>,
 }
 
 impl<B: MessageBody> Encoder<B> {
@@ -87,7 +70,6 @@ impl<B: MessageBody> Encoder<B> {
                 });
             }
         }
-
         ResponseBody::Body(Encoder {
             body,
             eof: false,
@@ -101,15 +83,10 @@ impl<B: MessageBody> Encoder<B> {
 enum EncoderBody<B> {
     Bytes(Bytes),
     Stream(#[pin] B),
-    BoxedStream(BoxAnyBody),
+    BoxedStream(Box<dyn MessageBody + Unpin>),
 }
 
-impl<B> MessageBody for EncoderBody<B>
-where
-    B: MessageBody,
-{
-    type Error = EncoderError<B::Error>;
-
+impl<B: MessageBody> MessageBody for EncoderBody<B> {
     fn size(&self) -> BodySize {
         match self {
             EncoderBody::Bytes(ref b) => b.size(),
@@ -121,7 +98,7 @@ where
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         match self.project() {
             EncoderBodyProj::Bytes(b) => {
                 if b.is_empty() {
@@ -130,20 +107,15 @@ where
                     Poll::Ready(Some(Ok(std::mem::take(b))))
                 }
             }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx).map_err(EncoderError::Body),
+            EncoderBodyProj::Stream(b) => b.poll_next(cx),
             EncoderBodyProj::BoxedStream(ref mut b) => {
-                b.as_pin_mut().poll_next(cx).map_err(EncoderError::Boxed)
+                Pin::new(b.as_mut()).poll_next(cx)
             }
         }
     }
 }
 
-impl<B> MessageBody for Encoder<B>
-where
-    B: MessageBody,
-{
-    type Error = EncoderError<B::Error>;
-
+impl<B: MessageBody> MessageBody for Encoder<B> {
     fn size(&self) -> BodySize {
         if self.encoder.is_none() {
             self.body.size()
@@ -155,7 +127,7 @@ where
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         let mut this = self.project();
         loop {
             if *this.eof {
@@ -163,36 +135,32 @@ where
             }
 
             if let Some(ref mut fut) = this.fut {
-                let mut encoder = ready!(Pin::new(fut).poll(cx))
-                    .map_err(|_| EncoderError::Blocking(BlockingError))?
-                    .map_err(EncoderError::Io)?;
-
+                let mut encoder = match ready!(Pin::new(fut).poll(cx)) {
+                    Ok(item) => item,
+                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                };
                 let chunk = encoder.take();
                 *this.encoder = Some(encoder);
                 this.fut.take();
-
                 if !chunk.is_empty() {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
             }
 
-            let result = ready!(this.body.as_mut().poll_next(cx));
+            let result = this.body.as_mut().poll_next(cx);
 
             match result {
-                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
-
-                Some(Ok(chunk)) => {
+                Poll::Ready(Some(Ok(chunk))) => {
                     if let Some(mut encoder) = this.encoder.take() {
-                        if chunk.len() < MAX_CHUNK_SIZE_ENCODE_IN_PLACE {
-                            encoder.write(&chunk).map_err(EncoderError::Io)?;
+                        if chunk.len() < INPLACE {
+                            encoder.write(&chunk)?;
                             let chunk = encoder.take();
                             *this.encoder = Some(encoder);
-
                             if !chunk.is_empty() {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
                         } else {
-                            *this.fut = Some(spawn_blocking(move || {
+                            *this.fut = Some(run(move || {
                                 encoder.write(&chunk)?;
                                 Ok(encoder)
                             }));
@@ -201,10 +169,9 @@ where
                         return Poll::Ready(Some(Ok(chunk)));
                     }
                 }
-
-                None => {
+                Poll::Ready(None) => {
                     if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish().map_err(EncoderError::Io)?;
+                        let chunk = encoder.finish()?;
                         if chunk.is_empty() {
                             return Poll::Ready(None);
                         } else {
@@ -215,6 +182,7 @@ where
                         return Poll::Ready(None);
                     }
                 }
+                val => return val,
             }
         }
     }
@@ -228,40 +196,25 @@ fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
 }
 
 enum ContentEncoder {
-    #[cfg(feature = "compress-gzip")]
     Deflate(ZlibEncoder<Writer>),
-    #[cfg(feature = "compress-gzip")]
     Gzip(GzEncoder<Writer>),
-    #[cfg(feature = "compress-brotli")]
     Br(BrotliEncoder<Writer>),
-    // We need explicit 'static lifetime here because ZstdEncoder need lifetime
-    // argument, and we use `spawn_blocking` in `Encoder::poll_next` that require `FnOnce() -> R + Send + 'static`
-    #[cfg(feature = "compress-zstd")]
-    Zstd(ZstdEncoder<'static, Writer>),
 }
 
 impl ContentEncoder {
     fn encoder(encoding: ContentEncoding) -> Option<Self> {
         match encoding {
-            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentEncoder::Deflate(ZlibEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
-            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Gzip => Some(ContentEncoder::Gzip(GzEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
-            #[cfg(feature = "compress-brotli")]
             ContentEncoding::Br => {
                 Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
             }
-            #[cfg(feature = "compress-zstd")]
-            ContentEncoding::Zstd => {
-                let encoder = ZstdEncoder::new(Writer::new(), 3).ok()?;
-                Some(ContentEncoder::Zstd(encoder))
-            }
             _ => None,
         }
     }
@@ -269,45 +222,31 @@ impl ContentEncoder {
     #[inline]
     pub(crate) fn take(&mut self) -> Bytes {
         match *self {
-            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
-            #[cfg(feature = "compress-zstd")]
-            ContentEncoder::Zstd(ref mut encoder) => encoder.get_mut().take(),
         }
     }
 
     fn finish(self) -> Result<Bytes, io::Error> {
         match self {
-            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
-            #[cfg(feature = "compress-zstd")]
-            ContentEncoder::Zstd(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
         }
     }
 
     fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
         match *self {
-            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -315,7 +254,6 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -323,7 +261,6 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
-            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -331,47 +268,6 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
-            #[cfg(feature = "compress-zstd")]
-            ContentEncoder::Zstd(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding ztsd encoding: {}", err);
-                    Err(err)
-                }
-            },
         }
     }
 }
-
-#[derive(Debug, Display)]
-#[non_exhaustive]
-pub enum EncoderError<E> {
-    #[display(fmt = "body")]
-    Body(E),
-
-    #[display(fmt = "boxed")]
-    Boxed(Box<dyn StdError>),
-
-    #[display(fmt = "blocking")]
-    Blocking(BlockingError),
-
-    #[display(fmt = "io")]
-    Io(io::Error),
-}
-
-impl<E: StdError + 'static> StdError for EncoderError<E> {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match self {
-            EncoderError::Body(err) => Some(err),
-            EncoderError::Boxed(err) => Some(&**err),
-            EncoderError::Blocking(err) => Some(err),
-            EncoderError::Io(err) => Some(err),
-        }
-    }
-}
-
-impl<E: StdError + 'static> From<EncoderError<E>> for crate::Error {
-    fn from(err: EncoderError<E>) -> Self {
-        crate::Error::new_encoder().with_cause(err)
-    }
-}

actix-http/src/encoding/mod.rs

@@ -1,5 +1,4 @@
-//! Content-Encoding support.
-
+//! Content-Encoding support
 use std::io;
 
 use bytes::{Bytes, BytesMut};

actix-http/src/extensions.rs

@@ -1,119 +1,62 @@
-use std::{
-    any::{Any, TypeId},
-    fmt, mem,
-};
+use std::any::{Any, TypeId};
+use std::{fmt, mem};
 
-use ahash::AHashMap;
+use fxhash::FxHashMap;
 
-/// A type map for request extensions.
-///
-/// All entries into this map must be owned types (or static references).
 #[derive(Default)]
+/// A type map of request extensions.
 pub struct Extensions {
     /// Use FxHasher with a std HashMap with for faster
     /// lookups on the small `TypeId` (u64 equivalent) keys.
-    map: AHashMap<TypeId, Box<dyn Any>>,
+    map: FxHashMap<TypeId, Box<dyn Any>>,
 }
 
 impl Extensions {
-    /// Creates an empty `Extensions`.
+    /// Create an empty `Extensions`.
     #[inline]
     pub fn new() -> Extensions {
         Extensions {
-            map: AHashMap::default(),
+            map: FxHashMap::default(),
         }
     }
 
-    /// Insert an item into the map.
+    /// Insert a type into this `Extensions`.
     ///
-    /// If an item of this type was already stored, it will be replaced and returned.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// assert_eq!(map.insert(""), None);
-    /// assert_eq!(map.insert(1u32), None);
-    /// assert_eq!(map.insert(2u32), Some(1u32));
-    /// assert_eq!(*map.get::<u32>().unwrap(), 2u32);
-    /// ```
-    pub fn insert<T: 'static>(&mut self, val: T) -> Option<T> {
-        self.map
-            .insert(TypeId::of::<T>(), Box::new(val))
-            .and_then(downcast_owned)
+    /// If a extension of this type already existed, it will
+    /// be returned.
+    pub fn insert<T: 'static>(&mut self, val: T) {
+        self.map.insert(TypeId::of::<T>(), Box::new(val));
     }
 
-    /// Check if map contains an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// assert!(!map.contains::<u32>());
-    ///
-    /// assert_eq!(map.insert(1u32), None);
-    /// assert!(map.contains::<u32>());
-    /// ```
+    /// Check if container contains entry
     pub fn contains<T: 'static>(&self) -> bool {
         self.map.contains_key(&TypeId::of::<T>())
     }
 
-    /// Get a reference to an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// map.insert(1u32);
-    /// assert_eq!(map.get::<u32>(), Some(&1u32));
-    /// ```
+    /// Get a reference to a type previously inserted on this `Extensions`.
     pub fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .get(&TypeId::of::<T>())
             .and_then(|boxed| boxed.downcast_ref())
     }
 
-    /// Get a mutable reference to an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// map.insert(1u32);
-    /// assert_eq!(map.get_mut::<u32>(), Some(&mut 1u32));
-    /// ```
+    /// Get a mutable reference to a type previously inserted on this `Extensions`.
     pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
         self.map
             .get_mut(&TypeId::of::<T>())
             .and_then(|boxed| boxed.downcast_mut())
     }
 
-    /// Remove an item from the map of a given type.
+    /// Remove a type from this `Extensions`.
     ///
-    /// If an item of this type was already stored, it will be returned.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    ///
-    /// map.insert(1u32);
-    /// assert_eq!(map.get::<u32>(), Some(&1u32));
-    ///
-    /// assert_eq!(map.remove::<u32>(), Some(1u32));
-    /// assert!(!map.contains::<u32>());
-    /// ```
+    /// If a extension of this type existed, it will be returned.
     pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(downcast_owned)
+        self.map
+            .remove(&TypeId::of::<T>())
+            .and_then(|boxed| boxed.downcast().ok().map(|boxed| *boxed))
     }
 
     /// Clear the `Extensions` of all inserted extensions.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    ///
-    /// map.insert(1u32);
-    /// assert!(map.contains::<u32>());
-    ///
-    /// map.clear();
-    /// assert!(!map.contains::<u32>());
-    /// ```
     #[inline]
     pub fn clear(&mut self) {
         self.map.clear();
@@ -136,10 +79,6 @@ impl fmt::Debug for Extensions {
     }
 }
 
-fn downcast_owned<T: 'static>(boxed: Box<dyn Any>) -> Option<T> {
-    boxed.downcast().ok().map(|boxed| *boxed)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

actix-http/src/h1/chunked.rs

@@ -1,432 +0,0 @@
-use std::{io, task::Poll};
-
-use bytes::{Buf as _, Bytes, BytesMut};
-
-macro_rules! byte (
-    ($rdr:ident) => ({
-        if $rdr.len() > 0 {
-            let b = $rdr[0];
-            $rdr.advance(1);
-            b
-        } else {
-            return Poll::Pending
-        }
-    })
-);
-
-#[derive(Debug, PartialEq, Clone)]
-pub(super) enum ChunkedState {
-    Size,
-    SizeLws,
-    Extension,
-    SizeLf,
-    Body,
-    BodyCr,
-    BodyLf,
-    EndCr,
-    EndLf,
-    End,
-}
-
-impl ChunkedState {
-    pub(super) fn step(
-        &self,
-        body: &mut BytesMut,
-        size: &mut u64,
-        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        use self::ChunkedState::*;
-        match *self {
-            Size => ChunkedState::read_size(body, size),
-            SizeLws => ChunkedState::read_size_lws(body),
-            Extension => ChunkedState::read_extension(body),
-            SizeLf => ChunkedState::read_size_lf(body, *size),
-            Body => ChunkedState::read_body(body, size, buf),
-            BodyCr => ChunkedState::read_body_cr(body),
-            BodyLf => ChunkedState::read_body_lf(body),
-            EndCr => ChunkedState::read_end_cr(body),
-            EndLf => ChunkedState::read_end_lf(body),
-            End => Poll::Ready(Ok(ChunkedState::End)),
-        }
-    }
-
-    fn read_size(
-        rdr: &mut BytesMut,
-        size: &mut u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        let radix = 16;
-
-        let rem = match byte!(rdr) {
-            b @ b'0'..=b'9' => b - b'0',
-            b @ b'a'..=b'f' => b + 10 - b'a',
-            b @ b'A'..=b'F' => b + 10 - b'A',
-            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => {
-                return Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "Invalid chunk size line: Invalid Size",
-                )));
-            }
-        };
-
-        match size.checked_mul(radix) {
-            Some(n) => {
-                *size = n as u64;
-                *size += rem as u64;
-
-                Poll::Ready(Ok(ChunkedState::Size))
-            }
-            None => {
-                log::debug!("chunk size would overflow u64");
-                Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "Invalid chunk size line: Size is too big",
-                )))
-            }
-        }
-    }
-
-    fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            // LWS can follow the chunk size, but no more digits can come
-            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk size linear white space",
-            ))),
-        }
-    }
-    fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            // strictly 0x20 (space) should be disallowed but we don't parse quoted strings here
-            0x00..=0x08 | 0x0a..=0x1f | 0x7f => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid character in chunk extension",
-            ))),
-            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
-        }
-    }
-    fn read_size_lf(
-        rdr: &mut BytesMut,
-        size: u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' if size > 0 => Poll::Ready(Ok(ChunkedState::Body)),
-            b'\n' if size == 0 => Poll::Ready(Ok(ChunkedState::EndCr)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk size LF",
-            ))),
-        }
-    }
-
-    fn read_body(
-        rdr: &mut BytesMut,
-        rem: &mut u64,
-        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
-        log::trace!("Chunked read, remaining={:?}", rem);
-
-        let len = rdr.len() as u64;
-        if len == 0 {
-            Poll::Ready(Ok(ChunkedState::Body))
-        } else {
-            let slice;
-            if *rem > len {
-                slice = rdr.split().freeze();
-                *rem -= len;
-            } else {
-                slice = rdr.split_to(*rem as usize).freeze();
-                *rem = 0;
-            }
-            *buf = Some(slice);
-            if *rem > 0 {
-                Poll::Ready(Ok(ChunkedState::Body))
-            } else {
-                Poll::Ready(Ok(ChunkedState::BodyCr))
-            }
-        }
-    }
-
-    fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk body CR",
-            ))),
-        }
-    }
-    fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk body LF",
-            ))),
-        }
-    }
-    fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk end CR",
-            ))),
-        }
-    }
-    fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
-        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
-            _ => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Invalid chunk end LF",
-            ))),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use actix_codec::Decoder as _;
-    use bytes::{Bytes, BytesMut};
-    use http::Method;
-
-    use crate::{
-        error::ParseError,
-        h1::decoder::{MessageDecoder, PayloadItem},
-        HttpMessage as _, Request,
-    };
-
-    macro_rules! parse_ready {
-        ($e:expr) => {{
-            match MessageDecoder::<Request>::default().decode($e) {
-                Ok(Some((msg, _))) => msg,
-                Ok(_) => unreachable!("Eof during parsing http request"),
-                Err(err) => unreachable!("Error during parsing http request: {:?}", err),
-            }
-        }};
-    }
-
-    macro_rules! expect_parse_err {
-        ($e:expr) => {{
-            match MessageDecoder::<Request>::default().decode($e) {
-                Err(err) => match err {
-                    ParseError::Io(_) => unreachable!("Parse error expected"),
-                    _ => {}
-                },
-                _ => unreachable!("Error expected"),
-            }
-        }};
-    }
-
-    #[test]
-    fn test_parse_chunked_payload_chunk_extension() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-            transfer-encoding: chunked\r\n\
-            \r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(msg.chunked().unwrap());
-
-        buf.extend(b"4;test\r\ndata\r\n4\r\nline\r\n0\r\n\r\n"); // test: test\r\n\r\n")
-        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
-        assert_eq!(chunk, Bytes::from_static(b"data"));
-        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
-        assert_eq!(chunk, Bytes::from_static(b"line"));
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-    }
-
-    #[test]
-    fn test_request_chunked() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let req = parse_ready!(&mut buf);
-
-        if let Ok(val) = req.chunked() {
-            assert!(val);
-        } else {
-            unreachable!("Error");
-        }
-
-        // intentional typo in "chunked"
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chnked\r\n\r\n",
-        );
-        expect_parse_err!(&mut buf);
-    }
-
-    #[test]
-    fn test_http_request_chunked_payload() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n");
-        assert_eq!(
-            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
-            b"data"
-        );
-        assert_eq!(
-            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
-            b"line"
-        );
-        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
-    }
-
-    #[test]
-    fn test_http_request_chunked_payload_and_next_message() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(
-            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
-              POST /test2 HTTP/1.1\r\n\
-              transfer-encoding: chunked\r\n\r\n"
-                .iter(),
-        );
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"line");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-
-        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
-        assert!(req.chunked().unwrap());
-        assert_eq!(*req.method(), Method::POST);
-        assert!(req.chunked().unwrap());
-    }
-
-    #[test]
-    fn test_http_request_chunked_payload_chunks() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-        assert!(req.chunked().unwrap());
-
-        buf.extend(b"4\r\n1111\r\n");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"1111");
-
-        buf.extend(b"4\r\ndata\r");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-
-        buf.extend(b"\n4");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"\r");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-        buf.extend(b"\n");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"li");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"li");
-
-        //trailers
-        //buf.feed_data("test: test\r\n");
-        //not_ready!(reader.parse(&mut buf, &mut readbuf));
-
-        buf.extend(b"ne\r\n0\r\n");
-        let msg = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"ne");
-        assert!(pl.decode(&mut buf).unwrap().is_none());
-
-        buf.extend(b"\r\n");
-        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
-    }
-
-    #[test]
-    fn chunk_extension_quoted() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-            Host: localhost:8080\r\n\
-            Transfer-Encoding: chunked\r\n\
-            \r\n\
-            2;hello=b;one=\"1 2 3\"\r\n\
-            xx",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-
-        let chunk = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"xx")));
-    }
-
-    #[test]
-    fn hrs_chunk_extension_invalid() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: localhost:8080\r\n\
-            Transfer-Encoding: chunked\r\n\
-            \r\n\
-            2;x\nx\r\n\
-            4c\r\n\
-            0\r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-
-        let err = pl.decode(&mut buf).unwrap_err();
-        assert!(err
-            .to_string()
-            .contains("Invalid character in chunk extension"));
-    }
-
-    #[test]
-    fn hrs_chunk_size_overflow() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Transfer-Encoding: chunked\r\n\
-            \r\n\
-            f0000000000000003\r\n\
-            abc\r\n\
-            0\r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-
-        let err = pl.decode(&mut buf).unwrap_err();
-        assert!(err
-            .to_string()
-            .contains("Invalid chunk size line: Size is too big"));
-    }
-}

actix-http/src/h1/client.rs

@@ -223,3 +223,15 @@ impl Encoder<Message<(RequestHeadType, BodySize)>> for ClientCodec {
         Ok(())
     }
 }
+
+pub struct Writer<'a>(pub &'a mut BytesMut);
+
+impl<'a> io::Write for Writer<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

actix-http/src/h1/codec.rs

@@ -58,7 +58,6 @@ impl Codec {
         } else {
             Flags::empty()
         };
-
         Codec {
             config,
             flags,
@@ -70,26 +69,26 @@ impl Codec {
         }
     }
 
-    /// Check if request is upgrade.
     #[inline]
+    /// Check if request is upgrade
     pub fn upgrade(&self) -> bool {
         self.ctype == ConnectionType::Upgrade
     }
 
-    /// Check if last response is keep-alive.
     #[inline]
+    /// Check if last response is keep-alive
     pub fn keepalive(&self) -> bool {
         self.ctype == ConnectionType::KeepAlive
     }
 
-    /// Check if keep-alive enabled on server level.
     #[inline]
+    /// Check if keep-alive enabled on server level
     pub fn keepalive_enabled(&self) -> bool {
         self.flags.contains(Flags::KEEPALIVE_ENABLED)
     }
 
-    /// Check last request's message type.
     #[inline]
+    /// Check last request's message type
     pub fn message_type(&self) -> MessageType {
         if self.flags.contains(Flags::STREAM) {
             MessageType::Stream
@@ -111,8 +110,8 @@ impl Decoder for Codec {
     type Error = ParseError;
 
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        if let Some(ref mut payload) = self.payload {
-            Ok(match payload.decode(src)? {
+        if self.payload.is_some() {
+            Ok(match self.payload.as_mut().unwrap().decode(src)? {
                 Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
                 Some(PayloadItem::Eof) => {
                     self.payload.take();
@@ -199,10 +198,10 @@ mod tests {
     use http::Method;
 
     use super::*;
-    use crate::HttpMessage;
+    use crate::httpmessage::HttpMessage;
 
-    #[actix_rt::test]
-    async fn test_http_request_chunked_payload_and_next_message() {
+    #[test]
+    fn test_http_request_chunked_payload_and_next_message() {
         let mut codec = Codec::default();
 
         let mut buf = BytesMut::from(

actix-http/src/h1/decoder.rs

@@ -1,20 +1,20 @@
-use std::{convert::TryFrom, io, marker::PhantomData, mem::MaybeUninit, task::Poll};
+use std::convert::TryFrom;
+use std::io;
+use std::marker::PhantomData;
+use std::task::Poll;
 
 use actix_codec::Decoder;
-use bytes::{Bytes, BytesMut};
+use bytes::{Buf, Bytes, BytesMut};
 use http::header::{HeaderName, HeaderValue};
 use http::{header, Method, StatusCode, Uri, Version};
 use log::{debug, error, trace};
 
-use super::chunked::ChunkedState;
-use crate::{
-    error::ParseError,
-    header::HeaderMap,
-    message::{ConnectionType, ResponseHead},
-    request::Request,
-};
+use crate::error::ParseError;
+use crate::header::HeaderMap;
+use crate::message::{ConnectionType, ResponseHead};
+use crate::request::Request;
 
-pub(crate) const MAX_BUFFER_SIZE: usize = 131_072;
+const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;
 
 /// Incoming message decoder
@@ -92,7 +92,7 @@ pub(crate) trait MessageType: Sized {
                     }
 
                     header::CONTENT_LENGTH => match value.to_str() {
-                        Ok(s) if s.trim().starts_with('+') => {
+                        Ok(s) if s.trim().starts_with("+") => {
                             debug!("illegal Content-Length: {:?}", s);
                             return Err(ParseError::Header);
                         }
@@ -121,7 +121,7 @@ pub(crate) trait MessageType: Sized {
                     header::TRANSFER_ENCODING => {
                         seen_te = true;
 
-                        if let Ok(s) = value.to_str().map(str::trim) {
+                        if let Ok(s) = value.to_str().map(|s| s.trim()) {
                             if s.eq_ignore_ascii_case("chunked") {
                                 chunked = true;
                             } else if s.eq_ignore_ascii_case("identity") {
@@ -136,7 +136,7 @@ pub(crate) trait MessageType: Sized {
                     }
                     // connection keep-alive state
                     header::CONNECTION => {
-                        ka = if let Ok(conn) = value.to_str().map(str::trim) {
+                        ka = if let Ok(conn) = value.to_str().map(|conn| conn.trim()) {
                             if conn.eq_ignore_ascii_case("keep-alive") {
                                 Some(ConnectionType::KeepAlive)
                             } else if conn.eq_ignore_ascii_case("close") {
@@ -151,7 +151,7 @@ pub(crate) trait MessageType: Sized {
                         };
                     }
                     header::UPGRADE => {
-                        if let Ok(val) = value.to_str().map(str::trim) {
+                        if let Ok(val) = value.to_str().map(|val| val.trim()) {
                             if val.eq_ignore_ascii_case("websocket") {
                                 has_upgrade_websocket = true;
                             }
@@ -163,7 +163,7 @@ pub(crate) trait MessageType: Sized {
                             expect = true;
                         }
                     }
-                    _ => {}
+                    _ => (),
                 }
 
                 headers.append(name, value);
@@ -212,17 +212,10 @@ impl MessageType for Request {
         let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
 
         let (len, method, uri, ver, h_len) = {
-            // SAFETY:
-            // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
-            // safe because the type we are claiming to have initialized here is a
-            // bunch of `MaybeUninit`s, which do not require initialization.
-            let mut parsed = unsafe {
-                MaybeUninit::<[MaybeUninit<httparse::Header<'_>>; MAX_HEADERS]>::uninit()
-                    .assume_init()
-            };
+            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
 
-            let mut req = httparse::Request::new(&mut []);
-            match req.parse_with_uninit_headers(src, &mut parsed)? {
+            let mut req = httparse::Request::new(&mut parsed);
+            match req.parse(src)? {
                 httparse::Status::Complete(len) => {
                     let method = Method::from_bytes(req.method.unwrap().as_bytes())
                         .map_err(|_| ParseError::Method)?;
@@ -236,15 +229,7 @@ impl MessageType for Request {
 
                     (len, method, uri, version, req.headers.len())
                 }
-                httparse::Status::Partial => {
-                    return if src.len() >= MAX_BUFFER_SIZE {
-                        trace!("MAX_BUFFER_SIZE unprocessed data reached, closing");
-                        Err(ParseError::TooLarge)
-                    } else {
-                        // Return None to notify more read are needed for parsing request
-                        Ok(None)
-                    };
-                }
+                httparse::Status::Partial => return Ok(None),
             }
         };
 
@@ -257,12 +242,15 @@ impl MessageType for Request {
         let decoder = match length {
             PayloadLength::Payload(pl) => pl,
             PayloadLength::UpgradeWebSocket => {
-                // upgrade (WebSocket)
+                // upgrade(websocket)
                 PayloadType::Stream(PayloadDecoder::eof())
             }
             PayloadLength::None => {
                 if method == Method::CONNECT {
                     PayloadType::Stream(PayloadDecoder::eof())
+                } else if src.len() >= MAX_BUFFER_SIZE {
+                    trace!("MAX_BUFFER_SIZE unprocessed data reached, closing");
+                    return Err(ParseError::TooLarge);
                 } else {
                     PayloadType::None
                 }
@@ -311,14 +299,7 @@ impl MessageType for ResponseHead {
 
                     (len, version, status, res.headers.len())
                 }
-                httparse::Status::Partial => {
-                    return if src.len() >= MAX_BUFFER_SIZE {
-                        error!("MAX_BUFFER_SIZE unprocessed data reached, closing");
-                        Err(ParseError::TooLarge)
-                    } else {
-                        Ok(None)
-                    }
-                }
+                httparse::Status::Partial => return Ok(None),
             }
         };
 
@@ -334,6 +315,9 @@ impl MessageType for ResponseHead {
         } else if status == StatusCode::SWITCHING_PROTOCOLS {
             // switching protocol or connect
             PayloadType::Stream(PayloadDecoder::eof())
+        } else if src.len() >= MAX_BUFFER_SIZE {
+            error!("MAX_BUFFER_SIZE unprocessed data reached, closing");
+            return Err(ParseError::TooLarge);
         } else {
             // for HTTP/1.0 read to eof and close connection
             if msg.version == Version::HTTP_10 {
@@ -441,6 +425,20 @@ enum Kind {
     Eof,
 }
 
+#[derive(Debug, PartialEq, Clone)]
+enum ChunkedState {
+    Size,
+    SizeLws,
+    Extension,
+    SizeLf,
+    Body,
+    BodyCr,
+    BodyLf,
+    EndCr,
+    EndLf,
+    End,
+}
+
 impl Decoder for PayloadDecoder {
     type Item = PayloadItem;
     type Error = io::Error;
@@ -470,23 +468,19 @@ impl Decoder for PayloadDecoder {
             Kind::Chunked(ref mut state, ref mut size) => {
                 loop {
                     let mut buf = None;
-
                     // advances the chunked state
                     *state = match state.step(src, size, &mut buf) {
                         Poll::Pending => return Ok(None),
                         Poll::Ready(Ok(state)) => state,
                         Poll::Ready(Err(e)) => return Err(e),
                     };
-
                     if *state == ChunkedState::End {
                         trace!("End of chunked stream");
                         return Ok(Some(PayloadItem::Eof));
                     }
-
                     if let Some(buf) = buf {
                         return Ok(Some(PayloadItem::Chunk(buf)));
                     }
-
                     if src.is_empty() {
                         return Ok(None);
                     }
@@ -503,40 +497,213 @@ impl Decoder for PayloadDecoder {
     }
 }
 
+macro_rules! byte (
+    ($rdr:ident) => ({
+        if $rdr.len() > 0 {
+            let b = $rdr[0];
+            $rdr.advance(1);
+            b
+        } else {
+            return Poll::Pending
+        }
+    })
+);
+
+impl ChunkedState {
+    fn step(
+        &self,
+        body: &mut BytesMut,
+        size: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        use self::ChunkedState::*;
+        match *self {
+            Size => ChunkedState::read_size(body, size),
+            SizeLws => ChunkedState::read_size_lws(body),
+            Extension => ChunkedState::read_extension(body),
+            SizeLf => ChunkedState::read_size_lf(body, size),
+            Body => ChunkedState::read_body(body, size, buf),
+            BodyCr => ChunkedState::read_body_cr(body),
+            BodyLf => ChunkedState::read_body_lf(body),
+            EndCr => ChunkedState::read_end_cr(body),
+            EndLf => ChunkedState::read_end_lf(body),
+            End => Poll::Ready(Ok(ChunkedState::End)),
+        }
+    }
+
+    fn read_size(
+        rdr: &mut BytesMut,
+        size: &mut u64,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        let radix = 16;
+
+        let rem = match byte!(rdr) {
+            b @ b'0'..=b'9' => b - b'0',
+            b @ b'a'..=b'f' => b + 10 - b'a',
+            b @ b'A'..=b'F' => b + 10 - b'A',
+            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => {
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Invalid chunk size line: Invalid Size",
+                )));
+            }
+        };
+
+        match size.checked_mul(radix) {
+            Some(n) => {
+                *size = n as u64;
+                *size += rem as u64;
+
+                Poll::Ready(Ok(ChunkedState::Size))
+            }
+            None => {
+                debug!("chunk size would overflow");
+                Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Invalid chunk size line: Invalid Size",
+                )))
+            }
+        }
+    }
+
+    fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("read_size_lws");
+        match byte!(rdr) {
+            // LWS can follow the chunk size, but no more digits can come
+            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size linear white space",
+            ))),
+        }
+    }
+    fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            // strictly 0x20 (space) should be disallowed but we don't parse quoted strings here
+            0x00..=0x08 | 0x0a..=0x1f | 0x7f => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid character in chunk extension",
+            ))),
+            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
+        }
+    }
+    fn read_size_lf(
+        rdr: &mut BytesMut,
+        size: &mut u64,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' if *size > 0 => Poll::Ready(Ok(ChunkedState::Body)),
+            b'\n' if *size == 0 => Poll::Ready(Ok(ChunkedState::EndCr)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size LF",
+            ))),
+        }
+    }
+
+    fn read_body(
+        rdr: &mut BytesMut,
+        rem: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("Chunked read, remaining={:?}", rem);
+
+        let len = rdr.len() as u64;
+        if len == 0 {
+            Poll::Ready(Ok(ChunkedState::Body))
+        } else {
+            let slice;
+            if *rem > len {
+                slice = rdr.split().freeze();
+                *rem -= len;
+            } else {
+                slice = rdr.split_to(*rem as usize).freeze();
+                *rem = 0;
+            }
+            *buf = Some(slice);
+            if *rem > 0 {
+                Poll::Ready(Ok(ChunkedState::Body))
+            } else {
+                Poll::Ready(Ok(ChunkedState::BodyCr))
+            }
+        }
+    }
+
+    fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body CR",
+            ))),
+        }
+    }
+    fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body LF",
+            ))),
+        }
+    }
+    fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk end CR",
+            ))),
+        }
+    }
+    fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk end LF",
+            ))),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use bytes::{Bytes, BytesMut};
     use http::{Method, Version};
 
     use super::*;
-    use crate::{
-        error::ParseError,
-        http::header::{HeaderName, SET_COOKIE},
-        HttpMessage as _,
-    };
+    use crate::error::ParseError;
+    use crate::http::header::{HeaderName, SET_COOKIE};
+    use crate::httpmessage::HttpMessage;
 
     impl PayloadType {
-        pub(crate) fn unwrap(self) -> PayloadDecoder {
+        fn unwrap(self) -> PayloadDecoder {
             match self {
                 PayloadType::Payload(pl) => pl,
                 _ => panic!(),
             }
         }
 
-        pub(crate) fn is_unhandled(&self) -> bool {
+        fn is_unhandled(&self) -> bool {
             matches!(self, PayloadType::Stream(_))
         }
     }
 
     impl PayloadItem {
-        pub(crate) fn chunk(self) -> Bytes {
+        fn chunk(self) -> Bytes {
             match self {
                 PayloadItem::Chunk(chunk) => chunk,
                 _ => panic!("error"),
             }
         }
-
-        pub(crate) fn eof(&self) -> bool {
+        fn eof(&self) -> bool {
             matches!(*self, PayloadItem::Eof)
         }
     }
@@ -556,7 +723,7 @@ mod tests {
             match MessageDecoder::<Request>::default().decode($e) {
                 Err(err) => match err {
                     ParseError::Io(_) => unreachable!("Parse error expected"),
-                    _ => {}
+                    _ => (),
                 },
                 _ => unreachable!("Error expected"),
             }
@@ -692,8 +859,8 @@ mod tests {
             .get_all(SET_COOKIE)
             .map(|v| v.to_str().unwrap().to_owned())
             .collect();
-        assert_eq!(val[0], "c1=cookie1");
-        assert_eq!(val[1], "c2=cookie2");
+        assert_eq!(val[1], "c1=cookie1");
+        assert_eq!(val[0], "c2=cookie2");
     }
 
     #[test]
@@ -829,6 +996,28 @@ mod tests {
         assert!(req.upgrade());
     }
 
+    #[test]
+    fn test_request_chunked() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let req = parse_ready!(&mut buf);
+
+        if let Ok(val) = req.chunked() {
+            assert!(val);
+        } else {
+            unreachable!("Error");
+        }
+
+        // intentional typo in "chunked"
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chnked\r\n\r\n",
+        );
+        expect_parse_err!(&mut buf);
+    }
+
     #[test]
     fn test_headers_content_length_err_1() {
         let mut buf = BytesMut::from(
@@ -946,9 +1135,128 @@ mod tests {
         expect_parse_err!(&mut buf);
     }
 
+    #[test]
+    fn test_http_request_chunked_payload() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n");
+        assert_eq!(
+            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
+            b"data"
+        );
+        assert_eq!(
+            pl.decode(&mut buf).unwrap().unwrap().chunk().as_ref(),
+            b"line"
+        );
+        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
+    }
+
+    #[test]
+    fn test_http_request_chunked_payload_and_next_message() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(
+            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
+              POST /test2 HTTP/1.1\r\n\
+              transfer-encoding: chunked\r\n\r\n"
+                .iter(),
+        );
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"data");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"line");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert!(msg.eof());
+
+        let (req, _) = reader.decode(&mut buf).unwrap().unwrap();
+        assert!(req.chunked().unwrap());
+        assert_eq!(*req.method(), Method::POST);
+        assert!(req.chunked().unwrap());
+    }
+
+    #[test]
+    fn test_http_request_chunked_payload_chunks() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(req.chunked().unwrap());
+
+        buf.extend(b"4\r\n1111\r\n");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"1111");
+
+        buf.extend(b"4\r\ndata\r");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"data");
+
+        buf.extend(b"\n4");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"\r");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+        buf.extend(b"\n");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"li");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"li");
+
+        //trailers
+        //buf.feed_data("test: test\r\n");
+        //not_ready!(reader.parse(&mut buf, &mut readbuf));
+
+        buf.extend(b"ne\r\n0\r\n");
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"ne");
+        assert!(pl.decode(&mut buf).unwrap().is_none());
+
+        buf.extend(b"\r\n");
+        assert!(pl.decode(&mut buf).unwrap().unwrap().eof());
+    }
+
+    #[test]
+    fn test_parse_chunked_payload_chunk_extension() {
+        let mut buf = BytesMut::from(
+            &"GET /test HTTP/1.1\r\n\
+              transfer-encoding: chunked\r\n\r\n"[..],
+        );
+
+        let mut reader = MessageDecoder::<Request>::default();
+        let (msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+        assert!(msg.chunked().unwrap());
+
+        buf.extend(b"4;test\r\ndata\r\n4\r\nline\r\n0\r\n\r\n"); // test: test\r\n\r\n")
+        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
+        assert_eq!(chunk, Bytes::from_static(b"data"));
+        let chunk = pl.decode(&mut buf).unwrap().unwrap().chunk();
+        assert_eq!(chunk, Bytes::from_static(b"line"));
+        let msg = pl.decode(&mut buf).unwrap().unwrap();
+        assert!(msg.eof());
+    }
+
     #[test]
     fn test_response_http10_read_until_eof() {
-        let mut buf = BytesMut::from("HTTP/1.0 200 Ok\r\n\r\ntest data");
+        let mut buf = BytesMut::from(&"HTTP/1.0 200 Ok\r\n\r\ntest data"[..]);
 
         let mut reader = MessageDecoder::<ResponseHead>::default();
         let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
@@ -957,84 +1265,4 @@ mod tests {
         let chunk = pl.decode(&mut buf).unwrap().unwrap();
         assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"test data")));
     }
-
-    #[test]
-    fn hrs_multiple_content_length() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Content-Length: 4\r\n\
-            Content-Length: 2\r\n\
-            \r\n\
-            abcd",
-        );
-
-        expect_parse_err!(&mut buf);
-    }
-
-    #[test]
-    fn hrs_content_length_plus() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Content-Length: +3\r\n\
-            \r\n\
-            000",
-        );
-
-        expect_parse_err!(&mut buf);
-    }
-
-    #[test]
-    fn hrs_unknown_transfer_encoding() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Transfer-Encoding: JUNK\r\n\
-            Transfer-Encoding: chunked\r\n\
-            \r\n\
-            5\r\n\
-            hello\r\n\
-            0",
-        );
-
-        expect_parse_err!(&mut buf);
-    }
-
-    #[test]
-    fn hrs_multiple_transfer_encoding() {
-        let mut buf = BytesMut::from(
-            "GET / HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Content-Length: 51\r\n\
-            Transfer-Encoding: identity\r\n\
-            Transfer-Encoding: chunked\r\n\
-            \r\n\
-            0\r\n\
-            \r\n\
-            GET /forbidden HTTP/1.1\r\n\
-            Host: example.com\r\n\r\n",
-        );
-
-        expect_parse_err!(&mut buf);
-    }
-
-    #[test]
-    fn transfer_encoding_agrees() {
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-            Host: example.com\r\n\
-            Content-Length: 3\r\n\
-            Transfer-Encoding: identity\r\n\
-            \r\n\
-            0\r\n",
-        );
-
-        let mut reader = MessageDecoder::<Request>::default();
-        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
-        let mut pl = pl.unwrap();
-
-        let chunk = pl.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"0\r\n")));
-    }
 }

actix-http/src/h1/encoder.rs

@@ -6,24 +6,22 @@ use std::{cmp, io};
 
 use bytes::{BufMut, BytesMut};
 
-use crate::{
-    body::BodySize,
-    config::ServiceConfig,
-    header::{map::Value, HeaderMap, HeaderName},
-    header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
-    helpers,
-    message::{ConnectionType, RequestHeadType},
-    Response, StatusCode, Version,
-};
+use crate::body::BodySize;
+use crate::config::ServiceConfig;
+use crate::header::map;
+use crate::helpers;
+use crate::http::header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
+use crate::http::{HeaderMap, StatusCode, Version};
+use crate::message::{ConnectionType, RequestHeadType};
+use crate::response::Response;
 
 const AVERAGE_HEADER_SIZE: usize = 30;
 
 #[derive(Debug)]
 pub(crate) struct MessageEncoder<T: MessageType> {
-    #[allow(dead_code)]
     pub length: BodySize,
     pub te: TransferEncoding,
-    _phantom: PhantomData<T>,
+    _t: PhantomData<T>,
 }
 
 impl<T: MessageType> Default for MessageEncoder<T> {
@@ -31,7 +29,7 @@ impl<T: MessageType> Default for MessageEncoder<T> {
         MessageEncoder {
             length: BodySize::None,
             te: TransferEncoding::empty(),
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 }
@@ -121,14 +119,24 @@ pub(crate) trait MessageType: Sized {
                     dst.put_slice(b"connection: close\r\n")
                 }
             }
-            _ => {}
+            _ => (),
         }
 
+        // merging headers from head and extra headers. HeaderMap::new() does not allocate.
+        let empty_headers = HeaderMap::new();
+        let extra_headers = self.extra_headers().unwrap_or(&empty_headers);
+        let headers = self
+            .headers()
+            .inner
+            .iter()
+            .filter(|(name, _)| !extra_headers.contains_key(*name))
+            .chain(extra_headers.inner.iter());
+
         // write headers
 
         let mut has_date = false;
 
-        let mut buf = dst.chunk_mut().as_mut_ptr();
+        let mut buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
         let mut remaining = dst.capacity() - dst.len();
 
         // tracks bytes written since last buffer resize
@@ -136,67 +144,117 @@ pub(crate) trait MessageType: Sized {
         // container's knowledge, this is used to sync the containers cursor after data is written
         let mut pos = 0;
 
-        self.write_headers(|key, value| {
+        for (key, value) in headers {
             match *key {
-                CONNECTION => return,
-                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => return,
+                CONNECTION => continue,
+                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
                 DATE => has_date = true,
-                _ => {}
+                _ => (),
             }
 
             let k = key.as_str().as_bytes();
             let k_len = k.len();
 
-            // TODO: drain?
-            for val in value.iter() {
-                let v = val.as_ref();
-                let v_len = v.len();
+            match value {
+                map::Value::One(ref val) => {
+                    let v = val.as_ref();
+                    let v_len = v.len();
 
-                // key length + value length + colon + space + \r\n
-                let len = k_len + v_len + 4;
+                    // key length + value length + colon + space + \r\n
+                    let len = k_len + v_len + 4;
 
-                if len > remaining {
-                    // SAFETY: all the bytes written up to position "pos" are initialized
-                    // the written byte count and pointer advancement are kept in sync
-                    unsafe {
-                        dst.advance_mut(pos);
+                    if len > remaining {
+                        // not enough room in buffer for this header; reserve more space
+
+                        // SAFETY: all the bytes written up to position "pos" are initialized
+                        // the written byte count and pointer advancement are kept in sync
+                        unsafe {
+                            dst.advance_mut(pos);
+                        }
+
+                        pos = 0;
+                        dst.reserve(len * 2);
+                        remaining = dst.capacity() - dst.len();
+
+                        // re-assign buf raw pointer since it's possible that the buffer was
+                        // reallocated and/or resized
+                        buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
                     }
 
-                    pos = 0;
-                    dst.reserve(len * 2);
-                    remaining = dst.capacity() - dst.len();
+                    // SAFETY: on each write, it is enough to ensure that the advancement of the
+                    // cursor matches the number of bytes written
+                    unsafe {
+                        // use upper Camel-Case
+                        if camel_case {
+                            write_camel_case(k, from_raw_parts_mut(buf, k_len))
+                        } else {
+                            write_data(k, buf, k_len)
+                        }
 
-                    // re-assign buf raw pointer since it's possible that the buffer was
-                    // reallocated and/or resized
-                    buf = dst.chunk_mut().as_mut_ptr();
+                        buf = buf.add(k_len);
+
+                        write_data(b": ", buf, 2);
+                        buf = buf.add(2);
+
+                        write_data(v, buf, v_len);
+                        buf = buf.add(v_len);
+
+                        write_data(b"\r\n", buf, 2);
+                        buf = buf.add(2);
+                    }
+
+                    pos += len;
+                    remaining -= len;
                 }
 
-                // SAFETY: on each write, it is enough to ensure that the advancement of
-                // the cursor matches the number of bytes written
-                unsafe {
-                    if camel_case {
-                        // use Camel-Case headers
-                        write_camel_case(k, buf, k_len);
-                    } else {
-                        write_data(k, buf, k_len);
+                map::Value::Multi(ref vec) => {
+                    for val in vec {
+                        let v = val.as_ref();
+                        let v_len = v.len();
+                        let len = k_len + v_len + 4;
+
+                        if len > remaining {
+                            // SAFETY: all the bytes written up to position "pos" are initialized
+                            // the written byte count and pointer advancement are kept in sync
+                            unsafe {
+                                dst.advance_mut(pos);
+                            }
+                            pos = 0;
+                            dst.reserve(len * 2);
+                            remaining = dst.capacity() - dst.len();
+
+                            // re-assign buf raw pointer since it's possible that the buffer was
+                            // reallocated and/or resized
+                            buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
+                        }
+
+                        // SAFETY: on each write, it is enough to ensure that the advancement of
+                        // the cursor matches the number of bytes written
+                        unsafe {
+                            if camel_case {
+                                write_camel_case(k, from_raw_parts_mut(buf, k_len));
+                            } else {
+                                write_data(k, buf, k_len);
+                            }
+
+                            buf = buf.add(k_len);
+
+                            write_data(b": ", buf, 2);
+                            buf = buf.add(2);
+
+                            write_data(v, buf, v_len);
+                            buf = buf.add(v_len);
+
+                            write_data(b"\r\n", buf, 2);
+                            buf = buf.add(2);
+                        };
+
+                        pos += len;
+                        remaining -= len;
                     }
-
-                    buf = buf.add(k_len);
-
-                    write_data(b": ", buf, 2);
-                    buf = buf.add(2);
-
-                    write_data(v, buf, v_len);
-                    buf = buf.add(v_len);
-
-                    write_data(b"\r\n", buf, 2);
-                    buf = buf.add(2);
-                };
-
-                pos += len;
-                remaining -= len;
+                }
             }
-        });
+        }
 
         // final cursor synchronization with the bytes container
         //
@@ -216,24 +274,6 @@ pub(crate) trait MessageType: Sized {
 
         Ok(())
     }
-
-    fn write_headers<F>(&mut self, mut f: F)
-    where
-        F: FnMut(&HeaderName, &Value),
-    {
-        match self.extra_headers() {
-            Some(headers) => {
-                // merging headers from head and extra headers.
-                self.headers()
-                    .inner
-                    .iter()
-                    .filter(|(name, _)| !headers.contains_key(*name))
-                    .chain(headers.inner.iter())
-                    .for_each(|(k, v)| f(k, v))
-            }
-            None => self.headers().inner.iter().for_each(|(k, v)| f(k, v)),
-        }
-    }
 }
 
 impl MessageType for Response<()> {
@@ -290,7 +330,7 @@ impl MessageType for RequestHeadType {
         let head = self.as_ref();
         dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
         write!(
-            helpers::MutWriter(dst),
+            Writer(dst),
             "{} {} {}",
             head.method,
             head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
@@ -423,7 +463,7 @@ impl TransferEncoding {
                     *eof = true;
                     buf.extend_from_slice(b"0\r\n\r\n");
                 } else {
-                    writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
+                    writeln!(Writer(buf), "{:X}\r", msg.len())
                         .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
                     buf.reserve(msg.len() + 2);
@@ -473,44 +513,50 @@ impl TransferEncoding {
     }
 }
 
+struct Writer<'a>(pub &'a mut BytesMut);
+
+impl<'a> io::Write for Writer<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 /// # Safety
-/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
-/// valid for writes of at least `len` bytes.
+/// Callers must ensure that the given length matches given value length.
 unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
     debug_assert_eq!(value.len(), len);
     copy_nonoverlapping(value.as_ptr(), buf, len);
 }
 
-/// # Safety
-/// Callers must ensure that the given `len` matches the given `value` length and that `buf` is
-/// valid for writes of at least `len` bytes.
-unsafe fn write_camel_case(value: &[u8], buf: *mut u8, len: usize) {
-    // first copy entire (potentially wrong) slice to output
-    write_data(value, buf, len);
+fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+    let mut index = 0;
+    let key = value;
+    let mut key_iter = key.iter();
 
-    // SAFETY: We just initialized the buffer with `value`
-    let buffer = from_raw_parts_mut(buf, len);
-
-    let mut iter = value.iter();
-
-    // first character should be uppercase
-    if let Some(c @ b'a'..=b'z') = iter.next() {
-        buffer[0] = c & 0b1101_1111;
+    if let Some(c) = key_iter.next() {
+        if *c >= b'a' && *c <= b'z' {
+            buffer[index] = *c ^ b' ';
+            index += 1;
+        }
+    } else {
+        return;
     }
 
-    // track 1 ahead of the current position since that's the location being assigned to
-    let mut index = 2;
-
-    // remaining characters after hyphens should also be uppercase
-    while let Some(&c) = iter.next() {
-        if c == b'-' {
-            // advance iter by one and uppercase if needed
-            if let Some(c @ b'a'..=b'z') = iter.next() {
-                buffer[index] = c & 0b1101_1111;
+    while let Some(c) = key_iter.next() {
+        buffer[index] = *c;
+        index += 1;
+        if *c == b'-' {
+            if let Some(c) = key_iter.next() {
+                if *c >= b'a' && *c <= b'z' {
+                    buffer[index] = *c ^ b' ';
+                    index += 1;
+                }
             }
         }
-
-        index += 1;
     }
 }
 
@@ -539,8 +585,8 @@ mod tests {
         );
     }
 
-    #[actix_rt::test]
-    async fn test_camel_case() {
+    #[test]
+    fn test_camel_case() {
         let mut bytes = BytesMut::with_capacity(2048);
         let mut head = RequestHead::default();
         head.set_camel_case_headers(true);
@@ -559,7 +605,6 @@ mod tests {
         );
         let data =
             String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-
         assert!(data.contains("Content-Length: 0\r\n"));
         assert!(data.contains("Connection: close\r\n"));
         assert!(data.contains("Content-Type: plain/text\r\n"));
@@ -602,8 +647,8 @@ mod tests {
         assert!(data.contains("date: date\r\n"));
     }
 
-    #[actix_rt::test]
-    async fn test_extra_headers() {
+    #[test]
+    fn test_extra_headers() {
         let mut bytes = BytesMut::with_capacity(2048);
 
         let mut head = RequestHead::default();
@@ -636,14 +681,16 @@ mod tests {
         assert!(data.contains("date: date\r\n"));
     }
 
-    #[actix_rt::test]
-    async fn test_no_content_length() {
+    #[test]
+    fn test_no_content_length() {
         let mut bytes = BytesMut::with_capacity(2048);
 
-        let mut res = Response::with_body(StatusCode::SWITCHING_PROTOCOLS, ());
-        res.headers_mut().insert(DATE, HeaderValue::from_static(""));
+        let mut res: Response<()> =
+            Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
         res.headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
+            .insert(DATE, HeaderValue::from_static(&""));
+        res.headers_mut()
+            .insert(CONTENT_LENGTH, HeaderValue::from_static(&"0"));
 
         let _ = res.encode_headers(
             &mut bytes,

actix-http/src/h1/expect.rs

@@ -1,34 +1,38 @@
+use std::task::{Context, Poll};
+
 use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ready, Ready};
+use futures_util::future::{ok, Ready};
 
 use crate::error::Error;
 use crate::request::Request;
 
 pub struct ExpectHandler;
 
-impl ServiceFactory<Request> for ExpectHandler {
+impl ServiceFactory for ExpectHandler {
+    type Config = ();
+    type Request = Request;
     type Response = Request;
     type Error = Error;
-    type Config = ();
     type Service = ExpectHandler;
     type InitError = Error;
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: Self::Config) -> Self::Future {
-        ready(Ok(ExpectHandler))
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(ExpectHandler)
     }
 }
 
-impl Service<Request> for ExpectHandler {
+impl Service for ExpectHandler {
+    type Request = Request;
     type Response = Request;
     type Error = Error;
     type Future = Ready<Result<Self::Response, Self::Error>>;
 
-    actix_service::always_ready!();
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
 
-    fn call(&self, req: Request) -> Self::Future {
-        ready(Ok(req))
-        // TODO: add some way to trigger error
-        // Err(error::ErrorExpectationFailed("test"))
+    fn call(&mut self, req: Request) -> Self::Future {
+        ok(req)
     }
 }

actix-http/src/h1/mod.rs

@@ -1,8 +1,6 @@
-//! HTTP/1 protocol implementation.
-
+//! HTTP/1 implementation
 use bytes::{Bytes, BytesMut};
 
-mod chunked;
 mod client;
 mod codec;
 mod decoder;
@@ -19,7 +17,7 @@ pub use self::codec::Codec;
 pub use self::dispatcher::Dispatcher;
 pub use self::expect::ExpectHandler;
 pub use self::payload::Payload;
-pub use self::service::{H1Service, H1ServiceHandler};
+pub use self::service::{H1Service, H1ServiceHandler, OneRequest};
 pub use self::upgrade::UpgradeHandler;
 pub use self::utils::SendResponse;
 

actix-http/src/h1/payload.rs

@@ -3,8 +3,9 @@ use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
-use std::task::{Context, Poll, Waker};
+use std::task::{Context, Poll};
 
+use actix_utils::task::LocalWaker;
 use bytes::Bytes;
 use futures_core::Stream;
 
@@ -133,7 +134,7 @@ impl PayloadSender {
             if shared.borrow().need_read {
                 PayloadStatus::Read
             } else {
-                shared.borrow_mut().register_io(cx);
+                shared.borrow_mut().io_task.register(cx.waker());
                 PayloadStatus::Pause
             }
         } else {
@@ -149,8 +150,8 @@ struct Inner {
     err: Option<PayloadError>,
     need_read: bool,
     items: VecDeque<Bytes>,
-    task: Option<Waker>,
-    io_task: Option<Waker>,
+    task: LocalWaker,
+    io_task: LocalWaker,
 }
 
 impl Inner {
@@ -161,46 +162,8 @@ impl Inner {
             err: None,
             items: VecDeque::new(),
             need_read: true,
-            task: None,
-            io_task: None,
-        }
-    }
-
-    /// Wake up future waiting for payload data to be available.
-    fn wake(&mut self) {
-        if let Some(waker) = self.task.take() {
-            waker.wake();
-        }
-    }
-
-    /// Wake up future feeding data to Payload.
-    fn wake_io(&mut self) {
-        if let Some(waker) = self.io_task.take() {
-            waker.wake();
-        }
-    }
-
-    /// Register future waiting data from payload.
-    /// Waker would be used in `Inner::wake`
-    fn register(&mut self, cx: &mut Context<'_>) {
-        if self
-            .task
-            .as_ref()
-            .map_or(true, |w| !cx.waker().will_wake(w))
-        {
-            self.task = Some(cx.waker().clone());
-        }
-    }
-
-    // Register future feeding data to payload.
-    /// Waker would be used in `Inner::wake_io`
-    fn register_io(&mut self, cx: &mut Context<'_>) {
-        if self
-            .io_task
-            .as_ref()
-            .map_or(true, |w| !cx.waker().will_wake(w))
-        {
-            self.io_task = Some(cx.waker().clone());
+            task: LocalWaker::new(),
+            io_task: LocalWaker::new(),
         }
     }
 
@@ -219,7 +182,9 @@ impl Inner {
         self.len += data.len();
         self.items.push_back(data);
         self.need_read = self.len < MAX_BUFFER_SIZE;
-        self.wake();
+        if let Some(task) = self.task.take() {
+            task.wake()
+        }
     }
 
     #[cfg(test)]
@@ -236,9 +201,9 @@ impl Inner {
             self.need_read = self.len < MAX_BUFFER_SIZE;
 
             if self.need_read && !self.eof {
-                self.register(cx);
+                self.task.register(cx.waker());
             }
-            self.wake_io();
+            self.io_task.wake();
             Poll::Ready(Some(Ok(data)))
         } else if let Some(err) = self.err.take() {
             Poll::Ready(Some(Err(err)))
@@ -246,8 +211,8 @@ impl Inner {
             Poll::Ready(None)
         } else {
             self.need_read = true;
-            self.register(cx);
-            self.wake_io();
+            self.task.register(cx.waker());
+            self.io_task.wake();
             Poll::Pending
         }
     }
@@ -261,7 +226,7 @@ impl Inner {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use actix_utils::future::poll_fn;
+    use futures_util::future::poll_fn;
 
     #[actix_rt::test]
     async fn test_unread_data() {

actix-http/src/h1/service.rs

@@ -1,50 +1,50 @@
-use std::{
-    error::Error as StdError,
-    fmt,
-    marker::PhantomData,
-    net,
-    rc::Rc,
-    task::{Context, Poll},
-};
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};
+use std::{fmt, net};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
-use actix_service::{
-    fn_service, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
-};
-use actix_utils::future::ready;
-use futures_core::future::LocalBoxFuture;
+use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
+use futures_core::ready;
+use futures_util::future::{ok, Ready};
 
-use crate::{
-    body::{AnyBody, MessageBody},
-    config::ServiceConfig,
-    error::DispatchError,
-    service::HttpServiceHandler,
-    ConnectCallback, OnConnectData, Request, Response,
-};
+use crate::body::MessageBody;
+use crate::cloneable::CloneableService;
+use crate::config::ServiceConfig;
+use crate::error::{DispatchError, Error, ParseError};
+use crate::helpers::DataFactory;
+use crate::request::Request;
+use crate::response::Response;
+use crate::{ConnectCallback, Extensions};
 
-use super::{codec::Codec, dispatcher::Dispatcher, ExpectHandler, UpgradeHandler};
+use super::codec::Codec;
+use super::dispatcher::Dispatcher;
+use super::{ExpectHandler, Message, UpgradeHandler};
 
 /// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
+pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
     srv: S,
     cfg: ServiceConfig,
     expect: X,
     upgrade: Option<U>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
+    _t: PhantomData<(T, B)>,
 }
 
 impl<T, S, B> H1Service<T, S, B>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
     B: MessageBody,
 {
     /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
+    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
         cfg: ServiceConfig,
         service: F,
     ) -> Self {
@@ -53,46 +53,44 @@ where
             srv: service.into_factory(),
             expect: ExpectHandler,
             upgrade: None,
+            on_connect: None,
             on_connect_ext: None,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 }
 
 impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Future: 'static,
-    S::Error: Into<Response<AnyBody>>,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
-
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
-
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Future: 'static,
-    X::Error: Into<Response<AnyBody>>,
+    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-
-    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
-    U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    U: ServiceFactory<
+        Config = (),
+        Request = (Request, Framed<TcpStream, Codec>),
+        Response = (),
+    >,
+    U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
 {
     /// Create simple tcp stream service
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
-        TcpStream,
         Config = (),
+        Request = TcpStream,
         Response = (),
         Error = DispatchError,
         InitError = (),
     > {
-        fn_service(|io: TcpStream| {
+        pipeline_factory(|io: TcpStream| {
             let peer_addr = io.peer_addr().ok();
-            ready(Ok((io, peer_addr)))
+            ok((io, peer_addr))
         })
         .and_then(self)
     }
@@ -102,35 +100,25 @@ where
 mod openssl {
     use super::*;
 
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::{
-        openssl::{Acceptor, SslAcceptor, SslError, TlsStream},
-        TlsError,
-    };
+    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
+    use actix_tls::{openssl::HandshakeError, TlsError};
 
-    impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
+    impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Future: 'static,
-        S::Error: Into<Response<AnyBody>>,
+        S: ServiceFactory<Config = (), Request = Request>,
+        S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
-
         B: MessageBody,
-        B::Error: Into<Box<dyn StdError>>,
-
-        X: ServiceFactory<Request, Config = (), Response = Request>,
-        X::Future: 'static,
-        X::Error: Into<Response<AnyBody>>,
+        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X::Error: Into<Error>,
         X::InitError: fmt::Debug,
-
         U: ServiceFactory<
-            (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
+            Request = (Request, Framed<SslStream<TcpStream>, Codec>),
             Response = (),
         >,
-        U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
+        U::Error: fmt::Display + Into<Error>,
         U::InitError: fmt::Debug,
     {
         /// Create openssl based service
@@ -138,20 +126,22 @@ mod openssl {
             self,
             acceptor: SslAcceptor,
         ) -> impl ServiceFactory<
-            TcpStream,
             Config = (),
+            Request = TcpStream,
             Response = (),
-            Error = TlsError<SslError, DispatchError>,
+            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
             InitError = (),
         > {
-            Acceptor::new(acceptor)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(|io: TlsStream<TcpStream>| {
-                    let peer_addr = io.get_ref().peer_addr().ok();
-                    ready(Ok((io, peer_addr)))
-                })
-                .and_then(self.map_err(TlsError::Service))
+            pipeline_factory(
+                Acceptor::new(acceptor)
+                    .map_err(TlsError::Tls)
+                    .map_init_err(|_| panic!()),
+            )
+            .and_then(|io: SslStream<TcpStream>| {
+                let peer_addr = io.get_ref().peer_addr().ok();
+                ok((io, peer_addr))
+            })
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -159,38 +149,26 @@ mod openssl {
 #[cfg(feature = "rustls")]
 mod rustls {
     use super::*;
-
-    use std::io;
-
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::{
-        rustls::{Acceptor, ServerConfig, TlsStream},
-        TlsError,
-    };
+    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
+    use actix_tls::TlsError;
+    use std::{fmt, io};
 
     impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Future: 'static,
-        S::Error: Into<Response<AnyBody>>,
+        S: ServiceFactory<Config = (), Request = Request>,
+        S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
-
         B: MessageBody,
-        B::Error: Into<Box<dyn StdError>>,
-
-        X: ServiceFactory<Request, Config = (), Response = Request>,
-        X::Future: 'static,
-        X::Error: Into<Response<AnyBody>>,
+        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X::Error: Into<Error>,
         X::InitError: fmt::Debug,
-
         U: ServiceFactory<
-            (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
+            Request = (Request, Framed<TlsStream<TcpStream>, Codec>),
             Response = (),
         >,
-        U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
+        U::Error: fmt::Display + Into<Error>,
         U::InitError: fmt::Debug,
     {
         /// Create rustls based service
@@ -198,36 +176,38 @@ mod rustls {
             self,
             config: ServerConfig,
         ) -> impl ServiceFactory<
-            TcpStream,
             Config = (),
+            Request = TcpStream,
             Response = (),
             Error = TlsError<io::Error, DispatchError>,
             InitError = (),
         > {
-            Acceptor::new(config)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(|io: TlsStream<TcpStream>| {
-                    let peer_addr = io.get_ref().0.peer_addr().ok();
-                    ready(Ok((io, peer_addr)))
-                })
-                .and_then(self.map_err(TlsError::Service))
+            pipeline_factory(
+                Acceptor::new(config)
+                    .map_err(TlsError::Tls)
+                    .map_init_err(|_| panic!()),
+            )
+            .and_then(|io: TlsStream<TcpStream>| {
+                let peer_addr = io.get_ref().0.peer_addr().ok();
+                ok((io, peer_addr))
+            })
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
 
 impl<T, S, B, X, U> H1Service<T, S, B, X, U>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
     B: MessageBody,
 {
     pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
     where
-        X1: ServiceFactory<Request, Response = Request>,
-        X1::Error: Into<Response<AnyBody>>,
+        X1: ServiceFactory<Request = Request, Response = Request>,
+        X1::Error: Into<Error>,
         X1::InitError: fmt::Debug,
     {
         H1Service {
@@ -235,14 +215,15 @@ where
             cfg: self.cfg,
             srv: self.srv,
             upgrade: self.upgrade,
+            on_connect: self.on_connect,
             on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 
     pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
     where
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
+        U1: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
     {
@@ -251,11 +232,21 @@ where
             cfg: self.cfg,
             srv: self.srv,
             expect: self.expect,
+            on_connect: self.on_connect,
             on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
+
     /// Set on connect callback.
     pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
         self.on_connect_ext = f;
@@ -263,116 +254,349 @@ where
     }
 }
 
-impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
-    for H1Service<T, S, B, X, U>
+impl<T, S, B, X, U> ServiceFactory for H1Service<T, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-
-    S: ServiceFactory<Request, Config = ()>,
-    S::Future: 'static,
-    S::Error: Into<Response<AnyBody>>,
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
-
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
-
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Future: 'static,
-    X::Error: Into<Response<AnyBody>>,
+    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
-    U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
 {
+    type Config = ();
+    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
-    type Config = ();
-    type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
     type InitError = ();
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+    type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
+    type Future = H1ServiceResponse<T, S, B, X, U>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        let service = self.srv.new_service(());
-        let expect = self.expect.new_service(());
-        let upgrade = self.upgrade.as_ref().map(|s| s.new_service(()));
-        let on_connect_ext = self.on_connect_ext.clone();
-        let cfg = self.cfg.clone();
+        H1ServiceResponse {
+            fut: self.srv.new_service(()),
+            fut_ex: Some(self.expect.new_service(())),
+            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(())),
+            expect: None,
+            upgrade: None,
+            on_connect: self.on_connect.clone(),
+            on_connect_ext: self.on_connect_ext.clone(),
+            cfg: Some(self.cfg.clone()),
+            _t: PhantomData,
+        }
+    }
+}
 
-        Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| log::error!("Init http expect service error: {:?}", e))?;
+#[doc(hidden)]
+#[pin_project::pin_project]
+pub struct H1ServiceResponse<T, S, B, X, U>
+where
+    S: ServiceFactory<Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    X: ServiceFactory<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    #[pin]
+    fut: S::Future,
+    #[pin]
+    fut_ex: Option<X::Future>,
+    #[pin]
+    fut_upg: Option<U::Future>,
+    expect: Option<X::Service>,
+    upgrade: Option<U::Service>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
+    cfg: Option<ServiceConfig>,
+    _t: PhantomData<(T, B)>,
+}
 
-            let upgrade = match upgrade {
-                Some(upgrade) => {
-                    let upgrade = upgrade.await.map_err(|e| {
-                        log::error!("Init http upgrade service error: {:?}", e)
-                    })?;
-                    Some(upgrade)
-                }
-                None => None,
-            };
+impl<T, S, B, X, U> Future for H1ServiceResponse<T, S, B, X, U>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: ServiceFactory<Request = Request>,
+    S::Error: Into<Error>,
+    S::Response: Into<Response<B>>,
+    S::InitError: fmt::Debug,
+    B: MessageBody,
+    X: ServiceFactory<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    type Output = Result<H1ServiceHandler<T, S::Service, B, X::Service, U::Service>, ()>;
 
-            let service = service
-                .await
-                .map_err(|e| log::error!("Init http service error: {:?}", e))?;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
 
-            Ok(H1ServiceHandler::new(
-                cfg,
+        if let Some(fut) = this.fut_ex.as_pin_mut() {
+            let expect = ready!(fut
+                .poll(cx)
+                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
+            this = self.as_mut().project();
+            *this.expect = Some(expect);
+            this.fut_ex.set(None);
+        }
+
+        if let Some(fut) = this.fut_upg.as_pin_mut() {
+            let upgrade = ready!(fut
+                .poll(cx)
+                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
+            this = self.as_mut().project();
+            *this.upgrade = Some(upgrade);
+            this.fut_ex.set(None);
+        }
+
+        let result = ready!(this
+            .fut
+            .poll(cx)
+            .map_err(|e| log::error!("Init http service error: {:?}", e)));
+
+        Poll::Ready(result.map(|service| {
+            let this = self.as_mut().project();
+
+            H1ServiceHandler::new(
+                this.cfg.take().unwrap(),
                 service,
-                expect,
-                upgrade,
-                on_connect_ext,
-            ))
-        })
+                this.expect.take().unwrap(),
+                this.upgrade.take(),
+                this.on_connect.clone(),
+                this.on_connect_ext.clone(),
+            )
+        }))
     }
 }
 
 /// `Service` implementation for HTTP/1 transport
-pub type H1ServiceHandler<T, S, B, X, U> = HttpServiceHandler<T, S, B, X, U>;
+pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
+    srv: CloneableService<S>,
+    expect: CloneableService<X>,
+    upgrade: Option<CloneableService<U>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
+    cfg: ServiceConfig,
+    _t: PhantomData<(T, B)>,
+}
 
-impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
-    for HttpServiceHandler<T, S, B, X, U>
+impl<T, S, B, X, U> H1ServiceHandler<T, S, B, X, U>
+where
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    fn new(
+        cfg: ServiceConfig,
+        srv: S,
+        expect: X,
+        upgrade: Option<U>,
+        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
+    ) -> H1ServiceHandler<T, S, B, X, U> {
+        H1ServiceHandler {
+            srv: CloneableService::new(srv),
+            expect: CloneableService::new(expect),
+            upgrade: upgrade.map(CloneableService::new),
+            cfg,
+            on_connect,
+            on_connect_ext,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, S, B, X, U> Service for H1ServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
-
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
-
-    X: Service<Request, Response = Request>,
-    X::Error: Into<Response<AnyBody>>,
-
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display + Into<Error>,
 {
+    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type Future = Dispatcher<T, S, B, X, U>;
 
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self._poll_ready(cx).map_err(|e| {
-            log::error!("HTTP/1 service readiness error: {:?}", e);
-            DispatchError::Service(e)
-        })
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let ready = self
+            .expect
+            .poll_ready(cx)
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready();
+
+        let ready = self
+            .srv
+            .poll_ready(cx)
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready()
+            && ready;
+
+        let ready = if let Some(ref mut upg) = self.upgrade {
+            upg.poll_ready(cx)
+                .map_err(|e| {
+                    let e = e.into();
+                    log::error!("Http service readiness error: {:?}", e);
+                    DispatchError::Service(e)
+                })?
+                .is_ready()
+                && ready
+        } else {
+            ready
+        };
+
+        if ready {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
     }
 
-    fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
+    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
+        let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
+
+        let mut connect_extensions = Extensions::new();
+        if let Some(ref handler) = self.on_connect_ext {
+            // run on_connect_ext callback, populating connect extensions
+            handler(&io, &mut connect_extensions);
+        }
 
         Dispatcher::new(
             io,
             self.cfg.clone(),
-            self.flow.clone(),
-            on_connect_data,
+            self.srv.clone(),
+            self.expect.clone(),
+            self.upgrade.clone(),
+            deprecated_on_connect,
+            connect_extensions,
             addr,
         )
     }
 }
+
+/// `ServiceFactory` implementation for `OneRequestService` service
+#[derive(Default)]
+pub struct OneRequest<T> {
+    config: ServiceConfig,
+    _t: PhantomData<T>,
+}
+
+impl<T> OneRequest<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    /// Create new `H1SimpleService` instance.
+    pub fn new() -> Self {
+        OneRequest {
+            config: ServiceConfig::default(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> ServiceFactory for OneRequest<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Config = ();
+    type Request = T;
+    type Response = (Request, Framed<T, Codec>);
+    type Error = ParseError;
+    type InitError = ();
+    type Service = OneRequestService<T>;
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(OneRequestService {
+            _t: PhantomData,
+            config: self.config.clone(),
+        })
+    }
+}
+
+/// `Service` implementation for HTTP1 transport. Reads one request and returns
+/// request and framed object.
+pub struct OneRequestService<T> {
+    _t: PhantomData<T>,
+    config: ServiceConfig,
+}
+
+impl<T> Service for OneRequestService<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Request = T;
+    type Response = (Request, Framed<T, Codec>);
+    type Error = ParseError;
+    type Future = OneRequestServiceResponse<T>;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        OneRequestServiceResponse {
+            framed: Some(Framed::new(req, Codec::new(self.config.clone()))),
+        }
+    }
+}
+
+#[doc(hidden)]
+#[pin_project::pin_project]
+pub struct OneRequestServiceResponse<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    #[pin]
+    framed: Option<Framed<T, Codec>>,
+}
+
+impl<T> Future for OneRequestServiceResponse<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Output = Result<(Request, Framed<T, Codec>), ParseError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.as_mut().project();
+
+        match ready!(this.framed.as_pin_mut().unwrap().next_item(cx)) {
+            Some(Ok(req)) => match req {
+                Message::Item(req) => {
+                    let mut this = self.as_mut().project();
+                    Poll::Ready(Ok((req, this.framed.take().unwrap())))
+                }
+                Message::Chunk(_) => unreachable!("Something is wrong"),
+            },
+            Some(Err(err)) => Poll::Ready(Err(err)),
+            None => Poll::Ready(Err(ParseError::Incomplete)),
+        }
+    }
+}

actix-http/src/h1/upgrade.rs

@@ -1,34 +1,41 @@
+use std::marker::PhantomData;
+use std::task::{Context, Poll};
+
 use actix_codec::Framed;
 use actix_service::{Service, ServiceFactory};
-use futures_core::future::LocalBoxFuture;
+use futures_util::future::Ready;
 
 use crate::error::Error;
 use crate::h1::Codec;
 use crate::request::Request;
 
-pub struct UpgradeHandler;
+pub struct UpgradeHandler<T>(PhantomData<T>);
 
-impl<T> ServiceFactory<(Request, Framed<T, Codec>)> for UpgradeHandler {
+impl<T> ServiceFactory for UpgradeHandler<T> {
+    type Config = ();
+    type Request = (Request, Framed<T, Codec>);
     type Response = ();
     type Error = Error;
-    type Config = ();
-    type Service = UpgradeHandler;
+    type Service = UpgradeHandler<T>;
     type InitError = Error;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
         unimplemented!()
     }
 }
 
-impl<T> Service<(Request, Framed<T, Codec>)> for UpgradeHandler {
+impl<T> Service for UpgradeHandler<T> {
+    type Request = (Request, Framed<T, Codec>);
     type Response = ();
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+    type Future = Ready<Result<Self::Response, Self::Error>>;
 
-    actix_service::always_ready!();
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
 
-    fn call(&self, _: (Request, Framed<T, Codec>)) -> Self::Future {
+    fn call(&mut self, _: Self::Request) -> Self::Future {
         unimplemented!()
     }
 }

actix-http/src/h1/utils.rs

@@ -4,7 +4,7 @@ use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 
-use crate::body::{BodySize, MessageBody};
+use crate::body::{BodySize, MessageBody, ResponseBody};
 use crate::error::Error;
 use crate::h1::{Codec, Message};
 use crate::response::Response;
@@ -14,7 +14,7 @@ use crate::response::Response;
 pub struct SendResponse<T, B> {
     res: Option<Message<(Response<()>, BodySize)>>,
     #[pin]
-    body: Option<B>,
+    body: Option<ResponseBody<B>>,
     #[pin]
     framed: Option<Framed<T, Codec>>,
 }
@@ -22,7 +22,6 @@ pub struct SendResponse<T, B> {
 impl<T, B> SendResponse<T, B>
 where
     B: MessageBody,
-    B::Error: Into<Error>,
 {
     pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
         let (res, body) = response.into_parts();
@@ -39,7 +38,6 @@ impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     B: MessageBody + Unpin,
-    B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
 
@@ -62,17 +60,7 @@ where
                         .unwrap()
                         .is_write_buf_full()
                 {
-                    let next =
-                        match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
-                            Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
-                            Poll::Ready(Some(Err(err))) => {
-                                return Poll::Ready(Err(err.into()))
-                            }
-                            Poll::Ready(None) => Poll::Ready(None),
-                            Poll::Pending => Poll::Pending,
-                        };
-
-                    match next {
+                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
                         Poll::Ready(item) => {
                             // body is done when item is None
                             body_done = item.is_none();
@@ -80,9 +68,7 @@ where
                                 let _ = this.body.take();
                             }
                             let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                            framed.write(Message::Chunk(item)).map_err(|err| {
-                                Error::new_send_response().with_cause(err)
-                            })?;
+                            framed.write(Message::Chunk(item))?;
                         }
                         Poll::Pending => body_ready = false,
                     }
@@ -93,10 +79,7 @@ where
 
             // flush write buffer
             if !framed.is_write_buf_empty() {
-                match framed
-                    .flush(cx)
-                    .map_err(|err| Error::new_send_response().with_cause(err))?
-                {
+                match framed.flush(cx)? {
                     Poll::Ready(_) => {
                         if body_ready {
                             continue;
@@ -110,9 +93,7 @@ where
 
             // send response
             if let Some(res) = this.res.take() {
-                framed
-                    .write(res)
-                    .map_err(|err| Error::new_send_response().with_cause(err))?;
+                framed.write(res)?;
                 continue;
             }
 

actix-http/src/h2/dispatcher.rs

@@ -1,269 +1,371 @@
-use std::{
-    cmp,
-    error::Error as StdError,
-    future::Future,
-    marker::PhantomData,
-    net,
-    pin::Pin,
-    rc::Rc,
-    task::{Context, Poll},
-};
+use std::convert::TryFrom;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::net;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::time::{Delay, Instant};
 use actix_service::Service;
-use actix_utils::future::poll_fn;
 use bytes::{Bytes, BytesMut};
-use futures_core::ready;
 use h2::server::{Connection, SendResponse};
+use h2::SendStream;
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
 use log::{error, trace};
-use pin_project_lite::pin_project;
 
-use crate::{
-    body::{AnyBody, BodySize, MessageBody},
-    config::ServiceConfig,
-    service::HttpFlow,
-    OnConnectData, Payload, Request, Response, ResponseHead,
-};
+use crate::body::{BodySize, MessageBody, ResponseBody};
+use crate::cloneable::CloneableService;
+use crate::config::ServiceConfig;
+use crate::error::{DispatchError, Error};
+use crate::helpers::DataFactory;
+use crate::httpmessage::HttpMessage;
+use crate::message::ResponseHead;
+use crate::payload::Payload;
+use crate::request::Request;
+use crate::response::Response;
+use crate::Extensions;
 
 const CHUNK_SIZE: usize = 16_384;
 
-pin_project! {
-    /// Dispatcher for HTTP/2 protocol.
-    pub struct Dispatcher<T, S, B, X, U> {
-        flow: Rc<HttpFlow<S, X, U>>,
-        connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
-        config: ServiceConfig,
-        peer_addr: Option<net::SocketAddr>,
-        _phantom: PhantomData<B>,
-    }
+/// Dispatcher for HTTP/2 protocol
+#[pin_project::pin_project]
+pub struct Dispatcher<T, S: Service<Request = Request>, B: MessageBody>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    service: CloneableService<S>,
+    connection: Connection<T, Bytes>,
+    on_connect: Option<Box<dyn DataFactory>>,
+    on_connect_data: Extensions,
+    config: ServiceConfig,
+    peer_addr: Option<net::SocketAddr>,
+    ka_expire: Instant,
+    ka_timer: Option<Delay>,
+    _t: PhantomData<B>,
 }
 
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U> {
+impl<T, S, B> Dispatcher<T, S, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    // S::Future: 'static,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
     pub(crate) fn new(
-        flow: Rc<HttpFlow<S, X, U>>,
+        service: CloneableService<S>,
         connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
+        on_connect: Option<Box<dyn DataFactory>>,
+        on_connect_data: Extensions,
         config: ServiceConfig,
+        timeout: Option<Delay>,
         peer_addr: Option<net::SocketAddr>,
     ) -> Self {
-        Self {
-            flow,
+        // let keepalive = config.keep_alive_enabled();
+        // let flags = if keepalive {
+        // Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
+        // } else {
+        //     Flags::empty()
+        // };
+
+        // keep-alive timer
+        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
+            (delay.deadline(), Some(delay))
+        } else if let Some(delay) = config.keep_alive_timer() {
+            (delay.deadline(), Some(delay))
+        } else {
+            (config.now(), None)
+        };
+
+        Dispatcher {
+            service,
             config,
             peer_addr,
             connection,
+            on_connect,
             on_connect_data,
-            _phantom: PhantomData,
+            ka_expire,
+            ka_timer,
+            _t: PhantomData,
         }
     }
 }
 
-impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
+impl<T, S, B> Future for Dispatcher<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
+    S: Service<Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Future: 'static,
-    S::Response: Into<Response<B>>,
-
-    B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
+    S::Response: Into<Response<B>> + 'static,
+    B: MessageBody + 'static,
 {
-    type Output = Result<(), crate::error::DispatchError>;
+    type Output = Result<(), DispatchError>;
 
     #[inline]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
-        while let Some((req, tx)) =
-            ready!(Pin::new(&mut this.connection).poll_accept(cx)?)
-        {
-            let (parts, body) = req.into_parts();
-            let pl = crate::h2::Payload::new(body);
-            let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
-            let mut req = Request::with_payload(pl);
-
-            let head = req.head_mut();
-            head.uri = parts.uri;
-            head.method = parts.method;
-            head.version = parts.version;
-            head.headers = parts.headers.into();
-            head.peer_addr = this.peer_addr;
-
-            // merge on_connect_ext data into request extensions
-            this.on_connect_data.merge_into(&mut req);
-
-            let fut = this.flow.service.call(req);
-            let config = this.config.clone();
-
-            // multiplex request handling with spawn task
-            actix_rt::spawn(async move {
-                // resolve service call and send response.
-                let res = match fut.await {
-                    Ok(res) => handle_response(res.into(), tx, config).await,
-                    Err(err) => {
-                        let res: Response<AnyBody> = err.into();
-                        handle_response(res, tx, config).await
-                    }
-                };
-
-                // log error.
-                if let Err(err) = res {
-                    match err {
-                        DispatchError::SendResponse(err) => {
-                            trace!("Error sending HTTP/2 response: {:?}", err)
-                        }
-                        DispatchError::SendData(err) => warn!("{:?}", err),
-                        DispatchError::ResponseBody(err) => {
-                            error!("Response payload stream error: {:?}", err)
+        loop {
+            match Pin::new(&mut this.connection).poll_accept(cx) {
+                Poll::Ready(None) => return Poll::Ready(Ok(())),
+                Poll::Ready(Some(Err(err))) => return Poll::Ready(Err(err.into())),
+                Poll::Ready(Some(Ok((req, res)))) => {
+                    // update keep-alive expire
+                    if this.ka_timer.is_some() {
+                        if let Some(expire) = this.config.keep_alive_expire() {
+                            this.ka_expire = expire;
                         }
                     }
+
+                    let (parts, body) = req.into_parts();
+                    let mut req = Request::with_payload(Payload::<
+                        crate::payload::PayloadStream,
+                    >::H2(
+                        crate::h2::Payload::new(body)
+                    ));
+
+                    let head = &mut req.head_mut();
+                    head.uri = parts.uri;
+                    head.method = parts.method;
+                    head.version = parts.version;
+                    head.headers = parts.headers.into();
+                    head.peer_addr = this.peer_addr;
+
+                    // DEPRECATED
+                    // set on_connect data
+                    if let Some(ref on_connect) = this.on_connect {
+                        on_connect.set(&mut req.extensions_mut());
+                    }
+
+                    // merge on_connect_ext data into request extensions
+                    req.extensions_mut().drain_from(&mut this.on_connect_data);
+
+                    actix_rt::spawn(ServiceResponse::<
+                        S::Future,
+                        S::Response,
+                        S::Error,
+                        B,
+                    > {
+                        state: ServiceResponseState::ServiceCall(
+                            this.service.call(req),
+                            Some(res),
+                        ),
+                        config: this.config.clone(),
+                        buffer: None,
+                        _t: PhantomData,
+                    });
                 }
-            });
+                Poll::Pending => return Poll::Pending,
+            }
+        }
+    }
+}
+
+#[pin_project::pin_project]
+struct ServiceResponse<F, I, E, B> {
+    #[pin]
+    state: ServiceResponseState<F, B>,
+    config: ServiceConfig,
+    buffer: Option<Bytes>,
+    _t: PhantomData<(I, E)>,
+}
+
+#[pin_project::pin_project(project = ServiceResponseStateProj)]
+enum ServiceResponseState<F, B> {
+    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
+    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
+}
+
+impl<F, I, E, B> ServiceResponse<F, I, E, B>
+where
+    F: Future<Output = Result<I, E>>,
+    E: Into<Error>,
+    I: Into<Response<B>>,
+    B: MessageBody,
+{
+    fn prepare_response(
+        &self,
+        head: &ResponseHead,
+        size: &mut BodySize,
+    ) -> http::Response<()> {
+        let mut has_date = false;
+        let mut skip_len = size != &BodySize::Stream;
+
+        let mut res = http::Response::new(());
+        *res.status_mut() = head.status;
+        *res.version_mut() = http::Version::HTTP_2;
+
+        // Content length
+        match head.status {
+            http::StatusCode::NO_CONTENT
+            | http::StatusCode::CONTINUE
+            | http::StatusCode::PROCESSING => *size = BodySize::None,
+            http::StatusCode::SWITCHING_PROTOCOLS => {
+                skip_len = true;
+                *size = BodySize::Stream;
+            }
+            _ => (),
+        }
+        let _ = match size {
+            BodySize::None | BodySize::Stream => None,
+            BodySize::Empty => res
+                .headers_mut()
+                .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+            BodySize::Sized(len) => res.headers_mut().insert(
+                CONTENT_LENGTH,
+                HeaderValue::try_from(format!("{}", len)).unwrap(),
+            ),
+        };
+
+        // copy headers
+        for (key, value) in head.headers.iter() {
+            match *key {
+                CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
+                CONTENT_LENGTH if skip_len => continue,
+                DATE => has_date = true,
+                _ => (),
+            }
+            res.headers_mut().append(key, value.clone());
         }
 
-        Poll::Ready(Ok(()))
+        // set date header
+        if !has_date {
+            let mut bytes = BytesMut::with_capacity(29);
+            self.config.set_date_header(&mut bytes);
+            res.headers_mut().insert(
+                DATE,
+                // SAFETY: serialized date-times are known ASCII strings
+                unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
+            );
+        }
+
+        res
     }
 }
 
-enum DispatchError {
-    SendResponse(h2::Error),
-    SendData(h2::Error),
-    ResponseBody(Box<dyn StdError>),
-}
-
-async fn handle_response<B>(
-    res: Response<B>,
-    mut tx: SendResponse<Bytes>,
-    config: ServiceConfig,
-) -> Result<(), DispatchError>
+impl<F, I, E, B> Future for ServiceResponse<F, I, E, B>
 where
+    F: Future<Output = Result<I, E>>,
+    E: Into<Error>,
+    I: Into<Response<B>>,
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 {
-    let (res, body) = res.replace_body(());
+    type Output = ();
 
-    // prepare response.
-    let mut size = body.size();
-    let res = prepare_response(config, res.head(), &mut size);
-    let eof = size.is_eof();
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
 
-    // send response head and return on eof.
-    let mut stream = tx
-        .send_response(res, eof)
-        .map_err(DispatchError::SendResponse)?;
+        match this.state.project() {
+            ServiceResponseStateProj::ServiceCall(call, send) => match call.poll(cx) {
+                Poll::Ready(Ok(res)) => {
+                    let (res, body) = res.into().replace_body(());
 
-    if eof {
-        return Ok(());
-    }
+                    let mut send = send.take().unwrap();
+                    let mut size = body.size();
+                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
+                    this = self.as_mut().project();
 
-    // poll response body and send chunks to client.
-    actix_rt::pin!(body);
+                    let stream = match send.send_response(h2_res, size.is_eof()) {
+                        Err(e) => {
+                            trace!("Error sending h2 response: {:?}", e);
+                            return Poll::Ready(());
+                        }
+                        Ok(stream) => stream,
+                    };
 
-    while let Some(res) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-        let mut chunk = res.map_err(|err| DispatchError::ResponseBody(err.into()))?;
+                    if size.is_eof() {
+                        Poll::Ready(())
+                    } else {
+                        this.state
+                            .set(ServiceResponseState::SendPayload(stream, body));
+                        self.poll(cx)
+                    }
+                }
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => {
+                    let res: Response = e.into().into();
+                    let (res, body) = res.replace_body(());
 
-        'send: loop {
-            // reserve enough space and wait for stream ready.
-            stream.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
+                    let mut send = send.take().unwrap();
+                    let mut size = body.size();
+                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
+                    this = self.as_mut().project();
 
-            match poll_fn(|cx| stream.poll_capacity(cx)).await {
-                // No capacity left. drop body and return.
-                None => return Ok(()),
-                Some(res) => {
-                    // Split chuck to writeable size and send to client.
-                    let cap = res.map_err(DispatchError::SendData)?;
+                    let stream = match send.send_response(h2_res, size.is_eof()) {
+                        Err(e) => {
+                            trace!("Error sending h2 response: {:?}", e);
+                            return Poll::Ready(());
+                        }
+                        Ok(stream) => stream,
+                    };
 
-                    let len = chunk.len();
-                    let bytes = chunk.split_to(cmp::min(cap, len));
+                    if size.is_eof() {
+                        Poll::Ready(())
+                    } else {
+                        this.state.set(ServiceResponseState::SendPayload(
+                            stream,
+                            body.into_body(),
+                        ));
+                        self.poll(cx)
+                    }
+                }
+            },
+            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
+                loop {
+                    loop {
+                        if let Some(ref mut buffer) = this.buffer {
+                            match stream.poll_capacity(cx) {
+                                Poll::Pending => return Poll::Pending,
+                                Poll::Ready(None) => return Poll::Ready(()),
+                                Poll::Ready(Some(Ok(cap))) => {
+                                    let len = buffer.len();
+                                    let bytes = buffer.split_to(std::cmp::min(cap, len));
 
-                    stream
-                        .send_data(bytes, false)
-                        .map_err(DispatchError::SendData)?;
-
-                    // Current chuck completely sent. break send loop and poll next one.
-                    if chunk.is_empty() {
-                        break 'send;
+                                    if let Err(e) = stream.send_data(bytes, false) {
+                                        warn!("{:?}", e);
+                                        return Poll::Ready(());
+                                    } else if !buffer.is_empty() {
+                                        let cap =
+                                            std::cmp::min(buffer.len(), CHUNK_SIZE);
+                                        stream.reserve_capacity(cap);
+                                    } else {
+                                        this.buffer.take();
+                                    }
+                                }
+                                Poll::Ready(Some(Err(e))) => {
+                                    warn!("{:?}", e);
+                                    return Poll::Ready(());
+                                }
+                            }
+                        } else {
+                            match body.as_mut().poll_next(cx) {
+                                Poll::Pending => return Poll::Pending,
+                                Poll::Ready(None) => {
+                                    if let Err(e) = stream.send_data(Bytes::new(), true)
+                                    {
+                                        warn!("{:?}", e);
+                                    }
+                                    return Poll::Ready(());
+                                }
+                                Poll::Ready(Some(Ok(chunk))) => {
+                                    stream.reserve_capacity(std::cmp::min(
+                                        chunk.len(),
+                                        CHUNK_SIZE,
+                                    ));
+                                    *this.buffer = Some(chunk);
+                                }
+                                Poll::Ready(Some(Err(e))) => {
+                                    error!("Response payload stream error: {:?}", e);
+                                    return Poll::Ready(());
+                                }
+                            }
+                        }
                     }
                 }
             }
         }
     }
-
-    // response body streaming finished. send end of stream and return.
-    stream
-        .send_data(Bytes::new(), true)
-        .map_err(DispatchError::SendData)?;
-
-    Ok(())
-}
-
-fn prepare_response(
-    config: ServiceConfig,
-    head: &ResponseHead,
-    size: &mut BodySize,
-) -> http::Response<()> {
-    let mut has_date = false;
-    let mut skip_len = size != &BodySize::Stream;
-
-    let mut res = http::Response::new(());
-    *res.status_mut() = head.status;
-    *res.version_mut() = http::Version::HTTP_2;
-
-    // Content length
-    match head.status {
-        http::StatusCode::NO_CONTENT
-        | http::StatusCode::CONTINUE
-        | http::StatusCode::PROCESSING => *size = BodySize::None,
-        http::StatusCode::SWITCHING_PROTOCOLS => {
-            skip_len = true;
-            *size = BodySize::Stream;
-        }
-        _ => {}
-    }
-
-    let _ = match size {
-        BodySize::None | BodySize::Stream => None,
-        BodySize::Empty => res
-            .headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-        BodySize::Sized(len) => {
-            let mut buf = itoa::Buffer::new();
-
-            res.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::from_str(buf.format(*len)).unwrap(),
-            )
-        }
-    };
-
-    // copy headers
-    for (key, value) in head.headers.iter() {
-        match *key {
-            // TODO: consider skipping other headers according to:
-            //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
-            // omit HTTP/1.x only headers
-            CONNECTION | TRANSFER_ENCODING => continue,
-            CONTENT_LENGTH if skip_len => continue,
-            DATE => has_date = true,
-            _ => {}
-        }
-
-        res.headers_mut().append(key, value.clone());
-    }
-
-    // set date header
-    if !has_date {
-        let mut bytes = BytesMut::with_capacity(29);
-        config.set_date_header(&mut bytes);
-        res.headers_mut().insert(
-            DATE,
-            // SAFETY: serialized date-times are known ASCII strings
-            unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
-        );
-    }
-
-    res
 }

actix-http/src/h2/mod.rs

@@ -1,12 +1,9 @@
-//! HTTP/2 protocol.
-
-use std::{
-    pin::Pin,
-    task::{Context, Poll},
-};
+//! HTTP/2 implementation
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
 use bytes::Bytes;
-use futures_core::{ready, Stream};
+use futures_core::Stream;
 use h2::RecvStream;
 
 mod dispatcher;
@@ -16,14 +13,14 @@ pub use self::dispatcher::Dispatcher;
 pub use self::service::H2Service;
 use crate::error::PayloadError;
 
-/// HTTP/2 peer stream.
+/// H2 receive stream
 pub struct Payload {
-    stream: RecvStream,
+    pl: RecvStream,
 }
 
 impl Payload {
-    pub(crate) fn new(stream: RecvStream) -> Self {
-        Self { stream }
+    pub(crate) fn new(pl: RecvStream) -> Self {
+        Self { pl }
     }
 }
 
@@ -36,17 +33,18 @@ impl Stream for Payload {
     ) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
 
-        match ready!(Pin::new(&mut this.stream).poll_data(cx)) {
-            Some(Ok(chunk)) => {
+        match Pin::new(&mut this.pl).poll_data(cx) {
+            Poll::Ready(Some(Ok(chunk))) => {
                 let len = chunk.len();
-
-                match this.stream.flow_control().release_capacity(len) {
-                    Ok(()) => Poll::Ready(Some(Ok(chunk))),
-                    Err(err) => Poll::Ready(Some(Err(err.into()))),
+                if let Err(err) = this.pl.flow_control().release_capacity(len) {
+                    Poll::Ready(Some(Err(err.into())))
+                } else {
+                    Poll::Ready(Some(Ok(chunk)))
                 }
             }
-            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-            None => Poll::Ready(None),
+            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err.into()))),
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(None) => Poll::Ready(None),
         }
     }
 }

actix-http/src/h2/service.rs

@@ -1,66 +1,73 @@
-use std::{
-    error::Error as StdError,
-    future::Future,
-    marker::PhantomData,
-    net,
-    pin::Pin,
-    rc::Rc,
-    task::{Context, Poll},
-};
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{net, rc::Rc};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
 use actix_service::{
-    fn_factory, fn_service, IntoServiceFactory, Service, ServiceFactory,
-    ServiceFactoryExt as _,
+    fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
+    ServiceFactory,
 };
-use actix_utils::future::ready;
 use bytes::Bytes;
-use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
+use futures_core::ready;
+use futures_util::future::ok;
+use h2::server::{self, Handshake};
 use log::error;
 
-use crate::{
-    body::{AnyBody, MessageBody},
-    config::ServiceConfig,
-    error::DispatchError,
-    service::HttpFlow,
-    ConnectCallback, OnConnectData, Request, Response,
-};
+use crate::body::MessageBody;
+use crate::cloneable::CloneableService;
+use crate::config::ServiceConfig;
+use crate::error::{DispatchError, Error};
+use crate::helpers::DataFactory;
+use crate::request::Request;
+use crate::response::Response;
+use crate::{ConnectCallback, Extensions};
 
 use super::dispatcher::Dispatcher;
 
-/// `ServiceFactory` implementation for HTTP/2 transport
+/// `ServiceFactory` implementation for HTTP2 transport
 pub struct H2Service<T, S, B> {
     srv: S,
     cfg: ServiceConfig,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<(T, B)>,
+    _t: PhantomData<(T, B)>,
 }
 
 impl<T, S, B> H2Service<T, S, B>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-
+    <S::Service as Service>::Future: 'static,
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
-    /// Create new `H2Service` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
+    /// Create new `HttpService` instance with config.
+    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
         cfg: ServiceConfig,
         service: F,
     ) -> Self {
         H2Service {
             cfg,
+            on_connect: None,
             on_connect_ext: None,
             srv: service.into_factory(),
-            _phantom: PhantomData,
+            _t: PhantomData,
         }
     }
 
+    /// Set on connect callback.
+
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
+
     /// Set on connect callback.
     pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
         self.on_connect_ext = f;
@@ -70,77 +77,71 @@ where
 
 impl<S, B> H2Service<TcpStream, S, B>
 where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Future: 'static,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-
+    <S::Service as Service>::Future: 'static,
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
-    /// Create plain TCP based service
+    /// Create simple tcp based service
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
-        TcpStream,
         Config = (),
+        Request = TcpStream,
         Response = (),
         Error = DispatchError,
         InitError = S::InitError,
     > {
-        fn_factory(|| {
-            ready(Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
+        pipeline_factory(fn_factory(|| async {
+            Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
                 let peer_addr = io.peer_addr().ok();
-                ready(Ok::<_, DispatchError>((io, peer_addr)))
-            })))
-        })
+                ok::<_, DispatchError>((io, peer_addr))
+            }))
+        }))
         .and_then(self)
     }
 }
 
 #[cfg(feature = "openssl")]
 mod openssl {
-    use actix_service::{fn_factory, fn_service, ServiceFactoryExt};
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, TlsStream};
-    use actix_tls::accept::TlsError;
+    use actix_service::{fn_factory, fn_service};
+    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
+    use actix_tls::{openssl::HandshakeError, TlsError};
 
     use super::*;
 
-    impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
+    impl<S, B> H2Service<SslStream<TcpStream>, S, B>
     where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Future: 'static,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S: ServiceFactory<Config = (), Request = Request>,
+        S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::Future: 'static,
-
+        <S::Service as Service>::Future: 'static,
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
-        /// Create OpenSSL based service
+        /// Create ssl based service
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
         ) -> impl ServiceFactory<
-            TcpStream,
             Config = (),
+            Request = TcpStream,
             Response = (),
-            Error = TlsError<SslError, DispatchError>,
+            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
             InitError = S::InitError,
         > {
-            Acceptor::new(acceptor)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(fn_factory(|| {
-                    ready(Ok::<_, S::InitError>(fn_service(
-                        |io: TlsStream<TcpStream>| {
-                            let peer_addr = io.get_ref().peer_addr().ok();
-                            ready(Ok((io, peer_addr)))
-                        },
-                    )))
+            pipeline_factory(
+                Acceptor::new(acceptor)
+                    .map_err(TlsError::Tls)
+                    .map_init_err(|_| panic!()),
+            )
+            .and_then(fn_factory(|| {
+                ok::<_, S::InitError>(fn_service(|io: SslStream<TcpStream>| {
+                    let peer_addr = io.get_ref().peer_addr().ok();
+                    ok((io, peer_addr))
                 }))
-                .and_then(self.map_err(TlsError::Service))
+            }))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -148,176 +149,211 @@ mod openssl {
 #[cfg(feature = "rustls")]
 mod rustls {
     use super::*;
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::accept::TlsError;
+    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
+    use actix_tls::TlsError;
     use std::io;
 
     impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
     where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Future: 'static,
-        S::Error: Into<Response<AnyBody>> + 'static,
+        S: ServiceFactory<Config = (), Request = Request>,
+        S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::Future: 'static,
-
+        <S::Service as Service>::Future: 'static,
         B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
     {
-        /// Create Rustls based service
+        /// Create openssl based service
         pub fn rustls(
             self,
             mut config: ServerConfig,
         ) -> impl ServiceFactory<
-            TcpStream,
             Config = (),
+            Request = TcpStream,
             Response = (),
             Error = TlsError<io::Error, DispatchError>,
             InitError = S::InitError,
         > {
-            let mut protos = vec![b"h2".to_vec()];
-            protos.extend_from_slice(&config.alpn_protocols);
-            config.alpn_protocols = protos;
+            let protos = vec!["h2".to_string().into()];
+            config.set_protocols(&protos);
 
-            Acceptor::new(config)
-                .map_err(TlsError::Tls)
-                .map_init_err(|_| panic!())
-                .and_then(fn_factory(|| {
-                    ready(Ok::<_, S::InitError>(fn_service(
-                        |io: TlsStream<TcpStream>| {
-                            let peer_addr = io.get_ref().0.peer_addr().ok();
-                            ready(Ok((io, peer_addr)))
-                        },
-                    )))
+            pipeline_factory(
+                Acceptor::new(config)
+                    .map_err(TlsError::Tls)
+                    .map_init_err(|_| panic!()),
+            )
+            .and_then(fn_factory(|| {
+                ok::<_, S::InitError>(fn_service(|io: TlsStream<TcpStream>| {
+                    let peer_addr = io.get_ref().0.peer_addr().ok();
+                    ok((io, peer_addr))
                 }))
-                .and_then(self.map_err(TlsError::Service))
+            }))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
 
-impl<T, S, B> ServiceFactory<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
+impl<T, S, B> ServiceFactory for H2Service<T, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-
-    S: ServiceFactory<Request, Config = ()>,
-    S::Future: 'static,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-
+    <S::Service as Service>::Future: 'static,
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
+    type Config = ();
+    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
-    type Config = ();
-    type Service = H2ServiceHandler<T, S::Service, B>;
     type InitError = S::InitError;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+    type Service = H2ServiceHandler<T, S::Service, B>;
+    type Future = H2ServiceResponse<T, S, B>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        let service = self.srv.new_service(());
-        let cfg = self.cfg.clone();
-        let on_connect_ext = self.on_connect_ext.clone();
-
-        Box::pin(async move {
-            let service = service.await?;
-            Ok(H2ServiceHandler::new(cfg, on_connect_ext, service))
-        })
+        H2ServiceResponse {
+            fut: self.srv.new_service(()),
+            cfg: Some(self.cfg.clone()),
+            on_connect: self.on_connect.clone(),
+            on_connect_ext: self.on_connect_ext.clone(),
+            _t: PhantomData,
+        }
     }
 }
 
-/// `Service` implementation for HTTP/2 transport
-pub struct H2ServiceHandler<T, S, B>
-where
-    S: Service<Request>,
-{
-    flow: Rc<HttpFlow<S, (), ()>>,
-    cfg: ServiceConfig,
+#[doc(hidden)]
+#[pin_project::pin_project]
+pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
+    #[pin]
+    fut: S::Future,
+    cfg: Option<ServiceConfig>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
+    _t: PhantomData<(T, B)>,
+}
+
+impl<T, S, B> Future for H2ServiceResponse<T, S, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: ServiceFactory<Config = (), Request = Request>,
+    S::Error: Into<Error> + 'static,
+    S::Response: Into<Response<B>> + 'static,
+    <S::Service as Service>::Future: 'static,
+    B: MessageBody + 'static,
+{
+    type Output = Result<H2ServiceHandler<T, S::Service, B>, S::InitError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.as_mut().project();
+
+        Poll::Ready(ready!(this.fut.poll(cx)).map(|service| {
+            let this = self.as_mut().project();
+            H2ServiceHandler::new(
+                this.cfg.take().unwrap(),
+                this.on_connect.clone(),
+                this.on_connect_ext.clone(),
+                service,
+            )
+        }))
+    }
+}
+
+/// `Service` implementation for http/2 transport
+pub struct H2ServiceHandler<T, S: Service, B> {
+    srv: CloneableService<S>,
+    cfg: ServiceConfig,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
+    _t: PhantomData<(T, B)>,
 }
 
 impl<T, S, B> H2ServiceHandler<T, S, B>
 where
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: Service<Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
 {
     fn new(
         cfg: ServiceConfig,
+        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
         on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-        service: S,
+        srv: S,
     ) -> H2ServiceHandler<T, S, B> {
         H2ServiceHandler {
-            flow: HttpFlow::new(service, (), None),
             cfg,
+            on_connect,
             on_connect_ext,
-            _phantom: PhantomData,
+            srv: CloneableService::new(srv),
+            _t: PhantomData,
         }
     }
 }
 
-impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B>
+impl<T, S, B> Service for H2ServiceHandler<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: Service<Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    B::Error: Into<Box<dyn StdError>>,
 {
+    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type Future = H2ServiceHandlerResponse<T, S, B>;
 
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.flow.service.poll_ready(cx).map_err(|e| {
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.srv.poll_ready(cx).map_err(|e| {
             let e = e.into();
             error!("Service readiness error: {:?}", e);
             DispatchError::Service(e)
         })
     }
 
-    fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
+    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
+        let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
+
+        let mut connect_extensions = Extensions::new();
+        if let Some(ref handler) = self.on_connect_ext {
+            // run on_connect_ext callback, populating connect extensions
+            handler(&io, &mut connect_extensions);
+        }
 
         H2ServiceHandlerResponse {
             state: State::Handshake(
-                Some(self.flow.clone()),
+                Some(self.srv.clone()),
                 Some(self.cfg.clone()),
                 addr,
-                on_connect_data,
-                h2_handshake(io),
+                deprecated_on_connect,
+                Some(connect_extensions),
+                server::handshake(io),
             ),
         }
     }
 }
 
-enum State<T, S: Service<Request>, B: MessageBody>
+enum State<T, S: Service<Request = Request>, B: MessageBody>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S::Future: 'static,
 {
-    Incoming(Dispatcher<T, S, B, (), ()>),
+    Incoming(Dispatcher<T, S, B>),
     Handshake(
-        Option<Rc<HttpFlow<S, (), ()>>>,
+        Option<CloneableService<S>>,
         Option<ServiceConfig>,
         Option<net::SocketAddr>,
-        OnConnectData,
-        H2Handshake<T, Bytes>,
+        Option<Box<dyn DataFactory>>,
+        Option<Extensions>,
+        Handshake<T, Bytes>,
     ),
 }
 
 pub struct H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: Service<Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
@@ -328,12 +364,11 @@ where
 impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>> + 'static,
+    S: Service<Request = Request>,
+    S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
 {
     type Output = Result<(), DispatchError>;
 
@@ -344,24 +379,27 @@ where
                 ref mut srv,
                 ref mut config,
                 ref peer_addr,
+                ref mut on_connect,
                 ref mut on_connect_data,
                 ref mut handshake,
-            ) => match ready!(Pin::new(handshake).poll(cx)) {
-                Ok(conn) => {
-                    let on_connect_data = std::mem::take(on_connect_data);
+            ) => match Pin::new(handshake).poll(cx) {
+                Poll::Ready(Ok(conn)) => {
                     self.state = State::Incoming(Dispatcher::new(
                         srv.take().unwrap(),
                         conn,
-                        on_connect_data,
+                        on_connect.take(),
+                        on_connect_data.take().unwrap(),
                         config.take().unwrap(),
+                        None,
                         *peer_addr,
                     ));
                     self.poll(cx)
                 }
-                Err(err) => {
+                Poll::Ready(Err(err)) => {
                     trace!("H2 handshake error: {}", err);
                     Poll::Ready(Err(err.into()))
                 }
+                Poll::Pending => Poll::Pending,
             },
         }
     }

actix-http/src/header/as_name.rs

@@ -1,50 +0,0 @@
-//! Helper trait for types that can be effectively borrowed as a [HeaderValue].
-//!
-//! [HeaderValue]: crate::http::HeaderValue
-
-use std::{borrow::Cow, str::FromStr};
-
-use http::header::{HeaderName, InvalidHeaderName};
-
-pub trait AsHeaderName: Sealed {}
-
-pub struct Seal;
-
-pub trait Sealed {
-    fn try_as_name(&self, seal: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName>;
-}
-
-impl Sealed for HeaderName {
-    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
-        Ok(Cow::Borrowed(self))
-    }
-}
-impl AsHeaderName for HeaderName {}
-
-impl Sealed for &HeaderName {
-    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
-        Ok(Cow::Borrowed(*self))
-    }
-}
-impl AsHeaderName for &HeaderName {}
-
-impl Sealed for &str {
-    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
-        HeaderName::from_str(self).map(Cow::Owned)
-    }
-}
-impl AsHeaderName for &str {}
-
-impl Sealed for String {
-    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
-        HeaderName::from_str(self).map(Cow::Owned)
-    }
-}
-impl AsHeaderName for String {}
-
-impl Sealed for &String {
-    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
-        HeaderName::from_str(self).map(Cow::Owned)
-    }
-}
-impl AsHeaderName for &String {}

actix-http/src/header/common/accept.rs

@@ -2,10 +2,10 @@ use std::cmp::Ordering;
 
 use mime::Mime;
 
-use super::{qitem, QualityItem};
+use crate::header::{qitem, QualityItem};
 use crate::http::header;
 
-crate::http::header::common_header! {
+header! {
     /// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
     ///
     /// The `Accept` header field can be used by user agents to specify
@@ -32,36 +32,50 @@ crate::http::header::common_header! {
     /// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
     ///
     /// # Examples
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{Accept, qitem};
+    /// ```rust
+    /// # extern crate actix_http;
+    /// extern crate mime;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{Accept, qitem};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    ///
+    /// builder.set(
     ///     Accept(vec![
     ///         qitem(mime::TEXT_HTML),
     ///     ])
     /// );
+    /// # }
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{Accept, qitem};
+    /// ```rust
+    /// # extern crate actix_http;
+    /// extern crate mime;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{Accept, qitem};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    ///
+    /// builder.set(
     ///     Accept(vec![
     ///         qitem(mime::APPLICATION_JSON),
     ///     ])
     /// );
+    /// # }
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{Accept, QualityItem, q, qitem};
+    /// ```rust
+    /// # extern crate actix_http;
+    /// extern crate mime;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{Accept, QualityItem, q, qitem};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    ///
+    /// builder.set(
     ///     Accept(vec![
     ///         qitem(mime::TEXT_HTML),
     ///         qitem("application/xhtml+xml".parse().unwrap()),
@@ -76,19 +90,20 @@ crate::http::header::common_header! {
     ///         ),
     ///     ])
     /// );
+    /// # }
     /// ```
     (Accept, header::ACCEPT) => (QualityItem<Mime>)+
 
     test_accept {
         // Tests from the RFC
-         crate::http::header::common_header_test!(
+         test_header!(
             test1,
             vec![b"audio/*; q=0.2, audio/basic"],
             Some(Accept(vec![
                 QualityItem::new("audio/*".parse().unwrap(), q(200)),
                 qitem("audio/basic".parse().unwrap()),
                 ])));
-        crate::http::header::common_header_test!(
+        test_header!(
             test2,
             vec![b"text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"],
             Some(Accept(vec![
@@ -100,13 +115,13 @@ crate::http::header::common_header! {
                 qitem("text/x-c".parse().unwrap()),
                 ])));
         // Custom tests
-        crate::http::header::common_header_test!(
+        test_header!(
             test3,
             vec![b"text/plain; charset=utf-8"],
             Some(Accept(vec![
                 qitem(mime::TEXT_PLAIN_UTF_8),
                 ])));
-        crate::http::header::common_header_test!(
+        test_header!(
             test4,
             vec![b"text/plain; charset=utf-8; q=0.5"],
             Some(Accept(vec![
@@ -116,8 +131,8 @@ crate::http::header::common_header! {
 
         #[test]
         fn test_fuzzing1() {
-            use actix_http::test::TestRequest;
-            let req = TestRequest::default().insert_header((crate::http::header::ACCEPT, "chunk#;e")).finish();
+            use crate::test::TestRequest;
+            let req = TestRequest::with_header(crate::header::ACCEPT, "chunk#;e").finish();
             let header = Accept::parse(&req);
             assert!(header.is_ok());
         }
@@ -213,7 +228,7 @@ impl Accept {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::header::q;
+    use crate::header::q;
 
     #[test]
     fn test_mime_precedence() {

actix-http/src/header/common/accept_charset.rs

@@ -1,6 +1,6 @@
-use super::{Charset, QualityItem, ACCEPT_CHARSET};
+use crate::header::{Charset, QualityItem, ACCEPT_CHARSET};
 
-crate::http::header::common_header! {
+header! {
     /// `Accept-Charset` header, defined in
     /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.3)
     ///
@@ -21,42 +21,49 @@ crate::http::header::common_header! {
     /// * `iso-8859-5, unicode-1-1;q=0.8`
     ///
     /// # Examples
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
+    /// ```rust
+    /// # extern crate actix_http;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{AcceptCharset, Charset, qitem};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     AcceptCharset(vec![qitem(Charset::Us_Ascii)])
     /// );
+    /// # }
     /// ```
+    /// ```rust
+    /// # extern crate actix_http;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{AcceptCharset, Charset, q, QualityItem};
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptCharset, Charset, q, QualityItem};
-    ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     AcceptCharset(vec![
     ///         QualityItem::new(Charset::Us_Ascii, q(900)),
     ///         QualityItem::new(Charset::Iso_8859_10, q(200)),
     ///     ])
     /// );
+    /// # }
     /// ```
+    /// ```rust
+    /// # extern crate actix_http;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{AcceptCharset, Charset, qitem};
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
-    ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     AcceptCharset(vec![qitem(Charset::Ext("utf-8".to_owned()))])
     /// );
+    /// # }
     /// ```
     (AcceptCharset, ACCEPT_CHARSET) => (QualityItem<Charset>)+
 
     test_accept_charset {
         // Test case from RFC
-        crate::http::header::common_header_test!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
+        test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
     }
 }

actix-http/src/header/common/accept_encoding.rs

@@ -26,20 +26,18 @@ header! {
     ///
     /// # Examples
     /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptEncoding, Encoding, qitem};
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
     ///
-    /// let mut builder = HttpResponse::new();
-    /// builder.insert_header(
+    /// let mut headers = Headers::new();
+    /// headers.set(
     ///     AcceptEncoding(vec![qitem(Encoding::Chunked)])
     /// );
     /// ```
     /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptEncoding, Encoding, qitem};
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
     ///
-    /// let mut builder = HttpResponse::new();
-    /// builder.insert_header(
+    /// let mut headers = Headers::new();
+    /// headers.set(
     ///     AcceptEncoding(vec![
     ///         qitem(Encoding::Chunked),
     ///         qitem(Encoding::Gzip),
@@ -48,11 +46,10 @@ header! {
     /// );
     /// ```
     /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptEncoding, Encoding, QualityItem, q, qitem};
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, QualityItem, q, qitem};
     ///
-    /// let mut builder = HttpResponse::new();
-    /// builder.insert_header(
+    /// let mut headers = Headers::new();
+    /// headers.set(
     ///     AcceptEncoding(vec![
     ///         qitem(Encoding::Chunked),
     ///         QualityItem::new(Encoding::Gzip, q(600)),
@@ -64,12 +61,12 @@ header! {
 
     test_accept_encoding {
         // From the RFC
-        crate::http::header::common_header_test!(test1, vec![b"compress, gzip"]);
-        crate::http::header::common_header_test!(test2, vec![b""], Some(AcceptEncoding(vec![])));
-        crate::http::header::common_header_test!(test3, vec![b"*"]);
+        test_header!(test1, vec![b"compress, gzip"]);
+        test_header!(test2, vec![b""], Some(AcceptEncoding(vec![])));
+        test_header!(test3, vec![b"*"]);
         // Note: Removed quality 1 from gzip
-        crate::http::header::common_header_test!(test4, vec![b"compress;q=0.5, gzip"]);
+        test_header!(test4, vec![b"compress;q=0.5, gzip"]);
         // Note: Removed quality 1 from gzip
-        crate::http::header::common_header_test!(test5, vec![b"gzip, identity; q=0.5, *;q=0"]);
+        test_header!(test5, vec![b"gzip, identity; q=0.5, *;q=0"]);
     }
 }

actix-http/src/header/common/accept_language.rs

@@ -1,8 +1,7 @@
+use crate::header::{QualityItem, ACCEPT_LANGUAGE};
 use language_tags::LanguageTag;
 
-use super::{QualityItem, ACCEPT_LANGUAGE};
-
-crate::http::header::common_header! {
+header! {
     /// `Accept-Language` header, defined in
     /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.5)
     ///
@@ -23,39 +22,49 @@ crate::http::header::common_header! {
     ///
     /// # Examples
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
+    /// ```rust
+    /// # extern crate actix_http;
+    /// # extern crate language_tags;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{AcceptLanguage, LanguageTag, qitem};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// let langtag = LanguageTag::parse("en-US").unwrap();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// let mut langtag: LanguageTag = Default::default();
+    /// langtag.language = Some("en".to_owned());
+    /// langtag.region = Some("US".to_owned());
+    /// builder.set(
     ///     AcceptLanguage(vec![
     ///         qitem(langtag),
     ///     ])
     /// );
+    /// # }
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, QualityItem, q, qitem};
-    ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// ```rust
+    /// # extern crate actix_http;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     AcceptLanguage(vec![
-    ///         qitem(LanguageTag::parse("da").unwrap()),
-    ///         QualityItem::new(LanguageTag::parse("en-GB").unwrap(), q(800)),
-    ///         QualityItem::new(LanguageTag::parse("en").unwrap(), q(700)),
+    ///         qitem(langtag!(da)),
+    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
+    ///         QualityItem::new(langtag!(en), q(700)),
     ///     ])
     /// );
+    /// # }
     /// ```
     (AcceptLanguage, ACCEPT_LANGUAGE) => (QualityItem<LanguageTag>)+
 
     test_accept_language {
         // From the RFC
-        crate::http::header::common_header_test!(test1, vec![b"da, en-gb;q=0.8, en;q=0.7"]);
+        test_header!(test1, vec![b"da, en-gb;q=0.8, en;q=0.7"]);
         // Own test
-        crate::http::header::common_header_test!(
+        test_header!(
             test2, vec![b"en-US, en; q=0.5, fr"],
             Some(AcceptLanguage(vec![
                 qitem("en-US".parse().unwrap()),

actix-http/src/header/common/allow.rs

@@ -1,7 +1,7 @@
-use crate::http::header;
-use actix_http::http::Method;
+use http::header;
+use http::Method;
 
-crate::http::header::common_header! {
+header! {
     /// `Allow` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.4.1)
     ///
     /// The `Allow` header field lists the set of methods advertised as
@@ -22,39 +22,49 @@ crate::http::header::common_header! {
     ///
     /// # Examples
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::{header::Allow, Method};
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_http;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::Allow;
+    /// use http::Method;
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     Allow(vec![Method::GET])
     /// );
+    /// # }
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::{header::Allow, Method};
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_http;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::Allow;
+    /// use http::Method;
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     Allow(vec![
     ///         Method::GET,
     ///         Method::POST,
     ///         Method::PATCH,
     ///     ])
     /// );
+    /// # }
     /// ```
     (Allow, header::ALLOW) => (Method)*
 
     test_allow {
         // From the RFC
-        crate::http::header::common_header_test!(
+        test_header!(
             test1,
             vec![b"GET, HEAD, PUT"],
             Some(HeaderField(vec![Method::GET, Method::HEAD, Method::PUT])));
         // Own tests
-        crate::http::header::common_header_test!(
+        test_header!(
             test2,
             vec![b"OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH"],
             Some(HeaderField(vec![
@@ -67,7 +77,7 @@ crate::http::header::common_header! {
                 Method::TRACE,
                 Method::CONNECT,
                 Method::PATCH])));
-        crate::http::header::common_header_test!(
+        test_header!(
             test3,
             vec![b""],
             Some(HeaderField(Vec::<Method>::new())));

actix-http/src/header/common/cache_control.rs

@@ -1,9 +1,11 @@
 use std::fmt::{self, Write};
 use std::str::FromStr;
 
-use super::{fmt_comma_delimited, from_comma_delimited, Header, IntoHeaderValue, Writer};
+use http::header;
 
-use crate::http::header;
+use crate::header::{
+    fmt_comma_delimited, from_comma_delimited, Header, IntoHeaderValue, Writer,
+};
 
 /// `Cache-Control` header, defined in [RFC7234](https://tools.ietf.org/html/rfc7234#section-5.2)
 ///
@@ -26,20 +28,20 @@ use crate::http::header;
 /// * `max-age=30`
 ///
 /// # Examples
-/// ```
-/// use actix_web::HttpResponse;
-/// use actix_web::http::header::{CacheControl, CacheDirective};
+/// ```rust
+/// use actix_http::Response;
+/// use actix_http::http::header::{CacheControl, CacheDirective};
 ///
-/// let mut builder = HttpResponse::Ok();
-/// builder.insert_header(CacheControl(vec![CacheDirective::MaxAge(86400u32)]));
+/// let mut builder = Response::Ok();
+/// builder.set(CacheControl(vec![CacheDirective::MaxAge(86400u32)]));
 /// ```
 ///
-/// ```
-/// use actix_web::HttpResponse;
-/// use actix_web::http::header::{CacheControl, CacheDirective};
+/// ```rust
+/// use actix_http::Response;
+/// use actix_http::http::header::{CacheControl, CacheDirective};
 ///
-/// let mut builder = HttpResponse::Ok();
-/// builder.insert_header(CacheControl(vec![
+/// let mut builder = Response::Ok();
+/// builder.set(CacheControl(vec![
 ///     CacheDirective::NoCache,
 ///     CacheDirective::Private,
 ///     CacheDirective::MaxAge(360u32),
@@ -49,9 +51,9 @@ use crate::http::header;
 #[derive(PartialEq, Clone, Debug)]
 pub struct CacheControl(pub Vec<CacheDirective>);
 
-crate::http::header::common_header_deref!(CacheControl => Vec<CacheDirective>);
+__hyper__deref!(CacheControl => Vec<CacheDirective>);
 
-// TODO: this could just be the crate::http::header::common_header! macro
+//TODO: this could just be the header! macro
 impl Header for CacheControl {
     fn name() -> header::HeaderName {
         header::CACHE_CONTROL
@@ -73,14 +75,14 @@ impl Header for CacheControl {
 
 impl fmt::Display for CacheControl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt_comma_delimited(f, &self.0[..])
+        fmt_comma_delimited(f, &self[..])
     }
 }
 
 impl IntoHeaderValue for CacheControl {
     type Error = header::InvalidHeaderValue;
 
-    fn try_into_value(self) -> Result<header::HeaderValue, Self::Error> {
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
         let mut writer = Writer::new();
         let _ = write!(&mut writer, "{}", self);
         header::HeaderValue::from_maybe_shared(writer.take())
@@ -174,7 +176,9 @@ impl FromStr for CacheDirective {
                         ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
                         ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
                         ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(Some),
-                        (left, right) => Ok(Extension(left.to_owned(), Some(right.to_owned()))),
+                        (left, right) => {
+                            Ok(Extension(left.to_owned(), Some(right.to_owned())))
+                        }
                     }
                 }
                 Some(_) => Err(None),
@@ -187,13 +191,12 @@ impl FromStr for CacheDirective {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::header::Header;
-    use actix_http::test::TestRequest;
+    use crate::header::Header;
+    use crate::test::TestRequest;
 
     #[test]
     fn test_parse_multiple_headers() {
-        let req = TestRequest::default()
-            .insert_header((header::CACHE_CONTROL, "no-cache, private"))
+        let req = TestRequest::with_header(header::CACHE_CONTROL, "no-cache, private")
             .finish();
         let cache = Header::parse(&req);
         assert_eq!(
@@ -207,9 +210,9 @@ mod tests {
 
     #[test]
     fn test_parse_argument() {
-        let req = TestRequest::default()
-            .insert_header((header::CACHE_CONTROL, "max-age=100, private"))
-            .finish();
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "max-age=100, private")
+                .finish();
         let cache = Header::parse(&req);
         assert_eq!(
             cache.ok(),
@@ -222,9 +225,8 @@ mod tests {
 
     #[test]
     fn test_parse_quote_form() {
-        let req = TestRequest::default()
-            .insert_header((header::CACHE_CONTROL, "max-age=\"200\""))
-            .finish();
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "max-age=\"200\"").finish();
         let cache = Header::parse(&req);
         assert_eq!(
             cache.ok(),
@@ -234,9 +236,8 @@ mod tests {
 
     #[test]
     fn test_parse_extension() {
-        let req = TestRequest::default()
-            .insert_header((header::CACHE_CONTROL, "foo, bar=baz"))
-            .finish();
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "foo, bar=baz").finish();
         let cache = Header::parse(&req);
         assert_eq!(
             cache.ok(),
@@ -249,9 +250,7 @@ mod tests {
 
     #[test]
     fn test_parse_bad_syntax() {
-        let req = TestRequest::default()
-            .insert_header((header::CACHE_CONTROL, "foo="))
-            .finish();
+        let req = TestRequest::with_header(header::CACHE_CONTROL, "foo=").finish();
         let cache: Result<CacheControl, _> = Header::parse(&req);
         assert_eq!(cache.ok(), None)
     }

actix-http/src/header/common/content_disposition.rs

@@ -1,17 +1,16 @@
-//! # References
-//!
-//! "The Content-Disposition Header Field" <https://www.ietf.org/rfc/rfc2183.txt>
-//! "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" <https://www.ietf.org/rfc/rfc6266.txt>
-//! "Returning Values from Forms: multipart/form-data" <https://www.ietf.org/rfc/rfc7578.txt>
-//! Browser conformance tests at: <http://greenbytes.de/tech/tc2231/>
-//! IANA assignment: <http://www.iana.org/assignments/cont-disp/cont-disp.xhtml>
+// # References
+//
+// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
+// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
+// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc7578.txt
+// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
+// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
 
-use once_cell::sync::Lazy;
+use lazy_static::lazy_static;
 use regex::Regex;
 use std::fmt::{self, Write};
 
-use super::{ExtendedValue, Header, IntoHeaderValue, Writer};
-use crate::http::header;
+use crate::header::{self, ExtendedValue, Header, IntoHeaderValue, Writer};
 
 /// Split at the index of the first `needle` if it exists or at the end.
 fn split_once(haystack: &str, needle: char) -> (&str, &str) {
@@ -64,7 +63,7 @@ impl<'a> From<&'a str> for DispositionType {
 ///
 /// # Examples
 /// ```
-/// use actix_web::http::header::DispositionParam;
+/// use actix_http::http::header::DispositionParam;
 ///
 /// let param = DispositionParam::Filename(String::from("sample.txt"));
 /// assert!(param.is_filename());
@@ -241,7 +240,7 @@ impl DispositionParam {
 /// # Example
 ///
 /// ```
-/// use actix_web::http::header::{
+/// use actix_http::http::header::{
 ///     Charset, ContentDisposition, DispositionParam, DispositionType,
 ///     ExtendedValue,
 /// };
@@ -319,8 +318,9 @@ impl ContentDisposition {
                 return Err(crate::error::ParseError::Header);
             }
             left = new_left;
-            if let Some(param_name) = param_name.strip_suffix('*') {
+            if param_name.ends_with('*') {
                 // extended parameters
+                let param_name = &param_name[..param_name.len() - 1]; // trim asterisk
                 let (ext_value, new_left) = split_once_and_trim(left, ';');
                 left = new_left;
                 let ext_value = header::parse_extended_value(ext_value)?;
@@ -401,49 +401,61 @@ impl ContentDisposition {
     }
 
     /// Returns `true` if it is [`Ext`](DispositionType::Ext) and the `disp_type` matches.
-    pub fn is_ext(&self, disp_type: impl AsRef<str>) -> bool {
-        matches!(
-            self.disposition,
-            DispositionType::Ext(ref t) if t.eq_ignore_ascii_case(disp_type.as_ref())
-        )
+    pub fn is_ext<T: AsRef<str>>(&self, disp_type: T) -> bool {
+        match self.disposition {
+            DispositionType::Ext(ref t)
+                if t.eq_ignore_ascii_case(disp_type.as_ref()) =>
+            {
+                true
+            }
+            _ => false,
+        }
     }
 
     /// Return the value of *name* if exists.
     pub fn get_name(&self) -> Option<&str> {
-        self.parameters.iter().find_map(DispositionParam::as_name)
+        self.parameters.iter().filter_map(|p| p.as_name()).next()
     }
 
     /// Return the value of *filename* if exists.
     pub fn get_filename(&self) -> Option<&str> {
         self.parameters
             .iter()
-            .find_map(DispositionParam::as_filename)
+            .filter_map(|p| p.as_filename())
+            .next()
     }
 
     /// Return the value of *filename\** if exists.
     pub fn get_filename_ext(&self) -> Option<&ExtendedValue> {
         self.parameters
             .iter()
-            .find_map(DispositionParam::as_filename_ext)
+            .filter_map(|p| p.as_filename_ext())
+            .next()
     }
 
     /// Return the value of the parameter which the `name` matches.
-    pub fn get_unknown(&self, name: impl AsRef<str>) -> Option<&str> {
+    pub fn get_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
         let name = name.as_ref();
-        self.parameters.iter().find_map(|p| p.as_unknown(name))
+        self.parameters
+            .iter()
+            .filter_map(|p| p.as_unknown(name))
+            .next()
     }
 
     /// Return the value of the extended parameter which the `name` matches.
-    pub fn get_unknown_ext(&self, name: impl AsRef<str>) -> Option<&ExtendedValue> {
+    pub fn get_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&ExtendedValue> {
         let name = name.as_ref();
-        self.parameters.iter().find_map(|p| p.as_unknown_ext(name))
+        self.parameters
+            .iter()
+            .filter_map(|p| p.as_unknown_ext(name))
+            .next()
     }
 }
 
 impl IntoHeaderValue for ContentDisposition {
     type Error = header::InvalidHeaderValue;
 
-    fn try_into_value(self) -> Result<header::HeaderValue, Self::Error> {
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
         let mut writer = Writer::new();
         let _ = write!(&mut writer, "{}", self);
         header::HeaderValue::from_maybe_shared(writer.take())
@@ -457,7 +469,7 @@ impl Header for ContentDisposition {
 
     fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
         if let Some(h) = msg.headers().get(&Self::name()) {
-            Self::from_raw(h)
+            Self::from_raw(&h)
         } else {
             Err(crate::error::ParseError::Header)
         }
@@ -509,8 +521,9 @@ impl fmt::Display for DispositionParam {
         //
         //
         // See also comments in test_from_raw_unnecessary_percent_decode.
-        static RE: Lazy<Regex> =
-            Lazy::new(|| Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap());
+        lazy_static! {
+            static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
+        }
         match self {
             DispositionParam::Name(ref value) => write!(f, "name={}", value),
             DispositionParam::Filename(ref value) => {
@@ -537,14 +550,16 @@ impl fmt::Display for ContentDisposition {
         write!(f, "{}", self.disposition)?;
         self.parameters
             .iter()
-            .try_for_each(|param| write!(f, "; {}", param))
+            .map(|param| write!(f, "; {}", param))
+            .collect()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::{ContentDisposition, DispositionParam, DispositionType};
-    use crate::http::header::{Charset, ExtendedValue, HeaderValue};
+    use crate::header::shared::Charset;
+    use crate::header::{ExtendedValue, HeaderValue};
 
     #[test]
     fn test_from_raw_basic() {
@@ -606,8 +621,8 @@ mod tests {
                 charset: Charset::Ext(String::from("UTF-8")),
                 language_tag: None,
                 value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20, b'r',
-                    b'a', b't', b'e', b's',
+                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
+                    b'r', b'a', b't', b'e', b's',
                 ],
             })],
         };
@@ -623,8 +638,8 @@ mod tests {
                 charset: Charset::Ext(String::from("UTF-8")),
                 language_tag: None,
                 value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20, b'r',
-                    b'a', b't', b'e', b's',
+                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
+                    b'r', b'a', b't', b'e', b's',
                 ],
             })],
         };
@@ -686,22 +701,26 @@ mod tests {
 
     #[test]
     fn test_from_raw_only_disp() {
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static("attachment")).unwrap();
+        let a = ContentDisposition::from_raw(&HeaderValue::from_static("attachment"))
+            .unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::Attachment,
             parameters: vec![],
         };
         assert_eq!(a, b);
 
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static("inline ;")).unwrap();
+        let a =
+            ContentDisposition::from_raw(&HeaderValue::from_static("inline ;")).unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::Inline,
             parameters: vec![],
         };
         assert_eq!(a, b);
 
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static("unknown-disp-param"))
-            .unwrap();
+        let a = ContentDisposition::from_raw(&HeaderValue::from_static(
+            "unknown-disp-param",
+        ))
+        .unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::Ext(String::from("unknown-disp-param")),
             parameters: vec![],
@@ -740,8 +759,8 @@ mod tests {
         Mainstream browsers like Firefox (gecko) and Chrome use UTF-8 directly as above.
         (And now, only UTF-8 is handled by this implementation.)
         */
-        let a =
-            HeaderValue::from_str("form-data; name=upload; filename=\"文件.webp\"").unwrap();
+        let a = HeaderValue::from_str("form-data; name=upload; filename=\"文件.webp\"")
+            .unwrap();
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::FormData,
@@ -792,7 +811,8 @@ mod tests {
 
     #[test]
     fn test_from_raw_semicolon() {
-        let a = HeaderValue::from_static("form-data; filename=\"A semicolon here;.pdf\"");
+        let a =
+            HeaderValue::from_static("form-data; filename=\"A semicolon here;.pdf\"");
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::FormData,
@@ -828,8 +848,9 @@ mod tests {
         };
         assert_eq!(a, b);
 
-        let a =
-            HeaderValue::from_static("form-data; name=photo; filename=\"%74%65%73%74.png\"");
+        let a = HeaderValue::from_static(
+            "form-data; name=photo; filename=\"%74%65%73%74.png\"",
+        );
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
             disposition: DispositionType::FormData,
@@ -874,7 +895,8 @@ mod tests {
 
     #[test]
     fn test_display_extended() {
-        let as_string = "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
+        let as_string =
+            "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
         let a = HeaderValue::from_static(as_string);
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let display_rendered = format!("{}", a);

actix-http/src/header/common/content_language.rs

@@ -0,0 +1,65 @@
+use crate::header::{QualityItem, CONTENT_LANGUAGE};
+use language_tags::LanguageTag;
+
+header! {
+    /// `Content-Language` header, defined in
+    /// [RFC7231](https://tools.ietf.org/html/rfc7231#section-3.1.3.2)
+    ///
+    /// The `Content-Language` header field describes the natural language(s)
+    /// of the intended audience for the representation.  Note that this
+    /// might not be equivalent to all the languages used within the
+    /// representation.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Language = 1#language-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `da`
+    /// * `mi, en`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_http;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_http::Response;
+    /// # use actix_http::http::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(en)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_http;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_http::Response;
+    /// # use actix_http::http::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    ///
+    /// let mut builder = Response::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         qitem(langtag!(en;;;GB)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (ContentLanguage, CONTENT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_content_language {
+        test_header!(test1, vec![b"da"]);
+        test_header!(test2, vec![b"mi, en"]);
+    }
+}

actix-http/src/header/common/content_range.rs

@@ -1,68 +1,70 @@
 use std::fmt::{self, Display, Write};
 use std::str::FromStr;
 
-use super::{HeaderValue, IntoHeaderValue, InvalidHeaderValue, Writer, CONTENT_RANGE};
 use crate::error::ParseError;
+use crate::header::{
+    HeaderValue, IntoHeaderValue, InvalidHeaderValue, Writer, CONTENT_RANGE,
+};
 
-crate::http::header::common_header! {
+header! {
     /// `Content-Range` header, defined in
     /// [RFC7233](http://tools.ietf.org/html/rfc7233#section-4.2)
     (ContentRange, CONTENT_RANGE) => [ContentRangeSpec]
 
     test_content_range {
-        crate::http::header::common_header_test!(test_bytes,
+        test_header!(test_bytes,
             vec![b"bytes 0-499/500"],
             Some(ContentRange(ContentRangeSpec::Bytes {
                 range: Some((0, 499)),
                 instance_length: Some(500)
             })));
 
-        crate::http::header::common_header_test!(test_bytes_unknown_len,
+        test_header!(test_bytes_unknown_len,
             vec![b"bytes 0-499/*"],
             Some(ContentRange(ContentRangeSpec::Bytes {
                 range: Some((0, 499)),
                 instance_length: None
             })));
 
-        crate::http::header::common_header_test!(test_bytes_unknown_range,
+        test_header!(test_bytes_unknown_range,
             vec![b"bytes */500"],
             Some(ContentRange(ContentRangeSpec::Bytes {
                 range: None,
                 instance_length: Some(500)
             })));
 
-        crate::http::header::common_header_test!(test_unregistered,
+        test_header!(test_unregistered,
             vec![b"seconds 1-2"],
             Some(ContentRange(ContentRangeSpec::Unregistered {
                 unit: "seconds".to_owned(),
                 resp: "1-2".to_owned()
             })));
 
-        crate::http::header::common_header_test!(test_no_len,
+        test_header!(test_no_len,
             vec![b"bytes 0-499"],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_only_unit,
+        test_header!(test_only_unit,
             vec![b"bytes"],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_end_less_than_start,
+        test_header!(test_end_less_than_start,
             vec![b"bytes 499-0/500"],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_blank,
+        test_header!(test_blank,
             vec![b""],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_bytes_many_spaces,
+        test_header!(test_bytes_many_spaces,
             vec![b"bytes 1-2/500 3"],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_bytes_many_slashes,
+        test_header!(test_bytes_many_slashes,
             vec![b"bytes 1-2/500/600"],
             None::<ContentRange>);
 
-        crate::http::header::common_header_test!(test_bytes_many_dashes,
+        test_header!(test_bytes_many_dashes,
             vec![b"bytes 1-2-3/500"],
             None::<ContentRange>);
 
@@ -139,7 +141,8 @@ impl FromStr for ContentRangeSpec {
                 } else {
                     let (first_byte, last_byte) =
                         split_in_two(range, '-').ok_or(ParseError::Header)?;
-                    let first_byte = first_byte.parse().map_err(|_| ParseError::Header)?;
+                    let first_byte =
+                        first_byte.parse().map_err(|_| ParseError::Header)?;
                     let last_byte = last_byte.parse().map_err(|_| ParseError::Header)?;
                     if last_byte < first_byte {
                         return Err(ParseError::Header);
@@ -197,7 +200,7 @@ impl Display for ContentRangeSpec {
 impl IntoHeaderValue for ContentRangeSpec {
     type Error = InvalidHeaderValue;
 
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
         let mut writer = Writer::new();
         let _ = write!(&mut writer, "{}", self);
         HeaderValue::from_maybe_shared(writer.take())

actix-http/src/header/common/content_type.rs

@@ -1,7 +1,7 @@
-use super::CONTENT_TYPE;
+use crate::header::CONTENT_TYPE;
 use mime::Mime;
 
-crate::http::header::common_header! {
+header! {
     /// `Content-Type` header, defined in
     /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)
     ///
@@ -30,29 +30,36 @@ crate::http::header::common_header! {
     ///
     /// # Examples
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::ContentType;
+    /// ```rust
+    /// use actix_http::Response;
+    /// use actix_http::http::header::ContentType;
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
     ///     ContentType::json()
     /// );
+    /// # }
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::ContentType;
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_http;
+    /// use mime::TEXT_HTML;
+    /// use actix_http::Response;
+    /// use actix_http::http::header::ContentType;
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
-    ///     ContentType(mime::TEXT_HTML)
+    /// # fn main() {
+    /// let mut builder = Response::Ok();
+    /// builder.set(
+    ///     ContentType(TEXT_HTML)
     /// );
+    /// # }
     /// ```
     (ContentType, CONTENT_TYPE) => [Mime]
 
     test_content_type {
-        crate::http::header::common_header_test!(
+        test_header!(
             test1,
             vec![b"text/html"],
             Some(HeaderField(mime::TEXT_HTML)));
@@ -92,7 +99,6 @@ impl ContentType {
     pub fn form_url_encoded() -> ContentType {
         ContentType(mime::APPLICATION_WWW_FORM_URLENCODED)
     }
-
     /// A constructor  to easily create a `Content-Type: image/jpeg` header.
     #[inline]
     pub fn jpeg() -> ContentType {

actix-http/src/header/common/date.rs

@@ -1,7 +1,7 @@
-use super::{HttpDate, DATE};
+use crate::header::{HttpDate, DATE};
 use std::time::SystemTime;
 
-crate::http::header::common_header! {
+header! {
     /// `Date` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.1.2)
     ///
     /// The `Date` header field represents the date and time at which the
@@ -19,20 +19,18 @@ crate::http::header::common_header! {
     ///
     /// # Example
     ///
-    /// ```
+    /// ```rust
+    /// use actix_http::Response;
+    /// use actix_http::http::header::Date;
     /// use std::time::SystemTime;
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::Date;
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
-    ///     Date(SystemTime::now().into())
-    /// );
+    /// let mut builder = Response::Ok();
+    /// builder.set(Date(SystemTime::now().into()));
     /// ```
     (Date, DATE) => [HttpDate]
 
     test_date {
-        crate::http::header::common_header_test!(test1, vec![b"Tue, 15 Nov 1994 08:12:31 GMT"]);
+        test_header!(test1, vec![b"Tue, 15 Nov 1994 08:12:31 GMT"]);
     }
 }
 

actix-http/src/header/common/etag.rs

@@ -1,6 +1,6 @@
-use super::{EntityTag, ETAG};
+use crate::header::{EntityTag, ETAG};
 
-crate::http::header::common_header! {
+header! {
     /// `ETag` header, defined in [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.3)
     ///
     /// The `ETag` header field in a response provides the current entity-tag
@@ -27,73 +27,69 @@ crate::http::header::common_header! {
     ///
     /// # Examples
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ETag, EntityTag};
+    /// ```rust
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{ETag, EntityTag};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
-    ///     ETag(EntityTag::new(false, "xyzzy".to_owned()))
-    /// );
+    /// let mut builder = Response::Ok();
+    /// builder.set(ETag(EntityTag::new(false, "xyzzy".to_owned())));
     /// ```
     ///
-    /// ```
-    /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ETag, EntityTag};
+    /// ```rust
+    /// use actix_http::Response;
+    /// use actix_http::http::header::{ETag, EntityTag};
     ///
-    /// let mut builder = HttpResponse::Ok();
-    /// builder.insert_header(
-    ///     ETag(EntityTag::new(true, "xyzzy".to_owned()))
-    /// );
+    /// let mut builder = Response::Ok();
+    /// builder.set(ETag(EntityTag::new(true, "xyzzy".to_owned())));
     /// ```
     (ETag, ETAG) => [EntityTag]
 
     test_etag {
         // From the RFC
-        crate::http::header::common_header_test!(test1,
+        test_header!(test1,
             vec![b"\"xyzzy\""],
             Some(ETag(EntityTag::new(false, "xyzzy".to_owned()))));
-        crate::http::header::common_header_test!(test2,
+        test_header!(test2,
             vec![b"W/\"xyzzy\""],
             Some(ETag(EntityTag::new(true, "xyzzy".to_owned()))));
-        crate::http::header::common_header_test!(test3,
+        test_header!(test3,
             vec![b"\"\""],
             Some(ETag(EntityTag::new(false, "".to_owned()))));
         // Own tests
-        crate::http::header::common_header_test!(test4,
+        test_header!(test4,
             vec![b"\"foobar\""],
             Some(ETag(EntityTag::new(false, "foobar".to_owned()))));
-        crate::http::header::common_header_test!(test5,
+        test_header!(test5,
             vec![b"\"\""],
             Some(ETag(EntityTag::new(false, "".to_owned()))));
-        crate::http::header::common_header_test!(test6,
+        test_header!(test6,
             vec![b"W/\"weak-etag\""],
             Some(ETag(EntityTag::new(true, "weak-etag".to_owned()))));
-        crate::http::header::common_header_test!(test7,
+        test_header!(test7,
             vec![b"W/\"\x65\x62\""],
             Some(ETag(EntityTag::new(true, "\u{0065}\u{0062}".to_owned()))));
-        crate::http::header::common_header_test!(test8,
+        test_header!(test8,
             vec![b"W/\"\""],
             Some(ETag(EntityTag::new(true, "".to_owned()))));
-        crate::http::header::common_header_test!(test9,
+        test_header!(test9,
             vec![b"no-dquotes"],
             None::<ETag>);
-        crate::http::header::common_header_test!(test10,
+        test_header!(test10,
             vec![b"w/\"the-first-w-is-case-sensitive\""],
             None::<ETag>);
-        crate::http::header::common_header_test!(test11,
+        test_header!(test11,
             vec![b""],
             None::<ETag>);
-        crate::http::header::common_header_test!(test12,
+        test_header!(test12,
             vec![b"\"unmatched-dquotes1"],
             None::<ETag>);
-        crate::http::header::common_header_test!(test13,
+        test_header!(test13,
             vec![b"unmatched-dquotes2\""],
             None::<ETag>);
-        crate::http::header::common_header_test!(test14,
+        test_header!(test14,
             vec![b"matched-\"dquotes\""],
             None::<ETag>);
-        crate::http::header::common_header_test!(test15,
+        test_header!(test15,
             vec![b"\""],
             None::<ETag>);
     }