Fix segfault in ServerSettings::get_response_builder()

.appveyor.yml

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

.cargo/config.toml

@@ -1,9 +0,0 @@
-[alias]
-chk = "check --workspace --all-features --tests --examples --bins"
-lint = "clippy --workspace --tests --examples"
-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 = "hack test --workspace --all-features --doc --no-fail-fast -- --nocapture"

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,37 +0,0 @@
----
-name: Bug Report
-about: Create a bug report.
----
-
-Your issue may already be reported!
-Please search on the [Actix Web issue tracker](https://github.com/actix/actix-web/issues) before creating one.
-
-## Expected Behavior
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
-
-## Current Behavior
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-## Possible Solution
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
-<!--- or ideas how to implement the addition or change -->
-
-## Steps to Reproduce (for bugs)
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-1.
-2.
-3.
-4.
-
-## Context
-<!--- How has this issue affected you? What are you trying to accomplish? -->
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
-
-## Your Environment
-<!--- Include as many relevant details about the environment you experienced the bug in -->
-
-* Rust Version (I.e, output of `rustc -V`):
-* Actix Web Version:

.github/ISSUE_TEMPLATE/config.yml

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,27 +0,0 @@
-<!-- Thanks for considering contributing actix! -->
-<!-- Please fill out the following to get your PR reviewed quicker. -->
-
-## PR Type
-<!-- What kind of change does this PR make? -->
-<!-- Bug Fix / Feature / Refactor / Code Style / Other -->
-PR_TYPE
-
-
-## PR Checklist
-<!-- Check your PR fulfills the following items. ->>
-<!-- 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.
-
-
-## Overview
-<!-- Describe the current and new behavior. -->
-<!-- Emphasize any breaking changes. -->
-
-
-<!-- If this PR fixes or closes an issue, reference it here. -->
-<!-- Closes #000 -->

.github/workflows/bench.yml

@@ -1,28 +0,0 @@
-name: Benchmark
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches:
-      - master
-
-jobs:
-  check_benchmark:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          profile: minimal
-          override: true
-
-      - name: Check benchmark
-        uses: actions-rs/cargo@v1
-        with:
-          command: bench
-          args: --bench=server -- --sample-size=15

.github/workflows/ci.yml

@@ -1,110 +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-latest, triple: x86_64-pc-windows-msvc }
-        version:
-          - 1.46.0 # MSRV
-          - stable
-          - nightly
-
-    name: ${{ matrix.target.name }} / ${{ matrix.version }}
-    runs-on: ${{ matrix.target.os }}
-
-    env:
-      VCPKGRS_DYNAMIC: 1
-
-    steps:
-      - uses: actions/checkout@v2
-
-      # install OpenSSL on Windows
-      - 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: doc tests
-        # due to unknown issue with running doc tests on macOS
-        if: matrix.target.os == 'ubuntu-latest'
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with: { command: ci-doctest }
-
-      - name: Generate coverage file
-        if: >
-          matrix.target.os == 'ubuntu-latest'
-          && matrix.version == 'stable'
-          && github.ref == 'refs/heads/master'
-        run: |
-          cargo install cargo-tarpaulin --vers "^0.13"
-          cargo tarpaulin --out Xml --verbose
-      - name: Upload to Codecov
-        if: >
-          matrix.target.os == 'ubuntu-latest'
-          && matrix.version == 'stable'
-          && github.ref == 'refs/heads/master'
-        uses: codecov/codecov-action@v1
-        with:
-          file: cobertura.xml
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
-          cargo-cache

.github/workflows/clippy-fmt.yml

@@ -1,39 +0,0 @@
-name: Lint
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-jobs:
-  fmt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          components: rustfmt
-      - 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
-        with:
-          toolchain: stable
-          components: clippy
-          override: true
-      - name: Check with Clippy
-        uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --all-features --tests

.github/workflows/upload-doc.yml

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

.gitignore

@@ -9,13 +9,6 @@ guide/build/
 *.pid
 *.sock
 *~
-.DS_Store
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
-
-# Configuration directory generated by CLion
-.idea
-
-# Configuration directory generated by VSCode
-.vscode

.travis.yml

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

CHANGES.md

@@ -1,772 +1,316 @@
 # Changes
 
-## Unreleased - 2021-xx-xx
+## 0.5.8 (2018-05-11)
 
+* Fix segfault in ServerSettings::get_response_builder()
 
-## 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]
+## 0.5.7 (2018-05-09)
 
-### 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.
+* Fix http/2 payload streaming #215
 
-### 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
-* Removed an occasional `unwrap` on `None` panic in `NormalizePathNormalization`. [#1762]
-* Fix `match_pattern()` returning `None` for scope with empty path resource. [#1798]
-* Increase minimum `socket2` version. [#1803]
-
-[#1762]: https://github.com/actix/actix-web/pull/1762
-[#1798]: https://github.com/actix/actix-web/pull/1798
-[#1803]: https://github.com/actix/actix-web/pull/1803
-
-
-## 3.3.1 - 2020-11-29
-* Ensure `actix-http` dependency uses same `serde_urlencoded`.
-
-
-## 3.3.0 - 2020-11-25
-### Added
-* Add `Either<A, B>` extractor helper. [#1788]
-
-### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
-
-[#1773]: https://github.com/actix/actix-web/pull/1773
-[#1788]: https://github.com/actix/actix-web/pull/1788
-
-
-## 3.2.0 - 2020-10-30
-### Added
-* Implement `exclude_regex` for Logger middleware. [#1723]
-* Add request-local data extractor `web::ReqData`. [#1748]
-* Add ability to register closure for request middleware logging. [#1749]
-* Add `app_data` to `ServiceConfig`. [#1757]
-* Expose `on_connect` for access to the connection stream before request is handled. [#1754]
-
-### Changed
-* Updated actix-web-codegen dependency for access to new `#[route(...)]` multi-method macro.
-* Print non-configured `Data<T>` type when attempting extraction. [#1743]
-* Re-export bytes::Buf{Mut} in web module. [#1750]
-* Upgrade `pin-project` to `1.0`.
-
-[#1723]: https://github.com/actix/actix-web/pull/1723
-[#1743]: https://github.com/actix/actix-web/pull/1743
-[#1748]: https://github.com/actix/actix-web/pull/1748
-[#1750]: https://github.com/actix/actix-web/pull/1750
-[#1754]: https://github.com/actix/actix-web/pull/1754
-[#1749]: https://github.com/actix/actix-web/pull/1749
-
-
-## 3.1.0 - 2020-09-29
-### Changed
-* Add `TrailingSlash::MergeOnly` behaviour to `NormalizePath`, which allows `NormalizePath`
-  to retain any trailing slashes. [#1695]
-* Remove bound `std::marker::Sized` from `web::Data` to support storing `Arc<dyn Trait>`
-  via `web::Data::from` [#1710]
-
-### Fixed
-* `ResourceMap` debug printing is no longer infinitely recursive. [#1708]
+## 0.5.6 (2018-04-24)
 
-[#1695]: https://github.com/actix/actix-web/pull/1695
-[#1708]: https://github.com/actix/actix-web/pull/1708
-[#1710]: https://github.com/actix/actix-web/pull/1710
+* Make flate2 crate optional #200
 
 
-## 3.0.2 - 2020-09-15
-### Fixed
-* `NormalizePath` when used with `TrailingSlash::Trim` no longer trims the root path "/". [#1678]
+## 0.5.5 (2018-04-24)
 
-[#1678]: https://github.com/actix/actix-web/pull/1678
+* Fix panic when Websocket is closed with no error code #191
 
+* Allow to use rust backend for flate2 crate #199
 
-## 3.0.1 - 2020-09-13
-### Changed
-* `middleware::normalize::TrailingSlash` enum is now accessible. [#1673]
+## 0.5.4 (2018-04-19)
 
-[#1673]: https://github.com/actix/actix-web/pull/1673
+* Add identity service middleware
 
+* Middleware response() is not invoked if there was an error in async handler #187
 
-## 3.0.0 - 2020-09-11
-* No significant changes from `3.0.0-beta.4`.
+* Use Display formatting for InternalError Display implementation #188
 
 
-## 3.0.0-beta.4 - 2020-09-09
-### Added
-* `middleware::NormalizePath` now has configurable behavior for either always having a trailing 
-  slash, or as the new addition, always trimming trailing slashes. [#1639]
+## 0.5.3 (2018-04-18)
 
-### Changed
-* Update actix-codec and actix-utils dependencies. [#1634]
-* `FormConfig` and `JsonConfig` configurations are now also considered when set
-  using `App::data`. [#1641]
-* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`. [#1655]
-* `HttpServer::maxconnrate` is renamed to the more expressive
-  `HttpServer::max_connection_rate`. [#1655]
+* Impossible to quote slashes in path parameters #182
 
-[#1639]: https://github.com/actix/actix-web/pull/1639
-[#1641]: https://github.com/actix/actix-web/pull/1641
-[#1634]: https://github.com/actix/actix-web/pull/1634
-[#1655]: https://github.com/actix/actix-web/pull/1655
 
-## 3.0.0-beta.3 - 2020-08-17
-### Changed
-* Update `rustls` to 0.18
+## 0.5.2 (2018-04-16)
 
+* Allow to configure StaticFiles's CpuPool, via static method or env variable
 
-## 3.0.0-beta.2 - 2020-08-17
-### Changed
-* `PayloadConfig` is now also considered in `Bytes` and `String` extractors when set
-  using `App::data`. [#1610]
-* `web::Path` now has a public representation: `web::Path(pub T)` that enables
-  destructuring. [#1594]
-* `ServiceRequest::app_data` allows retrieval of non-Data data without splitting into parts to
-  access `HttpRequest` which already allows this. [#1618]
-* Re-export all error types from `awc`. [#1621]
-* MSRV is now 1.42.0.
+* Add support for custom handling of Json extractor errors #181
 
-### Fixed
-* Memory leak of app data in pooled requests. [#1609]
+* Fix StaticFiles does not support percent encoded paths #177
 
-[#1594]: https://github.com/actix/actix-web/pull/1594
-[#1609]: https://github.com/actix/actix-web/pull/1609
-[#1610]: https://github.com/actix/actix-web/pull/1610
-[#1618]: https://github.com/actix/actix-web/pull/1618
-[#1621]: https://github.com/actix/actix-web/pull/1621
+* Fix Client Request with custom Body Stream halting on certain size requests #176
 
 
-## 3.0.0-beta.1 - 2020-07-13
-### Added
-* Re-export `actix_rt::main` as `actix_web::main`.
-* `HttpRequest::match_pattern` and `ServiceRequest::match_pattern` for extracting the matched
-  resource pattern.
-* `HttpRequest::match_name` and `ServiceRequest::match_name` for extracting matched resource name.
+## 0.5.1 (2018-04-12)
 
-### Changed
-* Fix actix_http::h1::dispatcher so it returns when HW_BUFFER_SIZE is reached. Should reduce peak memory consumption during large uploads. [#1550]
-* Migrate cookie handling to `cookie` crate. Actix-web no longer requires `ring` dependency.
-* MSRV is now 1.41.1
+* Client connector provides stats, `ClientConnector::stats()`
 
-### Fixed
-* `NormalizePath` improved consistency when path needs slashes added _and_ removed.
+* Fix end-of-stream handling in parse_payload #173
 
+* Fix StaticFiles generate a lot of threads #174
 
-## 3.0.0-alpha.3 - 2020-05-21
-### Added
-* Add option to create `Data<T>` from `Arc<T>` [#1509]
 
-### Changed
-* Resources and Scopes can now access non-overridden data types set on App (or containing scopes) when setting their own data. [#1486]
-* Fix audit issue logging by default peer address [#1485]
-* Bump minimum supported Rust version to 1.40
-* Replace deprecated `net2` crate with `socket2`
+## 0.5.0 (2018-04-10)
 
-[#1485]: https://github.com/actix/actix-web/pull/1485
-[#1509]: https://github.com/actix/actix-web/pull/1509
+* Type-safe path/query/form parameter handling, using serde #70
 
-## [3.0.0-alpha.2] - 2020-05-08
+* HttpResponse builder's methods  `.body()`, `.finish()`, `.json()`
+  return `HttpResponse` instead of `Result`
 
-### Changed
+* Use more ergonomic `actix_web::Error` instead of `http::Error` for `ClientRequestBuilder::body()`
 
-* `{Resource,Scope}::default_service(f)` handlers now support app data extraction. [#1452]
-* Implement `std::error::Error` for our custom errors [#1422]
-* NormalizePath middleware now appends trailing / so that routes of form /example/ respond to /example requests. [#1433]
-* Remove the `failure` feature and support.
+* Added `signed` and `private` `CookieSessionBackend`s
 
-[#1422]: https://github.com/actix/actix-web/pull/1422
-[#1433]: https://github.com/actix/actix-web/pull/1433
-[#1452]: https://github.com/actix/actix-web/pull/1452
-[#1486]: https://github.com/actix/actix-web/pull/1486
+* Added `HttpRequest::resource()`, returns current matched resource
 
+* Added `ErrorHandlers` middleware
 
-## [3.0.0-alpha.1] - 2020-03-11
+* Fix router cannot parse Non-ASCII characters in URL #137
 
-### Added
+* Fix client connection pooling
 
-* Add helper function for creating routes with `TRACE` method guard `web::trace()`
-* Add convenience functions `test::read_body_json()` and `test::TestRequest::send_request()` for testing.
+* Fix long client urls #129
 
-### Changed
+* Fix panic on invalid URL characters #130
 
-* Use `sha-1` crate instead of unmaintained `sha1` crate
-* Skip empty chunks when returning response from a `Stream` [#1308]
-* Update the `time` dependency to 0.2.7
-* Update `actix-tls` dependency to 2.0.0-alpha.1
-* Update `rustls` dependency to 0.17
+* Fix logger request duration calculation #152
 
-[#1308]: https://github.com/actix/actix-web/pull/1308
+* Fix prefix and static file serving #168
 
-## [2.0.0] - 2019-12-25
 
-### Changed
+## 0.4.10 (2018-03-20)
 
-* Rename `HttpServer::start()` to `HttpServer::run()`
+* Use `Error` instead of `InternalError` for `error::ErrorXXXX` methods
 
-* Allow to gracefully stop test server via `TestServer::stop()`
+* Allow to set client request timeout
 
-* Allow to specify multi-patterns for resources
+* Allow to set client websocket handshake timeout
 
-## [2.0.0-rc] - 2019-12-20
+* Refactor `TestServer` configuration
 
-### Changed
+* Fix server websockets big payloads support
 
-* Move `BodyEncoding` to `dev` module #1220
+* Fix http/2 date header generation
 
-* Allow to set `peer_addr` for TestRequest #1074
 
-* Make web::Data deref to Arc<T> #1214
+## 0.4.9 (2018-03-16)
 
-* Rename `App::register_data()` to `App::app_data()`
+* Allow to disable http/2 support
 
-* `HttpRequest::app_data<T>()` returns `Option<&T>` instead of `Option<&Data<T>>`
+* Wake payload reading task when data is available
 
-### Fixed
+* Fix server keep-alive handling
 
-* Fix `AppConfig::secure()` is always false. #1202
+* Send Query Parameters in client requests #120
 
+* Move brotli encoding to a feature
 
-## [2.0.0-alpha.6] - 2019-12-15
+* Add option of default handler for `StaticFiles` handler #57
 
-### Fixed
+* Add basic client connection pooling
 
-* Fixed compilation with default features off
 
-## [2.0.0-alpha.5] - 2019-12-13
+## 0.4.8 (2018-03-12)
 
-### Added
+* Allow to set read buffer capacity for server request
 
-* Add test server, `test::start()` and `test::start_with()`
+* Handle WouldBlock error for socket accept call
 
-## [2.0.0-alpha.4] - 2019-12-08
 
-### Deleted
+## 0.4.7 (2018-03-11)
 
-* Delete HttpServer::run(), it is not useful with async/await
+* Fix panic on unknown content encoding
 
-## [2.0.0-alpha.3] - 2019-12-07
+* Fix connection get closed too early
 
-### Changed
+* Fix streaming response handling for http/2
 
-* Migrate to tokio 0.2
+* Better sleep on error support
 
 
-## [2.0.0-alpha.1] - 2019-11-22
+## 0.4.6 (2018-03-10)
 
-### Changed
+* Fix client cookie handling
 
-* Migrated to `std::future`
+* Fix json content type detection
 
-* Remove implementation of `Responder` for `()`. (#1167)
+* Fix CORS middleware #117
 
+* Optimize websockets stream support
 
-## [1.0.9] - 2019-11-14
 
-### Added
+## 0.4.5 (2018-03-07)
 
-* Add `Payload::into_inner` method and make stored `def::Payload` public. (#1110)
+* Fix compression #103 and #104
 
-### Changed
+* Fix client cookie handling #111
 
-* Support `Host` guards when the `Host` header is unset (e.g. HTTP/2 requests) (#1129)
+* Non-blocking processing of a `NamedFile`
 
+* Enable compression support for `NamedFile`
 
-## [1.0.8] - 2019-09-25
+* Better support for `NamedFile` type
 
-### Added
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
 
-* Add `Scope::register_data` and `Resource::register_data` methods, parallel to
-  `App::register_data`.
+* Add native-tls support for client
 
-* Add `middleware::Condition` that conditionally enables another middleware
+* Allow client connection timeout to be set #108
 
-* Allow to re-construct `ServiceRequest` from `HttpRequest` and `Payload`
+* Allow to use std::net::TcpListener for HttpServer
 
-* Add `HttpServer::listen_uds` for ability to listen on UDS FD rather than path,
-  which is useful for example with systemd.
+* Handle panics in worker threads
 
-### Changed
 
-* Make UrlEncodedError::Overflow more informative
+## 0.4.4 (2018-03-04)
 
-* Use actix-testing for testing utils
+* Allow to use Arc<Vec<u8>> as response/request body
 
+* Fix handling of requests with an encoded body with a length > 8192 #93
 
-## [1.0.7] - 2019-08-29
+## 0.4.3 (2018-03-03)
 
-### Fixed
+* Fix request body read bug
 
-* Request Extensions leak #1062
+* Fix segmentation fault #79
 
+* Set reuse address before bind #90
 
-## [1.0.6] - 2019-08-28
 
-### Added
+## 0.4.2 (2018-03-02)
 
-* Re-implement Host predicate (#989)
+* Better naming for websockets implementation
 
-* Form implements Responder, returning a `application/x-www-form-urlencoded` response
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
 
-* Add `into_inner` to `Data`
+* Add csrf middleware for filter for cross-site request forgery #89
 
-* Add `test::TestRequest::set_form()` convenience method to automatically serialize data and set
-  the header in test requests.
+* Fix disconnect on idle connections
 
-### Changed
 
-* `Query` payload made `pub`. Allows user to pattern-match the payload.
+## 0.4.1 (2018-03-01)
 
-* Enable `rust-tls` feature for client #1045
+* Rename `Route::p()` to `Route::filter()`
 
-* Update serde_urlencoded to 0.6.1
+* Better naming for http codes
 
-* Update url to 2.1
+* Fix payload parse in situation when socket data is not ready.
 
+* Fix Session mutable borrow lifetime #87
 
-## [1.0.5] - 2019-07-18
 
-### Added
+## 0.4.0 (2018-02-28)
 
-* Unix domain sockets (HttpServer::bind_uds) #92
+* Actix 0.5 compatibility
 
-* Actix now logs errors resulting in "internal server error" responses always, with the `error`
-  logging level
+* Fix request json/urlencoded loaders
 
-### Fixed
+* Simplify HttpServer type definition
 
-* Restored logging of errors through the `Logger` middleware
+* Added HttpRequest::encoding() method
 
+* Added HttpRequest::mime_type() method
 
-## [1.0.4] - 2019-07-17
+* Added HttpRequest::uri_mut(), allows to modify request uri
 
-### Added
+* Added StaticFiles::index_file()
 
-* Add `Responder` impl for `(T, StatusCode) where T: Responder`
+* Added http client
 
-* Allow to access app's resource map via
-  `ServiceRequest::resource_map()` and `HttpRequest::resource_map()` methods.
+* Added websocket client
 
-### Changed
+* Added TestServer::ws(), test websockets client
 
-* Upgrade `rand` dependency version to 0.7
+* Added TestServer http client support
 
+* Allow to override content encoding on application level
 
-## [1.0.3] - 2019-06-28
 
-### Added
+## 0.3.3 (2018-01-25)
 
-* Support asynchronous data factories #850
+* Stop processing any events after context stop
 
-### Changed
+* Re-enable write back-pressure for h1 connections
 
-*  Use `encoding_rs` crate instead of unmaintained `encoding` crate
+* Refactor HttpServer::start_ssl() method
 
+* Upgrade openssl to 0.10
 
-## [1.0.2] - 2019-06-17
 
-### Changed
+## 0.3.2 (2018-01-21)
 
-* Move cors middleware to `actix-cors` crate.
+* Fix HEAD requests handling
 
-* Move identity middleware to `actix-identity` crate.
+* Log request processing errors
 
+* Always enable content encoding if encoding explicitly selected
 
-## [1.0.1] - 2019-06-17
+* Allow multiple Applications on a single server with different state #49
 
-### Added
+* CORS middleware: allowed_headers is defaulting to None #50
 
-* Add support for PathConfig #903
 
-* Add `middleware::identity::RequestIdentity` trait to `get_identity` from `HttpMessage`.
+## 0.3.1 (2018-01-13)
 
-### Changed
+* Fix directory entry path #47
 
-* Move cors middleware to `actix-cors` crate.
+* Do not enable chunked encoding for HTTP/1.0
 
-* Move identity middleware to `actix-identity` crate.
+* Allow explicitly disable chunked encoding
 
-* Disable default feature `secure-cookies`.
 
-* Allow to test an app that uses async actors #897
+## 0.3.0 (2018-01-12)
 
-* Re-apply patch from #637 #894
+* HTTP/2 Support
 
-### Fixed
+* Refactor streaming responses
 
-* HttpRequest::url_for is broken with nested scopes #915
+* Refactor error handling
 
+* Asynchronous middlewares
 
-## [1.0.0] - 2019-06-05
+* Refactor logger middleware
 
-### Added
+* Content compression/decompression (br, gzip, deflate)
 
-* Add `Scope::configure()` method.
+* Server multi-threading
 
-* Add `ServiceRequest::set_payload()` method.
+* Gracefull shutdown support
 
-* Add `test::TestRequest::set_json()` convenience method to automatically
-  serialize data and set header in test requests.
 
-* Add macros for head, options, trace, connect and patch http methods
+## 0.2.1 (2017-11-03)
 
-### Changed
+* Allow to start tls server with `HttpServer::serve_tls`
 
-* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
+* Export `Frame` enum
 
-### Fixed
+* Add conversion impl from `HttpResponse` and `BinaryBody` to a `Frame`
 
-* Fix Logger request time format, and use rfc3339. #867
 
-* Clear http requests pool on app service drop #860
+## 0.2.0 (2017-10-30)
 
+* Do not use `http::Uri` as it can not parse some valid paths
 
-## [1.0.0-rc] - 2019-05-18
+* Refactor response `Body`
 
-### Added
+* Refactor `RouteRecognizer` usability
 
-* Add `Query<T>::from_query()` to extract parameters from a query string. #846
-* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
+* Refactor `HttpContext::write`
 
-### Changed
+* Refactor `Payload` stream
 
-* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
+* Re-use `BinaryBody` for `Frame::Payload`
 
-### Fixed
+* Stop http actor on `write_eof`
 
-* Codegen with parameters in the path only resolves the first registered endpoint #841
+* Fix disconnection handling.
 
 
-## [1.0.0-beta.4] - 2019-05-12
+## 0.1.0 (2017-10-23)
 
-### Added
-
-* Allow to set/override app data on scope level
-
-### Changed
-
-* `App::configure` take an `FnOnce` instead of `Fn`
-* Upgrade actix-net crates
-
-
-## [1.0.0-beta.3] - 2019-05-04
-
-### Added
-
-* Add helper function for executing futures `test::block_fn()`
-
-### Changed
-
-* Extractor configuration could be registered with `App::data()`
-  or with `Resource::data()` #775
-
-* Route data is unified with app data, `Route::data()` moved to resource
-  level to `Resource::data()`
-
-* CORS handling without headers #702
-
-* Allow constructing `Data` instances to avoid double `Arc` for `Send + Sync` types.
-
-### Fixed
-
-* Fix `NormalizePath` middleware impl #806
-
-### Deleted
-
-* `App::data_factory()` is deleted.
-
-
-## [1.0.0-beta.2] - 2019-04-24
-
-### Added
-
-* Add raw services support via `web::service()`
-
-* Add helper functions for reading response body `test::read_body()`
-
-* Add support for `remainder match` (i.e "/path/{tail}*")
-
-* Extend `Responder` trait, allow to override status code and headers.
-
-* Store visit and login timestamp in the identity cookie #502
-
-### Changed
-
-* `.to_async()` handler can return `Responder` type #792
-
-### Fixed
-
-* Fix async web::Data factory handling
-
-
-## [1.0.0-beta.1] - 2019-04-20
-
-### Added
-
-* Add helper functions for reading test response body,
- `test::read_response()` and test::read_response_json()`
-
-* Add `.peer_addr()` #744
-
-* Add `NormalizePath` middleware
-
-### Changed
-
-* Rename `RouterConfig` to `ServiceConfig`
-
-* Rename `test::call_success` to `test::call_service`
-
-* Removed `ServiceRequest::from_parts()` as it is unsafe to create from parts.
-
-* `CookieIdentityPolicy::max_age()` accepts value in seconds
-
-### Fixed
-
-* Fixed `TestRequest::app_data()`
-
-
-## [1.0.0-alpha.6] - 2019-04-14
-
-### Changed
-
-* Allow using any service as default service.
-
-* Remove generic type for request payload, always use default.
-
-* Removed `Decompress` middleware. Bytes, String, Json, Form extractors
-  automatically decompress payload.
-
-* Make extractor config type explicit. Add `FromRequest::Config` associated type.
-
-
-## [1.0.0-alpha.5] - 2019-04-12
-
-### Added
-
-* Added async io `TestBuffer` for testing.
-
-### Deleted
-
-* Removed native-tls support
-
-
-## [1.0.0-alpha.4] - 2019-04-08
-
-### Added
-
-* `App::configure()` allow to offload app configuration to different methods
-
-* Added `URLPath` option for logger
-
-* Added `ServiceRequest::app_data()`, returns `Data<T>`
-
-* Added `ServiceFromRequest::app_data()`, returns `Data<T>`
-
-### Changed
-
-* `FromRequest` trait refactoring
-
-* Move multipart support to actix-multipart crate
-
-### Fixed
-
-* Fix body propagation in Response::from_error. #760
-
-
-## [1.0.0-alpha.3] - 2019-04-02
-
-### Changed
-
-* Renamed `TestRequest::to_service()` to `TestRequest::to_srv_request()`
-
-* Renamed `TestRequest::to_response()` to `TestRequest::to_srv_response()`
-
-* Removed `Deref` impls
-
-### Removed
-
-* Removed unused `actix_web::web::md()`
-
-
-## [1.0.0-alpha.2] - 2019-03-29
-
-### Added
-
-* Rustls support
-
-### Changed
-
-* Use forked cookie
-
-* Multipart::Field renamed to MultipartField
-
-## [1.0.0-alpha.1] - 2019-03-28
-
-### Changed
-
-* Complete architecture re-design.
-
-* Return 405 response if no matching route found within resource #538
+* First release

CODE_OF_CONDUCT.md

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

Cargo.toml

@@ -1,161 +1,115 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.8"
+version = "0.5.8"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
-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"
-license = "MIT OR Apache-2.0"
-edition = "2018"
+description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
+readme = "README.md"
+keywords = ["http", "web", "framework", "async", "futures"]
+homepage = "https://github.com/actix/actix-web"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-web/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server",
+              "web-programming::http-client",
+              "web-programming::websocket"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+build = "build.rs"
 
-[package.metadata.docs.rs]
-# features that docs.rs will build with
-features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd", "cookies", "secure-cookies"]
+[badges]
+travis-ci = { repository = "actix/actix-web", branch = "master" }
+appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
 
 [lib]
 name = "actix_web"
 path = "src/lib.rs"
 
-[workspace]
-members = [
-    ".",
-    "awc",
-    "actix-http",
-    "actix-files",
-    "actix-multipart",
-    "actix-web-actors",
-    "actix-web-codegen",
-    "actix-http-test",
-    "actix-test",
-]
-# enable when MSRV is 1.51+
-# resolver = "2"
-
 [features]
-default = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
+default = ["session", "brotli", "flate2-c"]
 
-# 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"]
-
-# support for cookies
-cookies = ["cookie"]
-
-# secure cookies feature
-secure-cookies = ["cookie/secure"]
+# tls
+tls = ["native-tls", "tokio-tls"]
 
 # openssl
-openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
+alpn = ["openssl", "tokio-openssl"]
 
-# rustls
-rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]
+# sessions feature, session require "ring" crate and c compiler
+session = ["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 = []
+# brotli encoding, requires c compiler
+brotli = ["brotli2"]
+
+# miniz-sys backend for flate2 crate
+flate2-c = ["flate2/miniz-sys"]
+
+# rust backend for flate2 crate
+flate2-rust = ["flate2/rust_backend"]
 
 [dependencies]
-actix-codec = "0.4.0"
-actix-macros = "0.2.1"
-actix-router = "0.2.7"
-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.5", default-features = false, optional = true }
+actix = "^0.5.5"
 
-actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.8"
-
-ahash = "0.7"
-bytes = "1"
-cfg-if = "1"
-cookie = { version = "0.15", features = ["percent-encode"], optional = true }
-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"
+base64 = "0.9"
+bitflags = "1.0"
+failure = "0.1.1"
+h2 = "0.1"
+http = "^0.1.5"
+httparse = "1.2"
+http-range = "0.1"
+libc = "0.2"
 log = "0.4"
 mime = "0.3"
-paste = "1"
-pin-project = "1.0.0"
-regex = "1.4"
-serde = { version = "1.0", features = ["derive"] }
+mime_guess = "2.0.0-alpha"
+num_cpus = "1.0"
+percent-encoding = "1.0"
+rand = "0.4"
+regex = "0.2"
+serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.7"
-smallvec = "1.6"
-socket2 = "0.4.0"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-url = "2.1"
+serde_urlencoded = "0.5"
+sha1 = "0.6"
+smallvec = "0.6"
+time = "0.1"
+encoding = "0.2"
+language-tags = "0.2"
+lazy_static = "1.0"
+url = { version="1.7", features=["query_encoding"] }
+cookie = { version="0.10", features=["percent-encode"] }
+brotli2 = { version="^0.3.2", optional = true }
+flate2 = { version="1.0", optional = true, default-features = false }
+
+# io
+mio = "^0.6.13"
+net2 = "0.2"
+bytes = "0.4"
+byteorder = "1"
+futures = "0.1"
+futures-cpupool = "0.1"
+tokio-io = "0.1"
+tokio-core = "0.1"
+
+# native-tls
+native-tls = { version="0.1", optional = true }
+tokio-tls = { version="0.1", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.2", optional = true }
 
 [dev-dependencies]
-actix-test = { version = "0.1.0-beta.3", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.7", features = ["openssl"] }
+env_logger = "0.5"
+serde_derive = "1.0"
 
-brotli2 = "0.3.2"
-criterion = { version = "0.3", features = ["html_reports"] }
-env_logger = "0.8"
-flate2 = "1.0.13"
-zstd = "0.7"
-rand = "0.8"
-rcgen = "0.8"
-tls-openssl = { package = "openssl", version = "0.10.9" }
-tls-rustls = { package = "rustls", version = "0.19.0" }
+[build-dependencies]
+version_check = "0.1"
 
 [profile.release]
 lto = true
 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-test = { path = "actix-test" }
-actix-web = { path = "." }
-actix-web-actors = { path = "actix-web-actors" }
-actix-web-codegen = { path = "actix-web-codegen" }
-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
-
-[[bench]]
-name = "service"
-harness = false
-
-[[bench]]
-name = "responder"
-harness = false
+[workspace]
+members = [
+  "./",
+  "tools/wsload/",
+]

LICENSE-APACHE

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

LICENSE-MIT

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

MIGRATION-0.4-0.5.md

@@ -0,0 +1,30 @@
+# Migration from 0.4 to 0.5
+
+* `HttpResponseBuilder::body()`, `.finish()`, `.json()`
+   methods return `HttpResponse` instead of `Result<HttpResponse>`
+
+* `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
+   moved to `actix_web::http` module
+
+* `actix_web::header` moved to `actix_web::http::header`
+
+* `NormalizePath` moved to `actix_web::http` module
+
+* `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
+  shortcut for `actix_web::server::HttpServer::new()`
+
+* `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
+
+* `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
+
+* `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
+
+* `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
+   functions should be used instead
+
+* `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
+  instead of `Result<_, http::Error>`
+
+* `Application` renamed to a `App`
+
+* `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`

MIGRATION.md

@@ -1,674 +0,0 @@
-## 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()`.
-  
-  Before: `#[get("/test/")`  
-  After: `#[get("/test")`  
-
-  Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
-
-* 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
-
-* The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
-  simply a `T`. To access a `Data<T>` use `ServiceRequest::app_data::<Data<T>>()`.
-
-* Cookie handling has been offloaded to the `cookie` crate:
-  * `USERINFO_ENCODE_SET` is no longer exposed. Percent-encoding is still supported; check docs.
-  * Some types now require lifetime parameters.
-
-* The time crate was updated to `v0.2`, a major breaking change to the time crate, which affects
-  any `actix-web` method previously expecting a time v0.1 input.
-
-* Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
-  result in `SameSite=None` being sent with the response Set-Cookie header.
-  To create a cookie without a SameSite attribute, remove any calls setting same_site.
-
-* actix-http support for Actors messages was moved to actix-http crate and is enabled 
-  with feature `actors`
-
-* content_length function is removed from actix-http.
-  You can set Content-Length by normally setting the response body or calling no_chunking function. 
-
-* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
-  `u64` instead of a `usize`.
-
-* Code that was using `path.<index>` to access a `web::Path<(A, B, C)>`s elements now needs to use
-  destructuring or `.into_inner()`. For example:
-
-  ```rust
-  // Previously:
-  async fn some_route(path: web::Path<(String, String)>) -> String {
-    format!("Hello, {} {}", path.0, path.1)
-  }
-
-  // Now (this also worked before):
-  async fn some_route(path: web::Path<(String, String)>) -> String {
-    let (first_name, last_name) = path.into_inner();
-    format!("Hello, {} {}", first_name, last_name)
-  }
-  // Or (this wasn't previously supported):
-  async fn some_route(web::Path((first_name, last_name)): web::Path<(String, String)>) -> String {
-    format!("Hello, {} {}", first_name, last_name)
-  }
-  ```
-
-* `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
-  It will need `middleware::normalize::TrailingSlash` when being constructed with `NormalizePath::new(...)`,
-  or for an easier migration you can replace `wrap(middleware::NormalizePath)` with `wrap(middleware::NormalizePath::new(TrailingSlash::MergeOnly))`.
-
-* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
-
-* `HttpServer::maxconnrate` is renamed to the more expressive `HttpServer::max_connection_rate`.
-
-
-## 2.0.0
-
-* `HttpServer::start()` renamed to `HttpServer::run()`. It also possible to
-  `.await` on `run` method result, in that case it awaits server exit.
-
-* `App::register_data()` renamed to `App::app_data()` and accepts any type `T: 'static`.
-  Stored data is available via `HttpRequest::app_data()` method at runtime.
-
-* Extractor configuration must be registered with `App::app_data()` instead of `App::data()`
-
-* Sync handlers has been removed. `.to_async()` method has been renamed to `.to()`
-  replace `fn` with `async fn` to convert sync handler to async
-
-* `actix_http_test::TestServer` moved to `actix_web::test` module. To start
-  test server use `test::start()` or `test_start_with_config()` methods
-
-* `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
-  http response.
-
-* Feature `rust-tls` renamed to `rustls`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rust-tls"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rustls"] }
-    ```
-
-* Feature `ssl` renamed to `openssl`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["ssl"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["openssl"] }
-    ```
-* `Cors` builder now requires that you call `.finish()` to construct the middleware
-
-## 1.0.1
-
-* Cors middleware has been moved to `actix-cors` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::cors::Cors;
-  ```
-
-  use
-
-  ```rust
-  use actix_cors::Cors;
-  ```
-
-* Identity middleware has been moved to `actix-identity` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-  use
-
-  ```rust
-  use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-
-## 1.0.0
-
-* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
-
-  instead of
-
-  ```rust
-
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-
-  impl FromRequest for YourExtractor {
-     type Config = ExtractorConfig;
-     type Result = Result<YourExtractor, Error>;
-
-     fn from_request(req: &HttpRequest, cfg: &Self::Config) -> Self::Result {
-         println!("use the config: {:?}", cfg.config);
-         ...
-     }
-  }
-
-  App::new().resource("/route_with_config", |r| {
-     r.post().with_config(handler_fn, |cfg| {
-         cfg.0.config = "test".to_string();
-     })
-  })
-
-  ```
-
-  use the HttpRequest to get the configuration like any other `Data` with `req.app_data::<C>()` and set it with the `data()` method on the `resource`
-
-  ```rust
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-
-  impl FromRequest for YourExtractor {
-     type Error = Error;
-     type Future = Result<Self, Self::Error>;
-     type Config = ExtractorConfig;
-
-     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-         let cfg = req.app_data::<ExtractorConfig>();
-         println!("config data?: {:?}", cfg.unwrap().role);
-         ...
-     }
-  }
-
-  App::new().service(
-     resource("/route_with_config")
-         .data(ExtractorConfig {
-             config: "test".to_string(),
-         })
-         .route(post().to(handler_fn)),
-  )
-  ```
-
-* Resource registration. 1.0 version uses generalized resource
-  registration via `.service()` method.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's or Scope's `.service()` method. `.service()` method accepts
-  object that implements `HttpServiceFactory` trait. By default
-  actix-web provides `Resource` and `Scope` services.
-
-  ```rust
-    App.new().service(
-        web::resource("/welcome")
-            .route(web::get().to(welcome))
-            .route(web::post().to(post_handler))
-  ```
-
-* Scope registration.
-
-  instead of
-
-  ```rust
-      let app = App::new().scope("/{project_id}", |scope| {
-            scope
-                .resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
-      });
-  ```
-
-  use `.service()` for registration and `web::scope()` as scope object factory.
-
-  ```rust
-      let app = App::new().service(
-          web::scope("/{project_id}")
-              .service(web::resource("/path1").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path2").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path3").to(|| HttpResponse::MethodNotAllowed()))
-      );
-  ```
-
-* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.with(welcome))
-  ```
-
-  use `.to()` or `.to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* Passing arguments to handler with extractors, multiple arguments are allowed
-
-  instead of
-
-  ```rust
-  fn welcome((body, req): (Bytes, HttpRequest)) -> ... {
-    ...
-  }
-  ```
-
-  use multiple arguments
-
-  ```rust
-  fn welcome(body: Bytes, req: HttpRequest) -> ... {
-    ...
-  }
-  ```
-
-* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
-  Use `.to()` for handlers and `.to_async()` for async handlers. Handler function
-  must use extractors.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's `to()` or `to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* `HttpRequest` does not provide access to request's payload stream.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req
-       .payload()
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-       .responder()
-  }
-  ```
-
-  use `Payload` extractor
-
-  ```rust
-  fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
-     stream
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-  }
-  ```
-
-* `State` is now `Data`.  You register Data during the App initialization process
-  and then access it from handlers either using a Data extractor or using
-  HttpRequest's api.
-
-  instead of
-
-  ```rust
-    App.with_state(T)
-  ```
-
-  use App's `data` method
-
-  ```rust
-	App.new()
-       .data(T)
-  ```
-
-  and either use the Data extractor within your handler
-
-  ```rust
-    use actix_web::web::Data;
-
-	fn endpoint_handler(Data<T>)){
-      ...
-    }
-  ```
-
-  .. or access your Data element from the HttpRequest
-
-  ```rust
-	fn endpoint_handler(req: HttpRequest) {
-		let data: Option<Data<T>> = req.app_data::<T>();
-    }
-  ```
-
-
-* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
-
-  instead of
-
-  ```rust
-	use actix_web::AsyncResponder;
-
-    fn endpoint_handler(...) -> impl Future<Item=HttpResponse, Error=Error>{
-		...
-        .responder()
-	}
-  ```
-
-  .. simply omit AsyncResponder and the corresponding responder() finish method
-
-
-* Middleware
-
-  instead of
-
-  ```rust
-      let app = App::new()
-           .middleware(middleware::Logger::default())
-  ```
-
-  use `.wrap()` method
-
-  ```rust
-      let app = App::new()
-           .wrap(middleware::Logger::default())
-           .route("/index.html", web::get().to(index));
-  ```
-
-* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
-  method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Responder {
-     req.body()
-       .and_then(|body| {
-          ...
-       })
-  }
-  ```
-
-  use
-
-  ```rust
-  fn index(body: Bytes) -> Responder {
-     ...
-  }
-  ```
-
-* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
-
-* StaticFiles and NamedFile have been moved to a separate crate.
-
-  instead of `use actix_web::fs::StaticFile`
-
-  use `use actix_files::Files`
-
-  instead of `use actix_web::fs::Namedfile`
-
-  use `use actix_files::NamedFile`
-
-* Multipart has been moved to a separate crate.
-
-  instead of `use actix_web::multipart::Multipart`
-
-  use `use actix_multipart::Multipart`
-
-* Response compression is not enabled by default.
-  To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
-
-* Session middleware moved to actix-session crate
-
-* Actors support have been moved to `actix-web-actors` crate
-
-* Custom Error
-
-  Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
-
-  Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
-
-  ```rust
-  fn render_response(&self) -> HttpResponse {
-    self.error_response()
-  }
-  ```
-
-## 0.7.15
-
-* The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
-  your routes, you should use `%20`.
-
-  instead of
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/my index", |r| {
-             r.method(http::Method::GET)
-                    .with(index);
-         });
-    }
-    ```
-
-  use
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/my%20index", |r| {
-             r.method(http::Method::GET)
-                    .with(index);
-         });
-    }
-    ```
-
-* If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
-
-
-## 0.7.4
-
-* `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
-  even for handler with one parameter.
-
-
-## 0.7
-
-* `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
-  use `HttpMessage::payload()` method.
-
-  instead of
-
-    ```rust
-    fn index(req: HttpRequest) -> impl Responder {
-         req
-            .from_err()
-            .fold(...)
-            ....
-    }
-    ```
-
-  use `.payload()`
-
-    ```rust
-    fn index(req: HttpRequest) -> impl Responder {
-         req
-            .payload()  // <- get request payload stream
-            .from_err()
-            .fold(...)
-            ....
-    }
-    ```
-
-* [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
-  trait uses `&HttpRequest` instead of `&mut HttpRequest`.
-
-* Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
-
-    instead of
-
-    ```rust
-    fn index(query: Query<..>, info: Json<MyStruct) -> impl Responder {}
-    ```
-
-    use tuple of extractors and use `.with()` for registration:
-
-    ```rust
-    fn index((query, json): (Query<..>, Json<MyStruct)) -> impl Responder {}
-    ```
-
-* `Handler::handle()` uses `&self` instead of `&mut self`
-
-* `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
-
-* Removed deprecated `HttpServer::threads()`, use
-  [HttpServer::workers()](https://actix.rs/actix-web/actix_web/server/struct.HttpServer.html#method.workers) instead.
-
-* Renamed `client::ClientConnectorError::Connector` to
-  `client::ClientConnectorError::Resolver`
-
-* `Route::with()` does not return `ExtractorConfig`, to configure
-  extractor use `Route::with_config()`
-
-    instead of
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/index.html", |r| {
-             r.method(http::Method::GET)
-                    .with(index)
-                    .limit(4096);  // <- limit size of the payload
-         });
-    }
-    ```
-
-    use
-
-    ```rust
-
-    fn main() {
-         let app = App::new().resource("/index.html", |r| {
-             r.method(http::Method::GET)
-                    .with_config(index, |cfg| { // <- register handler
-                       cfg.limit(4096);  // <- limit size of the payload
-                     })
-         });
-    }
-    ```
-
-* `Route::with_async()` does not return `ExtractorConfig`, to configure
-  extractor use `Route::with_async_config()`
-
-
-## 0.6
-
-* `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
-
-* `ws::Message::Close` now includes optional close reason.
-  `ws::CloseCode::Status` and `ws::CloseCode::Empty` have been removed.
-
-* `HttpServer::threads()` renamed to `HttpServer::workers()`.
-
-* `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
-  Use `HttpServer::bind_ssl()` and `HttpServer::bind_tls()` instead.
-
-* `HttpRequest::extensions()` returns read only reference to the request's Extension
-  `HttpRequest::extensions_mut()` returns mutable reference.
-
-* Instead of
-
-   `use actix_web::middleware::{
-        CookieSessionBackend, CookieSessionError, RequestSession,
-        Session, SessionBackend, SessionImpl, SessionStorage};`
-
-  use `actix_web::middleware::session`
-
-   `use actix_web::middleware::session{CookieSessionBackend, CookieSessionError,
-        RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};`
-
-* `FromRequest::from_request()` accepts mutable reference to a request
-
-* `FromRequest::Result` has to implement `Into<Reply<Self>>`
-
-* [`Responder::respond_to()`](
-  https://actix.rs/actix-web/actix_web/trait.Responder.html#tymethod.respond_to)
-  is generic over `S`
-
-*  Use `Query` extractor instead of HttpRequest::query()`.
-
-   ```rust
-   fn index(q: Query<HashMap<String, String>>) -> Result<..> {
-       ...
-   }
-   ```
-
-   or
-
-   ```rust
-   let q = Query::<HashMap<String, String>>::extract(req);
-   ```
-
-* Websocket operations are implemented as `WsWriter` trait.
-  you need to use `use actix_web::ws::WsWriter`
-
-
-## 0.5
-
-* `HttpResponseBuilder::body()`, `.finish()`, `.json()`
-   methods return `HttpResponse` instead of `Result<HttpResponse>`
-
-* `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
-   moved to `actix_web::http` module
-
-* `actix_web::header` moved to `actix_web::http::header`
-
-* `NormalizePath` moved to `actix_web::http` module
-
-* `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
-  shortcut for `actix_web::server::HttpServer::new()`
-
-* `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
-
-* `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
-
-* `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
-
-* `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
-   functions should be used instead
-
-* `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
-  instead of `Result<_, http::Error>`
-
-* `Application` renamed to a `App`
-
-* `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`

Makefile

@@ -0,0 +1,14 @@
+.PHONY: default build test doc book clean
+
+CARGO_FLAGS := --features "$(FEATURES) alpn"
+
+default: test
+
+build:
+	cargo build $(CARGO_FLAGS)
+
+test: build clippy
+	cargo test $(CARGO_FLAGS)
+
+doc: build
+	cargo doc --no-deps $(CARGO_FLAGS)

README.md

@@ -1,109 +1,88 @@
-<div align="center">
-  <h1>Actix Web</h1>
-  <p>
-    <strong>Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust</strong>
-  </p>
-  <p>
+# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](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)
 
-[![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.8)](https://docs.rs/actix-web/4.0.0-beta.8)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.8/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.8)
-<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)
-[![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)
-[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 
-  </p>
-</div>
-
-## Features
-
-* Supports *HTTP/1.x* and *HTTP/2*
+* Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/book/actix-web/sec-12-http2.html) protocols
 * 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)
-* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
+* Client/server [WebSockets](https://actix.rs/book/actix-web/sec-11-websockets.html) support
+* Transparent content compression/decompression (br, gzip, deflate)
+* Configurable [request routing](https://actix.rs/book/actix-web/sec-6-url-dispatch.html)
+* Graceful server shutdown
 * 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.46+
+* SSL support with OpenSSL or `native-tls`
+* Middlewares ([Logger](https://actix.rs/book/actix-web/sec-9-middlewares.html#logging),
+  [Session](https://actix.rs/book/actix-web/sec-9-middlewares.html#user-sessions),
+  [Redis sessions](https://github.com/actix/actix-redis),
+  [DefaultHeaders](https://actix.rs/book/actix-web/sec-9-middlewares.html#default-headers),
+  [CORS](https://actix.rs/actix-web/actix_web/middleware/cors/index.html),
+  [CSRF](https://actix.rs/actix-web/actix_web/middleware/csrf/index.html))
+* Built on top of [Actix actor framework](https://github.com/actix/actix)
 
-## Documentation
+## Documentation & community resources
 
-* [Website & User Guide](https://actix.rs)
-* [Examples Repository](https://github.com/actix/examples)
-* [API Documentation](https://docs.rs/actix-web)
-* [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)
+* [User Guide](https://actix.rs/book/actix-web/)
+* [API Documentation (Development)](https://actix.rs/actix-web/actix_web/)
+* [API Documentation (Releases)](https://docs.rs/actix-web/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-web](https://crates.io/crates/actix-web)
+* Minimum supported Rust version: 1.21 or later
 
 ## Example
 
-Dependencies:
-
-```toml
-[dependencies]
-actix-web = "3"
-```
-
-Code:
-
 ```rust
-use actix_web::{get, web, App, HttpServer, Responder};
+extern crate actix_web;
+use actix_web::{http, server, App, Path};
 
-#[get("/{id}/{name}/index.html")]
-async fn index(web::Path((id, name)): web::Path<(u32, String)>) -> impl Responder {
-    format!("Hello {}! id:{}", name, id)
+fn index(info: Path<(u32, String)>) -> String {
+    format!("Hello {}! id:{}", info.0, info.1)
 }
 
-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-    HttpServer::new(|| App::new().service(index))
-        .bind("127.0.0.1:8080")?
-        .run()
-        .await
+fn main() {
+    server::new(
+        || App::new()
+            .route("/{id}/{name}/index.html", http::Method::GET, index))
+        .bind("127.0.0.1:8080").unwrap()
+        .run();
 }
 ```
 
 ### 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/)
+* [Basics](https://github.com/actix/examples/tree/master/basics/)
+* [Stateful](https://github.com/actix/examples/tree/master/state/)
+* [Protobuf support](https://github.com/actix/examples/tree/master/protobuf/)
+* [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
+* [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
+* [Tera](https://github.com/actix/examples/tree/master/template_tera/) / 
+  [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
+* [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
+* [r2d2](https://github.com/actix/examples/tree/master/r2d2/)
+* [SSL / HTTP/2.0](https://github.com/actix/examples/tree/master/tls/)
+* [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [Json](https://github.com/actix/examples/tree/master/json/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.
 
 ## 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-r15&hw=ph&test=plaintext)
+
+* Some basic benchmarks could be found in this [repository](https://github.com/fafhrd91/benchmarks).
 
 ## 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])
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or
-  [http://opensource.org/licenses/MIT])
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-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 maintainer of actix-web, @fafhrd91, promises to
+intervene to uphold that code of conduct.

actix-files/CHANGES.md

@@ -1,153 +0,0 @@
-# Changes
-
-## Unreleased - 2021-xx-xx
-
-
-## 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
-
-
-## 0.4.1 - 2020-11-24
-* Clarify order of parameters in `Files::new` and improve docs.
-
-
-## 0.4.0 - 2020-10-06
-* Add `Files::prefer_utf8` option that adds UTF-8 charset on certain response types. [#1714]
-
-[#1714]: https://github.com/actix/actix-web/pull/1714
-
-
-## 0.3.0 - 2020-09-11
-* No significant changes from 0.3.0-beta.1.
-
-
-## 0.3.0-beta.1 - 2020-07-15
-* Update `v_htmlescape` to 0.10
-* Update `actix-web` and `actix-http` dependencies to beta.1
-
-
-## 0.3.0-alpha.1 - 2020-05-23
-* Update `actix-web` and `actix-http` dependencies to alpha
-* Fix some typos in the docs
-* Bump minimum supported Rust version to 1.40
-* Support sending Content-Length when Content-Range is specified [#1384]
-
-[#1384]: https://github.com/actix/actix-web/pull/1384
-
-
-## 0.2.1 - 2019-12-22
-* Use the same format for file URLs regardless of platforms
-
-
-## 0.2.0 - 2019-12-20
-* Fix BodyEncoding trait import #1220
-
-
-## 0.2.0-alpha.1 - 2019-12-07
-* Migrate to `std::future`
-
-
-## 0.1.7 - 2019-11-06
-* Add an additional `filename*` param in the `Content-Disposition` header of
-  `actix_files::NamedFile` to be more compatible. (#1151)
-
-## 0.1.6 - 2019-10-14
-* Add option to redirect to a slash-ended path `Files` #1132
-
-
-## 0.1.5 - 2019-10-08
-* Bump up `mime_guess` crate version to 2.0.1
-* Bump up `percent-encoding` crate version to 2.1
-* Allow user defined request guards for `Files` #1113
-
-
-## 0.1.4 - 2019-07-20
-* Allow to disable `Content-Disposition` header #686
-
-
-## 0.1.3 - 2019-06-28
-* Do not set `Content-Length` header, let actix-http set it #930
-
-
-## 0.1.2 - 2019-06-13
-* Content-Length is 0 for NamedFile HEAD request #914
-* Fix ring dependency from actix-web default features for #741
-
-
-## 0.1.1 - 2019-06-01
-* Static files are incorrectly served as both chunked and with length #812
-
-
-## 0.1.0 - 2019-05-25
-* NamedFile last-modified check always fails due to nano-seconds in file modified date #820
-
-
-## 0.1.0-beta.4 - 2019-05-12
-* Update actix-web to beta.4
-
-
-## 0.1.0-beta.1 - 2019-04-20
-* Update actix-web to beta.1
-
-
-## 0.1.0-alpha.6 - 2019-04-14
-* Update actix-web to alpha6
-
-
-## 0.1.0-alpha.4 - 2019-04-08
-* Update actix-web to alpha4
-
-
-## 0.1.0-alpha.2 - 2019-04-02
-* Add default handler support
-
-
-## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl

actix-files/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "actix-files"
-version = "0.6.0-beta.6"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static file serving for Actix Web"
-keywords = ["actix", "http", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web"
-categories = ["asynchronous", "web-programming::http-server"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_files"
-path = "src/lib.rs"
-
-[dependencies]
-actix-web = { version = "4.0.0-beta.8", default-features = false }
-actix-http = "3.0.0-beta.8"
-actix-service = "2.0.0"
-actix-utils = "3.0.0"
-
-askama_escape = "0.10"
-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"
-log = "0.4"
-mime = "0.3"
-mime_guess = "2.0.1"
-percent-encoding = "2.1"
-
-[dev-dependencies]
-actix-rt = "2.2"
-actix-web = "4.0.0-beta.8"
-actix-test = "0.1.0-beta.3"

actix-files/LICENSE-APACHE

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

actix-files/LICENSE-MIT

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

actix-files/README.md

@@ -1,18 +0,0 @@
-# actix-files
-
-> 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.6)](https://docs.rs/actix-files/0.6.0-beta.6)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![License](https://img.shields.io/crates/l/actix-files.svg)
-<br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.6/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.6)
-[![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)
-
-## 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: 1.46 or later

actix-files/src/chunked.rs

@@ -1,98 +0,0 @@
-use std::{
-    cmp, fmt,
-    fs::File,
-    future::Future,
-    io::{self, Read, Seek},
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use actix_web::{
-    error::{BlockingError, Error},
-    rt::task::{spawn_blocking, JoinHandle},
-};
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-
-#[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,
-        }
-    }
-}
-
-impl fmt::Debug for ChunkedReadFile {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("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;
-
-                if size == counter {
-                    Poll::Ready(None)
-                } else {
-                    let mut file = file
-                        .take()
-                        .expect("ChunkedReadFile polled after completion");
-
-                    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)
-                }
-            }
-            ChunkedReadFileState::Future(ref mut fut) => {
-                let (file, bytes) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-                this.state = ChunkedReadFileState::File(Some(file));
-
-                this.offset += bytes.len() as u64;
-                this.counter += bytes.len() as u64;
-
-                Poll::Ready(Some(Ok(bytes)))
-            }
-        }
-    }
-}

actix-files/src/directory.rs

@@ -1,112 +0,0 @@
-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};
-
-/// A directory; responds with the generated directory listing.
-#[derive(Debug)]
-pub struct Directory {
-    /// Base directory.
-    pub base: PathBuf,
-
-    /// Path of subdirectory to generate listing for.
-    pub path: PathBuf,
-}
-
-impl Directory {
-    /// Create a new directory
-    pub fn new(base: PathBuf, path: PathBuf) -> Directory {
-        Directory { base, path }
-    }
-
-    /// Is this entry visible from this directory?
-    pub fn is_visible(&self, entry: &io::Result<DirEntry>) -> bool {
-        if let Ok(ref entry) = *entry {
-            if let Some(name) = entry.file_name().to_str() {
-                if name.starts_with('.') {
-                    return false;
-                }
-            }
-            if let Ok(ref md) = entry.metadata() {
-                let ft = md.file_type();
-                return ft.is_dir() || ft.is_file() || ft.is_symlink();
-            }
-        }
-        false
-    }
-}
-
-pub(crate) type DirectoryRenderer =
-    dyn Fn(&Directory, &HttpRequest) -> Result<ServiceResponse, io::Error>;
-
-// show file url as relative to static path
-macro_rules! encode_file_url {
-    ($path:ident) => {
-        utf8_percent_encode(&$path, CONTROLS)
-    };
-}
-
-// " -- &quot;  & -- &amp;  ' -- &#x27;  < -- &lt;  > -- &gt;  / -- &#x2f;
-macro_rules! encode_file_name {
-    ($entry:ident) => {
-        escape_html_entity(&$entry.file_name().to_string_lossy(), Html)
-    };
-}
-
-pub(crate) fn directory_listing(
-    dir: &Directory,
-    req: &HttpRequest,
-) -> Result<ServiceResponse, io::Error> {
-    let index_of = format!("Index of {}", req.path());
-    let mut body = String::new();
-    let base = Path::new(req.path());
-
-    for entry in dir.path.read_dir()? {
-        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) => base.join(p).to_string_lossy().into_owned(),
-                Err(_) => continue,
-            };
-
-            // if file is a directory, add '/' to the end of the name
-            if let Ok(metadata) = entry.metadata() {
-                if metadata.is_dir() {
-                    let _ = write!(
-                        body,
-                        "<li><a href=\"{}\">{}/</a></li>",
-                        encode_file_url!(p),
-                        encode_file_name!(entry),
-                    );
-                } else {
-                    let _ = write!(
-                        body,
-                        "<li><a href=\"{}\">{}</a></li>",
-                        encode_file_url!(p),
-                        encode_file_name!(entry),
-                    );
-                }
-            } else {
-                continue;
-            }
-        }
-    }
-
-    let html = format!(
-        "<html>\
-         <head><title>{}</title></head>\
-         <body><h1>{}</h1>\
-         <ul>\
-         {}\
-         </ul></body>\n</html>",
-        index_of, index_of, body
-    );
-    Ok(ServiceResponse::new(
-        req.clone(),
-        HttpResponse::Ok()
-            .content_type("text/html; charset=utf-8")
-            .body(html),
-    ))
-}

actix-files/src/encoding.rs

@@ -1,52 +0,0 @@
-use mime::Mime;
-
-/// Transforms MIME `text/*` types into their UTF-8 equivalent, if supported.
-///
-/// MIME types that are converted
-/// - application/javascript
-/// - text/html
-/// - text/css
-/// - text/plain
-/// - text/csv
-/// - text/tab-separated-values
-pub(crate) fn equiv_utf8_text(ct: Mime) -> Mime {
-    // use (roughly) order of file-type popularity for a web server
-
-    if ct == mime::APPLICATION_JAVASCRIPT {
-        return mime::APPLICATION_JAVASCRIPT_UTF_8;
-    }
-
-    if ct == mime::TEXT_HTML {
-        return mime::TEXT_HTML_UTF_8;
-    }
-
-    if ct == mime::TEXT_CSS {
-        return mime::TEXT_CSS_UTF_8;
-    }
-
-    if ct == mime::TEXT_PLAIN {
-        return mime::TEXT_PLAIN_UTF_8;
-    }
-
-    if ct == mime::TEXT_CSV {
-        return mime::TEXT_CSV_UTF_8;
-    }
-
-    if ct == mime::TEXT_TAB_SEPARATED_VALUES {
-        return mime::TEXT_TAB_SEPARATED_VALUES_UTF_8;
-    }
-
-    ct
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_equiv_utf8_text() {
-        assert_eq!(equiv_utf8_text(mime::TEXT_PLAIN), mime::TEXT_PLAIN_UTF_8);
-        assert_eq!(equiv_utf8_text(mime::TEXT_XML), mime::TEXT_XML);
-        assert_eq!(equiv_utf8_text(mime::IMAGE_PNG), mime::IMAGE_PNG);
-    }
-}

actix-files/src/error.rs

@@ -1,42 +0,0 @@
-use actix_web::{http::StatusCode, ResponseError};
-use derive_more::Display;
-
-/// Errors which can occur when serving static files.
-#[derive(Display, Debug, PartialEq)]
-pub enum FilesError {
-    /// Path is not a directory
-    #[allow(dead_code)]
-    #[display(fmt = "Path is not a directory. Unable to serve static files")]
-    IsNotDirectory,
-
-    /// Cannot render directory
-    #[display(fmt = "Unable to render directory without index file")]
-    IsDirectory,
-}
-
-/// Return `NotFound` for `FilesError`
-impl ResponseError for FilesError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::NOT_FOUND
-    }
-}
-
-#[derive(Display, Debug, PartialEq)]
-pub enum UriSegmentError {
-    /// The segment started with the wrapped invalid character.
-    #[display(fmt = "The segment started with the wrapped invalid character")]
-    BadStart(char),
-    /// The segment contained the wrapped invalid character.
-    #[display(fmt = "The segment contained the wrapped invalid character")]
-    BadChar(char),
-    /// The segment ended with the wrapped invalid character.
-    #[display(fmt = "The segment ended with the wrapped invalid character")]
-    BadEnd(char),
-}
-
-/// Return `BadRequest` for `UriSegmentError`
-impl ResponseError for UriSegmentError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
-    }
-}

actix-files/src/files.rs

@@ -1,385 +0,0 @@
-use std::{
-    cell::RefCell,
-    fmt, io,
-    path::{Path, PathBuf},
-    rc::Rc,
-};
-
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
-use actix_utils::future::ok;
-use actix_web::{
-    dev::{
-        AppService, HttpServiceFactory, RequestHead, ResourceDef, ServiceRequest,
-        ServiceResponse,
-    },
-    error::Error,
-    guard::Guard,
-    http::header::DispositionType,
-    HttpRequest,
-};
-use futures_core::future::LocalBoxFuture;
-
-use crate::{
-    directory_listing, named, Directory, DirectoryRenderer, FilesService, HttpNewService,
-    MimeOverride, PathFilter,
-};
-
-/// Static files handling service.
-///
-/// `Files` service must be registered with `App::service()` method.
-///
-/// ```
-/// use actix_web::App;
-/// use actix_files::Files;
-///
-/// let app = App::new()
-///     .service(Files::new("/static", "."));
-/// ```
-pub struct Files {
-    path: String,
-    directory: PathBuf,
-    index: Option<String>,
-    show_index: bool,
-    redirect_to_slash: bool,
-    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,
-}
-
-impl fmt::Debug for Files {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Files")
-    }
-}
-
-impl Clone for Files {
-    fn clone(&self) -> Self {
-        Self {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            default: self.default.clone(),
-            renderer: self.renderer.clone(),
-            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,
-        }
-    }
-}
-
-impl Files {
-    /// Create new `Files` instance for a specified base directory.
-    ///
-    /// # Argument Order
-    /// The first argument (`mount_path`) is the root URL at which the static files are served.
-    /// For example, `/assets` will serve files at `example.com/assets/...`.
-    ///
-    /// The second argument (`serve_from`) is the location on disk at which files are loaded.
-    /// This can be a relative path. For example, `./` would serve files from the current
-    /// working directory.
-    ///
-    /// # Implementation Notes
-    /// 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.
-    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() {
-            Ok(canon_dir) => canon_dir,
-            Err(_) => {
-                log::error!("Specified path is not a directory: {:?}", orig_dir);
-                PathBuf::new()
-            }
-        };
-
-        Files {
-            path: mount_path.to_owned(),
-            directory: dir,
-            index: None,
-            show_index: false,
-            redirect_to_slash: false,
-            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,
-        }
-    }
-
-    /// 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
-    }
-
-    /// Redirects to a slash-ended path when browsing a directory.
-    ///
-    /// By default never redirect.
-    pub fn redirect_to_slash_directory(mut self) -> Self {
-        self.redirect_to_slash = true;
-        self
-    }
-
-    /// 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,
-    {
-        self.renderer = Rc::new(f);
-        self
-    }
-
-    /// Specifies mime override callback
-    pub fn mime_override<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&mime::Name<'_>) -> DispositionType + 'static,
-    {
-        self.mime_override = Some(Rc::new(f));
-        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
-    /// 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
-    }
-
-    /// Specifies whether to use ETag or not.
-    ///
-    /// Default is true.
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::ETAG, value);
-        self
-    }
-
-    /// Specifies whether to use Last-Modified or not.
-    ///
-    /// Default is true.
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::LAST_MD, value);
-        self
-    }
-
-    /// Specifies whether text responses should signal a UTF-8 encoding.
-    ///
-    /// Default is false (but will default to true in a future version).
-    pub fn prefer_utf8(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::PREFER_UTF8, value);
-        self
-    }
-
-    /// Adds a routing guard.
-    ///
-    /// 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));
-        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.
-    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>,
-        U: ServiceFactory<
-                ServiceRequest,
-                Config = (),
-                Response = ServiceResponse,
-                Error = Error,
-            > + 'static,
-    {
-        // create and configure default resource
-        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
-            f.into_factory().map_init_err(|_| ()),
-        )))));
-
-        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<_>>(),
-            )
-        };
-
-        if self.default.borrow().is_none() {
-            *self.default.borrow_mut() = Some(config.default_service());
-        }
-
-        let rdef = if config.is_root() {
-            ResourceDef::root_prefix(&self.path)
-        } else {
-            ResourceDef::prefix(&self.path)
-        };
-
-        config.register_service(rdef, guards, self, None)
-    }
-}
-
-impl ServiceFactory<ServiceRequest> for Files {
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Config = ();
-    type Service = FilesService;
-    type InitError = ();
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let mut srv = FilesService {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            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,
-        };
-
-        if let Some(ref default) = *self.default.borrow() {
-            let fut = default.new_service(());
-            Box::pin(async {
-                match fut.await {
-                    Ok(default) => {
-                        srv.default = Some(default);
-                        Ok(srv)
-                    }
-                    Err(_) => Err(()),
-                }
-            })
-        } else {
-            Box::pin(ok(srv))
-        }
-    }
-}

actix-files/src/lib.rs

@@ -1,943 +0,0 @@
-//! Static file serving for Actix Web.
-//!
-//! Provides a non-blocking service for serving static files from disk.
-//!
-//! # Example
-//! ```
-//! use actix_web::App;
-//! use actix_files::Files;
-//!
-//! let app = App::new()
-//!     .service(Files::new("/static", ".").prefer_utf8(true));
-//! ```
-
-#![deny(rust_2018_idioms)]
-#![warn(missing_docs, missing_debug_implementations)]
-
-use actix_service::boxed::{BoxService, BoxServiceFactory};
-use actix_web::{
-    dev::{RequestHead, ServiceRequest, ServiceResponse},
-    error::Error,
-    http::header::DispositionType,
-};
-use mime_guess::from_ext;
-use std::path::Path;
-
-mod chunked;
-mod directory;
-mod encoding;
-mod error;
-mod files;
-mod named;
-mod path_buf;
-mod range;
-mod service;
-
-pub use crate::chunked::ChunkedReadFile;
-pub use crate::directory::Directory;
-pub use crate::files::Files;
-pub use crate::named::NamedFile;
-pub use crate::range::HttpRange;
-pub use crate::service::FilesService;
-
-use self::directory::{directory_listing, DirectoryRenderer};
-use self::error::FilesError;
-use self::path_buf::PathBufWrap;
-
-type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
-
-/// Return the MIME type associated with a filename extension (case-insensitive).
-/// If `ext` is empty or no associated type for the extension was found, returns
-/// the type `application/octet-stream`.
-#[inline]
-pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
-    from_ext(ext).first_or_octet_stream()
-}
-
-type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
-
-type PathFilter = dyn Fn(&Path, &RequestHead) -> bool;
-
-#[cfg(test)]
-mod tests {
-    use std::{
-        fs::{self, File},
-        ops::Add,
-        time::{Duration, SystemTime},
-    };
-
-    use actix_service::ServiceFactory;
-    use actix_utils::future::ok;
-    use actix_web::{
-        guard,
-        http::{
-            header::{self, ContentDisposition, DispositionParam, DispositionType},
-            Method, StatusCode,
-        },
-        middleware::Compress,
-        test::{self, TestRequest},
-        web::{self, Bytes},
-        App, HttpResponse, Responder,
-    };
-
-    use super::*;
-
-    #[actix_rt::test]
-    async fn test_file_extension_to_mime() {
-        let m = file_extension_to_mime("");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-
-        let m = file_extension_to_mime("jpg");
-        assert_eq!(m, mime::IMAGE_JPEG);
-
-        let m = file_extension_to_mime("invalid extension!!");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-
-        let m = file_extension_to_mime("");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-    }
-
-    #[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 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))
-            .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_with_if_none_match() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        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))
-            .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());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_disposition() {
-        assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-
-        let file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .disable_content_disposition();
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert!(resp.headers().get(header::CONTENT_DISPOSITION).is_none());
-    }
-
-    #[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();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"貨物.toml\"; filename*=UTF-8''%E8%B2%A8%E7%89%A9.toml"
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_set_content_type() {
-        let mut file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .set_content_type(mime::TEXT_XML);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/xml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_image() {
-        let mut file = NamedFile::open("tests/test.png").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "image/png"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"test.png\""
-        );
-    }
-
-    #[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 {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Filename(String::from("test.png"))],
-        };
-        let mut file = NamedFile::open("tests/test.png")
-            .unwrap()
-            .set_content_disposition(cd);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "image/png"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "attachment; filename=\"test.png\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_binary() {
-        let mut file = NamedFile::open("tests/test.binary").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        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/octet-stream"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "attachment; filename=\"test.binary\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_status_code_text() {
-        let mut file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .set_status_code(StatusCode::NOT_FOUND);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_mime_override() {
-        fn all_attachment(_: &mime::Name<'_>) -> DispositionType {
-            DispositionType::Attachment
-        }
-
-        let srv = test::init_service(
-            App::new().service(
-                Files::new("/", ".")
-                    .mime_override(all_attachment)
-                    .index_file("Cargo.toml"),
-            ),
-        )
-        .await;
-
-        let request = TestRequest::get().uri("/").to_request();
-        let response = test::call_service(&srv, request).await;
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let content_disposition = response
-            .headers()
-            .get(header::CONTENT_DISPOSITION)
-            .expect("To have CONTENT_DISPOSITION");
-        let content_disposition = content_disposition
-            .to_str()
-            .expect("Convert CONTENT_DISPOSITION to str");
-        assert_eq!(content_disposition, "attachment; filename=\"Cargo.toml\"");
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_ranges_status_code() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        // Valid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/Cargo.toml")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .to_request();
-        let response = test::call_service(&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"))
-            .to_request();
-        let response = test::call_service(&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("/", ".")));
-
-        // Valid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
-        assert_eq!(content_range.to_str().unwrap(), "bytes 10-20/100");
-
-        // Invalid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-5"))
-            .send()
-            .await
-            .unwrap();
-        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
-        assert_eq!(content_range.to_str().unwrap(), "bytes */100");
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_length_headers() {
-        let srv = actix_test::start(|| App::new().service(Files::new("/", ".")));
-
-        // Valid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "11");
-
-        // Valid range header, starting from 0
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=0-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "21");
-
-        // Without range header
-        let mut response = srv.get("/tests/test.binary").send().await.unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "100");
-
-        // Should be no transfer-encoding
-        let transfer_encoding = response.headers().get(header::TRANSFER_ENCODING);
-        assert!(transfer_encoding.is_none());
-
-        // Check file contents
-        let bytes = response.body().await.unwrap();
-        let data = web::Bytes::from(fs::read("tests/test.binary").unwrap());
-        assert_eq!(bytes, data);
-    }
-
-    #[actix_rt::test]
-    async fn test_head_content_length_headers() {
-        let srv = actix_test::start(|| App::new().service(Files::new("/", ".")));
-
-        let response = srv.head("/tests/test.binary").send().await.unwrap();
-
-        let content_length = response
-            .headers()
-            .get(header::CONTENT_LENGTH)
-            .unwrap()
-            .to_str()
-            .unwrap();
-
-        assert_eq!(content_length, "100");
-    }
-
-    #[actix_rt::test]
-    async fn test_static_files_with_spaces() {
-        let 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;
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let bytes = test::read_body(response).await;
-        let data = web::Bytes::from(fs::read("tests/test space.binary").unwrap());
-        assert_eq!(bytes, data);
-    }
-
-    #[actix_rt::test]
-    async fn test_files_not_allowed() {
-        let 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;
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-
-        let 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;
-        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())),
-        )
-        .await;
-
-        let req = TestRequest::default()
-            .uri("/Cargo.toml")
-            .method(Method::POST)
-            .to_request();
-
-        let resp = test::call_service(&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(
-            web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
-                    .unwrap()
-                    .set_content_encoding(header::ContentEncoding::Identity)
-            }),
-        ))
-        .await;
-
-        let request = TestRequest::get()
-            .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
-            .to_request();
-        let res = test::call_service(&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(
-            web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
-                    .unwrap()
-                    .set_content_encoding(header::ContentEncoding::Gzip)
-            }),
-        ))
-        .await;
-
-        let request = TestRequest::get()
-            .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
-            .to_request();
-        let res = test::call_service(&srv, request).await;
-        assert_eq!(res.status(), StatusCode::OK);
-        assert_eq!(
-            res.headers()
-                .get(header::CONTENT_ENCODING)
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            "gzip"
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_allowed_method() {
-        let req = TestRequest::default().method(Method::GET).to_http_request();
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_static_files() {
-        let 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;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
-
-        let req = TestRequest::default().to_request();
-        let resp = test::call_service(&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 req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, 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_redirect_to_slash_directory() {
-        // should not redirect if no index and files listing is disabled
-        let 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;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-        // should redirect if index present
-        let srv = test::init_service(
-            App::new().service(
-                Files::new("/", ".")
-                    .index_file("test.png")
-                    .redirect_to_slash_directory(),
-            ),
-        )
-        .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;
-        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;
-        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);
-    }
-
-    #[actix_rt::test]
-    async fn test_default_handler_file_missing() {
-        let st = Files::new("/", ".")
-            .default_handler(|req: ServiceRequest| {
-                ok(req.into_response(HttpResponse::Ok().body("default content")))
-            })
-            .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;
-        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();
-
-        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"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"lib.rs\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn integration_serve_index() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        let req = TestRequest::get().uri("/test").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/").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);
-
-        // 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);
-
-        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 integration_percent_encoded() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        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"));
-    }
-}

actix-files/src/named.rs

@@ -1,567 +0,0 @@
-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};
-use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-#[cfg(unix)]
-use std::os::unix::fs::MetadataExt;
-
-use actix_web::{
-    dev::{BodyEncoding, ServiceRequest, ServiceResponse, SizedStream},
-    http::{
-        header::{
-            self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
-        },
-        ContentEncoding, StatusCode,
-    },
-    Error, HttpMessage, HttpRequest, HttpResponse, Responder,
-};
-use bitflags::bitflags;
-use mime_guess::from_path;
-
-use crate::ChunkedReadFile;
-use crate::{encoding::equiv_utf8_text, range::HttpRange};
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const ETAG =                0b0000_0001;
-        const LAST_MD =             0b0000_0010;
-        const CONTENT_DISPOSITION = 0b0000_0100;
-        const PREFER_UTF8 =         0b0000_1000;
-    }
-}
-
-impl Default for Flags {
-    fn default() -> Self {
-        Flags::from_bits_truncate(0b0000_0111)
-    }
-}
-
-/// 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,
-    file: File,
-    modified: Option<SystemTime>,
-    pub(crate) md: Metadata,
-    pub(crate) flags: Flags,
-    pub(crate) status_code: StatusCode,
-    pub(crate) content_type: mime::Mime,
-    pub(crate) content_disposition: header::ContentDisposition,
-    pub(crate) encoding: Option<ContentEncoding>,
-}
-
-impl NamedFile {
-    /// Creates an instance from a previously opened file.
-    ///
-    /// The given `path` need not exist and is only used to determine the `ContentType` and
-    /// `ContentDisposition` headers.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use actix_files::NamedFile;
-    /// use std::io::{self, Write};
-    /// use std::env;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> io::Result<()> {
-    ///     let mut file = File::create("foo.txt")?;
-    ///     file.write_all(b"Hello, world!")?;
-    ///     let named_file = NamedFile::from_file(file, "bar.txt")?;
-    ///     # std::fs::remove_file("foo.txt");
-    ///     Ok(())
-    /// }
-    /// ```
-    pub fn from_file<P: AsRef<Path>>(file: File, path: P) -> io::Result<NamedFile> {
-        let path = path.as_ref().to_path_buf();
-
-        // Get the name of the file and use it to construct default Content-Type
-        // and Content-Disposition values
-        let (content_type, content_disposition) = {
-            let filename = match path.file_name() {
-                Some(name) => name.to_string_lossy(),
-                None => {
-                    return Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "Provided path has no filename",
-                    ));
-                }
-            };
-
-            let ct = from_path(&path).first_or_octet_stream();
-
-            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,
-            };
-
-            let mut parameters =
-                vec![DispositionParam::Filename(String::from(filename.as_ref()))];
-
-            if !filename.is_ascii() {
-                parameters.push(DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Ext(String::from("UTF-8")),
-                    language_tag: None,
-                    value: filename.into_owned().into_bytes(),
-                }))
-            }
-
-            let cd = ContentDisposition {
-                disposition,
-                parameters,
-            };
-
-            (ct, cd)
-        };
-
-        let md = file.metadata()?;
-        let modified = md.modified().ok();
-        let encoding = None;
-
-        Ok(NamedFile {
-            path,
-            file,
-            content_type,
-            content_disposition,
-            md,
-            modified,
-            encoding,
-            status_code: StatusCode::OK,
-            flags: Flags::default(),
-        })
-    }
-
-    /// Attempts to open a file in read-only mode.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use actix_files::NamedFile;
-    ///
-    /// let file = NamedFile::open("foo.txt");
-    /// ```
-    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
-        Self::from_file(File::open(&path)?, path)
-    }
-
-    /// Returns reference to the underlying `File` object.
-    #[inline]
-    pub fn file(&self) -> &File {
-        &self.file
-    }
-
-    /// Retrieve the path of this file.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use std::io;
-    /// use actix_files::NamedFile;
-    ///
-    /// # fn path() -> io::Result<()> {
-    /// let file = NamedFile::open("test.txt")?;
-    /// assert_eq!(file.path().as_os_str(), "foo.txt");
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[inline]
-    pub fn path(&self) -> &Path {
-        self.path.as_path()
-    }
-
-    /// Set response **Status Code**
-    pub fn set_status_code(mut self, status: StatusCode) -> Self {
-        self.status_code = status;
-        self
-    }
-
-    /// Set the MIME Content-Type for serving this file. By default
-    /// the Content-Type is inferred from the filename extension.
-    #[inline]
-    pub fn set_content_type(mut self, mime_type: mime::Mime) -> Self {
-        self.content_type = mime_type;
-        self
-    }
-
-    /// 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
-    /// after converting it to UTF-8 using.
-    /// [`std::ffi::OsStr::to_string_lossy`]
-    #[inline]
-    pub fn set_content_disposition(mut self, cd: header::ContentDisposition) -> Self {
-        self.content_disposition = cd;
-        self.flags.insert(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Disable `Content-Disposition` header.
-    ///
-    /// By default Content-Disposition` header is enabled.
-    #[inline]
-    pub fn disable_content_disposition(mut self) -> Self {
-        self.flags.remove(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// 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);
-        self
-    }
-
-    /// Specifies whether to use ETag or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.flags.set(Flags::ETAG, value);
-        self
-    }
-
-    /// Specifies whether to use Last-Modified or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.flags.set(Flags::LAST_MD, value);
-        self
-    }
-
-    /// 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.flags.set(Flags::PREFER_UTF8, value);
-        self
-    }
-
-    pub(crate) fn etag(&self) -> Option<header::EntityTag> {
-        // This etag format is similar to Apache's.
-        self.modified.as_ref().map(|mtime| {
-            let ino = {
-                #[cfg(unix)]
-                {
-                    self.md.ino()
-                }
-                #[cfg(not(unix))]
-                {
-                    0
-                }
-            };
-
-            let dur = mtime
-                .duration_since(UNIX_EPOCH)
-                .expect("modification time must be after epoch");
-
-            header::EntityTag::strong(format!(
-                "{:x}:{:x}:{:x}:{:x}",
-                ino,
-                self.md.len(),
-                dur.as_secs(),
-                dur.subsec_nanos()
-            ))
-        })
-    }
-
-    pub(crate) fn last_modified(&self) -> Option<header::HttpDate> {
-        self.modified.map(|mtime| mtime.into())
-    }
-
-    /// Creates an `HttpResponse` with file as a streaming body.
-    pub fn into_response(self, req: &HttpRequest) -> HttpResponse {
-        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()));
-            } else {
-                res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
-            }
-
-            if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-                res.insert_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);
-
-            return res.streaming(reader);
-        }
-
-        let etag = if self.flags.contains(Flags::ETAG) {
-            self.etag()
-        } else {
-            None
-        };
-
-        let last_modified = if self.flags.contains(Flags::LAST_MD) {
-            self.last_modified()
-        } else {
-            None
-        };
-
-        // check preconditions
-        let precondition_failed = if !any_match(etag.as_ref(), req) {
-            true
-        } 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();
-
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1.as_secs() > t2.as_secs(),
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        // check last modified
-        let not_modified = if !none_match(etag.as_ref(), req) {
-            true
-        } else if req.headers().contains_key(header::IF_NONE_MATCH) {
-            false
-        } 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();
-
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1.as_secs() <= t2.as_secs(),
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        let mut resp = HttpResponse::build(self.status_code);
-
-        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()));
-        } else {
-            resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
-        }
-
-        if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-            resp.insert_header((
-                header::CONTENT_DISPOSITION,
-                self.content_disposition.to_string(),
-            ));
-        }
-
-        // default compressing
-        if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
-        }
-
-        if let Some(lm) = last_modified {
-            resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
-        }
-
-        if let Some(etag) = etag {
-            resp.insert_header((header::ETAG, etag.to_string()));
-        }
-
-        resp.insert_header((header::ACCEPT_RANGES, "bytes"));
-
-        let mut length = self.md.len();
-        let mut offset = 0;
-
-        // check for range header
-        if let Some(ranges) = req.headers().get(header::RANGE) {
-            if let Ok(ranges_header) = ranges.to_str() {
-                if let Ok(ranges) = HttpRange::parse(ranges_header, length) {
-                    length = ranges[0].length;
-                    offset = ranges[0].start;
-
-                    resp.encoding(ContentEncoding::Identity);
-                    resp.insert_header((
-                        header::CONTENT_RANGE,
-                        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();
-                };
-            } else {
-                return resp.status(StatusCode::BAD_REQUEST).finish();
-            };
-        };
-
-        if precondition_failed {
-            return resp.status(StatusCode::PRECONDITION_FAILED).finish();
-        } else if not_modified {
-            return resp.status(StatusCode::NOT_MODIFIED).finish();
-        }
-
-        let reader = ChunkedReadFile::new(length, offset, self.file);
-
-        if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
-        }
-
-        resp.body(SizedStream::new(length, reader))
-    }
-}
-
-impl Deref for NamedFile {
-    type Target = File;
-
-    fn deref(&self) -> &File {
-        &self.file
-    }
-}
-
-impl DerefMut for NamedFile {
-    fn deref_mut(&mut self) -> &mut File {
-        &mut self.file
-    }
-}
-
-/// Returns true if `req` has no `If-Match` header or one which matches `etag`.
-fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfMatch>() {
-        None | Some(header::IfMatch::Any) => true,
-
-        Some(header::IfMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.strong_eq(some_etag) {
-                        return true;
-                    }
-                }
-            }
-
-            false
-        }
-    }
-}
-
-/// Returns true if `req` doesn't have an `If-None-Match` header matching `req`.
-fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfNoneMatch>() {
-        Some(header::IfNoneMatch::Any) => false,
-
-        Some(header::IfNoneMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.weak_eq(some_etag) {
-                        return false;
-                    }
-                }
-            }
-
-            true
-        }
-
-        None => true,
-    }
-}
-
-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, ()>>;
-
-    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,
-        )
-    }
-}

actix-files/src/path_buf.rs

@@ -1,119 +0,0 @@
-use std::{
-    path::{Path, PathBuf},
-    str::FromStr,
-};
-
-use actix_utils::future::{ready, Ready};
-use actix_web::{dev::Payload, FromRequest, HttpRequest};
-
-use crate::error::UriSegmentError;
-
-#[derive(Debug)]
-pub(crate) struct PathBufWrap(PathBuf);
-
-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('.') {
-                return Err(UriSegmentError::BadStart('.'));
-            } else if segment.starts_with('*') {
-                return Err(UriSegmentError::BadStart('*'));
-            } else if segment.ends_with(':') {
-                return Err(UriSegmentError::BadEnd(':'));
-            } else if segment.ends_with('>') {
-                return Err(UriSegmentError::BadEnd('>'));
-            } else if segment.ends_with('<') {
-                return Err(UriSegmentError::BadEnd('<'));
-            } else if segment.is_empty() {
-                continue;
-            } else if cfg!(windows) && segment.contains('\\') {
-                return Err(UriSegmentError::BadChar('\\'));
-            } else {
-                buf.push(segment)
-            }
-        }
-
-        Ok(PathBufWrap(buf))
-    }
-}
-
-impl AsRef<Path> for PathBufWrap {
-    fn as_ref(&self) -> &Path {
-        self.0.as_ref()
-    }
-}
-
-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())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::iter::FromIterator;
-
-    use super::*;
-
-    #[test]
-    fn test_path_buf() {
-        assert_eq!(
-            PathBufWrap::from_str("/test/.tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('.'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/*tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('*'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt:").map(|t| t.0),
-            Err(UriSegmentError::BadEnd(':'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt<").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('<'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt>").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('>'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/seg1/seg2/").unwrap().0,
-            PathBuf::from_iter(vec!["seg1", "seg2"])
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/seg1/../seg2/").unwrap().0,
-            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,310 +0,0 @@
-use derive_more::{Display, Error};
-
-/// HTTP Range header representation.
-#[derive(Debug, Clone, Copy)]
-pub struct HttpRange {
-    /// Start of range.
-    pub start: u64,
-
-    /// Length of range.
-    pub length: u64,
-}
-
-#[derive(Debug, Clone, Display, Error)]
-#[display(fmt = "Parse HTTP Range failed")]
-pub struct ParseRangeErr(#[error(not(source))] ());
-
-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(())),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    struct T(&'static str, u64, Vec<HttpRange>);
-
-    #[test]
-    fn test_parse() {
-        let tests = vec![
-            T("", 0, vec![]),
-            T("", 1000, vec![]),
-            T("foo", 0, vec![]),
-            T("bytes=", 0, vec![]),
-            T("bytes=7", 10, vec![]),
-            T("bytes= 7 ", 10, vec![]),
-            T("bytes=1-", 0, vec![]),
-            T("bytes=5-4", 10, vec![]),
-            T("bytes=0-2,5-4", 10, vec![]),
-            T("bytes=2-5,4-3", 10, vec![]),
-            T("bytes=--5,4--3", 10, vec![]),
-            T("bytes=A-", 10, vec![]),
-            T("bytes=A- ", 10, vec![]),
-            T("bytes=A-Z", 10, vec![]),
-            T("bytes= -Z", 10, vec![]),
-            T("bytes=5-Z", 10, vec![]),
-            T("bytes=Ran-dom, garbage", 10, vec![]),
-            T("bytes=0x01-0x02", 10, vec![]),
-            T("bytes=         ", 10, vec![]),
-            T("bytes= , , ,   ", 10, vec![]),
-            T(
-                "bytes=0-9",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=0-",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=5-",
-                10,
-                vec![HttpRange {
-                    start: 5,
-                    length: 5,
-                }],
-            ),
-            T(
-                "bytes=0-20",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=15-,0-5",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 6,
-                }],
-            ),
-            T(
-                "bytes=1-2,5-",
-                10,
-                vec![
-                    HttpRange {
-                        start: 1,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 5,
-                        length: 5,
-                    },
-                ],
-            ),
-            T(
-                "bytes=-2 , 7-",
-                11,
-                vec![
-                    HttpRange {
-                        start: 9,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 4,
-                    },
-                ],
-            ),
-            T(
-                "bytes=0-0 ,2-2, 7-",
-                11,
-                vec![
-                    HttpRange {
-                        start: 0,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 2,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 4,
-                    },
-                ],
-            ),
-            T(
-                "bytes=-5",
-                10,
-                vec![HttpRange {
-                    start: 5,
-                    length: 5,
-                }],
-            ),
-            T(
-                "bytes=-15",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=0-499",
-                10000,
-                vec![HttpRange {
-                    start: 0,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=500-999",
-                10000,
-                vec![HttpRange {
-                    start: 500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=-500",
-                10000,
-                vec![HttpRange {
-                    start: 9500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=9500-",
-                10000,
-                vec![HttpRange {
-                    start: 9500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=0-0,-1",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 0,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 9999,
-                        length: 1,
-                    },
-                ],
-            ),
-            T(
-                "bytes=500-600,601-999",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 500,
-                        length: 101,
-                    },
-                    HttpRange {
-                        start: 601,
-                        length: 399,
-                    },
-                ],
-            ),
-            T(
-                "bytes=500-700,601-999",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 500,
-                        length: 201,
-                    },
-                    HttpRange {
-                        start: 601,
-                        length: 399,
-                    },
-                ],
-            ),
-            // Match Apache laxity:
-            T(
-                "bytes=   1 -2   ,  4- 5, 7 - 8 , ,,",
-                11,
-                vec![
-                    HttpRange {
-                        start: 1,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 4,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 2,
-                    },
-                ],
-            ),
-        ];
-
-        for t in tests {
-            let header = t.0;
-            let size = t.1;
-            let expected = t.2;
-
-            let res = HttpRange::parse(header, size);
-
-            if res.is_err() {
-                if expected.is_empty() {
-                    continue;
-                } else {
-                    panic!(
-                        "parse({}, {}) returned error {:?}",
-                        header,
-                        size,
-                        res.unwrap_err()
-                    );
-                }
-            }
-
-            let got = res.unwrap();
-
-            if got.len() != expected.len() {
-                panic!(
-                    "len(parseRange({}, {})) = {}, want {}",
-                    header,
-                    size,
-                    got.len(),
-                    expected.len()
-                );
-            }
-
-            for i in 0..expected.len() {
-                if got[i].start != expected[i].start {
-                    panic!(
-                        "parseRange({}, {})[{}].start = {}, want {}",
-                        header, size, i, got[i].start, expected[i].start
-                    )
-                }
-                if got[i].length != expected[i].length {
-                    panic!(
-                        "parseRange({}, {})[{}].length = {}, want {}",
-                        header, size, i, got[i].length, expected[i].length
-                    )
-                }
-            }
-        }
-    }
-}

actix-files/src/service.rs

@@ -1,171 +0,0 @@
-use std::{fmt, io, path::PathBuf, rc::Rc};
-
-use actix_service::Service;
-use actix_utils::future::ok;
-use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
-    error::Error,
-    guard::Guard,
-    http::{header, Method},
-    HttpResponse,
-};
-use futures_core::future::LocalBoxFuture;
-
-use crate::{
-    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
-    PathBufWrap, PathFilter,
-};
-
-/// Assembled file serving service.
-pub struct FilesService {
-    pub(crate) directory: PathBuf,
-    pub(crate) index: Option<String>,
-    pub(crate) show_index: bool,
-    pub(crate) redirect_to_slash: bool,
-    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);
-
-        if let Some(ref default) = self.default {
-            Box::pin(default.call(req))
-        } else {
-            Box::pin(ok(req.error_response(err)))
-        }
-    }
-}
-
-impl fmt::Debug for FilesService {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("FilesService")
-    }
-}
-
-impl Service<ServiceRequest> for FilesService {
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, req: ServiceRequest) -> Self::Future {
-        let is_method_valid = if let Some(guard) = &self.guards {
-            // execute user defined guards
-            (**guard).check(req.head())
-        } else {
-            // default behavior
-            matches!(*req.method(), Method::HEAD | Method::GET)
-        };
-
-        if !is_method_valid {
-            return Box::pin(ok(req.into_response(
-                actix_web::HttpResponse::MethodNotAllowed()
-                    .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
-                    .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())
-                    ));
-                }
-            }
-        }
-
-        // full file path
-        let path = self.directory.join(&real_path);
-        if let Err(err) = path.canonicalize() {
-            return Box::pin(self.handle_err(err, 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());
-
-                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;
-                }
-                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 show_index = |req: ServiceRequest| {
-                let dir = Directory::new(self.directory.clone(), path.clone());
-
-                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(
-                    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_());
-                        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)))
-                }
-                Err(err) => self.handle_err(err, req),
-            }
-        }
-    }
-}

actix-files/tests/encoding.rs

@@ -1,38 +0,0 @@
-use actix_files::Files;
-use actix_web::{
-    http::{
-        header::{self, HeaderValue},
-        StatusCode,
-    },
-    test::{self, TestRequest},
-    App,
-};
-
-#[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 req = TestRequest::with_uri("/utf8.txt").to_request();
-    let res = test::call_service(&srv, req).await;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(
-        res.headers().get(header::CONTENT_TYPE),
-        Some(&HeaderValue::from_static("text/plain")),
-    );
-
-    // prefer UTF-8 encoding
-    let 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;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(
-        res.headers().get(header::CONTENT_TYPE),
-        Some(&HeaderValue::from_static("text/plain; charset=utf-8")),
-    );
-}

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_rt::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 space.binary

@@ -1 +0,0 @@
-<EFBFBD>TǑɂV<EFBFBD>2<EFBFBD>vI<EFBFBD><EFBFBD><EFBFBD>\<5C>R˙<52><CB99><EFBFBD>e<EFBFBD><04>vD<76>:藽<>RV<03>Yp<59><70>;<3B><>G<><47>p!2<7F>C<EFBFBD>.<2E><0C><><EFBFBD><EFBFBD>pA!<21>ߦ<EFBFBD>x	j+Uc<55><63><EFBFBD>X<13>c%<17>;<3B>"y<10><>AI

actix-files/tests/test.binary

@@ -1 +0,0 @@
-<EFBFBD>TǑɂV<EFBFBD>2<EFBFBD>vI<EFBFBD><EFBFBD><EFBFBD>\<5C>R˙<52><CB99><EFBFBD>e<EFBFBD><04>vD<76>:藽<>RV<03>Yp<59><70>;<3B><>G<><47>p!2<7F>C<EFBFBD>.<2E><0C><><EFBFBD><EFBFBD>pA!<21>ߦ<EFBFBD>x	j+Uc<55><63><EFBFBD>X<13>c%<17>;<3B>"y<10><>AI

actix-files/tests/test.js

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

actix-files/tests/utf8.txt

@@ -1,3 +0,0 @@
-中文内容显示正确。
-
-English is OK.

actix-http-test/CHANGES.md

@@ -1,100 +0,0 @@
-# Changes
-
-## Unreleased - 2021-xx-xx
-
-
-## 3.0.0-beta.4 - 2021-04-02
-* Added `TestServer::client_headers` method. [#2097]
-
-[#2097]: https://github.com/actix/actix-web/pull/2097
-
-
-## 3.0.0-beta.3 - 2021-03-09
-* No notable changes.
-
-
-## 3.0.0-beta.2 - 2021-02-10
-* No notable changes.
-
-
-## 3.0.0-beta.1 - 2021-01-07
-* Update `bytes` to `1.0`. [#1813]
-
-[#1813]: https://github.com/actix/actix-web/pull/1813
-
-
-## 2.1.0 - 2020-11-25
-* Add ability to set address for `TestServer`. [#1645]
-* Upgrade `base64` to `0.13`.
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
-
-[#1773]: https://github.com/actix/actix-web/pull/1773
-[#1645]: https://github.com/actix/actix-web/pull/1645
-
-
-## 2.0.0 - 2020-09-11
-* Update actix-codec and actix-utils dependencies.
-
-
-## 2.0.0-alpha.1 - 2020-05-23
-* Update the `time` dependency to 0.2.7
-* Update `actix-connect` dependency to 2.0.0-alpha.2
-* Make `test_server` `async` fn.
-* Bump minimum supported Rust version to 1.40
-* Replace deprecated `net2` crate with `socket2`
-* Update `base64` dependency to 0.12
-* Update `env_logger` dependency to 0.7
-
-## 1.0.0 - 2019-12-13
-* Replaced `TestServer::start()` with `test_server()`
-
-
-## 1.0.0-alpha.3 - 2019-12-07
-* Migrate to `std::future`
-
-
-## 0.2.5 - 2019-09-17
-* Update serde_urlencoded to "0.6.1"
-* Increase TestServerRuntime timeouts from 500ms to 3000ms
-* Do not override current `System`
-
-
-## 0.2.4 - 2019-07-18
-* Update actix-server to 0.6
-
-
-## 0.2.3 - 2019-07-16
-* Add `delete`, `options`, `patch` methods to `TestServerRunner`
-
-
-## 0.2.2 - 2019-06-16
-* Add .put() and .sput() methods
-
-
-## 0.2.1 - 2019-06-05
-* Add license files
-
-
-## 0.2.0 - 2019-05-12
-* Update awc and actix-http deps
-
-
-## 0.1.1 - 2019-04-24
-* Always make new connection for http client
-
-
-## 0.1.0 - 2019-04-16
-* No changes
-
-
-## 0.1.0-alpha.3 - 2019-04-02
-* Request functions accept path #743
-
-
-## 0.1.0-alpha.2 - 2019-03-29
-* Added TestServerRuntime::load_body() method
-* Update actix-http and awc libraries
-
-
-## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl

actix-http-test/Cargo.toml

@@ -1,55 +0,0 @@
-[package]
-name = "actix-http-test"
-version = "3.0.0-beta.4"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Various helpers for Actix applications to use during testing"
-readme = "README.md"
-keywords = ["http", "web", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-http-test/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
-license = "MIT OR Apache-2.0"
-exclude = [".gitignore", ".cargo/config"]
-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.5"
-actix-utils = "3.0.0"
-actix-rt = "2.2"
-actix-server = "2.0.0-beta.3"
-awc = { version = "3.0.0-beta.7", 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"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
-
-[dev-dependencies]
-actix-web = { version = "4.0.0-beta.8", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.8"

actix-http-test/LICENSE-APACHE

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

actix-http-test/LICENSE-MIT

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

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.4)](https://docs.rs/actix-http-test/3.0.0-beta.4)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-<br>
-[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.4)
-[![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.46.0

actix-http-test/src/lib.rs

@@ -1,281 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-
-#![deny(rust_2018_idioms)]
-#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
-#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-
-#[cfg(feature = "openssl")]
-extern crate tls_openssl as openssl;
-
-use std::sync::mpsc;
-use std::{net, thread, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::{net::TcpStream, System};
-use actix_server::{Server, ServiceFactory};
-use awc::{
-    error::PayloadError, http::HeaderMap, ws, Client, ClientRequest, ClientResponse, Connector,
-};
-use bytes::Bytes;
-use futures_core::stream::Stream;
-use http::Method;
-use socket2::{Domain, Protocol, Socket, Type};
-
-/// Start test server
-///
-/// `TestServer` is very simple test server that simplify process of writing
-/// integration tests cases for actix web applications.
-///
-/// # Examples
-///
-/// ```
-/// use actix_http::HttpService;
-/// use actix_http_test::TestServer;
-/// use actix_web::{web, App, HttpResponse, Error};
-///
-/// async fn my_handler() -> Result<HttpResponse, Error> {
-///     Ok(HttpResponse::Ok().into())
-/// }
-///
-/// #[actix_rt::test]
-/// async fn test_example() {
-///     let mut srv = TestServer::start(
-///         || HttpService::new(
-///             App::new().service(
-///                 web::resource("/").to(my_handler))
-///         )
-///     );
-///
-///     let req = srv.get("/");
-///     let response = req.send().await.unwrap();
-///     assert!(response.status().is_success());
-/// }
-/// ```
-pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
-    let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
-    test_server_with_addr(tcp, factory).await
-}
-
-/// Start [`test server`](test_server()) on a concrete Address
-pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
-    tcp: net::TcpListener,
-    factory: F,
-) -> TestServer {
-    let (tx, rx) = mpsc::channel();
-
-    // run server in separate thread
-    thread::spawn(move || {
-        let sys = System::new();
-        let local_addr = tcp.local_addr().unwrap();
-
-        let srv = Server::build()
-            .listen("test", tcp, factory)?
-            .workers(1)
-            .disable_signals();
-
-        sys.block_on(async {
-            srv.run();
-            tx.send((System::current(), local_addr)).unwrap();
-        });
-
-        sys.run()
-    });
-
-    let (system, addr) = rx.recv().unwrap();
-
-    let client = {
-        let connector = {
-            #[cfg(feature = "openssl")]
-            {
-                use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
-
-                let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
-                builder.set_verify(SslVerifyMode::NONE);
-                let _ = builder
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
-                Connector::new()
-                    .conn_lifetime(time::Duration::from_secs(0))
-                    .timeout(time::Duration::from_millis(30000))
-                    .ssl(builder.build())
-            }
-            #[cfg(not(feature = "openssl"))]
-            {
-                Connector::new()
-                    .conn_lifetime(time::Duration::from_secs(0))
-                    .timeout(time::Duration::from_millis(30000))
-            }
-        };
-
-        Client::builder().connector(connector).finish()
-    };
-
-    TestServer {
-        addr,
-        client,
-        system,
-    }
-}
-
-/// Test server controller
-pub struct TestServer {
-    addr: net::SocketAddr,
-    client: Client,
-    system: System,
-}
-
-impl TestServer {
-    /// Construct test server url
-    pub fn addr(&self) -> net::SocketAddr {
-        self.addr
-    }
-
-    /// Construct test server url
-    pub fn url(&self, uri: &str) -> String {
-        if uri.starts_with('/') {
-            format!("http://localhost:{}{}", self.addr.port(), uri)
-        } else {
-            format!("http://localhost:{}/{}", self.addr.port(), uri)
-        }
-    }
-
-    /// Construct test HTTPS server URL.
-    pub fn surl(&self, uri: &str) -> String {
-        if uri.starts_with('/') {
-            format!("https://localhost:{}{}", self.addr.port(), uri)
-        } else {
-            format!("https://localhost:{}/{}", self.addr.port(), uri)
-        }
-    }
-
-    /// Create `GET` request
-    pub fn get<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.get(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `GET` request
-    pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.get(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `POST` request
-    pub fn post<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.post(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `POST` request
-    pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.post(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `HEAD` request
-    pub fn head<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.head(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `HEAD` request
-    pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.head(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `PUT` request
-    pub fn put<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.put(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `PUT` request
-    pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.put(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `PATCH` request
-    pub fn patch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.patch(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `PATCH` request
-    pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.patch(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `DELETE` request
-    pub fn delete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.delete(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `DELETE` request
-    pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.delete(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Create `OPTIONS` request
-    pub fn options<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.options(self.url(path.as_ref()).as_str())
-    }
-
-    /// Create HTTPS `OPTIONS` request
-    pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
-        self.client.options(self.surl(path.as_ref()).as_str())
-    }
-
-    /// Connect to test HTTP server
-    pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
-        self.client.request(method, path.as_ref())
-    }
-
-    pub async fn load_body<S>(
-        &mut self,
-        mut response: ClientResponse<S>,
-    ) -> Result<Bytes, PayloadError>
-    where
-        S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
-    {
-        response.body().limit(10_485_760).await
-    }
-
-    /// Connect to WebSocket server at a given path.
-    pub async fn ws_at(
-        &mut self,
-        path: &str,
-    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
-        let url = self.url(path);
-        let connect = self.client.ws(url).connect();
-        connect.await.map(|(_, framed)| framed)
-    }
-
-    /// Connect to a WebSocket server.
-    pub async fn ws(
-        &mut self,
-    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
-        self.ws_at("/").await
-    }
-
-    /// Get default HeaderMap of Client.
-    ///
-    /// Returns Some(&mut HeaderMap) when Client object is unique
-    /// (No other clone of client exists at the same time).
-    pub fn client_headers(&mut self) -> Option<&mut HeaderMap> {
-        self.client.headers()
-    }
-
-    /// Stop HTTP server
-    fn stop(&mut self) {
-        self.system.stop();
-    }
-}
-
-impl Drop for TestServer {
-    fn drop(&mut self) {
-        self.stop()
-    }
-}
-
-/// Get a localhost socket address with random, unused port.
-pub fn unused_addr() -> net::SocketAddr {
-    let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
-    socket.bind(&addr.into()).unwrap();
-    socket.set_reuse_address(true).unwrap();
-    let tcp = net::TcpListener::from(socket);
-    tcp.local_addr().unwrap()
-}

actix-http/CHANGES.md

@@ -1,560 +0,0 @@
-# Changes
-
-## Unreleased - 2021-xx-xx
-
-
-## 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.0 - 2020-11-25
-### Added
-* HttpResponse builders for 1xx status codes. [#1768]
-* `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
-* `TryFrom<u16>` and `TryFrom<f32>` for `http::header::Quality`. [#1797]
-
-### Fixed
-* Started dropping `transfer-encoding: chunked` and `Content-Length` for 1XX and 204 responses. [#1767]
-
-### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
-
-[#1773]: https://github.com/actix/actix-web/pull/1773
-[#1767]: https://github.com/actix/actix-web/pull/1767
-[#1768]: https://github.com/actix/actix-web/pull/1768
-[#1793]: https://github.com/actix/actix-web/pull/1793
-[#1797]: https://github.com/actix/actix-web/pull/1797
-
-
-## 2.1.0 - 2020-10-30
-### Added
-* Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
-
-### Changed
-* Upgrade `base64` to `0.13`. [#1744]
-* Upgrade `pin-project` to `1.0`. [#1733]
-* Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
-
-[#1760]: https://github.com/actix/actix-web/pull/1760
-[#1754]: https://github.com/actix/actix-web/pull/1754
-[#1733]: https://github.com/actix/actix-web/pull/1733
-[#1744]: https://github.com/actix/actix-web/pull/1744
-
-
-## 2.0.0 - 2020-09-11
-* No significant changes from `2.0.0-beta.4`.
-
-
-## 2.0.0-beta.4 - 2020-09-09
-### Changed
-* Update actix-codec and actix-utils dependencies.
-* Update actix-connect and actix-tls dependencies.
-
-
-## 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
-### Fixed
-* Potential UB in h1 decoder using uninitialized memory. [#1614]
-
-### Changed
-* Fix illegal chunked encoding. [#1615]
-
-[#1614]: https://github.com/actix/actix-web/pull/1614
-[#1615]: https://github.com/actix/actix-web/pull/1615
-
-
-## 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]
-* MSRV is now 1.41.1.
-
-[#1558]: https://github.com/actix/actix-web/pull/1558
-[#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
-### 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]
-* `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
-### 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.
-
-[#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
-### 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]
-* 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
-### 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().
-* 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
-### Fixed
-* Poll upgrade service's readiness from HTTP service handlers
-* Replace brotli with brotli2 #1224
-
-
-## 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
-### Fixed
-* Check `Upgrade` service readiness before calling it
-* Fix buffer remaining capacity calculation
-
-### Changed
-* Websockets: Ping and Pong should have binary data #1049
-
-
-## 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
-### Changed
-* Migrate to tokio 0.2
-* Migrate to `std::future`
-
-
-## 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)
-* 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
-
-
-## 0.2.10 - 2019-09-11
-### Added
-* 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
-### 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
-### 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
-
-
-## 0.2.7 - 2019-07-18
-### Added
-* Add support for downcasting response errors #986
-
-
-## 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
-### 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
-### Fixed
-* Do not compress NoContent (204) responses #918
-
-
-## 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
-### Fixed
-* Parse incoming stream before closing stream on disconnect #868
-
-
-## 0.2.1 - 2019-05-25
-### Fixed
-* Handle socket read disconnect
-
-
-## 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
-### Fixed
-* Clean up response extensions in response pool #817
-
-
-## 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
-### Fixed
-* Fix http client pool management
-* Fix http client wait queue management #794
-
-
-## 0.1.2 - 2019-04-23
-### Fixed
-* Fix BorrowMutError panic in client connector #793
-
-
-## 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
-### 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
-### 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
-### 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
-
-### Deleted
-* Removed PayloadBuffer
-
-
-## 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
-### Added
-* Added ws::Message::Nop, no-op websockets message
-
-### Changed
-* Do not use thread pool for decompression if chunk size is smaller than 2048.
-
-
-## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl

actix-http/Cargo.toml

@@ -1,115 +0,0 @@
-[package]
-name = "actix-http"
-version = "3.0.0-beta.8"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "HTTP primitives for the Actix ecosystem"
-keywords = ["actix", "http", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/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"]
-
-[lib]
-name = "actix_http"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# openssl
-openssl = ["actix-tls/openssl"]
-
-# rustls support
-rustls = ["actix-tls/rustls"]
-
-# enable compression support
-compress-brotli = ["brotli2", "__compress"]
-compress-gzip = ["flate2", "__compress"]
-compress-zstd = ["zstd", "__compress"]
-
-# trust-dns as client dns resolver
-trust-dns = ["trust-dns-resolver"]
-
-# Internal (PRIVATE!) features used to aid testing and cheking feature status.
-# Don't rely on these whatsoever. They may disappear at anytime.
-__compress = []
-
-[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.5", features = ["accept", "connect"] }
-
-ahash = "0.7"
-base64 = "0.13"
-bitflags = "1.2"
-bytes = "1"
-bytestring = "1"
-derive_more = "0.99.5"
-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.3"
-itoa = "0.4"
-language-tags = "0.3"
-local-channel = "0.1"
-once_cell = "1.5"
-log = "0.4"
-mime = "0.3"
-percent-encoding = "2.1"
-pin-project = "1.0.0"
-pin-project-lite = "0.2"
-rand = "0.8"
-regex = "1.3"
-serde = "1.0"
-sha-1 = "0.9"
-smallvec = "1.6"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-tokio = { version = "1.2", features = ["sync"] }
-
-# 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.4", features = ["openssl"] }
-actix-tls = { version = "3.0.0-beta.5", features = ["openssl"] }
-async-stream = "0.3"
-criterion = { version = "0.3", features = ["html_reports"] }
-env_logger = "0.8"
-rcgen = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-tls-openssl = { version = "0.10", package = "openssl" }
-tls-rustls = { version = "0.19", package = "rustls" }
-webpki = { version = "0.21.0" }
-
-[[example]]
-name = "ws"
-required-features = ["rustls"]
-
-[[bench]]
-name = "write-camel-case"
-harness = false
-
-[[bench]]
-name = "status-line"
-harness = false
-
-[[bench]]
-name = "uninit-headers"
-harness = false

actix-http/LICENSE-APACHE

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

actix-http/LICENSE-MIT

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

actix-http/README.md

@@ -1,66 +0,0 @@
-# actix-http
-
-> 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.8)](https://docs.rs/actix-http/3.0.0-beta.8)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
-<br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.8/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.8)
-[![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 & Resources
-
-- [API Documentation](https://docs.rs/actix-http)
-- Minimum Supported Rust Version (MSRV): 1.46.0
-
-## Example
-
-```rust
-use std::{env, io};
-
-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::set_var("RUST_LOG", "hello_world=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("hello-world", "127.0.0.1:8080", || {
-            HttpService::build()
-                .client_timeout(1000)
-                .client_disconnect(1000)
-                .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()
-        })?
-        .run()
-        .await
-}
-```
-
-## 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))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
-
-at your option.
-
-## Code of Conduct
-
-Contribution to the actix-http crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-http, @fafhrd91, promises to
-intervene to uphold that code of conduct.

actix-http/benches/status-line.rs

@@ -1,222 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-
-use bytes::BytesMut;
-use http::Version;
-
-const CODES: &[u16] = &[201, 303, 404, 515];
-
-fn bench_write_status_line_11(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v1.1");
-
-    let version = Version::HTTP_11;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, 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_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-fn bench_write_status_line_10(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v1.0");
-
-    let version = Version::HTTP_10;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, 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_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-fn bench_write_status_line_09(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v0.9");
-
-    let version = Version::HTTP_09;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, 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_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    bench_write_status_line_11,
-    bench_write_status_line_10,
-    bench_write_status_line_09
-);
-criterion_main!(benches);
-
-mod _naive {
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
-        match version {
-            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
-            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
-            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
-            _ => {
-                // other HTTP version handlers do not use this method
-            }
-        }
-
-        bytes.put_slice(n.to_string().as_bytes());
-    }
-}
-
-mod _new {
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    const DIGITS_START: u8 = b'0';
-
-    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
-        match version {
-            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
-            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
-            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
-            _ => {
-                // other HTTP version handlers do not use this method
-            }
-        }
-
-        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);
-
-        bytes.put_u8(b' ');
-    }
-}
-
-mod _original {
-    use std::ptr;
-
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
-        2021222324252627282930313233343536373839\
-        4041424344454647484950515253545556575859\
-        6061626364656667686970717273747576777879\
-        8081828384858687888990919293949596979899";
-
-    pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
-
-    pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
-        let mut buf: [u8; STATUS_LINE_BUF_SIZE] = *b"HTTP/1.1     ";
-
-        match version {
-            Version::HTTP_2 => buf[5] = b'2',
-            Version::HTTP_10 => buf[7] = b'0',
-            Version::HTTP_09 => {
-                buf[5] = b'0';
-                buf[7] = b'9';
-            }
-            _ => {}
-        }
-
-        let mut curr: isize = 12;
-        let buf_ptr = buf.as_mut_ptr();
-        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-        let four = n > 999;
-
-        // decode 2 more chars, if > 2 chars
-        let d1 = (n % 100) << 1;
-        n /= 100;
-        curr -= 2;
-        unsafe {
-            ptr::copy_nonoverlapping(
-                lut_ptr.offset(d1 as isize),
-                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 as isize),
-                    buf_ptr.offset(curr),
-                    2,
-                );
-            }
-        }
-
-        bytes.put_slice(&buf);
-        if four {
-            bytes.put_u8(b' ');
-        }
-    }
-}

actix-http/benches/uninit-headers.rs

@@ -1,139 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use bytes::BytesMut;
-
-// A Miri run detects UB, seen on this playground:
-// https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=f5d9aa166aa48df8dca05fce2b6c3915
-
-fn bench_header_parsing(c: &mut Criterion) {
-    c.bench_function("Original (Unsound) [short]", |b| {
-        b.iter(|| {
-            let mut buf = BytesMut::from(REQ_SHORT);
-            _original::parse_headers(&mut buf);
-        })
-    });
-
-    c.bench_function("New (safe) [short]", |b| {
-        b.iter(|| {
-            let mut buf = BytesMut::from(REQ_SHORT);
-            _new::parse_headers(&mut buf);
-        })
-    });
-
-    c.bench_function("Original (Unsound) [realistic]", |b| {
-        b.iter(|| {
-            let mut buf = BytesMut::from(REQ);
-            _original::parse_headers(&mut buf);
-        })
-    });
-
-    c.bench_function("New (safe) [realistic]", |b| {
-        b.iter(|| {
-            let mut buf = BytesMut::from(REQ);
-            _new::parse_headers(&mut buf);
-        })
-    });
-}
-
-criterion_group!(benches, bench_header_parsing);
-criterion_main!(benches);
-
-const MAX_HEADERS: usize = 96;
-
-const EMPTY_HEADER_ARRAY: [httparse::Header<'static>; MAX_HEADERS] =
-    [httparse::EMPTY_HEADER; MAX_HEADERS];
-
-#[derive(Clone, Copy)]
-struct HeaderIndex {
-    name: (usize, usize),
-    value: (usize, usize),
-}
-
-const EMPTY_HEADER_INDEX: HeaderIndex = HeaderIndex {
-    name: (0, 0),
-    value: (0, 0),
-};
-
-const EMPTY_HEADER_INDEX_ARRAY: [HeaderIndex; MAX_HEADERS] =
-    [EMPTY_HEADER_INDEX; MAX_HEADERS];
-
-impl HeaderIndex {
-    fn record(
-        bytes: &[u8],
-        headers: &[httparse::Header<'_>],
-        indices: &mut [HeaderIndex],
-    ) {
-        let bytes_ptr = bytes.as_ptr() as usize;
-        for (header, indices) in headers.iter().zip(indices.iter_mut()) {
-            let name_start = header.name.as_ptr() as usize - bytes_ptr;
-            let name_end = name_start + header.name.len();
-            indices.name = (name_start, name_end);
-            let value_start = header.value.as_ptr() as usize - bytes_ptr;
-            let value_end = value_start + header.value.len();
-            indices.value = (value_start, value_end);
-        }
-    }
-}
-
-// test cases taken from:
-// https://github.com/seanmonstar/httparse/blob/master/benches/parse.rs
-
-const REQ_SHORT: &[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"\
-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\
-Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\
-Accept-Language: ja,en-us;q=0.7,en;q=0.3\r\n\
-Accept-Encoding: gzip,deflate\r\n\
-Accept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7\r\n\
-Keep-Alive: 115\r\n\
-Connection: keep-alive\r\n\
-Cookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx; __utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x; __utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral|padding=under256\r\n\r\n";
-
-mod _new {
-    use super::*;
-
-    pub fn parse_headers(src: &mut BytesMut) -> usize {
-        let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
-        let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
-
-        let mut req = httparse::Request::new(&mut parsed);
-        match req.parse(src).unwrap() {
-            httparse::Status::Complete(_len) => {
-                HeaderIndex::record(src, req.headers, &mut headers);
-                req.headers.len()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-mod _original {
-    use super::*;
-
-    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() };
-
-        let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
-            unsafe { MaybeUninit::uninit().assume_init() };
-
-        let mut req = httparse::Request::new(&mut parsed);
-        match req.parse(src).unwrap() {
-            httparse::Status::Complete(_len) => {
-                HeaderIndex::record(src, req.headers, &mut headers);
-                req.headers.len()
-            }
-            _ => unreachable!(),
-        }
-    }
-}

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

@@ -1,89 +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]);
-                _new::write_camel_case(black_box(bts), &mut buf)
-            });
-        });
-    }
-
-    group.finish();
-}
-
-criterion_group!(benches, bench_write_camel_case);
-criterion_main!(benches);
-
-mod _new {
-    pub fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
-        // first copy entire (potentially wrong) slice to output
-        buffer[..value.len()].copy_from_slice(value);
-
-        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,39 +0,0 @@
-use std::io;
-
-use actix_http::{http::StatusCode, Error, HttpService, Request, Response};
-use actix_server::Server;
-use bytes::BytesMut;
-use futures_util::StreamExt as _;
-use http::header::HeaderValue;
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
-
-    Server::build()
-        .bind("echo", ("127.0.0.1", 8080), || {
-            HttpService::build()
-                .client_timeout(1000)
-                .client_disconnect(1000)
-                .finish(|mut req: Request| async move {
-                    let mut body = BytesMut::new();
-                    while let Some(item) = req.payload().next().await {
-                        body.extend_from_slice(&item?);
-                    }
-
-                    log::info!("request body: {:?}", body);
-
-                    Ok::<_, Error>(
-                        Response::build(StatusCode::OK)
-                            .insert_header((
-                                "x-head",
-                                HeaderValue::from_static("dummy value!"),
-                            ))
-                            .body(body),
-                    )
-                })
-                .tcp()
-        })?
-        .run()
-        .await
-}

actix-http/examples/echo2.rs

@@ -1,32 +0,0 @@
-use std::io;
-
-use actix_http::{body::Body, http::HeaderValue, http::StatusCode};
-use actix_http::{Error, HttpService, Request, Response};
-use actix_server::Server;
-use bytes::BytesMut;
-use futures_util::StreamExt as _;
-
-async fn handle_request(mut req: Request) -> Result<Response<Body>, 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!")))
-        .body(body))
-}
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
-
-    Server::build()
-        .bind("echo", ("127.0.0.1", 8080), || {
-            HttpService::build().finish(handle_request).tcp()
-        })?
-        .run()
-        .await
-}

actix-http/examples/hello-world.rs

@@ -1,31 +0,0 @@
-use std::{convert::Infallible, io};
-
-use actix_http::{http::StatusCode, HttpService, Response};
-use actix_server::Server;
-use http::header::HeaderValue;
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
-
-    Server::build()
-        .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!"))
-                })
-                .tcp()
-        })?
-        .run()
-        .await
-}

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,106 +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::{
-        internal::pemfile::{certs, pkcs8_private_keys},
-        NoClientAuth, ServerConfig,
-    };
-
-    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 mut config = ServerConfig::new(NoClientAuth::new());
-    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();
-    let mut keys = pkcs8_private_keys(key_file).unwrap();
-    config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
-
-    config
-}

actix-http/rustfmt.toml

@@ -1,5 +0,0 @@
-max_width = 89
-reorder_imports = true
-#wrap_comments = true
-#fn_args_density = "Compressed"
-#use_small_heuristics = false

actix-http/src/body/body.rs

@@ -1,233 +0,0 @@
-use std::{
-    borrow::Cow,
-    error::Error as StdError,
-    fmt, mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::{ready, 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))))
-                }
-            }
-
-            // TODO: MSRV 1.51: poll_map_err
-            AnyBody::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
-                Some(Err(err)) => {
-                    Poll::Ready(Some(Err(Error::new_body().with_cause(err))))
-                }
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-        }
-    }
-}
-
-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>>> {
-        // TODO: MSRV 1.51: poll_map_err
-        match ready!(self.0.as_mut().poll_next(cx)) {
-            Some(Err(err)) => Poll::Ready(Some(Err(Error::new_body().with_cause(err)))),
-            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-            None => Poll::Ready(None),
-        }
-    }
-}

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,232 +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 crate::error::Error;
-
-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,
-    B::Error: Into<Error>,
-{
-    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,
-    B::Error: Into<Error>,
-{
-    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,89 +0,0 @@
-use std::{
-    mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, 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() {
-            // TODO: MSRV 1.51: poll_map_err
-            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-            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,246 +0,0 @@
-use std::{error::Error as StdError, fmt, marker::PhantomData, net, rc::Rc};
-
-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,
-};
-
-/// 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> {
-    keep_alive: KeepAlive,
-    client_timeout: u64,
-    client_disconnect: u64,
-    secure: bool,
-    local_addr: Option<net::SocketAddr>,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<S>,
-}
-
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
-{
-    /// Create instance of `ServiceConfigBuilder`
-    pub fn new() -> Self {
-        HttpServiceBuilder {
-            keep_alive: KeepAlive::Timeout(5),
-            client_timeout: 5000,
-            client_disconnect: 0,
-            secure: false,
-            local_addr: None,
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect_ext: None,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Response<AnyBody>>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    /// Set server keep-alive setting.
-    ///
-    /// By default keep alive is set to a 5 seconds.
-    pub fn keep_alive<W: Into<KeepAlive>>(mut self, val: W) -> Self {
-        self.keep_alive = val.into();
-        self
-    }
-
-    /// Set connection secure state
-    pub fn secure(mut self) -> Self {
-        self.secure = true;
-        self
-    }
-
-    /// Set the local address that this service is bound to.
-    pub fn local_addr(mut self, addr: net::SocketAddr) -> Self {
-        self.local_addr = Some(addr);
-        self
-    }
-
-    /// Set server client timeout in milliseconds for first request.
-    ///
-    /// Defines a timeout for reading client request header. If a client does not transmit
-    /// the entire set headers within this time, the request is terminated with
-    /// the 408 (Request Time-out) error.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default client timeout is set to 5000 milliseconds.
-    pub fn client_timeout(mut self, val: u64) -> Self {
-        self.client_timeout = val;
-        self
-    }
-
-    /// Set server connection disconnect timeout in milliseconds.
-    ///
-    /// Defines a timeout for disconnect connection. If a disconnect procedure does not complete
-    /// within this time, the request get dropped. This timeout affects secure connections.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default disconnect timeout is set to 0.
-    pub fn client_disconnect(mut self, val: u64) -> Self {
-        self.client_disconnect = val;
-        self
-    }
-
-    /// Provide service for `EXPECT: 100-Continue` support.
-    ///
-    /// Service get called with request that contains `EXPECT` header.
-    /// Service must return request in case of success, in that case
-    /// 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>>,
-        X1::InitError: fmt::Debug,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            client_timeout: self.client_timeout,
-            client_disconnect: self.client_disconnect,
-            secure: self.secure,
-            local_addr: self.local_addr,
-            expect: expect.into_factory(),
-            upgrade: self.upgrade,
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Provide service for custom `Connection: UPGRADE` support.
-    ///
-    /// If service is provided then normal requests handling get halted
-    /// 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 = ()>,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            client_timeout: self.client_timeout,
-            client_disconnect: self.client_disconnect,
-            secure: self.secure,
-            local_addr: self.local_addr,
-            expect: self.expect,
-            upgrade: Some(upgrade.into_factory()),
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Sets the callback to be run on connection establishment.
-    ///
-    /// Has mutable access to a data container that will be merged into request extensions.
-    /// This enables transport layer data (like client certificates) to be accessed in middleware
-    /// and handlers.
-    pub fn on_connect_ext<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&T, &mut Extensions) + 'static,
-    {
-        self.on_connect_ext = Some(Rc::new(f));
-        self
-    }
-
-    /// Finish service configuration and create a HTTP Service for HTTP/1 protocol.
-    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>>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-            self.secure,
-            self.local_addr,
-        );
-
-        H1Service::with_config(cfg, service.into_factory())
-            .expect(self.expect)
-            .upgrade(self.upgrade)
-            .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,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-            self.secure,
-            self.local_addr,
-        );
-
-        H2Service::with_config(cfg, service.into_factory())
-            .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,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-
-        B: MessageBody + 'static,
-        B::Error: Into<Box<dyn StdError>>,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-            self.secure,
-            self.local_addr,
-        );
-
-        HttpService::with_config(cfg, service.into_factory())
-            .expect(self.expect)
-            .upgrade(self.upgrade)
-            .on_connect_ext(self.on_connect_ext)
-    }
-}

actix-http/src/client/config.rs

@@ -1,43 +0,0 @@
-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
-
-/// 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),
-            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,
-        }
-    }
-}
-
-impl ConnectorConfig {
-    pub(crate) fn no_disconnect_timeout(&self) -> Self {
-        let mut res = self.clone();
-        res.disconnect_timeout = None;
-        res
-    }
-}

actix-http/src/client/connection.rs

@@ -1,475 +0,0 @@
-use std::{
-    io,
-    ops::{Deref, DerefMut},
-    pin::Pin,
-    task::{Context, Poll},
-    time,
-};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
-use actix_rt::task::JoinHandle;
-use bytes::Bytes;
-use futures_core::future::LocalBoxFuture;
-use h2::client::SendRequest;
-
-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::{h1proto, h2proto};
-
-/// Trait alias for types impl [tokio::io::AsyncRead] and [tokio::io::AsyncWrite].
-pub trait ConnectionIo: AsyncRead + AsyncWrite + Unpin + 'static {}
-
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static> ConnectionIo for T {}
-
-/// HTTP client connection
-pub struct H1Connection<Io: ConnectionIo> {
-    io: Option<Io>,
-    created: time::Instant,
-    acquired: Acquired<Io>,
-}
-
-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();
-        }
-    }
-
-    /// 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>,
-    ) -> Self {
-        let handle = actix_rt::spawn(async move {
-            let _ = connection.await;
-        });
-
-        Self { handle, sender }
-    }
-}
-
-/// 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();
-        }
-    }
-}
-
-#[allow(dead_code)]
-/// Unified connection type cover Http1 Plain/Tls and Http2 protocols
-pub enum Connection<A, B = Box<dyn ConnectionIo>>
-where
-    A: ConnectionIo,
-    B: ConnectionIo,
-{
-    Tcp(ConnectionType<A>),
-    Tls(ConnectionType<B>),
-}
-
-/// 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),
-        }
-    }
-
-    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>(
-        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"
-                ),
-            }
-        })
-    }
-
-    /// Send request, returns Response and Framed tunnel.
-    pub fn open_tunnel<H: Into<RequestHeadType> + 'static>(
-        self,
-        head: H,
-    ) -> 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"
-                    )
-                }
-            }
-        })
-    }
-}
-
-impl<A, B> AsyncRead for Connection<A, B>
-where
-    A: ConnectionIo,
-    B: ConnectionIo,
-{
-    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"),
-        }
-    }
-}
-
-const H2_UNREACHABLE_WRITE: &str = "H2Connection can not impl AsyncWrite trait";
-
-impl<A, B> AsyncWrite for Connection<A, B>
-where
-    A: ConnectionIo,
-    B: ConnectionIo,
-{
-    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),
-        }
-    }
-
-    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),
-        }
-    }
-
-    fn poll_shutdown(
-        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),
-        }
-    }
-
-    fn poll_write_vectored(
-        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),
-        }
-    }
-}
-
-#[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/connector.rs

@@ -1,764 +0,0 @@
-use std::{
-    fmt,
-    future::Future,
-    net::IpAddr,
-    pin::Pin,
-    rc::Rc,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use actix_rt::{
-    net::{ActixStream, TcpStream},
-    time::{sleep, Sleep},
-};
-use actix_service::Service;
-use actix_tls::connect::{
-    new_connector, Connect as TcpConnect, ConnectError as TcpConnectError,
-    Connection as TcpConnection, Resolver,
-};
-use futures_core::{future::LocalBoxFuture, ready};
-use http::Uri;
-use pin_project::pin_project;
-
-use super::config::ConnectorConfig;
-use super::connection::{Connection, ConnectionIo};
-use super::error::ConnectError;
-use super::pool::ConnectionPool;
-use super::Connect;
-use super::Protocol;
-
-#[cfg(feature = "openssl")]
-use actix_tls::connect::ssl::openssl::SslConnector as OpensslConnector;
-#[cfg(feature = "rustls")]
-use actix_tls::connect::ssl::rustls::ClientConfig;
-
-enum SslConnector {
-    #[allow(dead_code)]
-    None,
-    #[cfg(feature = "openssl")]
-    Openssl(OpensslConnector),
-    #[cfg(feature = "rustls")]
-    Rustls(std::sync::Arc<ClientConfig>),
-}
-
-/// Manages HTTP client network connectivity.
-///
-/// The `Connector` type uses a builder-like combinator pattern for service
-/// construction that finishes by calling the `.finish()` method.
-///
-/// ```ignore
-/// use std::time::Duration;
-/// use actix_http::client::Connector;
-///
-/// let connector = Connector::new()
-///      .timeout(Duration::from_secs(5))
-///      .finish();
-/// ```
-pub struct Connector<T> {
-    connector: T,
-    config: ConnectorConfig,
-    #[allow(dead_code)]
-    ssl: SslConnector,
-}
-
-impl Connector<()> {
-    #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
-    pub fn new() -> Connector<
-        impl Service<
-                TcpConnect<Uri>,
-                Response = TcpConnection<Uri, TcpStream>,
-                Error = actix_tls::connect::ConnectError,
-            > + Clone,
-    > {
-        Connector {
-            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
-            connector: new_connector(resolver::resolver()),
-            config: ConnectorConfig::default(),
-        }
-    }
-
-    // Build Ssl connector with openssl, based on supplied alpn protocols
-    #[cfg(feature = "openssl")]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        use actix_tls::connect::ssl::openssl::SslMethod;
-        use bytes::{BufMut, BytesMut};
-
-        let mut alpn = BytesMut::with_capacity(20);
-        for proto in &protocols {
-            alpn.put_u8(proto.len() as u8);
-            alpn.put(proto.as_slice());
-        }
-
-        let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
-        let _ = ssl
-            .set_alpn_protos(&alpn)
-            .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
-        SslConnector::Openssl(ssl.build())
-    }
-
-    // Build Ssl connector with rustls, based on supplied alpn protocols
-    #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        let mut config = ClientConfig::new();
-        config.set_protocols(&protocols);
-        config.root_store.add_server_trust_anchors(
-            &actix_tls::connect::ssl::rustls::TLS_SERVER_ROOTS,
-        );
-        SslConnector::Rustls(std::sync::Arc::new(config))
-    }
-
-    // ssl turned off, provides empty ssl connector
-    #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-    fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {
-        SslConnector::None
-    }
-}
-
-impl<S> Connector<S> {
-    /// Use custom connector.
-    pub fn connector<S1, Io1>(self, connector: S1) -> Connector<S1>
-    where
-        Io1: ActixStream + fmt::Debug + 'static,
-        S1: Service<
-                TcpConnect<Uri>,
-                Response = TcpConnection<Uri, Io1>,
-                Error = TcpConnectError,
-            > + Clone,
-    {
-        Connector {
-            connector,
-            config: self.config,
-            ssl: self.ssl,
-        }
-    }
-}
-
-impl<S, Io> Connector<S>
-where
-    // Note:
-    // Input Io type is bound to ActixStream trait but internally in client module they
-    // are bound to ConnectionIo trait alias. And latter is the trait exposed to public
-    // in the form of Box<dyn ConnectionIo> type.
-    //
-    // This remap is to hide ActixStream's trait methods. They are not meant to be called
-    // from user code.
-    Io: ActixStream + fmt::Debug + 'static,
-    S: Service<
-            TcpConnect<Uri>,
-            Response = TcpConnection<Uri, Io>,
-            Error = TcpConnectError,
-        > + Clone
-        + 'static,
-{
-    /// Tcp connection timeout, i.e. max time to connect to remote host including dns name
-    /// resolution. Set to 5 second by default.
-    pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.config.timeout = timeout;
-        self
-    }
-
-    /// Tls handshake timeout, i.e. max time to do tls handshake with remote host after tcp
-    /// connection established. Set to 5 second by default.
-    pub fn handshake_timeout(mut self, timeout: Duration) -> Self {
-        self.config.handshake_timeout = timeout;
-        self
-    }
-
-    #[cfg(feature = "openssl")]
-    /// Use custom `SslConnector` instance.
-    pub fn ssl(mut self, connector: OpensslConnector) -> Self {
-        self.ssl = SslConnector::Openssl(connector);
-        self
-    }
-
-    #[cfg(feature = "rustls")]
-    /// Use custom `SslConnector` instance.
-    pub fn rustls(mut self, connector: std::sync::Arc<ClientConfig>) -> Self {
-        self.ssl = SslConnector::Rustls(connector);
-        self
-    }
-
-    /// Maximum supported HTTP major version.
-    ///
-    /// Supported versions are HTTP/1.1 and HTTP/2.
-    pub fn max_http_version(mut self, val: http::Version) -> Self {
-        let versions = match val {
-            http::Version::HTTP_11 => vec![b"http/1.1".to_vec()],
-            http::Version::HTTP_2 => vec![b"h2".to_vec(), b"http/1.1".to_vec()],
-            _ => {
-                unimplemented!("actix-http:client: supported versions http/1.1, http/2")
-            }
-        };
-        self.ssl = Connector::build_ssl(versions);
-        self
-    }
-
-    /// Indicates the initial window size (in octets) for
-    /// HTTP2 stream-level flow control for received data.
-    ///
-    /// The default value is 65,535 and is good for APIs, but not for big objects.
-    pub fn initial_window_size(mut self, size: u32) -> Self {
-        self.config.stream_window_size = size;
-        self
-    }
-
-    /// Indicates the initial window size (in octets) for
-    /// HTTP2 connection-level flow control for received data.
-    ///
-    /// The default value is 65,535 and is good for APIs, but not for big objects.
-    pub fn initial_connection_window_size(mut self, size: u32) -> Self {
-        self.config.conn_window_size = size;
-        self
-    }
-
-    /// Set total number of simultaneous connections per type of scheme.
-    ///
-    /// If limit is 0, the connector has no limit.
-    /// The default limit size is 100.
-    pub fn limit(mut self, limit: usize) -> Self {
-        self.config.limit = limit;
-        self
-    }
-
-    /// Set keep-alive period for opened connection.
-    ///
-    /// Keep-alive period is the period between connection usage. If
-    /// the delay between repeated usages of the same connection
-    /// exceeds this period, the connection is closed.
-    /// Default keep-alive period is 15 seconds.
-    pub fn conn_keep_alive(mut self, dur: Duration) -> Self {
-        self.config.conn_keep_alive = dur;
-        self
-    }
-
-    /// Set max lifetime period for connection.
-    ///
-    /// Connection lifetime is max lifetime of any opened connection
-    /// until it is closed regardless of keep-alive period.
-    /// Default lifetime period is 75 seconds.
-    pub fn conn_lifetime(mut self, dur: Duration) -> Self {
-        self.config.conn_lifetime = dur;
-        self
-    }
-
-    /// Set server connection disconnect timeout in milliseconds.
-    ///
-    /// Defines a timeout for disconnect connection. If a disconnect procedure does not complete
-    /// within this time, the socket get dropped. This timeout affects only secure connections.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default disconnect timeout is set to 3000 milliseconds.
-    pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
-        self.config.disconnect_timeout = Some(dur);
-        self
-    }
-
-    /// Set local IP Address the connector would use for establishing connection.
-    pub fn local_address(mut self, addr: IpAddr) -> Self {
-        self.config.local_address = Some(addr);
-        self
-    }
-
-    /// Finish configuration process and create connector service.
-    /// The Connector builder always concludes by calling `finish()` last in
-    /// its combinator chain.
-    pub fn finish(self) -> ConnectorService<S, Io> {
-        let local_address = self.config.local_address;
-        let timeout = self.config.timeout;
-
-        let tcp_service_inner =
-            TcpConnectorInnerService::new(self.connector, timeout, local_address);
-
-        #[allow(clippy::redundant_clone)]
-        let tcp_service = TcpConnectorService {
-            service: tcp_service_inner.clone(),
-        };
-
-        let tls_service = match self.ssl {
-            SslConnector::None => None,
-            #[cfg(feature = "openssl")]
-            SslConnector::Openssl(tls) => {
-                const H2: &[u8] = b"h2";
-
-                use actix_tls::connect::ssl::openssl::{OpensslConnector, SslStream};
-
-                impl<Io: ConnectionIo> IntoConnectionIo for TcpConnection<Uri, SslStream<Io>> {
-                    fn into_connection_io(self) -> (Box<dyn ConnectionIo>, Protocol) {
-                        let sock = self.into_parts().0;
-                        let h2 = sock
-                            .ssl()
-                            .selected_alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
-                        if h2 {
-                            (Box::new(sock), Protocol::Http2)
-                        } else {
-                            (Box::new(sock), Protocol::Http1)
-                        }
-                    }
-                }
-
-                let handshake_timeout = self.config.handshake_timeout;
-
-                let tls_service = TlsConnectorService {
-                    tcp_service: tcp_service_inner,
-                    tls_service: OpensslConnector::service(tls),
-                    timeout: handshake_timeout,
-                };
-
-                Some(actix_service::boxed::rc_service(tls_service))
-            }
-            #[cfg(feature = "rustls")]
-            SslConnector::Rustls(tls) => {
-                const H2: &[u8] = b"h2";
-
-                use actix_tls::connect::ssl::rustls::{
-                    RustlsConnector, Session, TlsStream,
-                };
-
-                impl<Io: ConnectionIo> IntoConnectionIo for TcpConnection<Uri, TlsStream<Io>> {
-                    fn into_connection_io(self) -> (Box<dyn ConnectionIo>, Protocol) {
-                        let sock = self.into_parts().0;
-                        let h2 = sock
-                            .get_ref()
-                            .1
-                            .get_alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
-                        if h2 {
-                            (Box::new(sock), Protocol::Http2)
-                        } else {
-                            (Box::new(sock), Protocol::Http1)
-                        }
-                    }
-                }
-
-                let handshake_timeout = self.config.handshake_timeout;
-
-                let tls_service = TlsConnectorService {
-                    tcp_service: tcp_service_inner,
-                    tls_service: RustlsConnector::service(tls),
-                    timeout: handshake_timeout,
-                };
-
-                Some(actix_service::boxed::rc_service(tls_service))
-            }
-        };
-
-        let tcp_config = self.config.no_disconnect_timeout();
-
-        let tcp_pool = ConnectionPool::new(tcp_service, tcp_config);
-
-        let tls_config = self.config;
-        let tls_pool = tls_service
-            .map(move |tls_service| ConnectionPool::new(tls_service, tls_config));
-
-        ConnectorServicePriv { tcp_pool, tls_pool }
-    }
-}
-
-/// tcp service for map `TcpConnection<Uri, Io>` type to `(Io, Protocol)`
-#[derive(Clone)]
-pub struct TcpConnectorService<S: Clone> {
-    service: S,
-}
-
-impl<S, Io> Service<Connect> for TcpConnectorService<S>
-where
-    S: Service<Connect, Response = TcpConnection<Uri, Io>, Error = ConnectError>
-        + Clone
-        + 'static,
-{
-    type Response = (Io, Protocol);
-    type Error = ConnectError;
-    type Future = TcpConnectorFuture<S::Future>;
-
-    actix_service::forward_ready!(service);
-
-    fn call(&self, req: Connect) -> Self::Future {
-        TcpConnectorFuture {
-            fut: self.service.call(req),
-        }
-    }
-}
-
-#[pin_project]
-pub struct TcpConnectorFuture<Fut> {
-    #[pin]
-    fut: Fut,
-}
-
-impl<Fut, Io> Future for TcpConnectorFuture<Fut>
-where
-    Fut: Future<Output = Result<TcpConnection<Uri, Io>, ConnectError>>,
-{
-    type Output = Result<(Io, Protocol), ConnectError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project()
-            .fut
-            .poll(cx)
-            .map_ok(|res| (res.into_parts().0, Protocol::Http1))
-    }
-}
-
-/// service for establish tcp connection and do client tls handshake.
-/// operation is canceled when timeout limit reached.
-struct TlsConnectorService<S, St> {
-    /// tcp connection is canceled on `TcpConnectorInnerService`'s timeout setting.
-    tcp_service: S,
-    /// tls connection is canceled on `TlsConnectorService`'s timeout setting.
-    tls_service: St,
-    timeout: Duration,
-}
-
-impl<S, St, Io> Service<Connect> for TlsConnectorService<S, St>
-where
-    S: Service<Connect, Response = TcpConnection<Uri, Io>, Error = ConnectError>
-        + Clone
-        + 'static,
-    St: Service<TcpConnection<Uri, Io>, Error = std::io::Error> + Clone + 'static,
-    Io: ConnectionIo,
-    St::Response: IntoConnectionIo,
-{
-    type Response = (Box<dyn ConnectionIo>, Protocol);
-    type Error = ConnectError;
-    type Future = TlsConnectorFuture<St, S::Future, St::Future>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        ready!(self.tcp_service.poll_ready(cx))?;
-        ready!(self.tls_service.poll_ready(cx))?;
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&self, req: Connect) -> Self::Future {
-        let fut = self.tcp_service.call(req);
-        let tls_service = self.tls_service.clone();
-        let timeout = self.timeout;
-
-        TlsConnectorFuture::TcpConnect {
-            fut,
-            tls_service: Some(tls_service),
-            timeout,
-        }
-    }
-}
-
-#[pin_project(project = TlsConnectorProj)]
-#[allow(clippy::large_enum_variant)]
-enum TlsConnectorFuture<S, Fut1, Fut2> {
-    TcpConnect {
-        #[pin]
-        fut: Fut1,
-        tls_service: Option<S>,
-        timeout: Duration,
-    },
-    TlsConnect {
-        #[pin]
-        fut: Fut2,
-        #[pin]
-        timeout: Sleep,
-    },
-}
-
-/// helper trait for generic over different TlsStream types between tls crates.
-trait IntoConnectionIo {
-    fn into_connection_io(self) -> (Box<dyn ConnectionIo>, Protocol);
-}
-
-impl<S, Io, Fut1, Fut2, Res> Future for TlsConnectorFuture<S, Fut1, Fut2>
-where
-    S: Service<
-        TcpConnection<Uri, Io>,
-        Response = Res,
-        Error = std::io::Error,
-        Future = Fut2,
-    >,
-    S::Response: IntoConnectionIo,
-    Fut1: Future<Output = Result<TcpConnection<Uri, Io>, ConnectError>>,
-    Fut2: Future<Output = Result<S::Response, S::Error>>,
-    Io: ConnectionIo,
-{
-    type Output = Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.as_mut().project() {
-            TlsConnectorProj::TcpConnect {
-                fut,
-                tls_service,
-                timeout,
-            } => {
-                let res = ready!(fut.poll(cx))?;
-                let fut = tls_service
-                    .take()
-                    .expect("TlsConnectorFuture polled after complete")
-                    .call(res);
-                let timeout = sleep(*timeout);
-                self.set(TlsConnectorFuture::TlsConnect { fut, timeout });
-                self.poll(cx)
-            }
-            TlsConnectorProj::TlsConnect { fut, timeout } => match fut.poll(cx)? {
-                Poll::Ready(res) => Poll::Ready(Ok(res.into_connection_io())),
-                Poll::Pending => timeout.poll(cx).map(|_| Err(ConnectError::Timeout)),
-            },
-        }
-    }
-}
-
-/// service for establish tcp connection.
-/// operation is canceled when timeout limit reached.
-#[derive(Clone)]
-pub struct TcpConnectorInnerService<S: Clone> {
-    service: S,
-    timeout: Duration,
-    local_address: Option<std::net::IpAddr>,
-}
-
-impl<S: Clone> TcpConnectorInnerService<S> {
-    fn new(
-        service: S,
-        timeout: Duration,
-        local_address: Option<std::net::IpAddr>,
-    ) -> Self {
-        Self {
-            service,
-            timeout,
-            local_address,
-        }
-    }
-}
-
-impl<S, Io> Service<Connect> for TcpConnectorInnerService<S>
-where
-    S: Service<
-            TcpConnect<Uri>,
-            Response = TcpConnection<Uri, Io>,
-            Error = TcpConnectError,
-        > + Clone
-        + 'static,
-{
-    type Response = S::Response;
-    type Error = ConnectError;
-    type Future = TcpConnectorInnerFuture<S::Future>;
-
-    actix_service::forward_ready!(service);
-
-    fn call(&self, req: Connect) -> Self::Future {
-        let mut req = TcpConnect::new(req.uri).set_addr(req.addr);
-
-        if let Some(local_addr) = self.local_address {
-            req = req.set_local_addr(local_addr);
-        }
-
-        TcpConnectorInnerFuture {
-            fut: self.service.call(req),
-            timeout: sleep(self.timeout),
-        }
-    }
-}
-
-#[pin_project]
-pub struct TcpConnectorInnerFuture<Fut> {
-    #[pin]
-    fut: Fut,
-    #[pin]
-    timeout: Sleep,
-}
-
-impl<Fut, Io> Future for TcpConnectorInnerFuture<Fut>
-where
-    Fut: Future<Output = Result<TcpConnection<Uri, Io>, TcpConnectError>>,
-{
-    type Output = Result<TcpConnection<Uri, Io>, ConnectError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-        match this.fut.poll(cx) {
-            Poll::Ready(res) => Poll::Ready(res.map_err(ConnectError::from)),
-            Poll::Pending => this.timeout.poll(cx).map(|_| Err(ConnectError::Timeout)),
-        }
-    }
-}
-
-/// Connector service for pooled Plain/Tls Tcp connections.
-pub type ConnectorService<S, Io> = ConnectorServicePriv<
-    TcpConnectorService<TcpConnectorInnerService<S>>,
-    Rc<
-        dyn Service<
-            Connect,
-            Response = (Box<dyn ConnectionIo>, Protocol),
-            Error = ConnectError,
-            Future = LocalBoxFuture<
-                'static,
-                Result<(Box<dyn ConnectionIo>, Protocol), ConnectError>,
-            >,
-        >,
-    >,
-    Io,
-    Box<dyn ConnectionIo>,
->;
-
-pub struct ConnectorServicePriv<S1, S2, Io1, Io2>
-where
-    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>,
-    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>,
-    Io1: ConnectionIo,
-    Io2: ConnectionIo,
-{
-    tcp_pool: ConnectionPool<S1, Io1>,
-    tls_pool: Option<ConnectionPool<S2, Io2>>,
-}
-
-impl<S1, S2, Io1, Io2> Service<Connect> for ConnectorServicePriv<S1, S2, Io1, Io2>
-where
-    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    Io1: ConnectionIo,
-    Io2: ConnectionIo,
-{
-    type Response = Connection<Io1, Io2>;
-    type Error = ConnectError;
-    type Future = ConnectorServiceFuture<S1, S2, Io1, Io2>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        ready!(self.tcp_pool.poll_ready(cx))?;
-        if let Some(ref tls_pool) = self.tls_pool {
-            ready!(tls_pool.poll_ready(cx))?;
-        }
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&self, req: Connect) -> Self::Future {
-        match req.uri.scheme_str() {
-            Some("https") | Some("wss") => match self.tls_pool {
-                None => ConnectorServiceFuture::SslIsNotSupported,
-                Some(ref pool) => ConnectorServiceFuture::Tls(pool.call(req)),
-            },
-            _ => ConnectorServiceFuture::Tcp(self.tcp_pool.call(req)),
-        }
-    }
-}
-
-#[pin_project(project = ConnectorServiceProj)]
-pub enum ConnectorServiceFuture<S1, S2, Io1, Io2>
-where
-    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    Io1: ConnectionIo,
-    Io2: ConnectionIo,
-{
-    Tcp(#[pin] <ConnectionPool<S1, Io1> as Service<Connect>>::Future),
-    Tls(#[pin] <ConnectionPool<S2, Io2> as Service<Connect>>::Future),
-    SslIsNotSupported,
-}
-
-impl<S1, S2, Io1, Io2> Future for ConnectorServiceFuture<S1, S2, Io1, Io2>
-where
-    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    Io1: ConnectionIo,
-    Io2: ConnectionIo,
-{
-    type Output = Result<Connection<Io1, Io2>, ConnectError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.project() {
-            ConnectorServiceProj::Tcp(fut) => fut.poll(cx).map_ok(Connection::Tcp),
-            ConnectorServiceProj::Tls(fut) => fut.poll(cx).map_ok(Connection::Tls),
-            ConnectorServiceProj::SslIsNotSupported => {
-                Poll::Ready(Err(ConnectError::SslIsNotSupported))
-            }
-        }
-    }
-}
-
-#[cfg(not(feature = "trust-dns"))]
-mod resolver {
-    use super::*;
-
-    pub(super) fn resolver() -> Resolver {
-        Resolver::Default
-    }
-}
-
-#[cfg(feature = "trust-dns")]
-mod resolver {
-    use std::{cell::RefCell, net::SocketAddr};
-
-    use actix_tls::connect::Resolve;
-    use futures_core::future::LocalBoxFuture;
-    use trust_dns_resolver::{
-        config::{ResolverConfig, ResolverOpts},
-        system_conf::read_system_conf,
-        TokioAsyncResolver,
-    };
-
-    use super::*;
-
-    pub(super) fn resolver() -> Resolver {
-        // new type for impl Resolve trait for TokioAsyncResolver.
-        struct TrustDnsResolver(TokioAsyncResolver);
-
-        impl Resolve for TrustDnsResolver {
-            fn lookup<'a>(
-                &'a self,
-                host: &'a str,
-                port: u16,
-            ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>>
-            {
-                Box::pin(async move {
-                    let res = self
-                        .0
-                        .lookup_ip(host)
-                        .await?
-                        .iter()
-                        .map(|ip| SocketAddr::new(ip, port))
-                        .collect();
-                    Ok(res)
-                })
-            }
-        }
-
-        // dns struct is cached in thread local.
-        // so new client constructor can reuse the existing dns resolver.
-        thread_local! {
-            static TRUST_DNS_RESOLVER: RefCell<Option<Resolver>> = RefCell::new(None);
-        }
-
-        // get from thread local or construct a new trust-dns resolver.
-        TRUST_DNS_RESOLVER.with(|local| {
-            let resolver = local.borrow().as_ref().map(Clone::clone);
-            match resolver {
-                Some(resolver) => resolver,
-                None => {
-                    let (cfg, opts) = match read_system_conf() {
-                        Ok((cfg, opts)) => (cfg, opts),
-                        Err(e) => {
-                            log::error!("TRust-DNS can not load system config: {}", e);
-                            (ResolverConfig::default(), ResolverOpts::default())
-                        }
-                    };
-
-                    let resolver = TokioAsyncResolver::tokio(cfg, opts).unwrap();
-
-                    // box trust dns resolver and put it in thread local.
-                    let resolver = Resolver::new_custom(TrustDnsResolver(resolver));
-                    *local.borrow_mut() = Some(resolver.clone());
-                    resolver
-                }
-            }
-        })
-    }
-}

actix-http/src/client/error.rs

@@ -1,156 +0,0 @@
-use std::{error::Error as StdError, fmt, io};
-
-use derive_more::{Display, From};
-
-#[cfg(feature = "openssl")]
-use actix_tls::accept::openssl::SslError;
-
-use crate::error::{Error, ParseError};
-use crate::http::Error as HttpError;
-
-/// 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")]
-    SslIsNotSupported,
-
-    /// SSL error
-    #[cfg(feature = "openssl")]
-    #[display(fmt = "{}", _0)]
-    SslError(SslError),
-
-    /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(Box<dyn std::error::Error>),
-
-    /// No dns records
-    #[display(fmt = "No DNS records found for the input")]
-    NoRecords,
-
-    /// Http2 error
-    #[display(fmt = "{}", _0)]
-    H2(h2::Error),
-
-    /// Connecting took too long
-    #[display(fmt = "Timeout while establishing connection")]
-    Timeout,
-
-    /// Connector has been disconnected
-    #[display(fmt = "Internal error: connector has been disconnected")]
-    Disconnected,
-
-    /// Unresolved host name
-    #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolved,
-
-    /// Connection io error
-    #[display(fmt = "{}", _0)]
-    Io(io::Error),
-}
-
-impl std::error::Error for ConnectError {}
-
-impl From<actix_tls::connect::ConnectError> for ConnectError {
-    fn from(err: actix_tls::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),
-        }
-    }
-}
-
-#[derive(Debug, Display, From)]
-#[non_exhaustive]
-pub enum InvalidUrl {
-    #[display(fmt = "Missing URL scheme")]
-    MissingScheme,
-
-    #[display(fmt = "Unknown URL scheme")]
-    UnknownScheme,
-
-    #[display(fmt = "Missing host name")]
-    MissingHost,
-
-    #[display(fmt = "URL parse error: {}", _0)]
-    HttpError(http::Error),
-}
-
-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
-    #[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 {}
-
-/// 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
-    #[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),
-        }
-    }
-}

actix-http/src/client/h1proto.rs

@@ -1,230 +0,0 @@
-use std::{
-    io::Write,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use actix_codec::Framed;
-use actix_utils::future::poll_fn;
-use bytes::buf::BufMut;
-use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
-use futures_util::SinkExt as _;
-
-use crate::h1;
-use crate::http::{
-    header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
-    StatusCode,
-};
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-use crate::{error::PayloadError, Error};
-
-use super::connection::{ConnectionIo, H1Connection};
-use super::error::{ConnectError, SendRequestError};
-use crate::body::{BodySize, MessageBody};
-
-pub(crate) async fn send_request<Io, B>(
-    io: H1Connection<Io>,
-    mut head: RequestHeadType,
-    body: B,
-) -> Result<(ResponseHead, Payload), SendRequestError>
-where
-    Io: ConnectionIo,
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    // set request host header
-    if !head.as_ref().headers.contains_key(HOST)
-        && !head.extra_headers().iter().any(|h| h.contains_key(HOST))
-    {
-        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)?,
-            };
-
-            match wrt.get_mut().split().freeze().try_into_value() {
-                Ok(value) => match head {
-                    RequestHeadType::Owned(ref mut head) => {
-                        head.headers.insert(HOST, value);
-                    }
-                    RequestHeadType::Rc(_, ref mut extra_headers) => {
-                        let headers = extra_headers.get_or_insert(HeaderMap::new());
-                        headers.insert(HOST, value);
-                    }
-                },
-                Err(e) => log::error!("Can not set HOST header {}", e),
-            }
-        }
-    }
-
-    // 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
-    };
-
-    framed.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)
-    };
-
-    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 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() {
-        h1::MessageType::None => {
-            let keep_alive = pin_framed.codec_ref().keepalive();
-            pin_framed.io_mut().on_release(keep_alive);
-
-            Ok((head, Payload::None))
-        }
-        _ => Ok((head, Payload::Stream(Box::pin(PlStream::new(framed))))),
-    }
-}
-
-pub(crate) async fn open_tunnel<Io>(
-    io: Io,
-    head: RequestHeadType,
-) -> Result<(ResponseHead, Framed<Io, h1::ClientCodec>), SendRequestError>
-where
-    Io: ConnectionIo,
-{
-    // 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))
-}
-
-/// send request body to the peer
-pub(crate) async fn send_body<Io, B>(
-    body: B,
-    mut framed: Pin<&mut Framed<Io, h1::ClientCodec>>,
-) -> Result<(), SendRequestError>
-where
-    Io: ConnectionIo,
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    actix_rt::pin!(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(Err(err)) => return Err(err.into().into()),
-                None => {
-                    eof = true;
-                    framed.as_mut().write(h1::Message::Chunk(None))?;
-                }
-            }
-        }
-
-        if !framed.as_ref().is_write_buf_empty() {
-            poll_fn(|cx| match framed.as_mut().flush(cx) {
-                Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
-                Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-                Poll::Pending => {
-                    if !framed.as_ref().is_write_buf_full() {
-                        Poll::Ready(Ok(()))
-                    } else {
-                        Poll::Pending
-                    }
-                }
-            })
-            .await?;
-        }
-    }
-
-    framed.get_mut().flush().await?;
-    Ok(())
-}
-
-#[pin_project::pin_project]
-pub(crate) struct PlStream<Io: ConnectionIo> {
-    #[pin]
-    framed: Framed<H1Connection<Io>, h1::ClientPayloadCodec>,
-}
-
-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());
-
-        PlStream { framed }
-    }
-}
-
-impl<Io: ConnectionIo> Stream for PlStream<Io> {
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> 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)
-            }
-            None => Poll::Ready(None),
-        }
-    }
-}

actix-http/src/client/h2proto.rs

@@ -1,195 +0,0 @@
-use std::future::Future;
-
-use actix_utils::future::poll_fn;
-use bytes::Bytes;
-use h2::{
-    client::{Builder, Connection, SendRequest},
-    SendStream,
-};
-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 super::{
-    config::ConnectorConfig,
-    connection::{ConnectionIo, H2Connection},
-    error::SendRequestError,
-};
-
-pub(crate) async fn send_request<Io, B>(
-    mut io: H2Connection<Io>,
-    head: RequestHeadType,
-    body: B,
-) -> Result<(ResponseHead, Payload), SendRequestError>
-where
-    Io: ConnectionIo,
-    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!(
-        length,
-        BodySize::None | BodySize::Empty | BodySize::Sized(0)
-    );
-
-    let mut req = Request::new(());
-    *req.uri_mut() = head.as_ref().uri.clone();
-    *req.method_mut() = head.as_ref().method.clone();
-    *req.version_mut() = Version::HTTP_2;
-
-    let mut skip_len = true;
-    // let mut has_date = false;
-
-    // Content length
-    let _ = match length {
-        BodySize::None => None,
-        BodySize::Stream => {
-            skip_len = false;
-            None
-        }
-        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(),
-            )
-        }
-    };
-
-    // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
-    let (head, extra_headers) = match head {
-        RequestHeadType::Owned(head) => (RequestHeadType::Owned(head), HeaderMap::new()),
-        RequestHeadType::Rc(head, extra_headers) => (
-            RequestHeadType::Rc(head, None),
-            extra_headers.unwrap_or_else(HeaderMap::new),
-        ),
-    };
-
-    // merging headers from head and extra headers.
-    let headers = head
-        .as_ref()
-        .headers
-        .iter()
-        .filter(|(name, _)| !extra_headers.contains_key(*name))
-        .chain(extra_headers.iter());
-
-    // 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,
-            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());
-        return Err(SendRequestError::from(e));
-    }
-
-    let resp = match io.send_request(req, eof) {
-        Ok((fut, send)) => {
-            io.on_release(false);
-
-            if !eof {
-                send_body(body, send).await?;
-            }
-            fut.await.map_err(SendRequestError::from)?
-        }
-        Err(e) => {
-            io.on_release(e.is_io());
-            return Err(e.into());
-        }
-    };
-
-    let (parts, body) = resp.into_parts();
-    let payload = if head_req { Payload::None } else { body.into() };
-
-    let mut head = ResponseHead::new(parts.status);
-    head.version = parts.version;
-    head.headers = parts.headers.into();
-    Ok((head, payload))
-}
-
-async fn send_body<B>(
-    body: B,
-    mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    let mut buf = None;
-    actix_rt::pin!(body);
-    loop {
-        if buf.is_none() {
-            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(Ok(b)) => {
-                    send.reserve_capacity(b.len());
-                    buf = Some(b);
-                }
-                Some(Err(e)) => return Err(e.into().into()),
-                None => {
-                    if let Err(e) = send.send_data(Bytes::new(), true) {
-                        return Err(e.into());
-                    }
-                    send.reserve_capacity(0);
-                    return Ok(());
-                }
-            }
-        }
-
-        match poll_fn(|cx| send.poll_capacity(cx)).await {
-            None => return Ok(()),
-            Some(Ok(cap)) => {
-                let b = buf.as_mut().unwrap();
-                let len = b.len();
-                let bytes = b.split_to(std::cmp::min(cap, len));
-
-                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;
-                }
-                continue;
-            }
-            Some(Err(e)) => return Err(e.into()),
-        }
-    }
-}
-
-pub(crate) fn handshake<Io: ConnectionIo>(
-    io: Io,
-    config: &ConnectorConfig,
-) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
-{
-    let mut builder = Builder::new();
-    builder
-        .initial_window_size(config.stream_window_size)
-        .initial_connection_window_size(config.conn_window_size)
-        .enable_push(false);
-    builder.handshake(io)
-}

actix-http/src/client/mod.rs

@@ -1,26 +0,0 @@
-//! HTTP client.
-
-use http::Uri;
-
-mod config;
-mod connection;
-mod connector;
-mod error;
-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::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
-pub use crate::Protocol;
-
-#[derive(Clone)]
-pub struct Connect {
-    pub uri: Uri,
-    pub addr: Option<std::net::SocketAddr>,
-}

actix-http/src/client/pool.rs

@@ -1,669 +0,0 @@
-//! Client connection pooling keyed on the authority part of the connection URI.
-
-use std::{
-    cell::RefCell,
-    collections::VecDeque,
-    future::Future,
-    io,
-    ops::Deref,
-    pin::Pin,
-    rc::Rc,
-    sync::Arc,
-    task::{Context, Poll},
-    time::{Duration, Instant},
-};
-
-use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
-use actix_rt::time::{sleep, Sleep};
-use actix_service::Service;
-use ahash::AHashMap;
-use futures_core::future::LocalBoxFuture;
-use http::uri::Authority;
-use pin_project::pin_project;
-use tokio::sync::{OwnedSemaphorePermit, Semaphore};
-
-use super::config::ConnectorConfig;
-use super::connection::{
-    ConnectionInnerType, ConnectionIo, ConnectionType, H2ConnectionInner,
-};
-use super::error::ConnectError;
-use super::h2proto::handshake;
-use super::Connect;
-use super::Protocol;
-
-#[derive(Hash, Eq, PartialEq, Clone, Debug)]
-pub struct Key {
-    authority: Authority,
-}
-
-impl From<Authority> for Key {
-    fn from(authority: Authority) -> Key {
-        Key { authority }
-    }
-}
-
-#[doc(hidden)]
-/// Connections pool for reuse Io type for certain [`http::uri::Authority`] as key.
-pub struct ConnectionPool<S, Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    connector: S,
-    inner: ConnectionPoolInner<Io>,
-}
-
-/// wrapper type for check the ref count of Rc.
-pub struct ConnectionPoolInner<Io>(Rc<ConnectionPoolInnerPriv<Io>>)
-where
-    Io: AsyncWrite + Unpin + 'static;
-
-impl<Io> ConnectionPoolInner<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    fn new(config: ConnectorConfig) -> Self {
-        let permits = Arc::new(Semaphore::new(config.limit));
-        let available = RefCell::new(AHashMap::default());
-
-        Self(Rc::new(ConnectionPoolInnerPriv {
-            config,
-            available,
-            permits,
-        }))
-    }
-
-    /// spawn a async for graceful shutdown h1 Io type with a timeout.
-    fn close(&self, conn: ConnectionInnerType<Io>) {
-        if let Some(timeout) = self.config.disconnect_timeout {
-            if let ConnectionInnerType::H1(io) = conn {
-                actix_rt::spawn(CloseConnection::new(io, timeout));
-            }
-        }
-    }
-}
-
-impl<Io> Clone for ConnectionPoolInner<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    fn clone(&self) -> Self {
-        Self(Rc::clone(&self.0))
-    }
-}
-
-impl<Io> Deref for ConnectionPoolInner<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    type Target = ConnectionPoolInnerPriv<Io>;
-
-    fn deref(&self) -> &Self::Target {
-        &*self.0
-    }
-}
-
-impl<Io> Drop for ConnectionPoolInner<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    fn drop(&mut self) {
-        // When strong count is one it means the pool is dropped
-        // remove and drop all Io types.
-        if Rc::strong_count(&self.0) == 1 {
-            self.permits.close();
-            std::mem::take(&mut *self.available.borrow_mut())
-                .into_iter()
-                .for_each(|(_, conns)| {
-                    conns.into_iter().for_each(|pooled| self.close(pooled.conn))
-                });
-        }
-    }
-}
-
-pub struct ConnectionPoolInnerPriv<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    config: ConnectorConfig,
-    available: RefCell<AHashMap<Key, VecDeque<PooledConnection<Io>>>>,
-    permits: Arc<Semaphore>,
-}
-
-impl<S, Io> ConnectionPool<S, Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    /// Construct a new connection pool.
-    ///
-    /// [`super::config::ConnectorConfig`]'s `limit` is used as the max permits allowed for
-    /// in-flight connections.
-    ///
-    /// The pool can only have equal to `limit` amount of requests spawning/using Io type
-    /// concurrently.
-    ///
-    /// Any requests beyond limit would be wait in fifo order and get notified in async manner
-    /// by [`tokio::sync::Semaphore`]
-    pub(crate) fn new(connector: S, config: ConnectorConfig) -> Self {
-        let inner = ConnectionPoolInner::new(config);
-
-        Self { connector, inner }
-    }
-}
-
-impl<S, Io> Service<Connect> for ConnectionPool<S, Io>
-where
-    S: Service<Connect, Response = (Io, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-    Io: ConnectionIo,
-{
-    type Response = ConnectionType<Io>;
-    type Error = ConnectError;
-    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    actix_service::forward_ready!(connector);
-
-    fn call(&self, req: Connect) -> Self::Future {
-        let connector = self.connector.clone();
-        let inner = self.inner.clone();
-
-        Box::pin(async move {
-            let key = if let Some(authority) = req.uri.authority() {
-                authority.clone().into()
-            } else {
-                return Err(ConnectError::Unresolved);
-            };
-
-            // acquire an owned permit and carry it with connection
-            let permit = inner.permits.clone().acquire_owned().await.map_err(|_| {
-                ConnectError::Io(io::Error::new(
-                    io::ErrorKind::Other,
-                    "failed to acquire semaphore on client connection pool",
-                ))
-            })?;
-
-            let conn = {
-                let mut conn = None;
-
-                // check if there is idle connection for given key.
-                let mut map = inner.available.borrow_mut();
-
-                if let Some(conns) = map.get_mut(&key) {
-                    let now = Instant::now();
-
-                    while let Some(mut c) = conns.pop_front() {
-                        let config = &inner.config;
-                        let idle_dur = now - c.used;
-                        let age = now - c.created;
-                        let conn_ineligible = idle_dur > config.conn_keep_alive
-                            || age > config.conn_lifetime;
-
-                        if conn_ineligible {
-                            // drop connections that are too old
-                            inner.close(c.conn);
-                        } else {
-                            // check if the connection is still usable
-                            if let ConnectionInnerType::H1(ref mut io) = c.conn {
-                                let check = ConnectionCheckFuture { io };
-                                match check.await {
-                                    ConnectionState::Tainted => {
-                                        inner.close(c.conn);
-                                        continue;
-                                    }
-                                    ConnectionState::Skip => continue,
-                                    ConnectionState::Live => conn = Some(c),
-                                }
-                            } else {
-                                conn = Some(c);
-                            }
-
-                            break;
-                        }
-                    }
-                };
-
-                conn
-            };
-
-            // construct acquired. It's used to put Io type back to pool/ close the Io type.
-            // permit is carried with the whole lifecycle of Acquired.
-            let acquired = Acquired { key, inner, permit };
-
-            // match the connection and spawn new one if did not get anything.
-            match conn {
-                Some(conn) => {
-                    Ok(ConnectionType::from_pool(conn.conn, conn.created, acquired))
-                }
-                None => {
-                    let (io, proto) = connector.call(req).await?;
-
-                    // TODO: remove when http3 is added in support.
-                    assert!(proto != Protocol::Http3);
-
-                    if proto == Protocol::Http1 {
-                        Ok(ConnectionType::from_h1(io, Instant::now(), acquired))
-                    } else {
-                        let config = &acquired.inner.config;
-                        let (sender, connection) = handshake(io, config).await?;
-                        let inner = H2ConnectionInner::new(sender, connection);
-                        Ok(ConnectionType::from_h2(inner, Instant::now(), acquired))
-                    }
-                }
-            }
-        })
-    }
-}
-
-/// Type for check the connection and determine if it's usable.
-struct ConnectionCheckFuture<'a, Io> {
-    io: &'a mut Io,
-}
-
-enum ConnectionState {
-    /// IO is pending and a new request would wake it.
-    Live,
-
-    /// IO unexpectedly has unread data and should be dropped.
-    Tainted,
-
-    /// IO should be skipped but not dropped.
-    Skip,
-}
-
-impl<Io> Future for ConnectionCheckFuture<'_, Io>
-where
-    Io: AsyncRead + Unpin,
-{
-    type Output = ConnectionState;
-
-    // this future is only used to get access to Context.
-    // It should never return Poll::Pending.
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-        let mut buf = [0; 2];
-        let mut read_buf = ReadBuf::new(&mut buf);
-
-        let state = match Pin::new(&mut this.io).poll_read(cx, &mut read_buf) {
-            Poll::Ready(Ok(())) if !read_buf.filled().is_empty() => {
-                ConnectionState::Tainted
-            }
-
-            Poll::Pending => ConnectionState::Live,
-            _ => ConnectionState::Skip,
-        };
-
-        Poll::Ready(state)
-    }
-}
-
-struct PooledConnection<Io> {
-    conn: ConnectionInnerType<Io>,
-    used: Instant,
-    created: Instant,
-}
-
-#[pin_project]
-struct CloseConnection<Io> {
-    io: Io,
-    #[pin]
-    timeout: Sleep,
-}
-
-impl<Io> CloseConnection<Io>
-where
-    Io: AsyncWrite + Unpin,
-{
-    fn new(io: Io, timeout: Duration) -> Self {
-        CloseConnection {
-            io,
-            timeout: sleep(timeout),
-        }
-    }
-}
-
-impl<Io> Future for CloseConnection<Io>
-where
-    Io: AsyncWrite + Unpin,
-{
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        let this = self.project();
-
-        match this.timeout.poll(cx) {
-            Poll::Ready(_) => Poll::Ready(()),
-            Poll::Pending => Pin::new(this.io).poll_shutdown(cx).map(|_| ()),
-        }
-    }
-}
-
-pub struct Acquired<Io>
-where
-    Io: AsyncWrite + Unpin + 'static,
-{
-    /// authority key for identify connection.
-    key: Key,
-    /// handle to connection pool.
-    inner: ConnectionPoolInner<Io>,
-    /// permit for limit concurrent in-flight connection for a Client object.
-    permit: OwnedSemaphorePermit,
-}
-
-impl<Io: ConnectionIo> Acquired<Io> {
-    /// Close the IO.
-    pub(super) fn close(&self, conn: ConnectionInnerType<Io>) {
-        self.inner.close(conn);
-    }
-
-    /// Release IO back into pool.
-    pub(super) fn release(&self, conn: ConnectionInnerType<Io>, created: Instant) {
-        let Acquired { key, inner, .. } = self;
-
-        inner
-            .available
-            .borrow_mut()
-            .entry(key.clone())
-            .or_insert_with(VecDeque::new)
-            .push_back(PooledConnection {
-                conn,
-                created,
-                used: Instant::now(),
-            });
-
-        let _ = &self.permit;
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{cell::Cell, io};
-
-    use http::Uri;
-
-    use super::*;
-    use crate::client::connection::ConnectionType;
-
-    /// A stream type that always returns pending on async read.
-    ///
-    /// Mocks an idle TCP stream that is ready to be used for client connections.
-    struct TestStream(Rc<Cell<usize>>);
-
-    impl Drop for TestStream {
-        fn drop(&mut self) {
-            self.0.set(self.0.get() - 1);
-        }
-    }
-
-    impl AsyncRead for TestStream {
-        fn poll_read(
-            self: Pin<&mut Self>,
-            _: &mut Context<'_>,
-            _: &mut ReadBuf<'_>,
-        ) -> Poll<io::Result<()>> {
-            Poll::Pending
-        }
-    }
-
-    impl AsyncWrite for TestStream {
-        fn poll_write(
-            self: Pin<&mut Self>,
-            _: &mut Context<'_>,
-            _: &[u8],
-        ) -> Poll<io::Result<usize>> {
-            unimplemented!()
-        }
-
-        fn poll_flush(
-            self: Pin<&mut Self>,
-            _: &mut Context<'_>,
-        ) -> Poll<io::Result<()>> {
-            unimplemented!()
-        }
-
-        fn poll_shutdown(
-            self: Pin<&mut Self>,
-            _: &mut Context<'_>,
-        ) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    #[derive(Clone)]
-    struct TestPoolConnector {
-        generated: Rc<Cell<usize>>,
-    }
-
-    impl Service<Connect> for TestPoolConnector {
-        type Response = (TestStream, Protocol);
-        type Error = ConnectError;
-        type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-        actix_service::always_ready!();
-
-        fn call(&self, _: Connect) -> Self::Future {
-            self.generated.set(self.generated.get() + 1);
-            let generated = self.generated.clone();
-            Box::pin(async { Ok((TestStream(generated), Protocol::Http1)) })
-        }
-    }
-
-    fn release<T>(conn: ConnectionType<T>)
-    where
-        T: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        match conn {
-            ConnectionType::H1(mut conn) => conn.on_release(true),
-            ConnectionType::H2(mut conn) => conn.on_release(false),
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_pool_limit() {
-        let connector = TestPoolConnector {
-            generated: Rc::new(Cell::new(0)),
-        };
-
-        let config = ConnectorConfig {
-            limit: 1,
-            ..Default::default()
-        };
-
-        let pool = super::ConnectionPool::new(connector, config);
-
-        let req = Connect {
-            uri: Uri::from_static("http://localhost"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-
-        let waiting = Rc::new(Cell::new(true));
-
-        let waiting_clone = waiting.clone();
-        actix_rt::spawn(async move {
-            actix_rt::time::sleep(Duration::from_millis(100)).await;
-            waiting_clone.set(false);
-            drop(conn);
-        });
-
-        assert!(waiting.get());
-
-        let now = Instant::now();
-        let conn = pool.call(req).await.unwrap();
-
-        release(conn);
-        assert!(!waiting.get());
-        assert!(now.elapsed() >= Duration::from_millis(100));
-    }
-
-    #[actix_rt::test]
-    async fn test_pool_keep_alive() {
-        let generated = Rc::new(Cell::new(0));
-        let generated_clone = generated.clone();
-
-        let connector = TestPoolConnector { generated };
-
-        let config = ConnectorConfig {
-            conn_keep_alive: Duration::from_secs(1),
-            ..Default::default()
-        };
-
-        let pool = super::ConnectionPool::new(connector, config);
-
-        let req = Connect {
-            uri: Uri::from_static("http://localhost"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        actix_rt::time::sleep(Duration::from_millis(1500)).await;
-        actix_rt::task::yield_now().await;
-
-        let conn = pool.call(req).await.unwrap();
-        // Note: spawned recycle connection is not ran yet.
-        // This is tokio current thread runtime specific behavior.
-        assert_eq!(2, generated_clone.get());
-
-        // yield task so the old connection is properly dropped.
-        actix_rt::task::yield_now().await;
-        assert_eq!(1, generated_clone.get());
-
-        release(conn);
-    }
-
-    #[actix_rt::test]
-    async fn test_pool_lifetime() {
-        let generated = Rc::new(Cell::new(0));
-        let generated_clone = generated.clone();
-
-        let connector = TestPoolConnector { generated };
-
-        let config = ConnectorConfig {
-            conn_lifetime: Duration::from_secs(1),
-            ..Default::default()
-        };
-
-        let pool = super::ConnectionPool::new(connector, config);
-
-        let req = Connect {
-            uri: Uri::from_static("http://localhost"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        actix_rt::time::sleep(Duration::from_millis(1500)).await;
-        actix_rt::task::yield_now().await;
-
-        let conn = pool.call(req).await.unwrap();
-        // Note: spawned recycle connection is not ran yet.
-        // This is tokio current thread runtime specific behavior.
-        assert_eq!(2, generated_clone.get());
-
-        // yield task so the old connection is properly dropped.
-        actix_rt::task::yield_now().await;
-        assert_eq!(1, generated_clone.get());
-
-        release(conn);
-    }
-
-    #[actix_rt::test]
-    async fn test_pool_authority_key() {
-        let generated = Rc::new(Cell::new(0));
-        let generated_clone = generated.clone();
-
-        let connector = TestPoolConnector { generated };
-
-        let config = ConnectorConfig::default();
-
-        let pool = super::ConnectionPool::new(connector, config);
-
-        let req = Connect {
-            uri: Uri::from_static("https://crates.io"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        let conn = pool.call(req).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        let req = Connect {
-            uri: Uri::from_static("https://google.com"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(2, generated_clone.get());
-        release(conn);
-        let conn = pool.call(req).await.unwrap();
-        assert_eq!(2, generated_clone.get());
-        release(conn);
-    }
-
-    #[actix_rt::test]
-    async fn test_pool_drop() {
-        let generated = Rc::new(Cell::new(0));
-        let generated_clone = generated.clone();
-
-        let connector = TestPoolConnector { generated };
-
-        let config = ConnectorConfig::default();
-
-        let pool = Rc::new(super::ConnectionPool::new(connector, config));
-
-        let req = Connect {
-            uri: Uri::from_static("https://crates.io"),
-            addr: None,
-        };
-
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(1, generated_clone.get());
-        release(conn);
-
-        let req = Connect {
-            uri: Uri::from_static("https://google.com"),
-            addr: None,
-        };
-        let conn = pool.call(req.clone()).await.unwrap();
-        assert_eq!(2, generated_clone.get());
-        release(conn);
-
-        let clone1 = pool.clone();
-        let clone2 = clone1.clone();
-
-        drop(clone2);
-        for _ in 0..2 {
-            actix_rt::task::yield_now().await;
-        }
-        assert_eq!(2, generated_clone.get());
-
-        drop(clone1);
-        for _ in 0..2 {
-            actix_rt::task::yield_now().await;
-        }
-        assert_eq!(2, generated_clone.get());
-
-        drop(pool);
-        for _ in 0..2 {
-            actix_rt::task::yield_now().await;
-        }
-        assert_eq!(0, generated_clone.get());
-    }
-}

actix-http/src/config.rs

@@ -1,392 +0,0 @@
-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 bytes::BytesMut;
-use time::OffsetDateTime;
-
-/// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-const DATE_VALUE_LENGTH: usize = 29;
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-/// Server keep-alive setting
-pub enum KeepAlive {
-    /// Keep alive in seconds
-    Timeout(usize),
-    /// Rely on OS to shutdown tcp connection
-    Os,
-    /// Disabled
-    Disabled,
-}
-
-impl From<usize> for KeepAlive {
-    fn from(keepalive: usize) -> Self {
-        KeepAlive::Timeout(keepalive)
-    }
-}
-
-impl From<Option<usize>> for KeepAlive {
-    fn from(keepalive: Option<usize>) -> Self {
-        if let Some(keepalive) = keepalive {
-            KeepAlive::Timeout(keepalive)
-        } else {
-            KeepAlive::Disabled
-        }
-    }
-}
-
-/// Http service configuration
-pub struct ServiceConfig(Rc<Inner>);
-
-struct Inner {
-    keep_alive: Option<Duration>,
-    client_timeout: u64,
-    client_disconnect: u64,
-    ka_enabled: bool,
-    secure: bool,
-    local_addr: Option<std::net::SocketAddr>,
-    date_service: DateService,
-}
-
-impl Clone for ServiceConfig {
-    fn clone(&self) -> Self {
-        ServiceConfig(self.0.clone())
-    }
-}
-
-impl Default for ServiceConfig {
-    fn default() -> Self {
-        Self::new(KeepAlive::Timeout(5), 0, 0, false, None)
-    }
-}
-
-impl ServiceConfig {
-    /// Create instance of `ServiceConfig`
-    pub fn new(
-        keep_alive: KeepAlive,
-        client_timeout: u64,
-        client_disconnect: u64,
-        secure: bool,
-        local_addr: Option<net::SocketAddr>,
-    ) -> ServiceConfig {
-        let (keep_alive, ka_enabled) = match keep_alive {
-            KeepAlive::Timeout(val) => (val as u64, true),
-            KeepAlive::Os => (0, true),
-            KeepAlive::Disabled => (0, false),
-        };
-        let keep_alive = if ka_enabled && keep_alive > 0 {
-            Some(Duration::from_secs(keep_alive))
-        } else {
-            None
-        };
-
-        ServiceConfig(Rc::new(Inner {
-            keep_alive,
-            ka_enabled,
-            client_timeout,
-            client_disconnect,
-            secure,
-            local_addr,
-            date_service: DateService::new(),
-        }))
-    }
-
-    /// Returns true if connection is secure (HTTPS)
-    #[inline]
-    pub fn secure(&self) -> bool {
-        self.0.secure
-    }
-
-    /// Returns the local address that this server is bound to.
-    #[inline]
-    pub fn local_addr(&self) -> Option<net::SocketAddr> {
-        self.0.local_addr
-    }
-
-    /// Keep alive duration if configured.
-    #[inline]
-    pub fn keep_alive(&self) -> Option<Duration> {
-        self.0.keep_alive
-    }
-
-    /// Return state of connection keep-alive functionality
-    #[inline]
-    pub fn keep_alive_enabled(&self) -> bool {
-        self.0.ka_enabled
-    }
-
-    /// Client timeout for first request.
-    #[inline]
-    pub fn client_timer(&self) -> Option<Sleep> {
-        let delay_time = self.0.client_timeout;
-        if delay_time != 0 {
-            Some(sleep_until(self.now() + Duration::from_millis(delay_time)))
-        } else {
-            None
-        }
-    }
-
-    /// Client timeout for first request.
-    pub fn client_timer_expire(&self) -> Option<Instant> {
-        let delay = self.0.client_timeout;
-        if delay != 0 {
-            Some(self.now() + Duration::from_millis(delay))
-        } else {
-            None
-        }
-    }
-
-    /// Client disconnect timer
-    pub fn client_disconnect_timer(&self) -> Option<Instant> {
-        let delay = self.0.client_disconnect;
-        if delay != 0 {
-            Some(self.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))
-    }
-
-    /// Keep-alive expire time
-    pub fn keep_alive_expire(&self) -> Option<Instant> {
-        self.keep_alive().map(|ka| self.now() + ka)
-    }
-
-    #[inline]
-    pub(crate) fn now(&self) -> Instant {
-        self.0.date_service.now()
-    }
-
-    #[doc(hidden)]
-    pub fn set_date(&self, dst: &mut BytesMut) {
-        let mut buf: [u8; 39] = [0; 39];
-        buf[..6].copy_from_slice(b"date: ");
-        self.0
-            .date_service
-            .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);
-    }
-
-    pub(crate) fn set_date_header(&self, dst: &mut BytesMut) {
-        self.0
-            .date_service
-            .set_date(|date| dst.extend_from_slice(&date.bytes));
-    }
-}
-
-#[derive(Copy, Clone)]
-struct Date {
-    bytes: [u8; DATE_VALUE_LENGTH],
-    pos: usize,
-}
-
-impl Date {
-    fn new() -> Date {
-        let mut date = Date {
-            bytes: [0; DATE_VALUE_LENGTH],
-            pos: 0,
-        };
-        date.update();
-        date
-    }
-
-    fn update(&mut self) {
-        self.pos = 0;
-        write!(
-            self,
-            "{}",
-            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
-    }
-}
-
-impl fmt::Write for Date {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        let len = s.len();
-        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
-        self.pos += len;
-        Ok(())
-    }
-}
-
-/// Service for update Date and Instant periodically at 500 millis interval.
-struct DateService {
-    current: Rc<Cell<(Date, Instant)>>,
-    handle: JoinHandle<()>,
-}
-
-impl Drop for DateService {
-    fn drop(&mut self) {
-        // stop the timer update async task on drop.
-        self.handle.abort();
-    }
-}
-
-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();
-
-            let mut interval = interval(Duration::from_millis(500));
-            loop {
-                let now = interval.tick().await;
-                let date = Date::new();
-                current_clone.set((date, now));
-            }
-        });
-
-        DateService { current, handle }
-    }
-
-    fn now(&self) -> Instant {
-        self.current.get().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.
-#[cfg(test)]
-/// 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
-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.
-    ///
-    /// # Panic:
-    ///
-    /// 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;
-                }
-            });
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use actix_rt::task::yield_now;
-
-    #[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);
-        assert!(notify_on_drop::is_dropped());
-    }
-
-    #[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);
-        assert!(notify_on_drop::is_dropped());
-    }
-
-    #[test]
-    fn test_date_len() {
-        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
-    }
-
-    #[actix_rt::test]
-    async fn test_date() {
-        let settings = ServiceConfig::new(KeepAlive::Os, 0, 0, false, None);
-        let mut buf1 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-        settings.set_date(&mut buf1);
-        let mut buf2 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-        settings.set_date(&mut buf2);
-        assert_eq!(buf1, buf2);
-    }
-}

actix-http/src/encoding/decoder.rs

@@ -1,295 +0,0 @@
-//! Stream decoders.
-
-use std::{
-    future::Future,
-    io::{self, Write as _},
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use actix_rt::task::{spawn_blocking, JoinHandle};
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-
-#[cfg(feature = "compress-brotli")]
-use brotli2::write::BrotliDecoder;
-
-#[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;
-
-pub struct Decoder<S> {
-    decoder: Option<ContentDecoder>,
-    stream: S,
-    eof: bool,
-    fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
-}
-
-impl<S> Decoder<S>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>>,
-{
-    /// Construct a decoder.
-    #[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,
-            fut: None,
-            eof: false,
-        }
-    }
-
-    /// Construct decoder based on headers.
-    #[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())
-            .map(ContentEncoding::from)
-            .unwrap_or(ContentEncoding::Identity);
-
-        Self::new(stream, encoding)
-    }
-}
-
-impl<S> Stream for Decoder<S>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
-{
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> 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)??;
-
-                self.decoder = Some(decoder);
-                self.fut.take();
-
-                if let Some(chunk) = chunk {
-                    return Poll::Ready(Some(Ok(chunk)));
-                }
-            }
-
-            if self.eof {
-                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)) => {
-                    if let Some(mut decoder) = self.decoder.take() {
-                        if chunk.len() < MAX_CHUNK_SIZE_DECODE_IN_PLACE {
-                            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 || {
-                                let chunk = decoder.feed_data(chunk)?;
-                                Ok((chunk, decoder))
-                            }));
-                        }
-
-                        continue;
-                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
-                    }
-                }
-
-                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))),
-                            Ok(None) => Poll::Ready(None),
-                            Err(err) => Poll::Ready(Some(Err(err.into()))),
-                        }
-                    } else {
-                        Poll::Ready(None)
-                    };
-                }
-            }
-        }
-    }
-}
-
-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 {
-                        Ok(None)
-                    }
-                }
-                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 {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-
-            #[cfg(feature = "compress-gzip")]
-            ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
-                Ok(_) => {
-                    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.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 {
-                        Ok(None)
-                    }
-                }
-                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 {
-                        Ok(None)
-                    }
-                }
-                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))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-        }
-    }
-}

actix-http/src/encoding/encoder.rs

@@ -1,388 +0,0 @@
-//! Stream encoders.
-
-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 bytes::Bytes;
-use derive_more::Display;
-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,
-    },
-    Error, ResponseHead,
-};
-
-use super::Writer;
-use crate::error::BlockingError;
-
-const MAX_CHUNK_SIZE_ENCODE_IN_PLACE: usize = 1024;
-
-#[pin_project]
-pub struct Encoder<B> {
-    eof: bool,
-    #[pin]
-    body: EncoderBody<B>,
-    encoder: Option<ContentEncoder>,
-    fut: Option<JoinHandle<Result<ContentEncoder, io::Error>>>,
-}
-
-impl<B: MessageBody> Encoder<B> {
-    pub fn response(
-        encoding: ContentEncoding,
-        head: &mut ResponseHead,
-        body: ResponseBody<B>,
-    ) -> ResponseBody<Encoder<B>> {
-        let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
-            || head.status == StatusCode::SWITCHING_PROTOCOLS
-            || head.status == StatusCode::NO_CONTENT
-            || encoding == ContentEncoding::Identity
-            || encoding == ContentEncoding::Auto);
-
-        let body = match body {
-            ResponseBody::Other(b) => match b {
-                Body::None => return ResponseBody::Other(Body::None),
-                Body::Empty => return ResponseBody::Other(Body::Empty),
-                Body::Bytes(buf) => {
-                    if can_encode {
-                        EncoderBody::Bytes(buf)
-                    } else {
-                        return ResponseBody::Other(Body::Bytes(buf));
-                    }
-                }
-                Body::Message(stream) => EncoderBody::BoxedStream(stream),
-            },
-            ResponseBody::Body(stream) => EncoderBody::Stream(stream),
-        };
-
-        if can_encode {
-            // Modify response body only if encoder is not None
-            if let Some(enc) = ContentEncoder::encoder(encoding) {
-                update_head(encoding, head);
-                head.no_chunking(false);
-                return ResponseBody::Body(Encoder {
-                    body,
-                    eof: false,
-                    fut: None,
-                    encoder: Some(enc),
-                });
-            }
-        }
-
-        ResponseBody::Body(Encoder {
-            body,
-            eof: false,
-            fut: None,
-            encoder: None,
-        })
-    }
-}
-
-#[pin_project(project = EncoderBodyProj)]
-enum EncoderBody<B> {
-    Bytes(Bytes),
-    Stream(#[pin] B),
-    BoxedStream(BoxAnyBody),
-}
-
-impl<B> MessageBody for EncoderBody<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Error = EncoderError<B::Error>;
-
-    fn size(&self) -> BodySize {
-        match self {
-            EncoderBody::Bytes(ref b) => b.size(),
-            EncoderBody::Stream(ref b) => b.size(),
-            EncoderBody::BoxedStream(ref b) => b.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        match self.project() {
-            EncoderBodyProj::Bytes(b) => {
-                if b.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(std::mem::take(b))))
-                }
-            }
-            // TODO: MSRV 1.51: poll_map_err
-            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
-                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
-                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                None => Poll::Ready(None),
-            },
-            EncoderBodyProj::BoxedStream(ref mut b) => {
-                match ready!(b.as_pin_mut().poll_next(cx)) {
-                    Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Boxed(err)))),
-                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
-                    None => Poll::Ready(None),
-                }
-            }
-        }
-    }
-}
-
-impl<B> MessageBody for Encoder<B>
-where
-    B: MessageBody,
-    B::Error: Into<Error>,
-{
-    type Error = EncoderError<B::Error>;
-
-    fn size(&self) -> BodySize {
-        if self.encoder.is_none() {
-            self.body.size()
-        } else {
-            BodySize::Stream
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        let mut this = self.project();
-        loop {
-            if *this.eof {
-                return Poll::Ready(None);
-            }
-
-            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 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));
-
-            match result {
-                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
-
-                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)?;
-                            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 || {
-                                encoder.write(&chunk)?;
-                                Ok(encoder)
-                            }));
-                        }
-                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
-                    }
-                }
-
-                None => {
-                    if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish().map_err(EncoderError::Io)?;
-                        if chunk.is_empty() {
-                            return Poll::Ready(None);
-                        } else {
-                            *this.eof = true;
-                            return Poll::Ready(Some(Ok(chunk)));
-                        }
-                    } else {
-                        return Poll::Ready(None);
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
-    head.headers_mut().insert(
-        CONTENT_ENCODING,
-        HeaderValue::from_static(encoding.as_str()),
-    );
-}
-
-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,
-        }
-    }
-
-    #[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) => {
-                    trace!("Error decoding br encoding: {}", err);
-                    Err(err)
-                }
-            },
-            #[cfg(feature = "compress-gzip")]
-            ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding gzip encoding: {}", err);
-                    Err(err)
-                }
-            },
-            #[cfg(feature = "compress-gzip")]
-            ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding deflate encoding: {}", err);
-                    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,38 +0,0 @@
-//! Content-Encoding support.
-
-use std::io;
-
-use bytes::{Bytes, BytesMut};
-
-mod decoder;
-mod encoder;
-
-pub use self::decoder::Decoder;
-pub use self::encoder::Encoder;
-
-pub(self) struct Writer {
-    buf: BytesMut,
-}
-
-impl Writer {
-    fn new() -> Writer {
-        Writer {
-            buf: BytesMut::with_capacity(8192),
-        }
-    }
-
-    fn take(&mut self) -> Bytes {
-        self.buf.split().freeze()
-    }
-}
-
-impl io::Write for Writer {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.buf.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}

actix-http/src/error.rs

@@ -1,508 +0,0 @@
-//! Error and Result module
-
-use std::{error::Error as StdError, fmt, io, str::Utf8Error, string::FromUtf8Error};
-
-use derive_more::{Display, Error, From};
-use http::{uri::InvalidUri, StatusCode};
-
-use crate::{
-    body::{AnyBody, Body},
-    ws, Response,
-};
-
-pub use http::Error as HttpError;
-
-pub struct Error {
-    inner: Box<ErrorInner>,
-}
-
-pub(crate) struct ErrorInner {
-    #[allow(dead_code)]
-    kind: Kind,
-    cause: Option<Box<dyn StdError>>,
-}
-
-impl Error {
-    fn new(kind: Kind) -> Self {
-        Self {
-            inner: Box::new(ErrorInner { kind, cause: None }),
-        }
-    }
-
-    pub(crate) fn new_http() -> Self {
-        Self::new(Kind::Http)
-    }
-
-    pub(crate) fn new_parse() -> Self {
-        Self::new(Kind::Parse)
-    }
-
-    pub(crate) fn new_payload() -> Self {
-        Self::new(Kind::Payload)
-    }
-
-    pub(crate) fn new_body() -> Self {
-        Self::new(Kind::Body)
-    }
-
-    pub(crate) fn new_send_response() -> Self {
-        Self::new(Kind::SendResponse)
-    }
-
-    // TODO: remove allow
-    #[allow(dead_code)]
-    pub(crate) fn new_io() -> Self {
-        Self::new(Kind::Io)
-    }
-
-    pub(crate) fn new_encoder() -> Self {
-        Self::new(Kind::Encoder)
-    }
-
-    pub(crate) fn new_ws() -> Self {
-        Self::new(Kind::Ws)
-    }
-
-    pub(crate) fn with_cause(mut self, cause: impl Into<Box<dyn StdError>>) -> Self {
-        self.inner.cause = Some(cause.into());
-        self
-    }
-}
-
-impl From<Error> for Response<AnyBody> {
-    fn from(err: Error) -> Self {
-        let status_code = match err.inner.kind {
-            Kind::Parse => StatusCode::BAD_REQUEST,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
-        };
-
-        Response::new(status_code).set_body(Body::from(err.to_string()))
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
-pub enum Kind {
-    #[display(fmt = "error processing HTTP")]
-    Http,
-
-    #[display(fmt = "error parsing HTTP message")]
-    Parse,
-
-    #[display(fmt = "request payload read error")]
-    Payload,
-
-    #[display(fmt = "response body write error")]
-    Body,
-
-    #[display(fmt = "send response error")]
-    SendResponse,
-
-    #[display(fmt = "error in WebSocket process")]
-    Ws,
-
-    #[display(fmt = "connection error")]
-    Io,
-
-    #[display(fmt = "encoder error")]
-    Encoder,
-}
-
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO: more detail
-        f.write_str("actix_http::Error")
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.inner.cause.as_ref() {
-            Some(err) => write!(f, "{}: {}", &self.inner.kind, err),
-            None => write!(f, "{}", &self.inner.kind),
-        }
-    }
-}
-
-impl StdError for Error {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        self.inner.cause.as_ref().map(Box::as_ref)
-    }
-}
-
-impl From<std::convert::Infallible> for Error {
-    fn from(err: std::convert::Infallible) -> Self {
-        match err {}
-    }
-}
-
-impl From<ws::ProtocolError> for Error {
-    fn from(err: ws::ProtocolError) -> Self {
-        Self::new_ws().with_cause(err)
-    }
-}
-
-impl From<HttpError> for Error {
-    fn from(err: HttpError) -> Self {
-        Self::new_http().with_cause(err)
-    }
-}
-
-impl From<ws::HandshakeError> for Error {
-    fn from(err: ws::HandshakeError) -> Self {
-        Self::new_ws().with_cause(err)
-    }
-}
-
-/// A set of errors that can occur during parsing HTTP streams.
-#[derive(Debug, Display, Error)]
-#[non_exhaustive]
-pub enum ParseError {
-    /// An invalid `Method`, such as `GE.T`.
-    #[display(fmt = "Invalid Method specified")]
-    Method,
-
-    /// An invalid `Uri`, such as `exam ple.domain`.
-    #[display(fmt = "Uri error: {}", _0)]
-    Uri(InvalidUri),
-
-    /// An invalid `HttpVersion`, such as `HTP/1.1`
-    #[display(fmt = "Invalid HTTP version specified")]
-    Version,
-
-    /// An invalid `Header`.
-    #[display(fmt = "Invalid Header provided")]
-    Header,
-
-    /// A message head is too large to be reasonable.
-    #[display(fmt = "Message head is too large")]
-    TooLarge,
-
-    /// A message reached EOF, but is not complete.
-    #[display(fmt = "Message is incomplete")]
-    Incomplete,
-
-    /// An invalid `Status`, such as `1337 ELITE`.
-    #[display(fmt = "Invalid Status provided")]
-    Status,
-
-    /// A timeout occurred waiting for an IO event.
-    #[allow(dead_code)]
-    #[display(fmt = "Timeout")]
-    Timeout,
-
-    /// An `io::Error` that occurred while trying to read or write to a network stream.
-    #[display(fmt = "IO error: {}", _0)]
-    Io(io::Error),
-
-    /// Parsing a field as string failed
-    #[display(fmt = "UTF8 error: {}", _0)]
-    Utf8(Utf8Error),
-}
-
-impl From<io::Error> for ParseError {
-    fn from(err: io::Error) -> ParseError {
-        ParseError::Io(err)
-    }
-}
-
-impl From<InvalidUri> for ParseError {
-    fn from(err: InvalidUri) -> ParseError {
-        ParseError::Uri(err)
-    }
-}
-
-impl From<Utf8Error> for ParseError {
-    fn from(err: Utf8Error) -> ParseError {
-        ParseError::Utf8(err)
-    }
-}
-
-impl From<FromUtf8Error> for ParseError {
-    fn from(err: FromUtf8Error) -> ParseError {
-        ParseError::Utf8(err.utf8_error())
-    }
-}
-
-impl From<httparse::Error> for ParseError {
-    fn from(err: httparse::Error) -> ParseError {
-        match err {
-            httparse::Error::HeaderName
-            | httparse::Error::HeaderValue
-            | httparse::Error::NewLine
-            | httparse::Error::Token => ParseError::Header,
-            httparse::Error::Status => ParseError::Status,
-            httparse::Error::TooManyHeaders => ParseError::TooLarge,
-            httparse::Error::Version => ParseError::Version,
-        }
-    }
-}
-
-impl From<ParseError> for Error {
-    fn from(err: ParseError) -> Self {
-        Self::new_parse().with_cause(err)
-    }
-}
-
-impl From<ParseError> for Response<AnyBody> {
-    fn from(err: ParseError) -> Self {
-        Error::from(err).into()
-    }
-}
-
-/// A set of errors that can occur running blocking tasks in thread pool.
-#[derive(Debug, Display, Error)]
-#[display(fmt = "Blocking thread pool is gone")]
-pub struct BlockingError;
-
-/// A set of errors that can occur during payload parsing.
-#[derive(Debug, Display)]
-#[non_exhaustive]
-pub enum PayloadError {
-    /// A payload reached EOF, but is not complete.
-    #[display(
-        fmt = "A payload reached EOF, but is not complete. Inner error: {:?}",
-        _0
-    )]
-    Incomplete(Option<io::Error>),
-
-    /// Content encoding stream corruption.
-    #[display(fmt = "Can not decode content-encoding.")]
-    EncodingCorrupted,
-
-    /// Payload reached size limit.
-    #[display(fmt = "Payload reached size limit.")]
-    Overflow,
-
-    /// Payload length is unknown.
-    #[display(fmt = "Payload length is unknown.")]
-    UnknownLength,
-
-    /// HTTP/2 payload error.
-    #[display(fmt = "{}", _0)]
-    Http2Payload(h2::Error),
-
-    /// Generic I/O error.
-    #[display(fmt = "{}", _0)]
-    Io(io::Error),
-}
-
-impl std::error::Error for PayloadError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            PayloadError::Incomplete(None) => None,
-            PayloadError::Incomplete(Some(err)) => Some(err as &dyn std::error::Error),
-            PayloadError::EncodingCorrupted => None,
-            PayloadError::Overflow => None,
-            PayloadError::UnknownLength => None,
-            PayloadError::Http2Payload(err) => Some(err as &dyn std::error::Error),
-            PayloadError::Io(err) => Some(err as &dyn std::error::Error),
-        }
-    }
-}
-
-impl From<h2::Error> for PayloadError {
-    fn from(err: h2::Error) -> Self {
-        PayloadError::Http2Payload(err)
-    }
-}
-
-impl From<Option<io::Error>> for PayloadError {
-    fn from(err: Option<io::Error>) -> Self {
-        PayloadError::Incomplete(err)
-    }
-}
-
-impl From<io::Error> for PayloadError {
-    fn from(err: io::Error) -> Self {
-        PayloadError::Incomplete(Some(err))
-    }
-}
-
-impl From<BlockingError> for PayloadError {
-    fn from(_: BlockingError) -> Self {
-        PayloadError::Io(io::Error::new(
-            io::ErrorKind::Other,
-            "Operation is canceled",
-        ))
-    }
-}
-
-impl From<PayloadError> for Error {
-    fn from(err: PayloadError) -> Self {
-        Self::new_payload().with_cause(err)
-    }
-}
-
-/// A set of errors that can occur during dispatching HTTP requests.
-#[derive(Debug, Display, Error, From)]
-#[non_exhaustive]
-pub enum DispatchError {
-    /// Service error
-    // FIXME: display and error type
-    #[display(fmt = "Service Error")]
-    Service(#[error(not(source))] Response<AnyBody>),
-
-    /// Body error
-    // FIXME: display and error type
-    #[display(fmt = "Body Error")]
-    Body(#[error(not(source))] Box<dyn StdError>),
-
-    /// Upgrade service error
-    Upgrade,
-
-    /// An `io::Error` that occurred while trying to read or write to a network stream.
-    #[display(fmt = "IO error: {}", _0)]
-    Io(io::Error),
-
-    /// Http request parse error.
-    #[display(fmt = "Parse error: {}", _0)]
-    Parse(ParseError),
-
-    /// Http/2 error
-    #[display(fmt = "{}", _0)]
-    H2(h2::Error),
-
-    /// The first request did not complete within the specified timeout.
-    #[display(fmt = "The first request did not complete within the specified timeout")]
-    SlowRequestTimeout,
-
-    /// Disconnect timeout. Makes sense for ssl streams.
-    #[display(fmt = "Connection shutdown timeout")]
-    DisconnectTimeout,
-
-    /// Payload is not consumed
-    #[display(fmt = "Task is completed but request's payload is not consumed")]
-    PayloadIsNotConsumed,
-
-    /// Malformed request
-    #[display(fmt = "Malformed request")]
-    MalformedRequest,
-
-    /// Internal error
-    #[display(fmt = "Internal error")]
-    InternalError,
-
-    /// Unknown error
-    #[display(fmt = "Unknown error")]
-    Unknown,
-}
-
-/// A set of error that can occur during parsing content type.
-#[derive(Debug, Display, Error)]
-#[non_exhaustive]
-pub enum ContentTypeError {
-    /// Can not parse content type
-    #[display(fmt = "Can not parse content type")]
-    ParseError,
-
-    /// Unknown content encoding
-    #[display(fmt = "Unknown content encoding")]
-    UnknownEncoding,
-}
-
-#[cfg(test)]
-mod content_type_test_impls {
-    use super::*;
-
-    impl std::cmp::PartialEq for ContentTypeError {
-        fn eq(&self, other: &Self) -> bool {
-            match self {
-                Self::ParseError => matches!(other, ContentTypeError::ParseError),
-                Self::UnknownEncoding => {
-                    matches!(other, ContentTypeError::UnknownEncoding)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use http::{Error as HttpError, StatusCode};
-    use std::io;
-
-    #[test]
-    fn test_into_response() {
-        let resp: Response<AnyBody> = ParseError::Incomplete.into();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-
-        let err: HttpError = StatusCode::from_u16(10000).err().unwrap().into();
-        let resp: Response<AnyBody> = Error::new_http().with_cause(err).into();
-        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    }
-
-    #[test]
-    fn test_as_response() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let err: Error = ParseError::Io(orig).into();
-        assert_eq!(
-            format!("{}", err),
-            "error parsing HTTP message: IO error: other"
-        );
-    }
-
-    #[test]
-    fn test_error_display() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let err = Error::new_io().with_cause(orig);
-        assert_eq!("connection error: other", err.to_string());
-    }
-
-    #[test]
-    fn test_error_http_response() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let err = Error::new_io().with_cause(orig);
-        let resp: Response<AnyBody> = err.into();
-        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    }
-
-    #[test]
-    fn test_payload_error() {
-        let err: PayloadError =
-            io::Error::new(io::ErrorKind::Other, "ParseError").into();
-        assert!(err.to_string().contains("ParseError"));
-
-        let err = PayloadError::Incomplete(None);
-        assert_eq!(
-            err.to_string(),
-            "A payload reached EOF, but is not complete. Inner error: None"
-        );
-    }
-
-    macro_rules! from {
-        ($from:expr => $error:pat) => {
-            match ParseError::from($from) {
-                err @ $error => {
-                    assert!(err.to_string().len() >= 5);
-                }
-                err => unreachable!("{:?}", err),
-            }
-        };
-    }
-
-    macro_rules! from_and_cause {
-        ($from:expr => $error:pat) => {
-            match ParseError::from($from) {
-                e @ $error => {
-                    let desc = format!("{}", e);
-                    assert_eq!(desc, format!("IO error: {}", $from));
-                }
-                _ => unreachable!("{:?}", $from),
-            }
-        };
-    }
-
-    #[test]
-    fn test_from() {
-        from_and_cause!(io::Error::new(io::ErrorKind::Other, "other") => ParseError::Io(..));
-        from!(httparse::Error::HeaderName => ParseError::Header);
-        from!(httparse::Error::HeaderName => ParseError::Header);
-        from!(httparse::Error::HeaderValue => ParseError::Header);
-        from!(httparse::Error::NewLine => ParseError::Header);
-        from!(httparse::Error::Status => ParseError::Status);
-        from!(httparse::Error::Token => ParseError::Header);
-        from!(httparse::Error::TooManyHeaders => ParseError::TooLarge);
-        from!(httparse::Error::Version => ParseError::Version);
-    }
-}

actix-http/src/extensions.rs

@@ -1,305 +0,0 @@
-use std::{
-    any::{Any, TypeId},
-    fmt, mem,
-};
-
-use ahash::AHashMap;
-
-/// A type map for request extensions.
-///
-/// All entries into this map must be owned types (or static references).
-#[derive(Default)]
-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>>,
-}
-
-impl Extensions {
-    /// Creates an empty `Extensions`.
-    #[inline]
-    pub fn new() -> Extensions {
-        Extensions {
-            map: AHashMap::default(),
-        }
-    }
-
-    /// Insert an item into the map.
-    ///
-    /// 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)
-    }
-
-    /// 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>());
-    /// ```
-    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));
-    /// ```
-    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));
-    /// ```
-    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.
-    ///
-    /// 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>());
-    /// ```
-    pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(downcast_owned)
-    }
-
-    /// 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();
-    }
-
-    /// Extends self with the items from another `Extensions`.
-    pub fn extend(&mut self, other: Extensions) {
-        self.map.extend(other.map);
-    }
-
-    /// Sets (or overrides) items from `other` into this map.
-    pub(crate) fn drain_from(&mut self, other: &mut Self) {
-        self.map.extend(mem::take(&mut other.map));
-    }
-}
-
-impl fmt::Debug for Extensions {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
-    }
-}
-
-fn downcast_owned<T: 'static>(boxed: Box<dyn Any>) -> Option<T> {
-    boxed.downcast().ok().map(|boxed| *boxed)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_remove() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(123);
-        assert!(map.get::<i8>().is_some());
-
-        map.remove::<i8>();
-        assert!(map.get::<i8>().is_none());
-    }
-
-    #[test]
-    fn test_clear() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
-
-        assert!(map.contains::<i8>());
-        assert!(map.contains::<i16>());
-        assert!(map.contains::<i32>());
-
-        map.clear();
-
-        assert!(!map.contains::<i8>());
-        assert!(!map.contains::<i16>());
-        assert!(!map.contains::<i32>());
-
-        map.insert::<i8>(10);
-        assert_eq!(*map.get::<i8>().unwrap(), 10);
-    }
-
-    #[test]
-    fn test_integers() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
-        map.insert::<i64>(64);
-        map.insert::<i128>(128);
-        map.insert::<u8>(8);
-        map.insert::<u16>(16);
-        map.insert::<u32>(32);
-        map.insert::<u64>(64);
-        map.insert::<u128>(128);
-        assert!(map.get::<i8>().is_some());
-        assert!(map.get::<i16>().is_some());
-        assert!(map.get::<i32>().is_some());
-        assert!(map.get::<i64>().is_some());
-        assert!(map.get::<i128>().is_some());
-        assert!(map.get::<u8>().is_some());
-        assert!(map.get::<u16>().is_some());
-        assert!(map.get::<u32>().is_some());
-        assert!(map.get::<u64>().is_some());
-        assert!(map.get::<u128>().is_some());
-    }
-
-    #[test]
-    fn test_composition() {
-        struct Magi<T>(pub T);
-
-        struct Madoka {
-            pub god: bool,
-        }
-
-        struct Homura {
-            pub attempts: usize,
-        }
-
-        struct Mami {
-            pub guns: usize,
-        }
-
-        let mut map = Extensions::new();
-
-        map.insert(Magi(Madoka { god: false }));
-        map.insert(Magi(Homura { attempts: 0 }));
-        map.insert(Magi(Mami { guns: 999 }));
-
-        assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
-        assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
-        assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
-    }
-
-    #[test]
-    fn test_extensions() {
-        #[derive(Debug, PartialEq)]
-        struct MyType(i32);
-
-        let mut extensions = Extensions::new();
-
-        extensions.insert(5i32);
-        extensions.insert(MyType(10));
-
-        assert_eq!(extensions.get(), Some(&5i32));
-        assert_eq!(extensions.get_mut(), Some(&mut 5i32));
-
-        assert_eq!(extensions.remove::<i32>(), Some(5i32));
-        assert!(extensions.get::<i32>().is_none());
-
-        assert_eq!(extensions.get::<bool>(), None);
-        assert_eq!(extensions.get(), Some(&MyType(10)));
-    }
-
-    #[test]
-    fn test_extend() {
-        #[derive(Debug, PartialEq)]
-        struct MyType(i32);
-
-        let mut extensions = Extensions::new();
-
-        extensions.insert(5i32);
-        extensions.insert(MyType(10));
-
-        let mut other = Extensions::new();
-
-        other.insert(15i32);
-        other.insert(20u8);
-
-        extensions.extend(other);
-
-        assert_eq!(extensions.get(), Some(&15i32));
-        assert_eq!(extensions.get_mut(), Some(&mut 15i32));
-
-        assert_eq!(extensions.remove::<i32>(), Some(15i32));
-        assert!(extensions.get::<i32>().is_none());
-
-        assert_eq!(extensions.get::<bool>(), None);
-        assert_eq!(extensions.get(), Some(&MyType(10)));
-
-        assert_eq!(extensions.get(), Some(&20u8));
-        assert_eq!(extensions.get_mut(), Some(&mut 20u8));
-    }
-
-    #[test]
-    fn test_drain_from() {
-        let mut ext = Extensions::new();
-        ext.insert(2isize);
-
-        let mut more_ext = Extensions::new();
-
-        more_ext.insert(5isize);
-        more_ext.insert(5usize);
-
-        assert_eq!(ext.get::<isize>(), Some(&2isize));
-        assert_eq!(ext.get::<usize>(), None);
-        assert_eq!(more_ext.get::<isize>(), Some(&5isize));
-        assert_eq!(more_ext.get::<usize>(), Some(&5usize));
-
-        ext.drain_from(&mut more_ext);
-
-        assert_eq!(ext.get::<isize>(), Some(&5isize));
-        assert_eq!(ext.get::<usize>(), Some(&5usize));
-        assert_eq!(more_ext.get::<isize>(), None);
-        assert_eq!(more_ext.get::<usize>(), None);
-    }
-}

actix-http/src/h1/client.rs

@@ -1,225 +0,0 @@
-use std::io;
-
-use actix_codec::{Decoder, Encoder};
-use bitflags::bitflags;
-use bytes::{Bytes, BytesMut};
-use http::{Method, Version};
-
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder, reserve_readbuf};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::{ParseError, PayloadError};
-use crate::message::{ConnectionType, RequestHeadType, ResponseHead};
-
-bitflags! {
-    struct Flags: u8 {
-        const HEAD              = 0b0000_0001;
-        const KEEPALIVE_ENABLED = 0b0000_1000;
-        const STREAM            = 0b0001_0000;
-    }
-}
-
-/// HTTP/1 Codec
-pub struct ClientCodec {
-    inner: ClientCodecInner,
-}
-
-/// HTTP/1 Payload Codec
-pub struct ClientPayloadCodec {
-    inner: ClientCodecInner,
-}
-
-struct ClientCodecInner {
-    config: ServiceConfig,
-    decoder: decoder::MessageDecoder<ResponseHead>,
-    payload: Option<PayloadDecoder>,
-    version: Version,
-    ctype: ConnectionType,
-
-    // encoder part
-    flags: Flags,
-    encoder: encoder::MessageEncoder<RequestHeadType>,
-}
-
-impl Default for ClientCodec {
-    fn default() -> Self {
-        ClientCodec::new(ServiceConfig::default())
-    }
-}
-
-impl ClientCodec {
-    /// Create HTTP/1 codec.
-    ///
-    /// `keepalive_enabled` how response `connection` header get generated.
-    pub fn new(config: ServiceConfig) -> Self {
-        let flags = if config.keep_alive_enabled() {
-            Flags::KEEPALIVE_ENABLED
-        } else {
-            Flags::empty()
-        };
-        ClientCodec {
-            inner: ClientCodecInner {
-                config,
-                decoder: decoder::MessageDecoder::default(),
-                payload: None,
-                version: Version::HTTP_11,
-                ctype: ConnectionType::Close,
-
-                flags,
-                encoder: encoder::MessageEncoder::default(),
-            },
-        }
-    }
-
-    /// Check if request is upgrade
-    pub fn upgrade(&self) -> bool {
-        self.inner.ctype == ConnectionType::Upgrade
-    }
-
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.inner.ctype == ConnectionType::KeepAlive
-    }
-
-    /// Check last request's message type
-    pub fn message_type(&self) -> MessageType {
-        if self.inner.flags.contains(Flags::STREAM) {
-            MessageType::Stream
-        } else if self.inner.payload.is_none() {
-            MessageType::None
-        } else {
-            MessageType::Payload
-        }
-    }
-
-    /// Convert message codec to a payload codec
-    pub fn into_payload_codec(self) -> ClientPayloadCodec {
-        ClientPayloadCodec { inner: self.inner }
-    }
-}
-
-impl ClientPayloadCodec {
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.inner.ctype == ConnectionType::KeepAlive
-    }
-
-    /// Transform payload codec to a message codec
-    pub fn into_message_codec(self) -> ClientCodec {
-        ClientCodec { inner: self.inner }
-    }
-}
-
-impl Decoder for ClientCodec {
-    type Item = ResponseHead;
-    type Error = ParseError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        debug_assert!(!self.inner.payload.is_some(), "Payload decoder is set");
-
-        if let Some((req, payload)) = self.inner.decoder.decode(src)? {
-            if let Some(ctype) = req.ctype() {
-                // do not use peer's keep-alive
-                self.inner.ctype = if ctype == ConnectionType::KeepAlive {
-                    self.inner.ctype
-                } else {
-                    ctype
-                };
-            }
-
-            if !self.inner.flags.contains(Flags::HEAD) {
-                match payload {
-                    PayloadType::None => self.inner.payload = None,
-                    PayloadType::Payload(pl) => self.inner.payload = Some(pl),
-                    PayloadType::Stream(pl) => {
-                        self.inner.payload = Some(pl);
-                        self.inner.flags.insert(Flags::STREAM);
-                    }
-                }
-            } else {
-                self.inner.payload = None;
-            }
-            reserve_readbuf(src);
-            Ok(Some(req))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Decoder for ClientPayloadCodec {
-    type Item = Option<Bytes>;
-    type Error = PayloadError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        debug_assert!(
-            self.inner.payload.is_some(),
-            "Payload decoder is not specified"
-        );
-
-        Ok(match self.inner.payload.as_mut().unwrap().decode(src)? {
-            Some(PayloadItem::Chunk(chunk)) => {
-                reserve_readbuf(src);
-                Some(Some(chunk))
-            }
-            Some(PayloadItem::Eof) => {
-                self.inner.payload.take();
-                Some(None)
-            }
-            None => None,
-        })
-    }
-}
-
-impl Encoder<Message<(RequestHeadType, BodySize)>> for ClientCodec {
-    type Error = io::Error;
-
-    fn encode(
-        &mut self,
-        item: Message<(RequestHeadType, BodySize)>,
-        dst: &mut BytesMut,
-    ) -> Result<(), Self::Error> {
-        match item {
-            Message::Item((mut head, length)) => {
-                let inner = &mut self.inner;
-                inner.version = head.as_ref().version;
-                inner
-                    .flags
-                    .set(Flags::HEAD, head.as_ref().method == Method::HEAD);
-
-                // connection status
-                inner.ctype = match head.as_ref().connection_type() {
-                    ConnectionType::KeepAlive => {
-                        if inner.flags.contains(Flags::KEEPALIVE_ENABLED) {
-                            ConnectionType::KeepAlive
-                        } else {
-                            ConnectionType::Close
-                        }
-                    }
-                    ConnectionType::Upgrade => ConnectionType::Upgrade,
-                    ConnectionType::Close => ConnectionType::Close,
-                };
-
-                inner.encoder.encode(
-                    dst,
-                    &mut head,
-                    false,
-                    false,
-                    inner.version,
-                    length,
-                    inner.ctype,
-                    &inner.config,
-                )?;
-            }
-            Message::Chunk(Some(bytes)) => {
-                self.inner.encoder.encode_chunk(bytes.as_ref(), dst)?;
-            }
-            Message::Chunk(None) => {
-                self.inner.encoder.encode_eof(dst)?;
-            }
-        }
-        Ok(())
-    }
-}

actix-http/src/h1/codec.rs

@@ -1,240 +0,0 @@
-use std::{fmt, io};
-
-use actix_codec::{Decoder, Encoder};
-use bitflags::bitflags;
-use bytes::BytesMut;
-use http::{Method, Version};
-
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::ParseError;
-use crate::message::ConnectionType;
-use crate::request::Request;
-use crate::response::Response;
-
-bitflags! {
-    struct Flags: u8 {
-        const HEAD              = 0b0000_0001;
-        const KEEPALIVE_ENABLED = 0b0000_0010;
-        const STREAM            = 0b0000_0100;
-    }
-}
-
-/// HTTP/1 Codec
-pub struct Codec {
-    config: ServiceConfig,
-    decoder: decoder::MessageDecoder<Request>,
-    payload: Option<PayloadDecoder>,
-    version: Version,
-    ctype: ConnectionType,
-
-    // encoder part
-    flags: Flags,
-    encoder: encoder::MessageEncoder<Response<()>>,
-}
-
-impl Default for Codec {
-    fn default() -> Self {
-        Codec::new(ServiceConfig::default())
-    }
-}
-
-impl fmt::Debug for Codec {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "h1::Codec({:?})", self.flags)
-    }
-}
-
-impl Codec {
-    /// Create HTTP/1 codec.
-    ///
-    /// `keepalive_enabled` how response `connection` header get generated.
-    pub fn new(config: ServiceConfig) -> Self {
-        let flags = if config.keep_alive_enabled() {
-            Flags::KEEPALIVE_ENABLED
-        } else {
-            Flags::empty()
-        };
-
-        Codec {
-            config,
-            flags,
-            decoder: decoder::MessageDecoder::default(),
-            payload: None,
-            version: Version::HTTP_11,
-            ctype: ConnectionType::Close,
-            encoder: encoder::MessageEncoder::default(),
-        }
-    }
-
-    /// Check if request is upgrade.
-    #[inline]
-    pub fn upgrade(&self) -> bool {
-        self.ctype == ConnectionType::Upgrade
-    }
-
-    /// Check if last response is keep-alive.
-    #[inline]
-    pub fn keepalive(&self) -> bool {
-        self.ctype == ConnectionType::KeepAlive
-    }
-
-    /// Check if keep-alive enabled on server level.
-    #[inline]
-    pub fn keepalive_enabled(&self) -> bool {
-        self.flags.contains(Flags::KEEPALIVE_ENABLED)
-    }
-
-    /// Check last request's message type.
-    #[inline]
-    pub fn message_type(&self) -> MessageType {
-        if self.flags.contains(Flags::STREAM) {
-            MessageType::Stream
-        } else if self.payload.is_none() {
-            MessageType::None
-        } else {
-            MessageType::Payload
-        }
-    }
-
-    #[inline]
-    pub fn config(&self) -> &ServiceConfig {
-        &self.config
-    }
-}
-
-impl Decoder for Codec {
-    type Item = Message<Request>;
-    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)? {
-                Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
-                Some(PayloadItem::Eof) => {
-                    self.payload.take();
-                    Some(Message::Chunk(None))
-                }
-                None => None,
-            })
-        } else if let Some((req, payload)) = self.decoder.decode(src)? {
-            let head = req.head();
-            self.flags.set(Flags::HEAD, head.method == Method::HEAD);
-            self.version = head.version;
-            self.ctype = head.connection_type();
-            if self.ctype == ConnectionType::KeepAlive
-                && !self.flags.contains(Flags::KEEPALIVE_ENABLED)
-            {
-                self.ctype = ConnectionType::Close
-            }
-            match payload {
-                PayloadType::None => self.payload = None,
-                PayloadType::Payload(pl) => self.payload = Some(pl),
-                PayloadType::Stream(pl) => {
-                    self.payload = Some(pl);
-                    self.flags.insert(Flags::STREAM);
-                }
-            }
-            Ok(Some(Message::Item(req)))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
-    type Error = io::Error;
-
-    fn encode(
-        &mut self,
-        item: Message<(Response<()>, BodySize)>,
-        dst: &mut BytesMut,
-    ) -> Result<(), Self::Error> {
-        match item {
-            Message::Item((mut res, length)) => {
-                // set response version
-                res.head_mut().version = self.version;
-
-                // connection status
-                self.ctype = if let Some(ct) = res.head().ctype() {
-                    if ct == ConnectionType::KeepAlive {
-                        self.ctype
-                    } else {
-                        ct
-                    }
-                } else {
-                    self.ctype
-                };
-
-                // encode message
-                self.encoder.encode(
-                    dst,
-                    &mut res,
-                    self.flags.contains(Flags::HEAD),
-                    self.flags.contains(Flags::STREAM),
-                    self.version,
-                    length,
-                    self.ctype,
-                    &self.config,
-                )?;
-                // self.headers_size = (dst.len() - len) as u32;
-            }
-            Message::Chunk(Some(bytes)) => {
-                self.encoder.encode_chunk(bytes.as_ref(), dst)?;
-            }
-            Message::Chunk(None) => {
-                self.encoder.encode_eof(dst)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use bytes::BytesMut;
-    use http::Method;
-
-    use super::*;
-    use crate::HttpMessage;
-
-    #[actix_rt::test]
-    async fn test_http_request_chunked_payload_and_next_message() {
-        let mut codec = Codec::default();
-
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let item = codec.decode(&mut buf).unwrap().unwrap();
-        let req = item.message();
-
-        assert_eq!(req.method(), Method::GET);
-        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 = codec.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-
-        let msg = codec.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"line");
-
-        let msg = codec.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-
-        // decode next message
-        let item = codec.decode(&mut buf).unwrap().unwrap();
-        let req = item.message();
-        assert_eq!(*req.method(), Method::POST);
-        assert!(req.chunked().unwrap());
-    }
-}

actix-http/src/h1/encoder.rs

@@ -1,651 +0,0 @@
-use std::io::Write;
-use std::marker::PhantomData;
-use std::ptr::copy_nonoverlapping;
-use std::slice::from_raw_parts_mut;
-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,
-};
-
-const AVERAGE_HEADER_SIZE: usize = 30;
-
-#[derive(Debug)]
-pub(crate) struct MessageEncoder<T: MessageType> {
-    pub length: BodySize,
-    pub te: TransferEncoding,
-    _phantom: PhantomData<T>,
-}
-
-impl<T: MessageType> Default for MessageEncoder<T> {
-    fn default() -> Self {
-        MessageEncoder {
-            length: BodySize::None,
-            te: TransferEncoding::empty(),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-pub(crate) trait MessageType: Sized {
-    fn status(&self) -> Option<StatusCode>;
-
-    fn headers(&self) -> &HeaderMap;
-
-    fn extra_headers(&self) -> Option<&HeaderMap>;
-
-    fn camel_case(&self) -> bool {
-        false
-    }
-
-    fn chunked(&self) -> bool;
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
-
-    fn encode_headers(
-        &mut self,
-        dst: &mut BytesMut,
-        version: Version,
-        mut length: BodySize,
-        ctype: ConnectionType,
-        config: &ServiceConfig,
-    ) -> io::Result<()> {
-        let chunked = self.chunked();
-        let mut skip_len = length != BodySize::Stream;
-        let camel_case = self.camel_case();
-
-        // Content length
-        if let Some(status) = self.status() {
-            match status {
-                StatusCode::CONTINUE
-                | StatusCode::SWITCHING_PROTOCOLS
-                | StatusCode::PROCESSING
-                | StatusCode::NO_CONTENT => {
-                    // skip content-length and transfer-encoding headers
-                    // See https://tools.ietf.org/html/rfc7230#section-3.3.1
-                    // and https://tools.ietf.org/html/rfc7230#section-3.3.2
-                    skip_len = true;
-                    length = BodySize::None
-                }
-                _ => {}
-            }
-        }
-        match length {
-            BodySize::Stream => {
-                if chunked {
-                    if camel_case {
-                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
-                    } else {
-                        dst.put_slice(b"\r\ntransfer-encoding: chunked\r\n")
-                    }
-                } else {
-                    skip_len = false;
-                    dst.put_slice(b"\r\n");
-                }
-            }
-            BodySize::Empty => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
-                }
-            }
-            BodySize::Sized(len) => helpers::write_content_length(len, dst),
-            BodySize::None => dst.put_slice(b"\r\n"),
-        }
-
-        // Connection
-        match ctype {
-            ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
-            ConnectionType::KeepAlive if version < Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: keep-alive\r\n")
-                } else {
-                    dst.put_slice(b"connection: keep-alive\r\n")
-                }
-            }
-            ConnectionType::Close if version >= Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: close\r\n")
-                } else {
-                    dst.put_slice(b"connection: close\r\n")
-                }
-            }
-            _ => {}
-        }
-
-        // write headers
-
-        let mut has_date = false;
-
-        let mut buf = dst.chunk_mut().as_mut_ptr();
-        let mut remaining = dst.capacity() - dst.len();
-
-        // tracks bytes written since last buffer resize
-        // since buf is a raw pointer to a bytes container storage but is written to without the
-        // container's knowledge, this is used to sync the containers cursor after data is written
-        let mut pos = 0;
-
-        self.write_headers(|key, value| {
-            match *key {
-                CONNECTION => return,
-                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => return,
-                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();
-
-                // 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);
-                    }
-
-                    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.chunk_mut().as_mut_ptr();
-                }
-
-                // 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, 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;
-            }
-        });
-
-        // final cursor synchronization with the bytes container
-        //
-        // 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);
-        }
-
-        // optimized date header, set_date writes \r\n
-        if !has_date {
-            config.set_date(dst);
-        } else {
-            // msg eof
-            dst.extend_from_slice(b"\r\n");
-        }
-
-        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<()> {
-    fn status(&self) -> Option<StatusCode> {
-        Some(self.head().status)
-    }
-
-    fn chunked(&self) -> bool {
-        self.head().chunked()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        None
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.head();
-        let reason = head.reason().as_bytes();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE + reason.len());
-
-        // status line
-        helpers::write_status_line(head.version, head.status.as_u16(), dst);
-        dst.put_slice(reason);
-        Ok(())
-    }
-}
-
-impl MessageType for RequestHeadType {
-    fn status(&self) -> Option<StatusCode> {
-        None
-    }
-
-    fn chunked(&self) -> bool {
-        self.as_ref().chunked()
-    }
-
-    fn camel_case(&self) -> bool {
-        self.as_ref().camel_case_headers()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        self.as_ref().headers()
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        self.extra_headers()
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.as_ref();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
-        write!(
-            helpers::MutWriter(dst),
-            "{} {} {}",
-            head.method,
-            head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
-            match head.version {
-                Version::HTTP_09 => "HTTP/0.9",
-                Version::HTTP_10 => "HTTP/1.0",
-                Version::HTTP_11 => "HTTP/1.1",
-                Version::HTTP_2 => "HTTP/2.0",
-                Version::HTTP_3 => "HTTP/3.0",
-                _ =>
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "unsupported version"
-                    )),
-            }
-        )
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-    }
-}
-
-impl<T: MessageType> MessageEncoder<T> {
-    /// Encode message
-    pub fn encode_chunk(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
-        self.te.encode(msg, buf)
-    }
-
-    /// Encode eof
-    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
-        self.te.encode_eof(buf)
-    }
-
-    pub fn encode(
-        &mut self,
-        dst: &mut BytesMut,
-        message: &mut T,
-        head: bool,
-        stream: bool,
-        version: Version,
-        length: BodySize,
-        ctype: ConnectionType,
-        config: &ServiceConfig,
-    ) -> io::Result<()> {
-        // transfer encoding
-        if !head {
-            self.te = match length {
-                BodySize::Empty => TransferEncoding::empty(),
-                BodySize::Sized(len) => TransferEncoding::length(len),
-                BodySize::Stream => {
-                    if message.chunked() && !stream {
-                        TransferEncoding::chunked()
-                    } else {
-                        TransferEncoding::eof()
-                    }
-                }
-                BodySize::None => TransferEncoding::empty(),
-            };
-        } else {
-            self.te = TransferEncoding::empty();
-        }
-
-        message.encode_status(dst)?;
-        message.encode_headers(dst, version, length, ctype, config)
-    }
-}
-
-/// Encoders to handle different Transfer-Encodings.
-#[derive(Debug)]
-pub(crate) struct TransferEncoding {
-    kind: TransferEncodingKind,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-enum TransferEncodingKind {
-    /// An Encoder for when Transfer-Encoding includes `chunked`.
-    Chunked(bool),
-    /// An Encoder for when Content-Length is set.
-    ///
-    /// Enforces that the body is not longer than the Content-Length header.
-    Length(u64),
-    /// An Encoder for when Content-Length is not known.
-    ///
-    /// Application decides when to stop writing.
-    Eof,
-}
-
-impl TransferEncoding {
-    #[inline]
-    pub fn empty() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Length(0),
-        }
-    }
-
-    #[inline]
-    pub fn eof() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Eof,
-        }
-    }
-
-    #[inline]
-    pub fn chunked() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Chunked(false),
-        }
-    }
-
-    #[inline]
-    pub fn length(len: u64) -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Length(len),
-        }
-    }
-
-    /// Encode message. Return `EOF` state of encoder
-    #[inline]
-    pub fn encode(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
-        match self.kind {
-            TransferEncodingKind::Eof => {
-                let eof = msg.is_empty();
-                buf.extend_from_slice(msg);
-                Ok(eof)
-            }
-            TransferEncodingKind::Chunked(ref mut eof) => {
-                if *eof {
-                    return Ok(true);
-                }
-
-                if msg.is_empty() {
-                    *eof = true;
-                    buf.extend_from_slice(b"0\r\n\r\n");
-                } else {
-                    writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
-                    buf.reserve(msg.len() + 2);
-                    buf.extend_from_slice(msg);
-                    buf.extend_from_slice(b"\r\n");
-                }
-                Ok(*eof)
-            }
-            TransferEncodingKind::Length(ref mut remaining) => {
-                if *remaining > 0 {
-                    if msg.is_empty() {
-                        return Ok(*remaining == 0);
-                    }
-                    let len = cmp::min(*remaining, msg.len() as u64);
-
-                    buf.extend_from_slice(&msg[..len as usize]);
-
-                    *remaining -= len as u64;
-                    Ok(*remaining == 0)
-                } else {
-                    Ok(true)
-                }
-            }
-        }
-    }
-
-    /// Encode eof. Return `EOF` state of encoder
-    #[inline]
-    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
-        match self.kind {
-            TransferEncodingKind::Eof => Ok(()),
-            TransferEncodingKind::Length(rem) => {
-                if rem != 0 {
-                    Err(io::Error::new(io::ErrorKind::UnexpectedEof, ""))
-                } else {
-                    Ok(())
-                }
-            }
-            TransferEncodingKind::Chunked(ref mut eof) => {
-                if !*eof {
-                    *eof = true;
-                    buf.extend_from_slice(b"0\r\n\r\n");
-                }
-                Ok(())
-            }
-        }
-    }
-}
-
-/// # Safety
-/// 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);
-}
-
-fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
-    // first copy entire (potentially wrong) slice to output
-    buffer[..value.len()].copy_from_slice(value);
-
-    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;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::rc::Rc;
-
-    use bytes::Bytes;
-    use http::header::AUTHORIZATION;
-
-    use super::*;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-    use crate::RequestHead;
-
-    #[test]
-    fn test_chunked_te() {
-        let mut bytes = BytesMut::new();
-        let mut enc = TransferEncoding::chunked();
-        {
-            assert!(!enc.encode(b"test", &mut bytes).ok().unwrap());
-            assert!(enc.encode(b"", &mut bytes).ok().unwrap());
-        }
-        assert_eq!(
-            bytes.split().freeze(),
-            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_camel_case() {
-        let mut bytes = BytesMut::with_capacity(2048);
-        let mut head = RequestHead::default();
-        head.set_camel_case_headers(true);
-        head.headers.insert(DATE, HeaderValue::from_static("date"));
-        head.headers
-            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
-
-        let mut head = RequestHeadType::Owned(head);
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Empty,
-            ConnectionType::Close,
-            &ServiceConfig::default(),
-        );
-        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"));
-        assert!(data.contains("Date: date\r\n"));
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        assert!(data.contains("Transfer-Encoding: chunked\r\n"));
-        assert!(data.contains("Content-Type: plain/text\r\n"));
-        assert!(data.contains("Date: date\r\n"));
-
-        let mut head = RequestHead::default();
-        head.set_camel_case_headers(false);
-        head.headers.insert(DATE, HeaderValue::from_static("date"));
-        head.headers
-            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
-        head.headers
-            .append(CONTENT_TYPE, HeaderValue::from_static("xml"));
-
-        let mut head = RequestHeadType::Owned(head);
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        assert!(data.contains("transfer-encoding: chunked\r\n"));
-        assert!(data.contains("content-type: xml\r\n"));
-        assert!(data.contains("content-type: plain/text\r\n"));
-        assert!(data.contains("date: date\r\n"));
-    }
-
-    #[actix_rt::test]
-    async fn test_extra_headers() {
-        let mut bytes = BytesMut::with_capacity(2048);
-
-        let mut head = RequestHead::default();
-        head.headers.insert(
-            AUTHORIZATION,
-            HeaderValue::from_static("some authorization"),
-        );
-
-        let mut extra_headers = HeaderMap::new();
-        extra_headers.insert(
-            AUTHORIZATION,
-            HeaderValue::from_static("another authorization"),
-        );
-        extra_headers.insert(DATE, HeaderValue::from_static("date"));
-
-        let mut head = RequestHeadType::Rc(Rc::new(head), Some(extra_headers));
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Empty,
-            ConnectionType::Close,
-            &ServiceConfig::default(),
-        );
-        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("authorization: another authorization\r\n"));
-        assert!(data.contains("date: date\r\n"));
-    }
-
-    #[actix_rt::test]
-    async 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(""));
-        res.headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
-
-        let _ = res.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::Upgrade,
-            &ServiceConfig::default(),
-        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        assert!(!data.contains("content-length: 0\r\n"));
-        assert!(!data.contains("transfer-encoding: chunked\r\n"));
-    }
-}

actix-http/src/h1/expect.rs

@@ -1,34 +0,0 @@
-use actix_service::{Service, ServiceFactory};
-use actix_utils::future::{ready, Ready};
-
-use crate::error::Error;
-use crate::request::Request;
-
-pub struct ExpectHandler;
-
-impl ServiceFactory<Request> for ExpectHandler {
-    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))
-    }
-}
-
-impl Service<Request> for ExpectHandler {
-    type Response = Request;
-    type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
-
-    actix_service::always_ready!();
-
-    fn call(&self, req: Request) -> Self::Future {
-        ready(Ok(req))
-        // TODO: add some way to trigger error
-        // Err(error::ErrorExpectationFailed("test"))
-    }
-}

actix-http/src/h1/mod.rs

@@ -1,85 +0,0 @@
-//! HTTP/1 protocol implementation.
-use bytes::{Bytes, BytesMut};
-
-mod client;
-mod codec;
-mod decoder;
-mod dispatcher;
-mod encoder;
-mod expect;
-mod payload;
-mod service;
-mod upgrade;
-mod utils;
-
-pub use self::client::{ClientCodec, ClientPayloadCodec};
-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::upgrade::UpgradeHandler;
-pub use self::utils::SendResponse;
-
-#[derive(Debug)]
-/// Codec message
-pub enum Message<T> {
-    /// Http message
-    Item(T),
-    /// Payload chunk
-    Chunk(Option<Bytes>),
-}
-
-impl<T> From<T> for Message<T> {
-    fn from(item: T) -> Self {
-        Message::Item(item)
-    }
-}
-
-/// Incoming request type
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MessageType {
-    None,
-    Payload,
-    Stream,
-}
-
-const LW: usize = 2 * 1024;
-const HW: usize = 32 * 1024;
-
-pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
-    let cap = src.capacity();
-    if cap < LW {
-        src.reserve(HW - cap);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::request::Request;
-
-    impl Message<Request> {
-        pub fn message(self) -> Request {
-            match self {
-                Message::Item(req) => req,
-                _ => panic!("error"),
-            }
-        }
-
-        pub fn chunk(self) -> Bytes {
-            match self {
-                Message::Chunk(Some(data)) => data,
-                _ => panic!("error"),
-            }
-        }
-
-        pub fn eof(self) -> bool {
-            match self {
-                Message::Chunk(None) => true,
-                Message::Chunk(Some(_)) => false,
-                _ => panic!("error"),
-            }
-        }
-    }
-}

actix-http/src/h1/payload.rs

@@ -1,279 +0,0 @@
-//! Payload stream
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::pin::Pin;
-use std::rc::{Rc, Weak};
-use std::task::{Context, Poll, Waker};
-
-use bytes::Bytes;
-use futures_core::Stream;
-
-use crate::error::PayloadError;
-
-/// max buffer size 32k
-pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
-
-#[derive(Debug, PartialEq)]
-pub enum PayloadStatus {
-    Read,
-    Pause,
-    Dropped,
-}
-
-/// Buffered stream of bytes chunks
-///
-/// Payload stores chunks in a vector. First chunk can be received with
-/// `.readany()` method. Payload stream is not thread safe. Payload does not
-/// notify current task when new data is available.
-///
-/// Payload stream can be used as `Response` body stream.
-#[derive(Debug)]
-pub struct Payload {
-    inner: Rc<RefCell<Inner>>,
-}
-
-impl Payload {
-    /// Create payload stream.
-    ///
-    /// This method construct two objects responsible for bytes stream
-    /// generation.
-    ///
-    /// * `PayloadSender` - *Sender* side of the stream
-    ///
-    /// * `Payload` - *Receiver* side of the stream
-    pub fn create(eof: bool) -> (PayloadSender, Payload) {
-        let shared = Rc::new(RefCell::new(Inner::new(eof)));
-
-        (
-            PayloadSender {
-                inner: Rc::downgrade(&shared),
-            },
-            Payload { inner: shared },
-        )
-    }
-
-    /// Create empty payload
-    #[doc(hidden)]
-    pub fn empty() -> Payload {
-        Payload {
-            inner: Rc::new(RefCell::new(Inner::new(true))),
-        }
-    }
-
-    /// Length of the data in this payload
-    #[cfg(test)]
-    pub fn len(&self) -> usize {
-        self.inner.borrow().len()
-    }
-
-    /// Is payload empty
-    #[cfg(test)]
-    pub fn is_empty(&self) -> bool {
-        self.inner.borrow().len() == 0
-    }
-
-    /// Put unused data back to payload
-    #[inline]
-    pub fn unread_data(&mut self, data: Bytes) {
-        self.inner.borrow_mut().unread_data(data);
-    }
-
-    #[inline]
-    pub fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
-    }
-}
-
-impl Stream for Payload {
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
-    }
-}
-
-/// Sender part of the payload stream
-pub struct PayloadSender {
-    inner: Weak<RefCell<Inner>>,
-}
-
-impl PayloadSender {
-    #[inline]
-    pub fn set_error(&mut self, err: PayloadError) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().set_error(err)
-        }
-    }
-
-    #[inline]
-    pub fn feed_eof(&mut self) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().feed_eof()
-        }
-    }
-
-    #[inline]
-    pub fn feed_data(&mut self, data: Bytes) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().feed_data(data)
-        }
-    }
-
-    #[inline]
-    pub fn need_read(&self, cx: &mut Context<'_>) -> PayloadStatus {
-        // we check need_read only if Payload (other side) is alive,
-        // otherwise always return true (consume payload)
-        if let Some(shared) = self.inner.upgrade() {
-            if shared.borrow().need_read {
-                PayloadStatus::Read
-            } else {
-                shared.borrow_mut().register_io(cx);
-                PayloadStatus::Pause
-            }
-        } else {
-            PayloadStatus::Dropped
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Inner {
-    len: usize,
-    eof: bool,
-    err: Option<PayloadError>,
-    need_read: bool,
-    items: VecDeque<Bytes>,
-    task: Option<Waker>,
-    io_task: Option<Waker>,
-}
-
-impl Inner {
-    fn new(eof: bool) -> Self {
-        Inner {
-            eof,
-            len: 0,
-            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());
-        }
-    }
-
-    #[inline]
-    fn set_error(&mut self, err: PayloadError) {
-        self.err = Some(err);
-    }
-
-    #[inline]
-    fn feed_eof(&mut self) {
-        self.eof = true;
-    }
-
-    #[inline]
-    fn feed_data(&mut self, data: Bytes) {
-        self.len += data.len();
-        self.items.push_back(data);
-        self.need_read = self.len < MAX_BUFFER_SIZE;
-        self.wake();
-    }
-
-    #[cfg(test)]
-    fn len(&self) -> usize {
-        self.len
-    }
-
-    fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        if let Some(data) = self.items.pop_front() {
-            self.len -= data.len();
-            self.need_read = self.len < MAX_BUFFER_SIZE;
-
-            if self.need_read && !self.eof {
-                self.register(cx);
-            }
-            self.wake_io();
-            Poll::Ready(Some(Ok(data)))
-        } else if let Some(err) = self.err.take() {
-            Poll::Ready(Some(Err(err)))
-        } else if self.eof {
-            Poll::Ready(None)
-        } else {
-            self.need_read = true;
-            self.register(cx);
-            self.wake_io();
-            Poll::Pending
-        }
-    }
-
-    fn unread_data(&mut self, data: Bytes) {
-        self.len += data.len();
-        self.items.push_front(data);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use actix_utils::future::poll_fn;
-
-    #[actix_rt::test]
-    async fn test_unread_data() {
-        let (_, mut payload) = Payload::create(false);
-
-        payload.unread_data(Bytes::from("data"));
-        assert!(!payload.is_empty());
-        assert_eq!(payload.len(), 4);
-
-        assert_eq!(
-            Bytes::from("data"),
-            poll_fn(|cx| payload.readany(cx)).await.unwrap().unwrap()
-        );
-    }
-}

actix-http/src/h1/service.rs

@@ -1,378 +0,0 @@
-use std::{
-    error::Error as StdError,
-    fmt,
-    marker::PhantomData,
-    net,
-    rc::Rc,
-    task::{Context, Poll},
-};
-
-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 crate::{
-    body::{AnyBody, MessageBody},
-    config::ServiceConfig,
-    error::DispatchError,
-    service::HttpServiceHandler,
-    ConnectCallback, OnConnectData, Request, Response,
-};
-
-use super::{codec::Codec, dispatcher::Dispatcher, ExpectHandler, UpgradeHandler};
-
-/// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B> H1Service<T, S, B>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
-    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>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        H1Service {
-            cfg,
-            srv: service.into_factory(),
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect_ext: None,
-            _phantom: 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::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::InitError: fmt::Debug,
-
-    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
-    U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
-    U::InitError: fmt::Debug,
-{
-    /// Create simple tcp stream service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        TcpStream,
-        Config = (),
-        Response = (),
-        Error = DispatchError,
-        InitError = (),
-    > {
-        fn_service(|io: TcpStream| {
-            let peer_addr = io.peer_addr().ok();
-            ready(Ok((io, peer_addr)))
-        })
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use super::*;
-
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::{
-        openssl::{Acceptor, SslAcceptor, SslError, TlsStream},
-        TlsError,
-    };
-
-    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::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::InitError: fmt::Debug,
-
-        U: ServiceFactory<
-            (Request, Framed<TlsStream<TcpStream>, Codec>),
-            Config = (),
-            Response = (),
-        >,
-        U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create openssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            Response = (),
-            Error = TlsError<SslError, 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))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-
-    use std::io;
-
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::{
-        rustls::{Acceptor, ServerConfig, TlsStream},
-        TlsError,
-    };
-
-    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::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::InitError: fmt::Debug,
-
-        U: ServiceFactory<
-            (Request, Framed<TlsStream<TcpStream>, Codec>),
-            Config = (),
-            Response = (),
-        >,
-        U::Future: 'static,
-        U::Error: fmt::Display + Into<Response<AnyBody>>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create rustls based service
-        pub fn rustls(
-            self,
-            config: ServerConfig,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            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))
-        }
-    }
-}
-
-impl<T, S, B, X, U> H1Service<T, S, B, X, U>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Response<AnyBody>>,
-    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::InitError: fmt::Debug,
-    {
-        H1Service {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
-    where
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        H1Service {
-            upgrade,
-            cfg: self.cfg,
-            srv: self.srv,
-            expect: self.expect,
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
-        self.on_connect_ext = f;
-        self
-    }
-}
-
-impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
-    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>>,
-    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::InitError: fmt::Debug,
-
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
-    U::Future: 'static,
-    U::Error: fmt::Display + Into<Response<AnyBody>>,
-    U::InitError: fmt::Debug,
-{
-    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>>;
-
-    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();
-
-        Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| log::error!("Init http expect service error: {:?}", e))?;
-
-            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,
-            };
-
-            let service = service
-                .await
-                .map_err(|e| log::error!("Init http service error: {:?}", e))?;
-
-            Ok(H1ServiceHandler::new(
-                cfg,
-                service,
-                expect,
-                upgrade,
-                on_connect_ext,
-            ))
-        })
-    }
-}
-
-/// `Service` implementation for HTTP/1 transport
-pub type H1ServiceHandler<T, S, B, X, U> = HttpServiceHandler<T, S, B, X, U>;
-
-impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
-    for HttpServiceHandler<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
-    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>>,
-{
-    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 call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
-
-        Dispatcher::new(
-            io,
-            self.cfg.clone(),
-            self.flow.clone(),
-            on_connect_data,
-            addr,
-        )
-    }
-}

actix-http/src/h1/upgrade.rs

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

actix-http/src/h1/utils.rs

@@ -1,135 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-
-use crate::body::{BodySize, MessageBody};
-use crate::error::Error;
-use crate::h1::{Codec, Message};
-use crate::response::Response;
-
-/// Send HTTP/1 response
-#[pin_project::pin_project]
-pub struct SendResponse<T, B> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    #[pin]
-    body: Option<B>,
-    #[pin]
-    framed: Option<Framed<T, Codec>>,
-}
-
-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();
-
-        SendResponse {
-            res: Some((res, body.size()).into()),
-            body: Some(body),
-            framed: Some(framed),
-        }
-    }
-}
-
-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>;
-
-    // TODO: rethink if we need loops in polls
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        let mut body_done = this.body.is_none();
-        loop {
-            let mut body_ready = !body_done;
-
-            // send body
-            if this.res.is_none() && body_ready {
-                while body_ready
-                    && !body_done
-                    && !this
-                        .framed
-                        .as_ref()
-                        .as_pin_ref()
-                        .unwrap()
-                        .is_write_buf_full()
-                {
-                    let next =
-                        // TODO: MSRV 1.51: poll_map_err
-                        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 {
-                        Poll::Ready(item) => {
-                            // body is done when item is None
-                            body_done = item.is_none();
-                            if body_done {
-                                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)
-                            })?;
-                        }
-                        Poll::Pending => body_ready = false,
-                    }
-                }
-            }
-
-            let framed = this.framed.as_mut().as_pin_mut().unwrap();
-
-            // flush write buffer
-            if !framed.is_write_buf_empty() {
-                match framed
-                    .flush(cx)
-                    .map_err(|err| Error::new_send_response().with_cause(err))?
-                {
-                    Poll::Ready(_) => {
-                        if body_ready {
-                            continue;
-                        } else {
-                            return Poll::Pending;
-                        }
-                    }
-                    Poll::Pending => return Poll::Pending,
-                }
-            }
-
-            // send response
-            if let Some(res) = this.res.take() {
-                framed
-                    .write(res)
-                    .map_err(|err| Error::new_send_response().with_cause(err))?;
-                continue;
-            }
-
-            if !body_done {
-                if body_ready {
-                    continue;
-                } else {
-                    return Poll::Pending;
-                }
-            } else {
-                break;
-            }
-        }
-
-        let framed = this.framed.take().unwrap();
-
-        Poll::Ready(Ok(framed))
-    }
-}

actix-http/src/h2/dispatcher.rs

@@ -1,269 +0,0 @@
-use std::{
-    cmp,
-    error::Error as StdError,
-    future::Future,
-    marker::PhantomData,
-    net,
-    pin::Pin,
-    rc::Rc,
-    task::{Context, Poll},
-};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_service::Service;
-use actix_utils::future::poll_fn;
-use bytes::{Bytes, BytesMut};
-use futures_core::ready;
-use h2::server::{Connection, SendResponse};
-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,
-};
-
-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>,
-    }
-}
-
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U> {
-    pub(crate) fn new(
-        flow: Rc<HttpFlow<S, X, U>>,
-        connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
-        config: ServiceConfig,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        Self {
-            flow,
-            config,
-            peer_addr,
-            connection,
-            on_connect_data,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-
-    S: Service<Request>,
-    S::Error: Into<Response<AnyBody>>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-
-    B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
-{
-    type Output = Result<(), crate::error::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)
-                        }
-                    }
-                }
-            });
-        }
-
-        Poll::Ready(Ok(()))
-    }
-}
-
-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>
-where
-    B: MessageBody,
-    B::Error: Into<Box<dyn StdError>>,
-{
-    let (res, body) = res.replace_body(());
-
-    // prepare response.
-    let mut size = body.size();
-    let res = prepare_response(config, res.head(), &mut size);
-    let eof = size.is_eof();
-
-    // send response head and return on eof.
-    let mut stream = tx
-        .send_response(res, eof)
-        .map_err(DispatchError::SendResponse)?;
-
-    if eof {
-        return Ok(());
-    }
-
-    // poll response body and send chunks to client.
-    actix_rt::pin!(body);
-
-    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()))?;
-
-        'send: loop {
-            // reserve enough space and wait for stream ready.
-            stream.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
-
-            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 len = chunk.len();
-                    let bytes = chunk.split_to(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;
-                    }
-                }
-            }
-        }
-    }
-
-    // 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,52 +0,0 @@
-//! HTTP/2 protocol.
-
-use std::{
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-use h2::RecvStream;
-
-mod dispatcher;
-mod service;
-
-pub use self::dispatcher::Dispatcher;
-pub use self::service::H2Service;
-use crate::error::PayloadError;
-
-/// HTTP/2 peer stream.
-pub struct Payload {
-    stream: RecvStream,
-}
-
-impl Payload {
-    pub(crate) fn new(stream: RecvStream) -> Self {
-        Self { stream }
-    }
-}
-
-impl Stream for Payload {
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-
-        match ready!(Pin::new(&mut this.stream).poll_data(cx)) {
-            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()))),
-                }
-            }
-            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-            None => Poll::Ready(None),
-        }
-    }
-}