add x509 to stream extension (#844)

* Fix never-ending HTTP2 empty response #737

.appveyor.yml

@@ -0,0 +1,41 @@
+environment:
+  global:
+    PROJECT_NAME: actix-web
+  matrix:
+    # Stable channel
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: stable
+    # Nightly channel
+    - 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 clean
+  - 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,15 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: GitHub Discussions
-    url: https://github.com/actix/actix-web/discussions
-    about: Actix Web Q&A
-  - name: Gitter chat (actix-web)
-    url: https://gitter.im/actix/actix-web
-    about: Actix Web Q&A
-  - name: Gitter chat (actix)
-    url: https://gitter.im/actix/actix
-    about: Actix (actor framework) Q&A
-  - name: Actix Discord
-    url: https://discord.gg/NWpN5mmg3x
-    about: Actix developer discussion and community chat
-

.github/PULL_REQUEST_TEMPLATE.md

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

.github/workflows/bench.yml

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

.github/workflows/clippy-fmt.yml

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

.github/workflows/linux.yml

@@ -1,81 +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.46.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: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
-
-      - 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'
-        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'
-        uses: codecov/codecov-action@v1
-        with:
-          file: cobertura.xml
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.github/workflows/macos.yml

@@ -1,56 +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: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
-
-      - 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
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.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: nightly-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --workspace --all-features --no-deps
-
-      - name: Tweak HTML
-        run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
-
-      - name: Deploy to GitHub Pages
-        uses: JamesIves/github-pages-deploy-action@3.7.1
-        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          BRANCH: gh-pages
-          FOLDER: target/doc

.github/workflows/windows.yml

@@ -1,76 +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: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
-
-      - 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
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.gitignore

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

.travis.yml

@@ -0,0 +1,57 @@
+language: rust
+sudo: required
+dist: trusty
+
+cache:
+  cargo: true
+  apt: true
+
+matrix:
+  include:
+    - 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 -y openssl 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" != "nightly" ]]; then
+    cargo clean
+    cargo check --features rust-tls
+    cargo check --features ssl
+    cargo check --features tls
+    cargo test --features="ssl,tls,rust-tls,uds" -- --nocapture
+    fi
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
+    RUST_BACKTRACE=1 cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
+    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 "ssl,tls,rust-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

CODE_OF_CONDUCT.md

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

Cargo.toml

@@ -1,144 +1,139 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.2"
+version = "0.7.19"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
+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/"
+documentation = "https://actix.rs/api/actix-web/stable/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"
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+build = "build.rs"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies"]
+features = ["tls", "ssl", "rust-tls", "session", "brotli", "flate2-c"]
 
 [badges]
 travis-ci = { repository = "actix/actix-web", branch = "master" }
+appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
 codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
 
 [lib]
 name = "actix_web"
 path = "src/lib.rs"
 
-[workspace]
-members = [
-  ".",
-  "awc",
-  "actix-http",
-  "actix-files",
-  "actix-multipart",
-  "actix-web-actors",
-  "actix-web-codegen",
-  "actix-http-test",
-]
-
 [features]
-default = ["compress"]
+default = ["session", "brotli", "flate2-c", "cell"]
 
-# content-encoding support
-compress = ["actix-http/compress", "awc/compress"]
-
-# sessions feature
-secure-cookies = ["actix-http/secure-cookies"]
+# tls
+tls = ["native-tls", "tokio-tls", "actix-net/tls"]
 
 # openssl
-openssl = ["tls_openssl", "actix-tls/accept", "actix-tls/openssl", "awc/openssl"]
+ssl = ["openssl", "tokio-openssl", "actix-net/ssl"]
+
+# deprecated, use "ssl"
+alpn = ["openssl", "tokio-openssl", "actix-net/ssl"]
 
 # rustls
-rustls = ["tls_rustls", "actix-tls/accept", "actix-tls/rustls", "awc/rustls"]
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots", "actix-net/rust-tls"]
 
-[[example]]
-name = "basic"
-required-features = ["compress"]
+# unix sockets
+uds = ["tokio-uds"]
 
-[[example]]
-name = "uds"
-required-features = ["compress"]
+# sessions feature, session require "ring" crate and c compiler
+session = ["cookie/secure"]
 
-[[test]]
-name = "test_server"
-required-features = ["compress"]
+# brotli encoding, requires c compiler
+brotli = ["brotli2"]
 
-[[example]]
-name = "on_connect"
-required-features = []
+# miniz-sys backend for flate2 crate
+flate2-c = ["flate2/miniz-sys"]
 
-[[example]]
-name = "client"
-required-features = ["rustls"]
+# rust backend for flate2 crate
+flate2-rust = ["flate2/rust_backend"]
+
+cell = ["actix-net/cell"]
 
 [dependencies]
-actix-codec = "0.4.0-beta.1"
-actix-macros = "0.2.0"
-actix-router = "0.2.7"
-actix-rt = "2"
-actix-server = "2.0.0-beta.3"
-actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.2"
-actix-tls = { version = "3.0.0-beta.3", default-features = false, optional = true }
+actix = "0.7.9"
+actix-net = "0.2.6"
 
-actix-web-codegen = "0.4.0"
-actix-http = "3.0.0-beta.2"
-awc = { version = "3.0.0-beta.2", default-features = false }
-
-ahash = "0.7"
-bytes = "1"
-derive_more = "0.99.5"
-either = "1.5.3"
-encoding_rs = "0.8"
-futures-core = { version = "0.3.7", default-features = false }
-futures-util = { version = "0.3.7", default-features = false }
+v_htmlescape = "0.4"
+base64 = "0.10"
+bitflags = "1.0"
+failure = "^0.1.2"
+h2 = "0.1"
+http = "^0.1.14"
+httparse = "1.3"
 log = "0.4"
 mime = "0.3"
-socket2 = "0.3.16"
-pin-project = "1.0.0"
-regex = "1.4"
-serde = { version = "1.0", features = ["derive"] }
+mime_guess = "2.0.0-alpha"
+num_cpus = "1.0"
+percent-encoding = "1.0"
+rand = "0.6"
+regex = "1.0"
+serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.7"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-url = "2.1"
-tls_openssl = { package = "openssl", version = "0.10.9", optional = true }
-tls_rustls = { package = "rustls", version = "0.19.0", optional = true }
-smallvec = "1.6"
+sha1 = "0.6"
+smallvec = "0.6"
+time = "0.1"
+encoding = "0.2"
+language-tags = "0.2"
+lazy_static = "1.0"
+lazycell = "1.0.0"
+parking_lot = "0.7"
+serde_urlencoded = "^0.5.3"
+url = { version="1.7", features=["query_encoding"] }
+cookie = { version="0.11", features=["percent-encode"] }
+brotli2 = { version="^0.3.2", optional = true }
+flate2 = { version="^1.0.2", optional = true, default-features = false }
+
+# io
+mio = "^0.6.13"
+net2 = "0.2"
+bytes = "0.4"
+byteorder = "1.2"
+futures = "0.1"
+futures-cpupool = "0.1"
+slab = "0.4"
+tokio = "0.1"
+tokio-io = "0.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2.8"
+tokio-reactor = "0.1"
+tokio-current-thread = "0.1"
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+tokio-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.2", optional = true }
+
+#rustls
+rustls = { version = "0.14", optional = true }
+tokio-rustls = { version = "0.8", optional = true }
+webpki = { version = "0.18", optional = true }
+webpki-roots = { version = "0.15", optional = true }
+
+# unix sockets
+tokio-uds = { version="0.2", optional = true }
 
 [dev-dependencies]
-actix = { version = "0.11.0-beta.2", default-features = false }
-rand = "0.8"
-env_logger = "0.8"
+env_logger = "0.6"
 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 = "actix-http-test" }
-actix-web-actors = { path = "actix-web-actors" }
-actix-web-codegen = { path = "actix-web-codegen" }
-actix-multipart = { path = "actix-multipart" }
-actix-files = { path = "actix-files" }
-awc = { path = "awc" }
-
-[[bench]]
-name = "server"
-harness = false
-
-[[bench]]
-name = "service"
-harness = false
-
-[[bench]]
-name = "responder"
-harness = false

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,459 +1,3 @@
-## Unreleased
-
-* The default `NormalizePath` behavior now strips trailing slashes by default. This was
-  previously documented to be the case in v3 but the behavior now matches. The effect is that
-  routes defined with trailing slashes will become inaccessible when
-  using `NormalizePath::default()`.
-  
-  Before: `#[get("/test/")`  
-  After: `#[get("/test")`  
-
-  Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
-
-
-## 3.0.0
-
-* The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
-  simply a `T`. To access a `Data<T>` use `ServiceRequest::app_data::<Data<T>>()`.
-
-* Cookie handling has been offloaded to the `cookie` crate:
-  * `USERINFO_ENCODE_SET` is no longer exposed. Percent-encoding is still supported; check docs.
-  * Some types now require lifetime parameters.
-
-* The time crate was updated to `v0.2`, a major breaking change to the time crate, which affects
-  any `actix-web` method previously expecting a time v0.1 input.
-
-* Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
-  result in `SameSite=None` being sent with the response Set-Cookie header.
-  To create a cookie without a SameSite attribute, remove any calls setting same_site.
-
-* actix-http support for Actors messages was moved to actix-http crate and is enabled 
-  with feature `actors`
-
-* content_length function is removed from actix-http.
-  You can set Content-Length by normally setting the response body or calling no_chunking function. 
-
-* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
-  `u64` instead of a `usize`.
-
-* Code that was using `path.<index>` to access a `web::Path<(A, B, C)>`s elements now needs to use
-  destructuring or `.into_inner()`. For example:
-
-  ```rust
-  // Previously:
-  async fn some_route(path: web::Path<(String, String)>) -> String {
-    format!("Hello, {} {}", path.0, path.1)
-  }
-
-  // Now (this also worked before):
-  async fn some_route(path: web::Path<(String, String)>) -> String {
-    let (first_name, last_name) = path.into_inner();
-    format!("Hello, {} {}", first_name, last_name)
-  }
-  // Or (this wasn't previously supported):
-  async fn some_route(web::Path((first_name, last_name)): web::Path<(String, String)>) -> String {
-    format!("Hello, {} {}", first_name, last_name)
-  }
-  ```
-
-* `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
-  It will need `middleware::normalize::TrailingSlash` when being constructed with `NormalizePath::new(...)`,
-  or for an easier migration you can replace `wrap(middleware::NormalizePath)` with `wrap(middleware::NormalizePath::new(TrailingSlash::MergeOnly))`.
-
-* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
-
-* `HttpServer::maxconnrate` is renamed to the more expressive `HttpServer::max_connection_rate`.
-
-
-## 2.0.0
-
-* `HttpServer::start()` renamed to `HttpServer::run()`. It also possible to
-  `.await` on `run` method result, in that case it awaits server exit.
-
-* `App::register_data()` renamed to `App::app_data()` and accepts any type `T: 'static`.
-  Stored data is available via `HttpRequest::app_data()` method at runtime.
-
-* Extractor configuration must be registered with `App::app_data()` instead of `App::data()`
-
-* Sync handlers has been removed. `.to_async()` method has been renamed to `.to()`
-  replace `fn` with `async fn` to convert sync handler to async
-
-* `actix_http_test::TestServer` moved to `actix_web::test` module. To start
-  test server use `test::start()` or `test_start_with_config()` methods
-
-* `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
-  http response.
-
-* Feature `rust-tls` renamed to `rustls`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rust-tls"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rustls"] }
-    ```
-
-* Feature `ssl` renamed to `openssl`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["ssl"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["openssl"] }
-    ```
-* `Cors` builder now requires that you call `.finish()` to construct the middleware
-
-## 1.0.1
-
-* Cors middleware has been moved to `actix-cors` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::cors::Cors;
-  ```
-
-  use
-
-  ```rust
-  use actix_cors::Cors;
-  ```
-
-* Identity middleware has been moved to `actix-identity` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-  use
-
-  ```rust
-  use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-
-## 1.0.0
-
-* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
-
-  instead of
-
-  ```rust
-
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-
-  impl FromRequest for YourExtractor {
-     type Config = ExtractorConfig;
-     type Result = Result<YourExtractor, Error>;
-
-     fn from_request(req: &HttpRequest, cfg: &Self::Config) -> Self::Result {
-         println!("use the config: {:?}", cfg.config);
-         ...
-     }
-  }
-
-  App::new().resource("/route_with_config", |r| {
-     r.post().with_config(handler_fn, |cfg| {
-         cfg.0.config = "test".to_string();
-     })
-  })
-
-  ```
-
-  use the HttpRequest to get the configuration like any other `Data` with `req.app_data::<C>()` and set it with the `data()` method on the `resource`
-
-  ```rust
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-
-  impl FromRequest for YourExtractor {
-     type Error = Error;
-     type Future = Result<Self, Self::Error>;
-     type Config = ExtractorConfig;
-
-     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-         let cfg = req.app_data::<ExtractorConfig>();
-         println!("config data?: {:?}", cfg.unwrap().role);
-         ...
-     }
-  }
-
-  App::new().service(
-     resource("/route_with_config")
-         .data(ExtractorConfig {
-             config: "test".to_string(),
-         })
-         .route(post().to(handler_fn)),
-  )
-  ```
-
-* Resource registration. 1.0 version uses generalized resource
-  registration via `.service()` method.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's or Scope's `.service()` method. `.service()` method accepts
-  object that implements `HttpServiceFactory` trait. By default
-  actix-web provides `Resource` and `Scope` services.
-
-  ```rust
-    App.new().service(
-        web::resource("/welcome")
-            .route(web::get().to(welcome))
-            .route(web::post().to(post_handler))
-  ```
-
-* Scope registration.
-
-  instead of
-
-  ```rust
-      let app = App::new().scope("/{project_id}", |scope| {
-            scope
-                .resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
-      });
-  ```
-
-  use `.service()` for registration and `web::scope()` as scope object factory.
-
-  ```rust
-      let app = App::new().service(
-          web::scope("/{project_id}")
-              .service(web::resource("/path1").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path2").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path3").to(|| HttpResponse::MethodNotAllowed()))
-      );
-  ```
-
-* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.with(welcome))
-  ```
-
-  use `.to()` or `.to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* Passing arguments to handler with extractors, multiple arguments are allowed
-
-  instead of
-
-  ```rust
-  fn welcome((body, req): (Bytes, HttpRequest)) -> ... {
-    ...
-  }
-  ```
-
-  use multiple arguments
-
-  ```rust
-  fn welcome(body: Bytes, req: HttpRequest) -> ... {
-    ...
-  }
-  ```
-
-* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
-  Use `.to()` for handlers and `.to_async()` for async handlers. Handler function
-  must use extractors.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's `to()` or `to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* `HttpRequest` does not provide access to request's payload stream.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req
-       .payload()
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-       .responder()
-  }
-  ```
-
-  use `Payload` extractor
-
-  ```rust
-  fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
-     stream
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-  }
-  ```
-
-* `State` is now `Data`.  You register Data during the App initialization process
-  and then access it from handlers either using a Data extractor or using
-  HttpRequest's api.
-
-  instead of
-
-  ```rust
-    App.with_state(T)
-  ```
-
-  use App's `data` method
-
-  ```rust
-	App.new()
-       .data(T)
-  ```
-
-  and either use the Data extractor within your handler
-
-  ```rust
-    use actix_web::web::Data;
-
-	fn endpoint_handler(Data<T>)){
-      ...
-    }
-  ```
-
-  .. or access your Data element from the HttpRequest
-
-  ```rust
-	fn endpoint_handler(req: HttpRequest) {
-		let data: Option<Data<T>> = req.app_data::<T>();
-    }
-  ```
-
-
-* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
-
-  instead of
-
-  ```rust
-	use actix_web::AsyncResponder;
-
-    fn endpoint_handler(...) -> impl Future<Item=HttpResponse, Error=Error>{
-		...
-        .responder()
-	}
-  ```
-
-  .. simply omit AsyncResponder and the corresponding responder() finish method
-
-
-* Middleware
-
-  instead of
-
-  ```rust
-      let app = App::new()
-           .middleware(middleware::Logger::default())
-  ```
-
-  use `.wrap()` method
-
-  ```rust
-      let app = App::new()
-           .wrap(middleware::Logger::default())
-           .route("/index.html", web::get().to(index));
-  ```
-
-* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
-  method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Responder {
-     req.body()
-       .and_then(|body| {
-          ...
-       })
-  }
-  ```
-
-  use
-
-  ```rust
-  fn index(body: Bytes) -> Responder {
-     ...
-  }
-  ```
-
-* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
-
-* StaticFiles and NamedFile have been moved to a separate crate.
-
-  instead of `use actix_web::fs::StaticFile`
-
-  use `use actix_files::Files`
-
-  instead of `use actix_web::fs::Namedfile`
-
-  use `use actix_files::NamedFile`
-
-* Multipart has been moved to a separate crate.
-
-  instead of `use actix_web::multipart::Multipart`
-
-  use `use actix_multipart::Multipart`
-
-* Response compression is not enabled by default.
-  To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
-
-* Session middleware moved to actix-session crate
-
-* Actors support have been moved to `actix-web-actors` crate
-
-* Custom Error
-
-  Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
-
-  Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
-
-  ```rust
-  fn render_response(&self) -> HttpResponse {
-    self.error_response()
-  }
-  ```
-
 ## 0.7.15
 
 * The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
@@ -494,9 +38,9 @@
 
 * `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
@@ -522,8 +66,8 @@
   trait uses `&HttpRequest` instead of `&mut HttpRequest`.
 
 * Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
-
-    instead of
+    
+    instead of 
 
     ```rust
     fn index(query: Query<..>, info: Json<MyStruct) -> impl Responder {}
@@ -539,7 +83,7 @@
 
 * `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
 
-* Removed deprecated `HttpServer::threads()`, use
+* 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
@@ -548,7 +92,7 @@
 * `Route::with()` does not return `ExtractorConfig`, to configure
   extractor use `Route::with_config()`
 
-    instead of
+    instead of 
 
     ```rust
     fn main() {
@@ -559,11 +103,11 @@
          });
     }
     ```
-
-    use
-
+    
+    use 
+    
     ```rust
-
+  
     fn main() {
          let app = App::new().resource("/index.html", |r| {
              r.method(http::Method::GET)
@@ -593,12 +137,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,

Makefile

@@ -0,0 +1,14 @@
+.PHONY: default build test doc book clean
+
+CARGO_FLAGS := --features "$(FEATURES) alpn tls"
+
+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,110 +1,82 @@
-<div align="center">
-  <h1>Actix Web</h1>
-  <p>
-    <strong>Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust</strong>
-  </p>
-  <p>
+# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-[![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.2)](https://docs.rs/actix-web/4.0.0-beta.2)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.2/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.2)
-<br />
-[![build status](https://github.com/actix/actix-web/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-web/actions)
-[![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
-![downloads](https://img.shields.io/crates/d/actix-web.svg)
-[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
+Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 
-  </p>
-</div>
-
-## Features
-
-* Supports *HTTP/1.x* and *HTTP/2*
+* Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/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/)
 * 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.46+
+* SSL support with OpenSSL or `native-tls`
+* Middlewares ([Logger, Session, CORS, CSRF, etc](https://actix.rs/docs/middleware/))
+* 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)
+* Experimental [Async/Await](https://github.com/mehcode/actix-web-async-await) support.
 
-## 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://actix.rs/api/actix-web/stable/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.31 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-r16&hw=ph&test=plaintext)
 
 ## License
 
 This project is licensed under either of
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-  [http://www.apache.org/licenses/LICENSE-2.0])
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or
-  [http://opensource.org/licenses/MIT])
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-web repo is organized under the terms of the Contributor Covenant.
-The Actix team promises to intervene to uphold that code of conduct.
+Contribution to the actix-web crate is organized under the terms of the
+Contributor Covenant, the maintainer of actix-web, @fafhrd91, promises to
+intervene to uphold that code of conduct.

actix-files/CHANGES.md

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

actix-files/Cargo.toml

@@ -1,36 +0,0 @@
-[package]
-name = "actix-files"
-version = "0.6.0-beta.2"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static file serving for Actix Web"
-readme = "README.md"
-keywords = ["actix", "http", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.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 = "4.0.0-beta.2", default-features = false }
-actix-service = "2.0.0-beta.4"
-
-askama_escape = "0.10"
-bitflags = "1"
-bytes = "1"
-futures-core = { version = "0.3.7", default-features = false }
-futures-util = { version = "0.3.7", default-features = false }
-derive_more = "0.99.5"
-log = "0.4"
-mime = "0.3"
-mime_guess = "2.0.1"
-percent-encoding = "2.1"
-
-[dev-dependencies]
-actix-rt = "2"
-actix-web = "4.0.0-beta.2"

actix-files/LICENSE-APACHE

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

actix-files/LICENSE-MIT

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

actix-files/README.md

@@ -1,19 +0,0 @@
-# actix-files
-
-> Static file serving for Actix Web
-
-[![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.5.0)](https://docs.rs/actix-files/0.5.0)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![License](https://img.shields.io/crates/l/actix-files.svg)
-<br />
-[![dependency status](https://deps.rs/crate/actix-files/0.5.0/status.svg)](https://deps.rs/crate/actix-files/0.5.0)
-[![Download](https://img.shields.io/crates/d/actix-files.svg)](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 & Resources
-
-- [API Documentation](https://docs.rs/actix-files/)
-- [Example Project](https://github.com/actix/examples/tree/master/static_index)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum supported Rust version: 1.46 or later

actix-files/src/chunked.rs

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

actix-files/src/directory.rs

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

actix-files/src/encoding.rs

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

actix-files/src/error.rs

@@ -1,42 +0,0 @@
-use actix_web::{http::StatusCode, 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/files.rs

@@ -1,282 +0,0 @@
-use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
-
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
-use actix_web::{
-    dev::{
-        AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
-    },
-    error::Error,
-    guard::Guard,
-    http::header::DispositionType,
-    HttpRequest,
-};
-use futures_util::future::{ok, FutureExt, LocalBoxFuture};
-
-use crate::{
-    directory_listing, named, Directory, DirectoryRenderer, FilesService,
-    HttpNewService, MimeOverride,
-};
-
-/// Static files handling service.
-///
-/// `Files` service must be registered with `App::service()` method.
-///
-/// ```rust
-/// use actix_web::App;
-/// use actix_files::Files;
-///
-/// let app = App::new()
-///     .service(Files::new("/static", "."));
-/// ```
-pub struct Files {
-    path: String,
-    directory: PathBuf,
-    index: Option<String>,
-    show_index: bool,
-    redirect_to_slash: bool,
-    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
-    renderer: Rc<DirectoryRenderer>,
-    mime_override: Option<Rc<MimeOverride>>,
-    file_flags: named::Flags,
-    guards: Option<Rc<dyn Guard>>,
-    hidden_files: bool,
-}
-
-impl fmt::Debug for Files {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Files")
-    }
-}
-
-impl Clone for Files {
-    fn clone(&self) -> Self {
-        Self {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            default: self.default.clone(),
-            renderer: self.renderer.clone(),
-            file_flags: self.file_flags,
-            path: self.path.clone(),
-            mime_override: self.mime_override.clone(),
-            guards: self.guards.clone(),
-            hidden_files: self.hidden_files,
-        }
-    }
-}
-
-impl Files {
-    /// Create new `Files` instance for a specified base directory.
-    ///
-    /// # Argument Order
-    /// The first argument (`mount_path`) is the root URL at which the static files are served.
-    /// For example, `/assets` will serve files at `example.com/assets/...`.
-    ///
-    /// The second argument (`serve_from`) is the location on disk at which files are loaded.
-    /// This can be a relative path. For example, `./` would serve files from the current
-    /// working directory.
-    ///
-    /// # Implementation Notes
-    /// If the mount path is set as the root path `/`, services registered after this one will
-    /// be inaccessible. Register more specific handlers and services first.
-    ///
-    /// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
-    /// max number of threads equal to `512 * HttpServer::worker`. Real time thread count are
-    /// adjusted with work load. More threads would spawn when need and threads goes idle for a
-    /// period of time would be de-spawned.
-    pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
-        let orig_dir = serve_from.into();
-        let dir = match orig_dir.canonicalize() {
-            Ok(canon_dir) => canon_dir,
-            Err(_) => {
-                log::error!("Specified path is not a directory: {:?}", orig_dir);
-                PathBuf::new()
-            }
-        };
-
-        Files {
-            path: mount_path.to_owned(),
-            directory: dir,
-            index: None,
-            show_index: false,
-            redirect_to_slash: false,
-            default: Rc::new(RefCell::new(None)),
-            renderer: Rc::new(directory_listing),
-            mime_override: None,
-            file_flags: named::Flags::default(),
-            guards: None,
-            hidden_files: false,
-        }
-    }
-
-    /// Show files listing for directories.
-    ///
-    /// By default show files listing is disabled.
-    pub fn show_files_listing(mut self) -> Self {
-        self.show_index = true;
-        self
-    }
-
-    /// Redirects to a slash-ended path when browsing a directory.
-    ///
-    /// By default never redirect.
-    pub fn redirect_to_slash_directory(mut self) -> Self {
-        self.redirect_to_slash = true;
-        self
-    }
-
-    /// Set custom directory renderer
-    pub fn files_listing_renderer<F>(mut self, f: F) -> Self
-    where
-        for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
-            + 'static,
-    {
-        self.renderer = Rc::new(f);
-        self
-    }
-
-    /// Specifies mime override callback
-    pub fn mime_override<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&mime::Name<'_>) -> DispositionType + 'static,
-    {
-        self.mime_override = Some(Rc::new(f));
-        self
-    }
-
-    /// Set index file
-    ///
-    /// Shows specific index file for directory "/" instead of
-    /// showing files listing.
-    pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
-        self.index = Some(index.into());
-        self
-    }
-
-    /// Specifies whether to use ETag or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::ETAG, value);
-        self
-    }
-
-    /// Specifies whether to use Last-Modified or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::LAST_MD, value);
-        self
-    }
-
-    /// Specifies whether text responses should signal a UTF-8 encoding.
-    ///
-    /// Default is false (but will default to true in a future version).
-    #[inline]
-    pub fn prefer_utf8(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::PREFER_UTF8, value);
-        self
-    }
-
-    /// Specifies custom guards to use for directory listings and files.
-    ///
-    /// Default behaviour allows GET and HEAD.
-    #[inline]
-    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
-        self.guards = Some(Rc::new(guards));
-        self
-    }
-
-    /// Disable `Content-Disposition` header.
-    ///
-    /// By default Content-Disposition` header is enabled.
-    #[inline]
-    pub fn disable_content_disposition(mut self) -> Self {
-        self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Sets default handler which is used when no matched file could be found.
-    pub fn default_handler<F, U>(mut self, f: F) -> Self
-    where
-        F: IntoServiceFactory<U, ServiceRequest>,
-        U: ServiceFactory<
-                ServiceRequest,
-                Config = (),
-                Response = ServiceResponse,
-                Error = Error,
-            > + 'static,
-    {
-        // create and configure default resource
-        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
-            f.into_factory().map_init_err(|_| ()),
-        )))));
-
-        self
-    }
-
-    /// Enables serving hidden files and directories, allowing a leading dots in url fragments.
-    #[inline]
-    pub fn use_hidden_files(mut self) -> Self {
-        self.hidden_files = true;
-        self
-    }
-}
-
-impl HttpServiceFactory for Files {
-    fn register(self, config: &mut AppService) {
-        if self.default.borrow().is_none() {
-            *self.default.borrow_mut() = Some(config.default_service());
-        }
-
-        let rdef = if config.is_root() {
-            ResourceDef::root_prefix(&self.path)
-        } else {
-            ResourceDef::prefix(&self.path)
-        };
-
-        config.register_service(rdef, None, self, None)
-    }
-}
-
-impl ServiceFactory<ServiceRequest> for Files {
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Config = ();
-    type Service = FilesService;
-    type InitError = ();
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let mut srv = FilesService {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            default: None,
-            renderer: self.renderer.clone(),
-            mime_override: self.mime_override.clone(),
-            file_flags: self.file_flags,
-            guards: self.guards.clone(),
-            hidden_files: self.hidden_files,
-        };
-
-        if let Some(ref default) = *self.default.borrow() {
-            default
-                .new_service(())
-                .map(move |result| match result {
-                    Ok(default) => {
-                        srv.default = Some(default);
-                        Ok(srv)
-                    }
-                    Err(_) => Err(()),
-                })
-                .boxed_local()
-        } else {
-            ok(srv).boxed_local()
-        }
-    }
-}

actix-files/src/lib.rs

@@ -1,799 +0,0 @@
-//! Static file serving for Actix Web.
-//!
-//! Provides a non-blocking service for serving static files from disk.
-//!
-//! # Example
-//! ```rust
-//! use actix_web::App;
-//! use actix_files::Files;
-//!
-//! let app = App::new()
-//!     .service(Files::new("/static", ".").prefer_utf8(true));
-//! ```
-
-#![deny(rust_2018_idioms)]
-#![warn(missing_docs, missing_debug_implementations)]
-
-use actix_service::boxed::{BoxService, BoxServiceFactory};
-use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
-    error::Error,
-    http::header::DispositionType,
-};
-use mime_guess::from_ext;
-
-mod chunked;
-mod directory;
-mod encoding;
-mod error;
-mod files;
-mod named;
-mod path_buf;
-mod range;
-mod service;
-
-pub use crate::chunked::ChunkedReadFile;
-pub use crate::directory::Directory;
-pub use crate::files::Files;
-pub use crate::named::NamedFile;
-pub use crate::range::HttpRange;
-pub use crate::service::FilesService;
-
-use self::directory::{directory_listing, DirectoryRenderer};
-use self::error::FilesError;
-use self::path_buf::PathBufWrap;
-
-type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
-
-/// Return the MIME type associated with a filename extension (case-insensitive).
-/// If `ext` is empty or no associated type for the extension was found, returns
-/// the type `application/octet-stream`.
-#[inline]
-pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
-    from_ext(ext).first_or_octet_stream()
-}
-
-type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
-
-#[cfg(test)]
-mod tests {
-    use std::{
-        fs::{self, File},
-        ops::Add,
-        time::{Duration, SystemTime},
-    };
-
-    use actix_service::ServiceFactory;
-    use actix_web::{
-        guard,
-        http::{
-            header::{self, ContentDisposition, DispositionParam, DispositionType},
-            Method, StatusCode,
-        },
-        middleware::Compress,
-        test::{self, TestRequest},
-        web::{self, Bytes},
-        App, HttpResponse, Responder,
-    };
-    use futures_util::future::ok;
-
-    use super::*;
-
-    #[actix_rt::test]
-    async fn test_file_extension_to_mime() {
-        let m = file_extension_to_mime("");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-
-        let m = file_extension_to_mime("jpg");
-        assert_eq!(m, mime::IMAGE_JPEG);
-
-        let m = file_extension_to_mime("invalid extension!!");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-
-        let m = file_extension_to_mime("");
-        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_modified_since_without_if_none_match() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since =
-            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_MODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_modified_since_without_if_none_match_same() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = file.last_modified().unwrap();
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_MODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_modified_since_with_if_none_match() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since =
-            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_NONE_MATCH, "miss_etag"))
-            .insert_header((header::IF_MODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_ne!(resp.status(), StatusCode::NOT_MODIFIED);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_unmodified_since() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = file.last_modified().unwrap();
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_UNMODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_if_unmodified_since_failed() {
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let since = header::HttpDate::from(SystemTime::UNIX_EPOCH);
-
-        let req = TestRequest::default()
-            .insert_header((header::IF_UNMODIFIED_SINCE, since))
-            .to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::PRECONDITION_FAILED);
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_text() {
-        assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_disposition() {
-        assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-
-        let file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .disable_content_disposition();
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert!(resp.headers().get(header::CONTENT_DISPOSITION).is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_non_ascii_file_name() {
-        let mut file =
-            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml")
-                .unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"貨物.toml\"; filename*=UTF-8''%E8%B2%A8%E7%89%A9.toml"
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_set_content_type() {
-        let mut file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .set_content_type(mime::TEXT_XML);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/xml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_image() {
-        let mut file = NamedFile::open("tests/test.png").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "image/png"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"test.png\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_image_attachment() {
-        let cd = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Filename(String::from("test.png"))],
-        };
-        let mut file = NamedFile::open("tests/test.png")
-            .unwrap()
-            .set_content_disposition(cd);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "image/png"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "attachment; filename=\"test.png\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_binary() {
-        let mut file = NamedFile::open("tests/test.binary").unwrap();
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "application/octet-stream"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "attachment; filename=\"test.binary\""
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_status_code_text() {
-        let mut file = NamedFile::open("Cargo.toml")
-            .unwrap()
-            .set_status_code(StatusCode::NOT_FOUND);
-        {
-            file.file();
-            let _f: &File = &file;
-        }
-        {
-            let _f: &mut File = &mut file;
-        }
-
-        let req = TestRequest::default().to_http_request();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/x-toml"
-        );
-        assert_eq!(
-            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"Cargo.toml\""
-        );
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_mime_override() {
-        fn all_attachment(_: &mime::Name<'_>) -> DispositionType {
-            DispositionType::Attachment
-        }
-
-        let srv = test::init_service(
-            App::new().service(
-                Files::new("/", ".")
-                    .mime_override(all_attachment)
-                    .index_file("Cargo.toml"),
-            ),
-        )
-        .await;
-
-        let request = TestRequest::get().uri("/").to_request();
-        let response = test::call_service(&srv, request).await;
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let content_disposition = response
-            .headers()
-            .get(header::CONTENT_DISPOSITION)
-            .expect("To have CONTENT_DISPOSITION");
-        let content_disposition = content_disposition
-            .to_str()
-            .expect("Convert CONTENT_DISPOSITION to str");
-        assert_eq!(content_disposition, "attachment; filename=\"Cargo.toml\"");
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_ranges_status_code() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        // Valid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/Cargo.toml")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .to_request();
-        let response = test::call_service(&srv, request).await;
-        assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
-
-        // Invalid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/Cargo.toml")
-            .insert_header((header::RANGE, "bytes=1-0"))
-            .to_request();
-        let response = test::call_service(&srv, request).await;
-
-        assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_range_headers() {
-        let srv = test::start(|| App::new().service(Files::new("/", ".")));
-
-        // Valid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
-        assert_eq!(content_range.to_str().unwrap(), "bytes 10-20/100");
-
-        // Invalid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-5"))
-            .send()
-            .await
-            .unwrap();
-        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
-        assert_eq!(content_range.to_str().unwrap(), "bytes */100");
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_length_headers() {
-        let srv = test::start(|| App::new().service(Files::new("/", ".")));
-
-        // Valid range header
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=10-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "11");
-
-        // Valid range header, starting from 0
-        let response = srv
-            .get("/tests/test.binary")
-            .insert_header((header::RANGE, "bytes=0-20"))
-            .send()
-            .await
-            .unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "21");
-
-        // Without range header
-        let mut response = srv.get("/tests/test.binary").send().await.unwrap();
-        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
-        assert_eq!(content_length.to_str().unwrap(), "100");
-
-        // Should be no transfer-encoding
-        let transfer_encoding = response.headers().get(header::TRANSFER_ENCODING);
-        assert!(transfer_encoding.is_none());
-
-        // Check file contents
-        let bytes = response.body().await.unwrap();
-        let data = web::Bytes::from(fs::read("tests/test.binary").unwrap());
-        assert_eq!(bytes, data);
-    }
-
-    #[actix_rt::test]
-    async fn test_head_content_length_headers() {
-        let srv = test::start(|| App::new().service(Files::new("/", ".")));
-
-        let response = srv.head("/tests/test.binary").send().await.unwrap();
-
-        let content_length = response
-            .headers()
-            .get(header::CONTENT_LENGTH)
-            .unwrap()
-            .to_str()
-            .unwrap();
-
-        assert_eq!(content_length, "100");
-    }
-
-    #[actix_rt::test]
-    async fn test_static_files_with_spaces() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").index_file("Cargo.toml")),
-        )
-        .await;
-        let request = TestRequest::get()
-            .uri("/tests/test%20space.binary")
-            .to_request();
-        let response = test::call_service(&srv, request).await;
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let bytes = test::read_body(response).await;
-        let data = web::Bytes::from(fs::read("tests/test space.binary").unwrap());
-        assert_eq!(bytes, data);
-    }
-
-    #[actix_rt::test]
-    async fn test_files_not_allowed() {
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
-
-        let req = TestRequest::default()
-            .uri("/Cargo.toml")
-            .method(Method::POST)
-            .to_request();
-
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
-        let req = TestRequest::default()
-            .method(Method::PUT)
-            .uri("/Cargo.toml")
-            .to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-    }
-
-    #[actix_rt::test]
-    async fn test_files_guards() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").use_guards(guard::Post())),
-        )
-        .await;
-
-        let req = TestRequest::default()
-            .uri("/Cargo.toml")
-            .method(Method::POST)
-            .to_request();
-
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_encoding() {
-        let srv = test::init_service(App::new().wrap(Compress::default()).service(
-            web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
-                    .unwrap()
-                    .set_content_encoding(header::ContentEncoding::Identity)
-            }),
-        ))
-        .await;
-
-        let request = TestRequest::get()
-            .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
-            .to_request();
-        let res = test::call_service(&srv, request).await;
-        assert_eq!(res.status(), StatusCode::OK);
-        assert!(!res.headers().contains_key(header::CONTENT_ENCODING));
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_content_encoding_gzip() {
-        let srv = test::init_service(App::new().wrap(Compress::default()).service(
-            web::resource("/").to(|| async {
-                NamedFile::open("Cargo.toml")
-                    .unwrap()
-                    .set_content_encoding(header::ContentEncoding::Gzip)
-            }),
-        ))
-        .await;
-
-        let request = TestRequest::get()
-            .uri("/")
-            .insert_header((header::ACCEPT_ENCODING, "gzip"))
-            .to_request();
-        let res = test::call_service(&srv, request).await;
-        assert_eq!(res.status(), StatusCode::OK);
-        assert_eq!(
-            res.headers()
-                .get(header::CONTENT_ENCODING)
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            "gzip"
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_named_file_allowed_method() {
-        let req = TestRequest::default().method(Method::GET).to_http_request();
-        let file = NamedFile::open("Cargo.toml").unwrap();
-        let resp = file.respond_to(&req).await.unwrap();
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[actix_rt::test]
-    async fn test_static_files() {
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").show_files_listing()),
-        )
-        .await;
-        let req = TestRequest::with_uri("/missing").to_request();
-
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-        let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
-
-        let req = TestRequest::default().to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").show_files_listing()),
-        )
-        .await;
-        let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "text/html; charset=utf-8"
-        );
-
-        let bytes = test::read_body(resp).await;
-        assert!(format!("{:?}", bytes).contains("/tests/test.png"));
-    }
-
-    #[actix_rt::test]
-    async fn test_redirect_to_slash_directory() {
-        // should not redirect if no index
-        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").redirect_to_slash_directory()),
-        )
-        .await;
-        let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-        // should redirect if index present
-        let srv = test::init_service(
-            App::new().service(
-                Files::new("/", ".")
-                    .index_file("test.png")
-                    .redirect_to_slash_directory(),
-            ),
-        )
-        .await;
-        let req = TestRequest::with_uri("/tests").to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::FOUND);
-
-        // should not redirect if the path is wrong
-        let req = TestRequest::with_uri("/not_existing").to_request();
-        let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn test_static_files_bad_directory() {
-        let _st: Files = Files::new("/", "missing");
-        let _st: Files = Files::new("/", "Cargo.toml");
-    }
-
-    #[actix_rt::test]
-    async fn test_default_handler_file_missing() {
-        let st = Files::new("/", ".")
-            .default_handler(|req: ServiceRequest| {
-                ok(req.into_response(HttpResponse::Ok().body("default content")))
-            })
-            .new_service(())
-            .await
-            .unwrap();
-        let req = TestRequest::with_uri("/missing").to_srv_request();
-
-        let resp = test::call_service(&st, req).await;
-        assert_eq!(resp.status(), StatusCode::OK);
-        let bytes = test::read_body(resp).await;
-        assert_eq!(bytes, web::Bytes::from_static(b"default content"));
-    }
-
-    //     #[actix_rt::test]
-    //     async fn test_serve_index() {
-    //         let st = Files::new(".").index_file("test.binary");
-    //         let req = TestRequest::default().uri("/tests").finish();
-
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.headers()
-    //                 .get(header::CONTENT_TYPE)
-    //                 .expect("content type"),
-    //             "application/octet-stream"
-    //         );
-    //         assert_eq!(
-    //             resp.headers()
-    //                 .get(header::CONTENT_DISPOSITION)
-    //                 .expect("content disposition"),
-    //             "attachment; filename=\"test.binary\""
-    //         );
-
-    //         let req = TestRequest::default().uri("/tests/").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
-    //             "application/octet-stream"
-    //         );
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-    //             "attachment; filename=\"test.binary\""
-    //         );
-
-    //         // nonexistent index file
-    //         let req = TestRequest::default().uri("/tests/unknown").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-    //         let req = TestRequest::default().uri("/tests/unknown/").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    //     }
-
-    //     #[actix_rt::test]
-    //     async fn test_serve_index_nested() {
-    //         let st = Files::new(".").index_file("mod.rs");
-    //         let req = TestRequest::default().uri("/src/client").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
-    //             "text/x-rust"
-    //         );
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-    //             "inline; filename=\"mod.rs\""
-    //         );
-    //     }
-
-    #[actix_rt::test]
-    async fn integration_serve_index() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        let req = TestRequest::get().uri("/test").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-
-        let bytes = test::read_body(res).await;
-
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
-
-        let req = TestRequest::get().uri("/test/").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-
-        let bytes = test::read_body(res).await;
-        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
-        assert_eq!(bytes, data);
-
-        // nonexistent index file
-        let req = TestRequest::get().uri("/test/unknown").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-
-        let req = TestRequest::get().uri("/test/unknown/").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[actix_rt::test]
-    async fn integration_percent_encoded() {
-        let srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
-        )
-        .await;
-
-        let req = TestRequest::get().uri("/test/%43argo.toml").to_request();
-        let res = test::call_service(&srv, req).await;
-        assert_eq!(res.status(), StatusCode::OK);
-    }
-}

actix-files/src/named.rs

@@ -1,491 +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 actix_web::{
-    dev::{BodyEncoding, SizedStream},
-    http::{
-        header::{
-            self, Charset, ContentDisposition, DispositionParam, DispositionType,
-            ExtendedValue,
-        },
-        ContentEncoding, StatusCode,
-    },
-    HttpMessage, HttpRequest, HttpResponse, Responder,
-};
-use bitflags::bitflags;
-use mime_guess::from_path;
-
-use crate::ChunkedReadFile;
-use crate::{encoding::equiv_utf8_text, range::HttpRange};
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const ETAG =                0b0000_0001;
-        const LAST_MD =             0b0000_0010;
-        const CONTENT_DISPOSITION = 0b0000_0100;
-        const PREFER_UTF8 =         0b0000_1000;
-    }
-}
-
-impl Default for Flags {
-    fn default() -> Self {
-        Flags::from_bits_truncate(0b0000_0111)
-    }
-}
-
-/// A file with an associated name.
-#[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.
-    /// [`std::ffi::OsStr::to_string_lossy`]
-    #[inline]
-    pub fn set_content_disposition(mut self, cd: header::ContentDisposition) -> Self {
-        self.content_disposition = cd;
-        self.flags.insert(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Disable `Content-Disposition` header.
-    ///
-    /// By default Content-Disposition` header is enabled.
-    #[inline]
-    pub fn disable_content_disposition(mut self) -> Self {
-        self.flags.remove(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Set content encoding for serving this file
-    #[inline]
-    pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
-        self.encoding = Some(enc);
-        self
-    }
-
-    /// Specifies whether to use ETag or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.flags.set(Flags::ETAG, value);
-        self
-    }
-
-    /// Specifies whether to use Last-Modified or not.
-    ///
-    /// Default is true.
-    #[inline]
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.flags.set(Flags::LAST_MD, value);
-        self
-    }
-
-    /// Specifies whether text responses should signal a UTF-8 encoding.
-    ///
-    /// Default is false (but will default to true in a future version).
-    #[inline]
-    pub fn prefer_utf8(mut self, value: bool) -> Self {
-        self.flags.set(Flags::PREFER_UTF8, value);
-        self
-    }
-
-    pub(crate) fn etag(&self) -> Option<header::EntityTag> {
-        // This etag format is similar to Apache's.
-        self.modified.as_ref().map(|mtime| {
-            let ino = {
-                #[cfg(unix)]
-                {
-                    self.md.ino()
-                }
-                #[cfg(not(unix))]
-                {
-                    0
-                }
-            };
-
-            let dur = mtime
-                .duration_since(UNIX_EPOCH)
-                .expect("modification time must be after epoch");
-
-            header::EntityTag::strong(format!(
-                "{:x}:{:x}:{:x}:{:x}",
-                ino,
-                self.md.len(),
-                dur.as_secs(),
-                dur.subsec_nanos()
-            ))
-        })
-    }
-
-    pub(crate) fn last_modified(&self) -> Option<header::HttpDate> {
-        self.modified.map(|mtime| mtime.into())
-    }
-
-    /// Creates an `HttpResponse` with file as a streaming body.
-    pub fn into_response(self, req: &HttpRequest) -> HttpResponse {
-        if self.status_code != StatusCode::OK {
-            let mut res = HttpResponse::build(self.status_code);
-
-            if self.flags.contains(Flags::PREFER_UTF8) {
-                let ct = equiv_utf8_text(self.content_type.clone());
-                res.insert_header((header::CONTENT_TYPE, ct.to_string()));
-            } else {
-                res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
-            }
-
-            if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-                res.insert_header((
-                    header::CONTENT_DISPOSITION,
-                    self.content_disposition.to_string(),
-                ));
-            }
-
-            if let Some(current_encoding) = self.encoding {
-                res.encoding(current_encoding);
-            }
-
-            let reader = ChunkedReadFile::new(self.md.len(), 0, self.file);
-
-            return res.streaming(reader);
-        }
-
-        let etag = if self.flags.contains(Flags::ETAG) {
-            self.etag()
-        } else {
-            None
-        };
-
-        let last_modified = if self.flags.contains(Flags::LAST_MD) {
-            self.last_modified()
-        } else {
-            None
-        };
-
-        // check preconditions
-        let precondition_failed = if !any_match(etag.as_ref(), req) {
-            true
-        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
-            (last_modified, req.get_header())
-        {
-            let t1: SystemTime = m.clone().into();
-            let t2: SystemTime = since.clone().into();
-
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1.as_secs() > t2.as_secs(),
-                _ => 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.as_secs() <= t2.as_secs(),
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        let mut resp = HttpResponse::build(self.status_code);
-
-        if self.flags.contains(Flags::PREFER_UTF8) {
-            let ct = equiv_utf8_text(self.content_type.clone());
-            resp.insert_header((header::CONTENT_TYPE, ct.to_string()));
-        } else {
-            resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
-        }
-
-        if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-            resp.insert_header((
-                header::CONTENT_DISPOSITION,
-                self.content_disposition.to_string(),
-            ));
-        }
-
-        // default compressing
-        if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
-        }
-
-        if let Some(lm) = last_modified {
-            resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
-        }
-
-        if let Some(etag) = etag {
-            resp.insert_header((header::ETAG, etag.to_string()));
-        }
-
-        resp.insert_header((header::ACCEPT_RANGES, "bytes"));
-
-        let mut length = self.md.len();
-        let mut offset = 0;
-
-        // check for range header
-        if let Some(ranges) = req.headers().get(header::RANGE) {
-            if let Ok(ranges_header) = ranges.to_str() {
-                if let Ok(ranges) = HttpRange::parse(ranges_header, length) {
-                    length = ranges[0].length;
-                    offset = ranges[0].start;
-
-                    resp.encoding(ContentEncoding::Identity);
-                    resp.insert_header((
-                        header::CONTENT_RANGE,
-                        format!(
-                            "bytes {}-{}/{}",
-                            offset,
-                            offset + length - 1,
-                            self.md.len()
-                        ),
-                    ));
-                } else {
-                    resp.insert_header((
-                        header::CONTENT_RANGE,
-                        format!("bytes */{}", length),
-                    ));
-                    return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
-                };
-            } else {
-                return resp.status(StatusCode::BAD_REQUEST).finish();
-            };
-        };
-
-        if precondition_failed {
-            return resp.status(StatusCode::PRECONDITION_FAILED).finish();
-        } else if not_modified {
-            return resp.status(StatusCode::NOT_MODIFIED).finish();
-        }
-
-        let reader = ChunkedReadFile::new(length, offset, self.file);
-
-        if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
-        }
-
-        resp.body(SizedStream::new(length, reader))
-    }
-}
-
-impl Deref for NamedFile {
-    type Target = File;
-
-    fn deref(&self) -> &File {
-        &self.file
-    }
-}
-
-impl DerefMut for NamedFile {
-    fn deref_mut(&mut self) -> &mut File {
-        &mut self.file
-    }
-}
-
-/// Returns true if `req` has no `If-Match` header or one which matches `etag`.
-fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfMatch>() {
-        None | Some(header::IfMatch::Any) => true,
-
-        Some(header::IfMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.strong_eq(some_etag) {
-                        return true;
-                    }
-                }
-            }
-
-            false
-        }
-    }
-}
-
-/// Returns true if `req` doesn't have an `If-None-Match` header matching `req`.
-fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfNoneMatch>() {
-        Some(header::IfNoneMatch::Any) => false,
-
-        Some(header::IfNoneMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.weak_eq(some_etag) {
-                        return false;
-                    }
-                }
-            }
-
-            true
-        }
-
-        None => true,
-    }
-}
-
-impl Responder for NamedFile {
-    fn respond_to(self, req: &HttpRequest) -> HttpResponse {
-        self.into_response(req)
-    }
-}

actix-files/src/path_buf.rs

@@ -1,119 +0,0 @@
-use std::{
-    path::{Path, PathBuf},
-    str::FromStr,
-};
-
-use actix_web::{dev::Payload, FromRequest, HttpRequest};
-use futures_util::future::{ready, Ready};
-
-use crate::error::UriSegmentError;
-
-#[derive(Debug)]
-pub(crate) struct PathBufWrap(PathBuf);
-
-impl FromStr for PathBufWrap {
-    type Err = UriSegmentError;
-
-    fn from_str(path: &str) -> Result<Self, Self::Err> {
-        Self::parse_path(path, false)
-    }
-}
-
-impl PathBufWrap {
-    /// Parse a path, giving the choice of allowing hidden files to be considered valid segments.
-    pub fn parse_path(path: &str, hidden_files: bool) -> Result<Self, UriSegmentError> {
-        let mut buf = PathBuf::new();
-
-        for segment in path.split('/') {
-            if segment == ".." {
-                buf.pop();
-            } else if !hidden_files && segment.starts_with('.') {
-                return Err(UriSegmentError::BadStart('.'));
-            } else if segment.starts_with('*') {
-                return Err(UriSegmentError::BadStart('*'));
-            } else if segment.ends_with(':') {
-                return Err(UriSegmentError::BadEnd(':'));
-            } else if segment.ends_with('>') {
-                return Err(UriSegmentError::BadEnd('>'));
-            } else if segment.ends_with('<') {
-                return Err(UriSegmentError::BadEnd('<'));
-            } else if segment.is_empty() {
-                continue;
-            } else if cfg!(windows) && segment.contains('\\') {
-                return Err(UriSegmentError::BadChar('\\'));
-            } else {
-                buf.push(segment)
-            }
-        }
-
-        Ok(PathBufWrap(buf))
-    }
-}
-
-impl AsRef<Path> for PathBufWrap {
-    fn as_ref(&self) -> &Path {
-        self.0.as_ref()
-    }
-}
-
-impl FromRequest for PathBufWrap {
-    type Error = UriSegmentError;
-    type Future = Ready<Result<Self, Self::Error>>;
-    type Config = ();
-
-    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        ready(req.match_info().path().parse())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::iter::FromIterator;
-
-    use super::*;
-
-    #[test]
-    fn test_path_buf() {
-        assert_eq!(
-            PathBufWrap::from_str("/test/.tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('.'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/*tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('*'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt:").map(|t| t.0),
-            Err(UriSegmentError::BadEnd(':'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt<").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('<'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/test/tt>").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('>'))
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/seg1/seg2/").unwrap().0,
-            PathBuf::from_iter(vec!["seg1", "seg2"])
-        );
-        assert_eq!(
-            PathBufWrap::from_str("/seg1/../seg2/").unwrap().0,
-            PathBuf::from_iter(vec!["seg2"])
-        );
-    }
-
-    #[test]
-    fn test_parse_path() {
-        assert_eq!(
-            PathBufWrap::parse_path("/test/.tt", false).map(|t| t.0),
-            Err(UriSegmentError::BadStart('.'))
-        );
-
-        assert_eq!(
-            PathBufWrap::parse_path("/test/.tt", true).unwrap().0,
-            PathBuf::from_iter(vec!["test", ".tt"])
-        );
-    }
-}

actix-files/src/range.rs

@@ -1,381 +0,0 @@
-use derive_more::{Display, Error};
-
-/// HTTP Range header representation.
-#[derive(Debug, Clone, Copy)]
-pub struct HttpRange {
-    /// Start of range.
-    pub start: u64,
-
-    /// Length of range.
-    pub length: u64,
-}
-
-const PREFIX: &str = "bytes=";
-const PREFIX_LEN: usize = 6;
-
-#[derive(Debug, Clone, Display, Error)]
-#[display(fmt = "Parse HTTP Range failed")]
-pub struct ParseRangeErr(#[error(not(source))] ());
-
-impl HttpRange {
-    /// Parses Range HTTP header string as per RFC 2616.
-    ///
-    /// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
-    /// `size` is full size of response (file).
-    pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ParseRangeErr> {
-        if header.is_empty() {
-            return Ok(Vec::new());
-        }
-        if !header.starts_with(PREFIX) {
-            return Err(ParseRangeErr(()));
-        }
-
-        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(ParseRangeErr(()))?.trim();
-                let end_str = start_end_iter.next().ok_or(ParseRangeErr(()))?.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(|_| ParseRangeErr(()))?;
-
-                    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(|_| ParseRangeErr(()))?;
-
-                    if start < 0 {
-                        return Err(ParseRangeErr(()));
-                    }
-                    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(|_| ParseRangeErr(()))?;
-
-                        if start > end {
-                            return Err(ParseRangeErr(()));
-                        }
-
-                        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(ParseRangeErr(()));
-        }
-
-        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 {
-                    panic!(
-                        "parse({}, {}) returned error {:?}",
-                        header,
-                        size,
-                        res.unwrap_err()
-                    );
-                }
-            }
-
-            let got = res.unwrap();
-
-            if got.len() != expected.len() {
-                panic!(
-                    "len(parseRange({}, {})) = {}, want {}",
-                    header,
-                    size,
-                    got.len(),
-                    expected.len()
-                );
-            }
-
-            for i in 0..expected.len() {
-                if got[i].start != expected[i].start {
-                    panic!(
-                        "parseRange({}, {})[{}].start = {}, want {}",
-                        header, size, i, got[i].start, expected[i].start
-                    )
-                }
-                if got[i].length != expected[i].length {
-                    panic!(
-                        "parseRange({}, {})[{}].length = {}, want {}",
-                        header, size, i, got[i].length, expected[i].length
-                    )
-                }
-            }
-        }
-    }
-}

actix-files/src/service.rs

@@ -1,155 +0,0 @@
-use std::{fmt, io, path::PathBuf, rc::Rc, task::Poll};
-
-use actix_service::Service;
-use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
-    error::Error,
-    guard::Guard,
-    http::{header, Method},
-    HttpResponse,
-};
-use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
-
-use crate::{
-    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride,
-    NamedFile, PathBufWrap,
-};
-
-/// Assembled file serving service.
-pub struct FilesService {
-    pub(crate) directory: PathBuf,
-    pub(crate) index: Option<String>,
-    pub(crate) show_index: bool,
-    pub(crate) redirect_to_slash: bool,
-    pub(crate) default: Option<HttpService>,
-    pub(crate) renderer: Rc<DirectoryRenderer>,
-    pub(crate) mime_override: Option<Rc<MimeOverride>>,
-    pub(crate) file_flags: named::Flags,
-    pub(crate) guards: Option<Rc<dyn Guard>>,
-    pub(crate) hidden_files: bool,
-}
-
-type FilesServiceFuture = Either<
-    Ready<Result<ServiceResponse, Error>>,
-    LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
->;
-
-impl FilesService {
-    fn handle_err(&self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
-        log::debug!("Failed to handle {}: {}", req.path(), e);
-
-        if let Some(ref default) = self.default {
-            Either::Right(default.call(req))
-        } else {
-            Either::Left(ok(req.error_response(e)))
-        }
-    }
-}
-
-impl fmt::Debug for FilesService {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("FilesService")
-    }
-}
-
-impl Service<ServiceRequest> for FilesService {
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Future = FilesServiceFuture;
-
-    actix_service::always_ready!();
-
-    fn call(&self, req: ServiceRequest) -> Self::Future {
-        let is_method_valid = if let Some(guard) = &self.guards {
-            // execute user defined guards
-            (**guard).check(req.head())
-        } else {
-            // default behavior
-            matches!(*req.method(), Method::HEAD | Method::GET)
-        };
-
-        if !is_method_valid {
-            return Either::Left(ok(req.into_response(
-                actix_web::HttpResponse::MethodNotAllowed()
-                    .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
-                    .body("Request did not meet this resource's requirements."),
-            )));
-        }
-
-        let real_path =
-            match PathBufWrap::parse_path(req.match_info().path(), self.hidden_files) {
-                Ok(item) => item,
-                Err(e) => return Either::Left(ok(req.error_response(e))),
-            };
-
-        // full file path
-        let path = match self.directory.join(&real_path).canonicalize() {
-            Ok(path) => path,
-            Err(e) => return self.handle_err(e, req),
-        };
-
-        if path.is_dir() {
-            if let Some(ref redir_index) = self.index {
-                if self.redirect_to_slash && !req.path().ends_with('/') {
-                    let redirect_to = format!("{}/", req.path());
-
-                    return Either::Left(ok(req.into_response(
-                        HttpResponse::Found()
-                            .insert_header((header::LOCATION, redirect_to))
-                            .body("")
-                            .into_body(),
-                    )));
-                }
-
-                let path = path.join(redir_index);
-
-                match NamedFile::open(path) {
-                    Ok(mut named_file) => {
-                        if let Some(ref mime_override) = self.mime_override {
-                            let new_disposition =
-                                mime_override(&named_file.content_type.type_());
-                            named_file.content_disposition.disposition = new_disposition;
-                        }
-                        named_file.flags = self.file_flags;
-
-                        let (req, _) = req.into_parts();
-                        let res = named_file.into_response(&req);
-                        Either::Left(ok(ServiceResponse::new(req, res)))
-                    }
-                    Err(e) => self.handle_err(e, req),
-                }
-            } else if self.show_index {
-                let dir = Directory::new(self.directory.clone(), path);
-
-                let (req, _) = req.into_parts();
-                let x = (self.renderer)(&dir, &req);
-
-                match x {
-                    Ok(resp) => Either::Left(ok(resp)),
-                    Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
-                }
-            } else {
-                Either::Left(ok(ServiceResponse::from_err(
-                    FilesError::IsDirectory,
-                    req.into_parts().0,
-                )))
-            }
-        } else {
-            match NamedFile::open(path) {
-                Ok(mut named_file) => {
-                    if let Some(ref mime_override) = self.mime_override {
-                        let new_disposition =
-                            mime_override(&named_file.content_type.type_());
-                        named_file.content_disposition.disposition = new_disposition;
-                    }
-                    named_file.flags = self.file_flags;
-
-                    let (req, _) = req.into_parts();
-                    let res = named_file.into_response(&req);
-                    Either::Left(ok(ServiceResponse::new(req, res)))
-                }
-                Err(e) => self.handle_err(e, req),
-            }
-        }
-    }
-}

actix-files/tests/encoding.rs

@@ -1,39 +0,0 @@
-use actix_files::Files;
-use actix_web::{
-    http::{
-        header::{self, HeaderValue},
-        StatusCode,
-    },
-    test::{self, TestRequest},
-    App,
-};
-
-#[actix_rt::test]
-async fn test_utf8_file_contents() {
-    // use default ISO-8859-1 encoding
-    let srv = test::init_service(App::new().service(Files::new("/", "./tests"))).await;
-
-    let req = TestRequest::with_uri("/utf8.txt").to_request();
-    let res = test::call_service(&srv, req).await;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(
-        res.headers().get(header::CONTENT_TYPE),
-        Some(&HeaderValue::from_static("text/plain")),
-    );
-
-    // prefer UTF-8 encoding
-    let srv = test::init_service(
-        App::new().service(Files::new("/", "./tests").prefer_utf8(true)),
-    )
-    .await;
-
-    let req = TestRequest::with_uri("/utf8.txt").to_request();
-    let res = test::call_service(&srv, req).await;
-
-    assert_eq!(res.status(), StatusCode::OK);
-    assert_eq!(
-        res.headers().get(header::CONTENT_TYPE),
-        Some(&HeaderValue::from_static("text/plain; charset=utf-8")),
-    );
-}

actix-files/tests/utf8.txt

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

actix-http-test/CHANGES.md

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

actix-http-test/Cargo.toml

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

actix-http-test/LICENSE-APACHE

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

actix-http-test/LICENSE-MIT

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

actix-http-test/README.md

@@ -1,15 +0,0 @@
-# actix-http-test
-
-> Various helpers for Actix applications to use during testing.
-
-[![crates.io](https://img.shields.io/crates/v/actix-http-test?label=latest)](https://crates.io/crates/actix-http-test)
-[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=2.1.0)](https://docs.rs/actix-http-test/2.1.0)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-[![Dependency Status](https://deps.rs/crate/actix-http-test/2.1.0/status.svg)](https://deps.rs/crate/actix-http-test/2.1.0)
-[![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & Resources
-
-- [API Documentation](https://docs.rs/actix-http-test)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum Supported Rust Version (MSRV): 1.46.0

actix-http-test/src/lib.rs

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

actix-http/CHANGES.md

@@ -1,433 +0,0 @@
-# Changes
-
-## Unreleased - 2021-xx-xx
-
-
-## 3.0.0-beta.2 - 2021-02-19
-### Added
-* `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
-* `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
-* `ResponseBuilder::append_header` method which allows using typed headers. [#1869]
-* `TestRequest::insert_header` method which allows using typed headers. [#1869]
-* `ContentEncoding` implements all necessary header traits. [#1912]
-* `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
-* `HeaderMap::drain` as an efficient draining iterator. [#1964]
-* Implement `IntoIterator` for owned `HeaderMap`. [#1964]
-* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
-
-### Changed
-* `ResponseBuilder::content_type` now takes an `impl IntoHeaderValue` to support using typed
-  `mime` types. [#1894]
-* Renamed `IntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
-  `TryInto` trait. [#1894]
-* `Extensions::insert` returns Option of replaced item. [#1904]
-* Remove `HttpResponseBuilder::json2()`. [#1903]
-* Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#1903]
-* `client::error::ConnectError` Resolver variant contains `Box<dyn std::error::Error>` type. [#1905]
-* `client::ConnectorConfig` default timeout changed to 5 seconds. [#1905]
-* Simplify `BlockingError` type to a unit struct. It's now only triggered when blocking thread pool
-  is dead. [#1957]
-* `HeaderMap::len` now returns number of values instead of number of keys. [#1964]
-* `HeaderMap::insert` now returns iterator of removed values. [#1964]
-* `HeaderMap::remove` now returns iterator of removed values. [#1964]
-
-### Removed
-* `ResponseBuilder::set`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
-* `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
-* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
-* `actors` optional feature. [#1969]
-* `ResponseError` impl for `actix::MailboxError`. [#1969]
-
-### Documentation
-* Vastly improve docs and add examples for `HeaderMap`. [#1964]
-
-[#1869]: https://github.com/actix/actix-web/pull/1869
-[#1894]: https://github.com/actix/actix-web/pull/1894
-[#1903]: https://github.com/actix/actix-web/pull/1903
-[#1904]: https://github.com/actix/actix-web/pull/1904
-[#1905]: https://github.com/actix/actix-web/pull/1905
-[#1912]: https://github.com/actix/actix-web/pull/1912
-[#1957]: https://github.com/actix/actix-web/pull/1957
-[#1964]: https://github.com/actix/actix-web/pull/1964
-[#1969]: https://github.com/actix/actix-web/pull/1969
-
-
-## 3.0.0-beta.1 - 2021-01-07
-### Added
-* Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
-
-### Changed
-* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
-* Bumped `rand` to `0.8`.
-* Update `bytes` to `1.0`. [#1813]
-* Update `h2` to `0.3`. [#1813]
-* The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
-
-### Removed
-* Deprecated `on_connect` methods have been removed. Prefer the new
-  `on_connect_ext` technique. [#1857]
-* Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
-  due to deprecate of resolver actor. [#1813]
-* Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
-  due to the removal of this type from `tokio-openssl` crate. openssl handshake 
-  error would return as `ConnectError::SslError`. [#1813]
-* Remove `actix-threadpool` dependency. Use `actix_rt::task::spawn_blocking`.
-  Due to this change `actix_threadpool::BlockingError` type is moved into 
-  `actix_http::error` module. [#1878]
-
-[#1813]: https://github.com/actix/actix-web/pull/1813
-[#1857]: https://github.com/actix/actix-web/pull/1857
-[#1864]: https://github.com/actix/actix-web/pull/1864
-[#1878]: https://github.com/actix/actix-web/pull/1878
-
-
-## 2.2.0 - 2020-11-25
-### Added
-* HttpResponse builders for 1xx status codes. [#1768]
-* `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
-* `TryFrom<u16>` and `TryFrom<f32>` for `http::header::Quality`. [#1797]
-
-### Fixed
-* Started dropping `transfer-encoding: chunked` and `Content-Length` for 1XX and 204 responses. [#1767]
-
-### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
-
-[#1773]: https://github.com/actix/actix-web/pull/1773
-[#1767]: https://github.com/actix/actix-web/pull/1767
-[#1768]: https://github.com/actix/actix-web/pull/1768
-[#1793]: https://github.com/actix/actix-web/pull/1793
-[#1797]: https://github.com/actix/actix-web/pull/1797
-
-
-## 2.1.0 - 2020-10-30
-### Added
-* Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
-
-### Changed
-* Upgrade `base64` to `0.13`. [#1744]
-* Upgrade `pin-project` to `1.0`. [#1733]
-* Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
-
-[#1760]: https://github.com/actix/actix-web/pull/1760
-[#1754]: https://github.com/actix/actix-web/pull/1754
-[#1733]: https://github.com/actix/actix-web/pull/1733
-[#1744]: https://github.com/actix/actix-web/pull/1744
-
-
-## 2.0.0 - 2020-09-11
-* No significant changes from `2.0.0-beta.4`.
-
-
-## 2.0.0-beta.4 - 2020-09-09
-### Changed
-* Update actix-codec and actix-utils dependencies.
-* Update actix-connect and actix-tls dependencies.
-
-
-## 2.0.0-beta.3 - 2020-08-14
-### Fixed
-* Memory leak of `client::pool::ConnectorPoolSupport`. [#1626]
-
-[#1626]: https://github.com/actix/actix-web/pull/1626
-
-
-## 2.0.0-beta.2 - 2020-07-21
-### Fixed
-* Potential UB in h1 decoder using uninitialized memory. [#1614]
-
-### Changed
-* Fix illegal chunked encoding. [#1615]
-
-[#1614]: https://github.com/actix/actix-web/pull/1614
-[#1615]: https://github.com/actix/actix-web/pull/1615
-
-
-## 2.0.0-beta.1 - 2020-07-11
-### Changed
-* Migrate cookie handling to `cookie` crate. [#1558]
-* Update `sha-1` to 0.9. [#1586]
-* Fix leak in client pool. [#1580]
-* MSRV is now 1.41.1.
-
-[#1558]: https://github.com/actix/actix-web/pull/1558
-[#1586]: https://github.com/actix/actix-web/pull/1586
-[#1580]: https://github.com/actix/actix-web/pull/1580
-
-
-## 2.0.0-alpha.4 - 2020-05-21
-### Changed
-* Bump minimum supported Rust version to 1.40
-* content_length function is removed, and you can set Content-Length by calling
-  no_chunking function [#1439]
-* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
-  `u64` instead of a `usize`.
-* Update `base64` dependency to 0.12
-
-### Fixed
-* Support parsing of `SameSite=None` [#1503]
-
-[#1439]: https://github.com/actix/actix-web/pull/1439
-[#1503]: https://github.com/actix/actix-web/pull/1503
-
-
-## 2.0.0-alpha.3 - 2020-05-08
-### Fixed
-* Correct spelling of ConnectError::Unresolved [#1487]
-* Fix a mistake in the encoding of websocket continuation messages wherein
-  Item::FirstText and Item::FirstBinary are each encoded as the other.
-
-### Changed
-* Implement `std::error::Error` for our custom errors [#1422]
-* Remove `failure` support for `ResponseError` since that crate
-  will be deprecated in the near future.
-
-[#1422]: https://github.com/actix/actix-web/pull/1422
-[#1487]: https://github.com/actix/actix-web/pull/1487
-
-
-## 2.0.0-alpha.2 - 2020-03-07
-### Changed
-* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
-* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB
-  respectively to improve download speed for awc when downloading large objects. [#1394]
-* client::Connector accepts initial_window_size and initial_connection_window_size
-  HTTP2 configuration. [#1394]
-* client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
-
-[#1394]: https://github.com/actix/actix-web/pull/1394
-[#1395]: https://github.com/actix/actix-web/pull/1395
-
-
-## 2.0.0-alpha.1 - 2020-02-27
-### Changed
-* Update the `time` dependency to 0.2.7.
-* Moved actors messages support from actix crate, enabled with feature `actors`.
-* Breaking change: trait MessageBody requires Unpin and accepting `Pin<&mut Self>` instead of
-  `&mut self` in the poll_next().
-* MessageBody is not implemented for &'static [u8] anymore.
-
-### Fixed
-* Allow `SameSite=None` cookies to be sent in a response.
-
-
-## 1.0.1 - 2019-12-20
-### Fixed
-* Poll upgrade service's readiness from HTTP service handlers
-* Replace brotli with brotli2 #1224
-
-
-## 1.0.0 - 2019-12-13
-### Added
-* Add websockets continuation frame support
-
-### Changed
-* Replace `flate2-xxx` features with `compress`
-
-
-## 1.0.0-alpha.5 - 2019-12-09
-### Fixed
-* Check `Upgrade` service readiness before calling it
-* Fix buffer remaining capacity calculation
-
-### Changed
-* Websockets: Ping and Pong should have binary data #1049
-
-
-## 1.0.0-alpha.4 - 2019-12-08
-### Added
-* Add impl ResponseBuilder for Error
-
-### Changed
-* Use rust based brotli compression library
-
-## 1.0.0-alpha.3 - 2019-12-07
-### Changed
-* Migrate to tokio 0.2
-* Migrate to `std::future`
-
-
-## 0.2.11 - 2019-11-06
-### Added
-* Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-* Add an additional `filename*` param in the `Content-Disposition` header of
-  `actix_files::NamedFile` to be more compatible. (#1151)
-* Allow to use `std::convert::Infallible` as `actix_http::error::Error`
-
-### Fixed
-* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain;
-  charset=utf-8` header [#1118]
-
-[#1878]: https://github.com/actix/actix-web/pull/1878
-
-
-## 0.2.10 - 2019-09-11
-### Added
-* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
-  with `RequestHead`
-
-### Fixed
-* h2 will use error response #1080
-* on_connect result isn't added to request extensions for http2 requests #1009
-
-
-## 0.2.9 - 2019-08-13
-### Changed
-* Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
-* Update percent-encoding to 2.1
-* Update serde_urlencoded to 0.6.1
-
-### Fixed
-* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
-
-
-## 0.2.8 - 2019-08-01
-### Added
-* Add `rustls` support
-* Add `Clone` impl for `HeaderMap`
-
-### Fixed
-* awc client panic #1016
-* Invalid response with compression middleware enabled, but compression-related features
-  disabled #997
-
-
-## 0.2.7 - 2019-07-18
-### Added
-* Add support for downcasting response errors #986
-
-
-## 0.2.6 - 2019-07-17
-### Changed
-* Replace `ClonableService` with local copy
-* Upgrade `rand` dependency version to 0.7
-
-
-## 0.2.5 - 2019-06-28
-### Added
-* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
-
-### Changed
-* Use `encoding_rs` crate instead of unmaintained `encoding` crate
-* Add `Copy` and `Clone` impls for `ws::Codec`
-
-
-## 0.2.4 - 2019-06-16
-### Fixed
-* Do not compress NoContent (204) responses #918
-
-
-## 0.2.3 - 2019-06-02
-### Added
-* Debug impl for ResponseBuilder
-* From SizedStream and BodyStream for Body
-
-### Changed
-* SizedStream uses u64
-
-
-## 0.2.2 - 2019-05-29
-### Fixed
-* Parse incoming stream before closing stream on disconnect #868
-
-
-## 0.2.1 - 2019-05-25
-### Fixed
-* Handle socket read disconnect
-
-
-## 0.2.0 - 2019-05-12
-### Changed
-* Update actix-service to 0.4
-* Expect and upgrade services accept `ServerConfig` config.
-
-### Deleted
-* `OneRequest` service
-
-
-## 0.1.5 - 2019-05-04
-### Fixed
-* Clean up response extensions in response pool #817
-
-
-## 0.1.4 - 2019-04-24
-### Added
-* Allow to render h1 request headers in `Camel-Case`
-
-### Fixed
-* Read until eof for http/1.0 responses #771
-
-
-## 0.1.3 - 2019-04-23
-### Fixed
-* Fix http client pool management
-* Fix http client wait queue management #794
-
-
-## 0.1.2 - 2019-04-23
-### Fixed
-* Fix BorrowMutError panic in client connector #793
-
-
-## 0.1.1 - 2019-04-19
-### Changed
-* Cookie::max_age() accepts value in seconds
-* Cookie::max_age_time() accepts value in time::Duration
-* Allow to specify server address for client connector
-
-
-## 0.1.0 - 2019-04-16
-### Added
-* Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
-
-### Changed
-* `actix_http::encoding` always available
-* use trust-dns-resolver 0.11.0
-
-
-## 0.1.0-alpha.5 - 2019-04-12
-### Added
-* Allow to use custom service for upgrade requests
-* Added `h1::SendResponse` future.
-
-### Changed
-* MessageBody::length() renamed to MessageBody::size() for consistency
-* ws handshake verification functions take RequestHead instead of Request
-
-
-## 0.1.0-alpha.4 - 2019-04-08
-### Added
-* Allow to use custom `Expect` handler
-* Add minimal `std::error::Error` impl for `Error`
-
-### Changed
-* Export IntoHeaderValue
-* Render error and return as response body
-* Use thread pool for response body compression
-
-### Deleted
-* Removed PayloadBuffer
-
-
-## 0.1.0-alpha.3 - 2019-04-02
-### Added
-* Warn when an unsealed private cookie isn't valid UTF-8
-
-### Fixed
-* Rust 1.31.0 compatibility
-* Preallocate read buffer for h1 codec
-* Detect socket disconnection during protocol selection
-
-
-## 0.1.0-alpha.2 - 2019-03-29
-### Added
-* Added ws::Message::Nop, no-op websockets message
-
-### Changed
-* Do not use thread pool for decompression if chunk size is smaller than 2048.
-
-
-## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl

actix-http/Cargo.toml

@@ -1,107 +0,0 @@
-[package]
-name = "actix-http"
-version = "3.0.0-beta.2"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "HTTP primitives for the Actix ecosystem"
-readme = "README.md"
-keywords = ["actix", "http", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-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"]
-
-# rustls support
-rustls = ["actix-tls/rustls"]
-
-# enable compressison support
-compress = ["flate2", "brotli2"]
-
-# support for secure cookies
-secure-cookies = ["cookie/secure"]
-
-# trust-dns as client dns resolver
-trust-dns = ["trust-dns-resolver"]
-
-[dependencies]
-actix-service = "2.0.0-beta.4"
-actix-codec = "0.4.0-beta.1"
-actix-utils = "3.0.0-beta.2"
-actix-rt = "2"
-actix-tls = "3.0.0-beta.2"
-
-base64 = "0.13"
-bitflags = "1.2"
-bytes = "1"
-bytestring = "1"
-cookie = { version = "0.14.1", features = ["percent-encode"] }
-derive_more = "0.99.5"
-encoding_rs = "0.8"
-futures-channel = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
-ahash = "0.7"
-h2 = "0.3.0"
-http = "0.2.2"
-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 = "1.0.0"
-rand = "0.8"
-regex = "1.3"
-serde = "1.0"
-serde_json = "1.0"
-sha-1 = "0.9"
-smallvec = "1.6"
-slab = "0.4"
-serde_urlencoded = "0.7"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-
-# compression
-brotli2 = { version="0.3.2", optional = true }
-flate2 = { version = "1.0.13", optional = true }
-
-trust-dns-resolver = { version = "0.20.0", optional = true }
-
-[dev-dependencies]
-actix-server = "2.0.0-beta.3"
-actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
-actix-tls = { version = "3.0.0-beta.2", features = ["openssl"] }
-criterion = "0.3"
-env_logger = "0.8"
-serde_derive = "1.0"
-tls-openssl = { version = "0.10", package = "openssl" }
-tls-rustls = { version = "0.19", package = "rustls" }
-
-[[bench]]
-name = "write-camel-case"
-harness = false
-
-[[bench]]
-name = "status-line"
-harness = false
-
-[[bench]]
-name = "uninit-headers"
-harness = false

actix-http/LICENSE-APACHE

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

actix-http/LICENSE-MIT

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

actix-http/README.md

@@ -1,67 +0,0 @@
-# actix-http
-
-> HTTP primitives for the Actix ecosystem.
-
-[![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.2)](https://docs.rs/actix-http/3.0.0-beta.2)
-[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
-<br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.2/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.2)
-[![Download](https://img.shields.io/crates/d/actix-http.svg)](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)
-
-## Documentation & Resources
-
-- [API Documentation](https://docs.rs/actix-http)
-- [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Minimum Supported Rust Version (MSRV): 1.46.0
-
-## Example
-
-```rust
-use std::{env, io};
-
-use actix_http::{HttpService, Response};
-use actix_server::Server;
-use futures_util::future;
-use http::header::HeaderValue;
-use log::info;
-
-#[actix_rt::main]
-async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "hello_world=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("hello-world", "127.0.0.1:8080", || {
-            HttpService::build()
-                .client_timeout(1000)
-                .client_disconnect(1000)
-                .finish(|_req| {
-                    info!("{:?}", _req);
-                    let mut res = Response::Ok();
-                    res.header("x-head", HeaderValue::from_static("dummy value!"));
-                    future::ok::<_, ()>(res.body("Hello world!"))
-                })
-                .tcp()
-        })?
-        .run()
-        .await
-}
-```
-
-## License
-
-This project is licensed under either of
-
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
-
-at your option.
-
-## Code of Conduct
-
-Contribution to the actix-http crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-http, @fafhrd91, promises to
-intervene to uphold that code of conduct.

actix-http/benches/status-line.rs

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

actix-http/benches/uninit-headers.rs

@@ -1,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/benches/write-camel-case.rs

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

actix-http/examples/echo.rs

@@ -1,40 +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()
-                            .insert_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()
-        .insert_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,32 +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.insert_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,710 +0,0 @@
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, mem};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
-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(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) => Pin::new(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) => Pin::new(body).poll_next(cx),
-        }
-    }
-}
-
-/// 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.get_mut() {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
-            Body::Bytes(ref mut bin) => {
-                let len = bin.len();
-                if len == 0 {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
-                }
-            }
-            Body::Message(body) => Pin::new(&mut **body).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>> for Body
-where
-    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-    E: Into<Error> + 'static,
-{
-    fn from(s: BodyStream<S>) -> 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.
-pub struct BodyStream<S: Unpin> {
-    stream: S,
-}
-
-impl<S, E> BodyStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
-    E: Into<Error>,
-{
-    pub fn new(stream: S) -> Self {
-        BodyStream { stream }
-    }
-}
-
-impl<S, E> MessageBody for BodyStream<S>
-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(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        loop {
-            let stream = &mut self.as_mut().stream;
-            return Poll::Ready(match ready!(Pin::new(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.
-pub struct SizedStream<S: Unpin> {
-    size: u64,
-    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(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        loop {
-            let stream = &mut self.as_mut().stream;
-            return Poll::Ready(match ready!(Pin::new(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::request::Request;
-use crate::response::Response;
-use crate::service::HttpService;
-use crate::{ConnectCallback, Extensions};
-
-/// A HTTP service builder
-///
-/// This type can be used to construct an instance of [`HttpService`] through a
-/// builder-like pattern.
-pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
-    keep_alive: KeepAlive,
-    client_timeout: u64,
-    client_disconnect: u64,
-    secure: bool,
-    local_addr: Option<net::SocketAddr>,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<S>,
-}
-
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
-{
-    /// Create instance of `ServiceConfigBuilder`
-    pub fn new() -> Self {
-        HttpServiceBuilder {
-            keep_alive: KeepAlive::Timeout(5),
-            client_timeout: 5000,
-            client_disconnect: 0,
-            secure: false,
-            local_addr: None,
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect_ext: None,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::InitError: fmt::Debug,
-    <S::Service as Service<Request>>::Future: 'static,
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    <X::Service as Service<Request>>::Future: 'static,
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-    <U::Service as Service<(Request, Framed<T, Codec>)>>::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, Request>,
-        X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-        <X1::Service as Service<Request>>::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_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Provide service for custom `Connection: UPGRADE` support.
-    ///
-    /// If service is provided then normal requests handling get halted
-    /// and this service get called with original request and framed object.
-    pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
-    where
-        F: IntoServiceFactory<U1, (Request, Framed<T, Codec>)>,
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-        <U1::Service as Service<(Request, Framed<T, Codec>)>>::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_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Sets the callback to be run on connection establishment.
-    ///
-    /// Has mutable access to a data container that will be merged into request extensions.
-    /// This enables transport layer data (like client certificates) to be accessed in middleware
-    /// and handlers.
-    pub fn on_connect_ext<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&T, &mut Extensions) + 'static,
-    {
-        self.on_connect_ext = Some(Rc::new(f));
-        self
-    }
-
-    /// Finish service configuration and create a HTTP Service for HTTP/1 protocol.
-    pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
-    where
-        B: MessageBody,
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<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_ext(self.on_connect_ext)
-    }
-
-    /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
-    pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
-    where
-        B: MessageBody + 'static,
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::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_ext(self.on_connect_ext)
-    }
-
-    /// Finish service configuration and create `HttpService` instance.
-    pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
-    where
-        B: MessageBody + 'static,
-        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::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_ext(self.on_connect_ext)
-    }
-}

actix-http/src/client/config.rs

@@ -1,38 +0,0 @@
-use std::time::Duration;
-
-const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2MB
-const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1MB
-
-/// Connector configuration
-#[derive(Clone)]
-pub(crate) struct ConnectorConfig {
-    pub(crate) timeout: Duration,
-    pub(crate) 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(5),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Some(Duration::from_millis(3000)),
-            limit: 100,
-            conn_window_size: DEFAULT_H2_CONN_WINDOW,
-            stream_window_size: DEFAULT_H2_STREAM_WINDOW,
-        }
-    }
-}
-
-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,348 +0,0 @@
-use std::future::Future;
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, io, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
-use actix_rt::task::JoinHandle;
-use bytes::Bytes;
-use futures_core::future::LocalBoxFuture;
-use futures_util::future::{err, Either, FutureExt, 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(H2Connection),
-}
-
-// h2 connection has two parts: SendRequest and Connection.
-// Connection is spawned as async task on runtime and H2Connection would hold a handle for
-// this task. So it can wake up and quit the task when SendRequest is dropped.
-pub(crate) struct H2Connection {
-    handle: JoinHandle<()>,
-    sender: SendRequest<Bytes>,
-}
-
-impl H2Connection {
-    pub(crate) fn new<Io>(
-        sender: SendRequest<Bytes>,
-        connection: h2::client::Connection<Io>,
-    ) -> Self
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        let handle = actix_rt::spawn(async move {
-            let _ = connection.await;
-        });
-
-        Self { handle, sender }
-    }
-}
-
-// wake up waker when drop
-impl Drop for H2Connection {
-    fn drop(&mut self) {
-        self.handle.abort();
-    }
-}
-
-// only expose sender type to public.
-impl Deref for H2Connection {
-    type Target = SendRequest<Bytes>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.sender
-    }
-}
-
-impl DerefMut for H2Connection {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.sender
-    }
-}
-
-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 ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        match self.project() {
-            EitherIoProj::A(val) => val.poll_read(cx, buf),
-            EitherIoProj::B(val) => val.poll_read(cx, 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),
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::net;
-
-    use actix_rt::net::TcpStream;
-
-    use super::*;
-
-    #[actix_rt::test]
-    async fn test_h2_connection_drop() {
-        let addr = "127.0.0.1:0".parse::<net::SocketAddr>().unwrap();
-        let listener = net::TcpListener::bind(addr).unwrap();
-        let local = listener.local_addr().unwrap();
-
-        std::thread::spawn(move || while listener.accept().is_ok() {});
-
-        let tcp = TcpStream::connect(local).await.unwrap();
-        let (sender, connection) = h2::client::handshake(tcp).await.unwrap();
-        let conn = H2Connection::new(sender.clone(), connection);
-
-        assert!(sender.clone().ready().await.is_ok());
-        assert!(h2::client::SendRequest::clone(&*conn).ready().await.is_ok());
-
-        drop(conn);
-
-        match sender.ready().await {
-            Ok(_) => panic!("connection should be gone and can not be ready"),
-            Err(e) => assert!(e.is_io()),
-        };
-    }
-}

actix-http/src/client/connector.rs

@@ -1,612 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::time::Duration;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
-use actix_service::{apply_fn, Service, ServiceExt};
-use actix_tls::connect::{
-    new_connector, Connect as TcpConnect, Connection as TcpConnection, Resolver,
-};
-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_tls::connect::ssl::openssl::SslConnector as OpensslConnector;
-#[cfg(feature = "rustls")]
-use actix_tls::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,
-    _phantom: 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<
-                TcpConnect<Uri>,
-                Response = TcpConnection<Uri, TcpStream>,
-                Error = actix_tls::connect::ConnectError,
-            > + Clone,
-        TcpStream,
-    > {
-        Connector {
-            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
-            connector: new_connector(resolver::resolver()),
-            config: ConnectorConfig::default(),
-            _phantom: PhantomData,
-        }
-    }
-
-    // Build Ssl connector with openssl, based on supplied alpn protocols
-    #[cfg(feature = "openssl")]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        use actix_tls::connect::ssl::openssl::SslMethod;
-        use bytes::{BufMut, BytesMut};
-
-        let mut alpn = BytesMut::with_capacity(20);
-        for proto in protocols.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::connect::ssl::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<
-                TcpConnect<Uri>,
-                Response = TcpConnection<Uri, U1>,
-                Error = actix_tls::connect::ConnectError,
-            > + Clone,
-    {
-        Connector {
-            connector,
-            config: self.config,
-            ssl: self.ssl,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, U> Connector<T, U>
-where
-    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
-    T: Service<
-            TcpConnect<Uri>,
-            Response = TcpConnection<Uri, U>,
-            Error = actix_tls::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<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";
-            use actix_service::{boxed::service, pipeline};
-            #[cfg(feature = "openssl")]
-            use actix_tls::connect::ssl::openssl::OpensslConnector;
-            #[cfg(feature = "rustls")]
-            use actix_tls::connect::ssl::rustls::{RustlsConnector, Session};
-
-            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<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<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-            }
-        }
-    }
-
-    impl<T, Io> Service<Connect> for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-    {
-        type Response = IoConnection<Io>;
-        type Error = ConnectError;
-        type Future = Either<
-            <ConnectionPool<T, Io> as Service<Connect>>::Future,
-            Ready<Result<IoConnection<Io>, ConnectError>>,
-        >;
-
-        fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&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<Connect, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<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<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-        T2: Service<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<Connect> for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-    {
-        type Response = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-        type Future = Either<
-            InnerConnectorResponseA<T1, Io1, Io2>,
-            InnerConnectorResponseB<T2, Io1, Io2>,
-        >;
-
-        fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => Either::Right(InnerConnectorResponseB {
-                    fut: self.ssl_pool.call(req),
-                    _phantom: PhantomData,
-                }),
-                _ => Either::Left(InnerConnectorResponseA {
-                    fut: self.tcp_pool.call(req),
-                    _phantom: PhantomData,
-                }),
-            }
-        }
-    }
-
-    #[pin_project::pin_project]
-    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io1> as Service<Connect>>::Future,
-        _phantom: PhantomData<Io2>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
-    where
-        T: Service<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<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io2> as Service<Connect>>::Future,
-        _phantom: PhantomData<Io1>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
-    where
-        T: Service<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),
-            )
-        }
-    }
-}
-
-#[cfg(not(feature = "trust-dns"))]
-mod resolver {
-    use super::*;
-
-    pub(super) fn resolver() -> Resolver {
-        Resolver::Default
-    }
-}
-
-#[cfg(feature = "trust-dns")]
-mod resolver {
-    use std::{cell::RefCell, net::SocketAddr};
-
-    use actix_tls::connect::Resolve;
-    use futures_core::future::LocalBoxFuture;
-    use trust_dns_resolver::{
-        config::{ResolverConfig, ResolverOpts},
-        system_conf::read_system_conf,
-        TokioAsyncResolver,
-    };
-
-    use super::*;
-
-    pub(super) fn resolver() -> Resolver {
-        // new type for impl Resolve trait for TokioAsyncResolver.
-        struct TrustDnsResolver(TokioAsyncResolver);
-
-        impl Resolve for TrustDnsResolver {
-            fn lookup<'a>(
-                &'a self,
-                host: &'a str,
-                port: u16,
-            ) -> LocalBoxFuture<'a, Result<Vec<SocketAddr>, Box<dyn std::error::Error>>>
-            {
-                Box::pin(async move {
-                    let res = self
-                        .0
-                        .lookup_ip(host)
-                        .await?
-                        .iter()
-                        .map(|ip| SocketAddr::new(ip, port))
-                        .collect();
-                    Ok(res)
-                })
-            }
-        }
-
-        // dns struct is cached in thread local.
-        // so new client constructor can reuse the existing dns resolver.
-        thread_local! {
-            static TRUST_DNS_RESOLVER: RefCell<Option<Resolver>> = RefCell::new(None);
-        }
-
-        // get from thread local or construct a new trust-dns resolver.
-        TRUST_DNS_RESOLVER.with(|local| {
-            let resolver = local.borrow().as_ref().map(Clone::clone);
-            match resolver {
-                Some(resolver) => resolver,
-                None => {
-                    let (cfg, opts) = match read_system_conf() {
-                        Ok((cfg, opts)) => (cfg, opts),
-                        Err(e) => {
-                            log::error!("TRust-DNS can not load system config: {}", e);
-                            (ResolverConfig::default(), ResolverOpts::default())
-                        }
-                    };
-
-                    let resolver = TokioAsyncResolver::tokio(cfg, opts).unwrap();
-
-                    // box trust dns resolver and put it in thread local.
-                    let resolver = Resolver::new_custom(TrustDnsResolver(resolver));
-                    *local.borrow_mut() = Some(resolver.clone());
-                    resolver
-                }
-            }
-        })
-    }
-}

actix-http/src/client/error.rs

@@ -1,144 +0,0 @@
-use std::io;
-
-use derive_more::{Display, From};
-
-#[cfg(feature = "openssl")]
-use actix_tls::accept::openssl::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),
-
-    /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(Box<dyn std::error::Error>),
-
-    /// No dns records
-    #[display(fmt = "No dns records found for the input")]
-    NoRecords,
-
-    /// Http2 error
-    #[display(fmt = "{}", _0)]
-    H2(h2::Error),
-
-    /// Connecting took too long
-    #[display(fmt = "Timeout while establishing connection")]
-    Timeout,
-
-    /// Connector has been disconnected
-    #[display(fmt = "Internal error: connector has been disconnected")]
-    Disconnected,
-
-    /// Unresolved host name
-    #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolved,
-
-    /// Connection io error
-    #[display(fmt = "{}", _0)]
-    Io(io::Error),
-}
-
-impl std::error::Error for ConnectError {}
-
-impl From<actix_tls::connect::ConnectError> for ConnectError {
-    fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
-        match err {
-            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
-            actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
-            actix_tls::connect::ConnectError::InvalidInput => panic!(),
-            actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
-        }
-    }
-}
-
-#[derive(Debug, Display, From)]
-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,291 +0,0 @@
-use std::io::Write;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{io, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
-use bytes::buf::BufMut;
-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_value() {
-                Ok(value) => match head {
-                    RequestHeadType::Owned(ref mut head) => {
-                        head.headers.insert(HOST, value);
-                    }
-                    RequestHeadType::Rc(_, ref mut extra_headers) => {
-                        let headers = extra_headers.get_or_insert(HeaderMap::new());
-                        headers.insert(HOST, value);
-                    }
-                },
-                Err(e) => log::error!("Can not set HOST header {}", e),
-            }
-        }
-    }
-
-    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> {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        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,204 +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;
-use crate::client::connection::H2Connection;
-
-pub(crate) async fn send_request<T, B>(
-    mut io: H2Connection,
-    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: H2Connection,
-    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,645 +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, ReadBuf};
-use actix_rt::time::{sleep, Sleep};
-use actix_service::Service;
-use actix_utils::task::LocalWaker;
-use ahash::AHashMap;
-use bytes::Bytes;
-use futures_channel::oneshot;
-use futures_core::future::LocalBoxFuture;
-use futures_util::future::{poll_fn, FutureExt};
-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;
-use crate::client::connection::H2Connection;
-
-#[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<T>, Rc<RefCell<Inner<Io>>>);
-
-impl<T, Io> ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-{
-    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
-        let connector_rc = Rc::new(connector);
-        let inner_rc = Rc::new(RefCell::new(Inner {
-            config,
-            acquired: 0,
-            waiters: Slab::new(),
-            waiters_queue: IndexSet::new(),
-            available: AHashMap::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<Connect> for ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-{
-    type Response = IoConnection<Io>;
-    type Error = ConnectError;
-    type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.poll_ready(cx)
-    }
-
-    fn call(&self, req: Connect) -> Self::Future {
-        let 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 (sender, connection) = handshake(io, &config).await?;
-                        Ok(IoConnection::new(
-                            ConnectionType::H2(H2Connection::new(sender, connection)),
-                            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: AHashMap<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];
-                    let mut read_buf = ReadBuf::new(&mut buf);
-                    if let ConnectionType::H1(ref mut s) = io {
-                        match Pin::new(s).poll_read(cx, &mut read_buf) {
-                            Poll::Pending => {}
-                            Poll::Ready(Ok(())) if !read_buf.filled().is_empty() => {
-                                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();
-        }
-    }
-}
-
-#[pin_project::pin_project]
-struct CloseConnection<T> {
-    io: T,
-    #[pin]
-    timeout: Sleep,
-}
-
-impl<T> CloseConnection<T>
-where
-    T: AsyncWrite + Unpin,
-{
-    fn new(io: T, timeout: Duration) -> Self {
-        CloseConnection {
-            io,
-            timeout: sleep(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.project();
-
-        match this.timeout.poll(cx) {
-            Poll::Ready(_) => Poll::Ready(()),
-            Poll::Pending => match Pin::new(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: Rc<T>,
-    inner: Rc<RefCell<Inner<Io>>>,
-}
-
-impl<T, Io> Future for ConnectorPoolSupport<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<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((sender, connection))) => {
-                    let rx = this.rx.take().unwrap();
-                    let _ = rx.send(Ok(IoConnection::new(
-                        ConnectionType::H2(H2Connection::new(sender, connection)),
-                        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/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::{sleep, sleep_until, Instant, Sleep};
-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<Sleep> {
-        let delay_time = self.0.client_timeout;
-        if delay_time != 0 {
-            Some(sleep_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<Sleep> {
-        if let Some(ka) = self.0.keep_alive {
-            Some(sleep_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(sleep(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,220 +0,0 @@
-use std::future::Future;
-use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_rt::task::{spawn_blocking, JoinHandle};
-use brotli2::write::BrotliDecoder;
-use bytes::Bytes;
-use flate2::write::{GzDecoder, ZlibDecoder};
-use futures_core::{ready, Stream};
-
-use super::Writer;
-use crate::error::{BlockingError, 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<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
-}
-
-impl<S> Decoder<S>
-where
-    S: Stream<Item = Result<Bytes, PayloadError>>,
-{
-    /// Construct a decoder.
-    #[inline]
-    pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
-        let decoder = match encoding {
-            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) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-                self.decoder = Some(decoder);
-                self.fut.take();
-                if let Some(chunk) = chunk {
-                    return Poll::Ready(Some(Ok(chunk)));
-                }
-            }
-
-            if self.eof {
-                return Poll::Ready(None);
-            }
-
-            match 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(spawn_blocking(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,272 +0,0 @@
-//! Stream encoder
-use std::future::Future;
-use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_rt::task::{spawn_blocking, JoinHandle};
-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;
-use crate::error::BlockingError;
-
-const INPLACE: usize = 1024;
-
-#[pin_project]
-pub struct Encoder<B> {
-    eof: bool,
-    #[pin]
-    body: EncoderBody<B>,
-    encoder: Option<ContentEncoder>,
-    fut: Option<JoinHandle<Result<ContentEncoder, io::Error>>>,
-}
-
-impl<B: MessageBody> Encoder<B> {
-    pub fn response(
-        encoding: ContentEncoding,
-        head: &mut ResponseHead,
-        body: ResponseBody<B>,
-    ) -> ResponseBody<Encoder<B>> {
-        let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
-            || head.status == StatusCode::SWITCHING_PROTOCOLS
-            || head.status == StatusCode::NO_CONTENT
-            || encoding == ContentEncoding::Identity
-            || encoding == ContentEncoding::Auto);
-
-        let body = match body {
-            ResponseBody::Other(b) => match b {
-                Body::None => return ResponseBody::Other(Body::None),
-                Body::Empty => return ResponseBody::Other(Body::Empty),
-                Body::Bytes(buf) => {
-                    if can_encode {
-                        EncoderBody::Bytes(buf)
-                    } else {
-                        return ResponseBody::Other(Body::Bytes(buf));
-                    }
-                }
-                Body::Message(stream) => EncoderBody::BoxedStream(stream),
-            },
-            ResponseBody::Body(stream) => EncoderBody::Stream(stream),
-        };
-
-        if can_encode {
-            // Modify response body only if encoder is not None
-            if let Some(enc) = ContentEncoder::encoder(encoding) {
-                update_head(encoding, head);
-                head.no_chunking(false);
-                return ResponseBody::Body(Encoder {
-                    body,
-                    eof: false,
-                    fut: None,
-                    encoder: Some(enc),
-                });
-            }
-        }
-        ResponseBody::Body(Encoder {
-            body,
-            eof: false,
-            fut: None,
-            encoder: None,
-        })
-    }
-}
-
-#[pin_project(project = EncoderBodyProj)]
-enum EncoderBody<B> {
-    Bytes(Bytes),
-    Stream(#[pin] B),
-    BoxedStream(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 =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
-                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(spawn_blocking(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,305 +0,0 @@
-use std::{
-    any::{Any, TypeId},
-    fmt, mem,
-};
-
-use ahash::AHashMap;
-
-/// A type map for request extensions.
-///
-/// All entries into this map must be owned types (or static references).
-#[derive(Default)]
-pub struct Extensions {
-    /// Use FxHasher with a std HashMap with for faster
-    /// lookups on the small `TypeId` (u64 equivalent) keys.
-    map: AHashMap<TypeId, Box<dyn Any>>,
-}
-
-impl Extensions {
-    /// Creates an empty `Extensions`.
-    #[inline]
-    pub fn new() -> Extensions {
-        Extensions {
-            map: AHashMap::default(),
-        }
-    }
-
-    /// Insert an item into the map.
-    ///
-    /// If an item of this type was already stored, it will be replaced and returned.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// assert_eq!(map.insert(""), None);
-    /// assert_eq!(map.insert(1u32), None);
-    /// assert_eq!(map.insert(2u32), Some(1u32));
-    /// assert_eq!(*map.get::<u32>().unwrap(), 2u32);
-    /// ```
-    pub fn insert<T: 'static>(&mut self, val: T) -> Option<T> {
-        self.map
-            .insert(TypeId::of::<T>(), Box::new(val))
-            .and_then(downcast_owned)
-    }
-
-    /// Check if map contains an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// assert!(!map.contains::<u32>());
-    ///
-    /// assert_eq!(map.insert(1u32), None);
-    /// assert!(map.contains::<u32>());
-    /// ```
-    pub fn contains<T: 'static>(&self) -> bool {
-        self.map.contains_key(&TypeId::of::<T>())
-    }
-
-    /// Get a reference to an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// map.insert(1u32);
-    /// assert_eq!(map.get::<u32>(), Some(&1u32));
-    /// ```
-    pub fn get<T: 'static>(&self) -> Option<&T> {
-        self.map
-            .get(&TypeId::of::<T>())
-            .and_then(|boxed| boxed.downcast_ref())
-    }
-
-    /// Get a mutable reference to an item of a given type.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    /// map.insert(1u32);
-    /// assert_eq!(map.get_mut::<u32>(), Some(&mut 1u32));
-    /// ```
-    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
-        self.map
-            .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| boxed.downcast_mut())
-    }
-
-    /// Remove an item from the map of a given type.
-    ///
-    /// If an item of this type was already stored, it will be returned.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    ///
-    /// map.insert(1u32);
-    /// assert_eq!(map.get::<u32>(), Some(&1u32));
-    ///
-    /// assert_eq!(map.remove::<u32>(), Some(1u32));
-    /// assert!(!map.contains::<u32>());
-    /// ```
-    pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(downcast_owned)
-    }
-
-    /// Clear the `Extensions` of all inserted extensions.
-    ///
-    /// ```
-    /// # use actix_http::Extensions;
-    /// let mut map = Extensions::new();
-    ///
-    /// map.insert(1u32);
-    /// assert!(map.contains::<u32>());
-    ///
-    /// map.clear();
-    /// assert!(!map.contains::<u32>());
-    /// ```
-    #[inline]
-    pub fn clear(&mut self) {
-        self.map.clear();
-    }
-
-    /// Extends self with the items from another `Extensions`.
-    pub fn extend(&mut self, other: Extensions) {
-        self.map.extend(other.map);
-    }
-
-    /// Sets (or overrides) items from `other` into this map.
-    pub(crate) fn drain_from(&mut self, other: &mut Self) {
-        self.map.extend(mem::take(&mut other.map));
-    }
-}
-
-impl fmt::Debug for Extensions {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
-    }
-}
-
-fn downcast_owned<T: 'static>(boxed: Box<dyn Any>) -> Option<T> {
-    boxed.downcast().ok().map(|boxed| *boxed)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_remove() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(123);
-        assert!(map.get::<i8>().is_some());
-
-        map.remove::<i8>();
-        assert!(map.get::<i8>().is_none());
-    }
-
-    #[test]
-    fn test_clear() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
-
-        assert!(map.contains::<i8>());
-        assert!(map.contains::<i16>());
-        assert!(map.contains::<i32>());
-
-        map.clear();
-
-        assert!(!map.contains::<i8>());
-        assert!(!map.contains::<i16>());
-        assert!(!map.contains::<i32>());
-
-        map.insert::<i8>(10);
-        assert_eq!(*map.get::<i8>().unwrap(), 10);
-    }
-
-    #[test]
-    fn test_integers() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
-        map.insert::<i64>(64);
-        map.insert::<i128>(128);
-        map.insert::<u8>(8);
-        map.insert::<u16>(16);
-        map.insert::<u32>(32);
-        map.insert::<u64>(64);
-        map.insert::<u128>(128);
-        assert!(map.get::<i8>().is_some());
-        assert!(map.get::<i16>().is_some());
-        assert!(map.get::<i32>().is_some());
-        assert!(map.get::<i64>().is_some());
-        assert!(map.get::<i128>().is_some());
-        assert!(map.get::<u8>().is_some());
-        assert!(map.get::<u16>().is_some());
-        assert!(map.get::<u32>().is_some());
-        assert!(map.get::<u64>().is_some());
-        assert!(map.get::<u128>().is_some());
-    }
-
-    #[test]
-    fn test_composition() {
-        struct Magi<T>(pub T);
-
-        struct Madoka {
-            pub god: bool,
-        }
-
-        struct Homura {
-            pub attempts: usize,
-        }
-
-        struct Mami {
-            pub guns: usize,
-        }
-
-        let mut map = Extensions::new();
-
-        map.insert(Magi(Madoka { god: false }));
-        map.insert(Magi(Homura { attempts: 0 }));
-        map.insert(Magi(Mami { guns: 999 }));
-
-        assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
-        assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
-        assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
-    }
-
-    #[test]
-    fn test_extensions() {
-        #[derive(Debug, PartialEq)]
-        struct MyType(i32);
-
-        let mut extensions = Extensions::new();
-
-        extensions.insert(5i32);
-        extensions.insert(MyType(10));
-
-        assert_eq!(extensions.get(), Some(&5i32));
-        assert_eq!(extensions.get_mut(), Some(&mut 5i32));
-
-        assert_eq!(extensions.remove::<i32>(), Some(5i32));
-        assert!(extensions.get::<i32>().is_none());
-
-        assert_eq!(extensions.get::<bool>(), None);
-        assert_eq!(extensions.get(), Some(&MyType(10)));
-    }
-
-    #[test]
-    fn test_extend() {
-        #[derive(Debug, PartialEq)]
-        struct MyType(i32);
-
-        let mut extensions = Extensions::new();
-
-        extensions.insert(5i32);
-        extensions.insert(MyType(10));
-
-        let mut other = Extensions::new();
-
-        other.insert(15i32);
-        other.insert(20u8);
-
-        extensions.extend(other);
-
-        assert_eq!(extensions.get(), Some(&15i32));
-        assert_eq!(extensions.get_mut(), Some(&mut 15i32));
-
-        assert_eq!(extensions.remove::<i32>(), Some(15i32));
-        assert!(extensions.get::<i32>().is_none());
-
-        assert_eq!(extensions.get::<bool>(), None);
-        assert_eq!(extensions.get(), Some(&MyType(10)));
-
-        assert_eq!(extensions.get(), Some(&20u8));
-        assert_eq!(extensions.get_mut(), Some(&mut 20u8));
-    }
-
-    #[test]
-    fn test_drain_from() {
-        let mut ext = Extensions::new();
-        ext.insert(2isize);
-
-        let mut more_ext = Extensions::new();
-
-        more_ext.insert(5isize);
-        more_ext.insert(5usize);
-
-        assert_eq!(ext.get::<isize>(), Some(&2isize));
-        assert_eq!(ext.get::<usize>(), None);
-        assert_eq!(more_ext.get::<isize>(), Some(&5isize));
-        assert_eq!(more_ext.get::<usize>(), Some(&5usize));
-
-        ext.drain_from(&mut more_ext);
-
-        assert_eq!(ext.get::<isize>(), Some(&5isize));
-        assert_eq!(ext.get::<usize>(), Some(&5usize));
-        assert_eq!(more_ext.get::<isize>(), None);
-        assert_eq!(more_ext.get::<usize>(), None);
-    }
-}

actix-http/src/h1/client.rs

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

actix-http/src/h1/codec.rs

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

@@ -1,653 +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::Value, HeaderName};
-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,
-    _phantom: PhantomData<T>,
-}
-
-impl<T: MessageType> Default for MessageEncoder<T> {
-    fn default() -> Self {
-        MessageEncoder {
-            length: BodySize::None,
-            te: TransferEncoding::empty(),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-pub(crate) trait MessageType: Sized {
-    fn status(&self) -> Option<StatusCode>;
-
-    fn headers(&self) -> &HeaderMap;
-
-    fn extra_headers(&self) -> Option<&HeaderMap>;
-
-    fn camel_case(&self) -> bool {
-        false
-    }
-
-    fn chunked(&self) -> bool;
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
-
-    fn encode_headers(
-        &mut self,
-        dst: &mut BytesMut,
-        version: Version,
-        mut length: BodySize,
-        ctype: ConnectionType,
-        config: &ServiceConfig,
-    ) -> io::Result<()> {
-        let chunked = self.chunked();
-        let mut skip_len = length != BodySize::Stream;
-        let camel_case = self.camel_case();
-
-        // Content length
-        if let Some(status) = self.status() {
-            match status {
-                StatusCode::CONTINUE
-                | StatusCode::SWITCHING_PROTOCOLS
-                | StatusCode::PROCESSING
-                | StatusCode::NO_CONTENT => {
-                    // skip content-length and transfer-encoding headers
-                    // See https://tools.ietf.org/html/rfc7230#section-3.3.1
-                    // and https://tools.ietf.org/html/rfc7230#section-3.3.2
-                    skip_len = true;
-                    length = BodySize::None
-                }
-                _ => {}
-            }
-        }
-        match length {
-            BodySize::Stream => {
-                if chunked {
-                    if camel_case {
-                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
-                    } else {
-                        dst.put_slice(b"\r\ntransfer-encoding: chunked\r\n")
-                    }
-                } else {
-                    skip_len = false;
-                    dst.put_slice(b"\r\n");
-                }
-            }
-            BodySize::Empty => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
-                }
-            }
-            BodySize::Sized(len) => helpers::write_content_length(len, dst),
-            BodySize::None => dst.put_slice(b"\r\n"),
-        }
-
-        // Connection
-        match ctype {
-            ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
-            ConnectionType::KeepAlive if version < Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: keep-alive\r\n")
-                } else {
-                    dst.put_slice(b"connection: keep-alive\r\n")
-                }
-            }
-            ConnectionType::Close if version >= Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: close\r\n")
-                } else {
-                    dst.put_slice(b"connection: close\r\n")
-                }
-            }
-            _ => {}
-        }
-
-        // write headers
-
-        let mut has_date = false;
-
-        let mut buf = dst.chunk_mut().as_mut_ptr();
-        let mut remaining = dst.capacity() - dst.len();
-
-        // tracks bytes written since last buffer resize
-        // since buf is a raw pointer to a bytes container storage but is written to without the
-        // container's knowledge, this is used to sync the containers cursor after data is written
-        let mut pos = 0;
-
-        self.write_headers(|key, value| {
-            match *key {
-                CONNECTION => return,
-                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => return,
-                DATE => has_date = true,
-                _ => {}
-            }
-
-            let k = key.as_str().as_bytes();
-            let k_len = k.len();
-
-            // TODO: drain?
-            for val in value.iter() {
-                let v = val.as_ref();
-                let v_len = v.len();
-
-                // key length + value length + colon + space + \r\n
-                let len = k_len + v_len + 4;
-
-                if len > remaining {
-                    // SAFETY: all the bytes written up to position "pos" are initialized
-                    // the written byte count and pointer advancement are kept in sync
-                    unsafe {
-                        dst.advance_mut(pos);
-                    }
-
-                    pos = 0;
-                    dst.reserve(len * 2);
-                    remaining = dst.capacity() - dst.len();
-
-                    // re-assign buf raw pointer since it's possible that the buffer was
-                    // reallocated and/or resized
-                    buf = dst.chunk_mut().as_mut_ptr();
-                }
-
-                // SAFETY: on each write, it is enough to ensure that the advancement of
-                // the cursor matches the number of bytes written
-                unsafe {
-                    if camel_case {
-                        // use Camel-Case headers
-                        write_camel_case(k, from_raw_parts_mut(buf, k_len));
-                    } else {
-                        write_data(k, buf, k_len);
-                    }
-
-                    buf = buf.add(k_len);
-
-                    write_data(b": ", buf, 2);
-                    buf = buf.add(2);
-
-                    write_data(v, buf, v_len);
-                    buf = buf.add(v_len);
-
-                    write_data(b"\r\n", buf, 2);
-                    buf = buf.add(2);
-                };
-
-                pos += len;
-                remaining -= len;
-            }
-        });
-
-        // final cursor synchronization with the bytes container
-        //
-        // SAFETY: all the bytes written up to position "pos" are initialized
-        // the written byte count and pointer advancement are kept in sync
-        unsafe {
-            dst.advance_mut(pos);
-        }
-
-        // optimized date header, set_date writes \r\n
-        if !has_date {
-            config.set_date(dst);
-        } else {
-            // msg eof
-            dst.extend_from_slice(b"\r\n");
-        }
-
-        Ok(())
-    }
-
-    fn write_headers<F>(&mut self, mut f: F)
-    where
-        F: FnMut(&HeaderName, &Value),
-    {
-        match self.extra_headers() {
-            Some(headers) => {
-                // merging headers from head and extra headers.
-                self.headers()
-                    .inner
-                    .iter()
-                    .filter(|(name, _)| !headers.contains_key(*name))
-                    .chain(headers.inner.iter())
-                    .for_each(|(k, v)| f(k, v))
-            }
-            None => self.headers().inner.iter().for_each(|(k, v)| f(k, v)),
-        }
-    }
-}
-
-impl MessageType for Response<()> {
-    fn status(&self) -> Option<StatusCode> {
-        Some(self.head().status)
-    }
-
-    fn chunked(&self) -> bool {
-        self.head().chunked()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        None
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.head();
-        let reason = head.reason().as_bytes();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE + reason.len());
-
-        // status line
-        helpers::write_status_line(head.version, head.status.as_u16(), dst);
-        dst.put_slice(reason);
-        Ok(())
-    }
-}
-
-impl MessageType for RequestHeadType {
-    fn status(&self) -> Option<StatusCode> {
-        None
-    }
-
-    fn chunked(&self) -> bool {
-        self.as_ref().chunked()
-    }
-
-    fn camel_case(&self) -> bool {
-        self.as_ref().camel_case_headers()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        self.as_ref().headers()
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        self.extra_headers()
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.as_ref();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
-        write!(
-            helpers::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!(helpers::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(())
-            }
-        }
-    }
-}
-
-/// # Safety
-/// Callers must ensure that the given length matches given value length.
-unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
-    debug_assert_eq!(value.len(), len);
-    copy_nonoverlapping(value.as_ptr(), buf, len);
-}
-
-fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
-    // first copy entire (potentially wrong) slice to output
-    buffer[..value.len()].copy_from_slice(value);
-
-    let mut iter = value.iter();
-
-    // first character should be uppercase
-    if let Some(c @ b'a'..=b'z') = iter.next() {
-        buffer[0] = c & 0b1101_1111;
-    }
-
-    // track 1 ahead of the current position since that's the location being assigned to
-    let mut index = 2;
-
-    // remaining characters after hyphens should also be uppercase
-    while let Some(&c) = iter.next() {
-        if c == b'-' {
-            // advance iter by one and uppercase if needed
-            if let Some(c @ b'a'..=b'z') = iter.next() {
-                buffer[index] = c & 0b1101_1111;
-            }
-        }
-
-        index += 1;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::rc::Rc;
-
-    use bytes::Bytes;
-    use http::header::AUTHORIZATION;
-
-    use super::*;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-    use crate::RequestHead;
-
-    #[test]
-    fn test_chunked_te() {
-        let mut bytes = BytesMut::new();
-        let mut enc = TransferEncoding::chunked();
-        {
-            assert!(!enc.encode(b"test", &mut bytes).ok().unwrap());
-            assert!(enc.encode(b"", &mut bytes).ok().unwrap());
-        }
-        assert_eq!(
-            bytes.split().freeze(),
-            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
-        );
-    }
-
-    #[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();
-        eprintln!("{}", &data);
-
-        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"));
-    }
-
-    #[test]
-    fn test_no_content_length() {
-        let mut bytes = BytesMut::with_capacity(2048);
-
-        let mut res: Response<()> =
-            Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
-        res.headers_mut()
-            .insert(DATE, HeaderValue::from_static(&""));
-        res.headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static(&"0"));
-
-        let _ = res.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::Upgrade,
-            &ServiceConfig::default(),
-        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        assert!(!data.contains("content-length: 0\r\n"));
-        assert!(!data.contains("transfer-encoding: chunked\r\n"));
-    }
-}

actix-http/src/h1/expect.rs

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

actix-http/src/h1/mod.rs

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

actix-http/src/h1/payload.rs

@@ -1,242 +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;
-        self.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,475 +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::ready;
-
-use crate::body::MessageBody;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::{ConnectCallback, OnConnectData};
-
-use super::codec::Codec;
-use super::dispatcher::Dispatcher;
-use super::{ExpectHandler, UpgradeHandler};
-
-/// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B> H1Service<T, S, B>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        H1Service {
-            cfg,
-            srv: service.into_factory(),
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect_ext: None,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-{
-    /// Create simple tcp stream service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        TcpStream,
-        Config = (),
-        Response = (),
-        Error = DispatchError,
-        InitError = (),
-    > {
-        pipeline_factory(|io: TcpStream| {
-            let peer_addr = io.peer_addr().ok();
-            ready(Ok((io, peer_addr)))
-        })
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use super::*;
-
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
-    use actix_tls::accept::TlsError;
-
-    impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Request, Config = (), Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            (Request, Framed<SslStream<TcpStream>, Codec>),
-            Config = (),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create openssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            Response = (),
-            Error = TlsError<SslError, 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();
-                ready(Ok((io, peer_addr)))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::accept::TlsError;
-    use std::{fmt, io};
-
-    impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Request, Config = (), Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            (Request, Framed<TlsStream<TcpStream>, Codec>),
-            Config = (),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create rustls based service
-        pub fn rustls(
-            self,
-            config: ServerConfig,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            Response = (),
-            Error = TlsError<io::Error, DispatchError>,
-            InitError = (),
-        > {
-            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();
-                ready(Ok((io, peer_addr)))
-            })
-            .and_then(self.map_err(TlsError::Service))
-        }
-    }
-}
-
-impl<T, S, B, X, U> H1Service<T, S, B, X, U>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-{
-    pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
-    where
-        X1: ServiceFactory<Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-    {
-        H1Service {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
-    where
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        H1Service {
-            upgrade,
-            cfg: self.cfg,
-            srv: self.srv,
-            expect: self.expect,
-            on_connect_ext: self.on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
-        self.on_connect_ext = f;
-        self
-    }
-}
-
-impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
-    for H1Service<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-{
-    type Response = ();
-    type Error = DispatchError;
-    type Config = ();
-    type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
-    type InitError = ();
-    type Future = 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_ext: self.on_connect_ext.clone(),
-            cfg: Some(self.cfg.clone()),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H1ServiceResponse<T, S, B, X, U>
-where
-    S: ServiceFactory<Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    X: ServiceFactory<Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<(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_ext: Option<Rc<ConnectCallback<T>>>,
-    cfg: Option<ServiceConfig>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B, X, U> Future for H1ServiceResponse<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: ServiceFactory<Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<(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_upg.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_ext.clone(),
-            )
-        }))
-    }
-}
-
-/// `Service` implementation for HTTP/1 transport
-pub struct H1ServiceHandler<T, S, B, X, U>
-where
-    S: Service<Request>,
-    X: Service<Request>,
-    U: Service<(Request, Framed<T, Codec>)>,
-{
-    flow: Rc<HttpFlow<S, X, U>>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    cfg: ServiceConfig,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B, X, U> H1ServiceHandler<T, S, B, X, U>
-where
-    S: Service<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn new(
-        cfg: ServiceConfig,
-        service: S,
-        expect: X,
-        upgrade: Option<U>,
-        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    ) -> H1ServiceHandler<T, S, B, X, U> {
-        H1ServiceHandler {
-            flow: HttpFlow::new(service, expect, upgrade),
-            cfg,
-            on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
-    for H1ServiceHandler<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
-{
-    type Response = ();
-    type Error = DispatchError;
-    type Future = Dispatcher<T, S, B, X, U>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let ready = self
-            .flow
-            .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
-            .flow
-            .service
-            .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 upg) = self.flow.upgrade {
-            upg.poll_ready(cx)
-                .map_err(|e| {
-                    let e = e.into();
-                    log::error!("Http service readiness error: {:?}", e);
-                    DispatchError::Service(e)
-                })?
-                .is_ready()
-                && ready
-        } else {
-            ready
-        };
-
-        if ready {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
-
-        Dispatcher::new(
-            io,
-            self.cfg.clone(),
-            self.flow.clone(),
-            on_connect_data,
-            addr,
-        )
-    }
-}

actix-http/src/h1/upgrade.rs

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

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,370 +0,0 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::net;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{cmp, convert::TryFrom};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{Instant, Sleep};
-use actix_service::Service;
-use bytes::{Bytes, BytesMut};
-use futures_core::ready;
-use h2::server::{Connection, SendResponse};
-use h2::SendStream;
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use log::{error, trace};
-
-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::message::ResponseHead;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::OnConnectData;
-
-const CHUNK_SIZE: usize = 16_384;
-
-/// Dispatcher for HTTP/2 protocol.
-#[pin_project::pin_project]
-pub struct Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    B: MessageBody,
-{
-    flow: Rc<HttpFlow<S, X, U>>,
-    connection: Connection<T, Bytes>,
-    on_connect_data: OnConnectData,
-    config: ServiceConfig,
-    peer_addr: Option<net::SocketAddr>,
-    ka_expire: Instant,
-    ka_timer: Option<Sleep>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    pub(crate) fn new(
-        flow: Rc<HttpFlow<S, X, U>>,
-        connection: Connection<T, Bytes>,
-        on_connect_data: OnConnectData,
-        config: ServiceConfig,
-        timeout: Option<Sleep>,
-        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 {
-            flow,
-            config,
-            peer_addr,
-            connection,
-            on_connect_data,
-            ka_expire,
-            ka_timer,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<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 ready!(Pin::new(&mut this.connection).poll_accept(cx)) {
-                None => return Poll::Ready(Ok(())),
-
-                Some(Err(err)) => return Poll::Ready(Err(err.into())),
-
-                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 pl = crate::h2::Payload::new(body);
-                    let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
-                    let mut req = Request::with_payload(pl);
-
-                    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;
-
-                    // merge on_connect_ext data into request extensions
-                    this.on_connect_data.merge_into(&mut req);
-
-                    let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> {
-                        state: ServiceResponseState::ServiceCall(
-                            this.flow.service.call(req),
-                            Some(res),
-                        ),
-                        config: this.config.clone(),
-                        buffer: None,
-                        _phantom: PhantomData,
-                    };
-
-                    actix_rt::spawn(svc);
-                }
-            }
-        }
-    }
-}
-
-#[pin_project::pin_project]
-struct ServiceResponse<F, I, E, B> {
-    #[pin]
-    state: ServiceResponseState<F, B>,
-    config: ServiceConfig,
-    buffer: Option<Bytes>,
-    _phantom: 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 {
-                // omit HTTP/1 only headers
-                CONNECTION | TRANSFER_ENCODING => continue,
-                CONTENT_LENGTH if skip_len => continue,
-                DATE => has_date = true,
-                _ => {}
-            }
-
-            res.headers_mut().append(key, value.clone());
-        }
-
-        // set date header
-        if !has_date {
-            let mut bytes = BytesMut::with_capacity(29);
-            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 ready!(call.poll(cx)) {
-                    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 HTTP/2 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)
-                        }
-                    }
-
-                    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 HTTP/2 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 {
-                        match this.buffer {
-                            Some(ref mut buffer) => {
-                                match ready!(stream.poll_capacity(cx)) {
-                                    None => return Poll::Ready(()),
-
-                                    Some(Ok(cap)) => {
-                                        let len = buffer.len();
-                                        let bytes = buffer.split_to(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 = cmp::min(buffer.len(), CHUNK_SIZE);
-                                            stream.reserve_capacity(cap);
-                                        } else {
-                                            this.buffer.take();
-                                        }
-                                    }
-
-                                    Some(Err(e)) => {
-                                        warn!("{:?}", e);
-                                        return Poll::Ready(());
-                                    }
-                                }
-                            }
-
-                            None => match ready!(body.as_mut().poll_next(cx)) {
-                                None => {
-                                    if let Err(e) = stream.send_data(Bytes::new(), true)
-                                    {
-                                        warn!("{:?}", e);
-                                    }
-                                    return Poll::Ready(());
-                                }
-
-                                Some(Ok(chunk)) => {
-                                    stream.reserve_capacity(cmp::min(
-                                        chunk.len(),
-                                        CHUNK_SIZE,
-                                    ));
-                                    *this.buffer = Some(chunk);
-                                }
-
-                                Some(Err(e)) => {
-                                    error!("Response payload stream error: {:?}", e);
-                                    return Poll::Ready(());
-                                }
-                            },
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

actix-http/src/h2/mod.rs

@@ -1,52 +0,0 @@
-//! HTTP/2 implementation.
-
-use std::{
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::Bytes;
-use futures_core::{ready, Stream};
-use h2::RecvStream;
-
-mod dispatcher;
-mod service;
-
-pub use self::dispatcher::Dispatcher;
-pub use self::service::H2Service;
-use crate::error::PayloadError;
-
-/// HTTP/2 peer stream.
-pub struct Payload {
-    stream: RecvStream,
-}
-
-impl Payload {
-    pub(crate) fn new(stream: RecvStream) -> Self {
-        Self { stream }
-    }
-}
-
-impl Stream for Payload {
-    type Item = Result<Bytes, PayloadError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-
-        match ready!(Pin::new(&mut this.stream).poll_data(cx)) {
-            Some(Ok(chunk)) => {
-                let len = chunk.len();
-
-                match this.stream.flow_control().release_capacity(len) {
-                    Ok(()) => Poll::Ready(Some(Ok(chunk))),
-                    Err(err) => Poll::Ready(Some(Err(err.into()))),
-                }
-            }
-            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
-            None => Poll::Ready(None),
-        }
-    }
-}

actix-http/src/h2/service.rs

@@ -1,383 +0,0 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{net, rc::Rc};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
-use actix_service::{
-    fn_factory, fn_service, 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::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::{ConnectCallback, OnConnectData};
-
-use super::dispatcher::Dispatcher;
-
-/// `ServiceFactory` implementation for HTTP/2 transport
-pub struct H2Service<T, S, B> {
-    srv: S,
-    cfg: ServiceConfig,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<(T, B)>,
-}
-
-impl<T, S, B> H2Service<T, S, B>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create new `H2Service` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        H2Service {
-            cfg,
-            on_connect_ext: None,
-            srv: service.into_factory(),
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
-        self.on_connect_ext = f;
-        self
-    }
-}
-
-impl<S, B> H2Service<TcpStream, S, B>
-where
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create plain TCP based service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        TcpStream,
-        Config = (),
-        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, ServiceFactoryExt};
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
-    use actix_tls::accept::TlsError;
-
-    use super::*;
-
-    impl<S, B> H2Service<SslStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create OpenSSL based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            Response = (),
-            Error = TlsError<SslError, 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_service::ServiceFactoryExt;
-    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::accept::TlsError;
-    use std::io;
-
-    impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Request, Config = ()>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service<Request>>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create Rustls based service
-        pub fn rustls(
-            self,
-            mut config: ServerConfig,
-        ) -> impl ServiceFactory<
-            TcpStream,
-            Config = (),
-            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<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Response = ();
-    type Error = DispatchError;
-    type Config = ();
-    type Service = H2ServiceHandler<T, S::Service, B>;
-    type InitError = S::InitError;
-    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_ext: self.on_connect_ext.clone(),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H2ServiceResponse<T, S, B>
-where
-    S: ServiceFactory<Request>,
-{
-    #[pin]
-    fut: S::Future,
-    cfg: Option<ServiceConfig>,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B> Future for H2ServiceResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service<Request>>::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();
-
-        this.fut.poll(cx).map_ok(|service| {
-            let this = self.as_mut().project();
-            H2ServiceHandler::new(
-                this.cfg.take().unwrap(),
-                this.on_connect_ext.clone(),
-                service,
-            )
-        })
-    }
-}
-
-/// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, S, B>
-where
-    S: Service<Request>,
-{
-    flow: Rc<HttpFlow<S, (), ()>>,
-    cfg: ServiceConfig,
-    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _phantom: PhantomData<B>,
-}
-
-impl<T, S, B> H2ServiceHandler<T, S, B>
-where
-    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    fn new(
-        cfg: ServiceConfig,
-        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-        service: S,
-    ) -> H2ServiceHandler<T, S, B> {
-        H2ServiceHandler {
-            flow: HttpFlow::new(service, (), None),
-            cfg,
-            on_connect_ext,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
-    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
-{
-    type Response = ();
-    type Error = DispatchError;
-    type Future = H2ServiceHandlerResponse<T, S, B>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.flow.service.poll_ready(cx).map_err(|e| {
-            let e = e.into();
-            error!("Service readiness error: {:?}", e);
-            DispatchError::Service(e)
-        })
-    }
-
-    fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
-        let on_connect_data =
-            OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
-
-        H2ServiceHandlerResponse {
-            state: State::Handshake(
-                Some(self.flow.clone()),
-                Some(self.cfg.clone()),
-                addr,
-                on_connect_data,
-                server::handshake(io),
-            ),
-        }
-    }
-}
-
-enum State<T, S: Service<Request>, B: MessageBody>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S::Future: 'static,
-{
-    Incoming(Dispatcher<T, S, B, (), ()>),
-    Handshake(
-        Option<Rc<HttpFlow<S, (), ()>>>,
-        Option<ServiceConfig>,
-        Option<net::SocketAddr>,
-        OnConnectData,
-        Handshake<T, Bytes>,
-    ),
-}
-
-pub struct H2ServiceHandlerResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<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>,
-    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_data,
-                ref mut handshake,
-            ) => match ready!(Pin::new(handshake).poll(cx)) {
-                Ok(conn) => {
-                    let on_connect_data = std::mem::take(on_connect_data);
-                    self.state = State::Incoming(Dispatcher::new(
-                        srv.take().unwrap(),
-                        conn,
-                        on_connect_data,
-                        config.take().unwrap(),
-                        None,
-                        *peer_addr,
-                    ));
-                    self.poll(cx)
-                }
-                Err(err) => {
-                    trace!("H2 handshake error: {}", err);
-                    Poll::Ready(Err(err.into()))
-                }
-            },
-        }
-    }
-}

actix-http/src/header/as_name.rs

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

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

@@ -1,272 +0,0 @@
-use std::cmp::Ordering;
-
-use mime::Mime;
-
-use crate::header::{qitem, QualityItem};
-use crate::http::header;
-
-header! {
-    /// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
-    ///
-    /// The `Accept` header field can be used by user agents to specify
-    /// response media types that are acceptable. Accept header fields can
-    /// be used to indicate that the request is specifically limited to a
-    /// small set of desired types, as in the case of a request for an
-    /// in-line image
-    ///
-    /// # ABNF
-    ///
-    /// ```text
-    /// Accept = #( media-range [ accept-params ] )
-    ///
-    /// media-range    = ( "*/*"
-    ///                  / ( type "/" "*" )
-    ///                  / ( type "/" subtype )
-    ///                  ) *( OWS ";" OWS parameter )
-    /// accept-params  = weight *( accept-ext )
-    /// accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]
-    /// ```
-    ///
-    /// # Example values
-    /// * `audio/*; q=0.2, audio/basic`
-    /// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
-    ///
-    /// # Examples
-    /// ```
-    /// use actix_http::Response;
-    /// use actix_http::http::header::{Accept, qitem};
-    ///
-    /// let mut builder = Response::Ok();
-    /// builder.insert_header(
-    ///     Accept(vec![
-    ///         qitem(mime::TEXT_HTML),
-    ///     ])
-    /// );
-    /// ```
-    ///
-    /// ```
-    /// use actix_http::Response;
-    /// use actix_http::http::header::{Accept, qitem};
-    ///
-    /// let mut builder = Response::Ok();
-    /// builder.insert_header(
-    ///     Accept(vec![
-    ///         qitem(mime::APPLICATION_JSON),
-    ///     ])
-    /// );
-    /// ```
-    ///
-    /// ```
-    /// use actix_http::Response;
-    /// use actix_http::http::header::{Accept, QualityItem, q, qitem};
-    ///
-    /// let mut builder = Response::Ok();
-    /// builder.insert_header(
-    ///     Accept(vec![
-    ///         qitem(mime::TEXT_HTML),
-    ///         qitem("application/xhtml+xml".parse().unwrap()),
-    ///         QualityItem::new(
-    ///             mime::TEXT_XML,
-    ///             q(900)
-    ///         ),
-    ///         qitem("image/webp".parse().unwrap()),
-    ///         QualityItem::new(
-    ///             mime::STAR_STAR,
-    ///             q(800)
-    ///         ),
-    ///     ])
-    /// );
-    /// ```
-    (Accept, header::ACCEPT) => (QualityItem<Mime>)+
-
-    test_accept {
-        // Tests from the RFC
-         test_header!(
-            test1,
-            vec![b"audio/*; q=0.2, audio/basic"],
-            Some(Accept(vec![
-                QualityItem::new("audio/*".parse().unwrap(), q(200)),
-                qitem("audio/basic".parse().unwrap()),
-                ])));
-        test_header!(
-            test2,
-            vec![b"text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"],
-            Some(Accept(vec![
-                QualityItem::new(mime::TEXT_PLAIN, q(500)),
-                qitem(mime::TEXT_HTML),
-                QualityItem::new(
-                    "text/x-dvi".parse().unwrap(),
-                    q(800)),
-                qitem("text/x-c".parse().unwrap()),
-                ])));
-        // Custom tests
-        test_header!(
-            test3,
-            vec![b"text/plain; charset=utf-8"],
-            Some(Accept(vec![
-                qitem(mime::TEXT_PLAIN_UTF_8),
-                ])));
-        test_header!(
-            test4,
-            vec![b"text/plain; charset=utf-8; q=0.5"],
-            Some(Accept(vec![
-                QualityItem::new(mime::TEXT_PLAIN_UTF_8,
-                    q(500)),
-            ])));
-
-        #[test]
-        fn test_fuzzing1() {
-            use crate::test::TestRequest;
-            let req = TestRequest::default().insert_header((crate::header::ACCEPT, "chunk#;e")).finish();
-            let header = Accept::parse(&req);
-            assert!(header.is_ok());
-        }
-    }
-}
-
-impl Accept {
-    /// Construct `Accept: */*`.
-    pub fn star() -> Accept {
-        Accept(vec![qitem(mime::STAR_STAR)])
-    }
-
-    /// Construct `Accept: application/json`.
-    pub fn json() -> Accept {
-        Accept(vec![qitem(mime::APPLICATION_JSON)])
-    }
-
-    /// Construct `Accept: text/*`.
-    pub fn text() -> Accept {
-        Accept(vec![qitem(mime::TEXT_STAR)])
-    }
-
-    /// Construct `Accept: image/*`.
-    pub fn image() -> Accept {
-        Accept(vec![qitem(mime::IMAGE_STAR)])
-    }
-
-    /// Construct `Accept: text/html`.
-    pub fn html() -> Accept {
-        Accept(vec![qitem(mime::TEXT_HTML)])
-    }
-
-    /// Returns a sorted list of mime types from highest to lowest preference, accounting for
-    /// [q-factor weighting] and specificity.
-    ///
-    /// [q-factor weighting]: https://tools.ietf.org/html/rfc7231#section-5.3.2
-    pub fn mime_precedence(&self) -> Vec<Mime> {
-        let mut types = self.0.clone();
-
-        // use stable sort so items with equal q-factor and specificity retain listed order
-        types.sort_by(|a, b| {
-            // sort by q-factor descending
-            b.quality.cmp(&a.quality).then_with(|| {
-                // use specificity rules on mime types with
-                // same q-factor (eg. text/html > text/* > */*)
-
-                // subtypes are not comparable if main type is star, so return
-                match (a.item.type_(), b.item.type_()) {
-                    (mime::STAR, mime::STAR) => return Ordering::Equal,
-
-                    // a is sorted after b
-                    (mime::STAR, _) => return Ordering::Greater,
-
-                    // a is sorted before b
-                    (_, mime::STAR) => return Ordering::Less,
-
-                    _ => {}
-                }
-
-                // in both these match expressions, the returned ordering appears
-                // inverted because sort is high-to-low ("descending") precedence
-                match (a.item.subtype(), b.item.subtype()) {
-                    (mime::STAR, mime::STAR) => Ordering::Equal,
-
-                    // a is sorted after b
-                    (mime::STAR, _) => Ordering::Greater,
-
-                    // a is sorted before b
-                    (_, mime::STAR) => Ordering::Less,
-
-                    _ => Ordering::Equal,
-                }
-            })
-        });
-
-        types.into_iter().map(|qitem| qitem.item).collect()
-    }
-
-    /// Extracts the most preferable mime type, accounting for [q-factor weighting].
-    ///
-    /// If no q-factors are provided, the first mime type is chosen. Note that items without
-    /// q-factors are given the maximum preference value.
-    ///
-    /// Returns `None` if contained list is empty.
-    ///
-    /// [q-factor weighting]: https://tools.ietf.org/html/rfc7231#section-5.3.2
-    pub fn mime_preference(&self) -> Option<Mime> {
-        let types = self.mime_precedence();
-        types.first().cloned()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::header::q;
-
-    #[test]
-    fn test_mime_precedence() {
-        let test = Accept(vec![]);
-        assert!(test.mime_precedence().is_empty());
-
-        let test = Accept(vec![qitem(mime::APPLICATION_JSON)]);
-        assert_eq!(test.mime_precedence(), vec!(mime::APPLICATION_JSON));
-
-        let test = Accept(vec![
-            qitem(mime::TEXT_HTML),
-            "application/xhtml+xml".parse().unwrap(),
-            QualityItem::new("application/xml".parse().unwrap(), q(0.9)),
-            QualityItem::new(mime::STAR_STAR, q(0.8)),
-        ]);
-        assert_eq!(
-            test.mime_precedence(),
-            vec![
-                mime::TEXT_HTML,
-                "application/xhtml+xml".parse().unwrap(),
-                "application/xml".parse().unwrap(),
-                mime::STAR_STAR,
-            ]
-        );
-
-        let test = Accept(vec![
-            qitem(mime::STAR_STAR),
-            qitem(mime::IMAGE_STAR),
-            qitem(mime::IMAGE_PNG),
-        ]);
-        assert_eq!(
-            test.mime_precedence(),
-            vec![mime::IMAGE_PNG, mime::IMAGE_STAR, mime::STAR_STAR]
-        );
-    }
-
-    #[test]
-    fn test_mime_preference() {
-        let test = Accept(vec![
-            qitem(mime::TEXT_HTML),
-            "application/xhtml+xml".parse().unwrap(),
-            QualityItem::new("application/xml".parse().unwrap(), q(0.9)),
-            QualityItem::new(mime::STAR_STAR, q(0.8)),
-        ]);
-        assert_eq!(test.mime_preference(), Some(mime::TEXT_HTML));
-
-        let test = Accept(vec![
-            QualityItem::new("video/*".parse().unwrap(), q(0.8)),
-            qitem(mime::IMAGE_PNG),
-            QualityItem::new(mime::STAR_STAR, q(0.5)),
-            qitem(mime::IMAGE_SVG),
-            QualityItem::new(mime::IMAGE_STAR, q(0.8)),
-        ]);
-        assert_eq!(test.mime_preference(), Some(mime::IMAGE_PNG));
-    }
-}

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

@@ -1,106 +0,0 @@
-use std::{convert::Infallible, str::FromStr};
-
-use http::header::InvalidHeaderValue;
-
-use crate::{
-    error::ParseError,
-    header::{self, from_one_raw_str, Header, HeaderName, HeaderValue, IntoHeaderValue},
-    HttpMessage,
-};
-
-/// Represents a supported content encoding.
-#[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 {
-    /// Is the content compressed?
-    #[inline]
-    pub fn is_compression(self) -> bool {
-        matches!(self, ContentEncoding::Identity | ContentEncoding::Auto)
-    }
-
-    /// Convert content encoding to string
-    #[inline]
-    pub fn as_str(self) -> &'static str {
-        match self {
-            ContentEncoding::Br => "br",
-            ContentEncoding::Gzip => "gzip",
-            ContentEncoding::Deflate => "deflate",
-            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
-        }
-    }
-
-    /// Default Q-factor (quality) value.
-    #[inline]
-    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 Default for ContentEncoding {
-    fn default() -> Self {
-        Self::Identity
-    }
-}
-
-impl FromStr for ContentEncoding {
-    type Err = Infallible;
-
-    fn from_str(val: &str) -> Result<Self, Self::Err> {
-        Ok(Self::from(val))
-    }
-}
-
-impl From<&str> for ContentEncoding {
-    fn from(val: &str) -> ContentEncoding {
-        let val = val.trim();
-
-        if val.eq_ignore_ascii_case("br") {
-            ContentEncoding::Br
-        } else if val.eq_ignore_ascii_case("gzip") {
-            ContentEncoding::Gzip
-        } else if val.eq_ignore_ascii_case("deflate") {
-            ContentEncoding::Deflate
-        } else {
-            ContentEncoding::default()
-        }
-    }
-}
-
-impl IntoHeaderValue for ContentEncoding {
-    type Error = InvalidHeaderValue;
-
-    fn try_into_value(self) -> Result<http::HeaderValue, Self::Error> {
-        Ok(HeaderValue::from_static(self.as_str()))
-    }
-}
-
-impl Header for ContentEncoding {
-    fn name() -> HeaderName {
-        header::CONTENT_ENCODING
-    }
-
-    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {
-        from_one_raw_str(msg.headers().get(Self::name()))
-    }
-}

actix-http/src/header/into_pair.rs

@@ -1,117 +0,0 @@
-use std::convert::TryFrom;
-
-use http::{
-    header::{HeaderName, InvalidHeaderName, InvalidHeaderValue},
-    Error as HttpError, HeaderValue,
-};
-
-use super::{Header, IntoHeaderValue};
-
-/// Transforms structures into header K/V pairs for inserting into `HeaderMap`s.
-pub trait IntoHeaderPair: Sized {
-    type Error: Into<HttpError>;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
-}
-
-#[derive(Debug)]
-pub enum InvalidHeaderPart {
-    Name(InvalidHeaderName),
-    Value(InvalidHeaderValue),
-}
-
-impl From<InvalidHeaderPart> for HttpError {
-    fn from(part_err: InvalidHeaderPart) -> Self {
-        match part_err {
-            InvalidHeaderPart::Name(err) => err.into(),
-            InvalidHeaderPart::Value(err) => err.into(),
-        }
-    }
-}
-
-impl<V> IntoHeaderPair for (HeaderName, V)
-where
-    V: IntoHeaderValue,
-    V::Error: Into<InvalidHeaderValue>,
-{
-    type Error = InvalidHeaderPart;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        let (name, value) = self;
-        let value = value
-            .try_into_value()
-            .map_err(|err| InvalidHeaderPart::Value(err.into()))?;
-        Ok((name, value))
-    }
-}
-
-impl<V> IntoHeaderPair for (&HeaderName, V)
-where
-    V: IntoHeaderValue,
-    V::Error: Into<InvalidHeaderValue>,
-{
-    type Error = InvalidHeaderPart;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        let (name, value) = self;
-        let value = value
-            .try_into_value()
-            .map_err(|err| InvalidHeaderPart::Value(err.into()))?;
-        Ok((name.clone(), value))
-    }
-}
-
-impl<V> IntoHeaderPair for (&[u8], V)
-where
-    V: IntoHeaderValue,
-    V::Error: Into<InvalidHeaderValue>,
-{
-    type Error = InvalidHeaderPart;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        let (name, value) = self;
-        let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
-        let value = value
-            .try_into_value()
-            .map_err(|err| InvalidHeaderPart::Value(err.into()))?;
-        Ok((name, value))
-    }
-}
-
-impl<V> IntoHeaderPair for (&str, V)
-where
-    V: IntoHeaderValue,
-    V::Error: Into<InvalidHeaderValue>,
-{
-    type Error = InvalidHeaderPart;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        let (name, value) = self;
-        let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
-        let value = value
-            .try_into_value()
-            .map_err(|err| InvalidHeaderPart::Value(err.into()))?;
-        Ok((name, value))
-    }
-}
-
-impl<V> IntoHeaderPair for (String, V)
-where
-    V: IntoHeaderValue,
-    V::Error: Into<InvalidHeaderValue>,
-{
-    type Error = InvalidHeaderPart;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        let (name, value) = self;
-        (name.as_str(), value).try_into_header_pair()
-    }
-}
-
-impl<T: Header> IntoHeaderPair for T {
-    type Error = <T as IntoHeaderValue>::Error;
-
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
-        Ok((T::name(), self.try_into_value()?))
-    }
-}

actix-http/src/header/into_value.rs

@@ -1,131 +0,0 @@
-use std::convert::TryFrom;
-
-use bytes::Bytes;
-use http::{header::InvalidHeaderValue, Error as HttpError, HeaderValue};
-use mime::Mime;
-
-/// 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 HeaderValue.
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error>;
-}
-
-impl IntoHeaderValue for HeaderValue {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        Ok(self)
-    }
-}
-
-impl IntoHeaderValue for &HeaderValue {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        Ok(self.clone())
-    }
-}
-
-impl IntoHeaderValue for &str {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        self.parse()
-    }
-}
-
-impl IntoHeaderValue for &[u8] {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_bytes(self)
-    }
-}
-
-impl IntoHeaderValue for Bytes {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_maybe_shared(self)
-    }
-}
-
-impl IntoHeaderValue for Vec<u8> {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
-    }
-}
-
-impl IntoHeaderValue for String {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
-    }
-}
-
-impl IntoHeaderValue for usize {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self.to_string())
-    }
-}
-
-impl IntoHeaderValue for i64 {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self.to_string())
-    }
-}
-
-impl IntoHeaderValue for u64 {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self.to_string())
-    }
-}
-
-impl IntoHeaderValue for i32 {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self.to_string())
-    }
-}
-
-impl IntoHeaderValue for u32 {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self.to_string())
-    }
-}
-
-impl IntoHeaderValue for Mime {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into_value(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_str(self.as_ref())
-    }
-}

actix-http/src/header/map.rs

@@ -1,953 +0,0 @@
-//! A multi-value [`HeaderMap`] and its iterators.
-
-use std::{borrow::Cow, collections::hash_map, ops};
-
-use ahash::AHashMap;
-use http::header::{HeaderName, HeaderValue};
-use smallvec::{smallvec, SmallVec};
-
-use crate::header::AsHeaderName;
-
-/// A multi-map of HTTP headers.
-///
-/// `HeaderMap` is a "multi-map" of [`HeaderName`] to one or more [`HeaderValue`]s.
-///
-/// # Examples
-/// ```
-/// use actix_http::http::{header, HeaderMap, HeaderValue};
-///
-/// let mut map = HeaderMap::new();
-///
-/// map.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));
-/// map.insert(header::ORIGIN, HeaderValue::from_static("example.com"));
-///
-/// assert!(map.contains_key(header::CONTENT_TYPE));
-/// assert!(map.contains_key(header::ORIGIN));
-///
-/// let mut removed = map.remove(header::ORIGIN);
-/// assert_eq!(removed.next().unwrap(), "example.com");
-///
-/// assert!(!map.contains_key(header::ORIGIN));
-/// ```
-#[derive(Debug, Clone, Default)]
-pub struct HeaderMap {
-    pub(crate) inner: AHashMap<HeaderName, Value>,
-}
-
-/// A bespoke non-empty list for HeaderMap values.
-#[derive(Debug, Clone)]
-pub(crate) struct Value {
-    inner: SmallVec<[HeaderValue; 4]>,
-}
-
-impl Value {
-    fn one(val: HeaderValue) -> Self {
-        Self {
-            inner: smallvec![val],
-        }
-    }
-
-    fn first(&self) -> &HeaderValue {
-        &self.inner[0]
-    }
-
-    fn first_mut(&mut self) -> &mut HeaderValue {
-        &mut self.inner[0]
-    }
-
-    fn append(&mut self, new_val: HeaderValue) {
-        self.inner.push(new_val)
-    }
-}
-
-impl ops::Deref for Value {
-    type Target = SmallVec<[HeaderValue; 4]>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl HeaderMap {
-    /// Create an empty `HeaderMap`.
-    ///
-    /// The map will be created without any capacity; this function will not allocate.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::HeaderMap;
-    /// let map = HeaderMap::new();
-    ///
-    /// assert!(map.is_empty());
-    /// assert_eq!(0, map.capacity());
-    /// ```
-    pub fn new() -> Self {
-        HeaderMap::default()
-    }
-
-    /// Create an empty `HeaderMap` with the specified capacity.
-    ///
-    /// The map will be able to hold at least `capacity` elements without needing to reallocate.
-    /// If `capacity` is 0, the map will be created without allocating.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::HeaderMap;
-    /// let map = HeaderMap::with_capacity(16);
-    ///
-    /// assert!(map.is_empty());
-    /// assert!(map.capacity() >= 16);
-    /// ```
-    pub fn with_capacity(capacity: usize) -> Self {
-        HeaderMap {
-            inner: AHashMap::with_capacity(capacity),
-        }
-    }
-
-    /// Create new `HeaderMap` from a `http::HeaderMap`-like drain.
-    pub(crate) fn from_drain<I>(mut drain: I) -> Self
-    where
-        I: Iterator<Item = (Option<HeaderName>, HeaderValue)>,
-    {
-        let (first_name, first_value) = match drain.next() {
-            None => return HeaderMap::new(),
-            Some((name, val)) => {
-                let name = name.expect("drained first item had no name");
-                (name, val)
-            }
-        };
-
-        let (lb, ub) = drain.size_hint();
-        let capacity = ub.unwrap_or(lb);
-
-        let mut map = HeaderMap::with_capacity(capacity);
-        map.append(first_name.clone(), first_value);
-
-        let (map, _) =
-            drain.fold((map, first_name), |(mut map, prev_name), (name, value)| {
-                let name = name.unwrap_or(prev_name);
-                map.append(name.clone(), value);
-                (map, name)
-            });
-
-        map
-    }
-
-    /// Returns the number of values stored in the map.
-    ///
-    /// See also: [`len_keys`](Self::len_keys).
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    /// assert_eq!(map.len(), 0);
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// assert_eq!(map.len(), 2);
-    ///
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    /// assert_eq!(map.len(), 3);
-    /// ```
-    pub fn len(&self) -> usize {
-        self.inner
-            .iter()
-            .fold(0, |acc, (_, values)| acc + values.len())
-    }
-
-    /// Returns the number of _keys_ stored in the map.
-    ///
-    /// The number of values stored will be at least this number. See also: [`Self::len`].
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    /// assert_eq!(map.len_keys(), 0);
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// assert_eq!(map.len_keys(), 2);
-    ///
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    /// assert_eq!(map.len_keys(), 2);
-    /// ```
-    pub fn len_keys(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    /// assert!(map.is_empty());
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// assert!(!map.is_empty());
-    /// ```
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0
-    }
-
-    /// Clears the map, removing all name-value pairs.
-    ///
-    /// Keeps the allocated memory for reuse.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// assert_eq!(map.len(), 2);
-    ///
-    /// map.clear();
-    /// assert!(map.is_empty());
-    /// ```
-    pub fn clear(&mut self) {
-        self.inner.clear();
-    }
-
-    fn get_value(&self, key: impl AsHeaderName) -> Option<&Value> {
-        match key.try_as_name().ok()? {
-            Cow::Borrowed(name) => self.inner.get(name),
-            Cow::Owned(name) => self.inner.get(&name),
-        }
-    }
-
-    /// Returns a reference to the _first_ value associated with a header name.
-    ///
-    /// Returns `None` if there is no value associated with the key.
-    ///
-    /// Even when multiple values are associated with the key, the "first" one is returned but is
-    /// not guaranteed to be chosen with any particular order; though, the returned item will be
-    /// consistent for each call to `get` if the map has not changed.
-    ///
-    /// See also: [`get_all`](Self::get_all).
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    ///
-    /// let cookie = map.get(header::SET_COOKIE).unwrap();
-    /// assert_eq!(cookie, "one=1");
-    ///
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    /// assert_eq!(map.get(header::SET_COOKIE).unwrap(), "one=1");
-    ///
-    /// assert_eq!(map.get(header::SET_COOKIE), map.get("set-cookie"));
-    /// assert_eq!(map.get(header::SET_COOKIE), map.get("Set-Cookie"));
-    ///
-    /// assert!(map.get(header::HOST).is_none());
-    /// assert!(map.get("INVALID HEADER NAME").is_none());
-    /// ```
-    pub fn get(&self, key: impl AsHeaderName) -> Option<&HeaderValue> {
-        self.get_value(key).map(|val| val.first())
-    }
-
-    /// Returns a mutable reference to the _first_ value associated a header name.
-    ///
-    /// Returns `None` if there is no value associated with the key.
-    ///
-    /// Even when multiple values are associated with the key, the "first" one is returned but is
-    /// not guaranteed to be chosen with any particular order; though, the returned item will be
-    /// consistent for each call to `get_mut` if the map has not changed.
-    ///
-    /// See also: [`get_all`](Self::get_all).
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    ///
-    /// let mut cookie = map.get_mut(header::SET_COOKIE).unwrap();
-    /// assert_eq!(cookie, "one=1");
-    ///
-    /// *cookie = HeaderValue::from_static("three=3");
-    /// assert_eq!(map.get(header::SET_COOKIE).unwrap(), "three=3");
-    ///
-    /// assert!(map.get(header::HOST).is_none());
-    /// assert!(map.get("INVALID HEADER NAME").is_none());
-    /// ```
-    pub fn get_mut(&mut self, key: impl AsHeaderName) -> Option<&mut HeaderValue> {
-        match key.try_as_name().ok()? {
-            Cow::Borrowed(name) => self.inner.get_mut(name).map(|v| v.first_mut()),
-            Cow::Owned(name) => self.inner.get_mut(&name).map(|v| v.first_mut()),
-        }
-    }
-
-    /// Returns an iterator over all values associated with a header name.
-    ///
-    /// The returned iterator does not incur any allocations and will yield no items if there are no
-    /// values associated with the key. Iteration order is **not** guaranteed to be the same as
-    /// insertion order.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// let mut none_iter = map.get_all(header::ORIGIN);
-    /// assert!(none_iter.next().is_none());
-    ///
-    /// map.insert(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    ///
-    /// let mut set_cookies_iter = map.get_all(header::SET_COOKIE);
-    /// assert_eq!(set_cookies_iter.next().unwrap(), "one=1");
-    /// assert_eq!(set_cookies_iter.next().unwrap(), "two=2");
-    /// assert!(set_cookies_iter.next().is_none());
-    /// ```
-    pub fn get_all(&self, key: impl AsHeaderName) -> GetAll<'_> {
-        GetAll::new(self.get_value(key))
-    }
-
-    // TODO: get_all_mut ?
-
-    /// Returns `true` if the map contains a value for the specified key.
-    ///
-    /// Invalid header names will simply return false.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    /// assert!(!map.contains_key(header::ACCEPT));
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// assert!(map.contains_key(header::ACCEPT));
-    /// ```
-    pub fn contains_key(&self, key: impl AsHeaderName) -> bool {
-        match key.try_as_name() {
-            Ok(Cow::Borrowed(name)) => self.inner.contains_key(name),
-            Ok(Cow::Owned(name)) => self.inner.contains_key(&name),
-            Err(_) => false,
-        }
-    }
-
-    /// Inserts a name-value pair into the map.
-    ///
-    /// If the map already contained this key, the new value is associated with the key and all
-    /// previous values are removed and returned as a `Removed` iterator. The key is not updated;
-    /// this matters for types that can be `==` without being identical.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.insert(header::ACCEPT, HeaderValue::from_static("text/plain"));
-    /// assert!(map.contains_key(header::ACCEPT));
-    /// assert_eq!(map.len(), 1);
-    ///
-    /// let mut removed = map.insert(header::ACCEPT, HeaderValue::from_static("text/csv"));
-    /// assert_eq!(removed.next().unwrap(), "text/plain");
-    /// assert!(removed.next().is_none());
-    ///
-    /// assert_eq!(map.len(), 1);
-    /// ```
-    pub fn insert(&mut self, key: HeaderName, val: HeaderValue) -> Removed {
-        let value = self.inner.insert(key, Value::one(val));
-        Removed::new(value)
-    }
-
-    /// Inserts a name-value pair into the map.
-    ///
-    /// If the map already contained this key, the new value is added to the list of values
-    /// currently associated with the key. The key is not updated; this matters for types that can
-    /// be `==` without being identical.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.append(header::HOST, HeaderValue::from_static("example.com"));
-    /// assert_eq!(map.len(), 1);
-    ///
-    /// map.append(header::ACCEPT, HeaderValue::from_static("text/csv"));
-    /// assert_eq!(map.len(), 2);
-    ///
-    /// map.append(header::ACCEPT, HeaderValue::from_static("text/html"));
-    /// assert_eq!(map.len(), 3);
-    /// ```
-    pub fn append(&mut self, key: HeaderName, value: HeaderValue) {
-        match self.inner.entry(key) {
-            hash_map::Entry::Occupied(mut entry) => {
-                entry.get_mut().append(value);
-            }
-            hash_map::Entry::Vacant(entry) => {
-                entry.insert(Value::one(value));
-            }
-        };
-    }
-
-    /// Removes all headers for a particular header name from the map.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=2"));
-    ///
-    /// assert_eq!(map.len(), 2);
-    ///
-    /// let mut removed = map.remove(header::SET_COOKIE);
-    /// assert_eq!(removed.next().unwrap(), "one=1");
-    /// assert_eq!(removed.next().unwrap(), "one=2");
-    /// assert!(removed.next().is_none());
-    ///
-    /// assert!(map.is_empty());
-    pub fn remove(&mut self, key: impl AsHeaderName) -> Removed {
-        let value = match key.try_as_name() {
-            Ok(Cow::Borrowed(name)) => self.inner.remove(name),
-            Ok(Cow::Owned(name)) => self.inner.remove(&name),
-            Err(_) => None,
-        };
-
-        Removed::new(value)
-    }
-
-    /// Returns the number of single-value headers the map can hold without needing to reallocate.
-    ///
-    /// Since this is a multi-value map, the actual capacity is much larger when considering
-    /// each header name can be associated with an arbitrary number of values. The effect is that
-    /// the size of `len` may be greater than `capacity` since it counts all the values.
-    /// Conversely, [`len_keys`](Self::len_keys) will never be larger than capacity.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::HeaderMap;
-    /// let map = HeaderMap::with_capacity(16);
-    ///
-    /// assert!(map.is_empty());
-    /// assert!(map.capacity() >= 16);
-    /// ```
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    /// Reserves capacity for at least `additional` more headers to be inserted in the map.
-    ///
-    /// The header map may reserve more space to avoid frequent reallocations. Additional capacity
-    /// only considers single-value headers.
-    ///
-    /// # Panics
-    /// Panics if the new allocation size overflows usize.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::HeaderMap;
-    /// let mut map = HeaderMap::with_capacity(2);
-    /// assert!(map.capacity() >= 2);
-    ///
-    /// map.reserve(100);
-    /// assert!(map.capacity() >= 102);
-    ///
-    /// assert!(map.is_empty());
-    /// ```
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    /// An iterator over all name-value pairs.
-    ///
-    /// Names will be yielded for each associated value. So, if a key has 3 associated values, it
-    /// will be yielded 3 times. The iteration order should be considered arbitrary.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// let mut iter = map.iter();
-    /// assert!(iter.next().is_none());
-    ///
-    /// map.append(header::HOST, HeaderValue::from_static("duck.com"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    ///
-    /// let mut iter = map.iter();
-    /// assert!(iter.next().is_some());
-    /// assert!(iter.next().is_some());
-    /// assert!(iter.next().is_some());
-    /// assert!(iter.next().is_none());
-    ///
-    /// let pairs = map.iter().collect::<Vec<_>>();
-    /// assert!(pairs.contains(&(&header::HOST, &HeaderValue::from_static("duck.com"))));
-    /// assert!(pairs.contains(&(&header::SET_COOKIE, &HeaderValue::from_static("one=1"))));
-    /// assert!(pairs.contains(&(&header::SET_COOKIE, &HeaderValue::from_static("two=2"))));
-    /// ```
-    pub fn iter(&self) -> Iter<'_> {
-        Iter::new(self.inner.iter())
-    }
-
-    /// An iterator over all contained header names.
-    ///
-    /// Each name will only be yielded once even if it has multiple associated values. The iteration
-    /// order should be considered arbitrary.
-    ///
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// let mut iter = map.keys();
-    /// assert!(iter.next().is_none());
-    ///
-    /// map.append(header::HOST, HeaderValue::from_static("duck.com"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    ///
-    /// let keys = map.keys().cloned().collect::<Vec<_>>();
-    /// assert_eq!(keys.len(), 2);
-    /// assert!(keys.contains(&header::HOST));
-    /// assert!(keys.contains(&header::SET_COOKIE));
-    /// ```
-    pub fn keys(&self) -> Keys<'_> {
-        Keys(self.inner.keys())
-    }
-
-    /// Clears the map, returning all name-value sets as an iterator.
-    ///
-    /// Header names will only be yielded for the first value in each set. All items that are
-    /// yielded without a name and after an item with a name are associated with that same name.
-    /// The first item will always contain a name.
-    ///
-    /// Keeps the allocated memory for reuse.
-    /// # Examples
-    /// ```
-    /// # use actix_http::http::{header, HeaderMap, HeaderValue};
-    /// let mut map = HeaderMap::new();
-    ///
-    /// let mut iter = map.drain();
-    /// assert!(iter.next().is_none());
-    /// drop(iter);
-    ///
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("one=1"));
-    /// map.append(header::SET_COOKIE, HeaderValue::from_static("two=2"));
-    ///
-    /// let mut iter = map.drain();
-    /// assert_eq!(iter.next().unwrap(), (Some(header::SET_COOKIE), HeaderValue::from_static("one=1")));
-    /// assert_eq!(iter.next().unwrap(), (None, HeaderValue::from_static("two=2")));
-    /// drop(iter);
-    ///
-    /// assert!(map.is_empty());
-    /// ```
-    pub fn drain(&mut self) -> Drain<'_> {
-        Drain::new(self.inner.drain())
-    }
-}
-
-/// Note that this implementation will clone a [HeaderName] for each value.
-impl IntoIterator for HeaderMap {
-    type Item = (HeaderName, HeaderValue);
-    type IntoIter = IntoIter;
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self.inner.into_iter())
-    }
-}
-
-impl<'a> IntoIterator for &'a HeaderMap {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-    type IntoIter = Iter<'a>;
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        Iter::new(self.inner.iter())
-    }
-}
-
-/// Iterator for all values with the same header name.
-///
-/// See [`HeaderMap::get_all`].
-#[derive(Debug)]
-pub struct GetAll<'a> {
-    idx: usize,
-    value: Option<&'a Value>,
-}
-
-impl<'a> GetAll<'a> {
-    fn new(value: Option<&'a Value>) -> Self {
-        Self { idx: 0, value }
-    }
-}
-
-impl<'a> Iterator for GetAll<'a> {
-    type Item = &'a HeaderValue;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let val = self.value?;
-
-        match val.get(self.idx) {
-            Some(val) => {
-                self.idx += 1;
-                Some(val)
-            }
-            None => {
-                // current index is none; remove value to fast-path future next calls
-                self.value = None;
-                None
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.value {
-            Some(val) => (val.len(), Some(val.len())),
-            None => (0, Some(0)),
-        }
-    }
-}
-
-/// Iterator for owned [`HeaderValue`]s with the same associated [`HeaderName`] returned from methods
-/// on [`HeaderMap`] that remove or replace items.
-#[derive(Debug)]
-pub struct Removed {
-    inner: Option<smallvec::IntoIter<[HeaderValue; 4]>>,
-}
-
-impl<'a> Removed {
-    fn new(value: Option<Value>) -> Self {
-        let inner = value.map(|value| value.inner.into_iter());
-        Self { inner }
-    }
-}
-
-impl Iterator for Removed {
-    type Item = HeaderValue;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.as_mut()?.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.inner {
-            Some(ref iter) => iter.size_hint(),
-            None => (0, None),
-        }
-    }
-}
-
-/// Iterator over all [`HeaderName`]s in the map.
-#[derive(Debug)]
-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<Self::Item> {
-        self.0.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
-
-#[derive(Debug)]
-pub struct Iter<'a> {
-    inner: hash_map::Iter<'a, HeaderName, Value>,
-    multi_inner: Option<(&'a HeaderName, &'a SmallVec<[HeaderValue; 4]>)>,
-    multi_idx: usize,
-}
-
-impl<'a> Iter<'a> {
-    fn new(iter: hash_map::Iter<'a, HeaderName, Value>) -> Self {
-        Self {
-            inner: iter,
-            multi_idx: 0,
-            multi_inner: None,
-        }
-    }
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // handle in-progress multi value lists first
-        if let Some((ref name, ref mut vals)) = self.multi_inner {
-            match vals.get(self.multi_idx) {
-                Some(val) => {
-                    self.multi_idx += 1;
-                    return Some((name, val));
-                }
-                None => {
-                    // no more items in value list; reset state
-                    self.multi_idx = 0;
-                    self.multi_inner = None;
-                }
-            }
-        }
-
-        let (name, value) = self.inner.next()?;
-
-        // set up new inner iter and recurse into it
-        self.multi_inner = Some((name, &value.inner));
-        self.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // take inner lower bound
-        // make no attempt at an upper bound
-        (self.inner.size_hint().0, None)
-    }
-}
-
-/// Iterator over drained name-value pairs.
-///
-/// Iterator items are `(Option<HeaderName>, HeaderValue)` to avoid cloning.
-#[derive(Debug)]
-pub struct Drain<'a> {
-    inner: hash_map::Drain<'a, HeaderName, Value>,
-    multi_inner: Option<(Option<HeaderName>, SmallVec<[HeaderValue; 4]>)>,
-    multi_idx: usize,
-}
-
-impl<'a> Drain<'a> {
-    fn new(iter: hash_map::Drain<'a, HeaderName, Value>) -> Self {
-        Self {
-            inner: iter,
-            multi_inner: None,
-            multi_idx: 0,
-        }
-    }
-}
-
-impl<'a> Iterator for Drain<'a> {
-    type Item = (Option<HeaderName>, HeaderValue);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // handle in-progress multi value iterators first
-        if let Some((ref mut name, ref mut vals)) = self.multi_inner {
-            if !vals.is_empty() {
-                // OPTIMIZE: array removals
-                return Some((name.take(), vals.remove(0)));
-            } else {
-                // no more items in value iterator; reset state
-                self.multi_inner = None;
-                self.multi_idx = 0;
-            }
-        }
-
-        let (name, value) = self.inner.next()?;
-
-        // set up new inner iter and recurse into it
-        self.multi_inner = Some((Some(name), value.inner));
-        self.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // take inner lower bound
-        // make no attempt at an upper bound
-        (self.inner.size_hint().0, None)
-    }
-}
-
-/// Iterator over owned name-value pairs.
-///
-/// Implementation necessarily clones header names for each value.
-#[derive(Debug)]
-pub struct IntoIter {
-    inner: hash_map::IntoIter<HeaderName, Value>,
-    multi_inner: Option<(HeaderName, smallvec::IntoIter<[HeaderValue; 4]>)>,
-}
-
-impl IntoIter {
-    fn new(inner: hash_map::IntoIter<HeaderName, Value>) -> Self {
-        Self {
-            inner,
-            multi_inner: None,
-        }
-    }
-}
-
-impl Iterator for IntoIter {
-    type Item = (HeaderName, HeaderValue);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // handle in-progress multi value iterators first
-        if let Some((ref name, ref mut vals)) = self.multi_inner {
-            match vals.next() {
-                Some(val) => {
-                    return Some((name.clone(), val));
-                }
-                None => {
-                    // no more items in value iterator; reset state
-                    self.multi_inner = None;
-                }
-            }
-        }
-
-        let (name, value) = self.inner.next()?;
-
-        // set up new inner iter and recurse into it
-        self.multi_inner = Some((name, value.inner.into_iter()));
-        self.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // take inner lower bound
-        // make no attempt at an upper bound
-        (self.inner.size_hint().0, None)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use http::header;
-
-    use super::*;
-
-    #[test]
-    fn create() {
-        let map = HeaderMap::new();
-        assert_eq!(map.len(), 0);
-        assert_eq!(map.capacity(), 0);
-
-        let map = HeaderMap::with_capacity(16);
-        assert_eq!(map.len(), 0);
-        assert!(map.capacity() >= 16);
-    }
-
-    #[test]
-    fn insert() {
-        let mut map = HeaderMap::new();
-
-        map.insert(header::LOCATION, HeaderValue::from_static("/test"));
-        assert_eq!(map.len(), 1);
-    }
-
-    #[test]
-    fn contains() {
-        let mut map = HeaderMap::new();
-        assert!(!map.contains_key(header::LOCATION));
-
-        map.insert(header::LOCATION, HeaderValue::from_static("/test"));
-        assert!(map.contains_key(header::LOCATION));
-        assert!(map.contains_key("Location"));
-        assert!(map.contains_key("Location".to_owned()));
-        assert!(map.contains_key("location"));
-    }
-
-    #[test]
-    fn entries_iter() {
-        let mut map = HeaderMap::new();
-
-        map.append(header::HOST, HeaderValue::from_static("duck.com"));
-        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
-        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
-
-        let mut iter = map.iter();
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_none());
-
-        let pairs = map.iter().collect::<Vec<_>>();
-        assert!(pairs.contains(&(&header::HOST, &HeaderValue::from_static("duck.com"))));
-        assert!(pairs.contains(&(&header::COOKIE, &HeaderValue::from_static("one=1"))));
-        assert!(pairs.contains(&(&header::COOKIE, &HeaderValue::from_static("two=2"))));
-    }
-
-    #[test]
-    fn drain_iter() {
-        let mut map = HeaderMap::new();
-
-        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
-        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
-
-        let mut vals = vec![];
-        let mut iter = map.drain();
-
-        let (name, val) = iter.next().unwrap();
-        assert_eq!(name, Some(header::COOKIE));
-        vals.push(val);
-
-        let (name, val) = iter.next().unwrap();
-        assert!(name.is_none());
-        vals.push(val);
-
-        assert!(vals.contains(&HeaderValue::from_static("one=1")));
-        assert!(vals.contains(&HeaderValue::from_static("two=2")));
-
-        assert!(iter.next().is_none());
-        drop(iter);
-
-        assert!(map.is_empty());
-    }
-
-    #[test]
-    fn entries_into_iter() {
-        let mut map = HeaderMap::new();
-
-        map.append(header::HOST, HeaderValue::from_static("duck.com"));
-        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
-        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
-
-        let mut iter = map.into_iter();
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn iter_and_into_iter_same_order() {
-        let mut map = HeaderMap::new();
-
-        map.append(header::HOST, HeaderValue::from_static("duck.com"));
-        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
-        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
-
-        let mut iter = map.iter();
-        let mut into_iter = map.clone().into_iter();
-
-        assert_eq!(iter.next().map(owned_pair), into_iter.next());
-        assert_eq!(iter.next().map(owned_pair), into_iter.next());
-        assert_eq!(iter.next().map(owned_pair), into_iter.next());
-        assert_eq!(iter.next().map(owned_pair), into_iter.next());
-    }
-
-    #[test]
-    fn get_all_and_remove_same_order() {
-        let mut map = HeaderMap::new();
-
-        map.append(header::COOKIE, HeaderValue::from_static("one=1"));
-        map.append(header::COOKIE, HeaderValue::from_static("two=2"));
-
-        let mut vals = map.get_all(header::COOKIE);
-        let mut removed = map.clone().remove(header::COOKIE);
-
-        assert_eq!(vals.next(), removed.next().as_ref());
-        assert_eq!(vals.next(), removed.next().as_ref());
-        assert_eq!(vals.next(), removed.next().as_ref());
-    }
-
-    fn owned_pair<'a>(
-        (name, val): (&'a HeaderName, &'a HeaderValue),
-    ) -> (HeaderName, HeaderValue) {
-        (name.clone(), val.clone())
-    }
-}

actix-http/src/header/mod.rs

@@ -1,101 +0,0 @@
-//! Typed HTTP headers, pre-defined `HeaderName`s, traits for parsing and conversion, and other
-//! header utility methods.
-
-use std::fmt;
-
-use bytes::{Bytes, BytesMut};
-use percent_encoding::{AsciiSet, CONTROLS};
-
-pub use http::header::*;
-
-use crate::error::ParseError;
-use crate::httpmessage::HttpMessage;
-
-mod as_name;
-mod into_pair;
-mod into_value;
-mod utils;
-
-mod common;
-pub(crate) mod map;
-mod shared;
-
-pub use self::common::*;
-#[doc(hidden)]
-pub use self::shared::*;
-
-pub use self::as_name::AsHeaderName;
-pub use self::into_pair::IntoHeaderPair;
-pub use self::into_value::IntoHeaderValue;
-#[doc(hidden)]
-pub use self::map::GetAll;
-pub use self::map::HeaderMap;
-pub use self::utils::*;
-
-/// A trait for any object that already represents a valid header field and value.
-pub trait Header: IntoHeaderValue {
-    /// Returns the name of the header field
-    fn name() -> HeaderName;
-
-    /// Parse a header
-    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct Writer {
-    buf: BytesMut,
-}
-
-impl Writer {
-    fn new() -> Writer {
-        Writer::default()
-    }
-
-    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)
-    }
-}
-
-/// Convert `http::HeaderMap` to our `HeaderMap`.
-impl From<http::HeaderMap> for HeaderMap {
-    fn from(mut map: http::HeaderMap) -> HeaderMap {
-        HeaderMap::from_drain(map.drain())
-    }
-}
-
-/// 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'}');

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

@@ -1,193 +0,0 @@
-use std::{fmt, str::FromStr};
-
-use language_tags::LanguageTag;
-
-use crate::header::{Charset, HTTP_VALUE};
-
-// 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`).
-/// - A character sequence representing the actual value (`value`), separated by single quotes.
-///
-/// 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)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[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,101 +0,0 @@
-use std::fmt::{self, Display};
-use std::io::Write;
-use std::str::FromStr;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use bytes::buf::BufMut;
-use bytes::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_value(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/header/utils.rs

@@ -1,63 +0,0 @@
-use std::{fmt, str::FromStr};
-
-use http::HeaderValue;
-
-use crate::{error::ParseError, header::HTTP_VALUE};
-
-/// Reads a comma-delimited raw header into a Vec.
-#[inline]
-pub fn from_comma_delimited<'a, I, T>(all: I) -> Result<Vec<T>, ParseError>
-where
-    I: Iterator<Item = &'a HeaderValue> + 'a,
-    T: FromStr,
-{
-    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)
-}
-
-/// Reads a single string when parsing a header.
-#[inline]
-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)
-}
-
-/// Format an array into a comma-delimited string.
-#[inline]
-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(())
-}
-
-/// Percent encode a sequence of bytes with a character set defined in
-/// <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)
-}

actix-http/src/helpers.rs

@@ -1,158 +0,0 @@
-use std::io;
-
-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);
-
-    // 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(())
-    }
-}
-
-#[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/httpcodes.rs

@@ -1,93 +0,0 @@
-//! Status code based HTTP response builders.
-
-#![allow(non_upper_case_globals)]
-
-use http::StatusCode;
-
-use crate::response::{Response, ResponseBuilder};
-
-macro_rules! static_resp {
-    ($name:ident, $status:expr) => {
-        #[allow(non_snake_case, missing_docs)]
-        pub fn $name() -> ResponseBuilder {
-            ResponseBuilder::new($status)
-        }
-    };
-}
-
-impl Response {
-    static_resp!(Continue, StatusCode::CONTINUE);
-    static_resp!(SwitchingProtocols, StatusCode::SWITCHING_PROTOCOLS);
-    static_resp!(Processing, StatusCode::PROCESSING);
-
-    static_resp!(Ok, StatusCode::OK);
-    static_resp!(Created, StatusCode::CREATED);
-    static_resp!(Accepted, StatusCode::ACCEPTED);
-    static_resp!(
-        NonAuthoritativeInformation,
-        StatusCode::NON_AUTHORITATIVE_INFORMATION
-    );
-
-    static_resp!(NoContent, StatusCode::NO_CONTENT);
-    static_resp!(ResetContent, StatusCode::RESET_CONTENT);
-    static_resp!(PartialContent, StatusCode::PARTIAL_CONTENT);
-    static_resp!(MultiStatus, StatusCode::MULTI_STATUS);
-    static_resp!(AlreadyReported, StatusCode::ALREADY_REPORTED);
-
-    static_resp!(MultipleChoices, StatusCode::MULTIPLE_CHOICES);
-    static_resp!(MovedPermanently, StatusCode::MOVED_PERMANENTLY);
-    static_resp!(Found, StatusCode::FOUND);
-    static_resp!(SeeOther, StatusCode::SEE_OTHER);
-    static_resp!(NotModified, StatusCode::NOT_MODIFIED);
-    static_resp!(UseProxy, StatusCode::USE_PROXY);
-    static_resp!(TemporaryRedirect, StatusCode::TEMPORARY_REDIRECT);
-    static_resp!(PermanentRedirect, StatusCode::PERMANENT_REDIRECT);
-
-    static_resp!(BadRequest, StatusCode::BAD_REQUEST);
-    static_resp!(NotFound, StatusCode::NOT_FOUND);
-    static_resp!(Unauthorized, StatusCode::UNAUTHORIZED);
-    static_resp!(PaymentRequired, StatusCode::PAYMENT_REQUIRED);
-    static_resp!(Forbidden, StatusCode::FORBIDDEN);
-    static_resp!(MethodNotAllowed, StatusCode::METHOD_NOT_ALLOWED);
-    static_resp!(NotAcceptable, StatusCode::NOT_ACCEPTABLE);
-    static_resp!(
-        ProxyAuthenticationRequired,
-        StatusCode::PROXY_AUTHENTICATION_REQUIRED
-    );
-    static_resp!(RequestTimeout, StatusCode::REQUEST_TIMEOUT);
-    static_resp!(Conflict, StatusCode::CONFLICT);
-    static_resp!(Gone, StatusCode::GONE);
-    static_resp!(LengthRequired, StatusCode::LENGTH_REQUIRED);
-    static_resp!(PreconditionFailed, StatusCode::PRECONDITION_FAILED);
-    static_resp!(PreconditionRequired, StatusCode::PRECONDITION_REQUIRED);
-    static_resp!(PayloadTooLarge, StatusCode::PAYLOAD_TOO_LARGE);
-    static_resp!(UriTooLong, StatusCode::URI_TOO_LONG);
-    static_resp!(UnsupportedMediaType, StatusCode::UNSUPPORTED_MEDIA_TYPE);
-    static_resp!(RangeNotSatisfiable, StatusCode::RANGE_NOT_SATISFIABLE);
-    static_resp!(ExpectationFailed, StatusCode::EXPECTATION_FAILED);
-    static_resp!(UnprocessableEntity, StatusCode::UNPROCESSABLE_ENTITY);
-    static_resp!(TooManyRequests, StatusCode::TOO_MANY_REQUESTS);
-
-    static_resp!(InternalServerError, StatusCode::INTERNAL_SERVER_ERROR);
-    static_resp!(NotImplemented, StatusCode::NOT_IMPLEMENTED);
-    static_resp!(BadGateway, StatusCode::BAD_GATEWAY);
-    static_resp!(ServiceUnavailable, StatusCode::SERVICE_UNAVAILABLE);
-    static_resp!(GatewayTimeout, StatusCode::GATEWAY_TIMEOUT);
-    static_resp!(VersionNotSupported, StatusCode::HTTP_VERSION_NOT_SUPPORTED);
-    static_resp!(VariantAlsoNegotiates, StatusCode::VARIANT_ALSO_NEGOTIATES);
-    static_resp!(InsufficientStorage, StatusCode::INSUFFICIENT_STORAGE);
-    static_resp!(LoopDetected, StatusCode::LOOP_DETECTED);
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::body::Body;
-    use crate::response::Response;
-    use http::StatusCode;
-
-    #[test]
-    fn test_build() {
-        let resp = Response::Ok().body(Body::Empty);
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-}

actix-http/src/httpmessage.rs

@@ -1,263 +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>;
-
-    /// Get a header.
-    #[doc(hidden)]
-    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 did not contain a *Content-Type* header, an empty
-    /// string is 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::default()
-            .insert_header(("content-type", "text/plain"))
-            .finish();
-        assert_eq!(req.content_type(), "text/plain");
-        let req = TestRequest::default()
-            .insert_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::default()
-            .insert_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::default()
-            .insert_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::default()
-            .insert_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::default()
-            .insert_header(("content-type", "application/json"))
-            .finish();
-        assert_eq!(UTF_8.name(), req.encoding().unwrap().name());
-
-        let req = TestRequest::default()
-            .insert_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::default()
-            .insert_header(("content-type", "applicatjson"))
-            .finish();
-        assert_eq!(Some(ContentTypeError::ParseError), req.encoding().err());
-
-        let req = TestRequest::default()
-            .insert_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::default()
-            .insert_header((header::TRANSFER_ENCODING, "chunked"))
-            .finish();
-        assert!(req.chunked().unwrap());
-
-        let req = TestRequest::default()
-            .insert_header((
-                header::TRANSFER_ENCODING,
-                Bytes::from_static(b"some va\xadscc\xacas0xsdasdlue"),
-            ))
-            .finish();
-        assert!(req.chunked().is_err());
-    }
-}

actix-http/src/lib.rs

@@ -1,120 +0,0 @@
-//! HTTP primitives for the Actix ecosystem.
-
-#![deny(rust_2018_idioms)]
-#![allow(
-    clippy::type_complexity,
-    clippy::too_many_arguments,
-    clippy::new_without_default,
-    clippy::borrow_interior_mutable_const
-)]
-#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
-#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-mod macros;
-
-pub mod body;
-mod builder;
-pub mod client;
-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;
-
-    /// A collection of HTTP headers and helpers.
-    pub mod header {
-        pub use crate::header::*;
-    }
-    pub use crate::header::ContentEncoding;
-    pub use crate::message::ConnectionType;
-}
-
-/// A major HTTP protocol version.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[non_exhaustive]
-pub enum Protocol {
-    Http1,
-    Http2,
-    Http3,
-}
-
-type ConnectCallback<IO> = dyn Fn(&IO, &mut Extensions);
-
-/// Container for data that extract with ConnectCallback.
-///
-/// # Implementation Details
-/// Uses Option to reduce necessary allocations when merging with request extensions.
-pub(crate) struct OnConnectData(Option<Extensions>);
-
-impl Default for OnConnectData {
-    fn default() -> Self {
-        Self(None)
-    }
-}
-
-impl OnConnectData {
-    /// Construct by calling the on-connect callback with the underlying transport I/O.
-    pub(crate) fn from_io<T>(
-        io: &T,
-        on_connect_ext: Option<&ConnectCallback<T>>,
-    ) -> Self {
-        let ext = on_connect_ext.map(|handler| {
-            let mut extensions = Extensions::new();
-            handler(io, &mut extensions);
-            extensions
-        });
-
-        Self(ext)
-    }
-
-    /// Merge self into given request's extensions.
-    #[inline]
-    pub(crate) fn merge_into(&mut self, req: &mut Request) {
-        if let Some(ref mut ext) = self.0 {
-            req.head.extensions.get_mut().drain_from(ext);
-        }
-    }
-}