prepare release

Deprecates Error::cause and introduces failure interoperability functions and downcasting.

.appveyor.yml

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

.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: Gitter channel (actix-web)
-    url: https://gitter.im/actix/actix-web
-    about: Please ask and answer questions about the actix-web here.
-  - name: Gitter channel (actix)
-    url: https://gitter.im/actix/actix
-    about: Please ask and answer questions about the actix here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,27 +0,0 @@
-<!-- Thanks for considering contributing actix! -->
-<!-- Please fill out the following to make our reviews easy. -->
-
-## PR Type
-<!-- What kind of change does this PR make? -->
-<!-- Bug Fix / Feature / Refactor / Code Style / Other -->
-INSERT_PR_TYPE
-
-
-## PR Checklist
-Check your PR fulfills the following:
-
-<!-- For draft PRs check the boxes as you complete them. -->
-
-- [ ] Tests for the changes have been added / updated.
-- [ ] Documentation comments have been added / updated.
-- [ ] A changelog entry has been made for the appropriate packages.
-- [ ] Format code with the latest stable rustfmt
-
-
-## Overview
-<!-- Describe the current and new behavior. -->
-<!-- Emphasize any breaking changes. -->
-
-
-<!-- If this PR fixes or closes an issue, reference it here. -->
-<!-- Closes #000 -->

.github/workflows/bench.yml

@@ -1,28 +0,0 @@
-name: Benchmark (Linux)
-
-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/clippy-fmt.yml

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

.github/workflows/linux.yml

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

.github/workflows/macos.yml

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

.github/workflows/upload-doc.yml

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

.github/workflows/windows.yml

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

.gitignore

@@ -9,7 +9,6 @@ guide/build/
 *.pid
 *.sock
 *~
-.DS_Store
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

.travis.yml

@@ -0,0 +1,55 @@
+language: rust
+sudo: false
+dist: trusty
+
+cache:
+  cargo: true
+  apt: true
+
+matrix:
+  include:
+    - rust: 1.24.0
+    - rust: stable
+    - rust: beta
+    - rust: nightly
+  allow_failures:
+    - rust: nightly
+
+env:
+  global:
+    # - RUSTFLAGS="-C link-dead-code"
+    - OPENSSL_VERSION=openssl-1.0.2
+
+before_install:
+  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
+
+# Add clippy
+before_script:
+  - export PATH=$PATH:~/.cargo/bin
+
+script:
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" != "1.24.0" ]]; then
+    cargo clean
+    cargo test --features="alpn,tls" -- --nocapture
+    fi
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" == "1.24.0" ]]; then
+    bash <(curl https://raw.githubusercontent.com/xd009642/tarpaulin/master/travis-install.sh)
+    USE_SKEPTIC=1 cargo tarpaulin --out Xml --no-count
+    bash <(curl -s https://codecov.io/bash)
+    echo "Uploaded code coverage"
+    fi
+
+# Upload docs
+after_success:
+  - |
+    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "stable" ]]; 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

CHANGES.md

@@ -1,523 +1,445 @@
 # Changes
 
-## Unreleased - 2020-xx-xx
-
-
-## 3.0.0 - 2020-09-11
-* No significant changes from `3.0.0-beta.4`.
-
-
-## 3.0.0-beta.4 - 2020-09-09
-### Added
-* `middleware::NormalizePath` now has configurable behaviour for either always having a trailing
-  slash, or as the new addition, always trimming trailing slashes. [#1639]
-
-### 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]
-
-[#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
-
-
-## 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.
-
-### Fixed
-* Memory leak of app data in pooled requests. [#1609]
-
-[#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
-
-
-## 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.
-
-### 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
-
-### Fixed
-* `NormalizePath` improved consistency when path needs slashes added _and_ removed.
-
-
-## 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`
-
-[#1485]: https://github.com/actix/actix-web/pull/1485
-[#1509]: https://github.com/actix/actix-web/pull/1509
-
-## [3.0.0-alpha.2] - 2020-05-08
-
-### Changed
-
-* `{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.
-
-[#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
-
-
-## [3.0.0-alpha.1] - 2020-03-11
-
-### Added
-
-* 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.
-
-### Changed
-
-* 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
-
-[#1308]: https://github.com/actix/actix-web/pull/1308
-
-## [2.0.0] - 2019-12-25
-
-### Changed
-
-* Rename `HttpServer::start()` to `HttpServer::run()`
-
-* Allow to gracefully stop test server via `TestServer::stop()`
-
-* Allow to specify multi-patterns for resources
-
-## [2.0.0-rc] - 2019-12-20
-
-### Changed
-
-* Move `BodyEncoding` to `dev` module #1220
-
-* Allow to set `peer_addr` for TestRequest #1074
-
-* Make web::Data deref to Arc<T> #1214
-
-* Rename `App::register_data()` to `App::app_data()`
-
-* `HttpRequest::app_data<T>()` returns `Option<&T>` instead of `Option<&Data<T>>`
+## [0.6.13] - 2018-06-13
 
 ### Fixed
 
-* Fix `AppConfig::secure()` is always false. #1202
+* http/2 end-of-frame is not set if body is empty bytes #307
+
+* InternalError can trigger memory unsafety #301
+
+* Fix docs.rs build
 
 
-## [2.0.0-alpha.6] - 2019-12-15
+## [0.6.12] - 2018-06-08
+
+### Added
+
+* Add `Host` filter #287
+
+* Allow to filter applications
+
+* Improved failure interoperability with downcasting #285
+
+* Allow to use custom resolver for `ClientConnector`
+
+
+### Deprecated
+
+* `Error::cause()` and introduces failure interoperability functions and downcasting.
+
+
+## [0.6.11] - 2018-06-05
 
 ### Fixed
 
-* Fixed compilation with default features off
+* Support chunked encoding for UrlEncoded body #262
 
-## [2.0.0-alpha.5] - 2019-12-13
+* `HttpRequest::url_for()` for a named route with no variables segments #265
+
+* `Middleware::response()` is not invoked if error result was returned by another `Middleware::start()` #255
+
+* CORS: Do not validate Origin header on non-OPTION requests #271
+
+* Fix multipart upload "Incomplete" error #282
+
+
+## [0.6.10] - 2018-05-24
 
 ### Added
 
-* Add test server, `test::start()` and `test::start_with()`
+* Allow to use path without traling slashes for scope registration #241
 
-## [2.0.0-alpha.4] - 2019-12-08
-
-### Deleted
-
-* Delete HttpServer::run(), it is not useful witht async/await
-
-## [2.0.0-alpha.3] - 2019-12-07
-
-### Changed
-
-* Migrate to tokio 0.2
-
-
-## [2.0.0-alpha.1] - 2019-11-22
-
-### Changed
-
-* Migrated to `std::future`
-
-* Remove implementation of `Responder` for `()`. (#1167)
-
-
-## [1.0.9] - 2019-11-14
-
-### Added
-
-* Add `Payload::into_inner` method and make stored `def::Payload` public. (#1110)
-
-### Changed
-
-* Support `Host` guards when the `Host` header is unset (e.g. HTTP/2 requests) (#1129)
-
-
-## [1.0.8] - 2019-09-25
-
-### Added
-
-* Add `Scope::register_data` and `Resource::register_data` methods, parallel to
-  `App::register_data`.
-
-* Add `middleware::Condition` that conditionally enables another middleware
-
-* Allow to re-construct `ServiceRequest` from `HttpRequest` and `Payload`
-
-* Add `HttpServer::listen_uds` for ability to listen on UDS FD rather than path,
-  which is useful for example with systemd.
-
-### Changed
-
-* Make UrlEncodedError::Overflow more informativve
-
-* Use actix-testing for testing utils
-
-
-## [1.0.7] - 2019-08-29
+* Allow to set encoding for exact NamedFile #239
 
 ### Fixed
 
-* Request Extensions leak #1062
+* `TestServer::post()` actually sends `GET` request #240
 
 
-## [1.0.6] - 2019-08-28
+## 0.6.9 (2018-05-22)
 
-### Added
+* Drop connection if request's payload is not fully consumed #236
 
-* Re-implement Host predicate (#989)
+* Fix streaming response with body compression
 
-* Form immplements Responder, returning a `application/x-www-form-urlencoded` response
 
-* Add `into_inner` to `Data`
+## 0.6.8 (2018-05-20)
 
-* Add `test::TestRequest::set_form()` convenience method to automatically serialize data and set
-  the header in test requests.
+* Fix scope resource path extractor #234
 
-### Changed
+* Re-use tcp listener on pause/resume
 
-* `Query` payload made `pub`. Allows user to pattern-match the payload.
 
-* Enable `rust-tls` feature for client #1045
+## 0.6.7 (2018-05-17)
 
-* Update serde_urlencoded to 0.6.1
+* Fix compilation with --no-default-features
 
-* Update url to 2.1
 
+## 0.6.6 (2018-05-17)
 
-## [1.0.5] - 2019-07-18
+* Panic during middleware execution #226
 
-### Added
+* Add support for listen_tls/listen_ssl #224
 
-* Unix domain sockets (HttpServer::bind_uds) #92
+* Implement extractor for `Session`
 
-* Actix now logs errors resulting in "internal server error" responses always, with the `error`
-  logging level
+* Ranges header support for NamedFile #60
 
-### Fixed
 
-* Restored logging of errors through the `Logger` middleware
+## 0.6.5 (2018-05-15)
 
+* Fix error handling during request decoding #222
 
-## [1.0.4] - 2019-07-17
 
-### Added
+## 0.6.4 (2018-05-11)
 
-* Add `Responder` impl for `(T, StatusCode) where T: Responder`
+* Fix segfault in ServerSettings::get_response_builder()
 
-* Allow to access app's resource map via
-  `ServiceRequest::resource_map()` and `HttpRequest::resource_map()` methods.
 
-### Changed
+## 0.6.3 (2018-05-10)
 
-* Upgrade `rand` dependency version to 0.7
+* Add `Router::with_async()` method for async handler registration.
 
+* Added error response functions for 501,502,503,504
 
-## [1.0.3] - 2019-06-28
+* Fix client request timeout handling
 
-### Added
 
-* Support asynchronous data factories #850
+## 0.6.2 (2018-05-09)
 
-### Changed
+* WsWriter trait is optional.
 
-*  Use `encoding_rs` crate instead of unmaintained `encoding` crate
 
+## 0.6.1 (2018-05-08)
 
-## [1.0.2] - 2019-06-17
+* Fix http/2 payload streaming #215
 
-### Changed
+* Fix connector's default `keep-alive` and `lifetime` settings #212
 
-* Move cors middleware to `actix-cors` crate.
+* Send `ErrorNotFound` instead of `ErrorBadRequest` when path extractor fails #214
 
-* Move identity middleware to `actix-identity` crate.
+* Allow to exclude certain endpoints from logging #211
 
 
-## [1.0.1] - 2019-06-17
+## 0.6.0 (2018-05-08)
 
-### Added
+* Add route scopes #202
 
-* Add support for PathConfig #903
+* Allow to use ssl and non-ssl connections at the same time #206
 
-* Add `middleware::identity::RequestIdentity` trait to `get_identity` from `HttpMessage`.
+* Websocket CloseCode Empty/Status is ambiguous #193
 
-### Changed
+* Add Content-Disposition to NamedFile #204
 
-* Move cors middleware to `actix-cors` crate.
+* Allow to access Error's backtrace object
 
-* Move identity middleware to `actix-identity` crate.
+* Allow to override files listing renderer for `StaticFiles` #203
 
-* Disable default feature `secure-cookies`.
+* Various extractor usability improvements #207
 
-* Allow to test an app that uses async actors #897
 
-* Re-apply patch from #637 #894
+## 0.5.6 (2018-04-24)
 
-### Fixed
+* Make flate2 crate optional #200
 
-* HttpRequest::url_for is broken with nested scopes #915
 
+## 0.5.5 (2018-04-24)
 
-## [1.0.0] - 2019-06-05
+* Fix panic when Websocket is closed with no error code #191
 
-### Added
+* Allow to use rust backend for flate2 crate #199
 
-* Add `Scope::configure()` method.
+## 0.5.4 (2018-04-19)
 
-* Add `ServiceRequest::set_payload()` method.
+* Add identity service middleware
 
-* Add `test::TestRequest::set_json()` convenience method to automatically
-  serialize data and set header in test requests.
+* Middleware response() is not invoked if there was an error in async handler #187
 
-* Add macros for head, options, trace, connect and patch http methods
+* Use Display formatting for InternalError Display implementation #188
 
-### Changed
 
-* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
+## 0.5.3 (2018-04-18)
 
-### Fixed
+* Impossible to quote slashes in path parameters #182
 
-* Fix Logger request time format, and use rfc3339. #867
 
-* Clear http requests pool on app service drop #860
+## 0.5.2 (2018-04-16)
 
+* Allow to configure StaticFiles's CpuPool, via static method or env variable
 
-## [1.0.0-rc] - 2019-05-18
+* Add support for custom handling of Json extractor errors #181
 
-### Add
+* Fix StaticFiles does not support percent encoded paths #177
 
-* Add `Query<T>::from_query()` to extract parameters from a query string. #846
-* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
+* Fix Client Request with custom Body Stream halting on certain size requests #176
 
-### Changed
 
-* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
+## 0.5.1 (2018-04-12)
 
-### Fixed
+* Client connector provides stats, `ClientConnector::stats()`
 
-* Codegen with parameters in the path only resolves the first registered endpoint #841
+* Fix end-of-stream handling in parse_payload #173
 
+* Fix StaticFiles generate a lot of threads #174
 
-## [1.0.0-beta.4] - 2019-05-12
 
-### Add
+## 0.5.0 (2018-04-10)
 
-* Allow to set/override app data on scope level
+* Type-safe path/query/form parameter handling, using serde #70
 
-### Changed
+* HttpResponse builder's methods  `.body()`, `.finish()`, `.json()`
+  return `HttpResponse` instead of `Result`
 
-* `App::configure` take an `FnOnce` instead of `Fn`
-* Upgrade actix-net crates
+* Use more ergonomic `actix_web::Error` instead of `http::Error` for `ClientRequestBuilder::body()`
 
+* Added `signed` and `private` `CookieSessionBackend`s
 
-## [1.0.0-beta.3] - 2019-05-04
+* Added `HttpRequest::resource()`, returns current matched resource
 
-### Added
+* Added `ErrorHandlers` middleware
 
-* Add helper function for executing futures `test::block_fn()`
+* Fix router cannot parse Non-ASCII characters in URL #137
 
-### Changed
+* Fix client connection pooling
 
-* Extractor configuration could be registered with `App::data()`
-  or with `Resource::data()` #775
+* Fix long client urls #129
 
-* Route data is unified with app data, `Route::data()` moved to resource
-  level to `Resource::data()`
+* Fix panic on invalid URL characters #130
 
-* CORS handling without headers #702
+* Fix logger request duration calculation #152
 
-* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
+* Fix prefix and static file serving #168
 
-### Fixed
 
-* Fix `NormalizePath` middleware impl #806
+## 0.4.10 (2018-03-20)
 
-### Deleted
+* Use `Error` instead of `InternalError` for `error::ErrorXXXX` methods
 
-* `App::data_factory()` is deleted.
+* Allow to set client request timeout
 
+* Allow to set client websocket handshake timeout
 
-## [1.0.0-beta.2] - 2019-04-24
+* Refactor `TestServer` configuration
 
-### Added
+* Fix server websockets big payloads support
 
-* Add raw services support via `web::service()`
+* Fix http/2 date header generation
 
-* Add helper functions for reading response body `test::read_body()`
 
-* Add support for `remainder match` (i.e "/path/{tail}*")
+## 0.4.9 (2018-03-16)
 
-* Extend `Responder` trait, allow to override status code and headers.
+* Allow to disable http/2 support
 
-* Store visit and login timestamp in the identity cookie #502
+* Wake payload reading task when data is available
 
-### Changed
+* Fix server keep-alive handling
 
-* `.to_async()` handler can return `Responder` type #792
+* Send Query Parameters in client requests #120
 
-### Fixed
+* Move brotli encoding to a feature
 
-* Fix async web::Data factory handling
+* Add option of default handler for `StaticFiles` handler #57
 
+* Add basic client connection pooling
 
-## [1.0.0-beta.1] - 2019-04-20
 
-### Added
+## 0.4.8 (2018-03-12)
 
-* Add helper functions for reading test response body,
- `test::read_response()` and test::read_response_json()`
+* Allow to set read buffer capacity for server request
 
-* Add `.peer_addr()` #744
+* Handle WouldBlock error for socket accept call
 
-* Add `NormalizePath` middleware
 
-### Changed
+## 0.4.7 (2018-03-11)
 
-* Rename `RouterConfig` to `ServiceConfig`
+* Fix panic on unknown content encoding
 
-* Rename `test::call_success` to `test::call_service`
+* Fix connection get closed too early
 
-* Removed `ServiceRequest::from_parts()` as it is unsafe to create from parts.
+* Fix streaming response handling for http/2
 
-* `CookieIdentityPolicy::max_age()` accepts value in seconds
+* Better sleep on error support
 
-### Fixed
 
-* Fixed `TestRequest::app_data()`
+## 0.4.6 (2018-03-10)
 
+* Fix client cookie handling
 
-## [1.0.0-alpha.6] - 2019-04-14
+* Fix json content type detection
 
-### Changed
+* Fix CORS middleware #117
 
-* Allow to use any service as default service.
+* Optimize websockets stream support
 
-* Remove generic type for request payload, always use default.
 
-* Removed `Decompress` middleware. Bytes, String, Json, Form extractors
-  automatically decompress payload.
+## 0.4.5 (2018-03-07)
 
-* Make extractor config type explicit. Add `FromRequest::Config` associated type.
+* Fix compression #103 and #104
 
+* Fix client cookie handling #111
 
-## [1.0.0-alpha.5] - 2019-04-12
+* Non-blocking processing of a `NamedFile`
 
-### Added
+* Enable compression support for `NamedFile`
 
-* Added async io `TestBuffer` for testing.
+* Better support for `NamedFile` type
 
-### Deleted
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
 
-* Removed native-tls support
+* Add native-tls support for client
 
+* Allow client connection timeout to be set #108
 
-## [1.0.0-alpha.4] - 2019-04-08
+* Allow to use std::net::TcpListener for HttpServer
 
-### Added
+* Handle panics in worker threads
 
-* `App::configure()` allow to offload app configuration to different methods
 
-* Added `URLPath` option for logger
+## 0.4.4 (2018-03-04)
 
-* Added `ServiceRequest::app_data()`, returns `Data<T>`
+* Allow to use Arc<Vec<u8>> as response/request body
 
-* Added `ServiceFromRequest::app_data()`, returns `Data<T>`
+* Fix handling of requests with an encoded body with a length > 8192 #93
 
-### Changed
+## 0.4.3 (2018-03-03)
 
-* `FromRequest` trait refactoring
+* Fix request body read bug
 
-* Move multipart support to actix-multipart crate
+* Fix segmentation fault #79
 
-### Fixed
+* Set reuse address before bind #90
 
-* Fix body propagation in Response::from_error. #760
 
+## 0.4.2 (2018-03-02)
 
-## [1.0.0-alpha.3] - 2019-04-02
+* Better naming for websockets implementation
 
-### Changed
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
 
-* Renamed `TestRequest::to_service()` to `TestRequest::to_srv_request()`
+* Add csrf middleware for filter for cross-site request forgery #89
 
-* Renamed `TestRequest::to_response()` to `TestRequest::to_srv_response()`
+* Fix disconnect on idle connections
 
-* Removed `Deref` impls
 
-### Removed
+## 0.4.1 (2018-03-01)
 
-* Removed unused `actix_web::web::md()`
+* Rename `Route::p()` to `Route::filter()`
 
+* Better naming for http codes
 
-## [1.0.0-alpha.2] - 2019-03-29
+* Fix payload parse in situation when socket data is not ready.
 
-### Added
+* Fix Session mutable borrow lifetime #87
 
-* rustls support
 
-### Changed
+## 0.4.0 (2018-02-28)
 
-* use forked cookie
+* Actix 0.5 compatibility
 
-* multipart::Field renamed to MultipartField
+* Fix request json/urlencoded loaders
 
-## [1.0.0-alpha.1] - 2019-03-28
+* Simplify HttpServer type definition
 
-### Changed
+* Added HttpRequest::encoding() method
 
-* Complete architecture re-design.
+* Added HttpRequest::mime_type() method
 
-* Return 405 response if no matching route found within resource #538
+* Added HttpRequest::uri_mut(), allows to modify request uri
+
+* Added StaticFiles::index_file()
+
+* Added http client
+
+* Added websocket client
+
+* Added TestServer::ws(), test websockets client
+
+* Added TestServer http client support
+
+* Allow to override content encoding on application level
+
+
+## 0.3.3 (2018-01-25)
+
+* Stop processing any events after context stop
+
+* Re-enable write back-pressure for h1 connections
+
+* Refactor HttpServer::start_ssl() method
+
+* Upgrade openssl to 0.10
+
+
+## 0.3.2 (2018-01-21)
+
+* Fix HEAD requests handling
+
+* Log request processing errors
+
+* Always enable content encoding if encoding explicitly selected
+
+* Allow multiple Applications on a single server with different state #49
+
+* CORS middleware: allowed_headers is defaulting to None #50
+
+
+## 0.3.1 (2018-01-13)
+
+* Fix directory entry path #47
+
+* Do not enable chunked encoding for HTTP/1.0
+
+* Allow explicitly disable chunked encoding
+
+
+## 0.3.0 (2018-01-12)
+
+* HTTP/2 Support
+
+* Refactor streaming responses
+
+* Refactor error handling
+
+* Asynchronous middlewares
+
+* Refactor logger middleware
+
+* Content compression/decompression (br, gzip, deflate)
+
+* Server multi-threading
+
+* Gracefull shutdown support
+
+
+## 0.2.1 (2017-11-03)
+
+* Allow to start tls server with `HttpServer::serve_tls`
+
+* Export `Frame` enum
+
+* Add conversion impl from `HttpResponse` and `BinaryBody` to a `Frame`
+
+
+## 0.2.0 (2017-10-30)
+
+* Do not use `http::Uri` as it can not parse some valid paths
+
+* Refactor response `Body`
+
+* Refactor `RouteRecognizer` usability
+
+* Refactor `HttpContext::write`
+
+* Refactor `Payload` stream
+
+* Re-use `BinaryBody` for `Frame::Payload`
+
+* Stop http actor on `write_eof`
+
+* Fix disconnection handling.
+
+
+## 0.1.0 (2017-10-23)
+
+* First release

Cargo.toml

@@ -1,138 +1,119 @@
 [package]
 name = "actix-web"
-version = "3.0.0"
+version = "0.6.13"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
-keywords = ["actix", "http", "web", "framework", "async"]
+keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-web/"
 categories = ["network-programming", "asynchronous",
               "web-programming::http-server",
+              "web-programming::http-client",
               "web-programming::websocket"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+build = "build.rs"
 
 [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",
-  "test-server",
-]
-
 [features]
-default = ["compress"]
+default = ["session", "brotli", "flate2-c"]
 
-# content-encoding support
-compress = ["actix-http/compress", "awc/compress"]
-
-# sessions feature
-secure-cookies = ["actix-http/secure-cookies"]
+# tls
+tls = ["native-tls", "tokio-tls"]
 
 # openssl
-openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
+alpn = ["openssl", "tokio-openssl"]
 
-# rustls
-rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
+# sessions feature, session require "ring" crate and c compiler
+session = ["cookie/secure"]
 
-[[example]]
-name = "basic"
-required-features = ["compress"]
+# brotli encoding, requires c compiler
+brotli = ["brotli2"]
 
-[[example]]
-name = "uds"
-required-features = ["compress"]
+# miniz-sys backend for flate2 crate
+flate2-c = ["flate2/miniz-sys"]
 
-[[test]]
-name = "test_server"
-required-features = ["compress"]
+# rust backend for flate2 crate
+flate2-rust = ["flate2/rust_backend"]
+
+[package.metadata.docs.rs]
+features = ["tls", "alpn", "session", "brotli", "flate2-c"]
 
 [dependencies]
-actix-codec = "0.3.0"
-actix-service = "1.0.6"
-actix-utils = "2.0.0"
-actix-router = "0.2.4"
-actix-rt = "1.1.1"
-actix-server = "1.0.0"
-actix-testing = "1.0.0"
-actix-macros = "0.1.0"
-actix-threadpool = "0.3.1"
-actix-tls = "2.0.0"
+actix = "^0.5.8"
 
-actix-web-codegen = "0.3.0"
-actix-http = "2.0.0"
-awc = { version = "2.0.0", default-features = false }
-
-bytes = "0.5.3"
-derive_more = "0.99.2"
-encoding_rs = "0.8"
-futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-fxhash = "0.2.1"
+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"
-socket2 = "0.3"
-pin-project = "0.4.17"
-regex = "1.3"
-serde = { version = "1.0", features = ["derive"] }
+mime_guess = "2.0.0-alpha"
+num_cpus = "1.0"
+percent-encoding = "1.0"
+rand = "0.4"
+regex = "1.0"
+serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.6.1"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
-url = "2.1"
-open-ssl = { package = "openssl", version = "0.10", optional = true }
-rust-tls = { package = "rustls", version = "0.18.0", optional = true }
-tinyvec = { version = "0.3", features = ["alloc"] }
+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"
+slab = "0.4"
+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 = "0.10.0"
-actix-http = { version = "2.0.0-beta.4", features = ["actors"] }
-rand = "0.7"
-env_logger = "0.7"
+env_logger = "0.5"
 serde_derive = "1.0"
-brotli2 = "0.3.2"
-flate2 = "1.0.13"
-criterion = "0.3"
+
+[build-dependencies]
+version_check = "0.1"
 
 [profile.release]
 lto = true
 opt-level = 3
 codegen-units = 1
 
-[patch.crates-io]
-actix-web = { path = "." }
-actix-http = { path = "actix-http" }
-actix-http-test = { path = "test-server" }
-actix-web-codegen = { path = "actix-web-codegen" }
-actix-files = { path = "actix-files" }
-actix-multipart = { path = "actix-multipart" }
-awc = { path = "awc" }
-
-[[example]]
-name = "client"
-required-features = ["rustls"]
-
-[[bench]]
-name = "server"
-harness = false
-
-[[bench]]
-name = "service"
-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 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.md

@@ -1,563 +1,4 @@
-## Unreleased
-
-
-## 3.0.0
-
-* 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::default())`.
-
-* `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
+## Migration from 0.5 to 0.6
 
 * `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
 
@@ -572,12 +13,12 @@
 * `HttpRequest::extensions()` returns read only reference to the request's Extension
   `HttpRequest::extensions_mut()` returns mutable reference.
 
-* Instead of
+* 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,
@@ -609,7 +50,7 @@
   you need to use `use actix_web::ws::WsWriter`
 
 
-## 0.5
+## Migration from 0.4 to 0.5
 
 * `HttpResponseBuilder::body()`, `.finish()`, `.json()`
    methods return `HttpResponse` instead of `Result<HttpResponse>`

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,89 @@
-<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://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg)](https://docs.rs/actix-web)
-[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
-![License](https://img.shields.io/crates/l/actix-web.svg)
-<br />
-[![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) 
-[![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
-[![Download](https://img.shields.io/crates/d/actix-web.svg)](https://crates.io/crates/actix-web)
-[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+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/docs/http2/) 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)
-* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
+* Configurable [request routing](https://actix.rs/docs/url-dispatch/)
+* 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://actix.rs/actix-web/actix_web/client/index.html)
-* Supports [Actix actor framework](https://github.com/actix/actix)
-* Runs on stable Rust 1.42+
+* 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))
+* Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/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/docs/)
+* [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.24 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, Responder};
 
-#[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)>) -> impl Responder {
+    format!("Hello {}! id:{}", info.1, info.0)
 }
 
-#[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/)
-* [Application State](https://github.com/actix/examples/tree/master/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [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-r19).
+* [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](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or
-  [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-web crate is organized under the terms of the Contributor Covenant, the
-maintainers of Actix web, promises to intervene to uphold that code of conduct.
+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,90 +0,0 @@
-# Changes
-
-## [Unreleased] - 2020-xx-xx
-
-## [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,36 +0,0 @@
-[package]
-name = "actix-files"
-version = "0.3.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static files support for actix web."
-readme = "README.md"
-keywords = ["actix", "http", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-files/"
-categories = ["asynchronous", "web-programming::http-server"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_files"
-path = "src/lib.rs"
-
-[dependencies]
-actix-web = { version = "3.0.0", default-features = false }
-actix-http = "2.0.0"
-actix-service = "1.0.6"
-bitflags = "1"
-bytes = "0.5.3"
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-derive_more = "0.99.2"
-log = "0.4"
-mime = "0.3"
-mime_guess = "2.0.1"
-percent-encoding = "2.1"
-v_htmlescape = "0.10"
-
-[dev-dependencies]
-actix-rt = "1.0.0"
-actix-web = { version = "3.0.0", features = ["openssl"] }

actix-files/LICENSE-APACHE

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

actix-files/LICENSE-MIT

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

actix-files/README.md

@@ -1,9 +0,0 @@
-# Static files support for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-files)](https://crates.io/crates/actix-files) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-files/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-files](https://crates.io/crates/actix-files)
-* Minimum supported Rust version: 1.40 or later

actix-files/src/error.rs

@@ -1,42 +0,0 @@
-use actix_web::{http::StatusCode, HttpResponse, 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 error_response(&self) -> HttpResponse {
-        HttpResponse::new(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/named.rs

@@ -1,455 +0,0 @@
-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 bitflags::bitflags;
-use mime_guess::from_path;
-
-use actix_http::body::SizedStream;
-use actix_web::dev::BodyEncoding;
-use actix_web::http::header::{
-    self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
-};
-use actix_web::http::{ContentEncoding, StatusCode};
-use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};
-use futures_util::future::{ready, Ready};
-
-use crate::range::HttpRange;
-use crate::ChunkedReadFile;
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const ETAG = 0b0000_0001;
-        const LAST_MD = 0b0000_0010;
-        const CONTENT_DISPOSITION = 0b0000_0100;
-    }
-}
-
-impl Default for Flags {
-    fn default() -> Self {
-        Flags::all()
-    }
-}
-
-/// A file with an associated name.
-#[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
-    ///
-    /// ```rust
-    /// 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,
-                _ => 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
-    ///
-    /// ```rust
-    /// 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
-    ///
-    /// ```rust
-    /// # 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, and video content types, and `attachment` otherwise, and
-    /// the filename is taken from the path provided in the `open` method
-    /// after converting it to UTF-8 using.
-    /// [to_string_lossy](https://doc.rust-lang.org/std/ffi/struct.OsStr.html#method.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
-    #[inline]
-    pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
-        self.encoding = Some(enc);
-        self
-    }
-
-    #[inline]
-    ///Specifies whether to use ETag or not.
-    ///
-    ///Default is true.
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.flags.set(Flags::ETAG, value);
-        self
-    }
-
-    #[inline]
-    ///Specifies whether to use Last-Modified or not.
-    ///
-    ///Default is true.
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.flags.set(Flags::LAST_MD, 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())
-    }
-
-    pub fn into_response(self, req: &HttpRequest) -> Result<HttpResponse, Error> {
-        if self.status_code != StatusCode::OK {
-            let mut resp = HttpResponse::build(self.status_code);
-            resp.set(header::ContentType(self.content_type.clone()))
-                .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                    res.header(
-                        header::CONTENT_DISPOSITION,
-                        self.content_disposition.to_string(),
-                    );
-                });
-            if let Some(current_encoding) = self.encoding {
-                resp.encoding(current_encoding);
-            }
-            let reader = ChunkedReadFile {
-                size: self.md.len(),
-                offset: 0,
-                file: Some(self.file),
-                fut: None,
-                counter: 0,
-            };
-            return Ok(resp.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.clone().into();
-            let t2: SystemTime = since.clone().into();
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1 > t2,
-                _ => 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.clone().into();
-            let t2: SystemTime = since.clone().into();
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1 <= t2,
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        let mut resp = HttpResponse::build(self.status_code);
-        resp.set(header::ContentType(self.content_type.clone()))
-            .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                res.header(
-                    header::CONTENT_DISPOSITION,
-                    self.content_disposition.to_string(),
-                );
-            });
-        // default compressing
-        if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
-        }
-
-        resp.if_some(last_modified, |lm, resp| {
-            resp.set(header::LastModified(lm));
-        })
-        .if_some(etag, |etag, resp| {
-            resp.set(header::ETag(etag));
-        });
-
-        resp.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(rangesheader) = ranges.to_str() {
-                if let Ok(rangesvec) = HttpRange::parse(rangesheader, length) {
-                    length = rangesvec[0].length;
-                    offset = rangesvec[0].start;
-                    resp.encoding(ContentEncoding::Identity);
-                    resp.header(
-                        header::CONTENT_RANGE,
-                        format!(
-                            "bytes {}-{}/{}",
-                            offset,
-                            offset + length - 1,
-                            self.md.len()
-                        ),
-                    );
-                } else {
-                    resp.header(header::CONTENT_RANGE, format!("bytes */{}", length));
-                    return Ok(resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish());
-                };
-            } else {
-                return Ok(resp.status(StatusCode::BAD_REQUEST).finish());
-            };
-        };
-
-        if precondition_failed {
-            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish());
-        } else if not_modified {
-            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
-        }
-
-        let reader = ChunkedReadFile {
-            offset,
-            size: length,
-            file: Some(self.file),
-            fut: None,
-            counter: 0,
-        };
-
-        if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
-        }
-
-        Ok(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 {
-    type Error = Error;
-    type Future = Ready<Result<HttpResponse, Error>>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        ready(self.into_response(req))
-    }
-}

actix-files/src/range.rs

@@ -1,375 +0,0 @@
-/// HTTP Range header representation.
-#[derive(Debug, Clone, Copy)]
-pub struct HttpRange {
-    pub start: u64,
-    pub length: u64,
-}
-
-static PREFIX: &str = "bytes=";
-const PREFIX_LEN: usize = 6;
-
-impl HttpRange {
-    /// Parses Range HTTP header string as per RFC 2616.
-    ///
-    /// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
-    /// `size` is full size of response (file).
-    pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ()> {
-        if header.is_empty() {
-            return Ok(Vec::new());
-        }
-        if !header.starts_with(PREFIX) {
-            return Err(());
-        }
-
-        let size_sig = size as i64;
-        let mut no_overlap = false;
-
-        let all_ranges: Vec<Option<HttpRange>> = header[PREFIX_LEN..]
-            .split(',')
-            .map(|x| x.trim())
-            .filter(|x| !x.is_empty())
-            .map(|ra| {
-                let mut start_end_iter = ra.split('-');
-
-                let start_str = start_end_iter.next().ok_or(())?.trim();
-                let end_str = start_end_iter.next().ok_or(())?.trim();
-
-                if start_str.is_empty() {
-                    // If no start is specified, end specifies the
-                    // range start relative to the end of the file.
-                    let mut length: i64 = end_str.parse().map_err(|_| ())?;
-
-                    if length > size_sig {
-                        length = size_sig;
-                    }
-
-                    Ok(Some(HttpRange {
-                        start: (size_sig - length) as u64,
-                        length: length as u64,
-                    }))
-                } else {
-                    let start: i64 = start_str.parse().map_err(|_| ())?;
-
-                    if start < 0 {
-                        return Err(());
-                    }
-                    if start >= size_sig {
-                        no_overlap = true;
-                        return Ok(None);
-                    }
-
-                    let length = if end_str.is_empty() {
-                        // If no end is specified, range extends to end of the file.
-                        size_sig - start
-                    } else {
-                        let mut end: i64 = end_str.parse().map_err(|_| ())?;
-
-                        if start > end {
-                            return Err(());
-                        }
-
-                        if end >= size_sig {
-                            end = size_sig - 1;
-                        }
-
-                        end - start + 1
-                    };
-
-                    Ok(Some(HttpRange {
-                        start: start as u64,
-                        length: length as u64,
-                    }))
-                }
-            })
-            .collect::<Result<_, _>>()?;
-
-        let ranges: Vec<HttpRange> = all_ranges.into_iter().filter_map(|x| x).collect();
-
-        if no_overlap && ranges.is_empty() {
-            return Err(());
-        }
-
-        Ok(ranges)
-    }
-}
-
-#[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 {
-                    assert!(
-                        false,
-                        "parse({}, {}) returned error {:?}",
-                        header,
-                        size,
-                        res.unwrap_err()
-                    );
-                }
-            }
-
-            let got = res.unwrap();
-
-            if got.len() != expected.len() {
-                assert!(
-                    false,
-                    "len(parseRange({}, {})) = {}, want {}",
-                    header,
-                    size,
-                    got.len(),
-                    expected.len()
-                );
-                continue;
-            }
-
-            for i in 0..expected.len() {
-                if got[i].start != expected[i].start {
-                    assert!(
-                        false,
-                        "parseRange({}, {})[{}].start = {}, want {}",
-                        header, size, i, got[i].start, expected[i].start
-                    )
-                }
-                if got[i].length != expected[i].length {
-                    assert!(
-                        false,
-                        "parseRange({}, {})[{}].length = {}, want {}",
-                        header, size, i, got[i].length, expected[i].length
-                    )
-                }
-            }
-        }
-    }
-}

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-http/CHANGES.md

@@ -1,416 +0,0 @@
-# Changes
-
-## Unreleased - 2020-xx-xx
-
-
-## 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 calcualtion
-
-### 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
-
-
-## [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 comression
-
-### 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 decomression if chunk size is smaller than 2048.
-
-
-## [0.1.0-alpha.1] - 2019-03-28
-
-* Initial impl

actix-http/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fafhrd91@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-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.
-
-## 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]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

actix-http/Cargo.toml

@@ -1,109 +0,0 @@
-[package]
-name = "actix-http"
-version = "2.0.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix HTTP primitives"
-readme = "README.md"
-keywords = ["actix", "http", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-http/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-
-[package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
-
-[lib]
-name = "actix_http"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# openssl
-openssl = ["actix-tls/openssl", "actix-connect/openssl"]
-
-# rustls support
-rustls = ["actix-tls/rustls", "actix-connect/rustls"]
-
-# enable compressison support
-compress = ["flate2", "brotli2"]
-
-# support for secure cookies
-secure-cookies = ["cookie/secure"]
-
-# support for actix Actor messages
-actors = ["actix"]
-
-[dependencies]
-actix-service = "1.0.6"
-actix-codec = "0.3.0"
-actix-connect = "2.0.0"
-actix-utils = "2.0.0"
-actix-rt = "1.0.0"
-actix-threadpool = "0.3.1"
-actix-tls = { version = "2.0.0", optional = true }
-actix = { version = "0.10.0", optional = true }
-
-base64 = "0.12"
-bitflags = "1.2"
-bytes = "0.5.3"
-cookie = { version = "0.14.1", features = ["percent-encode"] }
-copyless = "0.1.4"
-derive_more = "0.99.2"
-either = "1.5.3"
-encoding_rs = "0.8"
-futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-fxhash = "0.2.1"
-h2 = "0.2.1"
-http = "0.2.0"
-httparse = "1.3"
-indexmap = "1.3"
-itoa = "0.4"
-lazy_static = "1.4"
-language-tags = "0.2"
-log = "0.4"
-mime = "0.3"
-percent-encoding = "2.1"
-pin-project = "0.4.17"
-rand = "0.7"
-regex = "1.3"
-serde = "1.0"
-serde_json = "1.0"
-sha-1 = "0.9"
-slab = "0.4"
-serde_urlencoded = "0.6.1"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
-
-# compression
-brotli2 = { version="0.3.2", optional = true }
-flate2 = { version = "1.0.13", optional = true }
-
-[dev-dependencies]
-actix-server = "1.0.1"
-actix-connect = { version = "2.0.0", features = ["openssl"] }
-actix-http-test = { version = "2.0.0", features = ["openssl"] }
-actix-tls = { version = "2.0.0", features = ["openssl"] }
-criterion = "0.3"
-env_logger = "0.7"
-serde_derive = "1.0"
-open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.18", package = "rustls" }
-
-[[bench]]
-name = "content-length"
-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,61 +0,0 @@
-# Actix http [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)  [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-http)](https://crates.io/crates/actix-http) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Actix http
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-http/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-http](https://crates.io/crates/actix-http)
-* Minimum supported Rust version: 1.40 or later
-
-## Example
-
-```rust
-// see examples/framed_hello.rs for complete list of used crates.
-use std::{env, io};
-
-use actix_http::{HttpService, Response};
-use actix_server::Server;
-use futures::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/content-length.rs

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

actix-http/benches/status-line.rs

@@ -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,137 +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: &'static [u8] = b"\
-GET / HTTP/1.0\r\n\
-Host: example.com\r\n\
-Cookie: session=60; user_id=1\r\n\r\n";
-
-const REQ: &'static [u8] = b"\
-GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n\
-Host: www.kittyhell.com\r\n\
-User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\n\
-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 {
-        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/examples/echo.rs

@@ -1,37 +0,0 @@
-use std::{env, io};
-
-use actix_http::{Error, HttpService, Request, Response};
-use actix_server::Server;
-use bytes::BytesMut;
-use futures_util::StreamExt;
-use http::header::HeaderValue;
-use log::info;
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
-
-    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?);
-                    }
-
-                    info!("request body: {:?}", body);
-                    Ok::<_, Error>(
-                        Response::Ok()
-                            .header("x-head", HeaderValue::from_static("dummy value!"))
-                            .body(body),
-                    )
-                })
-                .tcp()
-        })?
-        .run()
-        .await
-}

actix-http/examples/echo2.rs

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

actix-http/examples/hello-world.rs

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

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.rs

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

actix-http/src/builder.rs

@@ -1,251 +0,0 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::{fmt, net};
-
-use actix_codec::Framed;
-use actix_service::{IntoServiceFactory, Service, ServiceFactory};
-
-use crate::body::MessageBody;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::Error;
-use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
-use crate::h2::H2Service;
-use crate::helpers::{Data, DataFactory};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpService;
-
-/// A http service builder
-///
-/// This type can be used to construct an instance of `http service` through a
-/// builder-like pattern.
-pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
-    keep_alive: KeepAlive,
-    client_timeout: u64,
-    client_disconnect: u64,
-    secure: bool,
-    local_addr: Option<net::SocketAddr>,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, S)>,
-}
-
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service>::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: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service>::Future: 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
-{
-    /// Set server keep-alive setting.
-    ///
-    /// 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>,
-        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-        <X1::Service as Service>::Future: 'static,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            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: self.on_connect,
-            _t: 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>,
-        U1: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<T, Codec>),
-            Response = (),
-        >,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-        <U1::Service as Service>::Future: 'static,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            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: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on-connect callback.
-    ///
-    /// It get called once per connection and result of the call
-    /// get stored to the request's extensions.
-    pub fn on_connect<F, I>(mut self, f: F) -> Self
-    where
-        F: Fn(&T) -> I + 'static,
-        I: Clone + 'static,
-    {
-        self.on_connect = Some(Rc::new(move |io| Box::new(Data(f(io)))));
-        self
-    }
-
-    /// Finish service configuration and create *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>,
-        S::Error: Into<Error>,
-        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(self.on_connect)
-    }
-
-    /// Finish service configuration and create *http service* for HTTP/2 protocol.
-    pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
-    where
-        B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-    {
-        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(self.on_connect)
-    }
-
-    /// Finish service configuration and create `HttpService` instance.
-    pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
-    where
-        B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-    {
-        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(self.on_connect)
-    }
-}

actix-http/src/client/config.rs

@@ -1,39 +0,0 @@
-use std::time::Duration;
-
-// These values are taken from hyper/src/proto/h2/client.rs
-const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
-const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
-
-/// Connector configuration
-#[derive(Clone)]
-pub(crate) struct ConnectorConfig {
-    pub(crate) timeout: Duration,
-    pub(crate) 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,
-}
-
-impl Default for ConnectorConfig {
-    fn default() -> Self {
-        Self {
-            timeout: Duration::from_secs(1),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Some(Duration::from_millis(3000)),
-            limit: 100,
-            conn_window_size: DEFAULT_H2_CONN_WINDOW,
-            stream_window_size: DEFAULT_H2_STREAM_WINDOW,
-        }
-    }
-}
-
-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,291 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, io, mem, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::{Buf, Bytes};
-use futures_util::future::{err, Either, FutureExt, LocalBoxFuture, Ready};
-use h2::client::SendRequest;
-use pin_project::pin_project;
-
-use crate::body::MessageBody;
-use crate::h1::ClientCodec;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-
-use super::error::SendRequestError;
-use super::pool::{Acquired, Protocol};
-use super::{h1proto, h2proto};
-
-pub(crate) enum ConnectionType<Io> {
-    H1(Io),
-    H2(SendRequest<Bytes>),
-}
-
-pub trait Connection {
-    type Io: AsyncRead + AsyncWrite + Unpin;
-    type Future: Future<Output = Result<(ResponseHead, Payload), SendRequestError>>;
-
-    fn protocol(&self) -> Protocol;
-
-    /// Send request and body
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
-        self,
-        head: H,
-        body: B,
-    ) -> Self::Future;
-
-    type TunnelFuture: Future<
-        Output = Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture;
-}
-
-pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
-    /// Close connection
-    fn close(self: Pin<&mut Self>);
-
-    /// Release connection to the connection pool
-    fn release(self: Pin<&mut Self>);
-}
-
-#[doc(hidden)]
-/// HTTP client connection
-pub struct IoConnection<T> {
-    io: Option<ConnectionType<T>>,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-}
-
-impl<T> fmt::Debug for IoConnection<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.io {
-            Some(ConnectionType::H1(ref io)) => write!(f, "H1Connection({:?})", io),
-            Some(ConnectionType::H2(_)) => write!(f, "H2Connection"),
-            None => write!(f, "Connection(Empty)"),
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
-    pub(crate) fn new(
-        io: ConnectionType<T>,
-        created: time::Instant,
-        pool: Option<Acquired<T>>,
-    ) -> Self {
-        IoConnection {
-            pool,
-            created,
-            io: Some(io),
-        }
-    }
-
-    pub(crate) fn into_inner(self) -> (ConnectionType<T>, time::Instant) {
-        (self.io.unwrap(), self.created)
-    }
-}
-
-impl<T> Connection for IoConnection<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    type Io = T;
-    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
-
-    fn protocol(&self) -> Protocol {
-        match self.io {
-            Some(ConnectionType::H1(_)) => Protocol::Http1,
-            Some(ConnectionType::H2(_)) => Protocol::Http2,
-            None => Protocol::Http1,
-        }
-    }
-
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
-        mut self,
-        head: H,
-        body: B,
-    ) -> Self::Future {
-        match self.io.take().unwrap() {
-            ConnectionType::H1(io) => {
-                h1proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
-            }
-            ConnectionType::H2(io) => {
-                h2proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
-            }
-        }
-    }
-
-    type TunnelFuture = Either<
-        LocalBoxFuture<
-            'static,
-            Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-        >,
-        Ready<Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>>,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(mut self, head: H) -> Self::TunnelFuture {
-        match self.io.take().unwrap() {
-            ConnectionType::H1(io) => {
-                Either::Left(h1proto::open_tunnel(io, head.into()).boxed_local())
-            }
-            ConnectionType::H2(io) => {
-                if let Some(mut pool) = self.pool.take() {
-                    pool.release(IoConnection::new(
-                        ConnectionType::H2(io),
-                        self.created,
-                        None,
-                    ));
-                }
-                Either::Right(err(SendRequestError::TunnelNotSupported))
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub(crate) enum EitherConnection<A, B> {
-    A(IoConnection<A>),
-    B(IoConnection<B>),
-}
-
-impl<A, B> Connection for EitherConnection<A, B>
-where
-    A: AsyncRead + AsyncWrite + Unpin + 'static,
-    B: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    type Io = EitherIo<A, B>;
-    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
-
-    fn protocol(&self) -> Protocol {
-        match self {
-            EitherConnection::A(con) => con.protocol(),
-            EitherConnection::B(con) => con.protocol(),
-        }
-    }
-
-    fn send_request<RB: MessageBody + 'static, H: Into<RequestHeadType>>(
-        self,
-        head: H,
-        body: RB,
-    ) -> Self::Future {
-        match self {
-            EitherConnection::A(con) => con.send_request(head, body),
-            EitherConnection::B(con) => con.send_request(head, body),
-        }
-    }
-
-    type TunnelFuture = LocalBoxFuture<
-        'static,
-        Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture {
-        match self {
-            EitherConnection::A(con) => con
-                .open_tunnel(head)
-                .map(|res| {
-                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::A)))
-                })
-                .boxed_local(),
-            EitherConnection::B(con) => con
-                .open_tunnel(head)
-                .map(|res| {
-                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::B)))
-                })
-                .boxed_local(),
-        }
-    }
-}
-
-#[pin_project(project = EitherIoProj)]
-pub enum EitherIo<A, B> {
-    A(#[pin] A),
-    B(#[pin] B),
-}
-
-impl<A, B> AsyncRead for EitherIo<A, B>
-where
-    A: AsyncRead,
-    B: AsyncRead,
-{
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_read(cx, buf),
-            EitherIoProj::B(val) => val.poll_read(cx, buf),
-        }
-    }
-
-    unsafe fn prepare_uninitialized_buffer(
-        &self,
-        buf: &mut [mem::MaybeUninit<u8>],
-    ) -> bool {
-        match self {
-            EitherIo::A(ref val) => val.prepare_uninitialized_buffer(buf),
-            EitherIo::B(ref val) => val.prepare_uninitialized_buffer(buf),
-        }
-    }
-}
-
-impl<A, B> AsyncWrite for EitherIo<A, B>
-where
-    A: AsyncWrite,
-    B: AsyncWrite,
-{
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_write(cx, buf),
-            EitherIoProj::B(val) => val.poll_write(cx, buf),
-        }
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_flush(cx),
-            EitherIoProj::B(val) => val.poll_flush(cx),
-        }
-    }
-
-    fn poll_shutdown(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<()>> {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_shutdown(cx),
-            EitherIoProj::B(val) => val.poll_shutdown(cx),
-        }
-    }
-
-    fn poll_write_buf<U: Buf>(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut U,
-    ) -> Poll<Result<usize, io::Error>>
-    where
-        Self: Sized,
-    {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_write_buf(cx, buf),
-            EitherIoProj::B(val) => val.poll_write_buf(cx, buf),
-        }
-    }
-}

actix-http/src/client/connector.rs

@@ -1,547 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::time::Duration;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_connect::{
-    default_connector, Connect as TcpConnect, Connection as TcpConnection,
-};
-use actix_rt::net::TcpStream;
-use actix_service::{apply_fn, Service};
-use actix_utils::timeout::{TimeoutError, TimeoutService};
-use http::Uri;
-
-use super::config::ConnectorConfig;
-use super::connection::Connection;
-use super::error::ConnectError;
-use super::pool::{ConnectionPool, Protocol};
-use super::Connect;
-
-#[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::SslConnector as OpensslConnector;
-
-#[cfg(feature = "rustls")]
-use actix_connect::ssl::rustls::ClientConfig;
-#[cfg(feature = "rustls")]
-use std::sync::Arc;
-
-#[cfg(any(feature = "openssl", feature = "rustls"))]
-enum SslConnector {
-    #[cfg(feature = "openssl")]
-    Openssl(OpensslConnector),
-    #[cfg(feature = "rustls")]
-    Rustls(Arc<ClientConfig>),
-}
-#[cfg(not(any(feature = "openssl", feature = "rustls")))]
-type SslConnector = ();
-
-/// Manages http client network connectivity
-/// The `Connector` type uses a builder-like combinator pattern for service
-/// construction that finishes by calling the `.finish()` method.
-///
-/// ```rust,ignore
-/// use std::time::Duration;
-/// use actix_http::client::Connector;
-///
-/// let connector = Connector::new()
-///      .timeout(Duration::from_secs(5))
-///      .finish();
-/// ```
-pub struct Connector<T, U> {
-    connector: T,
-    config: ConnectorConfig,
-    #[allow(dead_code)]
-    ssl: SslConnector,
-    _t: PhantomData<U>,
-}
-
-trait Io: AsyncRead + AsyncWrite + Unpin {}
-impl<T: AsyncRead + AsyncWrite + Unpin> Io for T {}
-
-impl Connector<(), ()> {
-    #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
-    pub fn new() -> Connector<
-        impl Service<
-                Request = TcpConnect<Uri>,
-                Response = TcpConnection<Uri, TcpStream>,
-                Error = actix_connect::ConnectError,
-            > + Clone,
-        TcpStream,
-    > {
-        Connector {
-            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
-            connector: default_connector(),
-            config: ConnectorConfig::default(),
-            _t: PhantomData,
-        }
-    }
-
-    // Build Ssl connector with openssl, based on supplied alpn protocols
-    #[cfg(feature = "openssl")]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        use actix_connect::ssl::openssl::SslMethod;
-        use bytes::{BufMut, BytesMut};
-
-        let mut alpn = BytesMut::with_capacity(20);
-        for proto in protocols.iter() {
-            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::rustls::TLS_SERVER_ROOTS);
-        SslConnector::Rustls(Arc::new(config))
-    }
-
-    // ssl turned off, provides empty ssl connector
-    #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-    fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {}
-}
-
-impl<T, U> Connector<T, U> {
-    /// Use custom connector.
-    pub fn connector<T1, U1>(self, connector: T1) -> Connector<T1, U1>
-    where
-        U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
-        T1: Service<
-                Request = TcpConnect<Uri>,
-                Response = TcpConnection<Uri, U1>,
-                Error = actix_connect::ConnectError,
-            > + Clone,
-    {
-        Connector {
-            connector,
-            config: self.config,
-            ssl: self.ssl,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, U> Connector<T, U>
-where
-    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
-    T: Service<
-            Request = TcpConnect<Uri>,
-            Response = TcpConnection<Uri, U>,
-            Error = actix_connect::ConnectError,
-        > + Clone
-        + 'static,
-{
-    /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
-    /// Set to 1 second by default.
-    pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.config.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")]
-    pub fn rustls(mut self, connector: Arc<ClientConfig>) -> Self {
-        self.ssl = SslConnector::Rustls(connector);
-        self
-    }
-
-    /// Maximum supported http major version
-    /// Supported versions http/1.1, 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
-    }
-
-    /// Finish configuration process and create connector service.
-    /// The Connector builder always concludes by calling `finish()` last in
-    /// its combinator chain.
-    pub fn finish(
-        self,
-    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-           + Clone {
-        #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-        {
-            let connector = TimeoutService::new(
-                self.config.timeout,
-                apply_fn(self.connector, |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            connect_impl::InnerConnector {
-                tcp_pool: ConnectionPool::new(
-                    connector,
-                    self.config.no_disconnect_timeout(),
-                ),
-            }
-        }
-        #[cfg(any(feature = "openssl", feature = "rustls"))]
-        {
-            const H2: &[u8] = b"h2";
-            #[cfg(feature = "openssl")]
-            use actix_connect::ssl::openssl::OpensslConnector;
-            #[cfg(feature = "rustls")]
-            use actix_connect::ssl::rustls::{RustlsConnector, Session};
-            use actix_service::{boxed::service, pipeline};
-
-            let ssl_service = TimeoutService::new(
-                self.config.timeout,
-                pipeline(
-                    apply_fn(self.connector.clone(), |msg: Connect, srv| {
-                        srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                    })
-                    .map_err(ConnectError::from),
-                )
-                .and_then(match self.ssl {
-                    #[cfg(feature = "openssl")]
-                    SslConnector::Openssl(ssl) => service(
-                        OpensslConnector::service(ssl)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .ssl()
-                                    .selected_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
-                                } else {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
-                                }
-                            })
-                            .map_err(ConnectError::from),
-                    ),
-                    #[cfg(feature = "rustls")]
-                    SslConnector::Rustls(ssl) => service(
-                        RustlsConnector::service(ssl)
-                            .map_err(ConnectError::from)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .get_ref()
-                                    .1
-                                    .get_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
-                                } else {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
-                                }
-                            }),
-                    ),
-                }),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            let tcp_service = TimeoutService::new(
-                self.config.timeout,
-                apply_fn(self.connector, |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            connect_impl::InnerConnector {
-                tcp_pool: ConnectionPool::new(
-                    tcp_service,
-                    self.config.no_disconnect_timeout(),
-                ),
-                ssl_pool: ConnectionPool::new(ssl_service, self.config),
-            }
-        }
-    }
-}
-
-#[cfg(not(any(feature = "openssl", feature = "rustls")))]
-mod connect_impl {
-    use std::task::{Context, Poll};
-
-    use futures_util::future::{err, Either, Ready};
-
-    use super::*;
-    use crate::client::connection::IoConnection;
-
-    pub(crate) struct InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        pub(crate) tcp_pool: ConnectionPool<T, Io>,
-    }
-
-    impl<T, Io> Clone for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-            }
-        }
-    }
-
-    impl<T, Io> Service for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        type Request = Connect;
-        type Response = IoConnection<Io>;
-        type Error = ConnectError;
-        type Future = Either<
-            <ConnectionPool<T, Io> as Service>::Future,
-            Ready<Result<IoConnection<Io>, ConnectError>>,
-        >;
-
-        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&mut self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => {
-                    Either::Right(err(ConnectError::SslIsNotSupported))
-                }
-                _ => Either::Left(self.tcp_pool.call(req)),
-            }
-        }
-    }
-}
-
-#[cfg(any(feature = "openssl", feature = "rustls"))]
-mod connect_impl {
-    use std::future::Future;
-    use std::marker::PhantomData;
-    use std::pin::Pin;
-    use std::task::{Context, Poll};
-
-    use futures_core::ready;
-    use futures_util::future::Either;
-
-    use super::*;
-    use crate::client::connection::EitherConnection;
-
-    pub(crate) struct InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>,
-    {
-        pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
-        pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
-    }
-
-    impl<T1, T2, Io1, Io2> Clone for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-                ssl_pool: self.ssl_pool.clone(),
-            }
-        }
-    }
-
-    impl<T1, T2, Io1, Io2> Service for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        type Request = Connect;
-        type Response = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-        type Future = Either<
-            InnerConnectorResponseA<T1, Io1, Io2>,
-            InnerConnectorResponseB<T2, Io1, Io2>,
-        >;
-
-        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&mut self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => Either::Right(InnerConnectorResponseB {
-                    fut: self.ssl_pool.call(req),
-                    _t: PhantomData,
-                }),
-                _ => Either::Left(InnerConnectorResponseA {
-                    fut: self.tcp_pool.call(req),
-                    _t: PhantomData,
-                }),
-            }
-        }
-    }
-
-    #[pin_project::pin_project]
-    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io1> as Service>::Future,
-        _t: PhantomData<Io2>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
-    where
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
-
-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::A),
-            )
-        }
-    }
-
-    #[pin_project::pin_project]
-    pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
-    where
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io2> as Service>::Future,
-        _t: PhantomData<Io1>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
-    where
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
-
-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::B),
-            )
-        }
-    }
-}

actix-http/src/client/error.rs

@@ -1,157 +0,0 @@
-use std::io;
-
-use actix_connect::resolver::ResolveError;
-use derive_more::{Display, From};
-
-#[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::{HandshakeError, SslError};
-
-use crate::error::{Error, ParseError, ResponseError};
-use crate::http::{Error as HttpError, StatusCode};
-
-/// A set of errors that can occur while connecting to an HTTP host
-#[derive(Debug, Display, From)]
-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),
-
-    /// SSL Handshake error
-    #[cfg(feature = "openssl")]
-    #[display(fmt = "{}", _0)]
-    SslHandshakeError(String),
-
-    /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolveError),
-
-    /// 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_connect::ConnectError> for ConnectError {
-    fn from(err: actix_connect::ConnectError) -> ConnectError {
-        match err {
-            actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
-            actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
-            actix_connect::ConnectError::InvalidInput => panic!(),
-            actix_connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
-        }
-    }
-}
-
-#[cfg(feature = "openssl")]
-impl<T: std::fmt::Debug> From<HandshakeError<T>> for ConnectError {
-    fn from(err: HandshakeError<T>) -> ConnectError {
-        ConnectError::SslHandshakeError(format!("{:?}", err))
-    }
-}
-
-#[derive(Debug, Display, From)]
-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)]
-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 http2 connection
-    #[display(fmt = "Tunnels are not supported for http2 connection")]
-    TunnelNotSupported,
-    /// Error sending request body
-    Body(Error),
-}
-
-impl std::error::Error for SendRequestError {}
-
-/// Convert `SendRequestError` to a server `Response`
-impl ResponseError for SendRequestError {
-    fn status_code(&self) -> StatusCode {
-        match *self {
-            SendRequestError::Connect(ConnectError::Timeout) => {
-                StatusCode::GATEWAY_TIMEOUT
-            }
-            SendRequestError::Connect(_) => StatusCode::BAD_REQUEST,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
-        }
-    }
-}
-
-/// A set of errors that can occur during freezing a request
-#[derive(Debug, Display, From)]
-pub enum FreezeRequestError {
-    /// Invalid URL
-    #[display(fmt = "Invalid URL: {}", _0)]
-    Url(InvalidUrl),
-    /// Http error
-    #[display(fmt = "{}", _0)]
-    Http(HttpError),
-}
-
-impl std::error::Error for FreezeRequestError {}
-
-impl From<FreezeRequestError> for SendRequestError {
-    fn from(e: FreezeRequestError) -> Self {
-        match e {
-            FreezeRequestError::Url(e) => e.into(),
-            FreezeRequestError::Http(e) => e.into(),
-        }
-    }
-}

actix-http/src/client/h1proto.rs

@@ -1,298 +0,0 @@
-use std::io::Write;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{io, mem, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::buf::BufMutExt;
-use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
-use futures_util::future::poll_fn;
-use futures_util::{pin_mut, SinkExt, StreamExt};
-
-use crate::error::PayloadError;
-use crate::h1;
-use crate::header::HeaderMap;
-use crate::http::header::{IntoHeaderValue, HOST};
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::{Payload, PayloadStream};
-
-use super::connection::{ConnectionLifetime, ConnectionType, IoConnection};
-use super::error::{ConnectError, SendRequestError};
-use super::pool::Acquired;
-use crate::body::{BodySize, MessageBody};
-
-pub(crate) async fn send_request<T, B>(
-    io: T,
-    mut head: RequestHeadType,
-    body: B,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-) -> Result<(ResponseHead, Payload), SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    B: MessageBody,
-{
-    // 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();
-
-            let _ = match head.as_ref().uri.port_u16() {
-                None | Some(80) | Some(443) => write!(wrt, "{}", host),
-                Some(port) => write!(wrt, "{}:{}", host, port),
-            };
-
-            match wrt.get_mut().split().freeze().try_into() {
-                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),
-            }
-        }
-    }
-
-    let io = H1Connection {
-        created,
-        pool,
-        io: Some(io),
-    };
-
-    // create Framed and send request
-    let mut framed_inner = Framed::new(io, h1::ClientCodec::default());
-    framed_inner.send((head, body.size()).into()).await?;
-
-    // send request body
-    match body.size() {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => (),
-        _ => send_body(body, Pin::new(&mut framed_inner)).await?,
-    };
-
-    // read response and init read body
-    let res = Pin::new(&mut framed_inner).into_future().await;
-    let (head, framed) = if let (Some(result), framed) = res {
-        let item = result.map_err(SendRequestError::from)?;
-        (item, framed)
-    } else {
-        return Err(SendRequestError::from(ConnectError::Disconnected));
-    };
-
-    match framed.codec_ref().message_type() {
-        h1::MessageType::None => {
-            let force_close = !framed.codec_ref().keepalive();
-            release_connection(framed, force_close);
-            Ok((head, Payload::None))
-        }
-        _ => {
-            let pl: PayloadStream = PlStream::new(framed_inner).boxed_local();
-            Ok((head, pl.into()))
-        }
-    }
-}
-
-pub(crate) async fn open_tunnel<T>(
-    io: T,
-    head: RequestHeadType,
-) -> Result<(ResponseHead, Framed<T, h1::ClientCodec>), SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    // create Framed and send request
-    let mut framed = Framed::new(io, h1::ClientCodec::default());
-    framed.send((head, BodySize::None).into()).await?;
-
-    // read response
-    if let (Some(result), framed) = framed.into_future().await {
-        let head = result.map_err(SendRequestError::from)?;
-        Ok((head, framed))
-    } else {
-        Err(SendRequestError::from(ConnectError::Disconnected))
-    }
-}
-
-/// send request body to the peer
-pub(crate) async fn send_body<T, B>(
-    body: B,
-    mut framed: Pin<&mut Framed<T, h1::ClientCodec>>,
-) -> Result<(), SendRequestError>
-where
-    T: ConnectionLifetime + Unpin,
-    B: MessageBody,
-{
-    pin_mut!(body);
-
-    let mut eof = false;
-    while !eof {
-        while !eof && !framed.as_ref().is_write_buf_full() {
-            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(result) => {
-                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
-                }
-                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?;
-        }
-    }
-
-    SinkExt::flush(Pin::into_inner(framed)).await?;
-    Ok(())
-}
-
-#[doc(hidden)]
-/// HTTP client connection
-pub struct H1Connection<T> {
-    /// T should be `Unpin`
-    io: Option<T>,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-}
-
-impl<T> ConnectionLifetime for H1Connection<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    /// Close connection
-    fn close(mut self: Pin<&mut Self>) {
-        if let Some(mut pool) = self.pool.take() {
-            if let Some(io) = self.io.take() {
-                pool.close(IoConnection::new(
-                    ConnectionType::H1(io),
-                    self.created,
-                    None,
-                ));
-            }
-        }
-    }
-
-    /// Release this connection to the connection pool
-    fn release(mut self: Pin<&mut Self>) {
-        if let Some(mut pool) = self.pool.take() {
-            if let Some(io) = self.io.take() {
-                pool.release(IoConnection::new(
-                    ConnectionType::H1(io),
-                    self.created,
-                    None,
-                ));
-            }
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncRead for H1Connection<T> {
-    unsafe fn prepare_uninitialized_buffer(
-        &self,
-        buf: &mut [mem::MaybeUninit<u8>],
-    ) -> bool {
-        self.io.as_ref().unwrap().prepare_uninitialized_buffer(buf)
-    }
-
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.io.as_mut().unwrap()).poll_read(cx, buf)
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncWrite for H1Connection<T> {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.io.as_mut().unwrap()).poll_write(cx, buf)
-    }
-
-    fn poll_flush(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(self.io.as_mut().unwrap()).poll_flush(cx)
-    }
-
-    fn poll_shutdown(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), io::Error>> {
-        Pin::new(self.io.as_mut().unwrap()).poll_shutdown(cx)
-    }
-}
-
-#[pin_project::pin_project]
-pub(crate) struct PlStream<Io> {
-    #[pin]
-    framed: Option<Framed<Io, h1::ClientPayloadCodec>>,
-}
-
-impl<Io: ConnectionLifetime> PlStream<Io> {
-    fn new(framed: Framed<Io, h1::ClientCodec>) -> Self {
-        let framed = framed.into_map_codec(|codec| codec.into_payload_codec());
-
-        PlStream {
-            framed: Some(framed),
-        }
-    }
-}
-
-impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let mut this = self.project();
-
-        match this.framed.as_mut().as_pin_mut().unwrap().next_item(cx)? {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(Some(chunk)) => {
-                if let Some(chunk) = chunk {
-                    Poll::Ready(Some(Ok(chunk)))
-                } else {
-                    let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                    let force_close = !framed.codec_ref().keepalive();
-                    release_connection(framed, force_close);
-                    Poll::Ready(None)
-                }
-            }
-            Poll::Ready(None) => Poll::Ready(None),
-        }
-    }
-}
-
-fn release_connection<T, U>(framed: Pin<&mut Framed<T, U>>, force_close: bool)
-where
-    T: ConnectionLifetime,
-{
-    if !force_close && framed.is_read_buf_empty() && framed.is_write_buf_empty() {
-        framed.io_pin().release()
-    } else {
-        framed.io_pin().close()
-    }
-}

actix-http/src/client/h2proto.rs

@@ -1,203 +0,0 @@
-use std::convert::TryFrom;
-use std::future::Future;
-use std::time;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use bytes::Bytes;
-use futures_util::future::poll_fn;
-use futures_util::pin_mut;
-use h2::{
-    client::{Builder, Connection, SendRequest},
-    SendStream,
-};
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
-use http::{request::Request, Method, Version};
-
-use crate::body::{BodySize, MessageBody};
-use crate::header::HeaderMap;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-
-use super::config::ConnectorConfig;
-use super::connection::{ConnectionType, IoConnection};
-use super::error::SendRequestError;
-use super::pool::Acquired;
-
-pub(crate) async fn send_request<T, B>(
-    mut io: SendRequest<Bytes>,
-    head: RequestHeadType,
-    body: B,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-) -> Result<(ResponseHead, Payload), SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    B: MessageBody,
-{
-    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) => req.headers_mut().insert(
-            CONTENT_LENGTH,
-            HeaderValue::try_from(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 {
-            CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
-            CONTENT_LENGTH if skip_len => continue,
-            // DATE => has_date = true,
-            _ => (),
-        }
-        req.headers_mut().append(key, value.clone());
-    }
-
-    let res = poll_fn(|cx| io.poll_ready(cx)).await;
-    if let Err(e) = res {
-        release(io, pool, created, e.is_io());
-        return Err(SendRequestError::from(e));
-    }
-
-    let resp = match io.send_request(req, eof) {
-        Ok((fut, send)) => {
-            release(io, pool, created, false);
-
-            if !eof {
-                send_body(body, send).await?;
-            }
-            fut.await.map_err(SendRequestError::from)?
-        }
-        Err(e) => {
-            release(io, pool, created, 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: MessageBody>(
-    body: B,
-    mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError> {
-    let mut buf = None;
-    pin_mut!(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()),
-                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());
-                } else {
-                    if !b.is_empty() {
-                        send.reserve_capacity(b.len());
-                    } else {
-                        buf = None;
-                    }
-                    continue;
-                }
-            }
-            Some(Err(e)) => return Err(e.into()),
-        }
-    }
-}
-
-// release SendRequest object
-fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
-    io: SendRequest<Bytes>,
-    pool: Option<Acquired<T>>,
-    created: time::Instant,
-    close: bool,
-) {
-    if let Some(mut pool) = pool {
-        if close {
-            pool.close(IoConnection::new(ConnectionType::H2(io), created, None));
-        } else {
-            pool.release(IoConnection::new(ConnectionType::H2(io), created, None));
-        }
-    }
-}
-
-pub(crate) fn handshake<Io>(
-    io: Io,
-    config: &ConnectorConfig,
-) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    let mut builder = Builder::new();
-    builder
-        .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,21 +0,0 @@
-//! Http client api
-use http::Uri;
-
-mod config;
-mod connection;
-mod connector;
-mod error;
-mod h1proto;
-mod h2proto;
-mod pool;
-
-pub use self::connection::Connection;
-pub use self::connector::Connector;
-pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
-pub use self::pool::Protocol;
-
-#[derive(Clone)]
-pub struct Connect {
-    pub uri: Uri,
-    pub addr: Option<std::net::SocketAddr>,
-}

actix-http/src/client/pool.rs

@@ -1,644 +0,0 @@
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::time::{Duration, Instant};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{delay_for, Delay};
-use actix_service::Service;
-use actix_utils::{oneshot, task::LocalWaker};
-use bytes::Bytes;
-use futures_util::future::{poll_fn, FutureExt, LocalBoxFuture};
-use fxhash::FxHashMap;
-use h2::client::{Connection, SendRequest};
-use http::uri::Authority;
-use indexmap::IndexSet;
-use pin_project::pin_project;
-use slab::Slab;
-
-use super::config::ConnectorConfig;
-use super::connection::{ConnectionType, IoConnection};
-use super::error::ConnectError;
-use super::h2proto::handshake;
-use super::Connect;
-
-#[derive(Clone, Copy, PartialEq)]
-/// Protocol version
-pub enum Protocol {
-    Http1,
-    Http2,
-}
-
-#[derive(Hash, Eq, PartialEq, Clone, Debug)]
-pub(crate) struct Key {
-    authority: Authority,
-}
-
-impl From<Authority> for Key {
-    fn from(authority: Authority) -> Key {
-        Key { authority }
-    }
-}
-
-/// Connections pool
-pub(crate) struct ConnectionPool<T, Io: 'static>(Rc<RefCell<T>>, Rc<RefCell<Inner<Io>>>);
-
-impl<T, Io> ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + 'static,
-{
-    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
-        let connector_rc = Rc::new(RefCell::new(connector));
-        let inner_rc = Rc::new(RefCell::new(Inner {
-            config,
-            acquired: 0,
-            waiters: Slab::new(),
-            waiters_queue: IndexSet::new(),
-            available: FxHashMap::default(),
-            waker: LocalWaker::new(),
-        }));
-
-        // start support future
-        actix_rt::spawn(ConnectorPoolSupport {
-            connector: Rc::clone(&connector_rc),
-            inner: Rc::clone(&inner_rc),
-        });
-
-        ConnectionPool(connector_rc, inner_rc)
-    }
-}
-
-impl<T, Io> Clone for ConnectionPool<T, Io>
-where
-    Io: 'static,
-{
-    fn clone(&self) -> Self {
-        ConnectionPool(self.0.clone(), self.1.clone())
-    }
-}
-
-impl<T, Io> Drop for ConnectionPool<T, Io> {
-    fn drop(&mut self) {
-        // wake up the ConnectorPoolSupport when dropping so it can exit properly.
-        self.1.borrow().waker.wake();
-    }
-}
-
-impl<T, Io> Service for ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + 'static,
-{
-    type Request = Connect;
-    type Response = IoConnection<Io>;
-    type Error = ConnectError;
-    type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.poll_ready(cx)
-    }
-
-    fn call(&mut self, req: Connect) -> Self::Future {
-        let mut connector = self.0.clone();
-        let inner = self.1.clone();
-
-        let fut = async move {
-            let key = if let Some(authority) = req.uri.authority() {
-                authority.clone().into()
-            } else {
-                return Err(ConnectError::Unresolved);
-            };
-
-            // acquire connection
-            match poll_fn(|cx| Poll::Ready(inner.borrow_mut().acquire(&key, cx))).await {
-                Acquire::Acquired(io, created) => {
-                    // use existing connection
-                    Ok(IoConnection::new(
-                        io,
-                        created,
-                        Some(Acquired(key, Some(inner))),
-                    ))
-                }
-                Acquire::Available => {
-                    // open tcp connection
-                    let (io, proto) = connector.call(req).await?;
-
-                    let config = inner.borrow().config.clone();
-
-                    let guard = OpenGuard::new(key, inner);
-
-                    if proto == Protocol::Http1 {
-                        Ok(IoConnection::new(
-                            ConnectionType::H1(io),
-                            Instant::now(),
-                            Some(guard.consume()),
-                        ))
-                    } else {
-                        let (snd, connection) = handshake(io, &config).await?;
-                        actix_rt::spawn(connection.map(|_| ()));
-                        Ok(IoConnection::new(
-                            ConnectionType::H2(snd),
-                            Instant::now(),
-                            Some(guard.consume()),
-                        ))
-                    }
-                }
-                _ => {
-                    // connection is not available, wait
-                    let (rx, token) = inner.borrow_mut().wait_for(req);
-
-                    let guard = WaiterGuard::new(key, token, inner);
-                    let res = match rx.await {
-                        Err(_) => Err(ConnectError::Disconnected),
-                        Ok(res) => res,
-                    };
-                    guard.consume();
-                    res
-                }
-            }
-        };
-
-        fut.boxed_local()
-    }
-}
-
-struct WaiterGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    key: Key,
-    token: usize,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-}
-
-impl<Io> WaiterGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn new(key: Key, token: usize, inner: Rc<RefCell<Inner<Io>>>) -> Self {
-        Self {
-            key,
-            token,
-            inner: Some(inner),
-        }
-    }
-
-    fn consume(mut self) {
-        let _ = self.inner.take();
-    }
-}
-
-impl<Io> Drop for WaiterGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn drop(&mut self) {
-        if let Some(i) = self.inner.take() {
-            let mut inner = i.as_ref().borrow_mut();
-            inner.release_waiter(&self.key, self.token);
-            inner.check_availability();
-        }
-    }
-}
-
-struct OpenGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    key: Key,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-}
-
-impl<Io> OpenGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn new(key: Key, inner: Rc<RefCell<Inner<Io>>>) -> Self {
-        Self {
-            key,
-            inner: Some(inner),
-        }
-    }
-
-    fn consume(mut self) -> Acquired<Io> {
-        Acquired(self.key.clone(), self.inner.take())
-    }
-}
-
-impl<Io> Drop for OpenGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn drop(&mut self) {
-        if let Some(i) = self.inner.take() {
-            let mut inner = i.as_ref().borrow_mut();
-            inner.release();
-            inner.check_availability();
-        }
-    }
-}
-
-enum Acquire<T> {
-    Acquired(ConnectionType<T>, Instant),
-    Available,
-    NotAvailable,
-}
-
-struct AvailableConnection<Io> {
-    io: ConnectionType<Io>,
-    used: Instant,
-    created: Instant,
-}
-
-pub(crate) struct Inner<Io> {
-    config: ConnectorConfig,
-    acquired: usize,
-    available: FxHashMap<Key, VecDeque<AvailableConnection<Io>>>,
-    waiters: Slab<
-        Option<(
-            Connect,
-            oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
-        )>,
-    >,
-    waiters_queue: IndexSet<(Key, usize)>,
-    waker: LocalWaker,
-}
-
-impl<Io> Inner<Io> {
-    fn reserve(&mut self) {
-        self.acquired += 1;
-    }
-
-    fn release(&mut self) {
-        self.acquired -= 1;
-    }
-
-    fn release_waiter(&mut self, key: &Key, token: usize) {
-        self.waiters.remove(token);
-        let _ = self.waiters_queue.shift_remove(&(key.clone(), token));
-    }
-}
-
-impl<Io> Inner<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    /// connection is not available, wait
-    fn wait_for(
-        &mut self,
-        connect: Connect,
-    ) -> (
-        oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
-        usize,
-    ) {
-        let (tx, rx) = oneshot::channel();
-
-        let key: Key = connect.uri.authority().unwrap().clone().into();
-        let entry = self.waiters.vacant_entry();
-        let token = entry.key();
-        entry.insert(Some((connect, tx)));
-        assert!(self.waiters_queue.insert((key, token)));
-
-        (rx, token)
-    }
-
-    fn acquire(&mut self, key: &Key, cx: &mut Context<'_>) -> Acquire<Io> {
-        // check limits
-        if self.config.limit > 0 && self.acquired >= self.config.limit {
-            return Acquire::NotAvailable;
-        }
-
-        self.reserve();
-
-        // check if open connection is available
-        // cleanup stale connections at the same time
-        if let Some(ref mut connections) = self.available.get_mut(key) {
-            let now = Instant::now();
-            while let Some(conn) = connections.pop_back() {
-                // check if it still usable
-                if (now - conn.used) > self.config.conn_keep_alive
-                    || (now - conn.created) > self.config.conn_lifetime
-                {
-                    if let Some(timeout) = self.config.disconnect_timeout {
-                        if let ConnectionType::H1(io) = conn.io {
-                            actix_rt::spawn(CloseConnection::new(io, timeout))
-                        }
-                    }
-                } else {
-                    let mut io = conn.io;
-                    let mut buf = [0; 2];
-                    if let ConnectionType::H1(ref mut s) = io {
-                        match Pin::new(s).poll_read(cx, &mut buf) {
-                            Poll::Pending => (),
-                            Poll::Ready(Ok(n)) if n > 0 => {
-                                if let Some(timeout) = self.config.disconnect_timeout {
-                                    if let ConnectionType::H1(io) = io {
-                                        actix_rt::spawn(CloseConnection::new(
-                                            io, timeout,
-                                        ))
-                                    }
-                                }
-                                continue;
-                            }
-                            _ => continue,
-                        }
-                    }
-                    return Acquire::Acquired(io, conn.created);
-                }
-            }
-        }
-        Acquire::Available
-    }
-
-    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
-        self.acquired -= 1;
-        self.available
-            .entry(key.clone())
-            .or_insert_with(VecDeque::new)
-            .push_back(AvailableConnection {
-                io,
-                created,
-                used: Instant::now(),
-            });
-        self.check_availability();
-    }
-
-    fn release_close(&mut self, io: ConnectionType<Io>) {
-        self.acquired -= 1;
-        if let Some(timeout) = self.config.disconnect_timeout {
-            if let ConnectionType::H1(io) = io {
-                actix_rt::spawn(CloseConnection::new(io, timeout))
-            }
-        }
-        self.check_availability();
-    }
-
-    fn check_availability(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.config.limit {
-            self.waker.wake();
-        }
-    }
-}
-
-struct CloseConnection<T> {
-    io: T,
-    timeout: Delay,
-}
-
-impl<T> CloseConnection<T>
-where
-    T: AsyncWrite + Unpin,
-{
-    fn new(io: T, timeout: Duration) -> Self {
-        CloseConnection {
-            io,
-            timeout: delay_for(timeout),
-        }
-    }
-}
-
-impl<T> Future for CloseConnection<T>
-where
-    T: AsyncWrite + Unpin,
-{
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        let this = self.get_mut();
-
-        match Pin::new(&mut this.timeout).poll(cx) {
-            Poll::Ready(_) => Poll::Ready(()),
-            Poll::Pending => match Pin::new(&mut this.io).poll_shutdown(cx) {
-                Poll::Ready(_) => Poll::Ready(()),
-                Poll::Pending => Poll::Pending,
-            },
-        }
-    }
-}
-
-#[pin_project]
-struct ConnectorPoolSupport<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    connector: T,
-    inner: Rc<RefCell<Inner<Io>>>,
-}
-
-impl<T, Io> Future for ConnectorPoolSupport<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
-    T::Future: 'static,
-{
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        if Rc::strong_count(this.inner) == 1 {
-            // If we are last copy of Inner<Io> it means the ConnectionPool is already gone
-            // and we are safe to exit.
-            return Poll::Ready(());
-        }
-
-        let mut inner = this.inner.borrow_mut();
-        inner.waker.register(cx.waker());
-
-        // check waiters
-        loop {
-            let (key, token) = {
-                if let Some((key, token)) = inner.waiters_queue.get_index(0) {
-                    (key.clone(), *token)
-                } else {
-                    break;
-                }
-            };
-            if inner.waiters.get(token).unwrap().is_none() {
-                continue;
-            }
-
-            match inner.acquire(&key, cx) {
-                Acquire::NotAvailable => break,
-                Acquire::Acquired(io, created) => {
-                    let tx = inner.waiters.get_mut(token).unwrap().take().unwrap().1;
-                    if let Err(conn) = tx.send(Ok(IoConnection::new(
-                        io,
-                        created,
-                        Some(Acquired(key.clone(), Some(this.inner.clone()))),
-                    ))) {
-                        let (io, created) = conn.unwrap().into_inner();
-                        inner.release_conn(&key, io, created);
-                    }
-                }
-                Acquire::Available => {
-                    let (connect, tx) =
-                        inner.waiters.get_mut(token).unwrap().take().unwrap();
-                    OpenWaitingConnection::spawn(
-                        key.clone(),
-                        tx,
-                        this.inner.clone(),
-                        this.connector.call(connect),
-                        inner.config.clone(),
-                    );
-                }
-            }
-            let _ = inner.waiters_queue.swap_remove_index(0);
-        }
-
-        Poll::Pending
-    }
-}
-
-#[pin_project::pin_project(PinnedDrop)]
-struct OpenWaitingConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    #[pin]
-    fut: F,
-    key: Key,
-    h2: Option<
-        LocalBoxFuture<
-            'static,
-            Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>,
-        >,
-    >,
-    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-    config: ConnectorConfig,
-}
-
-impl<F, Io> OpenWaitingConnection<F, Io>
-where
-    F: Future<Output = Result<(Io, Protocol), ConnectError>> + 'static,
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn spawn(
-        key: Key,
-        rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
-        inner: Rc<RefCell<Inner<Io>>>,
-        fut: F,
-        config: ConnectorConfig,
-    ) {
-        actix_rt::spawn(OpenWaitingConnection {
-            key,
-            fut,
-            h2: None,
-            rx: Some(rx),
-            inner: Some(inner),
-            config,
-        })
-    }
-}
-
-#[pin_project::pinned_drop]
-impl<F, Io> PinnedDrop for OpenWaitingConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn drop(self: Pin<&mut Self>) {
-        if let Some(inner) = self.project().inner.take() {
-            let mut inner = inner.as_ref().borrow_mut();
-            inner.release();
-            inner.check_availability();
-        }
-    }
-}
-
-impl<F, Io> Future for OpenWaitingConnection<F, Io>
-where
-    F: Future<Output = Result<(Io, Protocol), ConnectError>>,
-    Io: AsyncRead + AsyncWrite + Unpin,
-{
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-
-        if let Some(ref mut h2) = this.h2 {
-            return match Pin::new(h2).poll(cx) {
-                Poll::Ready(Ok((snd, connection))) => {
-                    actix_rt::spawn(connection.map(|_| ()));
-                    let rx = this.rx.take().unwrap();
-                    let _ = rx.send(Ok(IoConnection::new(
-                        ConnectionType::H2(snd),
-                        Instant::now(),
-                        Some(Acquired(this.key.clone(), this.inner.take())),
-                    )));
-                    Poll::Ready(())
-                }
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(Err(err)) => {
-                    let _ = this.inner.take();
-                    if let Some(rx) = this.rx.take() {
-                        let _ = rx.send(Err(ConnectError::H2(err)));
-                    }
-                    Poll::Ready(())
-                }
-            };
-        }
-
-        match this.fut.poll(cx) {
-            Poll::Ready(Err(err)) => {
-                let _ = this.inner.take();
-                if let Some(rx) = this.rx.take() {
-                    let _ = rx.send(Err(err));
-                }
-                Poll::Ready(())
-            }
-            Poll::Ready(Ok((io, proto))) => {
-                if proto == Protocol::Http1 {
-                    let rx = this.rx.take().unwrap();
-                    let _ = rx.send(Ok(IoConnection::new(
-                        ConnectionType::H1(io),
-                        Instant::now(),
-                        Some(Acquired(this.key.clone(), this.inner.take())),
-                    )));
-                    Poll::Ready(())
-                } else {
-                    *this.h2 = Some(handshake(io, this.config).boxed_local());
-                    self.poll(cx)
-                }
-            }
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-pub(crate) struct Acquired<T>(Key, Option<Rc<RefCell<Inner<T>>>>);
-
-impl<T> Acquired<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    pub(crate) fn close(&mut self, conn: IoConnection<T>) {
-        if let Some(inner) = self.1.take() {
-            let (io, _) = conn.into_inner();
-            inner.as_ref().borrow_mut().release_close(io);
-        }
-    }
-    pub(crate) fn release(&mut self, conn: IoConnection<T>) {
-        if let Some(inner) = self.1.take() {
-            let (io, created) = conn.into_inner();
-            inner
-                .as_ref()
-                .borrow_mut()
-                .release_conn(&self.0, io, created);
-        }
-    }
-}
-
-impl<T> Drop for Acquired<T> {
-    fn drop(&mut self) {
-        if let Some(inner) = self.1.take() {
-            inner.as_ref().borrow_mut().release();
-        }
-    }
-}

actix-http/src/cloneable.rs

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

actix-http/src/config.rs

@@ -1,315 +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::time::{delay_for, delay_until, Delay, Instant};
-use bytes::BytesMut;
-use futures_util::{future, FutureExt};
-use time::OffsetDateTime;
-
-// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-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>,
-    timer: 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,
-            timer: DateService::new(),
-        }))
-    }
-
-    #[inline]
-    /// Returns true if connection is secure(https)
-    pub fn secure(&self) -> bool {
-        self.0.secure
-    }
-
-    #[inline]
-    /// Returns the local address that this server is bound to.
-    pub fn local_addr(&self) -> Option<net::SocketAddr> {
-        self.0.local_addr
-    }
-
-    #[inline]
-    /// Keep alive duration if configured.
-    pub fn keep_alive(&self) -> Option<Duration> {
-        self.0.keep_alive
-    }
-
-    #[inline]
-    /// Return state of connection keep-alive functionality
-    pub fn keep_alive_enabled(&self) -> bool {
-        self.0.ka_enabled
-    }
-
-    #[inline]
-    /// Client timeout for first request.
-    pub fn client_timer(&self) -> Option<Delay> {
-        let delay_time = self.0.client_timeout;
-        if delay_time != 0 {
-            Some(delay_until(
-                self.0.timer.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.0.timer.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.0.timer.now() + Duration::from_millis(delay))
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Return keep-alive timer delay is configured.
-    pub fn keep_alive_timer(&self) -> Option<Delay> {
-        if let Some(ka) = self.0.keep_alive {
-            Some(delay_until(self.0.timer.now() + ka))
-        } else {
-            None
-        }
-    }
-
-    /// Keep-alive expire time
-    pub fn keep_alive_expire(&self) -> Option<Instant> {
-        if let Some(ka) = self.0.keep_alive {
-            Some(self.0.timer.now() + ka)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn now(&self) -> Instant {
-        self.0.timer.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
-            .timer
-            .set_date(|date| buf[6..35].copy_from_slice(&date.bytes));
-        buf[35..].copy_from_slice(b"\r\n\r\n");
-        dst.extend_from_slice(&buf);
-    }
-
-    pub(crate) fn set_date_header(&self, dst: &mut BytesMut) {
-        self.0
-            .timer
-            .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(())
-    }
-}
-
-#[derive(Clone)]
-struct DateService(Rc<DateServiceInner>);
-
-struct DateServiceInner {
-    current: Cell<Option<(Date, Instant)>>,
-}
-
-impl DateServiceInner {
-    fn new() -> Self {
-        DateServiceInner {
-            current: Cell::new(None),
-        }
-    }
-
-    fn reset(&self) {
-        self.current.take();
-    }
-
-    fn update(&self) {
-        let now = Instant::now();
-        let date = Date::new();
-        self.current.set(Some((date, now)));
-    }
-}
-
-impl DateService {
-    fn new() -> Self {
-        DateService(Rc::new(DateServiceInner::new()))
-    }
-
-    fn check_date(&self) {
-        if self.0.current.get().is_none() {
-            self.0.update();
-
-            // periodic date update
-            let s = self.clone();
-            actix_rt::spawn(delay_for(Duration::from_millis(500)).then(move |_| {
-                s.0.reset();
-                future::ready(())
-            }));
-        }
-    }
-
-    fn now(&self) -> Instant {
-        self.check_date();
-        self.0.current.get().unwrap().1
-    }
-
-    fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
-        self.check_date();
-        f(&self.0.current.get().unwrap().0);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // Test modifying the date from within the closure
-    // passed to `set_date`
-    #[test]
-    fn test_evil_date() {
-        let service = DateService::new();
-        // Make sure that `check_date` doesn't try to spawn a task
-        service.0.update();
-        service.set_date(|_| service.0.reset());
-    }
-
-    #[test]
-    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,222 +0,0 @@
-use std::future::Future;
-use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_threadpool::{run, CpuFuture};
-use brotli2::write::BrotliDecoder;
-use bytes::Bytes;
-use flate2::write::{GzDecoder, ZlibDecoder};
-use futures_core::{ready, Stream};
-
-use super::Writer;
-use crate::error::PayloadError;
-use crate::http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING};
-
-const INPLACE: usize = 2049;
-
-pub struct Decoder<S> {
-    decoder: Option<ContentDecoder>,
-    stream: S,
-    eof: bool,
-    fut: Option<CpuFuture<(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 {
-            ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
-                BrotliDecoder::new(Writer::new()),
-            ))),
-            ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
-                ZlibDecoder::new(Writer::new()),
-            ))),
-            ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
-                GzDecoder::new(Writer::new()),
-            ))),
-            _ => 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 = if let Some(enc) = headers.get(&CONTENT_ENCODING) {
-            if let Ok(enc) = enc.to_str() {
-                ContentEncoding::from(enc)
-            } else {
-                ContentEncoding::Identity
-            }
-        } else {
-            ContentEncoding::Identity
-        };
-
-        Self::new(stream, encoding)
-    }
-}
-
-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) = match ready!(Pin::new(fut).poll(cx)) {
-                    Ok(item) => item,
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
-                };
-                self.decoder = Some(decoder);
-                self.fut.take();
-                if let Some(chunk) = chunk {
-                    return Poll::Ready(Some(Ok(chunk)));
-                }
-            }
-
-            if self.eof {
-                return Poll::Ready(None);
-            }
-
-            match Pin::new(&mut self.stream).poll_next(cx) {
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
-                Poll::Ready(Some(Ok(chunk))) => {
-                    if let Some(mut decoder) = self.decoder.take() {
-                        if chunk.len() < INPLACE {
-                            let chunk = decoder.feed_data(chunk)?;
-                            self.decoder = Some(decoder);
-                            if let Some(chunk) = chunk {
-                                return Poll::Ready(Some(Ok(chunk)));
-                            }
-                        } else {
-                            self.fut = Some(run(move || {
-                                let chunk = decoder.feed_data(chunk)?;
-                                Ok((chunk, decoder))
-                            }));
-                        }
-                        continue;
-                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
-                    }
-                }
-                Poll::Ready(None) => {
-                    self.eof = true;
-                    return if let Some(mut decoder) = self.decoder.take() {
-                        match decoder.feed_eof() {
-                            Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
-                            Ok(None) => Poll::Ready(None),
-                            Err(err) => Poll::Ready(Some(Err(err.into()))),
-                        }
-                    } else {
-                        Poll::Ready(None)
-                    };
-                }
-                Poll::Pending => break,
-            }
-        }
-        Poll::Pending
-    }
-}
-
-enum ContentDecoder {
-    Deflate(Box<ZlibDecoder<Writer>>),
-    Gzip(Box<GzDecoder<Writer>>),
-    Br(Box<BrotliDecoder<Writer>>),
-}
-
-impl ContentDecoder {
-    fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
-        match self {
-            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),
-            },
-            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),
-            },
-            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),
-            },
-        }
-    }
-
-    fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
-        match self {
-            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),
-            },
-            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),
-            },
-            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),
-            },
-        }
-    }
-}

actix-http/src/encoding/encoder.rs

@@ -1,273 +0,0 @@
-//! Stream encoder
-use std::future::Future;
-use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_threadpool::{run, CpuFuture};
-use brotli2::write::BrotliEncoder;
-use bytes::Bytes;
-use flate2::write::{GzEncoder, ZlibEncoder};
-use futures_core::ready;
-use pin_project::pin_project;
-
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
-use crate::http::{HeaderValue, StatusCode};
-use crate::{Error, ResponseHead};
-
-use super::Writer;
-
-const INPLACE: usize = 1024;
-
-#[pin_project]
-pub struct Encoder<B> {
-    eof: bool,
-    #[pin]
-    body: EncoderBody<B>,
-    encoder: Option<ContentEncoder>,
-    fut: Option<CpuFuture<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(Box<dyn MessageBody + Unpin>),
-}
-
-impl<B: MessageBody> MessageBody for EncoderBody<B> {
-    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, Error>>> {
-        match self.project() {
-            EncoderBodyProj::Bytes(b) => {
-                if b.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(std::mem::take(b))))
-                }
-            }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx),
-            EncoderBodyProj::BoxedStream(ref mut b) => {
-                Pin::new(b.as_mut()).poll_next(cx)
-            }
-        }
-    }
-}
-
-impl<B: MessageBody> MessageBody for Encoder<B> {
-    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, 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 = match ready!(Pin::new(fut).poll(cx)) {
-                    Ok(item) => item,
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
-                };
-                let chunk = encoder.take();
-                *this.encoder = Some(encoder);
-                this.fut.take();
-                if !chunk.is_empty() {
-                    return Poll::Ready(Some(Ok(chunk)));
-                }
-            }
-
-            let result = this.body.as_mut().poll_next(cx);
-
-            match result {
-                Poll::Ready(Some(Ok(chunk))) => {
-                    if let Some(mut encoder) = this.encoder.take() {
-                        if chunk.len() < INPLACE {
-                            encoder.write(&chunk)?;
-                            let chunk = encoder.take();
-                            *this.encoder = Some(encoder);
-                            if !chunk.is_empty() {
-                                return Poll::Ready(Some(Ok(chunk)));
-                            }
-                        } else {
-                            *this.fut = Some(run(move || {
-                                encoder.write(&chunk)?;
-                                Ok(encoder)
-                            }));
-                        }
-                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
-                    }
-                }
-                Poll::Ready(None) => {
-                    if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish()?;
-                        if chunk.is_empty() {
-                            return Poll::Ready(None);
-                        } else {
-                            *this.eof = true;
-                            return Poll::Ready(Some(Ok(chunk)));
-                        }
-                    } else {
-                        return Poll::Ready(None);
-                    }
-                }
-                val => return val,
-            }
-        }
-    }
-}
-
-fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
-    head.headers_mut().insert(
-        CONTENT_ENCODING,
-        HeaderValue::from_static(encoding.as_str()),
-    );
-}
-
-enum ContentEncoder {
-    Deflate(ZlibEncoder<Writer>),
-    Gzip(GzEncoder<Writer>),
-    Br(BrotliEncoder<Writer>),
-}
-
-impl ContentEncoder {
-    fn encoder(encoding: ContentEncoding) -> Option<Self> {
-        match encoding {
-            ContentEncoding::Deflate => Some(ContentEncoder::Deflate(ZlibEncoder::new(
-                Writer::new(),
-                flate2::Compression::fast(),
-            ))),
-            ContentEncoding::Gzip => Some(ContentEncoder::Gzip(GzEncoder::new(
-                Writer::new(),
-                flate2::Compression::fast(),
-            ))),
-            ContentEncoding::Br => {
-                Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
-            }
-            _ => None,
-        }
-    }
-
-    #[inline]
-    pub(crate) fn take(&mut self) -> Bytes {
-        match *self {
-            ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
-            ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
-            ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
-        }
-    }
-
-    fn finish(self) -> Result<Bytes, io::Error> {
-        match self {
-            ContentEncoder::Br(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
-            ContentEncoder::Gzip(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
-            ContentEncoder::Deflate(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 {
-            ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding br encoding: {}", err);
-                    Err(err)
-                }
-            },
-            ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding gzip encoding: {}", err);
-                    Err(err)
-                }
-            },
-            ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding deflate encoding: {}", err);
-                    Err(err)
-                }
-            },
-        }
-    }
-}

actix-http/src/encoding/mod.rs

@@ -1,37 +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/extensions.rs

@@ -1,181 +0,0 @@
-use std::any::{Any, TypeId};
-use std::fmt;
-
-use fxhash::FxHashMap;
-
-#[derive(Default)]
-/// A type map of request extensions.
-pub struct Extensions {
-    /// Use FxHasher with a std HashMap with for faster
-    /// lookups on the small `TypeId` (u64 equivalent) keys.
-    map: FxHashMap<TypeId, Box<dyn Any>>,
-}
-
-impl Extensions {
-    /// Create an empty `Extensions`.
-    #[inline]
-    pub fn new() -> Extensions {
-        Extensions {
-            map: FxHashMap::default(),
-        }
-    }
-
-    /// Insert a type into this `Extensions`.
-    ///
-    /// If a extension of this type already existed, it will
-    /// be returned.
-    pub fn insert<T: 'static>(&mut self, val: T) {
-        self.map.insert(TypeId::of::<T>(), Box::new(val));
-    }
-
-    /// Check if container contains entry
-    pub fn contains<T: 'static>(&self) -> bool {
-        self.map.contains_key(&TypeId::of::<T>())
-    }
-
-    /// Get a reference to a type previously inserted on this `Extensions`.
-    pub fn get<T: 'static>(&self) -> Option<&T> {
-        self.map
-            .get(&TypeId::of::<T>())
-            .and_then(|boxed| boxed.downcast_ref())
-    }
-
-    /// Get a mutable reference to a type previously inserted on this `Extensions`.
-    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
-        self.map
-            .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| boxed.downcast_mut())
-    }
-
-    /// Remove a type from this `Extensions`.
-    ///
-    /// If a extension of this type existed, it will be returned.
-    pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map
-            .remove(&TypeId::of::<T>())
-            .and_then(|boxed| boxed.downcast().ok().map(|boxed| *boxed))
-    }
-
-    /// Clear the `Extensions` of all inserted extensions.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.map.clear();
-    }
-}
-
-impl fmt::Debug for Extensions {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
-    }
-}
-
-#[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)));
-    }
-}

actix-http/src/h1/client.rs

@@ -1,237 +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(())
-    }
-}
-
-pub struct Writer<'a>(pub &'a mut BytesMut);
-
-impl<'a> io::Write for Writer<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}

actix-http/src/h1/codec.rs

@@ -1,239 +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(),
-        }
-    }
-
-    #[inline]
-    /// Check if request is upgrade
-    pub fn upgrade(&self) -> bool {
-        self.ctype == ConnectionType::Upgrade
-    }
-
-    #[inline]
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.ctype == ConnectionType::KeepAlive
-    }
-
-    #[inline]
-    /// Check if keep-alive enabled on server level
-    pub fn keepalive_enabled(&self) -> bool {
-        self.flags.contains(Flags::KEEPALIVE_ENABLED)
-    }
-
-    #[inline]
-    /// Check last request's message type
-    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 self.payload.is_some() {
-            Ok(match self.payload.as_mut().unwrap().decode(src)? {
-                Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
-                Some(PayloadItem::Eof) => {
-                    self.payload.take();
-                    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::HttpMessage;
-
-    #[test]
-    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/dispatcher.rs

@@ -1,947 +0,0 @@
-use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, io, net};
-
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts};
-use actix_rt::time::{delay_until, Delay, Instant};
-use actix_service::Service;
-use bitflags::bitflags;
-use bytes::{Buf, BytesMut};
-use log::{error, trace};
-use pin_project::pin_project;
-
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::error::{ParseError, PayloadError};
-use crate::helpers::DataFactory;
-use crate::httpmessage::HttpMessage;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::codec::Codec;
-use super::payload::{Payload, PayloadSender, PayloadStatus};
-use super::{Message, MessageType};
-
-const LW_BUFFER_SIZE: usize = 4096;
-const HW_BUFFER_SIZE: usize = 32_768;
-const MAX_PIPELINED_MESSAGES: usize = 16;
-
-bitflags! {
-    pub struct Flags: u8 {
-        const STARTED            = 0b0000_0001;
-        const KEEPALIVE          = 0b0000_0010;
-        const POLLED             = 0b0000_0100;
-        const SHUTDOWN           = 0b0000_1000;
-        const READ_DISCONNECT    = 0b0001_0000;
-        const WRITE_DISCONNECT   = 0b0010_0000;
-        const UPGRADE            = 0b0100_0000;
-    }
-}
-
-#[pin_project::pin_project]
-/// Dispatcher for HTTP/1.1 protocol
-pub struct Dispatcher<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    #[pin]
-    inner: DispatcherState<T, S, B, X, U>,
-}
-
-#[pin_project(project = DispatcherStateProj)]
-enum DispatcherState<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
-    Upgrade(Pin<Box<U::Future>>),
-}
-
-#[pin_project(project = InnerDispatcherProj)]
-struct InnerDispatcher<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    service: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    on_connect: Option<Box<dyn DataFactory>>,
-    flags: Flags,
-    peer_addr: Option<net::SocketAddr>,
-    error: Option<DispatchError>,
-
-    #[pin]
-    state: State<S, B, X>,
-    payload: Option<PayloadSender>,
-    messages: VecDeque<DispatcherMessage>,
-
-    ka_expire: Instant,
-    ka_timer: Option<Delay>,
-
-    io: Option<T>,
-    read_buf: BytesMut,
-    write_buf: BytesMut,
-    codec: Codec,
-}
-
-enum DispatcherMessage {
-    Item(Request),
-    Upgrade(Request),
-    Error(Response<()>),
-}
-
-#[pin_project(project = StateProj)]
-enum State<S, B, X>
-where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
-    B: MessageBody,
-{
-    None,
-    ExpectCall(Pin<Box<X::Future>>),
-    ServiceCall(Pin<Box<S::Future>>),
-    SendPayload(#[pin] ResponseBody<B>),
-}
-
-impl<S, B, X> State<S, B, X>
-where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
-    B: MessageBody,
-{
-    fn is_empty(&self) -> bool {
-        matches!(self, State::None)
-    }
-
-    fn is_call(&self) -> bool {
-        matches!(self, State::ServiceCall(_))
-    }
-}
-enum PollResponse {
-    Upgrade(Request),
-    DoNothing,
-    DrainWriteBuf,
-}
-
-impl PartialEq for PollResponse {
-    fn eq(&self, other: &PollResponse) -> bool {
-        match self {
-            PollResponse::DrainWriteBuf => matches!(other, PollResponse::DrainWriteBuf),
-            PollResponse::DoNothing => matches!(other, PollResponse::DoNothing),
-            _ => false,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    /// Create http/1 dispatcher.
-    pub(crate) fn new(
-        stream: T,
-        config: ServiceConfig,
-        service: CloneableService<S>,
-        expect: CloneableService<X>,
-        upgrade: Option<CloneableService<U>>,
-        on_connect: Option<Box<dyn DataFactory>>,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        Dispatcher::with_timeout(
-            stream,
-            Codec::new(config.clone()),
-            config,
-            BytesMut::with_capacity(HW_BUFFER_SIZE),
-            None,
-            service,
-            expect,
-            upgrade,
-            on_connect,
-            peer_addr,
-        )
-    }
-
-    /// Create http/1 dispatcher with slow request timeout.
-    pub(crate) fn with_timeout(
-        io: T,
-        codec: Codec,
-        config: ServiceConfig,
-        read_buf: BytesMut,
-        timeout: Option<Delay>,
-        service: CloneableService<S>,
-        expect: CloneableService<X>,
-        upgrade: Option<CloneableService<U>>,
-        on_connect: Option<Box<dyn DataFactory>>,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        let keepalive = config.keep_alive_enabled();
-        let flags = if keepalive {
-            Flags::KEEPALIVE
-        } else {
-            Flags::empty()
-        };
-
-        // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
-            (delay.deadline(), Some(delay))
-        } else if let Some(delay) = config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
-        };
-
-        Dispatcher {
-            inner: DispatcherState::Normal(InnerDispatcher {
-                write_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
-                payload: None,
-                state: State::None,
-                error: None,
-                messages: VecDeque::new(),
-                io: Some(io),
-                codec,
-                read_buf,
-                service,
-                expect,
-                upgrade,
-                on_connect,
-                flags,
-                peer_addr,
-                ka_expire,
-                ka_timer,
-            }),
-        }
-    }
-}
-
-impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn can_read(&self, cx: &mut Context<'_>) -> bool {
-        if self
-            .flags
-            .intersects(Flags::READ_DISCONNECT | Flags::UPGRADE)
-        {
-            false
-        } else if let Some(ref info) = self.payload {
-            info.need_read(cx) == PayloadStatus::Read
-        } else {
-            true
-        }
-    }
-
-    // if checked is set to true, delay disconnect until all tasks have finished.
-    fn client_disconnected(self: Pin<&mut Self>) {
-        let this = self.project();
-        this.flags
-            .insert(Flags::READ_DISCONNECT | Flags::WRITE_DISCONNECT);
-        if let Some(mut payload) = this.payload.take() {
-            payload.set_error(PayloadError::Incomplete(None));
-        }
-    }
-
-    /// Flush stream
-    ///
-    /// true - got WouldBlock
-    /// false - didn't get WouldBlock
-    fn poll_flush(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<bool, DispatchError> {
-        if self.write_buf.is_empty() {
-            return Ok(false);
-        }
-
-        let len = self.write_buf.len();
-        let mut written = 0;
-        let InnerDispatcherProj { io, write_buf, .. } = self.project();
-        let mut io = Pin::new(io.as_mut().unwrap());
-        while written < len {
-            match io.as_mut().poll_write(cx, &write_buf[written..]) {
-                Poll::Ready(Ok(0)) => {
-                    return Err(DispatchError::Io(io::Error::new(
-                        io::ErrorKind::WriteZero,
-                        "",
-                    )));
-                }
-                Poll::Ready(Ok(n)) => {
-                    written += n;
-                }
-                Poll::Pending => {
-                    if written > 0 {
-                        write_buf.advance(written);
-                    }
-                    return Ok(true);
-                }
-                Poll::Ready(Err(err)) => return Err(DispatchError::Io(err)),
-            }
-        }
-
-        if written == write_buf.len() {
-            // SAFETY: setting length to 0 is safe
-            // skips one length check vs truncate
-            unsafe { write_buf.set_len(0) }
-        } else {
-            write_buf.advance(written);
-        }
-
-        Ok(false)
-    }
-
-    fn send_response(
-        self: Pin<&mut Self>,
-        message: Response<()>,
-        body: ResponseBody<B>,
-    ) -> Result<State<S, B, X>, DispatchError> {
-        let mut this = self.project();
-        this.codec
-            .encode(Message::Item((message, body.size())), &mut this.write_buf)
-            .map_err(|err| {
-                if let Some(mut payload) = this.payload.take() {
-                    payload.set_error(PayloadError::Incomplete(None));
-                }
-                DispatchError::Io(err)
-            })?;
-
-        this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
-        match body.size() {
-            BodySize::None | BodySize::Empty => Ok(State::None),
-            _ => Ok(State::SendPayload(body)),
-        }
-    }
-
-    fn send_continue(self: Pin<&mut Self>) {
-        self.project()
-            .write_buf
-            .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
-    }
-
-    fn poll_response(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<PollResponse, DispatchError> {
-        loop {
-            let mut this = self.as_mut().project();
-            let state = match this.state.project() {
-                StateProj::None => match this.messages.pop_front() {
-                    Some(DispatcherMessage::Item(req)) => {
-                        Some(self.as_mut().handle_request(req, cx)?)
-                    }
-                    Some(DispatcherMessage::Error(res)) => Some(
-                        self.as_mut()
-                            .send_response(res, ResponseBody::Other(Body::Empty))?,
-                    ),
-                    Some(DispatcherMessage::Upgrade(req)) => {
-                        return Ok(PollResponse::Upgrade(req));
-                    }
-                    None => None,
-                },
-                StateProj::ExpectCall(fut) => match fut.as_mut().poll(cx) {
-                    Poll::Ready(Ok(req)) => {
-                        self.as_mut().send_continue();
-                        this = self.as_mut().project();
-                        this.state
-                            .set(State::ServiceCall(Box::pin(this.service.call(req))));
-                        continue;
-                    }
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.as_mut().send_response(res, body.into_body())?)
-                    }
-                    Poll::Pending => None,
-                },
-                StateProj::ServiceCall(fut) => match fut.as_mut().poll(cx) {
-                    Poll::Ready(Ok(res)) => {
-                        let (res, body) = res.into().replace_body(());
-                        let state = self.as_mut().send_response(res, body)?;
-                        this = self.as_mut().project();
-                        this.state.set(state);
-                        continue;
-                    }
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.as_mut().send_response(res, body.into_body())?)
-                    }
-                    Poll::Pending => None,
-                },
-                StateProj::SendPayload(mut stream) => {
-                    loop {
-                        if this.write_buf.len() < HW_BUFFER_SIZE {
-                            match stream.as_mut().poll_next(cx) {
-                                Poll::Ready(Some(Ok(item))) => {
-                                    this.codec.encode(
-                                        Message::Chunk(Some(item)),
-                                        &mut this.write_buf,
-                                    )?;
-                                    continue;
-                                }
-                                Poll::Ready(None) => {
-                                    this.codec.encode(
-                                        Message::Chunk(None),
-                                        &mut this.write_buf,
-                                    )?;
-                                    this = self.as_mut().project();
-                                    this.state.set(State::None);
-                                }
-                                Poll::Ready(Some(Err(_))) => {
-                                    return Err(DispatchError::Unknown)
-                                }
-                                Poll::Pending => return Ok(PollResponse::DoNothing),
-                            }
-                        } else {
-                            return Ok(PollResponse::DrainWriteBuf);
-                        }
-                        break;
-                    }
-                    continue;
-                }
-            };
-
-            this = self.as_mut().project();
-
-            // set new state
-            if let Some(state) = state {
-                this.state.set(state);
-                if !self.state.is_empty() {
-                    continue;
-                }
-            } else {
-                // if read-backpressure is enabled and we consumed some data.
-                // we may read more data and retry
-                if self.state.is_call() {
-                    if self.as_mut().poll_request(cx)? {
-                        continue;
-                    }
-                } else if !self.messages.is_empty() {
-                    continue;
-                }
-            }
-            break;
-        }
-
-        Ok(PollResponse::DoNothing)
-    }
-
-    fn handle_request(
-        mut self: Pin<&mut Self>,
-        req: Request,
-        cx: &mut Context<'_>,
-    ) -> Result<State<S, B, X>, DispatchError> {
-        // Handle `EXPECT: 100-Continue` header
-        let req = if req.head().expect() {
-            let mut task = Box::pin(self.as_mut().project().expect.call(req));
-            match task.as_mut().poll(cx) {
-                Poll::Ready(Ok(req)) => {
-                    self.as_mut().send_continue();
-                    req
-                }
-                Poll::Pending => return Ok(State::ExpectCall(task)),
-                Poll::Ready(Err(e)) => {
-                    let e = e.into();
-                    let res: Response = e.into();
-                    let (res, body) = res.replace_body(());
-                    return self.send_response(res, body.into_body());
-                }
-            }
-        } else {
-            req
-        };
-
-        // Call service
-        let mut task = Box::pin(self.as_mut().project().service.call(req));
-        match task.as_mut().poll(cx) {
-            Poll::Ready(Ok(res)) => {
-                let (res, body) = res.into().replace_body(());
-                self.send_response(res, body)
-            }
-            Poll::Pending => Ok(State::ServiceCall(task)),
-            Poll::Ready(Err(e)) => {
-                let res: Response = e.into().into();
-                let (res, body) = res.replace_body(());
-                self.send_response(res, body.into_body())
-            }
-        }
-    }
-
-    /// Process one incoming requests
-    pub(self) fn poll_request(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<bool, DispatchError> {
-        // limit a mount of non processed requests
-        if self.messages.len() >= MAX_PIPELINED_MESSAGES || !self.can_read(cx) {
-            return Ok(false);
-        }
-
-        let mut updated = false;
-        let mut this = self.as_mut().project();
-        loop {
-            match this.codec.decode(&mut this.read_buf) {
-                Ok(Some(msg)) => {
-                    updated = true;
-                    this.flags.insert(Flags::STARTED);
-
-                    match msg {
-                        Message::Item(mut req) => {
-                            let pl = this.codec.message_type();
-                            req.head_mut().peer_addr = *this.peer_addr;
-
-                            // set on_connect data
-                            if let Some(ref on_connect) = this.on_connect {
-                                on_connect.set(&mut req.extensions_mut());
-                            }
-
-                            if pl == MessageType::Stream && this.upgrade.is_some() {
-                                this.messages.push_back(DispatcherMessage::Upgrade(req));
-                                break;
-                            }
-                            if pl == MessageType::Payload || pl == MessageType::Stream {
-                                let (ps, pl) = Payload::create(false);
-                                let (req1, _) =
-                                    req.replace_payload(crate::Payload::H1(pl));
-                                req = req1;
-                                *this.payload = Some(ps);
-                            }
-
-                            // handle request early
-                            if this.state.is_empty() {
-                                let state = self.as_mut().handle_request(req, cx)?;
-                                this = self.as_mut().project();
-                                this.state.set(state);
-                            } else {
-                                this.messages.push_back(DispatcherMessage::Item(req));
-                            }
-                        }
-                        Message::Chunk(Some(chunk)) => {
-                            if let Some(ref mut payload) = this.payload {
-                                payload.feed_data(chunk);
-                            } else {
-                                error!(
-                                    "Internal server error: unexpected payload chunk"
-                                );
-                                this.flags.insert(Flags::READ_DISCONNECT);
-                                this.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
-                                ));
-                                *this.error = Some(DispatchError::InternalError);
-                                break;
-                            }
-                        }
-                        Message::Chunk(None) => {
-                            if let Some(mut payload) = this.payload.take() {
-                                payload.feed_eof();
-                            } else {
-                                error!("Internal server error: unexpected eof");
-                                this.flags.insert(Flags::READ_DISCONNECT);
-                                this.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
-                                ));
-                                *this.error = Some(DispatchError::InternalError);
-                                break;
-                            }
-                        }
-                    }
-                }
-                Ok(None) => break,
-                Err(ParseError::Io(e)) => {
-                    self.as_mut().client_disconnected();
-                    this = self.as_mut().project();
-                    *this.error = Some(DispatchError::Io(e));
-                    break;
-                }
-                Err(e) => {
-                    if let Some(mut payload) = this.payload.take() {
-                        payload.set_error(PayloadError::EncodingCorrupted);
-                    }
-
-                    // Malformed requests should be responded with 400
-                    this.messages.push_back(DispatcherMessage::Error(
-                        Response::BadRequest().finish().drop_body(),
-                    ));
-                    this.flags.insert(Flags::READ_DISCONNECT);
-                    *this.error = Some(e.into());
-                    break;
-                }
-            }
-        }
-
-        if updated && this.ka_timer.is_some() {
-            if let Some(expire) = this.codec.config().keep_alive_expire() {
-                *this.ka_expire = expire;
-            }
-        }
-        Ok(updated)
-    }
-
-    /// keep-alive timer
-    fn poll_keepalive(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<(), DispatchError> {
-        let mut this = self.as_mut().project();
-        if this.ka_timer.is_none() {
-            // shutdown timeout
-            if this.flags.contains(Flags::SHUTDOWN) {
-                if let Some(interval) = this.codec.config().client_disconnect_timer() {
-                    *this.ka_timer = Some(delay_until(interval));
-                } else {
-                    this.flags.insert(Flags::READ_DISCONNECT);
-                    if let Some(mut payload) = this.payload.take() {
-                        payload.set_error(PayloadError::Incomplete(None));
-                    }
-                    return Ok(());
-                }
-            } else {
-                return Ok(());
-            }
-        }
-
-        match Pin::new(&mut this.ka_timer.as_mut().unwrap()).poll(cx) {
-            Poll::Ready(()) => {
-                // if we get timeout during shutdown, drop connection
-                if this.flags.contains(Flags::SHUTDOWN) {
-                    return Err(DispatchError::DisconnectTimeout);
-                } else if this.ka_timer.as_mut().unwrap().deadline() >= *this.ka_expire {
-                    // check for any outstanding tasks
-                    if this.state.is_empty() && this.write_buf.is_empty() {
-                        if this.flags.contains(Flags::STARTED) {
-                            trace!("Keep-alive timeout, close connection");
-                            this.flags.insert(Flags::SHUTDOWN);
-
-                            // start shutdown timer
-                            if let Some(deadline) =
-                                this.codec.config().client_disconnect_timer()
-                            {
-                                if let Some(mut timer) = this.ka_timer.as_mut() {
-                                    timer.reset(deadline);
-                                    let _ = Pin::new(&mut timer).poll(cx);
-                                }
-                            } else {
-                                // no shutdown timeout, drop socket
-                                this.flags.insert(Flags::WRITE_DISCONNECT);
-                                return Ok(());
-                            }
-                        } else {
-                            // timeout on first request (slow request) return 408
-                            if !this.flags.contains(Flags::STARTED) {
-                                trace!("Slow request timeout");
-                                let _ = self.as_mut().send_response(
-                                    Response::RequestTimeout().finish().drop_body(),
-                                    ResponseBody::Other(Body::Empty),
-                                );
-                                this = self.as_mut().project();
-                            } else {
-                                trace!("Keep-alive connection timeout");
-                            }
-                            this.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
-                            this.state.set(State::None);
-                        }
-                    } else if let Some(deadline) =
-                        this.codec.config().keep_alive_expire()
-                    {
-                        if let Some(mut timer) = this.ka_timer.as_mut() {
-                            timer.reset(deadline);
-                            let _ = Pin::new(&mut timer).poll(cx);
-                        }
-                    }
-                } else if let Some(mut timer) = this.ka_timer.as_mut() {
-                    timer.reset(*this.ka_expire);
-                    let _ = Pin::new(&mut timer).poll(cx);
-                }
-            }
-            Poll::Pending => (),
-        }
-
-        Ok(())
-    }
-}
-
-impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Output = Result<(), DispatchError>;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-        match this.inner.project() {
-            DispatcherStateProj::Normal(mut inner) => {
-                inner.as_mut().poll_keepalive(cx)?;
-
-                if inner.flags.contains(Flags::SHUTDOWN) {
-                    if inner.flags.contains(Flags::WRITE_DISCONNECT) {
-                        Poll::Ready(Ok(()))
-                    } else {
-                        // flush buffer
-                        inner.as_mut().poll_flush(cx)?;
-                        if !inner.write_buf.is_empty() || inner.io.is_none() {
-                            Poll::Pending
-                        } else {
-                            match Pin::new(inner.project().io)
-                                .as_pin_mut()
-                                .unwrap()
-                                .poll_shutdown(cx)
-                            {
-                                Poll::Ready(res) => {
-                                    Poll::Ready(res.map_err(DispatchError::from))
-                                }
-                                Poll::Pending => Poll::Pending,
-                            }
-                        }
-                    }
-                } else {
-                    // read socket into a buf
-                    let should_disconnect =
-                        if !inner.flags.contains(Flags::READ_DISCONNECT) {
-                            let mut inner_p = inner.as_mut().project();
-                            read_available(
-                                cx,
-                                inner_p.io.as_mut().unwrap(),
-                                &mut inner_p.read_buf,
-                            )?
-                        } else {
-                            None
-                        };
-
-                    inner.as_mut().poll_request(cx)?;
-                    if let Some(true) = should_disconnect {
-                        let inner_p = inner.as_mut().project();
-                        inner_p.flags.insert(Flags::READ_DISCONNECT);
-                        if let Some(mut payload) = inner_p.payload.take() {
-                            payload.feed_eof();
-                        }
-                    };
-
-                    loop {
-                        let inner_p = inner.as_mut().project();
-                        let remaining =
-                            inner_p.write_buf.capacity() - inner_p.write_buf.len();
-                        if remaining < LW_BUFFER_SIZE {
-                            inner_p.write_buf.reserve(HW_BUFFER_SIZE - remaining);
-                        }
-                        let result = inner.as_mut().poll_response(cx)?;
-                        let drain = result == PollResponse::DrainWriteBuf;
-
-                        // switch to upgrade handler
-                        if let PollResponse::Upgrade(req) = result {
-                            let inner_p = inner.as_mut().project();
-                            let mut parts = FramedParts::with_read_buf(
-                                inner_p.io.take().unwrap(),
-                                std::mem::take(inner_p.codec),
-                                std::mem::take(inner_p.read_buf),
-                            );
-                            parts.write_buf = std::mem::take(inner_p.write_buf);
-                            let framed = Framed::from_parts(parts);
-                            let upgrade =
-                                inner_p.upgrade.take().unwrap().call((req, framed));
-                            self.as_mut()
-                                .project()
-                                .inner
-                                .set(DispatcherState::Upgrade(Box::pin(upgrade)));
-                            return self.poll(cx);
-                        }
-
-                        // we didn't get WouldBlock from write operation,
-                        // so data get written to kernel completely (OSX)
-                        // and we have to write again otherwise response can get stuck
-                        if inner.as_mut().poll_flush(cx)? || !drain {
-                            break;
-                        }
-                    }
-
-                    // client is gone
-                    if inner.flags.contains(Flags::WRITE_DISCONNECT) {
-                        return Poll::Ready(Ok(()));
-                    }
-
-                    let is_empty = inner.state.is_empty();
-
-                    let inner_p = inner.as_mut().project();
-                    // read half is closed and we do not processing any responses
-                    if inner_p.flags.contains(Flags::READ_DISCONNECT) && is_empty {
-                        inner_p.flags.insert(Flags::SHUTDOWN);
-                    }
-
-                    // keep-alive and stream errors
-                    if is_empty && inner_p.write_buf.is_empty() {
-                        if let Some(err) = inner_p.error.take() {
-                            Poll::Ready(Err(err))
-                        }
-                        // disconnect if keep-alive is not enabled
-                        else if inner_p.flags.contains(Flags::STARTED)
-                            && !inner_p.flags.intersects(Flags::KEEPALIVE)
-                        {
-                            inner_p.flags.insert(Flags::SHUTDOWN);
-                            self.poll(cx)
-                        }
-                        // disconnect if shutdown
-                        else if inner_p.flags.contains(Flags::SHUTDOWN) {
-                            self.poll(cx)
-                        } else {
-                            Poll::Pending
-                        }
-                    } else {
-                        Poll::Pending
-                    }
-                }
-            }
-            DispatcherStateProj::Upgrade(fut) => fut.as_mut().poll(cx).map_err(|e| {
-                error!("Upgrade handler error: {}", e);
-                DispatchError::Upgrade
-            }),
-        }
-    }
-}
-
-fn read_available<T>(
-    cx: &mut Context<'_>,
-    io: &mut T,
-    buf: &mut BytesMut,
-) -> Result<Option<bool>, io::Error>
-where
-    T: AsyncRead + Unpin,
-{
-    let mut read_some = false;
-
-    loop {
-        // If buf is full return but do not disconnect since
-        // there is more reading to be done
-        if buf.len() >= HW_BUFFER_SIZE {
-            return Ok(Some(false));
-        }
-
-        let remaining = buf.capacity() - buf.len();
-        if remaining < LW_BUFFER_SIZE {
-            buf.reserve(HW_BUFFER_SIZE - remaining);
-        }
-
-        match read(cx, io, buf) {
-            Poll::Pending => {
-                return if read_some { Ok(Some(false)) } else { Ok(None) };
-            }
-            Poll::Ready(Ok(n)) => {
-                if n == 0 {
-                    return Ok(Some(true));
-                } else {
-                    read_some = true;
-                }
-            }
-            Poll::Ready(Err(e)) => {
-                return if e.kind() == io::ErrorKind::WouldBlock {
-                    if read_some {
-                        Ok(Some(false))
-                    } else {
-                        Ok(None)
-                    }
-                } else if e.kind() == io::ErrorKind::ConnectionReset && read_some {
-                    Ok(Some(true))
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-fn read<T>(
-    cx: &mut Context<'_>,
-    io: &mut T,
-    buf: &mut BytesMut,
-) -> Poll<Result<usize, io::Error>>
-where
-    T: AsyncRead + Unpin,
-{
-    Pin::new(io).poll_read_buf(cx, buf)
-}
-
-#[cfg(test)]
-mod tests {
-    use actix_service::IntoService;
-    use futures_util::future::{lazy, ok};
-
-    use super::*;
-    use crate::error::Error;
-    use crate::h1::{ExpectHandler, UpgradeHandler};
-    use crate::test::TestBuffer;
-
-    #[actix_rt::test]
-    async fn test_req_parse_err() {
-        lazy(|cx| {
-            let buf = TestBuffer::new("GET /test HTTP/1\r\n\r\n");
-
-            let mut h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
-                buf,
-                ServiceConfig::default(),
-                CloneableService::new(
-                    (|_| ok::<_, Error>(Response::Ok().finish())).into_service(),
-                ),
-                CloneableService::new(ExpectHandler),
-                None,
-                None,
-                None,
-            );
-            match Pin::new(&mut h1).poll(cx) {
-                Poll::Pending => panic!(),
-                Poll::Ready(res) => assert!(res.is_err()),
-            }
-
-            if let DispatcherState::Normal(ref mut inner) = h1.inner {
-                assert!(inner.flags.contains(Flags::READ_DISCONNECT));
-                assert_eq!(
-                    &inner.io.take().unwrap().write_buf[..26],
-                    b"HTTP/1.1 400 Bad Request\r\n"
-                );
-            }
-        })
-        .await;
-    }
-}

actix-http/src/h1/encoder.rs

@@ -1,679 +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;
-use crate::config::ServiceConfig;
-use crate::header::map;
-use crate::helpers;
-use crate::http::header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use crate::http::{HeaderMap, StatusCode, Version};
-use crate::message::{ConnectionType, RequestHeadType};
-use crate::response::Response;
-
-const AVERAGE_HEADER_SIZE: usize = 30;
-
-#[derive(Debug)]
-pub(crate) struct MessageEncoder<T: MessageType> {
-    pub length: BodySize,
-    pub te: TransferEncoding,
-    _t: PhantomData<T>,
-}
-
-impl<T: MessageType> Default for MessageEncoder<T> {
-    fn default() -> Self {
-        MessageEncoder {
-            length: BodySize::None,
-            te: TransferEncoding::empty(),
-            _t: 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::NO_CONTENT
-                | StatusCode::CONTINUE
-                | StatusCode::PROCESSING => length = BodySize::None,
-                StatusCode::SWITCHING_PROTOCOLS => {
-                    skip_len = true;
-                    length = BodySize::Stream;
-                }
-                _ => (),
-            }
-        }
-        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")
-                }
-            }
-            _ => (),
-        }
-
-        // merging headers from head and extra headers. HeaderMap::new() does not allocate.
-        let empty_headers = HeaderMap::new();
-        let extra_headers = self.extra_headers().unwrap_or(&empty_headers);
-        let headers = self
-            .headers()
-            .inner
-            .iter()
-            .filter(|(name, _)| !extra_headers.contains_key(*name))
-            .chain(extra_headers.inner.iter());
-
-        // write headers
-
-        let mut has_date = false;
-
-        let mut buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
-        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;
-
-        for (key, value) in headers {
-            match *key {
-                CONNECTION => continue,
-                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
-                DATE => has_date = true,
-                _ => (),
-            }
-
-            let k = key.as_str().as_bytes();
-            let k_len = k.len();
-
-            match value {
-                map::Value::One(ref val) => {
-                    let v = val.as_ref();
-                    let v_len = v.len();
-
-                    // key length + value length + colon + space + \r\n
-                    let len = k_len + v_len + 4;
-
-                    if len > remaining {
-                        // not enough room in buffer for this header; reserve more space
-
-                        // SAFETY: all the bytes written up to position "pos" are initialized
-                        // the written byte count and pointer advancement are kept in sync
-                        unsafe {
-                            dst.advance_mut(pos);
-                        }
-
-                        pos = 0;
-                        dst.reserve(len * 2);
-                        remaining = dst.capacity() - dst.len();
-
-                        // re-assign buf raw pointer since it's possible that the buffer was
-                        // reallocated and/or resized
-                        buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
-                    }
-
-                    // SAFETY: on each write, it is enough to ensure that the advancement of the
-                    // cursor matches the number of bytes written
-                    unsafe {
-                        // use upper Camel-Case
-                        if camel_case {
-                            write_camel_case(k, from_raw_parts_mut(buf, k_len))
-                        } else {
-                            write_data(k, buf, k_len)
-                        }
-
-                        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;
-                }
-
-                map::Value::Multi(ref vec) => {
-                    for val in vec {
-                        let v = val.as_ref();
-                        let v_len = v.len();
-                        let len = k_len + v_len + 4;
-
-                        if len > remaining {
-                            // SAFETY: all the bytes written up to position "pos" are initialized
-                            // the written byte count and pointer advancement are kept in sync
-                            unsafe {
-                                dst.advance_mut(pos);
-                            }
-                            pos = 0;
-                            dst.reserve(len * 2);
-                            remaining = dst.capacity() - dst.len();
-
-                            // re-assign buf raw pointer since it's possible that the buffer was
-                            // reallocated and/or resized
-                            buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
-                        }
-
-                        // SAFETY: on each write, it is enough to ensure that the advancement of
-                        // the cursor matches the number of bytes written
-                        unsafe {
-                            if camel_case {
-                                write_camel_case(k, from_raw_parts_mut(buf, k_len));
-                            } else {
-                                write_data(k, buf, k_len);
-                            }
-
-                            buf = buf.add(k_len);
-
-                            write_data(b": ", buf, 2);
-                            buf = buf.add(2);
-
-                            write_data(v, buf, v_len);
-                            buf = buf.add(v_len);
-
-                            write_data(b"\r\n", buf, 2);
-                            buf = buf.add(2);
-                        };
-
-                        pos += len;
-                        remaining -= len;
-                    }
-                }
-            }
-        }
-
-        // 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(())
-    }
-}
-
-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!(
-            Writer(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!(Writer(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(())
-            }
-        }
-    }
-}
-
-struct Writer<'a>(pub &'a mut BytesMut);
-
-impl<'a> io::Write for Writer<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-/// # Safety
-/// Callers must ensure that the given 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]) {
-    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;
-                }
-            }
-        }
-    }
-}
-
-#[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")
-        );
-    }
-
-    #[test]
-    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"));
-    }
-
-    #[test]
-    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-http/src/h1/expect.rs

@@ -1,38 +0,0 @@
-use std::task::{Context, Poll};
-
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, Ready};
-
-use crate::error::Error;
-use crate::request::Request;
-
-pub struct ExpectHandler;
-
-impl ServiceFactory for ExpectHandler {
-    type Config = ();
-    type Request = Request;
-    type Response = Request;
-    type Error = Error;
-    type Service = ExpectHandler;
-    type InitError = Error;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(ExpectHandler)
-    }
-}
-
-impl Service for ExpectHandler {
-    type Request = Request;
-    type Response = Request;
-    type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: Request) -> Self::Future {
-        ok(req)
-    }
-}

actix-http/src/h1/mod.rs

@@ -1,85 +0,0 @@
-//! HTTP/1 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, OneRequest};
-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,244 +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};
-
-use actix_utils::task::LocalWaker;
-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().io_task.register(cx.waker());
-                PayloadStatus::Pause
-            }
-        } else {
-            PayloadStatus::Dropped
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Inner {
-    len: usize,
-    eof: bool,
-    err: Option<PayloadError>,
-    need_read: bool,
-    items: VecDeque<Bytes>,
-    task: LocalWaker,
-    io_task: LocalWaker,
-}
-
-impl Inner {
-    fn new(eof: bool) -> Self {
-        Inner {
-            eof,
-            len: 0,
-            err: None,
-            items: VecDeque::new(),
-            need_read: true,
-            task: LocalWaker::new(),
-            io_task: LocalWaker::new(),
-        }
-    }
-
-    #[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;
-        if let Some(task) = self.task.take() {
-            task.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.task.register(cx.waker());
-            }
-            self.io_task.wake();
-            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.task.register(cx.waker());
-            self.io_task.wake();
-            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 futures_util::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,581 +0,0 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{fmt, net};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::net::TcpStream;
-use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
-use futures_core::ready;
-use futures_util::future::{ok, Ready};
-
-use crate::body::MessageBody;
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error, ParseError};
-use crate::helpers::DataFactory;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::codec::Codec;
-use super::dispatcher::Dispatcher;
-use super::{ExpectHandler, Message, UpgradeHandler};
-
-/// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> H1Service<T, S, B>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        H1Service {
-            cfg,
-            srv: service.into_factory(),
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<TcpStream, Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-{
-    /// Create simple tcp stream service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        Config = (),
-        Request = TcpStream,
-        Response = (),
-        Error = DispatchError,
-        InitError = (),
-    > {
-        pipeline_factory(|io: TcpStream| {
-            let peer_addr = io.peer_addr().ok();
-            ok((io, peer_addr))
-        })
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use super::*;
-
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, TlsError};
-
-    impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<SslStream<TcpStream>, Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create openssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
-            InitError = (),
-        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: SslStream<TcpStream>| {
-                let peer_addr = io.get_ref().peer_addr().ok();
-                ok((io, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::TlsError;
-    use std::{fmt, io};
-
-    impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<TlsStream<TcpStream>, Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create rustls based service
-        pub fn rustls(
-            self,
-            config: ServerConfig,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<io::Error, DispatchError>,
-            InitError = (),
-        > {
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| {
-                let peer_addr = io.get_ref().0.peer_addr().ok();
-                ok((io, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-impl<T, S, B, X, U> H1Service<T, S, B, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-{
-    pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
-    where
-        X1: ServiceFactory<Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-    {
-        H1Service {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
-    where
-        U1: ServiceFactory<Request = (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: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<T, S, B, X, U> ServiceFactory for H1Service<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-{
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = ();
-    type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
-    type Future = H1ServiceResponse<T, S, B, X, U>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        H1ServiceResponse {
-            fut: self.srv.new_service(()),
-            fut_ex: Some(self.expect.new_service(())),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(())),
-            expect: None,
-            upgrade: None,
-            on_connect: self.on_connect.clone(),
-            cfg: Some(self.cfg.clone()),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H1ServiceResponse<T, S, B, X, U>
-where
-    S: ServiceFactory<Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    X: ServiceFactory<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    #[pin]
-    fut: S::Future,
-    #[pin]
-    fut_ex: Option<X::Future>,
-    #[pin]
-    fut_upg: Option<U::Future>,
-    expect: Option<X::Service>,
-    upgrade: Option<U::Service>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: Option<ServiceConfig>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B, X, U> Future for H1ServiceResponse<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: ServiceFactory<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    type Output = Result<H1ServiceHandler<T, S::Service, B, X::Service, U::Service>, ()>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        if let Some(fut) = this.fut_ex.as_pin_mut() {
-            let expect = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.expect = Some(expect);
-            this.fut_ex.set(None);
-        }
-
-        if let Some(fut) = this.fut_upg.as_pin_mut() {
-            let upgrade = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.upgrade = Some(upgrade);
-            this.fut_ex.set(None);
-        }
-
-        let result = ready!(this
-            .fut
-            .poll(cx)
-            .map_err(|e| log::error!("Init http service error: {:?}", e)));
-
-        Poll::Ready(result.map(|service| {
-            let this = self.as_mut().project();
-            H1ServiceHandler::new(
-                this.cfg.take().unwrap(),
-                service,
-                this.expect.take().unwrap(),
-                this.upgrade.take(),
-                this.on_connect.clone(),
-            )
-        }))
-    }
-}
-
-/// `Service` implementation for HTTP1 transport
-pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
-    srv: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: ServiceConfig,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B, X, U> H1ServiceHandler<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn new(
-        cfg: ServiceConfig,
-        srv: S,
-        expect: X,
-        upgrade: Option<U>,
-        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> H1ServiceHandler<T, S, B, X, U> {
-        H1ServiceHandler {
-            srv: CloneableService::new(srv),
-            expect: CloneableService::new(expect),
-            upgrade: upgrade.map(CloneableService::new),
-            cfg,
-            on_connect,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Service for H1ServiceHandler<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-{
-    type Request = (T, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type Future = Dispatcher<T, S, B, X, U>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let ready = self
-            .expect
-            .poll_ready(cx)
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready();
-
-        let ready = self
-            .srv
-            .poll_ready(cx)
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready()
-            && ready;
-
-        let ready = if let Some(ref mut upg) = self.upgrade {
-            upg.poll_ready(cx)
-                .map_err(|e| {
-                    let e = e.into();
-                    log::error!("Http service readiness error: {:?}", e);
-                    DispatchError::Service(e)
-                })?
-                .is_ready()
-                && ready
-        } else {
-            ready
-        };
-
-        if ready {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        Dispatcher::new(
-            io,
-            self.cfg.clone(),
-            self.srv.clone(),
-            self.expect.clone(),
-            self.upgrade.clone(),
-            on_connect,
-            addr,
-        )
-    }
-}
-
-/// `ServiceFactory` implementation for `OneRequestService` service
-#[derive(Default)]
-pub struct OneRequest<T> {
-    config: ServiceConfig,
-    _t: PhantomData<T>,
-}
-
-impl<T> OneRequest<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    /// Create new `H1SimpleService` instance.
-    pub fn new() -> Self {
-        OneRequest {
-            config: ServiceConfig::default(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> ServiceFactory for OneRequest<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Config = ();
-    type Request = T;
-    type Response = (Request, Framed<T, Codec>);
-    type Error = ParseError;
-    type InitError = ();
-    type Service = OneRequestService<T>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(OneRequestService {
-            _t: PhantomData,
-            config: self.config.clone(),
-        })
-    }
-}
-
-/// `Service` implementation for HTTP1 transport. Reads one request and returns
-/// request and framed object.
-pub struct OneRequestService<T> {
-    _t: PhantomData<T>,
-    config: ServiceConfig,
-}
-
-impl<T> Service for OneRequestService<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Request = T;
-    type Response = (Request, Framed<T, Codec>);
-    type Error = ParseError;
-    type Future = OneRequestServiceResponse<T>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        OneRequestServiceResponse {
-            framed: Some(Framed::new(req, Codec::new(self.config.clone()))),
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct OneRequestServiceResponse<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    #[pin]
-    framed: Option<Framed<T, Codec>>,
-}
-
-impl<T> Future for OneRequestServiceResponse<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Output = Result<(Request, Framed<T, Codec>), ParseError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-
-        match ready!(this.framed.as_pin_mut().unwrap().next_item(cx)) {
-            Some(Ok(req)) => match req {
-                Message::Item(req) => {
-                    let mut this = self.as_mut().project();
-                    Poll::Ready(Ok((req, this.framed.take().unwrap())))
-                }
-                Message::Chunk(_) => unreachable!("Something is wrong"),
-            },
-            Some(Err(err)) => Poll::Ready(Err(err)),
-            None => Poll::Ready(Err(ParseError::Incomplete)),
-        }
-    }
-}

actix-http/src/h1/upgrade.rs

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

actix-http/src/h1/utils.rs

@@ -1,115 +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, ResponseBody};
-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<ResponseBody<B>>,
-    #[pin]
-    framed: Option<Framed<T, Codec>>,
-}
-
-impl<T, B> SendResponse<T, B>
-where
-    B: MessageBody,
-{
-    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,
-{
-    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()
-                {
-                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
-                        Poll::Ready(item) => {
-                            // body is done when item is None
-                            body_done = item.is_none();
-                            if body_done {
-                                let _ = this.body.take();
-                            }
-                            let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                            framed.write(Message::Chunk(item))?;
-                        }
-                        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)? {
-                    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)?;
-                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,363 +0,0 @@
-use std::convert::TryFrom;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::net;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{Delay, Instant};
-use actix_service::Service;
-use bytes::{Bytes, BytesMut};
-use h2::server::{Connection, SendResponse};
-use h2::SendStream;
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use log::{error, trace};
-
-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::helpers::DataFactory;
-use crate::httpmessage::HttpMessage;
-use crate::message::ResponseHead;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-
-const CHUNK_SIZE: usize = 16_384;
-
-/// Dispatcher for HTTP/2 protocol
-#[pin_project::pin_project]
-pub struct Dispatcher<T, S: Service<Request = Request>, B: MessageBody>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    service: CloneableService<S>,
-    connection: Connection<T, Bytes>,
-    on_connect: Option<Box<dyn DataFactory>>,
-    config: ServiceConfig,
-    peer_addr: Option<net::SocketAddr>,
-    ka_expire: Instant,
-    ka_timer: Option<Delay>,
-    _t: PhantomData<B>,
-}
-
-impl<T, S, B> Dispatcher<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    // S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    pub(crate) fn new(
-        service: CloneableService<S>,
-        connection: Connection<T, Bytes>,
-        on_connect: Option<Box<dyn DataFactory>>,
-        config: ServiceConfig,
-        timeout: Option<Delay>,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        // let keepalive = config.keep_alive_enabled();
-        // let flags = if keepalive {
-        // Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
-        // } else {
-        //     Flags::empty()
-        // };
-
-        // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
-            (delay.deadline(), Some(delay))
-        } else if let Some(delay) = config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
-        };
-
-        Dispatcher {
-            service,
-            config,
-            peer_addr,
-            connection,
-            on_connect,
-            ka_expire,
-            ka_timer,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B> Future for Dispatcher<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    type Output = Result<(), DispatchError>;
-
-    #[inline]
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
-        loop {
-            match Pin::new(&mut this.connection).poll_accept(cx) {
-                Poll::Ready(None) => return Poll::Ready(Ok(())),
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Err(err.into())),
-                Poll::Ready(Some(Ok((req, res)))) => {
-                    // update keep-alive expire
-                    if this.ka_timer.is_some() {
-                        if let Some(expire) = this.config.keep_alive_expire() {
-                            this.ka_expire = expire;
-                        }
-                    }
-
-                    let (parts, body) = req.into_parts();
-                    let mut req = Request::with_payload(Payload::<
-                        crate::payload::PayloadStream,
-                    >::H2(
-                        crate::h2::Payload::new(body)
-                    ));
-
-                    let head = &mut req.head_mut();
-                    head.uri = parts.uri;
-                    head.method = parts.method;
-                    head.version = parts.version;
-                    head.headers = parts.headers.into();
-                    head.peer_addr = this.peer_addr;
-
-                    // set on_connect data
-                    if let Some(ref on_connect) = this.on_connect {
-                        on_connect.set(&mut req.extensions_mut());
-                    }
-
-                    actix_rt::spawn(ServiceResponse::<
-                        S::Future,
-                        S::Response,
-                        S::Error,
-                        B,
-                    > {
-                        state: ServiceResponseState::ServiceCall(
-                            this.service.call(req),
-                            Some(res),
-                        ),
-                        config: this.config.clone(),
-                        buffer: None,
-                        _t: PhantomData,
-                    });
-                }
-                Poll::Pending => return Poll::Pending,
-            }
-        }
-    }
-}
-
-#[pin_project::pin_project]
-struct ServiceResponse<F, I, E, B> {
-    #[pin]
-    state: ServiceResponseState<F, B>,
-    config: ServiceConfig,
-    buffer: Option<Bytes>,
-    _t: PhantomData<(I, E)>,
-}
-
-#[pin_project::pin_project(project = ServiceResponseStateProj)]
-enum ServiceResponseState<F, B> {
-    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
-}
-
-impl<F, I, E, B> ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    fn prepare_response(
-        &self,
-        head: &ResponseHead,
-        size: &mut BodySize,
-    ) -> http::Response<()> {
-        let mut has_date = false;
-        let mut skip_len = size != &BodySize::Stream;
-
-        let mut res = http::Response::new(());
-        *res.status_mut() = head.status;
-        *res.version_mut() = http::Version::HTTP_2;
-
-        // Content length
-        match head.status {
-            http::StatusCode::NO_CONTENT
-            | http::StatusCode::CONTINUE
-            | http::StatusCode::PROCESSING => *size = BodySize::None,
-            http::StatusCode::SWITCHING_PROTOCOLS => {
-                skip_len = true;
-                *size = BodySize::Stream;
-            }
-            _ => (),
-        }
-        let _ = match size {
-            BodySize::None | BodySize::Stream => None,
-            BodySize::Empty => res
-                .headers_mut()
-                .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-            BodySize::Sized(len) => res.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::try_from(format!("{}", len)).unwrap(),
-            ),
-        };
-
-        // copy headers
-        for (key, value) in head.headers.iter() {
-            match *key {
-                CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
-                CONTENT_LENGTH if skip_len => continue,
-                DATE => has_date = true,
-                _ => (),
-            }
-            res.headers_mut().append(key, value.clone());
-        }
-
-        // set date header
-        if !has_date {
-            let mut bytes = BytesMut::with_capacity(29);
-            self.config.set_date_header(&mut bytes);
-            res.headers_mut().insert(
-                DATE,
-                // SAFETY: serialized date-times are known ASCII strings
-                unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
-            );
-        }
-
-        res
-    }
-}
-
-impl<F, I, E, B> Future for ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.project() {
-            ServiceResponseStateProj::ServiceCall(call, send) => match call.poll(cx) {
-                Poll::Ready(Ok(res)) => {
-                    let (res, body) = res.into().replace_body(());
-
-                    let mut send = send.take().unwrap();
-                    let mut size = body.size();
-                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
-
-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
-                        }
-                        Ok(stream) => stream,
-                    };
-
-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state
-                            .set(ServiceResponseState::SendPayload(stream, body));
-                        self.poll(cx)
-                    }
-                }
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(Err(e)) => {
-                    let res: Response = e.into().into();
-                    let (res, body) = res.replace_body(());
-
-                    let mut send = send.take().unwrap();
-                    let mut size = body.size();
-                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
-
-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
-                        }
-                        Ok(stream) => stream,
-                    };
-
-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state.set(ServiceResponseState::SendPayload(
-                            stream,
-                            body.into_body(),
-                        ));
-                        self.poll(cx)
-                    }
-                }
-            },
-            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
-                loop {
-                    loop {
-                        if let Some(ref mut buffer) = this.buffer {
-                            match stream.poll_capacity(cx) {
-                                Poll::Pending => return Poll::Pending,
-                                Poll::Ready(None) => return Poll::Ready(()),
-                                Poll::Ready(Some(Ok(cap))) => {
-                                    let len = buffer.len();
-                                    let bytes = buffer.split_to(std::cmp::min(cap, len));
-
-                                    if let Err(e) = stream.send_data(bytes, false) {
-                                        warn!("{:?}", e);
-                                        return Poll::Ready(());
-                                    } else if !buffer.is_empty() {
-                                        let cap =
-                                            std::cmp::min(buffer.len(), CHUNK_SIZE);
-                                        stream.reserve_capacity(cap);
-                                    } else {
-                                        this.buffer.take();
-                                    }
-                                }
-                                Poll::Ready(Some(Err(e))) => {
-                                    warn!("{:?}", e);
-                                    return Poll::Ready(());
-                                }
-                            }
-                        } else {
-                            match body.as_mut().poll_next(cx) {
-                                Poll::Pending => return Poll::Pending,
-                                Poll::Ready(None) => {
-                                    if let Err(e) = stream.send_data(Bytes::new(), true)
-                                    {
-                                        warn!("{:?}", e);
-                                    }
-                                    return Poll::Ready(());
-                                }
-                                Poll::Ready(Some(Ok(chunk))) => {
-                                    stream.reserve_capacity(std::cmp::min(
-                                        chunk.len(),
-                                        CHUNK_SIZE,
-                                    ));
-                                    *this.buffer = Some(chunk);
-                                }
-                                Poll::Ready(Some(Err(e))) => {
-                                    error!("Response payload stream error: {:?}", e);
-                                    return Poll::Ready(());
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

actix-http/src/h2/mod.rs

@@ -1,50 +0,0 @@
-//! HTTP/2 implementation
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use bytes::Bytes;
-use futures_core::Stream;
-use h2::RecvStream;
-
-mod dispatcher;
-mod service;
-
-pub use self::dispatcher::Dispatcher;
-pub use self::service::H2Service;
-use crate::error::PayloadError;
-
-/// H2 receive stream
-pub struct Payload {
-    pl: RecvStream,
-}
-
-impl Payload {
-    pub(crate) fn new(pl: RecvStream) -> Self {
-        Self { pl }
-    }
-}
-
-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 Pin::new(&mut this.pl).poll_data(cx) {
-            Poll::Ready(Some(Ok(chunk))) => {
-                let len = chunk.len();
-                if let Err(err) = this.pl.flow_control().release_capacity(len) {
-                    Poll::Ready(Some(Err(err.into())))
-                } else {
-                    Poll::Ready(Some(Ok(chunk)))
-                }
-            }
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err.into()))),
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(None) => Poll::Ready(None),
-        }
-    }
-}

actix-http/src/h2/service.rs

@@ -1,384 +0,0 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{net, rc};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
-use actix_service::{
-    fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
-    ServiceFactory,
-};
-use bytes::Bytes;
-use futures_core::ready;
-use futures_util::future::ok;
-use h2::server::{self, Handshake};
-use log::error;
-
-use crate::body::MessageBody;
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::helpers::DataFactory;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::dispatcher::Dispatcher;
-
-/// `ServiceFactory` implementation for HTTP2 transport
-pub struct H2Service<T, S, B> {
-    srv: S,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> H2Service<T, S, B>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        H2Service {
-            cfg,
-            on_connect: None,
-            srv: service.into_factory(),
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<S, B> H2Service<TcpStream, S, B>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create simple tcp based service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        Config = (),
-        Request = TcpStream,
-        Response = (),
-        Error = DispatchError,
-        InitError = S::InitError,
-    > {
-        pipeline_factory(fn_factory(|| async {
-            Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
-                let peer_addr = io.peer_addr().ok();
-                ok::<_, DispatchError>((io, peer_addr))
-            }))
-        }))
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use actix_service::{fn_factory, fn_service};
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, TlsError};
-
-    use super::*;
-
-    impl<S, B> H2Service<SslStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create ssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
-            InitError = S::InitError,
-        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ok::<_, S::InitError>(fn_service(|io: SslStream<TcpStream>| {
-                    let peer_addr = io.get_ref().peer_addr().ok();
-                    ok((io, peer_addr))
-                }))
-            }))
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::TlsError;
-    use std::io;
-
-    impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create openssl based service
-        pub fn rustls(
-            self,
-            mut config: ServerConfig,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<io::Error, DispatchError>,
-            InitError = S::InitError,
-        > {
-            let protos = vec!["h2".to_string().into()];
-            config.set_protocols(&protos);
-
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ok::<_, S::InitError>(fn_service(|io: TlsStream<TcpStream>| {
-                    let peer_addr = io.get_ref().0.peer_addr().ok();
-                    ok((io, peer_addr))
-                }))
-            }))
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-impl<T, S, B> ServiceFactory for H2Service<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = S::InitError;
-    type Service = H2ServiceHandler<T, S::Service, B>;
-    type Future = H2ServiceResponse<T, S, B>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        H2ServiceResponse {
-            fut: self.srv.new_service(()),
-            cfg: Some(self.cfg.clone()),
-            on_connect: self.on_connect.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
-    #[pin]
-    fut: S::Future,
-    cfg: Option<ServiceConfig>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> Future for H2ServiceResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Output = Result<H2ServiceHandler<T, S::Service, B>, S::InitError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-
-        Poll::Ready(ready!(this.fut.poll(cx)).map(|service| {
-            let this = self.as_mut().project();
-            H2ServiceHandler::new(
-                this.cfg.take().unwrap(),
-                this.on_connect.clone(),
-                service,
-            )
-        }))
-    }
-}
-
-/// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, S: Service, B> {
-    srv: CloneableService<S>,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> H2ServiceHandler<T, S, B>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    fn new(
-        cfg: ServiceConfig,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-        srv: S,
-    ) -> H2ServiceHandler<T, S, B> {
-        H2ServiceHandler {
-            cfg,
-            on_connect,
-            srv: CloneableService::new(srv),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B> Service for H2ServiceHandler<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    type Request = (T, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type Future = H2ServiceHandlerResponse<T, S, B>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.srv.poll_ready(cx).map_err(|e| {
-            let e = e.into();
-            error!("Service readiness error: {:?}", e);
-            DispatchError::Service(e)
-        })
-    }
-
-    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        H2ServiceHandlerResponse {
-            state: State::Handshake(
-                Some(self.srv.clone()),
-                Some(self.cfg.clone()),
-                addr,
-                on_connect,
-                server::handshake(io),
-            ),
-        }
-    }
-}
-
-enum State<T, S: Service<Request = Request>, B: MessageBody>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S::Future: 'static,
-{
-    Incoming(Dispatcher<T, S, B>),
-    Handshake(
-        Option<CloneableService<S>>,
-        Option<ServiceConfig>,
-        Option<net::SocketAddr>,
-        Option<Box<dyn DataFactory>>,
-        Handshake<T, Bytes>,
-    ),
-}
-
-pub struct H2ServiceHandlerResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    state: State<T, S, B>,
-}
-
-impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody,
-{
-    type Output = Result<(), DispatchError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.state {
-            State::Incoming(ref mut disp) => Pin::new(disp).poll(cx),
-            State::Handshake(
-                ref mut srv,
-                ref mut config,
-                ref peer_addr,
-                ref mut on_connect,
-                ref mut handshake,
-            ) => match Pin::new(handshake).poll(cx) {
-                Poll::Ready(Ok(conn)) => {
-                    self.state = State::Incoming(Dispatcher::new(
-                        srv.take().unwrap(),
-                        conn,
-                        on_connect.take(),
-                        config.take().unwrap(),
-                        None,
-                        *peer_addr,
-                    ));
-                    self.poll(cx)
-                }
-                Poll::Ready(Err(err)) => {
-                    trace!("H2 handshake error: {}", err);
-                    Poll::Ready(Err(err.into()))
-                }
-                Poll::Pending => Poll::Pending,
-            },
-        }
-    }
-}

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

@@ -1,989 +0,0 @@
-// # References
-//
-// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
-// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
-// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc7578.txt
-// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
-// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
-
-use lazy_static::lazy_static;
-use regex::Regex;
-use std::fmt::{self, Write};
-
-use crate::header::{self, ExtendedValue, Header, IntoHeaderValue, Writer};
-
-/// Split at the index of the first `needle` if it exists or at the end.
-fn split_once(haystack: &str, needle: char) -> (&str, &str) {
-    haystack.find(needle).map_or_else(
-        || (haystack, ""),
-        |sc| {
-            let (first, last) = haystack.split_at(sc);
-            (first, last.split_at(1).1)
-        },
-    )
-}
-
-/// Split at the index of the first `needle` if it exists or at the end, trim the right of the
-/// first part and the left of the last part.
-fn split_once_and_trim(haystack: &str, needle: char) -> (&str, &str) {
-    let (first, last) = split_once(haystack, needle);
-    (first.trim_end(), last.trim_start())
-}
-
-/// The implied disposition of the content of the HTTP body.
-#[derive(Clone, Debug, PartialEq)]
-pub enum DispositionType {
-    /// Inline implies default processing
-    Inline,
-    /// Attachment implies that the recipient should prompt the user to save the response locally,
-    /// rather than process it normally (as per its media type).
-    Attachment,
-    /// Used in *multipart/form-data* as defined in
-    /// [RFC7578](https://tools.ietf.org/html/rfc7578) to carry the field name and the file name.
-    FormData,
-    /// Extension type. Should be handled by recipients the same way as Attachment
-    Ext(String),
-}
-
-impl<'a> From<&'a str> for DispositionType {
-    fn from(origin: &'a str) -> DispositionType {
-        if origin.eq_ignore_ascii_case("inline") {
-            DispositionType::Inline
-        } else if origin.eq_ignore_ascii_case("attachment") {
-            DispositionType::Attachment
-        } else if origin.eq_ignore_ascii_case("form-data") {
-            DispositionType::FormData
-        } else {
-            DispositionType::Ext(origin.to_owned())
-        }
-    }
-}
-
-/// Parameter in [`ContentDisposition`].
-///
-/// # Examples
-/// ```
-/// use actix_http::http::header::DispositionParam;
-///
-/// let param = DispositionParam::Filename(String::from("sample.txt"));
-/// assert!(param.is_filename());
-/// assert_eq!(param.as_filename().unwrap(), "sample.txt");
-/// ```
-#[derive(Clone, Debug, PartialEq)]
-#[allow(clippy::large_enum_variant)]
-pub enum DispositionParam {
-    /// For [`DispositionType::FormData`] (i.e. *multipart/form-data*), the name of an field from
-    /// the form.
-    Name(String),
-    /// A plain file name.
-    ///
-    /// It is [not supposed](https://tools.ietf.org/html/rfc6266#appendix-D) to contain any
-    /// non-ASCII characters when used in a *Content-Disposition* HTTP response header, where
-    /// [`FilenameExt`](DispositionParam::FilenameExt) with charset UTF-8 may be used instead
-    /// in case there are Unicode characters in file names.
-    Filename(String),
-    /// An extended file name. It must not exist for `ContentType::Formdata` according to
-    /// [RFC7578 Section 4.2](https://tools.ietf.org/html/rfc7578#section-4.2).
-    FilenameExt(ExtendedValue),
-    /// An unrecognized regular parameter as defined in
-    /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *reg-parameter*, in
-    /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *token "=" value*. Recipients should
-    /// ignore unrecognizable parameters.
-    Unknown(String, String),
-    /// An unrecognized extended parameter as defined in
-    /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *ext-parameter*, in
-    /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *ext-token "=" ext-value*. The single
-    /// trailing asterisk is not included. Recipients should ignore unrecognizable parameters.
-    UnknownExt(String, ExtendedValue),
-}
-
-impl DispositionParam {
-    /// Returns `true` if the parameter is [`Name`](DispositionParam::Name).
-    #[inline]
-    pub fn is_name(&self) -> bool {
-        self.as_name().is_some()
-    }
-
-    /// Returns `true` if the parameter is [`Filename`](DispositionParam::Filename).
-    #[inline]
-    pub fn is_filename(&self) -> bool {
-        self.as_filename().is_some()
-    }
-
-    /// Returns `true` if the parameter is [`FilenameExt`](DispositionParam::FilenameExt).
-    #[inline]
-    pub fn is_filename_ext(&self) -> bool {
-        self.as_filename_ext().is_some()
-    }
-
-    /// Returns `true` if the parameter is [`Unknown`](DispositionParam::Unknown) and the `name`
-    #[inline]
-    /// matches.
-    pub fn is_unknown<T: AsRef<str>>(&self, name: T) -> bool {
-        self.as_unknown(name).is_some()
-    }
-
-    /// Returns `true` if the parameter is [`UnknownExt`](DispositionParam::UnknownExt) and the
-    /// `name` matches.
-    #[inline]
-    pub fn is_unknown_ext<T: AsRef<str>>(&self, name: T) -> bool {
-        self.as_unknown_ext(name).is_some()
-    }
-
-    /// Returns the name if applicable.
-    #[inline]
-    pub fn as_name(&self) -> Option<&str> {
-        match self {
-            DispositionParam::Name(ref name) => Some(name.as_str()),
-            _ => None,
-        }
-    }
-
-    /// Returns the filename if applicable.
-    #[inline]
-    pub fn as_filename(&self) -> Option<&str> {
-        match self {
-            DispositionParam::Filename(ref filename) => Some(filename.as_str()),
-            _ => None,
-        }
-    }
-
-    /// Returns the filename* if applicable.
-    #[inline]
-    pub fn as_filename_ext(&self) -> Option<&ExtendedValue> {
-        match self {
-            DispositionParam::FilenameExt(ref value) => Some(value),
-            _ => None,
-        }
-    }
-
-    /// Returns the value of the unrecognized regular parameter if it is
-    /// [`Unknown`](DispositionParam::Unknown) and the `name` matches.
-    #[inline]
-    pub fn as_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
-        match self {
-            DispositionParam::Unknown(ref ext_name, ref value)
-                if ext_name.eq_ignore_ascii_case(name.as_ref()) =>
-            {
-                Some(value.as_str())
-            }
-            _ => None,
-        }
-    }
-
-    /// Returns the value of the unrecognized extended parameter if it is
-    /// [`Unknown`](DispositionParam::Unknown) and the `name` matches.
-    #[inline]
-    pub fn as_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&ExtendedValue> {
-        match self {
-            DispositionParam::UnknownExt(ref ext_name, ref value)
-                if ext_name.eq_ignore_ascii_case(name.as_ref()) =>
-            {
-                Some(value)
-            }
-            _ => None,
-        }
-    }
-}
-
-/// A *Content-Disposition* header. It is compatible to be used either as
-/// [a response header for the main body](https://mdn.io/Content-Disposition#As_a_response_header_for_the_main_body)
-/// as (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266), or as
-/// [a header for a multipart body](https://mdn.io/Content-Disposition#As_a_header_for_a_multipart_body)
-/// as (re)defined in [RFC7587](https://tools.ietf.org/html/rfc7578).
-///
-/// In a regular HTTP response, the *Content-Disposition* response header is a header indicating if
-/// the content is expected to be displayed *inline* in the browser, that is, as a Web page or as
-/// part of a Web page, or as an attachment, that is downloaded and saved locally, and also can be
-/// used to attach additional metadata, such as the filename to use when saving the response payload
-/// locally.
-///
-/// In a *multipart/form-data* body, the HTTP *Content-Disposition* general header is a header that
-/// can be used on the subpart of a multipart body to give information about the field it applies to.
-/// The subpart is delimited by the boundary defined in the *Content-Type* header. Used on the body
-/// itself, *Content-Disposition* has no effect.
-///
-/// # ABNF
-
-/// ```text
-/// content-disposition = "Content-Disposition" ":"
-///                       disposition-type *( ";" disposition-parm )
-///
-/// disposition-type    = "inline" | "attachment" | disp-ext-type
-///                       ; case-insensitive
-///
-/// disp-ext-type       = token
-///
-/// disposition-parm    = filename-parm | disp-ext-parm
-///
-/// filename-parm       = "filename" "=" value
-///                     | "filename*" "=" ext-value
-///
-/// disp-ext-parm       = token "=" value
-///                     | ext-token "=" ext-value
-///
-/// ext-token           = <the characters in token, followed by "*">
-/// ```
-///
-/// # Note
-///
-/// filename is [not supposed](https://tools.ietf.org/html/rfc6266#appendix-D) to contain any
-/// non-ASCII characters when used in a *Content-Disposition* HTTP response header, where
-/// filename* with charset UTF-8 may be used instead in case there are Unicode characters in file
-/// names.
-/// filename is [acceptable](https://tools.ietf.org/html/rfc7578#section-4.2) to be UTF-8 encoded
-/// directly in a *Content-Disposition* header for *multipart/form-data*, though.
-///
-/// filename* [must not](https://tools.ietf.org/html/rfc7578#section-4.2) be used within
-/// *multipart/form-data*.
-///
-/// # Example
-///
-/// ```
-/// use actix_http::http::header::{
-///     Charset, ContentDisposition, DispositionParam, DispositionType,
-///     ExtendedValue,
-/// };
-///
-/// let cd1 = ContentDisposition {
-///     disposition: DispositionType::Attachment,
-///     parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-///         charset: Charset::Iso_8859_1, // The character set for the bytes of the filename
-///         language_tag: None, // The optional language tag (see `language-tag` crate)
-///         value: b"\xa9 Copyright 1989.txt".to_vec(), // the actual bytes of the filename
-///     })],
-/// };
-/// assert!(cd1.is_attachment());
-/// assert!(cd1.get_filename_ext().is_some());
-///
-/// let cd2 = ContentDisposition {
-///     disposition: DispositionType::FormData,
-///     parameters: vec![
-///         DispositionParam::Name(String::from("file")),
-///         DispositionParam::Filename(String::from("bill.odt")),
-///     ],
-/// };
-/// assert_eq!(cd2.get_name(), Some("file")); // field name
-/// assert_eq!(cd2.get_filename(), Some("bill.odt"));
-///
-/// // HTTP response header with Unicode characters in file names
-/// let cd3 = ContentDisposition {
-///     disposition: DispositionType::Attachment,
-///     parameters: vec![
-///         DispositionParam::FilenameExt(ExtendedValue {
-///             charset: Charset::Ext(String::from("UTF-8")),
-///             language_tag: None,
-///             value: String::from("\u{1f600}.svg").into_bytes(),
-///         }),
-///         // fallback for better compatibility
-///         DispositionParam::Filename(String::from("Grinning-Face-Emoji.svg"))
-///     ],
-/// };
-/// assert_eq!(cd3.get_filename_ext().map(|ev| ev.value.as_ref()),
-///            Some("\u{1f600}.svg".as_bytes()));
-/// ```
-///
-/// # Security Note
-///
-/// If "filename" parameter is supplied, do not use the file name blindly, check and possibly
-/// change to match local file system conventions if applicable, and do not use directory path
-/// information that may be present. See [RFC2183](https://tools.ietf.org/html/rfc2183#section-2.3).
-#[derive(Clone, Debug, PartialEq)]
-pub struct ContentDisposition {
-    /// The disposition type
-    pub disposition: DispositionType,
-    /// Disposition parameters
-    pub parameters: Vec<DispositionParam>,
-}
-
-impl ContentDisposition {
-    /// Parse a raw Content-Disposition header value.
-    pub fn from_raw(hv: &header::HeaderValue) -> Result<Self, crate::error::ParseError> {
-        // `header::from_one_raw_str` invokes `hv.to_str` which assumes `hv` contains only visible
-        //  ASCII characters. So `hv.as_bytes` is necessary here.
-        let hv = String::from_utf8(hv.as_bytes().to_vec())
-            .map_err(|_| crate::error::ParseError::Header)?;
-        let (disp_type, mut left) = split_once_and_trim(hv.as_str().trim(), ';');
-        if disp_type.is_empty() {
-            return Err(crate::error::ParseError::Header);
-        }
-        let mut cd = ContentDisposition {
-            disposition: disp_type.into(),
-            parameters: Vec::new(),
-        };
-
-        while !left.is_empty() {
-            let (param_name, new_left) = split_once_and_trim(left, '=');
-            if param_name.is_empty() || param_name == "*" || new_left.is_empty() {
-                return Err(crate::error::ParseError::Header);
-            }
-            left = new_left;
-            if param_name.ends_with('*') {
-                // extended parameters
-                let param_name = &param_name[..param_name.len() - 1]; // trim asterisk
-                let (ext_value, new_left) = split_once_and_trim(left, ';');
-                left = new_left;
-                let ext_value = header::parse_extended_value(ext_value)?;
-
-                let param = if param_name.eq_ignore_ascii_case("filename") {
-                    DispositionParam::FilenameExt(ext_value)
-                } else {
-                    DispositionParam::UnknownExt(param_name.to_owned(), ext_value)
-                };
-                cd.parameters.push(param);
-            } else {
-                // regular parameters
-                let value = if left.starts_with('\"') {
-                    // quoted-string: defined in RFC6266 -> RFC2616 Section 3.6
-                    let mut escaping = false;
-                    let mut quoted_string = vec![];
-                    let mut end = None;
-                    // search for closing quote
-                    for (i, &c) in left.as_bytes().iter().skip(1).enumerate() {
-                        if escaping {
-                            escaping = false;
-                            quoted_string.push(c);
-                        } else if c == 0x5c {
-                            // backslash
-                            escaping = true;
-                        } else if c == 0x22 {
-                            // double quote
-                            end = Some(i + 1); // cuz skipped 1 for the leading quote
-                            break;
-                        } else {
-                            quoted_string.push(c);
-                        }
-                    }
-                    left = &left[end.ok_or(crate::error::ParseError::Header)? + 1..];
-                    left = split_once(left, ';').1.trim_start();
-                    // In fact, it should not be Err if the above code is correct.
-                    String::from_utf8(quoted_string)
-                        .map_err(|_| crate::error::ParseError::Header)?
-                } else {
-                    // token: won't contains semicolon according to RFC 2616 Section 2.2
-                    let (token, new_left) = split_once_and_trim(left, ';');
-                    left = new_left;
-                    if token.is_empty() {
-                        // quoted-string can be empty, but token cannot be empty
-                        return Err(crate::error::ParseError::Header);
-                    }
-                    token.to_owned()
-                };
-
-                let param = if param_name.eq_ignore_ascii_case("name") {
-                    DispositionParam::Name(value)
-                } else if param_name.eq_ignore_ascii_case("filename") {
-                    // See also comments in test_from_raw_unnecessary_percent_decode.
-                    DispositionParam::Filename(value)
-                } else {
-                    DispositionParam::Unknown(param_name.to_owned(), value)
-                };
-                cd.parameters.push(param);
-            }
-        }
-
-        Ok(cd)
-    }
-
-    /// Returns `true` if it is [`Inline`](DispositionType::Inline).
-    pub fn is_inline(&self) -> bool {
-        matches!(self.disposition, DispositionType::Inline)
-    }
-
-    /// Returns `true` if it is [`Attachment`](DispositionType::Attachment).
-    pub fn is_attachment(&self) -> bool {
-        matches!(self.disposition, DispositionType::Attachment)
-    }
-
-    /// Returns `true` if it is [`FormData`](DispositionType::FormData).
-    pub fn is_form_data(&self) -> bool {
-        matches!(self.disposition, DispositionType::FormData)
-    }
-
-    /// Returns `true` if it is [`Ext`](DispositionType::Ext) and the `disp_type` matches.
-    pub fn is_ext<T: AsRef<str>>(&self, disp_type: T) -> bool {
-        match self.disposition {
-            DispositionType::Ext(ref t)
-                if t.eq_ignore_ascii_case(disp_type.as_ref()) =>
-            {
-                true
-            }
-            _ => false,
-        }
-    }
-
-    /// Return the value of *name* if exists.
-    pub fn get_name(&self) -> Option<&str> {
-        self.parameters.iter().filter_map(|p| p.as_name()).next()
-    }
-
-    /// Return the value of *filename* if exists.
-    pub fn get_filename(&self) -> Option<&str> {
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_filename())
-            .next()
-    }
-
-    /// Return the value of *filename\** if exists.
-    pub fn get_filename_ext(&self) -> Option<&ExtendedValue> {
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_filename_ext())
-            .next()
-    }
-
-    /// Return the value of the parameter which the `name` matches.
-    pub fn get_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
-        let name = name.as_ref();
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_unknown(name))
-            .next()
-    }
-
-    /// Return the value of the extended parameter which the `name` matches.
-    pub fn get_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&ExtendedValue> {
-        let name = name.as_ref();
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_unknown_ext(name))
-            .next()
-    }
-}
-
-impl IntoHeaderValue for ContentDisposition {
-    type Error = header::InvalidHeaderValue;
-
-    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
-        let mut writer = Writer::new();
-        let _ = write!(&mut writer, "{}", self);
-        header::HeaderValue::from_maybe_shared(writer.take())
-    }
-}
-
-impl Header for ContentDisposition {
-    fn name() -> header::HeaderName {
-        header::CONTENT_DISPOSITION
-    }
-
-    fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
-        if let Some(h) = msg.headers().get(&Self::name()) {
-            Self::from_raw(&h)
-        } else {
-            Err(crate::error::ParseError::Header)
-        }
-    }
-}
-
-impl fmt::Display for DispositionType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            DispositionType::Inline => write!(f, "inline"),
-            DispositionType::Attachment => write!(f, "attachment"),
-            DispositionType::FormData => write!(f, "form-data"),
-            DispositionType::Ext(ref s) => write!(f, "{}", s),
-        }
-    }
-}
-
-impl fmt::Display for DispositionParam {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // All ASCII control characters (0-30, 127) including horizontal tab, double quote, and
-        // backslash should be escaped in quoted-string (i.e. "foobar").
-        // Ref: RFC6266 S4.1 -> RFC2616 S3.6
-        // filename-parm  = "filename" "=" value
-        // value          = token | quoted-string
-        // quoted-string  = ( <"> *(qdtext | quoted-pair ) <"> )
-        // qdtext         = <any TEXT except <">>
-        // quoted-pair    = "\" CHAR
-        // TEXT           = <any OCTET except CTLs,
-        //                  but including LWS>
-        // LWS            = [CRLF] 1*( SP | HT )
-        // OCTET          = <any 8-bit sequence of data>
-        // CHAR           = <any US-ASCII character (octets 0 - 127)>
-        // CTL            = <any US-ASCII control character
-        //                  (octets 0 - 31) and DEL (127)>
-        //
-        // Ref: RFC7578 S4.2 -> RFC2183 S2 -> RFC2045 S5.1
-        // parameter := attribute "=" value
-        // attribute := token
-        //              ; Matching of attributes
-        //              ; is ALWAYS case-insensitive.
-        // value := token / quoted-string
-        // token := 1*<any (US-ASCII) CHAR except SPACE, CTLs,
-        //             or tspecials>
-        // tspecials :=  "(" / ")" / "<" / ">" / "@" /
-        //               "," / ";" / ":" / "\" / <">
-        //               "/" / "[" / "]" / "?" / "="
-        //               ; Must be in quoted-string,
-        //               ; to use within parameter values
-        //
-        //
-        // See also comments in test_from_raw_unnecessary_percent_decode.
-        lazy_static! {
-            static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
-        }
-        match self {
-            DispositionParam::Name(ref value) => write!(f, "name={}", value),
-            DispositionParam::Filename(ref value) => {
-                write!(f, "filename=\"{}\"", RE.replace_all(value, "\\$0").as_ref())
-            }
-            DispositionParam::Unknown(ref name, ref value) => write!(
-                f,
-                "{}=\"{}\"",
-                name,
-                &RE.replace_all(value, "\\$0").as_ref()
-            ),
-            DispositionParam::FilenameExt(ref ext_value) => {
-                write!(f, "filename*={}", ext_value)
-            }
-            DispositionParam::UnknownExt(ref name, ref ext_value) => {
-                write!(f, "{}*={}", name, ext_value)
-            }
-        }
-    }
-}
-
-impl fmt::Display for ContentDisposition {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.disposition)?;
-        self.parameters
-            .iter()
-            .map(|param| write!(f, "; {}", param))
-            .collect()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{ContentDisposition, DispositionParam, DispositionType};
-    use crate::header::shared::Charset;
-    use crate::header::{ExtendedValue, HeaderValue};
-
-    #[test]
-    fn test_from_raw_basic() {
-        assert!(ContentDisposition::from_raw(&HeaderValue::from_static("")).is_err());
-
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; name=upload; filename=\"sample.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static("attachment; filename=\"image.jpg\"");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Filename("image.jpg".to_owned())],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static("inline; filename=image.jpg");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename("image.jpg".to_owned())],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "attachment; creation-date=\"Wed, 12 Feb 1997 16:29:51 -0500\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Unknown(
-                String::from("creation-date"),
-                "Wed, 12 Feb 1997 16:29:51 -0500".to_owned(),
-            )],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_extended() {
-        let a = HeaderValue::from_static(
-            "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-                charset: Charset::Ext(String::from("UTF-8")),
-                language_tag: None,
-                value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
-                    b'r', b'a', b't', b'e', b's',
-                ],
-            })],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-                charset: Charset::Ext(String::from("UTF-8")),
-                language_tag: None,
-                value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
-                    b'r', b'a', b't', b'e', b's',
-                ],
-            })],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_extra_whitespace() {
-        let a = HeaderValue::from_static(
-            "form-data  ; du-mmy= 3  ; name =upload ; filename =  \"sample.png\"  ; ",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("du-mmy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_unordered() {
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; filename=\"sample.png\" ; name=upload;",
-            // Actually, a trailing semicolon is not compliant. But it is fine to accept.
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_str(
-            "attachment; filename*=iso-8859-1''foo-%E4.html; filename=\"foo-ä.html\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![
-                DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Iso_8859_1,
-                    language_tag: None,
-                    value: b"foo-\xe4.html".to_vec(),
-                }),
-                DispositionParam::Filename("foo-ä.html".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_only_disp() {
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static("attachment"))
-            .unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-
-        let a =
-            ContentDisposition::from_raw(&HeaderValue::from_static("inline ;")).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static(
-            "unknown-disp-param",
-        ))
-        .unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Ext(String::from("unknown-disp-param")),
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn from_raw_with_mixed_case() {
-        let a = HeaderValue::from_str(
-            "InLInE; fIlenAME*=iso-8859-1''foo-%E4.html; filEName=\"foo-ä.html\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![
-                DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Iso_8859_1,
-                    language_tag: None,
-                    value: b"foo-\xe4.html".to_vec(),
-                }),
-                DispositionParam::Filename("foo-ä.html".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn from_raw_with_unicode() {
-        /* RFC7578 Section 4.2:
-        Some commonly deployed systems use multipart/form-data with file names directly encoded
-        including octets outside the US-ASCII range. The encoding used for the file names is
-        typically UTF-8, although HTML forms will use the charset associated with the form.
-
-        Mainstream browsers like Firefox (gecko) and Chrome use UTF-8 directly as above.
-        (And now, only UTF-8 is handled by this implementation.)
-        */
-        let a = HeaderValue::from_str("form-data; name=upload; filename=\"文件.webp\"")
-            .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name(String::from("upload")),
-                DispositionParam::Filename(String::from("文件.webp")),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_str(
-            "form-data; name=upload; filename=\"余固知謇謇之為患兮，忍而不能舍也.pptx\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name(String::from("upload")),
-                DispositionParam::Filename(String::from(
-                    "余固知謇謇之為患兮，忍而不能舍也.pptx",
-                )),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_escape() {
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; name=upload; filename=\"s\\amp\\\"le.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename(
-                    ['s', 'a', 'm', 'p', '\"', 'l', 'e', '.', 'p', 'n', 'g']
-                        .iter()
-                        .collect(),
-                ),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_semicolon() {
-        let a =
-            HeaderValue::from_static("form-data; filename=\"A semicolon here;.pdf\"");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![DispositionParam::Filename(String::from(
-                "A semicolon here;.pdf",
-            ))],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_unnecessary_percent_decode() {
-        // In fact, RFC7578 (multipart/form-data) Section 2 and 4.2 suggests that filename with
-        // non-ASCII characters MAY be percent-encoded.
-        // On the contrary, RFC6266 or other RFCs related to Content-Disposition response header
-        // do not mention such percent-encoding.
-        // So, it appears to be undecidable whether to percent-decode or not without
-        // knowing the usage scenario (multipart/form-data v.s. HTTP response header) and
-        // inevitable to unnecessarily percent-decode filename with %XX in the former scenario.
-        // Fortunately, it seems that almost all mainstream browsers just send UTF-8 encoded file
-        // names in quoted-string format (tested on Edge, IE11, Chrome and Firefox) without
-        // percent-encoding. So we do not bother to attempt to percent-decode.
-        let a = HeaderValue::from_static(
-            "form-data; name=photo; filename=\"%74%65%73%74%2e%70%6e%67\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name("photo".to_owned()),
-                DispositionParam::Filename(String::from("%74%65%73%74%2e%70%6e%67")),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "form-data; name=photo; filename=\"%74%65%73%74.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name("photo".to_owned()),
-                DispositionParam::Filename(String::from("%74%65%73%74.png")),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_param_value_missing() {
-        let a = HeaderValue::from_static("form-data; name=upload ; filename=");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("attachment; dummy=; filename=invoice.pdf");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; filename=  ");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; filename=\"\"");
-        assert!(ContentDisposition::from_raw(&a)
-            .expect("parse cd")
-            .get_filename()
-            .expect("filename")
-            .is_empty());
-    }
-
-    #[test]
-    fn test_from_raw_param_name_missing() {
-        let a = HeaderValue::from_static("inline; =\"test.txt\"");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; =diary.odt");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; =");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-    }
-
-    #[test]
-    fn test_display_extended() {
-        let as_string =
-            "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-
-        let a = HeaderValue::from_static("attachment; filename=colourful.csv");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(
-            "attachment; filename=\"colourful.csv\"".to_owned(),
-            display_rendered
-        );
-    }
-
-    #[test]
-    fn test_display_quote() {
-        let as_string = "form-data; name=upload; filename=\"Quote\\\"here.png\"";
-        as_string
-            .find(['\\', '\"'].iter().collect::<String>().as_str())
-            .unwrap(); // ensure `\"` is there
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-    }
-
-    #[test]
-    fn test_display_space_tab() {
-        let as_string = "form-data; name=upload; filename=\"Space here.png\"";
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-
-        let a: ContentDisposition = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename(String::from("Tab\there.png"))],
-        };
-        let display_rendered = format!("{}", a);
-        assert_eq!("inline; filename=\"Tab\x09here.png\"", display_rendered);
-    }
-
-    #[test]
-    fn test_display_control_characters() {
-        /* let a = "attachment; filename=\"carriage\rreturn.png\"";
-        let a = HeaderValue::from_static(a);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(
-            "attachment; filename=\"carriage\\\rreturn.png\"",
-            display_rendered
-        );*/
-        // No way to create a HeaderValue containing a carriage return.
-
-        let a: ContentDisposition = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename(String::from("bell\x07.png"))],
-        };
-        let display_rendered = format!("{}", a);
-        assert_eq!("inline; filename=\"bell\\\x07.png\"", display_rendered);
-    }
-
-    #[test]
-    fn test_param_methods() {
-        let param = DispositionParam::Filename(String::from("sample.txt"));
-        assert!(param.is_filename());
-        assert_eq!(param.as_filename().unwrap(), "sample.txt");
-
-        let param = DispositionParam::Unknown(String::from("foo"), String::from("bar"));
-        assert!(param.is_unknown("foo"));
-        assert_eq!(param.as_unknown("fOo"), Some("bar"));
-    }
-
-    #[test]
-    fn test_disposition_methods() {
-        let cd = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(cd.get_name(), Some("upload"));
-        assert_eq!(cd.get_unknown("dummy"), Some("3"));
-        assert_eq!(cd.get_filename(), Some("sample.png"));
-        assert_eq!(cd.get_unknown_ext("dummy"), None);
-        assert_eq!(cd.get_unknown("duMMy"), Some("3"));
-    }
-}

actix-http/src/header/map.rs

@@ -1,385 +0,0 @@
-use std::collections::hash_map::{self, Entry};
-use std::convert::TryFrom;
-
-use either::Either;
-use fxhash::FxHashMap;
-use http::header::{HeaderName, HeaderValue};
-
-/// A set of HTTP headers
-///
-/// `HeaderMap` is an multi-map of [`HeaderName`] to values.
-///
-/// [`HeaderName`]: struct.HeaderName.html
-#[derive(Debug, Clone)]
-pub struct HeaderMap {
-    pub(crate) inner: FxHashMap<HeaderName, Value>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum Value {
-    One(HeaderValue),
-    Multi(Vec<HeaderValue>),
-}
-
-impl Value {
-    fn get(&self) -> &HeaderValue {
-        match self {
-            Value::One(ref val) => val,
-            Value::Multi(ref val) => &val[0],
-        }
-    }
-
-    fn get_mut(&mut self) -> &mut HeaderValue {
-        match self {
-            Value::One(ref mut val) => val,
-            Value::Multi(ref mut val) => &mut val[0],
-        }
-    }
-
-    fn append(&mut self, val: HeaderValue) {
-        match self {
-            Value::One(_) => {
-                let data = std::mem::replace(self, Value::Multi(vec![val]));
-                match data {
-                    Value::One(val) => self.append(val),
-                    Value::Multi(_) => unreachable!(),
-                }
-            }
-            Value::Multi(ref mut vec) => vec.push(val),
-        }
-    }
-}
-
-impl HeaderMap {
-    /// Create an empty `HeaderMap`.
-    ///
-    /// The map will be created without any capacity. This function will not
-    /// allocate.
-    pub fn new() -> Self {
-        HeaderMap {
-            inner: FxHashMap::default(),
-        }
-    }
-
-    /// Create an empty `HeaderMap` with the specified capacity.
-    ///
-    /// The returned map will allocate internal storage in order to hold about
-    /// `capacity` elements without reallocating. However, this is a "best
-    /// effort" as there are usage patterns that could cause additional
-    /// allocations before `capacity` headers are stored in the map.
-    ///
-    /// More capacity than requested may be allocated.
-    pub fn with_capacity(capacity: usize) -> HeaderMap {
-        HeaderMap {
-            inner: FxHashMap::with_capacity_and_hasher(capacity, Default::default()),
-        }
-    }
-
-    /// Returns the number of keys stored in the map.
-    ///
-    /// This number could be be less than or equal to actual headers stored in
-    /// the map.
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0
-    }
-
-    /// Clears the map, removing all key-value pairs. Keeps the allocated memory
-    /// for reuse.
-    pub fn clear(&mut self) {
-        self.inner.clear();
-    }
-
-    /// Returns the number of headers the map can hold without reallocating.
-    ///
-    /// This number is an approximation as certain usage patterns could cause
-    /// additional allocations before the returned capacity is filled.
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    /// Reserves capacity for at least `additional` more headers to be inserted
-    /// into the `HeaderMap`.
-    ///
-    /// The header map may reserve more space to avoid frequent reallocations.
-    /// Like with `with_capacity`, this will be a "best effort" to avoid
-    /// allocations until `additional` more headers are inserted. Certain usage
-    /// patterns could cause additional allocations before the number is
-    /// reached.
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    /// Returns a reference to the value associated with the key.
-    ///
-    /// If there are multiple values associated with the key, then the first one
-    /// is returned. Use `get_all` to get all values associated with a given
-    /// key. Returns `None` if there are no values associated with the key.
-    pub fn get<N: AsName>(&self, name: N) -> Option<&HeaderValue> {
-        self.get2(name).map(|v| v.get())
-    }
-
-    fn get2<N: AsName>(&self, name: N) -> Option<&Value> {
-        match name.as_name() {
-            Either::Left(name) => self.inner.get(name),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.get(&name)
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    /// Returns a view of all values associated with a key.
-    ///
-    /// The returned view does not incur any allocations and allows iterating
-    /// the values associated with the key.  See [`GetAll`] for more details.
-    /// Returns `None` if there are no values associated with the key.
-    ///
-    /// [`GetAll`]: struct.GetAll.html
-    pub fn get_all<N: AsName>(&self, name: N) -> GetAll<'_> {
-        GetAll {
-            idx: 0,
-            item: self.get2(name),
-        }
-    }
-
-    /// Returns a mutable reference to the value associated with the key.
-    ///
-    /// If there are multiple values associated with the key, then the first one
-    /// is returned. Use `entry` to get all values associated with a given
-    /// key. Returns `None` if there are no values associated with the key.
-    pub fn get_mut<N: AsName>(&mut self, name: N) -> Option<&mut HeaderValue> {
-        match name.as_name() {
-            Either::Left(name) => self.inner.get_mut(name).map(|v| v.get_mut()),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.get_mut(&name).map(|v| v.get_mut())
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    /// Returns true if the map contains a value for the specified key.
-    pub fn contains_key<N: AsName>(&self, key: N) -> bool {
-        match key.as_name() {
-            Either::Left(name) => self.inner.contains_key(name),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.contains_key(&name)
-                } else {
-                    false
-                }
-            }
-        }
-    }
-
-    /// An iterator visiting all key-value pairs.
-    ///
-    /// The iteration order is arbitrary, but consistent across platforms for
-    /// the same crate version. Each key will be yielded once per associated
-    /// value. So, if a key has 3 associated values, it will be yielded 3 times.
-    pub fn iter(&self) -> Iter<'_> {
-        Iter::new(self.inner.iter())
-    }
-
-    /// An iterator visiting all keys.
-    ///
-    /// The iteration order is arbitrary, but consistent across platforms for
-    /// the same crate version. Each key will be yielded only once even if it
-    /// has multiple associated values.
-    pub fn keys(&self) -> Keys<'_> {
-        Keys(self.inner.keys())
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not previously have this key present, then `None` is
-    /// returned.
-    ///
-    /// If the map did have this key present, the new value is associated with
-    /// the key and all previous values are removed. **Note** that only a single
-    /// one of the previous values is returned. If there are multiple values
-    /// that have been previously associated with the key, then the first one is
-    /// returned. See `insert_mult` on `OccupiedEntry` for an API that returns
-    /// all values.
-    ///
-    /// The key is not updated, though; this matters for types that can be `==`
-    /// without being identical.
-    pub fn insert(&mut self, key: HeaderName, val: HeaderValue) {
-        let _ = self.inner.insert(key, Value::One(val));
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not previously have this key present, then `false` is
-    /// returned.
-    ///
-    /// If the map did have this key present, the new value is pushed to the end
-    /// of the list of values currently associated with the key. The key is not
-    /// updated, though; this matters for types that can be `==` without being
-    /// identical.
-    pub fn append(&mut self, key: HeaderName, value: HeaderValue) {
-        match self.inner.entry(key) {
-            Entry::Occupied(mut entry) => entry.get_mut().append(value),
-            Entry::Vacant(entry) => {
-                entry.insert(Value::One(value));
-            }
-        }
-    }
-
-    /// Removes all headers for a particular header name from the map.
-    pub fn remove<N: AsName>(&mut self, key: N) {
-        match key.as_name() {
-            Either::Left(name) => {
-                let _ = self.inner.remove(name);
-            }
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    let _ = self.inner.remove(&name);
-                }
-            }
-        }
-    }
-}
-
-#[doc(hidden)]
-pub trait AsName {
-    fn as_name(&self) -> Either<&HeaderName, &str>;
-}
-
-impl AsName for HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Left(self)
-    }
-}
-
-impl<'a> AsName for &'a HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Left(self)
-    }
-}
-
-impl<'a> AsName for &'a str {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self)
-    }
-}
-
-impl AsName for String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self.as_str())
-    }
-}
-
-impl<'a> AsName for &'a String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self.as_str())
-    }
-}
-
-pub struct GetAll<'a> {
-    idx: usize,
-    item: Option<&'a Value>,
-}
-
-impl<'a> Iterator for GetAll<'a> {
-    type Item = &'a HeaderValue;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a HeaderValue> {
-        if let Some(ref val) = self.item {
-            match val {
-                Value::One(ref val) => {
-                    self.item.take();
-                    Some(val)
-                }
-                Value::Multi(ref vec) => {
-                    if self.idx < vec.len() {
-                        let item = Some(&vec[self.idx]);
-                        self.idx += 1;
-                        item
-                    } else {
-                        self.item.take();
-                        None
-                    }
-                }
-            }
-        } else {
-            None
-        }
-    }
-}
-
-pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
-
-impl<'a> Iterator for Keys<'a> {
-    type Item = &'a HeaderName;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a HeaderName> {
-        self.0.next()
-    }
-}
-
-impl<'a> IntoIterator for &'a HeaderMap {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-    type IntoIter = Iter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-pub struct Iter<'a> {
-    idx: usize,
-    current: Option<(&'a HeaderName, &'a Vec<HeaderValue>)>,
-    iter: hash_map::Iter<'a, HeaderName, Value>,
-}
-
-impl<'a> Iter<'a> {
-    fn new(iter: hash_map::Iter<'a, HeaderName, Value>) -> Self {
-        Self {
-            iter,
-            idx: 0,
-            current: None,
-        }
-    }
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-
-    #[inline]
-    fn next(&mut self) -> Option<(&'a HeaderName, &'a HeaderValue)> {
-        if let Some(ref mut item) = self.current {
-            if self.idx < item.1.len() {
-                let item = (item.0, &item.1[self.idx]);
-                self.idx += 1;
-                return Some(item);
-            } else {
-                self.idx = 0;
-                self.current.take();
-            }
-        }
-        if let Some(item) = self.iter.next() {
-            match item.1 {
-                Value::One(ref value) => Some((item.0, value)),
-                Value::Multi(ref vec) => {
-                    self.current = Some((item.0, vec));
-                    self.next()
-                }
-            }
-        } else {
-            None
-        }
-    }
-}

actix-http/src/header/mod.rs

@@ -1,502 +0,0 @@
-//! Various http headers
-// This is mostly copy of [hyper](https://github.com/hyperium/hyper/tree/master/src/header)
-
-use std::convert::TryFrom;
-use std::{fmt, str::FromStr};
-
-use bytes::{Bytes, BytesMut};
-use http::Error as HttpError;
-use mime::Mime;
-use percent_encoding::{AsciiSet, CONTROLS};
-
-pub use http::header::*;
-
-use crate::error::ParseError;
-use crate::httpmessage::HttpMessage;
-
-mod common;
-pub(crate) mod map;
-mod shared;
-pub use self::common::*;
-#[doc(hidden)]
-pub use self::shared::*;
-
-#[doc(hidden)]
-pub use self::map::GetAll;
-pub use self::map::HeaderMap;
-
-/// A trait for any object that will represent a header field and value.
-pub trait Header
-where
-    Self: IntoHeaderValue,
-{
-    /// Returns the name of the header field
-    fn name() -> HeaderName;
-
-    /// Parse a header
-    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
-}
-
-/// A trait for any object that can be Converted to a `HeaderValue`
-pub trait IntoHeaderValue: Sized {
-    /// The type returned in the event of a conversion error.
-    type Error: Into<HttpError>;
-
-    /// Try to convert value to a Header value.
-    fn try_into(self) -> Result<HeaderValue, Self::Error>;
-}
-
-impl IntoHeaderValue for HeaderValue {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        Ok(self)
-    }
-}
-
-impl<'a> IntoHeaderValue for &'a str {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        self.parse()
-    }
-}
-
-impl<'a> IntoHeaderValue for &'a [u8] {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_bytes(self)
-    }
-}
-
-impl IntoHeaderValue for Bytes {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_maybe_shared(self)
-    }
-}
-
-impl IntoHeaderValue for Vec<u8> {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
-    }
-}
-
-impl IntoHeaderValue for String {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
-    }
-}
-
-impl IntoHeaderValue for usize {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        let s = format!("{}", self);
-        HeaderValue::try_from(s)
-    }
-}
-
-impl IntoHeaderValue for u64 {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        let s = format!("{}", self);
-        HeaderValue::try_from(s)
-    }
-}
-
-impl IntoHeaderValue for Mime {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(format!("{}", self))
-    }
-}
-
-/// Represents supported types of content encodings
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum ContentEncoding {
-    /// Automatically select encoding based on encoding negotiation
-    Auto,
-    /// A format using the Brotli algorithm
-    Br,
-    /// A format using the zlib structure with deflate algorithm
-    Deflate,
-    /// Gzip algorithm
-    Gzip,
-    /// Indicates the identity function (i.e. no compression, nor modification)
-    Identity,
-}
-
-impl ContentEncoding {
-    #[inline]
-    /// Is the content compressed?
-    pub fn is_compression(self) -> bool {
-        matches!(self, ContentEncoding::Identity | ContentEncoding::Auto)
-    }
-
-    #[inline]
-    /// Convert content encoding to string
-    pub fn as_str(self) -> &'static str {
-        match self {
-            ContentEncoding::Br => "br",
-            ContentEncoding::Gzip => "gzip",
-            ContentEncoding::Deflate => "deflate",
-            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
-        }
-    }
-
-    #[inline]
-    /// default quality value
-    pub fn quality(self) -> f64 {
-        match self {
-            ContentEncoding::Br => 1.1,
-            ContentEncoding::Gzip => 1.0,
-            ContentEncoding::Deflate => 0.9,
-            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
-        }
-    }
-}
-
-impl<'a> From<&'a str> for ContentEncoding {
-    fn from(s: &'a str) -> ContentEncoding {
-        let s = s.trim();
-
-        if s.eq_ignore_ascii_case("br") {
-            ContentEncoding::Br
-        } else if s.eq_ignore_ascii_case("gzip") {
-            ContentEncoding::Gzip
-        } else if s.eq_ignore_ascii_case("deflate") {
-            ContentEncoding::Deflate
-        } else {
-            ContentEncoding::Identity
-        }
-    }
-}
-
-#[doc(hidden)]
-pub(crate) struct Writer {
-    buf: BytesMut,
-}
-
-impl Writer {
-    fn new() -> Writer {
-        Writer {
-            buf: BytesMut::new(),
-        }
-    }
-    fn take(&mut self) -> Bytes {
-        self.buf.split().freeze()
-    }
-}
-
-impl fmt::Write for Writer {
-    #[inline]
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.buf.extend_from_slice(s.as_bytes());
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
-        fmt::write(self, args)
-    }
-}
-
-#[inline]
-#[doc(hidden)]
-/// Reads a comma-delimited raw header into a Vec.
-pub fn from_comma_delimited<'a, I: Iterator<Item = &'a HeaderValue> + 'a, T: FromStr>(
-    all: I,
-) -> Result<Vec<T>, ParseError> {
-    let mut result = Vec::new();
-    for h in all {
-        let s = h.to_str().map_err(|_| ParseError::Header)?;
-        result.extend(
-            s.split(',')
-                .filter_map(|x| match x.trim() {
-                    "" => None,
-                    y => Some(y),
-                })
-                .filter_map(|x| x.trim().parse().ok()),
-        )
-    }
-    Ok(result)
-}
-
-#[inline]
-#[doc(hidden)]
-/// Reads a single string when parsing a header.
-pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result<T, ParseError> {
-    if let Some(line) = val {
-        let line = line.to_str().map_err(|_| ParseError::Header)?;
-        if !line.is_empty() {
-            return T::from_str(line).or(Err(ParseError::Header));
-        }
-    }
-    Err(ParseError::Header)
-}
-
-#[inline]
-#[doc(hidden)]
-/// Format an array into a comma-delimited string.
-pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter<'_>, parts: &[T]) -> fmt::Result
-where
-    T: fmt::Display,
-{
-    let mut iter = parts.iter();
-    if let Some(part) = iter.next() {
-        fmt::Display::fmt(part, f)?;
-    }
-    for part in iter {
-        f.write_str(", ")?;
-        fmt::Display::fmt(part, f)?;
-    }
-    Ok(())
-}
-
-// From hyper v0.11.27 src/header/parsing.rs
-
-/// The value part of an extended parameter consisting of three parts:
-/// the REQUIRED character set name (`charset`), the OPTIONAL language information (`language_tag`),
-/// and a character sequence representing the actual value (`value`), separated by single quote
-/// characters. It is defined in [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExtendedValue {
-    /// The character set that is used to encode the `value` to a string.
-    pub charset: Charset,
-    /// The human language details of the `value`, if available.
-    pub language_tag: Option<LanguageTag>,
-    /// The parameter value, as expressed in octets.
-    pub value: Vec<u8>,
-}
-
-/// Parses extended header parameter values (`ext-value`), as defined in
-/// [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
-///
-/// Extended values are denoted by parameter names that end with `*`.
-///
-/// ## ABNF
-///
-/// ```text
-/// ext-value     = charset  "'" [ language ] "'" value-chars
-///               ; like RFC 2231's <extended-initial-value>
-///               ; (see [RFC2231], Section 7)
-///
-/// charset       = "UTF-8" / "ISO-8859-1" / mime-charset
-///
-/// mime-charset  = 1*mime-charsetc
-/// mime-charsetc = ALPHA / DIGIT
-///               / "!" / "#" / "$" / "%" / "&"
-///               / "+" / "-" / "^" / "_" / "`"
-///               / "{" / "}" / "~"
-///               ; as <mime-charset> in Section 2.3 of [RFC2978]
-///               ; except that the single quote is not included
-///               ; SHOULD be registered in the IANA charset registry
-///
-/// language      = <Language-Tag, defined in [RFC5646], Section 2.1>
-///
-/// value-chars   = *( pct-encoded / attr-char )
-///
-/// pct-encoded   = "%" HEXDIG HEXDIG
-///               ; see [RFC3986], Section 2.1
-///
-/// attr-char     = ALPHA / DIGIT
-///               / "!" / "#" / "$" / "&" / "+" / "-" / "."
-///               / "^" / "_" / "`" / "|" / "~"
-///               ; token except ( "*" / "'" / "%" )
-/// ```
-pub fn parse_extended_value(
-    val: &str,
-) -> Result<ExtendedValue, crate::error::ParseError> {
-    // Break into three pieces separated by the single-quote character
-    let mut parts = val.splitn(3, '\'');
-
-    // Interpret the first piece as a Charset
-    let charset: Charset = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some(n) => FromStr::from_str(n).map_err(|_| crate::error::ParseError::Header)?,
-    };
-
-    // Interpret the second piece as a language tag
-    let language_tag: Option<LanguageTag> = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some("") => None,
-        Some(s) => match s.parse() {
-            Ok(lt) => Some(lt),
-            Err(_) => return Err(crate::error::ParseError::Header),
-        },
-    };
-
-    // Interpret the third piece as a sequence of value characters
-    let value: Vec<u8> = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some(v) => percent_encoding::percent_decode(v.as_bytes()).collect(),
-    };
-
-    Ok(ExtendedValue {
-        value,
-        charset,
-        language_tag,
-    })
-}
-
-impl fmt::Display for ExtendedValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let encoded_value =
-            percent_encoding::percent_encode(&self.value[..], HTTP_VALUE);
-        if let Some(ref lang) = self.language_tag {
-            write!(f, "{}'{}'{}", self.charset, lang, encoded_value)
-        } else {
-            write!(f, "{}''{}", self.charset, encoded_value)
-        }
-    }
-}
-
-/// Percent encode a sequence of bytes with a character set defined in
-/// [https://tools.ietf.org/html/rfc5987#section-3.2][url]
-///
-/// [url]: https://tools.ietf.org/html/rfc5987#section-3.2
-pub fn http_percent_encode(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> fmt::Result {
-    let encoded = percent_encoding::percent_encode(bytes, HTTP_VALUE);
-    fmt::Display::fmt(&encoded, f)
-}
-
-/// Convert http::HeaderMap to a HeaderMap
-impl From<http::HeaderMap> for HeaderMap {
-    fn from(map: http::HeaderMap) -> HeaderMap {
-        let mut new_map = HeaderMap::with_capacity(map.capacity());
-        for (h, v) in map.iter() {
-            new_map.append(h.clone(), v.clone());
-        }
-        new_map
-    }
-}
-
-// This encode set is used for HTTP header values and is defined at
-// https://tools.ietf.org/html/rfc5987#section-3.2
-pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS
-    .add(b' ')
-    .add(b'"')
-    .add(b'%')
-    .add(b'\'')
-    .add(b'(')
-    .add(b')')
-    .add(b'*')
-    .add(b',')
-    .add(b'/')
-    .add(b':')
-    .add(b';')
-    .add(b'<')
-    .add(b'-')
-    .add(b'>')
-    .add(b'?')
-    .add(b'[')
-    .add(b'\\')
-    .add(b']')
-    .add(b'{')
-    .add(b'}');
-
-#[cfg(test)]
-mod tests {
-    use super::shared::Charset;
-    use super::{parse_extended_value, ExtendedValue};
-    use language_tags::LanguageTag;
-
-    #[test]
-    fn test_parse_extended_value_with_encoding_and_language_tag() {
-        let expected_language_tag = "en".parse::<LanguageTag>().unwrap();
-        // RFC 5987, Section 3.2.2
-        // Extended notation, using the Unicode character U+00A3 (POUND SIGN)
-        let result = parse_extended_value("iso-8859-1'en'%A3%20rates");
-        assert!(result.is_ok());
-        let extended_value = result.unwrap();
-        assert_eq!(Charset::Iso_8859_1, extended_value.charset);
-        assert!(extended_value.language_tag.is_some());
-        assert_eq!(expected_language_tag, extended_value.language_tag.unwrap());
-        assert_eq!(
-            vec![163, b' ', b'r', b'a', b't', b'e', b's'],
-            extended_value.value
-        );
-    }
-
-    #[test]
-    fn test_parse_extended_value_with_encoding() {
-        // RFC 5987, Section 3.2.2
-        // Extended notation, using the Unicode characters U+00A3 (POUND SIGN)
-        // and U+20AC (EURO SIGN)
-        let result = parse_extended_value("UTF-8''%c2%a3%20and%20%e2%82%ac%20rates");
-        assert!(result.is_ok());
-        let extended_value = result.unwrap();
-        assert_eq!(Charset::Ext("UTF-8".to_string()), extended_value.charset);
-        assert!(extended_value.language_tag.is_none());
-        assert_eq!(
-            vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
-            ],
-            extended_value.value
-        );
-    }
-
-    #[test]
-    fn test_parse_extended_value_missing_language_tag_and_encoding() {
-        // From: https://greenbytes.de/tech/tc2231/#attwithfn2231quot2
-        let result = parse_extended_value("foo%20bar.html");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_parse_extended_value_partially_formatted() {
-        let result = parse_extended_value("UTF-8'missing third part");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_parse_extended_value_partially_formatted_blank() {
-        let result = parse_extended_value("blank second part'");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_fmt_extended_value_with_encoding_and_language_tag() {
-        let extended_value = ExtendedValue {
-            charset: Charset::Iso_8859_1,
-            language_tag: Some("en".parse().expect("Could not parse language tag")),
-            value: vec![163, b' ', b'r', b'a', b't', b'e', b's'],
-        };
-        assert_eq!("ISO-8859-1'en'%A3%20rates", format!("{}", extended_value));
-    }
-
-    #[test]
-    fn test_fmt_extended_value_with_encoding() {
-        let extended_value = ExtendedValue {
-            charset: Charset::Ext("UTF-8".to_string()),
-            language_tag: None,
-            value: vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
-            ],
-        };
-        assert_eq!(
-            "UTF-8''%C2%A3%20and%20%E2%82%AC%20rates",
-            format!("{}", extended_value)
-        );
-    }
-}

actix-http/src/header/shared/httpdate.rs

@@ -1,100 +0,0 @@
-use std::fmt::{self, Display};
-use std::io::Write;
-use std::str::FromStr;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use bytes::{buf::BufMutExt, BytesMut};
-use http::header::{HeaderValue, InvalidHeaderValue};
-use time::{offset, OffsetDateTime, PrimitiveDateTime};
-
-use crate::error::ParseError;
-use crate::header::IntoHeaderValue;
-use crate::time_parser;
-
-/// A timestamp with HTTP formatting and parsing
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HttpDate(OffsetDateTime);
-
-impl FromStr for HttpDate {
-    type Err = ParseError;
-
-    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
-        match time_parser::parse_http_date(s) {
-            Some(t) => Ok(HttpDate(t.assume_utc())),
-            None => Err(ParseError::Header),
-        }
-    }
-}
-
-impl Display for HttpDate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0.format("%a, %d %b %Y %H:%M:%S GMT"), f)
-    }
-}
-
-impl From<OffsetDateTime> for HttpDate {
-    fn from(dt: OffsetDateTime) -> HttpDate {
-        HttpDate(dt)
-    }
-}
-
-impl From<SystemTime> for HttpDate {
-    fn from(sys: SystemTime) -> HttpDate {
-        HttpDate(PrimitiveDateTime::from(sys).assume_utc())
-    }
-}
-
-impl IntoHeaderValue for HttpDate {
-    type Error = InvalidHeaderValue;
-
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        let mut wrt = BytesMut::with_capacity(29).writer();
-        write!(
-            wrt,
-            "{}",
-            self.0
-                .to_offset(offset!(UTC))
-                .format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
-        HeaderValue::from_maybe_shared(wrt.get_mut().split().freeze())
-    }
-}
-
-impl From<HttpDate> for SystemTime {
-    fn from(date: HttpDate) -> SystemTime {
-        let dt = date.0;
-        let epoch = OffsetDateTime::unix_epoch();
-
-        UNIX_EPOCH + (dt - epoch)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::HttpDate;
-    use time::{date, time, PrimitiveDateTime};
-
-    #[test]
-    fn test_date() {
-        let nov_07 = HttpDate(
-            PrimitiveDateTime::new(date!(1994 - 11 - 07), time!(8:48:37)).assume_utc(),
-        );
-
-        assert_eq!(
-            "Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
-            nov_07
-        );
-        assert_eq!(
-            "Sunday, 07-Nov-94 08:48:37 GMT"
-                .parse::<HttpDate>()
-                .unwrap(),
-            nov_07
-        );
-        assert_eq!(
-            "Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
-            nov_07
-        );
-        assert!("this-is-no-date".parse::<HttpDate>().is_err());
-    }
-}

actix-http/src/helpers.rs

@@ -1,171 +0,0 @@
-use std::io;
-
-use bytes::{BufMut, BytesMut};
-use http::Version;
-
-use crate::extensions::Extensions;
-
-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);
-
-    // trailing space before reason
-    bytes.put_u8(b' ');
-}
-
-/// NOTE: bytes object has to contain enough space
-pub fn write_content_length(n: u64, bytes: &mut BytesMut) {
-    if n == 0 {
-        bytes.put_slice(b"\r\ncontent-length: 0\r\n");
-        return;
-    }
-
-    let mut buf = itoa::Buffer::new();
-
-    bytes.put_slice(b"\r\ncontent-length: ");
-    bytes.put_slice(buf.format(n).as_bytes());
-    bytes.put_slice(b"\r\n");
-}
-
-pub(crate) struct Writer<'a>(pub &'a mut BytesMut);
-
-impl<'a> io::Write for Writer<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-pub(crate) trait DataFactory {
-    fn set(&self, ext: &mut Extensions);
-}
-
-pub(crate) struct Data<T>(pub(crate) T);
-
-impl<T: Clone + 'static> DataFactory for Data<T> {
-    fn set(&self, ext: &mut Extensions) {
-        ext.insert(self.0.clone())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::str::from_utf8;
-
-    use super::*;
-
-    #[test]
-    fn test_status_line() {
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_11, 200, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/1.1 200 ");
-
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_09, 404, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 404 ");
-
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_09, 515, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 515 ");
-    }
-
-    #[test]
-    fn test_write_content_length() {
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_content_length(0, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 0\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(9, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 9\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(10, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 10\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(99, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 99\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(100, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 100\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(101, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 101\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(998, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 998\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(1000, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 1000\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(1001, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 1001\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(5909, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 5909\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(9999, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 9999\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(10001, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 10001\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(59094, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 59094\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(99999, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 99999\r\n"[..]);
-
-        bytes.reserve(50);
-        write_content_length(590947, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 590947\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(999999, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 999999\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(5909471, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 5909471\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(59094718, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 59094718\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(4294973728, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 4294973728\r\n"[..]
-        );
-    }
-}

actix-http/src/httpmessage.rs

@@ -1,260 +0,0 @@
-use std::cell::{Ref, RefMut};
-use std::str;
-
-use encoding_rs::{Encoding, UTF_8};
-use http::header;
-use mime::Mime;
-
-use crate::cookie::Cookie;
-use crate::error::{ContentTypeError, CookieParseError, ParseError};
-use crate::extensions::Extensions;
-use crate::header::{Header, HeaderMap};
-use crate::payload::Payload;
-
-struct Cookies(Vec<Cookie<'static>>);
-
-/// Trait that implements general purpose operations on http messages
-pub trait HttpMessage: Sized {
-    /// Type of message payload stream
-    type Stream;
-
-    /// Read the message headers.
-    fn headers(&self) -> &HeaderMap;
-
-    /// Message payload stream
-    fn take_payload(&mut self) -> Payload<Self::Stream>;
-
-    /// Request's extensions container
-    fn extensions(&self) -> Ref<'_, Extensions>;
-
-    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<'_, Extensions>;
-
-    #[doc(hidden)]
-    /// Get a header
-    fn get_header<H: Header>(&self) -> Option<H>
-    where
-        Self: Sized,
-    {
-        if self.headers().contains_key(H::name()) {
-            H::parse(self).ok()
-        } else {
-            None
-        }
-    }
-
-    /// Read the request content type. If request does not contain
-    /// *Content-Type* header, empty str get returned.
-    fn content_type(&self) -> &str {
-        if let Some(content_type) = self.headers().get(header::CONTENT_TYPE) {
-            if let Ok(content_type) = content_type.to_str() {
-                return content_type.split(';').next().unwrap().trim();
-            }
-        }
-        ""
-    }
-
-    /// Get content type encoding
-    ///
-    /// UTF-8 is used by default, If request charset is not set.
-    fn encoding(&self) -> Result<&'static Encoding, ContentTypeError> {
-        if let Some(mime_type) = self.mime_type()? {
-            if let Some(charset) = mime_type.get_param("charset") {
-                if let Some(enc) =
-                    Encoding::for_label_no_replacement(charset.as_str().as_bytes())
-                {
-                    Ok(enc)
-                } else {
-                    Err(ContentTypeError::UnknownEncoding)
-                }
-            } else {
-                Ok(UTF_8)
-            }
-        } else {
-            Ok(UTF_8)
-        }
-    }
-
-    /// Convert the request content type to a known mime type.
-    fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError> {
-        if let Some(content_type) = self.headers().get(header::CONTENT_TYPE) {
-            if let Ok(content_type) = content_type.to_str() {
-                return match content_type.parse() {
-                    Ok(mt) => Ok(Some(mt)),
-                    Err(_) => Err(ContentTypeError::ParseError),
-                };
-            } else {
-                return Err(ContentTypeError::ParseError);
-            }
-        }
-        Ok(None)
-    }
-
-    /// Check if request has chunked transfer encoding
-    fn chunked(&self) -> Result<bool, ParseError> {
-        if let Some(encodings) = self.headers().get(header::TRANSFER_ENCODING) {
-            if let Ok(s) = encodings.to_str() {
-                Ok(s.to_lowercase().contains("chunked"))
-            } else {
-                Err(ParseError::Header)
-            }
-        } else {
-            Ok(false)
-        }
-    }
-
-    /// Load request cookies.
-    #[inline]
-    fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
-        if self.extensions().get::<Cookies>().is_none() {
-            let mut cookies = Vec::new();
-            for hdr in self.headers().get_all(header::COOKIE) {
-                let s =
-                    str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
-                for cookie_str in s.split(';').map(|s| s.trim()) {
-                    if !cookie_str.is_empty() {
-                        cookies.push(Cookie::parse_encoded(cookie_str)?.into_owned());
-                    }
-                }
-            }
-            self.extensions_mut().insert(Cookies(cookies));
-        }
-        Ok(Ref::map(self.extensions(), |ext| {
-            &ext.get::<Cookies>().unwrap().0
-        }))
-    }
-
-    /// Return request cookie.
-    fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Ok(cookies) = self.cookies() {
-            for cookie in cookies.iter() {
-                if cookie.name() == name {
-                    return Some(cookie.to_owned());
-                }
-            }
-        }
-        None
-    }
-}
-
-impl<'a, T> HttpMessage for &'a mut T
-where
-    T: HttpMessage,
-{
-    type Stream = T::Stream;
-
-    fn headers(&self) -> &HeaderMap {
-        (**self).headers()
-    }
-
-    /// Message payload stream
-    fn take_payload(&mut self) -> Payload<Self::Stream> {
-        (**self).take_payload()
-    }
-
-    /// Request's extensions container
-    fn extensions(&self) -> Ref<'_, Extensions> {
-        (**self).extensions()
-    }
-
-    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        (**self).extensions_mut()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use bytes::Bytes;
-    use encoding_rs::ISO_8859_2;
-
-    use super::*;
-    use crate::test::TestRequest;
-
-    #[test]
-    fn test_content_type() {
-        let req = TestRequest::with_header("content-type", "text/plain").finish();
-        assert_eq!(req.content_type(), "text/plain");
-        let req =
-            TestRequest::with_header("content-type", "application/json; charset=utf=8")
-                .finish();
-        assert_eq!(req.content_type(), "application/json");
-        let req = TestRequest::default().finish();
-        assert_eq!(req.content_type(), "");
-    }
-
-    #[test]
-    fn test_mime_type() {
-        let req = TestRequest::with_header("content-type", "application/json").finish();
-        assert_eq!(req.mime_type().unwrap(), Some(mime::APPLICATION_JSON));
-        let req = TestRequest::default().finish();
-        assert_eq!(req.mime_type().unwrap(), None);
-        let req =
-            TestRequest::with_header("content-type", "application/json; charset=utf-8")
-                .finish();
-        let mt = req.mime_type().unwrap().unwrap();
-        assert_eq!(mt.get_param(mime::CHARSET), Some(mime::UTF_8));
-        assert_eq!(mt.type_(), mime::APPLICATION);
-        assert_eq!(mt.subtype(), mime::JSON);
-    }
-
-    #[test]
-    fn test_mime_type_error() {
-        let req = TestRequest::with_header(
-            "content-type",
-            "applicationadfadsfasdflknadsfklnadsfjson",
-        )
-        .finish();
-        assert_eq!(Err(ContentTypeError::ParseError), req.mime_type());
-    }
-
-    #[test]
-    fn test_encoding() {
-        let req = TestRequest::default().finish();
-        assert_eq!(UTF_8.name(), req.encoding().unwrap().name());
-
-        let req = TestRequest::with_header("content-type", "application/json").finish();
-        assert_eq!(UTF_8.name(), req.encoding().unwrap().name());
-
-        let req = TestRequest::with_header(
-            "content-type",
-            "application/json; charset=ISO-8859-2",
-        )
-        .finish();
-        assert_eq!(ISO_8859_2, req.encoding().unwrap());
-    }
-
-    #[test]
-    fn test_encoding_error() {
-        let req = TestRequest::with_header("content-type", "applicatjson").finish();
-        assert_eq!(Some(ContentTypeError::ParseError), req.encoding().err());
-
-        let req = TestRequest::with_header(
-            "content-type",
-            "application/json; charset=kkkttktk",
-        )
-        .finish();
-        assert_eq!(
-            Some(ContentTypeError::UnknownEncoding),
-            req.encoding().err()
-        );
-    }
-
-    #[test]
-    fn test_chunked() {
-        let req = TestRequest::default().finish();
-        assert!(!req.chunked().unwrap());
-
-        let req =
-            TestRequest::with_header(header::TRANSFER_ENCODING, "chunked").finish();
-        assert!(req.chunked().unwrap());
-
-        let req = TestRequest::default()
-            .header(
-                header::TRANSFER_ENCODING,
-                Bytes::from_static(b"some va\xadscc\xacas0xsdasdlue"),
-            )
-            .finish();
-        assert!(req.chunked().is_err());
-    }
-}

actix-http/src/lib.rs

@@ -1,79 +0,0 @@
-//! Basic http primitives for actix-net framework.
-
-#![deny(rust_2018_idioms)]
-#![allow(
-    clippy::type_complexity,
-    clippy::too_many_arguments,
-    clippy::new_without_default,
-    clippy::borrow_interior_mutable_const
-)]
-
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-mod macros;
-
-pub mod body;
-mod builder;
-pub mod client;
-mod cloneable;
-mod config;
-#[cfg(feature = "compress")]
-pub mod encoding;
-mod extensions;
-mod header;
-mod helpers;
-mod httpcodes;
-pub mod httpmessage;
-mod message;
-mod payload;
-mod request;
-mod response;
-mod service;
-mod time_parser;
-
-pub use cookie;
-pub mod error;
-pub mod h1;
-pub mod h2;
-pub mod test;
-pub mod ws;
-
-pub use self::builder::HttpServiceBuilder;
-pub use self::config::{KeepAlive, ServiceConfig};
-pub use self::error::{Error, ResponseError, Result};
-pub use self::extensions::Extensions;
-pub use self::httpmessage::HttpMessage;
-pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
-pub use self::payload::{Payload, PayloadStream};
-pub use self::request::Request;
-pub use self::response::{Response, ResponseBuilder};
-pub use self::service::HttpService;
-
-pub mod http {
-    //! Various HTTP related types
-
-    // re-exports
-    pub use http::header::{HeaderName, HeaderValue};
-    pub use http::uri::PathAndQuery;
-    pub use http::{uri, Error, Uri};
-    pub use http::{Method, StatusCode, Version};
-
-    pub use crate::cookie::{Cookie, CookieBuilder};
-    pub use crate::header::HeaderMap;
-
-    /// Various http headers
-    pub mod header {
-        pub use crate::header::*;
-    }
-    pub use crate::header::ContentEncoding;
-    pub use crate::message::ConnectionType;
-}
-
-/// Http protocol
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Protocol {
-    Http1,
-    Http2,
-}

actix-http/src/macros.rs

@@ -1,96 +0,0 @@
-#[macro_export]
-macro_rules! downcast_get_type_id {
-    () => {
-        /// A helper method to get the type ID of the type
-        /// this trait is implemented on.
-        /// This method is unsafe to *implement*, since `downcast_ref` relies
-        /// on the returned `TypeId` to perform a cast.
-        ///
-        /// Unfortunately, Rust has no notion of a trait method that is
-        /// unsafe to implement (marking it as `unsafe` makes it unsafe
-        /// to *call*). As a workaround, we require this method
-        /// to return a private type along with the `TypeId`. This
-        /// private type (`PrivateHelper`) has a private constructor,
-        /// making it impossible for safe code to construct outside of
-        /// this module. This ensures that safe code cannot violate
-        /// type-safety by implementing this method.
-        #[doc(hidden)]
-        fn __private_get_type_id__(&self) -> (std::any::TypeId, PrivateHelper)
-        where
-            Self: 'static,
-        {
-            (std::any::TypeId::of::<Self>(), PrivateHelper(()))
-        }
-    };
-}
-
-//Generate implementation for dyn $name
-#[macro_export]
-macro_rules! downcast {
-    ($name:ident) => {
-        /// A struct with a private constructor, for use with
-        /// `__private_get_type_id__`. Its single field is private,
-        /// ensuring that it can only be constructed from this module
-        #[doc(hidden)]
-        pub struct PrivateHelper(());
-
-        impl dyn $name + 'static {
-            /// Downcasts generic body to a specific type.
-            pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
-                    // SAFETY: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe { Some(&*(self as *const dyn $name as *const T)) }
-                } else {
-                    None
-                }
-            }
-
-            /// Downcasts a generic body to a mutable specific type.
-            pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
-                    // SAFETY: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe {
-                        Some(&mut *(self as *const dyn $name as *const T as *mut T))
-                    }
-                } else {
-                    None
-                }
-            }
-        }
-    };
-}
-
-#[cfg(test)]
-mod tests {
-
-    trait MB {
-        downcast_get_type_id!();
-    }
-
-    downcast!(MB);
-
-    impl MB for String {}
-    impl MB for () {}
-
-    #[actix_rt::test]
-    async fn test_any_casting() {
-        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MB = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push('!');
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
-}

actix-http/src/message.rs

@@ -1,495 +0,0 @@
-use std::cell::{Ref, RefCell, RefMut};
-use std::net;
-use std::rc::Rc;
-
-use bitflags::bitflags;
-use copyless::BoxHelper;
-
-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::http::{header, Method, StatusCode, Uri, Version};
-
-/// Represents various types of connection
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum ConnectionType {
-    /// Close connection after response
-    Close,
-    /// Keep connection alive after response
-    KeepAlive,
-    /// Connection is upgraded to different type
-    Upgrade,
-}
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const CLOSE       = 0b0000_0001;
-        const KEEP_ALIVE  = 0b0000_0010;
-        const UPGRADE     = 0b0000_0100;
-        const EXPECT      = 0b0000_1000;
-        const NO_CHUNKING = 0b0001_0000;
-        const CAMEL_CASE  = 0b0010_0000;
-    }
-}
-
-#[doc(hidden)]
-pub trait Head: Default + 'static {
-    fn clear(&mut self);
-
-    fn pool() -> &'static MessagePool<Self>;
-}
-
-#[derive(Debug)]
-pub struct RequestHead {
-    pub uri: Uri,
-    pub method: Method,
-    pub version: Version,
-    pub headers: HeaderMap,
-    pub extensions: RefCell<Extensions>,
-    pub peer_addr: Option<net::SocketAddr>,
-    flags: Flags,
-}
-
-impl Default for RequestHead {
-    fn default() -> RequestHead {
-        RequestHead {
-            uri: Uri::default(),
-            method: Method::default(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::with_capacity(16),
-            flags: Flags::empty(),
-            peer_addr: None,
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-}
-
-impl Head for RequestHead {
-    fn clear(&mut self) {
-        self.flags = Flags::empty();
-        self.headers.clear();
-        self.extensions.borrow_mut().clear();
-    }
-
-    fn pool() -> &'static MessagePool<Self> {
-        REQUEST_POOL.with(|p| *p)
-    }
-}
-
-impl RequestHead {
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    /// Is to uppercase headers with Camel-Case.
-    /// Default is `false`
-    #[inline]
-    pub fn camel_case_headers(&self) -> bool {
-        self.flags.contains(Flags::CAMEL_CASE)
-    }
-
-    /// Set `true` to send headers which are formatted as Camel-Case.
-    #[inline]
-    pub fn set_camel_case_headers(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::CAMEL_CASE);
-        } else {
-            self.flags.remove(Flags::CAMEL_CASE);
-        }
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    /// Connection type
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Connection upgrade status
-    pub fn upgrade(&self) -> bool {
-        if let Some(hdr) = self.headers().get(header::CONNECTION) {
-            if let Ok(s) = hdr.to_str() {
-                s.to_ascii_lowercase().contains("upgrade")
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-
-    #[inline]
-    /// Request contains `EXPECT` header
-    pub fn expect(&self) -> bool {
-        self.flags.contains(Flags::EXPECT)
-    }
-
-    #[inline]
-    pub(crate) fn set_expect(&mut self) {
-        self.flags.insert(Flags::EXPECT);
-    }
-}
-
-#[derive(Debug)]
-pub enum RequestHeadType {
-    Owned(RequestHead),
-    Rc(Rc<RequestHead>, Option<HeaderMap>),
-}
-
-impl RequestHeadType {
-    pub fn extra_headers(&self) -> Option<&HeaderMap> {
-        match self {
-            RequestHeadType::Owned(_) => None,
-            RequestHeadType::Rc(_, headers) => headers.as_ref(),
-        }
-    }
-}
-
-impl AsRef<RequestHead> for RequestHeadType {
-    fn as_ref(&self) -> &RequestHead {
-        match self {
-            RequestHeadType::Owned(head) => &head,
-            RequestHeadType::Rc(head, _) => head.as_ref(),
-        }
-    }
-}
-
-impl From<RequestHead> for RequestHeadType {
-    fn from(head: RequestHead) -> Self {
-        RequestHeadType::Owned(head)
-    }
-}
-
-#[derive(Debug)]
-pub struct ResponseHead {
-    pub version: Version,
-    pub status: StatusCode,
-    pub headers: HeaderMap,
-    pub reason: Option<&'static str>,
-    pub(crate) extensions: RefCell<Extensions>,
-    flags: Flags,
-}
-
-impl ResponseHead {
-    /// Create new instance of `ResponseHead` type
-    #[inline]
-    pub fn new(status: StatusCode) -> ResponseHead {
-        ResponseHead {
-            status,
-            version: Version::default(),
-            headers: HeaderMap::with_capacity(12),
-            reason: None,
-            flags: Flags::empty(),
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    #[inline]
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    #[inline]
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    #[inline]
-    /// Check if keep-alive is enabled
-    pub fn keep_alive(&self) -> bool {
-        self.connection_type() == ConnectionType::KeepAlive
-    }
-
-    #[inline]
-    /// Check upgrade status of this message
-    pub fn upgrade(&self) -> bool {
-        self.connection_type() == ConnectionType::Upgrade
-    }
-
-    /// Get custom reason for the response
-    #[inline]
-    pub fn reason(&self) -> &str {
-        if let Some(reason) = self.reason {
-            reason
-        } else {
-            self.status
-                .canonical_reason()
-                .unwrap_or("<unknown status code>")
-        }
-    }
-
-    #[inline]
-    pub(crate) fn ctype(&self) -> Option<ConnectionType> {
-        if self.flags.contains(Flags::CLOSE) {
-            Some(ConnectionType::Close)
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            Some(ConnectionType::KeepAlive)
-        } else if self.flags.contains(Flags::UPGRADE) {
-            Some(ConnectionType::Upgrade)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    /// Set no chunking for payload
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-}
-
-pub struct Message<T: Head> {
-    head: Rc<T>,
-}
-
-impl<T: Head> Message<T> {
-    /// Get new message from the pool of objects
-    pub fn new() -> Self {
-        T::pool().get_message()
-    }
-}
-
-impl<T: Head> Clone for Message<T> {
-    fn clone(&self) -> Self {
-        Message {
-            head: self.head.clone(),
-        }
-    }
-}
-
-impl<T: Head> std::ops::Deref for Message<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.head.as_ref()
-    }
-}
-
-impl<T: Head> std::ops::DerefMut for Message<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        Rc::get_mut(&mut self.head).expect("Multiple copies exist")
-    }
-}
-
-impl<T: Head> Drop for Message<T> {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.head) == 1 {
-            T::pool().release(self.head.clone());
-        }
-    }
-}
-
-pub(crate) struct BoxedResponseHead {
-    head: Option<Box<ResponseHead>>,
-}
-
-impl BoxedResponseHead {
-    /// Get new message from the pool of objects
-    pub fn new(status: StatusCode) -> Self {
-        RESPONSE_POOL.with(|p| p.get_message(status))
-    }
-
-    pub(crate) fn take(&mut self) -> Self {
-        BoxedResponseHead {
-            head: self.head.take(),
-        }
-    }
-}
-
-impl std::ops::Deref for BoxedResponseHead {
-    type Target = ResponseHead;
-
-    fn deref(&self) -> &Self::Target {
-        self.head.as_ref().unwrap()
-    }
-}
-
-impl std::ops::DerefMut for BoxedResponseHead {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.head.as_mut().unwrap()
-    }
-}
-
-impl Drop for BoxedResponseHead {
-    fn drop(&mut self) {
-        if let Some(head) = self.head.take() {
-            RESPONSE_POOL.with(move |p| p.release(head))
-        }
-    }
-}
-
-#[doc(hidden)]
-/// Request's objects pool
-pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
-
-#[doc(hidden)]
-#[allow(clippy::vec_box)]
-/// Request's objects pool
-pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);
-
-thread_local!(static REQUEST_POOL: &'static MessagePool<RequestHead> = MessagePool::<RequestHead>::create());
-thread_local!(static RESPONSE_POOL: &'static BoxedResponsePool = BoxedResponsePool::create());
-
-impl<T: Head> MessagePool<T> {
-    fn create() -> &'static MessagePool<T> {
-        let pool = MessagePool(RefCell::new(Vec::with_capacity(128)));
-        Box::leak(Box::new(pool))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&'static self) -> Message<T> {
-        if let Some(mut msg) = self.0.borrow_mut().pop() {
-            if let Some(r) = Rc::get_mut(&mut msg) {
-                r.clear();
-            }
-            Message { head: msg }
-        } else {
-            Message {
-                head: Rc::new(T::default()),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, msg: Rc<T>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            v.push(msg);
-        }
-    }
-}
-
-impl BoxedResponsePool {
-    fn create() -> &'static BoxedResponsePool {
-        let pool = BoxedResponsePool(RefCell::new(Vec::with_capacity(128)));
-        Box::leak(Box::new(pool))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&'static self, status: StatusCode) -> BoxedResponseHead {
-        if let Some(mut head) = self.0.borrow_mut().pop() {
-            head.reason = None;
-            head.status = status;
-            head.headers.clear();
-            head.flags = Flags::empty();
-            BoxedResponseHead { head: Some(head) }
-        } else {
-            BoxedResponseHead {
-                head: Some(Box::alloc().init(ResponseHead::new(status))),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, msg: Box<ResponseHead>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            msg.extensions.borrow_mut().clear();
-            v.push(msg);
-        }
-    }
-}

actix-http/src/payload.rs

@@ -1,70 +0,0 @@
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use bytes::Bytes;
-use futures_core::Stream;
-use h2::RecvStream;
-
-use crate::error::PayloadError;
-
-/// Type represent boxed payload
-pub type PayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
-
-/// Type represent streaming payload
-pub enum Payload<S = PayloadStream> {
-    None,
-    H1(crate::h1::Payload),
-    H2(crate::h2::Payload),
-    Stream(S),
-}
-
-impl<S> From<crate::h1::Payload> for Payload<S> {
-    fn from(v: crate::h1::Payload) -> Self {
-        Payload::H1(v)
-    }
-}
-
-impl<S> From<crate::h2::Payload> for Payload<S> {
-    fn from(v: crate::h2::Payload) -> Self {
-        Payload::H2(v)
-    }
-}
-
-impl<S> From<RecvStream> for Payload<S> {
-    fn from(v: RecvStream) -> Self {
-        Payload::H2(crate::h2::Payload::new(v))
-    }
-}
-
-impl From<PayloadStream> for Payload {
-    fn from(pl: PayloadStream) -> Self {
-        Payload::Stream(pl)
-    }
-}
-
-impl<S> Payload<S> {
-    /// Takes current payload and replaces it with `None` value
-    pub fn take(&mut self) -> Payload<S> {
-        std::mem::replace(self, Payload::None)
-    }
-}
-
-impl<S> Stream for Payload<S>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
-{
-    type Item = Result<Bytes, PayloadError>;
-
-    #[inline]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.get_mut() {
-            Payload::None => Poll::Ready(None),
-            Payload::H1(ref mut pl) => pl.readany(cx),
-            Payload::H2(ref mut pl) => Pin::new(pl).poll_next(cx),
-            Payload::Stream(ref mut pl) => Pin::new(pl).poll_next(cx),
-        }
-    }
-}

actix-http/src/request.rs

@@ -1,209 +0,0 @@
-use std::cell::{Ref, RefMut};
-use std::{fmt, net};
-
-use http::{header, Method, Uri, Version};
-
-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::httpmessage::HttpMessage;
-use crate::message::{Message, RequestHead};
-use crate::payload::{Payload, PayloadStream};
-
-/// Request
-pub struct Request<P = PayloadStream> {
-    pub(crate) payload: Payload<P>,
-    pub(crate) head: Message<RequestHead>,
-}
-
-impl<P> HttpMessage for Request<P> {
-    type Stream = P;
-
-    #[inline]
-    fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    /// Request extensions
-    #[inline]
-    fn extensions(&self) -> Ref<'_, Extensions> {
-        self.head.extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.head.extensions_mut()
-    }
-
-    fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
-    }
-}
-
-impl From<Message<RequestHead>> for Request<PayloadStream> {
-    fn from(head: Message<RequestHead>) -> Self {
-        Request {
-            head,
-            payload: Payload::None,
-        }
-    }
-}
-
-impl Request<PayloadStream> {
-    /// Create new Request instance
-    pub fn new() -> Request<PayloadStream> {
-        Request {
-            head: Message::new(),
-            payload: Payload::None,
-        }
-    }
-}
-
-impl<P> Request<P> {
-    /// Create new Request instance
-    pub fn with_payload(payload: Payload<P>) -> Request<P> {
-        Request {
-            payload,
-            head: Message::new(),
-        }
-    }
-
-    /// Create new Request instance
-    pub fn replace_payload<P1>(self, payload: Payload<P1>) -> (Request<P1>, Payload<P>) {
-        let pl = self.payload;
-        (
-            Request {
-                payload,
-                head: self.head,
-            },
-            pl,
-        )
-    }
-
-    /// Get request's payload
-    pub fn payload(&mut self) -> &mut Payload<P> {
-        &mut self.payload
-    }
-
-    /// Get request's payload
-    pub fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
-    }
-
-    /// Split request into request head and payload
-    pub fn into_parts(self) -> (Message<RequestHead>, Payload<P>) {
-        (self.head, self.payload)
-    }
-
-    #[inline]
-    /// Http message part of the request
-    pub fn head(&self) -> &RequestHead {
-        &*self.head
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    /// Mutable reference to a http message part of the request
-    pub fn head_mut(&mut self) -> &mut RequestHead {
-        &mut *self.head
-    }
-
-    /// Mutable reference to the message's headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.head_mut().headers
-    }
-
-    /// Request's uri.
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.head().uri
-    }
-
-    /// Mutable reference to the request's uri.
-    #[inline]
-    pub fn uri_mut(&mut self) -> &mut Uri {
-        &mut self.head_mut().uri
-    }
-
-    /// Read the Request method.
-    #[inline]
-    pub fn method(&self) -> &Method {
-        &self.head().method
-    }
-
-    /// Read the Request Version.
-    #[inline]
-    pub fn version(&self) -> Version {
-        self.head().version
-    }
-
-    /// The target path of this Request.
-    #[inline]
-    pub fn path(&self) -> &str {
-        self.head().uri.path()
-    }
-
-    /// Check if request requires connection upgrade
-    #[inline]
-    pub fn upgrade(&self) -> bool {
-        if let Some(conn) = self.head().headers.get(header::CONNECTION) {
-            if let Ok(s) = conn.to_str() {
-                return s.to_lowercase().contains("upgrade");
-            }
-        }
-        self.head().method == Method::CONNECT
-    }
-
-    /// Peer socket address
-    ///
-    /// Peer address is actual socket address, if proxy is used in front of
-    /// actix http server, then peer address would be address of this proxy.
-    #[inline]
-    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.head().peer_addr
-    }
-}
-
-impl<P> fmt::Debug for Request<P> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(
-            f,
-            "\nRequest {:?} {}:{}",
-            self.version(),
-            self.method(),
-            self.path()
-        )?;
-        if let Some(q) = self.uri().query().as_ref() {
-            writeln!(f, "  query: ?{:?}", q)?;
-        }
-        writeln!(f, "  headers:")?;
-        for (key, val) in self.headers() {
-            writeln!(f, "    {:?}: {:?}", key, val)?;
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::convert::TryFrom;
-
-    #[test]
-    fn test_basics() {
-        let msg = Message::new();
-        let mut req = Request::from(msg);
-        req.headers_mut().insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static("text/plain"),
-        );
-        assert!(req.headers().contains_key(header::CONTENT_TYPE));
-
-        *req.uri_mut() = Uri::try_from("/index.html?q=1").unwrap();
-        assert_eq!(req.uri().path(), "/index.html");
-        assert_eq!(req.uri().query(), Some("q=1"));
-
-        let s = format!("{:?}", req);
-        assert!(s.contains("Request HTTP/1.1 GET:/index.html"));
-    }
-}

actix-http/src/service.rs

@@ -1,681 +0,0 @@
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, net, rc};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::net::TcpStream;
-use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
-use bytes::Bytes;
-use futures_core::{ready, Future};
-use futures_util::future::ok;
-use h2::server::{self, Handshake};
-use pin_project::pin_project;
-
-use crate::body::MessageBody;
-use crate::builder::HttpServiceBuilder;
-use crate::cloneable::CloneableService;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error};
-use crate::helpers::DataFactory;
-use crate::request::Request;
-use crate::response::Response;
-use crate::{h1, h2::Dispatcher, Protocol};
-
-/// `ServiceFactory` HTTP1.1/HTTP2 transport implementation
-pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> HttpService<T, S, B>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create builder for `HttpService` instance.
-    pub fn build() -> HttpServiceBuilder<T, S> {
-        HttpServiceBuilder::new()
-    }
-}
-
-impl<T, S, B> HttpService<T, S, B>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create new `HttpService` instance.
-    pub fn new<F: IntoServiceFactory<S>>(service: F) -> Self {
-        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0, false, None);
-
-        HttpService {
-            cfg,
-            srv: service.into_factory(),
-            expect: h1::ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        HttpService {
-            cfg,
-            srv: service.into_factory(),
-            expect: h1::ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> HttpService<T, S, B, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody,
-{
-    /// 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<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
-    where
-        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-        <X1::Service as Service>::Future: 'static,
-    {
-        HttpService {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect: self.on_connect,
-            _t: 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<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X, U1>
-    where
-        U1: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<T, h1::Codec>),
-            Response = (),
-        >,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-        <U1::Service as Service>::Future: 'static,
-    {
-        HttpService {
-            upgrade,
-            cfg: self.cfg,
-            srv: self.srv,
-            expect: self.expect,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<TcpStream, h1::Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
-{
-    /// Create simple tcp stream service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        Config = (),
-        Request = TcpStream,
-        Response = (),
-        Error = DispatchError,
-        InitError = (),
-    > {
-        pipeline_factory(|io: TcpStream| {
-            let peer_addr = io.peer_addr().ok();
-            ok((io, Protocol::Http1, peer_addr))
-        })
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use super::*;
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, TlsError};
-
-    impl<S, B, X, U> HttpService<SslStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        <X::Service as Service>::Future: 'static,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<SslStream<TcpStream>, h1::Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-        <U::Service as Service>::Future: 'static,
-    {
-        /// Create openssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
-            InitError = (),
-        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: SslStream<TcpStream>| {
-                let proto = if let Some(protos) = io.ssl().selected_alpn_protocol() {
-                    if protos.windows(2).any(|window| window == b"h2") {
-                        Protocol::Http2
-                    } else {
-                        Protocol::Http1
-                    }
-                } else {
-                    Protocol::Http1
-                };
-                let peer_addr = io.get_ref().peer_addr().ok();
-                ok((io, proto, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, Session, TlsStream};
-    use actix_tls::TlsError;
-    use std::io;
-
-    impl<S, B, X, U> HttpService<TlsStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        <X::Service as Service>::Future: 'static,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<TlsStream<TcpStream>, h1::Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-        <U::Service as Service>::Future: 'static,
-    {
-        /// Create openssl based service
-        pub fn rustls(
-            self,
-            mut config: ServerConfig,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = TlsError<io::Error, DispatchError>,
-            InitError = (),
-        > {
-            let protos = vec!["h2".to_string().into(), "http/1.1".to_string().into()];
-            config.set_protocols(&protos);
-
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| {
-                let proto = if let Some(protos) = io.get_ref().1.get_alpn_protocol() {
-                    if protos.windows(2).any(|window| window == b"h2") {
-                        Protocol::Http2
-                    } else {
-                        Protocol::Http1
-                    }
-                } else {
-                    Protocol::Http1
-                };
-                let peer_addr = io.get_ref().0.peer_addr().ok();
-                ok((io, proto, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-impl<T, S, B, X, U> ServiceFactory for HttpService<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<T, h1::Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
-{
-    type Config = ();
-    type Request = (T, Protocol, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = ();
-    type Service = HttpServiceHandler<T, S::Service, B, X::Service, U::Service>;
-    type Future = HttpServiceResponse<T, S, B, X, U>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        HttpServiceResponse {
-            fut: self.srv.new_service(()),
-            fut_ex: Some(self.expect.new_service(())),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(())),
-            expect: None,
-            upgrade: None,
-            on_connect: self.on_connect.clone(),
-            cfg: self.cfg.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project]
-pub struct HttpServiceResponse<
-    T,
-    S: ServiceFactory,
-    B,
-    X: ServiceFactory,
-    U: ServiceFactory,
-> {
-    #[pin]
-    fut: S::Future,
-    #[pin]
-    fut_ex: Option<X::Future>,
-    #[pin]
-    fut_upg: Option<U::Future>,
-    expect: Option<X::Service>,
-    upgrade: Option<U::Service>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: ServiceConfig,
-    _t: PhantomData<(T, B)>,
-}
-
-impl<T, S, B, X, U> Future for HttpServiceResponse<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-    X: ServiceFactory<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
-{
-    type Output =
-        Result<HttpServiceHandler<T, S::Service, B, X::Service, U::Service>, ()>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        if let Some(fut) = this.fut_ex.as_pin_mut() {
-            let expect = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.expect = Some(expect);
-            this.fut_ex.set(None);
-        }
-
-        if let Some(fut) = this.fut_upg.as_pin_mut() {
-            let upgrade = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.upgrade = Some(upgrade);
-            this.fut_ex.set(None);
-        }
-
-        let result = ready!(this
-            .fut
-            .poll(cx)
-            .map_err(|e| log::error!("Init http service error: {:?}", e)));
-        Poll::Ready(result.map(|service| {
-            let this = self.as_mut().project();
-            HttpServiceHandler::new(
-                this.cfg.clone(),
-                service,
-                this.expect.take().unwrap(),
-                this.upgrade.take(),
-                this.on_connect.clone(),
-            )
-        }))
-    }
-}
-
-/// `Service` implementation for http transport
-pub struct HttpServiceHandler<T, S: Service, B, X: Service, U: Service> {
-    srv: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, B, X)>,
-}
-
-impl<T, S, B, X, U> HttpServiceHandler<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn new(
-        cfg: ServiceConfig,
-        srv: S,
-        expect: X,
-        upgrade: Option<U>,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> HttpServiceHandler<T, S, B, X, U> {
-        HttpServiceHandler {
-            cfg,
-            on_connect,
-            srv: CloneableService::new(srv),
-            expect: CloneableService::new(expect),
-            upgrade: upgrade.map(CloneableService::new),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Service for HttpServiceHandler<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-{
-    type Request = (T, Protocol, Option<net::SocketAddr>);
-    type Response = ();
-    type Error = DispatchError;
-    type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let ready = self
-            .expect
-            .poll_ready(cx)
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready();
-
-        let ready = self
-            .srv
-            .poll_ready(cx)
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready()
-            && ready;
-
-        let ready = if let Some(ref mut upg) = self.upgrade {
-            upg.poll_ready(cx)
-                .map_err(|e| {
-                    let e = e.into();
-                    log::error!("Http service readiness error: {:?}", e);
-                    DispatchError::Service(e)
-                })?
-                .is_ready()
-                && ready
-        } else {
-            ready
-        };
-
-        if ready {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&mut self, (io, proto, peer_addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        match proto {
-            Protocol::Http2 => HttpServiceHandlerResponse {
-                state: State::H2Handshake(Some((
-                    server::handshake(io),
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                    on_connect,
-                    peer_addr,
-                ))),
-            },
-            Protocol::Http1 => HttpServiceHandlerResponse {
-                state: State::H1(h1::Dispatcher::new(
-                    io,
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                    self.expect.clone(),
-                    self.upgrade.clone(),
-                    on_connect,
-                    peer_addr,
-                )),
-            },
-        }
-    }
-}
-
-#[pin_project(project = StateProj)]
-enum State<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Future: 'static,
-    S::Error: Into<Error>,
-    T: AsyncRead + AsyncWrite + Unpin,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    H1(#[pin] h1::Dispatcher<T, S, B, X, U>),
-    H2(#[pin] Dispatcher<T, S, B>),
-    H2Handshake(
-        Option<(
-            Handshake<T, Bytes>,
-            ServiceConfig,
-            CloneableService<S>,
-            Option<Box<dyn DataFactory>>,
-            Option<net::SocketAddr>,
-        )>,
-    ),
-}
-
-#[pin_project]
-pub struct HttpServiceHandlerResponse<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    #[pin]
-    state: State<T, S, B, X, U>,
-}
-
-impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Output = Result<(), DispatchError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().state.poll(cx)
-    }
-}
-
-impl<T, S, B, X, U> State<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn poll(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), DispatchError>> {
-        match self.as_mut().project() {
-            StateProj::H1(disp) => disp.poll(cx),
-            StateProj::H2(disp) => disp.poll(cx),
-            StateProj::H2Handshake(ref mut data) => {
-                let conn = if let Some(ref mut item) = data {
-                    match Pin::new(&mut item.0).poll(cx) {
-                        Poll::Ready(Ok(conn)) => conn,
-                        Poll::Ready(Err(err)) => {
-                            trace!("H2 handshake error: {}", err);
-                            return Poll::Ready(Err(err.into()));
-                        }
-                        Poll::Pending => return Poll::Pending,
-                    }
-                } else {
-                    panic!()
-                };
-                let (_, cfg, srv, on_connect, peer_addr) = data.take().unwrap();
-                self.set(State::H2(Dispatcher::new(
-                    srv, conn, on_connect, cfg, None, peer_addr,
-                )));
-                self.poll(cx)
-            }
-        }
-    }
-}

actix-http/src/test.rs

@@ -1,270 +0,0 @@
-//! Test Various helpers for Actix applications to use during testing.
-use std::convert::TryFrom;
-use std::io::{self, Read, Write};
-use std::pin::Pin;
-use std::str::FromStr;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use bytes::{Bytes, BytesMut};
-use http::header::{self, HeaderName, HeaderValue};
-use http::{Error as HttpError, Method, Uri, Version};
-
-use crate::cookie::{Cookie, CookieJar};
-use crate::header::HeaderMap;
-use crate::header::{Header, IntoHeaderValue};
-use crate::payload::Payload;
-use crate::Request;
-
-/// Test `Request` builder
-///
-/// ```rust,ignore
-/// # use http::{header, StatusCode};
-/// # use actix_web::*;
-/// use actix_web::test::TestRequest;
-///
-/// fn index(req: &HttpRequest) -> Response {
-///     if let Some(hdr) = req.headers().get(header::CONTENT_TYPE) {
-///         Response::Ok().into()
-///     } else {
-///         Response::BadRequest().into()
-///     }
-/// }
-///
-/// let resp = TestRequest::with_header("content-type", "text/plain")
-///     .run(&index)
-///     .unwrap();
-/// assert_eq!(resp.status(), StatusCode::OK);
-///
-/// let resp = TestRequest::default().run(&index).unwrap();
-/// assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-/// ```
-pub struct TestRequest(Option<Inner>);
-
-struct Inner {
-    version: Version,
-    method: Method,
-    uri: Uri,
-    headers: HeaderMap,
-    cookies: CookieJar,
-    payload: Option<Payload>,
-}
-
-impl Default for TestRequest {
-    fn default() -> TestRequest {
-        TestRequest(Some(Inner {
-            method: Method::GET,
-            uri: Uri::from_str("/").unwrap(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::new(),
-            cookies: CookieJar::new(),
-            payload: None,
-        }))
-    }
-}
-
-impl TestRequest {
-    /// Create TestRequest and set request uri
-    pub fn with_uri(path: &str) -> TestRequest {
-        TestRequest::default().uri(path).take()
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_hdr<H: Header>(hdr: H) -> TestRequest {
-        TestRequest::default().set(hdr).take()
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_header<K, V>(key: K, value: V) -> TestRequest
-    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
-        V: IntoHeaderValue,
-    {
-        TestRequest::default().header(key, value).take()
-    }
-
-    /// Set HTTP version of this request
-    pub fn version(&mut self, ver: Version) -> &mut Self {
-        parts(&mut self.0).version = ver;
-        self
-    }
-
-    /// Set HTTP method of this request
-    pub fn method(&mut self, meth: Method) -> &mut Self {
-        parts(&mut self.0).method = meth;
-        self
-    }
-
-    /// Set HTTP Uri of this request
-    pub fn uri(&mut self, path: &str) -> &mut Self {
-        parts(&mut self.0).uri = Uri::from_str(path).unwrap();
-        self
-    }
-
-    /// Set a header
-    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self {
-        if let Ok(value) = hdr.try_into() {
-            parts(&mut self.0).headers.append(H::name(), value);
-            return self;
-        }
-        panic!("Can not set header");
-    }
-
-    /// Set a header
-    pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
-        V: IntoHeaderValue,
-    {
-        if let Ok(key) = HeaderName::try_from(key) {
-            if let Ok(value) = value.try_into() {
-                parts(&mut self.0).headers.append(key, value);
-                return self;
-            }
-        }
-        panic!("Can not create header");
-    }
-
-    /// Set cookie for this request
-    pub fn cookie<'a>(&mut self, cookie: Cookie<'a>) -> &mut Self {
-        parts(&mut self.0).cookies.add(cookie.into_owned());
-        self
-    }
-
-    /// Set request payload
-    pub fn set_payload<B: Into<Bytes>>(&mut self, data: B) -> &mut Self {
-        let mut payload = crate::h1::Payload::empty();
-        payload.unread_data(data.into());
-        parts(&mut self.0).payload = Some(payload.into());
-        self
-    }
-
-    pub fn take(&mut self) -> TestRequest {
-        TestRequest(self.0.take())
-    }
-
-    /// Complete request creation and generate `Request` instance
-    pub fn finish(&mut self) -> Request {
-        let inner = self.0.take().expect("cannot reuse test request builder");
-
-        let mut req = if let Some(pl) = inner.payload {
-            Request::with_payload(pl)
-        } else {
-            Request::with_payload(crate::h1::Payload::empty().into())
-        };
-
-        let head = req.head_mut();
-        head.uri = inner.uri;
-        head.method = inner.method;
-        head.version = inner.version;
-        head.headers = inner.headers;
-
-        let cookie: String = inner
-            .cookies
-            .delta()
-            // ensure only name=value is written to cookie header
-            .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
-            .collect::<Vec<_>>()
-            .join("; ");
-
-        if !cookie.is_empty() {
-            head.headers
-                .insert(header::COOKIE, HeaderValue::from_str(&cookie).unwrap());
-        }
-
-        req
-    }
-}
-
-#[inline]
-fn parts(parts: &mut Option<Inner>) -> &mut Inner {
-    parts.as_mut().expect("cannot reuse test request builder")
-}
-
-/// Async io buffer
-pub struct TestBuffer {
-    pub read_buf: BytesMut,
-    pub write_buf: BytesMut,
-    pub err: Option<io::Error>,
-}
-
-impl TestBuffer {
-    /// Create new TestBuffer instance
-    pub fn new<T>(data: T) -> TestBuffer
-    where
-        BytesMut: From<T>,
-    {
-        TestBuffer {
-            read_buf: BytesMut::from(data),
-            write_buf: BytesMut::new(),
-            err: None,
-        }
-    }
-
-    /// Create new empty TestBuffer instance
-    pub fn empty() -> TestBuffer {
-        TestBuffer::new("")
-    }
-
-    /// Add extra data to read buffer.
-    pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
-        self.read_buf.extend_from_slice(data.as_ref())
-    }
-}
-
-impl io::Read for TestBuffer {
-    fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
-        if self.read_buf.is_empty() {
-            if self.err.is_some() {
-                Err(self.err.take().unwrap())
-            } else {
-                Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
-            }
-        } else {
-            let size = std::cmp::min(self.read_buf.len(), dst.len());
-            let b = self.read_buf.split_to(size);
-            dst[..size].copy_from_slice(&b);
-            Ok(size)
-        }
-    }
-}
-
-impl io::Write for TestBuffer {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.write_buf.extend(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncRead for TestBuffer {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        Poll::Ready(self.get_mut().read(buf))
-    }
-}
-
-impl AsyncWrite for TestBuffer {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Poll::Ready(self.get_mut().write(buf))
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Poll::Ready(Ok(()))
-    }
-}

actix-http/src/time_parser.rs

@@ -1,42 +0,0 @@
-use time::{Date, OffsetDateTime, PrimitiveDateTime};
-
-/// Attempt to parse a `time` string as one of either RFC 1123, RFC 850, or asctime.
-pub fn parse_http_date(time: &str) -> Option<PrimitiveDateTime> {
-    try_parse_rfc_1123(time)
-        .or_else(|| try_parse_rfc_850(time))
-        .or_else(|| try_parse_asctime(time))
-}
-
-/// Attempt to parse a `time` string as a RFC 1123 formatted date time string.
-fn try_parse_rfc_1123(time: &str) -> Option<PrimitiveDateTime> {
-    time::parse(time, "%a, %d %b %Y %H:%M:%S").ok()
-}
-
-/// Attempt to parse a `time` string as a RFC 850 formatted date time string.
-fn try_parse_rfc_850(time: &str) -> Option<PrimitiveDateTime> {
-    match PrimitiveDateTime::parse(time, "%A, %d-%b-%y %H:%M:%S") {
-        Ok(dt) => {
-            // If the `time` string contains a two-digit year, then as per RFC 2616 § 19.3,
-            // we consider the year as part of this century if it's within the next 50 years,
-            // otherwise we consider as part of the previous century.
-            let now = OffsetDateTime::now_utc();
-            let century_start_year = (now.year() / 100) * 100;
-            let mut expanded_year = century_start_year + dt.year();
-
-            if expanded_year > now.year() + 50 {
-                expanded_year -= 100;
-            }
-
-            match Date::try_from_ymd(expanded_year, dt.month(), dt.day()) {
-                Ok(date) => Some(PrimitiveDateTime::new(date, dt.time())),
-                Err(_) => None,
-            }
-        }
-        Err(_) => None,
-    }
-}
-
-/// Attempt to parse a `time` string using ANSI C's `asctime` format.
-fn try_parse_asctime(time: &str) -> Option<PrimitiveDateTime> {
-    time::parse(time, "%a %b %_d %H:%M:%S %Y").ok()
-}

actix-http/src/ws/codec.rs

@@ -1,283 +0,0 @@
-use actix_codec::{Decoder, Encoder};
-use bytes::{Bytes, BytesMut};
-
-use super::frame::Parser;
-use super::proto::{CloseReason, OpCode};
-use super::ProtocolError;
-
-/// `WebSocket` Message
-#[derive(Debug, PartialEq)]
-pub enum Message {
-    /// Text message
-    Text(String),
-    /// Binary message
-    Binary(Bytes),
-    /// Continuation
-    Continuation(Item),
-    /// Ping message
-    Ping(Bytes),
-    /// Pong message
-    Pong(Bytes),
-    /// Close message with optional reason
-    Close(Option<CloseReason>),
-    /// No-op. Useful for actix-net services
-    Nop,
-}
-
-/// `WebSocket` frame
-#[derive(Debug, PartialEq)]
-pub enum Frame {
-    /// Text frame, codec does not verify utf8 encoding
-    Text(Bytes),
-    /// Binary frame
-    Binary(Bytes),
-    /// Continuation
-    Continuation(Item),
-    /// Ping message
-    Ping(Bytes),
-    /// Pong message
-    Pong(Bytes),
-    /// Close message with optional reason
-    Close(Option<CloseReason>),
-}
-
-/// `WebSocket` continuation item
-#[derive(Debug, PartialEq)]
-pub enum Item {
-    FirstText(Bytes),
-    FirstBinary(Bytes),
-    Continue(Bytes),
-    Last(Bytes),
-}
-
-#[derive(Debug, Copy, Clone)]
-/// WebSockets protocol codec
-pub struct Codec {
-    flags: Flags,
-    max_size: usize,
-}
-
-bitflags::bitflags! {
-    struct Flags: u8 {
-        const SERVER         = 0b0000_0001;
-        const CONTINUATION   = 0b0000_0010;
-        const W_CONTINUATION = 0b0000_0100;
-    }
-}
-
-impl Codec {
-    /// Create new websocket frames decoder
-    pub fn new() -> Codec {
-        Codec {
-            max_size: 65_536,
-            flags: Flags::SERVER,
-        }
-    }
-
-    /// Set max frame size
-    ///
-    /// By default max size is set to 64kb
-    pub fn max_size(mut self, size: usize) -> Self {
-        self.max_size = size;
-        self
-    }
-
-    /// Set decoder to client mode.
-    ///
-    /// By default decoder works in server mode.
-    pub fn client_mode(mut self) -> Self {
-        self.flags.remove(Flags::SERVER);
-        self
-    }
-}
-
-impl Encoder<Message> for Codec {
-    type Error = ProtocolError;
-
-    fn encode(&mut self, item: Message, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        match item {
-            Message::Text(txt) => Parser::write_message(
-                dst,
-                txt,
-                OpCode::Text,
-                true,
-                !self.flags.contains(Flags::SERVER),
-            ),
-            Message::Binary(bin) => Parser::write_message(
-                dst,
-                bin,
-                OpCode::Binary,
-                true,
-                !self.flags.contains(Flags::SERVER),
-            ),
-            Message::Ping(txt) => Parser::write_message(
-                dst,
-                txt,
-                OpCode::Ping,
-                true,
-                !self.flags.contains(Flags::SERVER),
-            ),
-            Message::Pong(txt) => Parser::write_message(
-                dst,
-                txt,
-                OpCode::Pong,
-                true,
-                !self.flags.contains(Flags::SERVER),
-            ),
-            Message::Close(reason) => {
-                Parser::write_close(dst, reason, !self.flags.contains(Flags::SERVER))
-            }
-            Message::Continuation(cont) => match cont {
-                Item::FirstText(data) => {
-                    if self.flags.contains(Flags::W_CONTINUATION) {
-                        return Err(ProtocolError::ContinuationStarted);
-                    } else {
-                        self.flags.insert(Flags::W_CONTINUATION);
-                        Parser::write_message(
-                            dst,
-                            &data[..],
-                            OpCode::Text,
-                            false,
-                            !self.flags.contains(Flags::SERVER),
-                        )
-                    }
-                }
-                Item::FirstBinary(data) => {
-                    if self.flags.contains(Flags::W_CONTINUATION) {
-                        return Err(ProtocolError::ContinuationStarted);
-                    } else {
-                        self.flags.insert(Flags::W_CONTINUATION);
-                        Parser::write_message(
-                            dst,
-                            &data[..],
-                            OpCode::Binary,
-                            false,
-                            !self.flags.contains(Flags::SERVER),
-                        )
-                    }
-                }
-                Item::Continue(data) => {
-                    if self.flags.contains(Flags::W_CONTINUATION) {
-                        Parser::write_message(
-                            dst,
-                            &data[..],
-                            OpCode::Continue,
-                            false,
-                            !self.flags.contains(Flags::SERVER),
-                        )
-                    } else {
-                        return Err(ProtocolError::ContinuationNotStarted);
-                    }
-                }
-                Item::Last(data) => {
-                    if self.flags.contains(Flags::W_CONTINUATION) {
-                        self.flags.remove(Flags::W_CONTINUATION);
-                        Parser::write_message(
-                            dst,
-                            &data[..],
-                            OpCode::Continue,
-                            true,
-                            !self.flags.contains(Flags::SERVER),
-                        )
-                    } else {
-                        return Err(ProtocolError::ContinuationNotStarted);
-                    }
-                }
-            },
-            Message::Nop => (),
-        }
-        Ok(())
-    }
-}
-
-impl Decoder for Codec {
-    type Item = Frame;
-    type Error = ProtocolError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        match Parser::parse(src, self.flags.contains(Flags::SERVER), self.max_size) {
-            Ok(Some((finished, opcode, payload))) => {
-                // continuation is not supported
-                if !finished {
-                    return match opcode {
-                        OpCode::Continue => {
-                            if self.flags.contains(Flags::CONTINUATION) {
-                                Ok(Some(Frame::Continuation(Item::Continue(
-                                    payload
-                                        .map(|pl| pl.freeze())
-                                        .unwrap_or_else(Bytes::new),
-                                ))))
-                            } else {
-                                Err(ProtocolError::ContinuationNotStarted)
-                            }
-                        }
-                        OpCode::Binary => {
-                            if !self.flags.contains(Flags::CONTINUATION) {
-                                self.flags.insert(Flags::CONTINUATION);
-                                Ok(Some(Frame::Continuation(Item::FirstBinary(
-                                    payload
-                                        .map(|pl| pl.freeze())
-                                        .unwrap_or_else(Bytes::new),
-                                ))))
-                            } else {
-                                Err(ProtocolError::ContinuationStarted)
-                            }
-                        }
-                        OpCode::Text => {
-                            if !self.flags.contains(Flags::CONTINUATION) {
-                                self.flags.insert(Flags::CONTINUATION);
-                                Ok(Some(Frame::Continuation(Item::FirstText(
-                                    payload
-                                        .map(|pl| pl.freeze())
-                                        .unwrap_or_else(Bytes::new),
-                                ))))
-                            } else {
-                                Err(ProtocolError::ContinuationStarted)
-                            }
-                        }
-                        _ => {
-                            error!("Unfinished fragment {:?}", opcode);
-                            Err(ProtocolError::ContinuationFragment(opcode))
-                        }
-                    };
-                }
-
-                match opcode {
-                    OpCode::Continue => {
-                        if self.flags.contains(Flags::CONTINUATION) {
-                            self.flags.remove(Flags::CONTINUATION);
-                            Ok(Some(Frame::Continuation(Item::Last(
-                                payload.map(|pl| pl.freeze()).unwrap_or_else(Bytes::new),
-                            ))))
-                        } else {
-                            Err(ProtocolError::ContinuationNotStarted)
-                        }
-                    }
-                    OpCode::Bad => Err(ProtocolError::BadOpCode),
-                    OpCode::Close => {
-                        if let Some(ref pl) = payload {
-                            let close_reason = Parser::parse_close_payload(pl);
-                            Ok(Some(Frame::Close(close_reason)))
-                        } else {
-                            Ok(Some(Frame::Close(None)))
-                        }
-                    }
-                    OpCode::Ping => Ok(Some(Frame::Ping(
-                        payload.map(|pl| pl.freeze()).unwrap_or_else(Bytes::new),
-                    ))),
-                    OpCode::Pong => Ok(Some(Frame::Pong(
-                        payload.map(|pl| pl.freeze()).unwrap_or_else(Bytes::new),
-                    ))),
-                    OpCode::Binary => Ok(Some(Frame::Binary(
-                        payload.map(|pl| pl.freeze()).unwrap_or_else(Bytes::new),
-                    ))),
-                    OpCode::Text => Ok(Some(Frame::Text(
-                        payload.map(|pl| pl.freeze()).unwrap_or_else(Bytes::new),
-                    ))),
-                }
-            }
-            Ok(None) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-}

actix-http/src/ws/dispatcher.rs

@@ -1,53 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_service::{IntoService, Service};
-use actix_utils::dispatcher::{Dispatcher as InnerDispatcher, DispatcherError};
-
-use super::{Codec, Frame, Message};
-
-#[pin_project::pin_project]
-pub struct Dispatcher<S, T>
-where
-    S: Service<Request = Frame, Response = Message> + 'static,
-    T: AsyncRead + AsyncWrite,
-{
-    #[pin]
-    inner: InnerDispatcher<S, T, Codec, Message>,
-}
-
-impl<S, T> Dispatcher<S, T>
-where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Frame, Response = Message>,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    pub fn new<F: IntoService<S>>(io: T, service: F) -> Self {
-        Dispatcher {
-            inner: InnerDispatcher::new(Framed::new(io, Codec::new()), service),
-        }
-    }
-
-    pub fn with<F: IntoService<S>>(framed: Framed<T, Codec>, service: F) -> Self {
-        Dispatcher {
-            inner: InnerDispatcher::new(framed, service),
-        }
-    }
-}
-
-impl<S, T> Future for Dispatcher<S, T>
-where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Frame, Response = Message>,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    type Output = Result<(), DispatcherError<S::Error, Codec, Message>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().inner.poll(cx)
-    }
-}

actix-http/src/ws/frame.rs

@@ -1,380 +0,0 @@
-use std::convert::TryFrom;
-
-use bytes::{Buf, BufMut, BytesMut};
-use log::debug;
-
-use crate::ws::mask::apply_mask;
-use crate::ws::proto::{CloseCode, CloseReason, OpCode};
-use crate::ws::ProtocolError;
-
-/// A struct representing a `WebSocket` frame.
-#[derive(Debug)]
-pub struct Parser;
-
-impl Parser {
-    fn parse_metadata(
-        src: &[u8],
-        server: bool,
-        max_size: usize,
-    ) -> Result<Option<(usize, bool, OpCode, usize, Option<u32>)>, ProtocolError> {
-        let chunk_len = src.len();
-
-        let mut idx = 2;
-        if chunk_len < 2 {
-            return Ok(None);
-        }
-
-        let first = src[0];
-        let second = src[1];
-        let finished = first & 0x80 != 0;
-
-        // check masking
-        let masked = second & 0x80 != 0;
-        if !masked && server {
-            return Err(ProtocolError::UnmaskedFrame);
-        } else if masked && !server {
-            return Err(ProtocolError::MaskedFrame);
-        }
-
-        // Op code
-        let opcode = OpCode::from(first & 0x0F);
-
-        if let OpCode::Bad = opcode {
-            return Err(ProtocolError::InvalidOpcode(first & 0x0F));
-        }
-
-        let len = second & 0x7F;
-        let length = if len == 126 {
-            if chunk_len < 4 {
-                return Ok(None);
-            }
-            let len = usize::from(u16::from_be_bytes(
-                TryFrom::try_from(&src[idx..idx + 2]).unwrap(),
-            ));
-            idx += 2;
-            len
-        } else if len == 127 {
-            if chunk_len < 10 {
-                return Ok(None);
-            }
-            let len = u64::from_be_bytes(TryFrom::try_from(&src[idx..idx + 8]).unwrap());
-            if len > max_size as u64 {
-                return Err(ProtocolError::Overflow);
-            }
-            idx += 8;
-            len as usize
-        } else {
-            len as usize
-        };
-
-        // check for max allowed size
-        if length > max_size {
-            return Err(ProtocolError::Overflow);
-        }
-
-        let mask = if server {
-            if chunk_len < idx + 4 {
-                return Ok(None);
-            }
-
-            let mask =
-                u32::from_le_bytes(TryFrom::try_from(&src[idx..idx + 4]).unwrap());
-            idx += 4;
-            Some(mask)
-        } else {
-            None
-        };
-
-        Ok(Some((idx, finished, opcode, length, mask)))
-    }
-
-    /// Parse the input stream into a frame.
-    pub fn parse(
-        src: &mut BytesMut,
-        server: bool,
-        max_size: usize,
-    ) -> Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError> {
-        // try to parse ws frame metadata
-        let (idx, finished, opcode, length, mask) =
-            match Parser::parse_metadata(src, server, max_size)? {
-                None => return Ok(None),
-                Some(res) => res,
-            };
-
-        // not enough data
-        if src.len() < idx + length {
-            return Ok(None);
-        }
-
-        // remove prefix
-        src.advance(idx);
-
-        // no need for body
-        if length == 0 {
-            return Ok(Some((finished, opcode, None)));
-        }
-
-        let mut data = src.split_to(length);
-
-        // control frames must have length <= 125
-        match opcode {
-            OpCode::Ping | OpCode::Pong if length > 125 => {
-                return Err(ProtocolError::InvalidLength(length));
-            }
-            OpCode::Close if length > 125 => {
-                debug!("Received close frame with payload length exceeding 125. Morphing to protocol close frame.");
-                return Ok(Some((true, OpCode::Close, None)));
-            }
-            _ => (),
-        }
-
-        // unmask
-        if let Some(mask) = mask {
-            apply_mask(&mut data, mask);
-        }
-
-        Ok(Some((finished, opcode, Some(data))))
-    }
-
-    /// Parse the payload of a close frame.
-    pub fn parse_close_payload(payload: &[u8]) -> Option<CloseReason> {
-        if payload.len() >= 2 {
-            let raw_code = u16::from_be_bytes(TryFrom::try_from(&payload[..2]).unwrap());
-            let code = CloseCode::from(raw_code);
-            let description = if payload.len() > 2 {
-                Some(String::from_utf8_lossy(&payload[2..]).into())
-            } else {
-                None
-            };
-            Some(CloseReason { code, description })
-        } else {
-            None
-        }
-    }
-
-    /// Generate binary representation
-    pub fn write_message<B: AsRef<[u8]>>(
-        dst: &mut BytesMut,
-        pl: B,
-        op: OpCode,
-        fin: bool,
-        mask: bool,
-    ) {
-        let payload = pl.as_ref();
-        let one: u8 = if fin {
-            0x80 | Into::<u8>::into(op)
-        } else {
-            op.into()
-        };
-        let payload_len = payload.len();
-        let (two, p_len) = if mask {
-            (0x80, payload_len + 4)
-        } else {
-            (0, payload_len)
-        };
-
-        if payload_len < 126 {
-            dst.reserve(p_len + 2 + if mask { 4 } else { 0 });
-            dst.put_slice(&[one, two | payload_len as u8]);
-        } else if payload_len <= 65_535 {
-            dst.reserve(p_len + 4 + if mask { 4 } else { 0 });
-            dst.put_slice(&[one, two | 126]);
-            dst.put_u16(payload_len as u16);
-        } else {
-            dst.reserve(p_len + 10 + if mask { 4 } else { 0 });
-            dst.put_slice(&[one, two | 127]);
-            dst.put_u64(payload_len as u64);
-        };
-
-        if mask {
-            let mask = rand::random::<u32>();
-            dst.put_u32_le(mask);
-            dst.put_slice(payload.as_ref());
-            let pos = dst.len() - payload_len;
-            apply_mask(&mut dst[pos..], mask);
-        } else {
-            dst.put_slice(payload.as_ref());
-        }
-    }
-
-    /// Create a new Close control frame.
-    #[inline]
-    pub fn write_close(dst: &mut BytesMut, reason: Option<CloseReason>, mask: bool) {
-        let payload = match reason {
-            None => Vec::new(),
-            Some(reason) => {
-                let mut payload = Into::<u16>::into(reason.code).to_be_bytes().to_vec();
-                if let Some(description) = reason.description {
-                    payload.extend(description.as_bytes());
-                }
-                payload
-            }
-        };
-
-        Parser::write_message(dst, payload, OpCode::Close, true, mask)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bytes::Bytes;
-
-    struct F {
-        finished: bool,
-        opcode: OpCode,
-        payload: Bytes,
-    }
-
-    fn is_none(
-        frm: &Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError>,
-    ) -> bool {
-        matches!(*frm, Ok(None))
-    }
-
-    fn extract(
-        frm: Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError>,
-    ) -> F {
-        match frm {
-            Ok(Some((finished, opcode, payload))) => F {
-                finished,
-                opcode,
-                payload: payload
-                    .map(|b| b.freeze())
-                    .unwrap_or_else(|| Bytes::from("")),
-            },
-            _ => unreachable!("error"),
-        }
-    }
-
-    #[test]
-    fn test_parse() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0001u8][..]);
-        assert!(is_none(&Parser::parse(&mut buf, false, 1024)));
-
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0001u8][..]);
-        buf.extend(b"1");
-
-        let frame = extract(Parser::parse(&mut buf, false, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert_eq!(frame.payload.as_ref(), &b"1"[..]);
-    }
-
-    #[test]
-    fn test_parse_length0() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0000u8][..]);
-        let frame = extract(Parser::parse(&mut buf, false, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert!(frame.payload.is_empty());
-    }
-
-    #[test]
-    fn test_parse_length2() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 126u8][..]);
-        assert!(is_none(&Parser::parse(&mut buf, false, 1024)));
-
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 126u8][..]);
-        buf.extend(&[0u8, 4u8][..]);
-        buf.extend(b"1234");
-
-        let frame = extract(Parser::parse(&mut buf, false, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert_eq!(frame.payload.as_ref(), &b"1234"[..]);
-    }
-
-    #[test]
-    fn test_parse_length4() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 127u8][..]);
-        assert!(is_none(&Parser::parse(&mut buf, false, 1024)));
-
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 127u8][..]);
-        buf.extend(&[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 4u8][..]);
-        buf.extend(b"1234");
-
-        let frame = extract(Parser::parse(&mut buf, false, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert_eq!(frame.payload.as_ref(), &b"1234"[..]);
-    }
-
-    #[test]
-    fn test_parse_frame_mask() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b1000_0001u8][..]);
-        buf.extend(b"0001");
-        buf.extend(b"1");
-
-        assert!(Parser::parse(&mut buf, false, 1024).is_err());
-
-        let frame = extract(Parser::parse(&mut buf, true, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert_eq!(frame.payload, Bytes::from(vec![1u8]));
-    }
-
-    #[test]
-    fn test_parse_frame_no_mask() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0001u8][..]);
-        buf.extend(&[1u8]);
-
-        assert!(Parser::parse(&mut buf, true, 1024).is_err());
-
-        let frame = extract(Parser::parse(&mut buf, false, 1024));
-        assert!(!frame.finished);
-        assert_eq!(frame.opcode, OpCode::Text);
-        assert_eq!(frame.payload, Bytes::from(vec![1u8]));
-    }
-
-    #[test]
-    fn test_parse_frame_max_size() {
-        let mut buf = BytesMut::from(&[0b0000_0001u8, 0b0000_0010u8][..]);
-        buf.extend(&[1u8, 1u8]);
-
-        assert!(Parser::parse(&mut buf, true, 1).is_err());
-
-        if let Err(ProtocolError::Overflow) = Parser::parse(&mut buf, false, 0) {
-        } else {
-            unreachable!("error");
-        }
-    }
-
-    #[test]
-    fn test_ping_frame() {
-        let mut buf = BytesMut::new();
-        Parser::write_message(&mut buf, Vec::from("data"), OpCode::Ping, true, false);
-
-        let mut v = vec![137u8, 4u8];
-        v.extend(b"data");
-        assert_eq!(&buf[..], &v[..]);
-    }
-
-    #[test]
-    fn test_pong_frame() {
-        let mut buf = BytesMut::new();
-        Parser::write_message(&mut buf, Vec::from("data"), OpCode::Pong, true, false);
-
-        let mut v = vec![138u8, 4u8];
-        v.extend(b"data");
-        assert_eq!(&buf[..], &v[..]);
-    }
-
-    #[test]
-    fn test_close_frame() {
-        let mut buf = BytesMut::new();
-        let reason = (CloseCode::Normal, "data");
-        Parser::write_close(&mut buf, Some(reason.into()), false);
-
-        let mut v = vec![136u8, 6u8, 3u8, 232u8];
-        v.extend(b"data");
-        assert_eq!(&buf[..], &v[..]);
-    }
-
-    #[test]
-    fn test_empty_close_frame() {
-        let mut buf = BytesMut::new();
-        Parser::write_close(&mut buf, None, false);
-        assert_eq!(&buf[..], &vec![0x88, 0x00][..]);
-    }
-}

actix-http/src/ws/mask.rs

@@ -1,151 +0,0 @@
-//! This is code from [Tungstenite project](https://github.com/snapview/tungstenite-rs)
-#![allow(clippy::cast_ptr_alignment)]
-use std::ptr::copy_nonoverlapping;
-use std::slice;
-
-// Holds a slice guaranteed to be shorter than 8 bytes
-struct ShortSlice<'a>(&'a mut [u8]);
-
-impl<'a> ShortSlice<'a> {
-    /// # Safety
-    /// Given slice must be shorter than 8 bytes.
-    unsafe fn new(slice: &'a mut [u8]) -> Self {
-        // Sanity check for debug builds
-        debug_assert!(slice.len() < 8);
-        ShortSlice(slice)
-    }
-    fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-/// Faster version of `apply_mask()` which operates on 8-byte blocks.
-#[inline]
-#[allow(clippy::cast_lossless)]
-pub(crate) fn apply_mask(buf: &mut [u8], mask_u32: u32) {
-    // Extend the mask to 64 bits
-    let mut mask_u64 = ((mask_u32 as u64) << 32) | (mask_u32 as u64);
-    // Split the buffer into three segments
-    let (head, mid, tail) = align_buf(buf);
-
-    // Initial unaligned segment
-    let head_len = head.len();
-    if head_len > 0 {
-        xor_short(head, mask_u64);
-        if cfg!(target_endian = "big") {
-            mask_u64 = mask_u64.rotate_left(8 * head_len as u32);
-        } else {
-            mask_u64 = mask_u64.rotate_right(8 * head_len as u32);
-        }
-    }
-    // Aligned segment
-    for v in mid {
-        *v ^= mask_u64;
-    }
-    // Final unaligned segment
-    if tail.len() > 0 {
-        xor_short(tail, mask_u64);
-    }
-}
-
-// TODO: copy_nonoverlapping here compiles to call memcpy. While it is not so
-// inefficient, it could be done better. The compiler does not understand that
-// a `ShortSlice` must be smaller than a u64.
-#[inline]
-#[allow(clippy::needless_pass_by_value)]
-fn xor_short(buf: ShortSlice<'_>, mask: u64) {
-    // SAFETY: we know that a `ShortSlice` fits in a u64
-    unsafe {
-        let (ptr, len) = (buf.0.as_mut_ptr(), buf.0.len());
-        let mut b: u64 = 0;
-        #[allow(trivial_casts)]
-        copy_nonoverlapping(ptr, &mut b as *mut _ as *mut u8, len);
-        b ^= mask;
-        #[allow(trivial_casts)]
-        copy_nonoverlapping(&b as *const _ as *const u8, ptr, len);
-    }
-}
-
-/// # Safety
-/// Caller must ensure the buffer has the correct size and alignment.
-#[inline]
-unsafe fn cast_slice(buf: &mut [u8]) -> &mut [u64] {
-    // Assert correct size and alignment in debug builds
-    debug_assert!(buf.len().trailing_zeros() >= 3);
-    debug_assert!((buf.as_ptr() as usize).trailing_zeros() >= 3);
-
-    slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u64, buf.len() >> 3)
-}
-
-// Splits a slice into three parts: an unaligned short head and tail, plus an aligned
-// u64 mid section.
-#[inline]
-fn align_buf(buf: &mut [u8]) -> (ShortSlice<'_>, &mut [u64], ShortSlice<'_>) {
-    let start_ptr = buf.as_ptr() as usize;
-    let end_ptr = start_ptr + buf.len();
-
-    // Round *up* to next aligned boundary for start
-    let start_aligned = (start_ptr + 7) & !0x7;
-    // Round *down* to last aligned boundary for end
-    let end_aligned = end_ptr & !0x7;
-
-    if end_aligned >= start_aligned {
-        // We have our three segments (head, mid, tail)
-        let (tmp, tail) = buf.split_at_mut(end_aligned - start_ptr);
-        let (head, mid) = tmp.split_at_mut(start_aligned - start_ptr);
-
-        // SAFETY: we know the middle section is correctly aligned, and the outer
-        // sections are smaller than 8 bytes
-        unsafe { (ShortSlice::new(head), cast_slice(mid), ShortSlice(tail)) }
-    } else {
-        // We didn't cross even one aligned boundary!
-
-        // SAFETY: The outer sections are smaller than 8 bytes
-        unsafe { (ShortSlice::new(buf), &mut [], ShortSlice::new(&mut [])) }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::apply_mask;
-
-    /// A safe unoptimized mask application.
-    fn apply_mask_fallback(buf: &mut [u8], mask: &[u8; 4]) {
-        for (i, byte) in buf.iter_mut().enumerate() {
-            *byte ^= mask[i & 3];
-        }
-    }
-
-    #[test]
-    fn test_apply_mask() {
-        let mask = [0x6d, 0xb6, 0xb2, 0x80];
-        let mask_u32 = u32::from_le_bytes(mask);
-
-        let unmasked = vec![
-            0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17,
-            0x74, 0xf9, 0x12, 0x03,
-        ];
-
-        // Check masking with proper alignment.
-        {
-            let mut masked = unmasked.clone();
-            apply_mask_fallback(&mut masked, &mask);
-
-            let mut masked_fast = unmasked.clone();
-            apply_mask(&mut masked_fast, mask_u32);
-
-            assert_eq!(masked, masked_fast);
-        }
-
-        // Check masking without alignment.
-        {
-            let mut masked = unmasked.clone();
-            apply_mask_fallback(&mut masked[1..], &mask);
-
-            let mut masked_fast = unmasked;
-            apply_mask(&mut masked_fast[1..], mask_u32);
-
-            assert_eq!(masked, masked_fast);
-        }
-    }
-}

actix-http/src/ws/mod.rs

@@ -1,320 +0,0 @@
-//! WebSocket protocol support.
-//!
-//! To setup a `WebSocket`, first do web socket handshake then on success
-//! convert `Payload` into a `WsStream` stream and then use `WsWriter` to
-//! communicate with the peer.
-use std::io;
-
-use derive_more::{Display, From};
-use http::{header, Method, StatusCode};
-
-use crate::error::ResponseError;
-use crate::message::RequestHead;
-use crate::response::{Response, ResponseBuilder};
-
-mod codec;
-mod dispatcher;
-mod frame;
-mod mask;
-mod proto;
-
-pub use self::codec::{Codec, Frame, Item, Message};
-pub use self::dispatcher::Dispatcher;
-pub use self::frame::Parser;
-pub use self::proto::{hash_key, CloseCode, CloseReason, OpCode};
-
-/// Websocket protocol errors
-#[derive(Debug, Display, From)]
-pub enum ProtocolError {
-    /// Received an unmasked frame from client
-    #[display(fmt = "Received an unmasked frame from client")]
-    UnmaskedFrame,
-    /// Received a masked frame from server
-    #[display(fmt = "Received a masked frame from server")]
-    MaskedFrame,
-    /// Encountered invalid opcode
-    #[display(fmt = "Invalid opcode: {}", _0)]
-    InvalidOpcode(u8),
-    /// Invalid control frame length
-    #[display(fmt = "Invalid control frame length: {}", _0)]
-    InvalidLength(usize),
-    /// Bad web socket op code
-    #[display(fmt = "Bad web socket op code")]
-    BadOpCode,
-    /// A payload reached size limit.
-    #[display(fmt = "A payload reached size limit.")]
-    Overflow,
-    /// Continuation is not started
-    #[display(fmt = "Continuation is not started.")]
-    ContinuationNotStarted,
-    /// Received new continuation but it is already started
-    #[display(fmt = "Received new continuation but it is already started")]
-    ContinuationStarted,
-    /// Unknown continuation fragment
-    #[display(fmt = "Unknown continuation fragment.")]
-    ContinuationFragment(OpCode),
-    /// Io error
-    #[display(fmt = "io error: {}", _0)]
-    Io(io::Error),
-}
-
-impl std::error::Error for ProtocolError {}
-
-impl ResponseError for ProtocolError {}
-
-/// Websocket handshake errors
-#[derive(PartialEq, Debug, Display)]
-pub enum HandshakeError {
-    /// Only get method is allowed
-    #[display(fmt = "Method not allowed")]
-    GetMethodRequired,
-    /// Upgrade header if not set to websocket
-    #[display(fmt = "Websocket upgrade is expected")]
-    NoWebsocketUpgrade,
-    /// Connection header is not set to upgrade
-    #[display(fmt = "Connection upgrade is expected")]
-    NoConnectionUpgrade,
-    /// Websocket version header is not set
-    #[display(fmt = "Websocket version header is required")]
-    NoVersionHeader,
-    /// Unsupported websocket version
-    #[display(fmt = "Unsupported version")]
-    UnsupportedVersion,
-    /// Websocket key is not set or wrong
-    #[display(fmt = "Unknown websocket key")]
-    BadWebsocketKey,
-}
-
-impl ResponseError for HandshakeError {
-    fn error_response(&self) -> Response {
-        match *self {
-            HandshakeError::GetMethodRequired => Response::MethodNotAllowed()
-                .header(header::ALLOW, "GET")
-                .finish(),
-            HandshakeError::NoWebsocketUpgrade => Response::BadRequest()
-                .reason("No WebSocket UPGRADE header found")
-                .finish(),
-            HandshakeError::NoConnectionUpgrade => Response::BadRequest()
-                .reason("No CONNECTION upgrade")
-                .finish(),
-            HandshakeError::NoVersionHeader => Response::BadRequest()
-                .reason("Websocket version header is required")
-                .finish(),
-            HandshakeError::UnsupportedVersion => Response::BadRequest()
-                .reason("Unsupported version")
-                .finish(),
-            HandshakeError::BadWebsocketKey => {
-                Response::BadRequest().reason("Handshake error").finish()
-            }
-        }
-    }
-}
-
-/// Verify `WebSocket` handshake request and create handshake response.
-// /// `protocols` is a sequence of known protocols. On successful handshake,
-// /// the returned response headers contain the first protocol in this list
-// /// which the server also knows.
-pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
-    verify_handshake(req)?;
-    Ok(handshake_response(req))
-}
-
-/// Verify `WebSocket` handshake request.
-// /// `protocols` is a sequence of known protocols. On successful handshake,
-// /// the returned response headers contain the first protocol in this list
-// /// which the server also knows.
-pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
-    // WebSocket accepts only GET
-    if req.method != Method::GET {
-        return Err(HandshakeError::GetMethodRequired);
-    }
-
-    // Check for "UPGRADE" to websocket header
-    let has_hdr = if let Some(hdr) = req.headers().get(header::UPGRADE) {
-        if let Ok(s) = hdr.to_str() {
-            s.to_ascii_lowercase().contains("websocket")
-        } else {
-            false
-        }
-    } else {
-        false
-    };
-    if !has_hdr {
-        return Err(HandshakeError::NoWebsocketUpgrade);
-    }
-
-    // Upgrade connection
-    if !req.upgrade() {
-        return Err(HandshakeError::NoConnectionUpgrade);
-    }
-
-    // check supported version
-    if !req.headers().contains_key(header::SEC_WEBSOCKET_VERSION) {
-        return Err(HandshakeError::NoVersionHeader);
-    }
-    let supported_ver = {
-        if let Some(hdr) = req.headers().get(header::SEC_WEBSOCKET_VERSION) {
-            hdr == "13" || hdr == "8" || hdr == "7"
-        } else {
-            false
-        }
-    };
-    if !supported_ver {
-        return Err(HandshakeError::UnsupportedVersion);
-    }
-
-    // check client handshake for validity
-    if !req.headers().contains_key(header::SEC_WEBSOCKET_KEY) {
-        return Err(HandshakeError::BadWebsocketKey);
-    }
-    Ok(())
-}
-
-/// Create websocket handshake response
-///
-/// This function returns handshake `Response`, ready to send to peer.
-pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
-    let key = {
-        let key = req.headers().get(header::SEC_WEBSOCKET_KEY).unwrap();
-        proto::hash_key(key.as_ref())
-    };
-
-    Response::build(StatusCode::SWITCHING_PROTOCOLS)
-        .upgrade("websocket")
-        .header(header::TRANSFER_ENCODING, "chunked")
-        .header(header::SEC_WEBSOCKET_ACCEPT, key.as_str())
-        .take()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test::TestRequest;
-    use http::{header, Method};
-
-    #[test]
-    fn test_handshake() {
-        let req = TestRequest::default().method(Method::POST).finish();
-        assert_eq!(
-            HandshakeError::GetMethodRequired,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default().finish();
-        assert_eq!(
-            HandshakeError::NoWebsocketUpgrade,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(header::UPGRADE, header::HeaderValue::from_static("test"))
-            .finish();
-        assert_eq!(
-            HandshakeError::NoWebsocketUpgrade,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(
-                header::UPGRADE,
-                header::HeaderValue::from_static("websocket"),
-            )
-            .finish();
-        assert_eq!(
-            HandshakeError::NoConnectionUpgrade,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(
-                header::UPGRADE,
-                header::HeaderValue::from_static("websocket"),
-            )
-            .header(
-                header::CONNECTION,
-                header::HeaderValue::from_static("upgrade"),
-            )
-            .finish();
-        assert_eq!(
-            HandshakeError::NoVersionHeader,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(
-                header::UPGRADE,
-                header::HeaderValue::from_static("websocket"),
-            )
-            .header(
-                header::CONNECTION,
-                header::HeaderValue::from_static("upgrade"),
-            )
-            .header(
-                header::SEC_WEBSOCKET_VERSION,
-                header::HeaderValue::from_static("5"),
-            )
-            .finish();
-        assert_eq!(
-            HandshakeError::UnsupportedVersion,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(
-                header::UPGRADE,
-                header::HeaderValue::from_static("websocket"),
-            )
-            .header(
-                header::CONNECTION,
-                header::HeaderValue::from_static("upgrade"),
-            )
-            .header(
-                header::SEC_WEBSOCKET_VERSION,
-                header::HeaderValue::from_static("13"),
-            )
-            .finish();
-        assert_eq!(
-            HandshakeError::BadWebsocketKey,
-            verify_handshake(req.head()).err().unwrap()
-        );
-
-        let req = TestRequest::default()
-            .header(
-                header::UPGRADE,
-                header::HeaderValue::from_static("websocket"),
-            )
-            .header(
-                header::CONNECTION,
-                header::HeaderValue::from_static("upgrade"),
-            )
-            .header(
-                header::SEC_WEBSOCKET_VERSION,
-                header::HeaderValue::from_static("13"),
-            )
-            .header(
-                header::SEC_WEBSOCKET_KEY,
-                header::HeaderValue::from_static("13"),
-            )
-            .finish();
-        assert_eq!(
-            StatusCode::SWITCHING_PROTOCOLS,
-            handshake_response(req.head()).finish().status()
-        );
-    }
-
-    #[test]
-    fn test_wserror_http_response() {
-        let resp: Response = HandshakeError::GetMethodRequired.error_response();
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-        let resp: Response = HandshakeError::NoWebsocketUpgrade.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::NoConnectionUpgrade.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::NoVersionHeader.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::UnsupportedVersion.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::BadWebsocketKey.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-    }
-}

actix-http/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-http/tests/test_client.rs

@@ -1,91 +0,0 @@
-use actix_service::ServiceFactory;
-use bytes::Bytes;
-use futures_util::future::{self, ok};
-
-use actix_http::{http, HttpService, Request, Response};
-use actix_http_test::test_server;
-
-const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World";
-
-#[actix_rt::test]
-async fn test_h1_v2() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    let request = srv.get("/").header("x-test", "111").send();
-    let mut response = request.await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = response.body().await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-
-    let mut response = srv.post("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = response.body().await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_connection_close() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-            .map(|_| ())
-    })
-    .await;
-
-    let response = srv.get("/").force_close().send().await.unwrap();
-    assert!(response.status().is_success());
-}
-
-#[actix_rt::test]
-async fn test_with_query_parameter() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .finish(|req: Request| {
-                if req.uri().query().unwrap().contains("qp=") {
-                    ok::<_, ()>(Response::Ok().finish())
-                } else {
-                    ok::<_, ()>(Response::BadRequest().finish())
-                }
-            })
-            .tcp()
-            .map(|_| ())
-    })
-    .await;
-
-    let request = srv.request(http::Method::GET, srv.url("/?qp=5"));
-    let response = request.send().await.unwrap();
-    assert!(response.status().is_success());
-}

actix-http/tests/test_openssl.rs

@@ -1,425 +0,0 @@
-#![cfg(feature = "openssl")]
-use std::io;
-
-use actix_http_test::test_server;
-use actix_service::{fn_service, ServiceFactory};
-
-use bytes::{Bytes, BytesMut};
-use futures_util::future::{err, ok, ready};
-use futures_util::stream::{once, Stream, StreamExt};
-use open_ssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};
-
-use actix_http::error::{ErrorBadRequest, PayloadError};
-use actix_http::http::header::{self, HeaderName, HeaderValue};
-use actix_http::http::{Method, StatusCode, Version};
-use actix_http::httpmessage::HttpMessage;
-use actix_http::{body, Error, HttpService, Request, Response};
-
-async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>>,
-{
-    let body = stream
-        .map(|res| match res {
-            Ok(chunk) => chunk,
-            Err(_) => panic!(),
-        })
-        .fold(BytesMut::new(), move |mut body, chunk| {
-            body.extend_from_slice(&chunk);
-            ready(body)
-        })
-        .await;
-
-    Ok(body)
-}
-
-fn ssl_acceptor() -> SslAcceptor {
-    // load ssl keys
-    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
-    builder
-        .set_private_key_file("../tests/key.pem", SslFiletype::PEM)
-        .unwrap();
-    builder
-        .set_certificate_chain_file("../tests/cert.pem")
-        .unwrap();
-    builder.set_alpn_select_callback(|_, protos| {
-        const H2: &[u8] = b"\x02h2";
-        const H11: &[u8] = b"\x08http/1.1";
-        if protos.windows(3).any(|window| window == H2) {
-            Ok(b"h2")
-        } else if protos.windows(9).any(|window| window == H11) {
-            Ok(b"http/1.1")
-        } else {
-            Err(AlpnError::NOACK)
-        }
-    });
-    builder
-        .set_alpn_protos(b"\x08http/1.1\x02h2")
-        .expect("Can not contrust SslAcceptor");
-
-    builder.build()
-}
-
-#[actix_rt::test]
-async fn test_h2() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, Error>(Response::Ok().finish()))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_1() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .finish(|req: Request| {
-                assert!(req.peer_addr().is_some());
-                assert_eq!(req.version(), Version::HTTP_2);
-                ok::<_, Error>(Response::Ok().finish())
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_body() -> io::Result<()> {
-    let data = "HELLOWORLD".to_owned().repeat(64 * 1024);
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|mut req: Request<_>| async move {
-                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send_body(data.clone()).await.unwrap();
-    assert!(response.status().is_success());
-
-    let body = srv.load_body(response).await.unwrap();
-    assert_eq!(&body, data.as_bytes());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_content_length() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|req: Request| {
-                let indx: usize = req.uri().path()[1..].parse().unwrap();
-                let statuses = [
-                    StatusCode::NO_CONTENT,
-                    StatusCode::CONTINUE,
-                    StatusCode::SWITCHING_PROTOCOLS,
-                    StatusCode::PROCESSING,
-                    StatusCode::OK,
-                    StatusCode::NOT_FOUND,
-                ];
-                ok::<_, ()>(Response::new(statuses[indx]))
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let header = HeaderName::from_static("content-length");
-    let value = HeaderValue::from_static("0");
-
-    {
-        for i in 0..4 {
-            let req = srv
-                .request(Method::GET, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-
-            let req = srv
-                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-        }
-
-        for i in 4..6 {
-            let req = srv
-                .request(Method::GET, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), Some(&value));
-        }
-    }
-}
-
-#[actix_rt::test]
-async fn test_h2_headers() {
-    let data = STR.repeat(10);
-    let data2 = data.clone();
-
-    let mut srv = test_server(move || {
-        let data = data.clone();
-        HttpService::build().h2(move |_| {
-            let mut builder = Response::Ok();
-            for idx in 0..90 {
-                builder.header(
-                    format!("X-TEST-{}", idx).as_str(),
-                    "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
-                );
-            }
-            ok::<_, ()>(builder.body(data.clone()))
-        })
-            .openssl(ssl_acceptor())
-                    .map_err(|_| ())
-    }).await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from(data2));
-}
-
-const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World";
-
-#[actix_rt::test]
-async fn test_h2_body2() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_head_empty() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(response.version(), Version::HTTP_2);
-
-    {
-        let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h2_head_binary() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h2_head_binary2() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-}
-
-#[actix_rt::test]
-async fn test_h2_body_length() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
-                )
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_body_chunked_explicit() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| {
-                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
-                        .header(header::TRANSFER_ENCODING, "chunked")
-                        .streaming(body),
-                )
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert!(!response.headers().contains_key(header::TRANSFER_ENCODING));
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-
-    // decode
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_response_http_error_handling() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(fn_service(|_| {
-                let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
-                    Response::Ok()
-                        .header(header::CONTENT_TYPE, broken_header)
-                        .body(STR),
-                )
-            }))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
-}
-
-#[actix_rt::test]
-async fn test_h2_service_error() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| err::<Response, Error>(ErrorBadRequest("error")))
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"error"));
-}
-
-#[actix_rt::test]
-async fn test_h2_on_connect() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .on_connect(|_| 10usize)
-            .h2(|req: Request| {
-                assert!(req.extensions().contains::<usize>());
-                ok::<_, ()>(Response::Ok().finish())
-            })
-            .openssl(ssl_acceptor())
-            .map_err(|_| ())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-}

actix-http/tests/test_rustls.rs

@@ -1,432 +0,0 @@
-#![cfg(feature = "rustls")]
-use actix_http::error::PayloadError;
-use actix_http::http::header::{self, HeaderName, HeaderValue};
-use actix_http::http::{Method, StatusCode, Version};
-use actix_http::{body, error, Error, HttpService, Request, Response};
-use actix_http_test::test_server;
-use actix_service::{fn_factory_with_config, fn_service};
-
-use bytes::{Bytes, BytesMut};
-use futures_util::future::{self, err, ok};
-use futures_util::stream::{once, Stream, StreamExt};
-use rust_tls::{
-    internal::pemfile::{certs, pkcs8_private_keys},
-    NoClientAuth, ServerConfig as RustlsServerConfig,
-};
-
-use std::fs::File;
-use std::io::{self, BufReader};
-
-async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
-{
-    let mut body = BytesMut::new();
-    while let Some(item) = stream.next().await {
-        body.extend_from_slice(&item?)
-    }
-    Ok(body)
-}
-
-fn ssl_acceptor() -> RustlsServerConfig {
-    // load ssl keys
-    let mut config = RustlsServerConfig::new(NoClientAuth::new());
-    let cert_file = &mut BufReader::new(File::open("../tests/cert.pem").unwrap());
-    let key_file = &mut BufReader::new(File::open("../tests/key.pem").unwrap());
-    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_rt::test]
-async fn test_h1() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h1(|_| future::ok::<_, Error>(Response::Ok().finish()))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| future::ok::<_, Error>(Response::Ok().finish()))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h1_1() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h1(|req: Request| {
-                assert!(req.peer_addr().is_some());
-                assert_eq!(req.version(), Version::HTTP_11);
-                future::ok::<_, Error>(Response::Ok().finish())
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_1() -> io::Result<()> {
-    let srv = test_server(move || {
-        HttpService::build()
-            .finish(|req: Request| {
-                assert!(req.peer_addr().is_some());
-                assert_eq!(req.version(), Version::HTTP_2);
-                future::ok::<_, Error>(Response::Ok().finish())
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_body1() -> io::Result<()> {
-    let data = "HELLOWORLD".to_owned().repeat(64 * 1024);
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|mut req: Request<_>| async move {
-                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send_body(data.clone()).await.unwrap();
-    assert!(response.status().is_success());
-
-    let body = srv.load_body(response).await.unwrap();
-    assert_eq!(&body, data.as_bytes());
-    Ok(())
-}
-
-#[actix_rt::test]
-async fn test_h2_content_length() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|req: Request| {
-                let indx: usize = req.uri().path()[1..].parse().unwrap();
-                let statuses = [
-                    StatusCode::NO_CONTENT,
-                    StatusCode::CONTINUE,
-                    StatusCode::SWITCHING_PROTOCOLS,
-                    StatusCode::PROCESSING,
-                    StatusCode::OK,
-                    StatusCode::NOT_FOUND,
-                ];
-                future::ok::<_, ()>(Response::new(statuses[indx]))
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let header = HeaderName::from_static("content-length");
-    let value = HeaderValue::from_static("0");
-    {
-        for i in 0..4 {
-            let req = srv
-                .request(Method::GET, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-
-            let req = srv
-                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-        }
-
-        for i in 4..6 {
-            let req = srv
-                .request(Method::GET, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), Some(&value));
-        }
-    }
-}
-
-#[actix_rt::test]
-async fn test_h2_headers() {
-    let data = STR.repeat(10);
-    let data2 = data.clone();
-
-    let mut srv = test_server(move || {
-        let data = data.clone();
-        HttpService::build().h2(move |_| {
-            let mut config = Response::Ok();
-            for idx in 0..90 {
-                config.header(
-                    format!("X-TEST-{}", idx).as_str(),
-                    "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
-                );
-            }
-            future::ok::<_, ()>(config.body(data.clone()))
-        })
-            .rustls(ssl_acceptor())
-    }).await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from(data2));
-}
-
-const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World";
-
-#[actix_rt::test]
-async fn test_h2_body2() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_head_empty() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(response.version(), Version::HTTP_2);
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h2_head_binary() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h2_head_binary2() {
-    let srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.shead("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-}
-
-#[actix_rt::test]
-async fn test_h2_body_length() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
-                )
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_body_chunked_explicit() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| {
-                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
-                        .header(header::TRANSFER_ENCODING, "chunked")
-                        .streaming(body),
-                )
-            })
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert!(!response.headers().contains_key(header::TRANSFER_ENCODING));
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-
-    // decode
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h2_response_http_error_handling() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(fn_factory_with_config(|_: ()| {
-                ok::<_, ()>(fn_service(|_| {
-                    let broken_header = Bytes::from_static(b"\0\0\0");
-                    ok::<_, ()>(
-                        Response::Ok()
-                            .header(http::header::CONTENT_TYPE, broken_header)
-                            .body(STR),
-                    )
-                }))
-            }))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
-}
-
-#[actix_rt::test]
-async fn test_h2_service_error() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h2(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"error"));
-}
-
-#[actix_rt::test]
-async fn test_h1_service_error() {
-    let mut srv = test_server(move || {
-        HttpService::build()
-            .h1(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
-            .rustls(ssl_acceptor())
-    })
-    .await;
-
-    let response = srv.sget("/").send().await.unwrap();
-    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"error"));
-}

actix-http/tests/test_server.rs

@@ -1,676 +0,0 @@
-use std::io::{Read, Write};
-use std::time::Duration;
-use std::{net, thread};
-
-use actix_http_test::test_server;
-use actix_rt::time::delay_for;
-use actix_service::fn_service;
-use bytes::Bytes;
-use futures_util::future::{self, err, ok, ready, FutureExt};
-use futures_util::stream::{once, StreamExt};
-use regex::Regex;
-
-use actix_http::httpmessage::HttpMessage;
-use actix_http::{
-    body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
-};
-
-#[actix_rt::test]
-async fn test_h1() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .keep_alive(KeepAlive::Disabled)
-            .client_timeout(1000)
-            .client_disconnect(1000)
-            .h1(|req: Request| {
-                assert!(req.peer_addr().is_some());
-                future::ok::<_, ()>(Response::Ok().finish())
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-}
-
-#[actix_rt::test]
-async fn test_h1_2() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .keep_alive(KeepAlive::Disabled)
-            .client_timeout(1000)
-            .client_disconnect(1000)
-            .finish(|req: Request| {
-                assert!(req.peer_addr().is_some());
-                assert_eq!(req.version(), http::Version::HTTP_11);
-                future::ok::<_, ()>(Response::Ok().finish())
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-}
-
-#[actix_rt::test]
-async fn test_expect_continue() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .expect(fn_service(|req: Request| {
-                if req.head().uri.query() == Some("yes=") {
-                    ok(req)
-                } else {
-                    err(error::ErrorPreconditionFailed("error"))
-                }
-            }))
-            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n"));
-}
-
-#[actix_rt::test]
-async fn test_expect_continue_h1() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .expect(fn_service(|req: Request| {
-                delay_for(Duration::from_millis(20)).then(move |_| {
-                    if req.head().uri.query() == Some("yes=") {
-                        ok(req)
-                    } else {
-                        err(error::ErrorPreconditionFailed("error"))
-                    }
-                })
-            }))
-            .h1(fn_service(|_| future::ok::<_, ()>(Response::Ok().finish())))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n"));
-}
-
-#[actix_rt::test]
-async fn test_chunked_payload() {
-    let chunk_sizes = vec![32768, 32, 32768];
-    let total_size: usize = chunk_sizes.iter().sum();
-
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(fn_service(|mut request: Request| {
-                request
-                    .take_payload()
-                    .map(|res| match res {
-                        Ok(pl) => pl,
-                        Err(e) => panic!(format!("Error reading payload: {}", e)),
-                    })
-                    .fold(0usize, |acc, chunk| ready(acc + chunk.len()))
-                    .map(|req_size| {
-                        Ok::<_, Error>(Response::Ok().body(format!("size={}", req_size)))
-                    })
-            }))
-            .tcp()
-    })
-    .await;
-
-    let returned_size = {
-        let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-        let _ = stream
-            .write_all(b"POST /test HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n");
-
-        for chunk_size in chunk_sizes.iter() {
-            let mut bytes = Vec::new();
-            let random_bytes: Vec<u8> =
-                (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
-
-            bytes.extend(format!("{:X}\r\n", chunk_size).as_bytes());
-            bytes.extend(&random_bytes[..]);
-            bytes.extend(b"\r\n");
-            let _ = stream.write_all(&bytes);
-        }
-
-        let _ = stream.write_all(b"0\r\n\r\n");
-        stream.shutdown(net::Shutdown::Write).unwrap();
-
-        let mut data = String::new();
-        let _ = stream.read_to_string(&mut data);
-
-        let re = Regex::new(r"size=(\d+)").unwrap();
-        let size: usize = match re.captures(&data) {
-            Some(caps) => caps.get(1).unwrap().as_str().parse().unwrap(),
-            None => panic!(format!("Failed to find size in HTTP Response: {}", data)),
-        };
-        size
-    };
-
-    assert_eq!(returned_size, total_size);
-}
-
-#[actix_rt::test]
-async fn test_slow_request() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .client_timeout(100)
-            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 408 Request Timeout"));
-}
-
-#[actix_rt::test]
-async fn test_http1_malformed_request() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP1.1\r\n");
-    let mut data = String::new();
-    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 400 Bad Request"));
-}
-
-#[actix_rt::test]
-async fn test_http1_keepalive() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");
-
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");
-}
-
-#[actix_rt::test]
-async fn test_http1_keepalive_timeout() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .keep_alive(1)
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");
-    thread::sleep(Duration::from_millis(1100));
-
-    let mut data = vec![0; 1024];
-    let res = stream.read(&mut data).unwrap();
-    assert_eq!(res, 0);
-}
-
-#[actix_rt::test]
-async fn test_http1_keepalive_close() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ =
-        stream.write_all(b"GET /test/tests/test HTTP/1.1\r\nconnection: close\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");
-
-    let mut data = vec![0; 1024];
-    let res = stream.read(&mut data).unwrap();
-    assert_eq!(res, 0);
-}
-
-#[actix_rt::test]
-async fn test_http10_keepalive_default_close() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.0\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.0 200 OK\r\n");
-
-    let mut data = vec![0; 1024];
-    let res = stream.read(&mut data).unwrap();
-    assert_eq!(res, 0);
-}
-
-#[actix_rt::test]
-async fn test_http10_keepalive() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream
-        .write_all(b"GET /test/tests/test HTTP/1.0\r\nconnection: keep-alive\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.0 200 OK\r\n");
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.0\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.0 200 OK\r\n");
-
-    let mut data = vec![0; 1024];
-    let res = stream.read(&mut data).unwrap();
-    assert_eq!(res, 0);
-}
-
-#[actix_rt::test]
-async fn test_http1_keepalive_disabled() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .keep_alive(KeepAlive::Disabled)
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
-            .tcp()
-    })
-    .await;
-
-    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
-    let mut data = vec![0; 1024];
-    let _ = stream.read(&mut data);
-    assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");
-
-    let mut data = vec![0; 1024];
-    let res = stream.read(&mut data).unwrap();
-    assert_eq!(res, 0);
-}
-
-#[actix_rt::test]
-async fn test_content_length() {
-    use actix_http::http::{
-        header::{HeaderName, HeaderValue},
-        StatusCode,
-    };
-
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|req: Request| {
-                let indx: usize = req.uri().path()[1..].parse().unwrap();
-                let statuses = [
-                    StatusCode::NO_CONTENT,
-                    StatusCode::CONTINUE,
-                    StatusCode::SWITCHING_PROTOCOLS,
-                    StatusCode::PROCESSING,
-                    StatusCode::OK,
-                    StatusCode::NOT_FOUND,
-                ];
-                future::ok::<_, ()>(Response::new(statuses[indx]))
-            })
-            .tcp()
-    })
-    .await;
-
-    let header = HeaderName::from_static("content-length");
-    let value = HeaderValue::from_static("0");
-
-    {
-        for i in 0..4 {
-            let req = srv.request(http::Method::GET, srv.url(&format!("/{}", i)));
-            let response = req.send().await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-
-            let req = srv.request(http::Method::HEAD, srv.url(&format!("/{}", i)));
-            let response = req.send().await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
-        }
-
-        for i in 4..6 {
-            let req = srv.request(http::Method::GET, srv.url(&format!("/{}", i)));
-            let response = req.send().await.unwrap();
-            assert_eq!(response.headers().get(&header), Some(&value));
-        }
-    }
-}
-
-#[actix_rt::test]
-async fn test_h1_headers() {
-    let data = STR.repeat(10);
-    let data2 = data.clone();
-
-    let mut srv = test_server(move || {
-        let data = data.clone();
-        HttpService::build().h1(move |_| {
-            let mut builder = Response::Ok();
-            for idx in 0..90 {
-                builder.header(
-                    format!("X-TEST-{}", idx).as_str(),
-                    "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
-                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
-                );
-            }
-            future::ok::<_, ()>(builder.body(data.clone()))
-        }).tcp()
-    }).await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from(data2));
-}
-
-const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World \
-                   Hello World Hello World Hello World Hello World Hello World";
-
-#[actix_rt::test]
-async fn test_h1_body() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h1_head_empty() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.head("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h1_head_binary() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.head("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert!(bytes.is_empty());
-}
-
-#[actix_rt::test]
-async fn test_h1_head_binary2() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.head("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    {
-        let len = response
-            .headers()
-            .get(http::header::CONTENT_LENGTH)
-            .unwrap();
-        assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
-    }
-}
-
-#[actix_rt::test]
-async fn test_h1_body_length() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
-                )
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h1_body_chunked_explicit() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| {
-                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
-                        .header(header::TRANSFER_ENCODING, "chunked")
-                        .streaming(body),
-                )
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(
-        response
-            .headers()
-            .get(header::TRANSFER_ENCODING)
-            .unwrap()
-            .to_str()
-            .unwrap(),
-        "chunked"
-    );
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-
-    // decode
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h1_body_chunked_implicit() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| {
-                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(Response::Ok().streaming(body))
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-    assert_eq!(
-        response
-            .headers()
-            .get(header::TRANSFER_ENCODING)
-            .unwrap()
-            .to_str()
-            .unwrap(),
-        "chunked"
-    );
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
-}
-
-#[actix_rt::test]
-async fn test_h1_response_http_error_handling() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(fn_service(|_| {
-                let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
-                    Response::Ok()
-                        .header(http::header::CONTENT_TYPE, broken_header)
-                        .body(STR),
-                )
-            }))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
-}
-
-#[actix_rt::test]
-async fn test_h1_service_error() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .h1(|_| future::err::<Response, Error>(error::ErrorBadRequest("error")))
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
-
-    // read response
-    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"error"));
-}
-
-#[actix_rt::test]
-async fn test_h1_on_connect() {
-    let srv = test_server(|| {
-        HttpService::build()
-            .on_connect(|_| 10usize)
-            .h1(|req: Request| {
-                assert!(req.extensions().contains::<usize>());
-                future::ok::<_, ()>(Response::Ok().finish())
-            })
-            .tcp()
-    })
-    .await;
-
-    let response = srv.get("/").send().await.unwrap();
-    assert!(response.status().is_success());
-}

actix-http/tests/test_ws.rs

@@ -1,196 +0,0 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::sync::{Arc, Mutex};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::{body, h1, ws, Error, HttpService, Request, Response};
-use actix_http_test::test_server;
-use actix_service::{fn_factory, Service};
-use actix_utils::dispatcher::Dispatcher;
-use bytes::Bytes;
-use futures_util::future;
-use futures_util::task::{Context, Poll};
-use futures_util::{SinkExt, StreamExt};
-
-struct WsService<T>(Arc<Mutex<(PhantomData<T>, Cell<bool>)>>);
-
-impl<T> WsService<T> {
-    fn new() -> Self {
-        WsService(Arc::new(Mutex::new((PhantomData, Cell::new(false)))))
-    }
-
-    fn set_polled(&mut self) {
-        *self.0.lock().unwrap().1.get_mut() = true;
-    }
-
-    fn was_polled(&self) -> bool {
-        self.0.lock().unwrap().1.get()
-    }
-}
-
-impl<T> Clone for WsService<T> {
-    fn clone(&self) -> Self {
-        WsService(self.0.clone())
-    }
-}
-
-impl<T> Service for WsService<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    type Request = (Request, Framed<T, h1::Codec>);
-    type Response = ();
-    type Error = Error;
-    type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>;
-
-    fn poll_ready(&mut self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.set_polled();
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, (req, mut framed): Self::Request) -> Self::Future {
-        let fut = async move {
-            let res = ws::handshake(req.head()).unwrap().message_body(());
-
-            framed
-                .send((res, body::BodySize::None).into())
-                .await
-                .unwrap();
-
-            Dispatcher::new(framed.replace_codec(ws::Codec::new()), service)
-                .await
-                .map_err(|_| panic!())
-        };
-
-        Box::pin(fut)
-    }
-}
-
-async fn service(msg: ws::Frame) -> Result<ws::Message, Error> {
-    let msg = match msg {
-        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
-        ws::Frame::Text(text) => {
-            ws::Message::Text(String::from_utf8_lossy(&text).to_string())
-        }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin),
-        ws::Frame::Continuation(item) => ws::Message::Continuation(item),
-        ws::Frame::Close(reason) => ws::Message::Close(reason),
-        _ => panic!(),
-    };
-    Ok(msg)
-}
-
-#[actix_rt::test]
-async fn test_simple() {
-    let ws_service = WsService::new();
-    let mut srv = test_server({
-        let ws_service = ws_service.clone();
-        move || {
-            let ws_service = ws_service.clone();
-            HttpService::build()
-                .upgrade(fn_factory(move || future::ok::<_, ()>(ws_service.clone())))
-                .finish(|_| future::ok::<_, ()>(Response::NotFound()))
-                .tcp()
-        }
-    })
-    .await;
-
-    // client service
-    let mut framed = srv.ws().await.unwrap();
-    framed
-        .send(ws::Message::Text("text".to_string()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
-    );
-
-    framed
-        .send(ws::Message::Binary("text".into()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(&b"text"[..]))
-    );
-
-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into(),
-        )))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::FirstText(Bytes::from_static(b"text")))
-    );
-
-    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into()
-        )))
-        .await
-        .is_err());
-    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstBinary(
-            "text".into()
-        )))
-        .await
-        .is_err());
-
-    framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Continue(Bytes::from_static(b"text")))
-    );
-
-    framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Last(Bytes::from_static(b"text")))
-    );
-
-    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
-        .await
-        .is_err());
-
-    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
-        .await
-        .is_err());
-
-    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
-        .await
-        .unwrap();
-
-    let (item, _framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
-    );
-
-    assert!(ws_service.was_polled());
-}