prepare actix-files release 0.6.0-beta.12

closes #2389

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [robjtede]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -33,5 +33,5 @@ Please search on the [Actix Web issue tracker](https://github.com/actix/actix-we
 ## Your Environment
 <!--- Include as many relevant details about the environment you experienced the bug in -->
 
-* Rust Version (I.e, output of `rustc -V`):
+- Rust Version (I.e, output of `rustc -V`):
-* Actix Web Version:
+- Actix Web Version:

.github/workflows/ci-master.yml

@@ -0,0 +1,66 @@
+name: CI (master only)
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  ci_feature_powerset_check:
+    name: Verify Feature Combinations
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: check feature combinations
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-all-feature-powerset }
+      
+      - name: check feature combinations
+        uses: actions-rs/cargo@v1
+        with: { command: ci-check-all-feature-powerset-linux }
+
+  coverage:
+    name: coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: Generate Cargo.lock
+        uses: actions-rs/cargo@v1
+        with: { command: generate-lockfile }
+      - name: Cache Dependencies
+        uses: Swatinem/rust-cache@v1.2.0
+
+      - name: Generate coverage file
+        run: |
+          cargo install cargo-tarpaulin --vers "^0.13"
+          cargo tarpaulin --workspace --features=rustls,openssl --out Xml --verbose
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v1
+        with: { file: cobertura.xml }

.github/workflows/ci.yml

@@ -96,68 +96,6 @@ jobs:
           cargo install cargo-cache --version 0.6.3 --no-default-features --features ci-autoclean
           cargo-cache
 
-  ci_feature_powerset_check:
-    name: Verify Feature Combinations
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.2.0
-
-      - name: Install cargo-hack
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-hack
-
-      - name: check feature combinations
-        uses: actions-rs/cargo@v1
-        with: { command: ci-check-all-feature-powerset }
-      
-      - name: check feature combinations
-        uses: actions-rs/cargo@v1
-        with: { command: ci-check-all-feature-powerset-linux }
-
-  coverage:
-    name: coverage
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with: { command: generate-lockfile }
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.2.0
-
-      - name: Generate coverage file
-        if: github.ref == 'refs/heads/master'
-        run: |
-          cargo install cargo-tarpaulin --vers "^0.13"
-          cargo tarpaulin --workspace --features=rustls,openssl --out Xml --verbose
-      - name: Upload to Codecov
-        if: github.ref == 'refs/heads/master'
-        uses: codecov/codecov-action@v1
-        with: { file: cobertura.xml }
-
   rustdoc:
     name: doc tests
     runs-on: ubuntu-latest

CODE_OF_CONDUCT.md

@@ -8,19 +8,19 @@ In the interest of fostering an open and welcoming environment, we as contributo
 
 Examples of behavior that contributes to creating a positive environment include:
 
-* Using welcoming and inclusive language
+- Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
+- Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
+- Gracefully accepting constructive criticism
-* Focusing on what is best for the community
+- Focusing on what is best for the community
-* Showing empathy towards other community members
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
+- Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
+- Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.14"
+version = "4.0.0-beta.17"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 keywords = ["actix", "http", "web", "framework", "async"]
@@ -72,13 +72,13 @@ experimental-io-uring = ["actix-server/io-uring"]
 actix-codec = "0.4.1"
 actix-macros = "0.2.3"
 actix-rt = "2.3"
-actix-server = "2.0.0-rc.1"
+actix-server = "2.0.0-rc.2"
 actix-service = "2.0.0"
 actix-utils = "3.0.0"
-actix-tls = { version = "3.0.0-rc.1", default-features = false, optional = true }
+actix-tls = { version = "3.0.0", default-features = false, optional = true }
 
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
-actix-router = "0.5.0-beta.2"
+actix-router = "0.5.0-beta.3"
 actix-web-codegen = "0.5.0-beta.6"
 
 ahash = "0.7"
@@ -86,11 +86,10 @@ bytes = "1"
 cfg-if = "1"
 cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
-either = "1.5.3"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
-itoa = "0.4"
+itoa = "1"
 language-tags = "0.3"
 once_cell = "1.5"
 log = "0.4"
@@ -107,8 +106,8 @@ time = { version = "0.3", default-features = false, features = ["formatting"] }
 url = "2.1"
 
 [dev-dependencies]
-actix-test = { version = "0.1.0-beta.8", features = ["openssl", "rustls"] }
+actix-test = { version = "0.1.0-beta.10", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.13", features = ["openssl"] }
+awc = { version = "3.0.0-beta.16", features = ["openssl"] }
 
 brotli2 = "0.3.2"
 criterion = { version = "0.3", features = ["html_reports"] }

MIGRATION.md

@@ -1,6 +1,6 @@
 ## Unreleased
 
-* The default `NormalizePath` behavior now strips trailing slashes by default. This was
+- The default `NormalizePath` behavior now strips trailing slashes by default. This was
   previously documented to be the case in v3 but the behavior now matches. The effect is that
   routes defined with trailing slashes will become inaccessible when
   using `NormalizePath::default()`. As such, calling `NormalizePath::default()` will log a warning.
@@ -11,9 +11,9 @@
 
   Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
 
-* The `type Config` of `FromRequest` was removed.
+- The `type Config` of `FromRequest` was removed.
 
-* Feature flag `compress` has been split into its supported algorithm (brotli, gzip, zstd).
+- Feature flag `compress` has been split into its supported algorithm (brotli, gzip, zstd).
   By default all compression algorithms are enabled.
   To select algorithm you want to include with `middleware::Compress` use following flags:
   - `compress-brotli`
@@ -28,30 +28,30 @@
 
 ## 3.0.0
 
-* The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
+- 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:
+- 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
+- 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
+- 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 
+- 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.
+- 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
+- `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
+- 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
@@ -71,35 +71,35 @@
   }
   ```
 
-* `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
+- `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::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
 
-* `HttpServer::maxconnrate` is renamed to the more expressive `HttpServer::max_connection_rate`.
+- `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
+- `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`.
+- `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()`
+- 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()`
+- 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
+- `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
+- `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
   http response.
 
-* Feature `rust-tls` renamed to `rustls`
+- Feature `rust-tls` renamed to `rustls`
 
   instead of
 
@@ -113,7 +113,7 @@
     actix-web = { version = "2.0.0", features = ["rustls"] }
     ```
 
-* Feature `ssl` renamed to `openssl`
+- Feature `ssl` renamed to `openssl`
 
   instead of
 
@@ -126,11 +126,11 @@
     ```rust
     actix-web = { version = "2.0.0", features = ["openssl"] }
     ```
-* `Cors` builder now requires that you call `.finish()` to construct the middleware
+- `Cors` builder now requires that you call `.finish()` to construct the middleware
 
 ## 1.0.1
 
-* Cors middleware has been moved to `actix-cors` crate
+- Cors middleware has been moved to `actix-cors` crate
 
   instead of
 
@@ -144,7 +144,7 @@
   use actix_cors::Cors;
   ```
 
-* Identity middleware has been moved to `actix-identity` crate
+- Identity middleware has been moved to `actix-identity` crate
 
   instead of
 
@@ -161,7 +161,7 @@
 
 ## 1.0.0
 
-* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
+- Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
 
   instead of
 
@@ -219,7 +219,7 @@
   )
   ```
 
-* Resource registration. 1.0 version uses generalized resource
+- Resource registration. 1.0 version uses generalized resource
   registration via `.service()` method.
 
   instead of
@@ -239,7 +239,7 @@
             .route(web::post().to(post_handler))
   ```
 
-* Scope registration.
+- Scope registration.
 
   instead of
 
@@ -263,7 +263,7 @@
       );
   ```
 
-* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
+- `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
 
   instead of
 
@@ -277,7 +277,7 @@
     App.new().service(web::resource("/welcome").to(welcome))
   ```
 
-* Passing arguments to handler with extractors, multiple arguments are allowed
+- Passing arguments to handler with extractors, multiple arguments are allowed
 
   instead of
 
@@ -295,7 +295,7 @@
   }
   ```
 
-* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
+- `.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.
 
@@ -311,7 +311,7 @@
     App.new().service(web::resource("/welcome").to(welcome))
   ```
 
-* `HttpRequest` does not provide access to request's payload stream.
+- `HttpRequest` does not provide access to request's payload stream.
 
   instead of
 
@@ -341,7 +341,7 @@
   }
   ```
 
-* `State` is now `Data`.  You register Data during the App initialization process
+- `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.
 
@@ -377,7 +377,7 @@
   ```
 
 
-* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
+- AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
 
   instead of
 
@@ -393,7 +393,7 @@
   .. simply omit AsyncResponder and the corresponding responder() finish method
 
 
-* Middleware
+- Middleware
 
   instead of
 
@@ -410,7 +410,7 @@
            .route("/index.html", web::get().to(index));
   ```
 
-* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
+- `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
   method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
 
   instead of
@@ -432,9 +432,9 @@
   }
   ```
 
-* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
+- `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.
+- StaticFiles and NamedFile have been moved to a separate crate.
 
   instead of `use actix_web::fs::StaticFile`
 
@@ -444,20 +444,20 @@
 
   use `use actix_files::NamedFile`
 
-* Multipart has been moved to a separate crate.
+- 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.
+- Response compression is not enabled by default.
   To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
 
-* Session middleware moved to actix-session crate
+- Session middleware moved to actix-session crate
 
-* Actors support have been moved to `actix-web-actors` crate
+- Actors support have been moved to `actix-web-actors` crate
 
-* Custom Error
+- 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. 
 
@@ -471,7 +471,7 @@
 
 ## 0.7.15
 
-* The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
+- The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
   your routes, you should use `%20`.
 
   instead of
@@ -496,18 +496,18 @@
     }
     ```
 
-* If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
+- If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
 
 
 ## 0.7.4
 
-* `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
+- `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
   even for handler with one parameter.
 
 
 ## 0.7
 
-* `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
+- `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
   use `HttpMessage::payload()` method.
 
   instead of
@@ -533,10 +533,10 @@
     }
     ```
 
-* [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
+- [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
   trait uses `&HttpRequest` instead of `&mut HttpRequest`.
 
-* Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
+- Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
 
     instead of
 
@@ -550,17 +550,17 @@
     fn index((query, json): (Query<..>, Json<MyStruct)) -> impl Responder {}
     ```
 
-* `Handler::handle()` uses `&self` instead of `&mut self`
+- `Handler::handle()` uses `&self` instead of `&mut self`
 
-* `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
+- `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
+- Renamed `client::ClientConnectorError::Connector` to
   `client::ClientConnectorError::Resolver`
 
-* `Route::with()` does not return `ExtractorConfig`, to configure
+- `Route::with()` does not return `ExtractorConfig`, to configure
   extractor use `Route::with_config()`
 
     instead of
@@ -589,26 +589,26 @@
     }
     ```
 
-* `Route::with_async()` does not return `ExtractorConfig`, to configure
+- `Route::with_async()` does not return `ExtractorConfig`, to configure
   extractor use `Route::with_async_config()`
 
 
 ## 0.6
 
-* `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
+- `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`
 
-* `ws::Message::Close` now includes optional close reason.
+- `ws::Message::Close` now includes optional close reason.
   `ws::CloseCode::Status` and `ws::CloseCode::Empty` have been removed.
 
-* `HttpServer::threads()` renamed to `HttpServer::workers()`.
+- `HttpServer::threads()` renamed to `HttpServer::workers()`.
 
-* `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
+- `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
   Use `HttpServer::bind_ssl()` and `HttpServer::bind_tls()` instead.
 
-* `HttpRequest::extensions()` returns read only reference to the request's Extension
+- `HttpRequest::extensions()` 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,
@@ -619,15 +619,15 @@
    `use actix_web::middleware::session{CookieSessionBackend, CookieSessionError,
         RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};`
 
-* `FromRequest::from_request()` accepts mutable reference to a request
+- `FromRequest::from_request()` accepts mutable reference to a request
 
-* `FromRequest::Result` has to implement `Into<Reply<Self>>`
+- `FromRequest::Result` has to implement `Into<Reply<Self>>`
 
-* [`Responder::respond_to()`](
+- [`Responder::respond_to()`](
   https://actix.rs/actix-web/actix_web/trait.Responder.html#tymethod.respond_to)
   is generic over `S`
 
-*  Use `Query` extractor instead of HttpRequest::query()`.
+-  Use `Query` extractor instead of HttpRequest::query()`.
 
    ```rust
    fn index(q: Query<HashMap<String, String>>) -> Result<..> {
@@ -641,37 +641,37 @@
    let q = Query::<HashMap<String, String>>::extract(req);
    ```
 
-* Websocket operations are implemented as `WsWriter` trait.
+- Websocket operations are implemented as `WsWriter` trait.
   you need to use `use actix_web::ws::WsWriter`
 
 
 ## 0.5
 
-* `HttpResponseBuilder::body()`, `.finish()`, `.json()`
+- `HttpResponseBuilder::body()`, `.finish()`, `.json()`
    methods return `HttpResponse` instead of `Result<HttpResponse>`
 
-* `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
+- `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
    moved to `actix_web::http` module
 
-* `actix_web::header` moved to `actix_web::http::header`
+- `actix_web::header` moved to `actix_web::http::header`
 
-* `NormalizePath` moved to `actix_web::http` module
+- `NormalizePath` moved to `actix_web::http` module
 
-* `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
+- `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
   shortcut for `actix_web::server::HttpServer::new()`
 
-* `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
+- `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
 
-* `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
+- `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
 
-* `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
+- `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
 
-* `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
+- `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
    functions should be used instead
 
-* `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
+- `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
   instead of `Result<_, http::Error>`
 
-* `Application` renamed to a `App`
+- `Application` renamed to a `App`
 
-* `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`
+- `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`

README.md

@@ -6,10 +6,10 @@
   <p>
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.14)](https://docs.rs/actix-web/4.0.0-beta.14)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.17)](https://docs.rs/actix-web/4.0.0-beta.17)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.14/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.14)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.17/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.17)
 <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) 
@@ -21,25 +21,25 @@
 
 ## Features
 
-* Supports *HTTP/1.x* and *HTTP/2*
+- Supports *HTTP/1.x* and *HTTP/2*
-* Streaming and pipelining
+- Streaming and pipelining
-* Keep-alive and slow requests handling
+- Keep-alive and slow requests handling
-* Client/server [WebSockets](https://actix.rs/docs/websockets/) support
+- Client/server [WebSockets](https://actix.rs/docs/websockets/) support
-* Transparent content compression/decompression (br, gzip, deflate, zstd)
+- Transparent content compression/decompression (br, gzip, deflate, zstd)
-* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
+- Powerful [request routing](https://actix.rs/docs/url-dispatch/)
-* Multipart streams
+- Multipart streams
-* Static assets
+- Static assets
-* SSL support using OpenSSL or Rustls
+- SSL support using OpenSSL or Rustls
-* Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
+- Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://docs.rs/awc/)
+- Includes an async [HTTP client](https://docs.rs/awc/)
-* Runs on stable Rust 1.52+
+- Runs on stable Rust 1.52+
 
 ## Documentation
 
-* [Website & User Guide](https://actix.rs)
+- [Website & User Guide](https://actix.rs)
-* [Examples Repository](https://github.com/actix/examples)
+- [Examples Repository](https://github.com/actix/examples)
-* [API Documentation](https://docs.rs/actix-web)
+- [API Documentation](https://docs.rs/actix-web)
-* [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)
+- [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)
 
 ## Example
 
@@ -71,18 +71,18 @@ async fn main() -> std::io::Result<()> {
 
 ### More examples
 
-* [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
+- [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
-* [Application State](https://github.com/actix/examples/tree/master/basics/state/)
+- [Application State](https://github.com/actix/examples/tree/master/basics/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
+- [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
+- [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
+- [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
+- [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
+- [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
+- [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
+- [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
+- [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
+- [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
+- [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.
@@ -96,9 +96,9 @@ One of the fastest web frameworks available according to the
 
 This project is licensed under either of
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+- 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
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
   [http://opensource.org/licenses/MIT])
 
 at your option.

actix-files/CHANGES.md

@@ -3,43 +3,51 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.6.0-beta.12 - 2021-12-29
+* No significant changes since `0.6.0-beta.11`.
+
+
+## 0.6.0-beta.11 - 2021-12-27
+* No significant changes since `0.6.0-beta.10`.
+
+
 ## 0.6.0-beta.10 - 2021-12-11
-* No significant changes since `0.6.0-beta.9`.
+- No significant changes since `0.6.0-beta.9`.
 
 
 ## 0.6.0-beta.9 - 2021-11-22
-* Add crate feature `experimental-io-uring`, enabling async file I/O to be utilized. This feature is only available on Linux OSes with recent kernel versions. This feature is semver-exempt. [#2408]
+- Add crate feature `experimental-io-uring`, enabling async file I/O to be utilized. This feature is only available on Linux OSes with recent kernel versions. This feature is semver-exempt. [#2408]
-* Add `NamedFile::open_async`. [#2408]
+- Add `NamedFile::open_async`. [#2408]
-* Fix 304 Not Modified responses to omit the Content-Length header, as per the spec. [#2453]
+- Fix 304 Not Modified responses to omit the Content-Length header, as per the spec. [#2453]
-* The `Responder` impl for `NamedFile` now has a boxed future associated type. [#2408]
+- The `Responder` impl for `NamedFile` now has a boxed future associated type. [#2408]
-* The `Service` impl for `NamedFileService` now has a boxed future associated type. [#2408]
+- The `Service` impl for `NamedFileService` now has a boxed future associated type. [#2408]
-* Add `impl Clone` for `FilesService`. [#2408]
+- Add `impl Clone` for `FilesService`. [#2408]
 
 [#2408]: https://github.com/actix/actix-web/pull/2408
 [#2453]: https://github.com/actix/actix-web/pull/2453
 
 
 ## 0.6.0-beta.8 - 2021-10-20
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 
 ## 0.6.0-beta.7 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.6.0-beta.6 - 2021-06-26
-* Added `Files::path_filter()`. [#2274]
+- Added `Files::path_filter()`. [#2274]
-* `Files::show_files_listing()` can now be used with `Files::index_file()` to show files listing as a fallback when the index file is not found. [#2228]
+- `Files::show_files_listing()` can now be used with `Files::index_file()` to show files listing as a fallback when the index file is not found. [#2228]
 
 [#2274]: https://github.com/actix/actix-web/pull/2274
 [#2228]: https://github.com/actix/actix-web/pull/2228
 
 
 ## 0.6.0-beta.5 - 2021-06-17
-* `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
+- `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
-* For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
+- For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
-* `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
+- `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
-* `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
+- `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
 
 [#2135]: https://github.com/actix/actix-web/pull/2135
 [#2156]: https://github.com/actix/actix-web/pull/2156
@@ -48,130 +56,130 @@
 
 
 ## 0.6.0-beta.4 - 2021-04-02
-* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
+- Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
 
 [#2046]: https://github.com/actix/actix-web/pull/2046
 
 
 ## 0.6.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 0.6.0-beta.2 - 2021-02-10
-* Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
+- Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
-* Replace `v_htmlescape` with `askama_escape`. [#1953]
+- 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.
+- `HttpRange::parse` now has its own error type.
-* Update `bytes` to `1.0`. [#1813]
+- 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]
+- 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.
+- 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]
+- 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.
+- No significant changes from 0.3.0-beta.1.
 
 
 ## 0.3.0-beta.1 - 2020-07-15
-* Update `v_htmlescape` to 0.10
+- Update `v_htmlescape` to 0.10
-* Update `actix-web` and `actix-http` dependencies to beta.1
+- 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
+- Update `actix-web` and `actix-http` dependencies to alpha
-* Fix some typos in the docs
+- Fix some typos in the docs
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
-* Support sending Content-Length when Content-Range is specified [#1384]
+- 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
+- Use the same format for file URLs regardless of platforms
 
 
 ## 0.2.0 - 2019-12-20
-* Fix BodyEncoding trait import #1220
+- Fix BodyEncoding trait import #1220
 
 
 ## 0.2.0-alpha.1 - 2019-12-07
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 
 ## 0.1.7 - 2019-11-06
-* Add an additional `filename*` param in the `Content-Disposition` header of
+- 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
+- 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 `mime_guess` crate version to 2.0.1
-* Bump up `percent-encoding` crate version to 2.1
+- Bump up `percent-encoding` crate version to 2.1
-* Allow user defined request guards for `Files` #1113
+- Allow user defined request guards for `Files` #1113
 
 
 ## 0.1.4 - 2019-07-20
-* Allow to disable `Content-Disposition` header #686
+- 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
+- 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
+- Content-Length is 0 for NamedFile HEAD request #914
-* Fix ring dependency from actix-web default features for #741
+- 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
+- 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
+- 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
+- Update actix-web to beta.4
 
 
 ## 0.1.0-beta.1 - 2019-04-20
-* Update actix-web to beta.1
+- Update actix-web to beta.1
 
 
 ## 0.1.0-alpha.6 - 2019-04-14
-* Update actix-web to alpha6
+- Update actix-web to alpha6
 
 
 ## 0.1.0-alpha.4 - 2019-04-08
-* Update actix-web to alpha4
+- Update actix-web to alpha4
 
 
 ## 0.1.0-alpha.2 - 2019-04-02
-* Add default handler support
+- Add default handler support
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.10"
+version = "0.6.0-beta.12"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "fakeshadow <24548779@qq.com>",
@@ -22,10 +22,10 @@ path = "src/lib.rs"
 experimental-io-uring = ["actix-web/experimental-io-uring", "tokio-uring"]
 
 [dependencies]
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
 actix-service = "2"
 actix-utils = "3"
-actix-web = { version = "4.0.0-beta.14", default-features = false }
+actix-web = { version = "4.0.0-beta.17", default-features = false }
 
 askama_escape = "0.10"
 bitflags = "1"
@@ -43,5 +43,5 @@ tokio-uring = { version = "0.1", optional = true }
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-test = "0.1.0-beta.8"
+actix-test = "0.1.0-beta.10"
-actix-web = "4.0.0-beta.14"
+actix-web = "4.0.0-beta.17"

actix-files/README.md

@@ -3,11 +3,11 @@
 > Static file serving for Actix Web
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.10)](https://docs.rs/actix-files/0.6.0-beta.10)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.12)](https://docs.rs/actix-files/0.6.0-beta.12)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.10/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.10)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.12/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.12)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-files/src/named.rs

@@ -2,14 +2,10 @@ use std::{
     fmt,
     fs::Metadata,
     io,
-    ops::{Deref, DerefMut},
     path::{Path, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
 
-#[cfg(unix)]
-use std::os::unix::fs::MetadataExt;
-
 use actix_service::{Service, ServiceFactory};
 use actix_web::{
     body::{self, BoxBody, SizedStream},
@@ -27,6 +23,7 @@ use actix_web::{
     Error, HttpMessage, HttpRequest, HttpResponse, Responder,
 };
 use bitflags::bitflags;
+use derive_more::{Deref, DerefMut};
 use futures_core::future::LocalBoxFuture;
 use mime_guess::from_path;
 
@@ -71,8 +68,11 @@ impl Default for Flags {
 ///     NamedFile::open_async("./static/index.html").await
 /// }
 /// ```
+#[derive(Deref, DerefMut)]
 pub struct NamedFile {
     path: PathBuf,
+    #[deref]
+    #[deref_mut]
     file: File,
     modified: Option<SystemTime>,
     pub(crate) md: Metadata,
@@ -364,14 +364,18 @@ impl NamedFile {
         self
     }
 
+    /// Creates a etag in a format is similar to Apache's.
     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)]
                 {
+                    #[cfg(unix)]
+                    use std::os::unix::fs::MetadataExt as _;
+
                     self.md.ino()
                 }
+
                 #[cfg(not(unix))]
                 {
                     0
@@ -472,17 +476,17 @@ impl NamedFile {
             false
         };
 
-        let mut resp = HttpResponse::build(self.status_code);
+        let mut res = 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()));
+            res.insert_header((header::CONTENT_TYPE, ct.to_string()));
         } else {
-            resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
+            res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
         }
 
         if self.flags.contains(Flags::CONTENT_DISPOSITION) {
-            resp.insert_header((
+            res.insert_header((
                 header::CONTENT_DISPOSITION,
                 self.content_disposition.to_string(),
             ));
@@ -490,18 +494,18 @@ impl NamedFile {
 
         // default compressing
         if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
+            res.encoding(current_encoding);
         }
 
         if let Some(lm) = last_modified {
-            resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
+            res.insert_header((header::LAST_MODIFIED, lm.to_string()));
         }
 
         if let Some(etag) = etag {
-            resp.insert_header((header::ETAG, etag.to_string()));
+            res.insert_header((header::ETAG, etag.to_string()));
         }
 
-        resp.insert_header((header::ACCEPT_RANGES, "bytes"));
+        res.insert_header((header::ACCEPT_RANGES, "bytes"));
 
         let mut length = self.md.len();
         let mut offset = 0;
@@ -513,24 +517,24 @@ impl NamedFile {
                     length = ranges[0].length;
                     offset = ranges[0].start;
 
-                    resp.encoding(ContentEncoding::Identity);
+                    res.encoding(ContentEncoding::Identity);
-                    resp.insert_header((
+                    res.insert_header((
                         header::CONTENT_RANGE,
                         format!("bytes {}-{}/{}", offset, offset + length - 1, self.md.len()),
                     ));
                 } else {
-                    resp.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
+                    res.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
-                    return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
+                    return res.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
                 };
             } else {
-                return resp.status(StatusCode::BAD_REQUEST).finish();
+                return res.status(StatusCode::BAD_REQUEST).finish();
             };
         };
 
         if precondition_failed {
-            return resp.status(StatusCode::PRECONDITION_FAILED).finish();
+            return res.status(StatusCode::PRECONDITION_FAILED).finish();
         } else if not_modified {
-            return resp
+            return res
                 .status(StatusCode::NOT_MODIFIED)
                 .body(body::None::new())
                 .map_into_boxed_body();
@@ -539,10 +543,10 @@ impl NamedFile {
         let reader = chunked::new_chunked_read(length, offset, self.file);
 
         if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
+            res.status(StatusCode::PARTIAL_CONTENT);
         }
 
-        resp.body(SizedStream::new(length, reader))
+        res.body(SizedStream::new(length, reader))
     }
 }
 
@@ -586,20 +590,6 @@ fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
     }
 }
 
-impl Deref for NamedFile {
-    type Target = File;
-
-    fn deref(&self) -> &Self::Target {
-        &self.file
-    }
-}
-
-impl DerefMut for NamedFile {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.file
-    }
-}
-
 impl Responder for NamedFile {
     type Body = BoxBody;
 

actix-files/src/service.rs

@@ -1,8 +1,8 @@
 use std::{fmt, io, ops::Deref, path::PathBuf, rc::Rc};
 
-use actix_service::Service;
 use actix_web::{
-    dev::{ServiceRequest, ServiceResponse},
+    body::BoxBody,
+    dev::{Service, ServiceRequest, ServiceResponse},
     error::Error,
     guard::Guard,
     http::{header, Method},
@@ -94,7 +94,7 @@ impl fmt::Debug for FilesService {
 }
 
 impl Service<ServiceRequest> for FilesService {
-    type Response = ServiceResponse;
+    type Response = ServiceResponse<BoxBody>;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -103,7 +103,7 @@ impl Service<ServiceRequest> for FilesService {
     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())
+            (**guard).check(&req.guard_ctx())
         } else {
             // default behavior
             matches!(*req.method(), Method::HEAD | Method::GET)

actix-http-test/CHANGES.md

@@ -3,126 +3,132 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 3.0.0-beta.10 - 2021-12-27
+- Update `actix-server` to `2.0.0-rc.2`. [#2550]
+
+[#2550]: https://github.com/actix/actix-web/pull/2550
+
+
 ## 3.0.0-beta.9 - 2021-12-11
-* No significant changes since `3.0.0-beta.8`.
+- No significant changes since `3.0.0-beta.8`.
 
 
 ## 3.0.0-beta.8 - 2021-11-30
-* Update `actix-tls` to `3.0.0-rc.1`. [#2474]
+- Update `actix-tls` to `3.0.0-rc.1`. [#2474]
 
 [#2474]: https://github.com/actix/actix-web/pull/2474
 
 
 ## 3.0.0-beta.7 - 2021-11-22
-* Fix compatibility with experimental `io-uring` feature of `actix-rt`. [#2408]
+- Fix compatibility with experimental `io-uring` feature of `actix-rt`. [#2408]
 
 [#2408]: https://github.com/actix/actix-web/pull/2408
 
 
 ## 3.0.0-beta.6 - 2021-11-15
-* `TestServer::stop` is now async and will wait for the server and system to shutdown. [#2442]
+- `TestServer::stop` is now async and will wait for the server and system to shutdown. [#2442]
-* Update `actix-server` to `2.0.0-beta.9`. [#2442]
+- Update `actix-server` to `2.0.0-beta.9`. [#2442]
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 [#2442]: https://github.com/actix/actix-web/pull/2442
 
 
 ## 3.0.0-beta.5 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 3.0.0-beta.4 - 2021-04-02
-* Added `TestServer::client_headers` method. [#2097]
+- Added `TestServer::client_headers` method. [#2097]
 
 [#2097]: https://github.com/actix/actix-web/pull/2097
 
 
 ## 3.0.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.2 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.1 - 2021-01-07
-* Update `bytes` to `1.0`. [#1813]
+- 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]
+- Add ability to set address for `TestServer`. [#1645]
-* Upgrade `base64` to `0.13`.
+- Upgrade `base64` to `0.13`.
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
+- 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.
+- Update actix-codec and actix-utils dependencies.
 
 
 ## 2.0.0-alpha.1 - 2020-05-23
-* Update the `time` dependency to 0.2.7
+- Update the `time` dependency to 0.2.7
-* Update `actix-connect` dependency to 2.0.0-alpha.2
+- Update `actix-connect` dependency to 2.0.0-alpha.2
-* Make `test_server` `async` fn.
+- Make `test_server` `async` fn.
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
-* Replace deprecated `net2` crate with `socket2`
+- Replace deprecated `net2` crate with `socket2`
-* Update `base64` dependency to 0.12
+- Update `base64` dependency to 0.12
-* Update `env_logger` dependency to 0.7
+- Update `env_logger` dependency to 0.7
 
 ## 1.0.0 - 2019-12-13
-* Replaced `TestServer::start()` with `test_server()`
+- Replaced `TestServer::start()` with `test_server()`
 
 
 ## 1.0.0-alpha.3 - 2019-12-07
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 
 ## 0.2.5 - 2019-09-17
-* Update serde_urlencoded to "0.6.1"
+- Update serde_urlencoded to "0.6.1"
-* Increase TestServerRuntime timeouts from 500ms to 3000ms
+- Increase TestServerRuntime timeouts from 500ms to 3000ms
-* Do not override current `System`
+- Do not override current `System`
 
 
 ## 0.2.4 - 2019-07-18
-* Update actix-server to 0.6
+- Update actix-server to 0.6
 
 
 ## 0.2.3 - 2019-07-16
-* Add `delete`, `options`, `patch` methods to `TestServerRunner`
+- Add `delete`, `options`, `patch` methods to `TestServerRunner`
 
 
 ## 0.2.2 - 2019-06-16
-* Add .put() and .sput() methods
+- Add .put() and .sput() methods
 
 
 ## 0.2.1 - 2019-06-05
-* Add license files
+- Add license files
 
 
 ## 0.2.0 - 2019-05-12
-* Update awc and actix-http deps
+- Update awc and actix-http deps
 
 
 ## 0.1.1 - 2019-04-24
-* Always make new connection for http client
+- Always make new connection for http client
 
 
 ## 0.1.0 - 2019-04-16
-* No changes
+- No changes
 
 
 ## 0.1.0-alpha.3 - 2019-04-02
-* Request functions accept path #743
+- Request functions accept path #743
 
 
 ## 0.1.0-alpha.2 - 2019-03-29
-* Added TestServerRuntime::load_body() method
+- Added TestServerRuntime::load_body() method
-* Update actix-http and awc libraries
+- Update actix-http and awc libraries
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-http-test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "3.0.0-beta.9"
+version = "3.0.0-beta.10"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Various helpers for Actix applications to use during testing"
 keywords = ["http", "web", "framework", "async", "futures"]
@@ -31,11 +31,11 @@ openssl = ["tls-openssl", "awc/openssl"]
 [dependencies]
 actix-service = "2.0.0"
 actix-codec = "0.4.1"
-actix-tls = "3.0.0-rc.1"
+actix-tls = "3.0.0"
 actix-utils = "3.0.0"
 actix-rt = "2.2"
-actix-server = "2.0.0-rc.1"
+actix-server = "2.0.0-rc.2"
-awc = { version = "3.0.0-beta.13", default-features = false }
+awc = { version = "3.0.0-beta.16", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
@@ -48,8 +48,8 @@ serde_json = "1.0"
 slab = "0.4"
 serde_urlencoded = "0.7"
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
-tokio = { version = "1.2", features = ["sync"] }
+tokio = { version = "1.8.4", features = ["sync"] }
 
 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.14", default-features = false, features = ["cookies"] }
+actix-web = { version = "4.0.0-beta.17", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"

actix-http-test/README.md

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

actix-http-test/src/lib.rs

@@ -12,7 +12,7 @@ use std::{net, thread, time::Duration};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::{net::TcpStream, System};
-use actix_server::{Server, ServiceFactory};
+use actix_server::{Server, ServerServiceFactory};
 use awc::{
     error::PayloadError, http::header::HeaderMap, ws, Client, ClientRequest, ClientResponse,
     Connector,
@@ -51,13 +51,13 @@ use tokio::sync::mpsc;
 ///     assert!(response.status().is_success());
 /// }
 /// ```
-pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+pub async fn test_server<F: ServerServiceFactory<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 an existing address binding.
-pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
+pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
     tcp: net::TcpListener,
     factory: F,
 ) -> TestServer {
@@ -107,7 +107,7 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
             Connector::new()
                 .conn_lifetime(Duration::from_secs(0))
                 .timeout(Duration::from_millis(30000))
-                .ssl(builder.build())
+                .openssl(builder.build())
         };
 
         #[cfg(not(feature = "openssl"))]

actix-http/CHANGES.md

@@ -3,44 +3,77 @@
 ## Unreleased - 2021-xx-xx
 
 
-## 3.0.0-beta.15 - 2021-12-11
+## 3.0.0-beta.17 - 2021-12-27
-### Added
+### Changes
-* Add timeout for canceling HTTP/2 server side connection handshake. Default to 5 seconds. [#2483]
+- `HeaderMap::get_all` now returns a `std::slice::Iter`. [#2527]
-* HTTP/2 handshake timeout can be configured with `ServiceConfig::client_timeout`. [#2483]
+- `Payload` inner fields are now named. [#2545]
-* `Response::map_into_boxed_body`. [#2468]
+- `impl Stream` for `Payload` no longer requires the `Stream` variant be `Unpin`. [#2545]
-* `body::EitherBody` enum. [#2468]
+- `impl Future` for `h1::SendResponse` no longer requires the body type be `Unpin`. [#2545]
-* `body::None` struct. [#2468]
+- `impl Stream` for `encoding::Decoder` no longer requires the stream type be `Unpin`. [#2545]
-* Impl `MessageBody` for `bytestring::ByteString`. [#2468]
+- Rename `PayloadStream` to `BoxedPayloadStream`. [#2545]
-* `impl Clone for ws::HandshakeError`. [#2468]
-* `#[must_use]` for `ws::Codec` to prevent subtle bugs. [#1920]
-* `impl Default ` for `ws::Codec`. [#1920]
-* `header::QualityItem::{max, min}`. [#2486]
-* `header::Quality::{MAX, MIN}`. [#2486]
-* `impl Display` for `header::Quality`. [#2486]
-* Connection data set through the `on_connect_ext` callbacks is now accessible only from the new `Request::conn_data()` method. [#2491]
-* `Request::take_conn_data()`. [#2491]
-* `Request::take_req_data()`. [#2487]
-* `impl Clone` for `RequestHead`. [#2487]
-* New methods on `MessageBody` trait, `is_complete_body` and `take_complete_body`, both with default implementations, for optimisations on body types that are done in exactly one poll/chunk. [#2497]
-
-### Changed
-* Rename `body::BoxBody::{from_body => new}`. [#2468]
-* Body type for `Responses` returned from `Response::{new, ok, etc...}` is now `BoxBody`. [#2468]
-* The `Error` associated type on `MessageBody` type now requires `impl Error` (or similar). [#2468]
-* Error types using in service builders now require `Into<Response<BoxBody>>`. [#2468]
-* `From` implementations on error types now return a `Response<BoxBody>`. [#2468]
-* `ResponseBuilder::body(B)` now returns `Response<EitherBody<B>>`. [#2468]
-* `ResponseBuilder::finish()` now returns `Response<EitherBody<()>>`. [#2468]
 
 ### Removed
-* `ResponseBuilder::streaming`. [#2468]
+- `h1::Payload::readany`. [#2545]
-* `impl Future` for `ResponseBuilder`. [#2468]
+
-* Remove unnecessary `MessageBody` bound on types passed to `body::AnyBody::new`. [#2468]
+[#2527]: https://github.com/actix/actix-web/pull/2527
-* Move `body::AnyBody` to `awc`. Replaced with `EitherBody` and `BoxBody`. [#2468]
+[#2545]: https://github.com/actix/actix-web/pull/2545
-* `impl Copy` for `ws::Codec`. [#1920]
+
-* `header::qitem` helper. Replaced with `header::QualityItem::max`. [#2486]
+
-* `impl TryFrom<u16>` for `header::Quality`. [#2486]
+## 3.0.0-beta.16 - 2021-12-17
-* `http` module. Most everything it contained is exported at the crate root. [#2488]
+### Added
+- New method on `MessageBody` trait, `try_into_bytes`, with default implementation, for optimizations on body types that complete in exactly one poll. Replaces `is_complete_body` and `take_complete_body`. [#2522]
+
+### Changed
+- Rename trait `IntoHeaderPair => TryIntoHeaderPair`. [#2510]
+- Rename `TryIntoHeaderPair::{try_into_header_pair => try_into_pair}`. [#2510]
+- Rename trait `IntoHeaderValue => TryIntoHeaderValue`. [#2510]
+
+### Removed
+- `MessageBody::{is_complete_body,take_complete_body}`. [#2522]
+
+[#2510]: https://github.com/actix/actix-web/pull/2510
+[#2522]: https://github.com/actix/actix-web/pull/2522
+
+
+## 3.0.0-beta.15 - 2021-12-11
+### Added
+- Add timeout for canceling HTTP/2 server side connection handshake. Default to 5 seconds. [#2483]
+- HTTP/2 handshake timeout can be configured with `ServiceConfig::client_timeout`. [#2483]
+- `Response::map_into_boxed_body`. [#2468]
+- `body::EitherBody` enum. [#2468]
+- `body::None` struct. [#2468]
+- Impl `MessageBody` for `bytestring::ByteString`. [#2468]
+- `impl Clone for ws::HandshakeError`. [#2468]
+- `#[must_use]` for `ws::Codec` to prevent subtle bugs. [#1920]
+- `impl Default ` for `ws::Codec`. [#1920]
+- `header::QualityItem::{max, min}`. [#2486]
+- `header::Quality::{MAX, MIN}`. [#2486]
+- `impl Display` for `header::Quality`. [#2486]
+- Connection data set through the `on_connect_ext` callbacks is now accessible only from the new `Request::conn_data()` method. [#2491]
+- `Request::take_conn_data()`. [#2491]
+- `Request::take_req_data()`. [#2487]
+- `impl Clone` for `RequestHead`. [#2487]
+- New methods on `MessageBody` trait, `is_complete_body` and `take_complete_body`, both with default implementations, for optimizations on body types that are done in exactly one poll/chunk. [#2497]
+- New `boxed` method on `MessageBody` trait for wrapping body type. [#2520]
+
+### Changed
+- Rename `body::BoxBody::{from_body => new}`. [#2468]
+- Body type for `Responses` returned from `Response::{new, ok, etc...}` is now `BoxBody`. [#2468]
+- The `Error` associated type on `MessageBody` type now requires `impl Error` (or similar). [#2468]
+- Error types using in service builders now require `Into<Response<BoxBody>>`. [#2468]
+- `From` implementations on error types now return a `Response<BoxBody>`. [#2468]
+- `ResponseBuilder::body(B)` now returns `Response<EitherBody<B>>`. [#2468]
+- `ResponseBuilder::finish()` now returns `Response<EitherBody<()>>`. [#2468]
+
+### Removed
+- `ResponseBuilder::streaming`. [#2468]
+- `impl Future` for `ResponseBuilder`. [#2468]
+- Remove unnecessary `MessageBody` bound on types passed to `body::AnyBody::new`. [#2468]
+- Move `body::AnyBody` to `awc`. Replaced with `EitherBody` and `BoxBody`. [#2468]
+- `impl Copy` for `ws::Codec`. [#1920]
+- `header::qitem` helper. Replaced with `header::QualityItem::max`. [#2486]
+- `impl TryFrom<u16>` for `header::Quality`. [#2486]
+- `http` module. Most everything it contained is exported at the crate root. [#2488]
 
 [#2483]: https://github.com/actix/actix-web/pull/2483
 [#2468]: https://github.com/actix/actix-web/pull/2468
@@ -50,14 +83,15 @@
 [#2488]: https://github.com/actix/actix-web/pull/2488
 [#2491]: https://github.com/actix/actix-web/pull/2491
 [#2497]: https://github.com/actix/actix-web/pull/2497
+[#2520]: https://github.com/actix/actix-web/pull/2520
 
 
 ## 3.0.0-beta.14 - 2021-11-30
 ### Changed
-* Guarantee ordering of `header::GetAll` iterator to be same as insertion order. [#2467]
+- Guarantee ordering of `header::GetAll` iterator to be same as insertion order. [#2467]
-* Expose `header::map` module. [#2467]
+- Expose `header::map` module. [#2467]
-* Implement `ExactSizeIterator` and `FusedIterator` for all `HeaderMap` iterators. [#2470]
+- Implement `ExactSizeIterator` and `FusedIterator` for all `HeaderMap` iterators. [#2470]
-* Update `actix-tls` to `3.0.0-rc.1`. [#2474]
+- Update `actix-tls` to `3.0.0-rc.1`. [#2474]
 
 [#2467]: https://github.com/actix/actix-web/pull/2467
 [#2470]: https://github.com/actix/actix-web/pull/2470
@@ -66,24 +100,24 @@
 
 ## 3.0.0-beta.13 - 2021-11-22
 ### Added
-* `body::AnyBody::empty` for quickly creating an empty body. [#2446]
+- `body::AnyBody::empty` for quickly creating an empty body. [#2446]
-* `body::AnyBody::none` for quickly creating a "none" body. [#2456]
+- `body::AnyBody::none` for quickly creating a "none" body. [#2456]
-* `impl Clone` for `body::AnyBody<S> where S: Clone`. [#2448]
+- `impl Clone` for `body::AnyBody<S> where S: Clone`. [#2448]
-* `body::AnyBody::into_boxed` for quickly converting to a type-erased, boxed body type. [#2448]
+- `body::AnyBody::into_boxed` for quickly converting to a type-erased, boxed body type. [#2448]
 
 ### Changed
-* Rename `body::AnyBody::{Message => Body}`. [#2446]
+- Rename `body::AnyBody::{Message => Body}`. [#2446]
-* Rename `body::AnyBody::{from_message => new_boxed}`. [#2448]
+- Rename `body::AnyBody::{from_message => new_boxed}`. [#2448]
-* Rename `body::AnyBody::{from_slice => copy_from_slice}`. [#2448]
+- Rename `body::AnyBody::{from_slice => copy_from_slice}`. [#2448]
-* Rename `body::{BoxAnyBody => BoxBody}`. [#2448]
+- Rename `body::{BoxAnyBody => BoxBody}`. [#2448]
-* Change representation of `AnyBody` to include a type parameter in `Body` variant. Defaults to `BoxBody`. [#2448]
+- Change representation of `AnyBody` to include a type parameter in `Body` variant. Defaults to `BoxBody`. [#2448]
-* `Encoder::response` now returns `AnyBody<Encoder<B>>`. [#2448]
+- `Encoder::response` now returns `AnyBody<Encoder<B>>`. [#2448]
 
 ### Removed
-* `body::AnyBody::Empty`; an empty body can now only be represented as a zero-length `Bytes` variant. [#2446]
+- `body::AnyBody::Empty`; an empty body can now only be represented as a zero-length `Bytes` variant. [#2446]
-* `body::BodySize::Empty`; an empty body can now only be represented as a `Sized(0)` variant. [#2446]
+- `body::BodySize::Empty`; an empty body can now only be represented as a `Sized(0)` variant. [#2446]
-* `EncoderError::Boxed`; it is no longer required. [#2446]
+- `EncoderError::Boxed`; it is no longer required. [#2446]
-* `body::ResponseBody`; is function is replaced by the new `body::AnyBody` enum. [#2446]
+- `body::ResponseBody`; is function is replaced by the new `body::AnyBody` enum. [#2446]
 
 [#2446]: https://github.com/actix/actix-web/pull/2446
 [#2448]: https://github.com/actix/actix-web/pull/2448
@@ -92,11 +126,11 @@
 
 ## 3.0.0-beta.12 - 2021-11-15
 ### Changed
-* Update `actix-server` to `2.0.0-beta.9`. [#2442]
+- Update `actix-server` to `2.0.0-beta.9`. [#2442]
 
 ### Removed
-* `client` module. [#2425]
+- `client` module. [#2425]
-* `trust-dns` feature. [#2425]
+- `trust-dns` feature. [#2425]
 
 [#2425]: https://github.com/actix/actix-web/pull/2425
 [#2442]: https://github.com/actix/actix-web/pull/2442
@@ -104,21 +138,21 @@
 
 ## 3.0.0-beta.11 - 2021-10-20
 ### Changed
-* Updated rustls to v0.20. [#2414]
+- Updated rustls to v0.20. [#2414]
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 [#2414]: https://github.com/actix/actix-web/pull/2414
 
 
 ## 3.0.0-beta.10 - 2021-09-09
 ### Changed
-* `ContentEncoding` is now marked `#[non_exhaustive]`. [#2377]
+- `ContentEncoding` is now marked `#[non_exhaustive]`. [#2377]
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 ### Fixed
-* Remove slice creation pointing to potential uninitialized data on h1 encoder. [#2364]
+- Remove slice creation pointing to potential uninitialized data on h1 encoder. [#2364]
-* Remove `Into<Error>` bound on `Encoder` body types. [#2375]
+- Remove `Into<Error>` bound on `Encoder` body types. [#2375]
-* Fix quality parse error in Accept-Encoding header. [#2344]
+- Fix quality parse error in Accept-Encoding header. [#2344]
 
 [#2364]: https://github.com/actix/actix-web/pull/2364
 [#2375]: https://github.com/actix/actix-web/pull/2375
@@ -128,15 +162,15 @@
 
 ## 3.0.0-beta.9 - 2021-08-09
 ### Fixed
-* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+- Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
 
 
 ## 3.0.0-beta.8 - 2021-06-26
 ### Changed
-* Change compression algorithm features flags. [#2250]
+- Change compression algorithm features flags. [#2250]
 
 ### Removed
-* `downcast` and `downcast_get_type_id` macros. [#2291]
+- `downcast` and `downcast_get_type_id` macros. [#2291]
 
 [#2291]: https://github.com/actix/actix-web/pull/2291
 [#2250]: https://github.com/actix/actix-web/pull/2250
@@ -144,37 +178,37 @@
 
 ## 3.0.0-beta.7 - 2021-06-17
 ### Added
-* Alias `body::Body` as `body::AnyBody`. [#2215]
+- Alias `body::Body` as `body::AnyBody`. [#2215]
-* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
+- `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
-* Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
+- Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
-* Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
+- Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
-* Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
+- Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
-* `Response::into_body` that consumes response and returns body type. [#2201]
+- `Response::into_body` that consumes response and returns body type. [#2201]
-* `impl Default` for `Response`. [#2201]
+- `impl Default` for `Response`. [#2201]
-* Add zstd support for `ContentEncoding`. [#2244]
+- Add zstd support for `ContentEncoding`. [#2244]
 
 ### Changed
-* The `MessageBody` trait now has an associated `Error` type. [#2183]
+- The `MessageBody` trait now has an associated `Error` type. [#2183]
-* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+- All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
-* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+- All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
-* Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
+- Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
-* `header` mod is now public. [#2171]
+- `header` mod is now public. [#2171]
-* `uri` mod is now public. [#2171]
+- `uri` mod is now public. [#2171]
-* Update `language-tags` to `0.3`.
+- Update `language-tags` to `0.3`.
-* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
+- Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
-* `ResponseBuilder::message_body` now returns a `Result`. [#2201]
+- `ResponseBuilder::message_body` now returns a `Result`. [#2201]
-* Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
+- Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
-* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+- `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
 
 ### Removed
-* Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
+- Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
-* Down-casting for `MessageBody` types. [#2183]
+- Down-casting for `MessageBody` types. [#2183]
-* `error::Result` alias. [#2201]
+- `error::Result` alias. [#2201]
-* Error field from `Response` and `Response::error`. [#2205]
+- Error field from `Response` and `Response::error`. [#2205]
-* `impl Future` for `Response`. [#2201]
+- `impl Future` for `Response`. [#2201]
-* `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
+- `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
-* `InternalError` and all the error types it constructed. [#2215]
+- `InternalError` and all the error types it constructed. [#2215]
-* Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
+- Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
 
 [#2171]: https://github.com/actix/actix-web/pull/2171
 [#2183]: https://github.com/actix/actix-web/pull/2183
@@ -189,27 +223,27 @@
 
 ## 3.0.0-beta.6 - 2021-04-17
 ### Added
-* `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
+- `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
-* `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
+- `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
-* Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
+- Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
 
 ### Changes
-* The type parameter of `Response` no longer has a default. [#2152]
+- The type parameter of `Response` no longer has a default. [#2152]
-* The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
+- The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
-* `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
+- `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
-* Error enum types are marked `#[non_exhaustive]`. [#2161]
+- Error enum types are marked `#[non_exhaustive]`. [#2161]
 
 ### Removed
-* `cookies` feature flag. [#2065]
+- `cookies` feature flag. [#2065]
-* Top-level `cookies` mod (re-export). [#2065]
+- Top-level `cookies` mod (re-export). [#2065]
-* `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
+- `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
-* `impl ResponseError for CookieParseError`. [#2065]
+- `impl ResponseError for CookieParseError`. [#2065]
-* Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
+- Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
-* `ResponseBuilder::json`. [#2148]
+- `ResponseBuilder::json`. [#2148]
-* `ResponseBuilder::{set_header, header}`. [#2148]
+- `ResponseBuilder::{set_header, header}`. [#2148]
-* `impl From<serde_json::Value> for Body`. [#2148]
+- `impl From<serde_json::Value> for Body`. [#2148]
-* `Response::build_from`. [#2159]
+- `Response::build_from`. [#2159]
-* Most of the status code builders on `Response`. [#2159]
+- Most of the status code builders on `Response`. [#2159]
 
 [#2065]: https://github.com/actix/actix-web/pull/2065
 [#2148]: https://github.com/actix/actix-web/pull/2148
@@ -221,16 +255,16 @@
 
 ## 3.0.0-beta.5 - 2021-04-02
 ### Added
-* `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
+- `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
-* `client::ConnectorService` as `client::Connector::finish` method's return type [#2081]
+- `client::ConnectorService` as `client::Connector::finish` method's return type [#2081]
-* `client::ConnectionIo` trait alias [#2081]
+- `client::ConnectionIo` trait alias [#2081]
 
 ### Changed
-* `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
+- `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
 
 ### Removed
-* Common typed HTTP headers were moved to actix-web. [2094]
+- Common typed HTTP headers were moved to actix-web. [2094]
-* `ResponseError` impl for `actix_utils::timeout::TimeoutError`. [#2127]
+- `ResponseError` impl for `actix_utils::timeout::TimeoutError`. [#2127]
 
 [#2063]: https://github.com/actix/actix-web/pull/2063
 [#2081]: https://github.com/actix/actix-web/pull/2081
@@ -240,13 +274,13 @@
 
 ## 3.0.0-beta.4 - 2021-03-08
 ### Changed
-* Feature `cookies` is now optional and disabled by default. [#1981]
+- Feature `cookies` is now optional and disabled by default. [#1981]
-* `ws::hash_key` now returns array. [#2035]
+- `ws::hash_key` now returns array. [#2035]
-* `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
+- `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
 
 ### Removed
-* Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
+- Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
-* `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
+- `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
 
 [#1981]: https://github.com/actix/actix-web/pull/1981
 [#1994]: https://github.com/actix/actix-web/pull/1994
@@ -255,48 +289,48 @@
 
 
 ## 3.0.0-beta.3 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 3.0.0-beta.2 - 2021-02-10
 ### Added
-* `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
+- `TryIntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
-* `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
+- `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
-* `ResponseBuilder::append_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]
+- `TestRequest::insert_header` method which allows using typed headers. [#1869]
-* `ContentEncoding` implements all necessary header traits. [#1912]
+- `ContentEncoding` implements all necessary header traits. [#1912]
-* `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
+- `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
-* `HeaderMap::drain` as an efficient draining iterator. [#1964]
+- `HeaderMap::drain` as an efficient draining iterator. [#1964]
-* Implement `IntoIterator` for owned `HeaderMap`. [#1964]
+- Implement `IntoIterator` for owned `HeaderMap`. [#1964]
-* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
+- `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
+- `ResponseBuilder::content_type` now takes an `impl TryIntoHeaderValue` to support using typed
   `mime` types. [#1894]
-* Renamed `IntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
+- Renamed `TryIntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
   `TryInto` trait. [#1894]
-* `Extensions::insert` returns Option of replaced item. [#1904]
+- `Extensions::insert` returns Option of replaced item. [#1904]
-* Remove `HttpResponseBuilder::json2()`. [#1903]
+- Remove `HttpResponseBuilder::json2()`. [#1903]
-* Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#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::error::ConnectError` Resolver variant contains `Box<dyn std::error::Error>` type. [#1905]
-* `client::ConnectorConfig` default timeout changed to 5 seconds. [#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
+- 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::len` now returns number of values instead of number of keys. [#1964]
-* `HeaderMap::insert` now returns iterator of removed values. [#1964]
+- `HeaderMap::insert` now returns iterator of removed values. [#1964]
-* `HeaderMap::remove` 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`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
+- `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
-* `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
+- `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
-* `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
+- `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
-* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
+- `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
-* `actors` optional feature. [#1969]
+- `actors` optional feature. [#1969]
-* `ResponseError` impl for `actix::MailboxError`. [#1969]
+- `ResponseError` impl for `actix::MailboxError`. [#1969]
 
 ### Documentation
-* Vastly improve docs and add examples for `HeaderMap`. [#1964]
+- 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
@@ -311,24 +345,24 @@
 
 ## 3.0.0-beta.1 - 2021-01-07
 ### Added
-* Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
+- Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
 
 ### Changed
-* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
+- Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
-* Bumped `rand` to `0.8`.
+- Bumped `rand` to `0.8`.
-* Update `bytes` to `1.0`. [#1813]
+- Update `bytes` to `1.0`. [#1813]
-* Update `h2` to `0.3`. [#1813]
+- Update `h2` to `0.3`. [#1813]
-* The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
+- The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
 
 ### Removed
-* Deprecated `on_connect` methods have been removed. Prefer the new
+- Deprecated `on_connect` methods have been removed. Prefer the new
   `on_connect_ext` technique. [#1857]
-* Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
+- Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
   due to deprecate of resolver actor. [#1813]
-* Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
+- 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`.
+- 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]
 
@@ -340,20 +374,20 @@
 
 ## 2.2.1 - 2021-08-09
 ### Fixed
-* Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
+- Potential HTTP request smuggling vulnerabilities. [RUSTSEC-2021-0081](https://github.com/rustsec/advisory-db/pull/977)
 
 
 ## 2.2.0 - 2020-11-25
 ### Added
-* HttpResponse builders for 1xx status codes. [#1768]
+- HttpResponse builders for 1xx status codes. [#1768]
-* `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
+- `Accept::mime_precedence` and `Accept::mime_preference`. [#1793]
-* `TryFrom<u16>` and `TryFrom<f32>` for `http::header::Quality`. [#1797]
+- `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]
+- Started dropping `transfer-encoding: chunked` and `Content-Length` for 1XX and 204 responses. [#1767]
 
 ### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
+- 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
@@ -364,12 +398,12 @@
 
 ## 2.1.0 - 2020-10-30
 ### Added
-* Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
+- Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
 
 ### Changed
-* Upgrade `base64` to `0.13`. [#1744]
+- Upgrade `base64` to `0.13`. [#1744]
-* Upgrade `pin-project` to `1.0`. [#1733]
+- Upgrade `pin-project` to `1.0`. [#1733]
-* Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
+- 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
@@ -378,28 +412,28 @@
 
 
 ## 2.0.0 - 2020-09-11
-* No significant changes from `2.0.0-beta.4`.
+- 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-codec and actix-utils dependencies.
-* Update actix-connect and actix-tls dependencies.
+- Update actix-connect and actix-tls dependencies.
 
 
 ## 2.0.0-beta.3 - 2020-08-14
 ### Fixed
-* Memory leak of `client::pool::ConnectorPoolSupport`. [#1626]
+- 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]
+- Potential UB in h1 decoder using uninitialized memory. [#1614]
 
 ### Changed
-* Fix illegal chunked encoding. [#1615]
+- Fix illegal chunked encoding. [#1615]
 
 [#1614]: https://github.com/actix/actix-web/pull/1614
 [#1615]: https://github.com/actix/actix-web/pull/1615
@@ -407,10 +441,10 @@
 
 ## 2.0.0-beta.1 - 2020-07-11
 ### Changed
-* Migrate cookie handling to `cookie` crate. [#1558]
+- Migrate cookie handling to `cookie` crate. [#1558]
-* Update `sha-1` to 0.9. [#1586]
+- Update `sha-1` to 0.9. [#1586]
-* Fix leak in client pool. [#1580]
+- Fix leak in client pool. [#1580]
-* MSRV is now 1.41.1.
+- MSRV is now 1.41.1.
 
 [#1558]: https://github.com/actix/actix-web/pull/1558
 [#1586]: https://github.com/actix/actix-web/pull/1586
@@ -419,15 +453,15 @@
 
 ## 2.0.0-alpha.4 - 2020-05-21
 ### Changed
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
-* content_length function is removed, and you can set Content-Length by calling
+- 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
+- `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
   `u64` instead of a `usize`.
-* Update `base64` dependency to 0.12
+- Update `base64` dependency to 0.12
 
 ### Fixed
-* Support parsing of `SameSite=None` [#1503]
+- Support parsing of `SameSite=None` [#1503]
 
 [#1439]: https://github.com/actix/actix-web/pull/1439
 [#1503]: https://github.com/actix/actix-web/pull/1503
@@ -435,13 +469,13 @@
 
 ## 2.0.0-alpha.3 - 2020-05-08
 ### Fixed
-* Correct spelling of ConnectError::Unresolved [#1487]
+- Correct spelling of ConnectError::Unresolved [#1487]
-* Fix a mistake in the encoding of websocket continuation messages wherein
+- 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]
+- Implement `std::error::Error` for our custom errors [#1422]
-* Remove `failure` support for `ResponseError` since that crate
+- Remove `failure` support for `ResponseError` since that crate
   will be deprecated in the near future.
 
 [#1422]: https://github.com/actix/actix-web/pull/1422
@@ -450,12 +484,12 @@
 
 ## 2.0.0-alpha.2 - 2020-03-07
 ### Changed
-* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
+- 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
+- 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
+- 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]
+- 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
@@ -463,61 +497,61 @@
 
 ## 2.0.0-alpha.1 - 2020-02-27
 ### Changed
-* Update the `time` dependency to 0.2.7.
+- Update the `time` dependency to 0.2.7.
-* Moved actors messages support from actix crate, enabled with feature `actors`.
+- Moved actors messages support from actix crate, enabled with feature `actors`.
-* Breaking change: trait MessageBody requires Unpin and accepting `Pin<&mut Self>` instead of
+- 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.
+- MessageBody is not implemented for &'static [u8] anymore.
 
 ### Fixed
-* Allow `SameSite=None` cookies to be sent in a response.
+- 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
+- Poll upgrade service's readiness from HTTP service handlers
-* Replace brotli with brotli2 #1224
+- Replace brotli with brotli2 #1224
 
 
 ## 1.0.0 - 2019-12-13
 ### Added
-* Add websockets continuation frame support
+- Add websockets continuation frame support
 
 ### Changed
-* Replace `flate2-xxx` features with `compress`
+- Replace `flate2-xxx` features with `compress`
 
 
 ## 1.0.0-alpha.5 - 2019-12-09
 ### Fixed
-* Check `Upgrade` service readiness before calling it
+- Check `Upgrade` service readiness before calling it
-* Fix buffer remaining capacity calculation
+- Fix buffer remaining capacity calculation
 
 ### Changed
-* Websockets: Ping and Pong should have binary data #1049
+- Websockets: Ping and Pong should have binary data #1049
 
 
 ## 1.0.0-alpha.4 - 2019-12-08
 ### Added
-* Add impl ResponseBuilder for Error
+- Add impl ResponseBuilder for Error
 
 ### Changed
-* Use rust based brotli compression library
+- Use rust based brotli compression library
 
 ## 1.0.0-alpha.3 - 2019-12-07
 ### Changed
-* Migrate to tokio 0.2
+- Migrate to tokio 0.2
-* Migrate to `std::future`
+- 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 support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-* Add an additional `filename*` param in the `Content-Disposition` header of
+- 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`
+- 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;
+- 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
@@ -525,169 +559,169 @@
 
 ## 0.2.10 - 2019-09-11
 ### Added
-* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
+- Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests
   with `RequestHead`
 
 ### Fixed
-* h2 will use error response #1080
+- h2 will use error response #1080
-* on_connect result isn't added to request extensions for http2 requests #1009
+- 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
+- Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
-* Update percent-encoding to 2.1
+- Update percent-encoding to 2.1
-* Update serde_urlencoded to 0.6.1
+- Update serde_urlencoded to 0.6.1
 
 ### Fixed
-* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
+- Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
 
 
 ## 0.2.8 - 2019-08-01
 ### Added
-* Add `rustls` support
+- Add `rustls` support
-* Add `Clone` impl for `HeaderMap`
+- Add `Clone` impl for `HeaderMap`
 
 ### Fixed
-* awc client panic #1016
+- awc client panic #1016
-* Invalid response with compression middleware enabled, but compression-related features
+- 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
+- Add support for downcasting response errors #986
 
 
 ## 0.2.6 - 2019-07-17
 ### Changed
-* Replace `ClonableService` with local copy
+- Replace `ClonableService` with local copy
-* Upgrade `rand` dependency version to 0.7
+- Upgrade `rand` dependency version to 0.7
 
 
 ## 0.2.5 - 2019-06-28
 ### Added
-* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
+- Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
 
 ### Changed
-* Use `encoding_rs` crate instead of unmaintained `encoding` crate
+- Use `encoding_rs` crate instead of unmaintained `encoding` crate
-* Add `Copy` and `Clone` impls for `ws::Codec`
+- Add `Copy` and `Clone` impls for `ws::Codec`
 
 
 ## 0.2.4 - 2019-06-16
 ### Fixed
-* Do not compress NoContent (204) responses #918
+- Do not compress NoContent (204) responses #918
 
 
 ## 0.2.3 - 2019-06-02
 ### Added
-* Debug impl for ResponseBuilder
+- Debug impl for ResponseBuilder
-* From SizedStream and BodyStream for Body
+- From SizedStream and BodyStream for Body
 
 ### Changed
-* SizedStream uses u64
+- SizedStream uses u64
 
 
 ## 0.2.2 - 2019-05-29
 ### Fixed
-* Parse incoming stream before closing stream on disconnect #868
+- Parse incoming stream before closing stream on disconnect #868
 
 
 ## 0.2.1 - 2019-05-25
 ### Fixed
-* Handle socket read disconnect
+- Handle socket read disconnect
 
 
 ## 0.2.0 - 2019-05-12
 ### Changed
-* Update actix-service to 0.4
+- Update actix-service to 0.4
-* Expect and upgrade services accept `ServerConfig` config.
+- Expect and upgrade services accept `ServerConfig` config.
 
 ### Deleted
-* `OneRequest` service
+- `OneRequest` service
 
 
 ## 0.1.5 - 2019-05-04
 ### Fixed
-* Clean up response extensions in response pool #817
+- Clean up response extensions in response pool #817
 
 
 ## 0.1.4 - 2019-04-24
 ### Added
-* Allow to render h1 request headers in `Camel-Case`
+- Allow to render h1 request headers in `Camel-Case`
 
 ### Fixed
-* Read until eof for http/1.0 responses #771
+- Read until eof for http/1.0 responses #771
 
 
 ## 0.1.3 - 2019-04-23
 ### Fixed
-* Fix http client pool management
+- Fix http client pool management
-* Fix http client wait queue management #794
+- Fix http client wait queue management #794
 
 
 ## 0.1.2 - 2019-04-23
 ### Fixed
-* Fix BorrowMutError panic in client connector #793
+- Fix BorrowMutError panic in client connector #793
 
 
 ## 0.1.1 - 2019-04-19
 ### Changed
-* Cookie::max_age() accepts value in seconds
+- Cookie::max_age() accepts value in seconds
-* Cookie::max_age_time() accepts value in time::Duration
+- Cookie::max_age_time() accepts value in time::Duration
-* Allow to specify server address for client connector
+- 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`
+- Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
 
 ### Changed
-* `actix_http::encoding` always available
+- `actix_http::encoding` always available
-* use trust-dns-resolver 0.11.0
+- use trust-dns-resolver 0.11.0
 
 
 ## 0.1.0-alpha.5 - 2019-04-12
 ### Added
-* Allow to use custom service for upgrade requests
+- Allow to use custom service for upgrade requests
-* Added `h1::SendResponse` future.
+- Added `h1::SendResponse` future.
 
 ### Changed
-* MessageBody::length() renamed to MessageBody::size() for consistency
+- MessageBody::length() renamed to MessageBody::size() for consistency
-* ws handshake verification functions take RequestHead instead of Request
+- ws handshake verification functions take RequestHead instead of Request
 
 
 ## 0.1.0-alpha.4 - 2019-04-08
 ### Added
-* Allow to use custom `Expect` handler
+- Allow to use custom `Expect` handler
-* Add minimal `std::error::Error` impl for `Error`
+- Add minimal `std::error::Error` impl for `Error`
 
 ### Changed
-* Export IntoHeaderValue
+- Export IntoHeaderValue
-* Render error and return as response body
+- Render error and return as response body
-* Use thread pool for response body compression
+- Use thread pool for response body compression
 
 ### Deleted
-* Removed PayloadBuffer
+- Removed PayloadBuffer
 
 
 ## 0.1.0-alpha.3 - 2019-04-02
 ### Added
-* Warn when an unsealed private cookie isn't valid UTF-8
+- Warn when an unsealed private cookie isn't valid UTF-8
 
 ### Fixed
-* Rust 1.31.0 compatibility
+- Rust 1.31.0 compatibility
-* Preallocate read buffer for h1 codec
+- Preallocate read buffer for h1 codec
-* Detect socket disconnection during protocol selection
+- Detect socket disconnection during protocol selection
 
 
 ## 0.1.0-alpha.2 - 2019-03-29
 ### Added
-* Added ws::Message::Nop, no-op websockets message
+- Added ws::Message::Nop, no-op websockets message
 
 ### Changed
-* Do not use thread pool for decompression if chunk size is smaller than 2048.
+- Do not use thread pool for decompression if chunk size is smaller than 2048.
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.15"
+version = "3.0.0-beta.17"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
 keywords = ["actix", "http", "framework", "async", "futures"]
@@ -45,7 +45,7 @@ __compress = []
 actix-service = "2.0.0"
 actix-codec = "0.4.1"
 actix-utils = "3.0.0"
-actix-rt = "2.2"
+actix-rt = { version = "2.2", default-features = false }
 
 ahash = "0.7"
 base64 = "0.13"
@@ -55,25 +55,23 @@ bytestring = "1"
 derive_more = "0.99.5"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
 h2 = "0.3.9"
 http = "0.2.5"
 httparse = "1.5.1"
 httpdate = "1.0.1"
-itoa = "0.4"
+itoa = "1"
 language-tags = "0.3"
 local-channel = "0.1"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "1.0.0"
 pin-project-lite = "0.2"
 rand = "0.8"
-sha-1 = "0.9"
+sha-1 = "0.10"
 smallvec = "1.6.1"
 
 # tls
-actix-tls = { version = "3.0.0-rc.1", default-features = false, optional = true }
+actix-tls = { version = "3.0.0", default-features = false, optional = true }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
@@ -81,14 +79,15 @@ flate2 = { version = "1.0.13", optional = true }
 zstd = { version = "0.9", optional = true }
 
 [dev-dependencies]
-actix-http-test = { version = "3.0.0-beta.9", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.10", features = ["openssl"] }
-actix-server = "2.0.0-rc.1"
+actix-server = "2.0.0-rc.2"
-actix-tls = { version = "3.0.0-rc.1", features = ["openssl"] }
+actix-tls = { version = "3.0.0", features = ["openssl"] }
-actix-web = "4.0.0-beta.14"
+actix-web = "4.0.0-beta.17"
 
 async-stream = "0.3"
 criterion = { version = "0.3", features = ["html_reports"] }
 env_logger = "0.9"
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
 rcgen = "0.8"
 regex = "1.3"
 rustls-pemfile = "0.2"
@@ -97,7 +96,7 @@ serde_json = "1.0"
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.9" }
 tls-rustls = { package = "rustls", version = "0.20.0" }
-tokio = { version = "1.2", features = ["net", "rt", "macros"] }
+tokio = { version = "1.8.4", features = ["net", "rt", "macros"] }
 
 [[example]]
 name = "ws"

actix-http/README.md

@@ -3,11 +3,11 @@
 > 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.15)](https://docs.rs/actix-http/3.0.0-beta.15)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.17)](https://docs.rs/actix-http/3.0.0-beta.17)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.15/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.15)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.17/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.17)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
@@ -54,8 +54,8 @@ async fn main() -> io::Result<()> {
 
 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))
+- 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))
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 

actix-http/src/body/body_stream.rs

@@ -27,6 +27,7 @@ where
     S: Stream<Item = Result<Bytes, E>>,
     E: Into<Box<dyn StdError>> + 'static,
 {
+    #[inline]
     pub fn new(stream: S) -> Self {
         BodyStream { stream }
     }
@@ -39,6 +40,7 @@ where
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         BodySize::Stream
     }

actix-http/src/body/boxed.rs

@@ -8,77 +8,98 @@ use std::{
 use bytes::Bytes;
 
 use super::{BodySize, MessageBody, MessageBodyMapErr};
-use crate::Error;
+use crate::body;
 
 /// A boxed message body with boxed errors.
-pub struct BoxBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError>>>>);
+#[derive(Debug)]
+pub struct BoxBody(BoxBodyInner);
+
+enum BoxBodyInner {
+    None(body::None),
+    Bytes(Bytes),
+    Stream(Pin<Box<dyn MessageBody<Error = Box<dyn StdError>>>>),
+}
+
+impl fmt::Debug for BoxBodyInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::None(arg0) => f.debug_tuple("None").field(arg0).finish(),
+            Self::Bytes(arg0) => f.debug_tuple("Bytes").field(arg0).finish(),
+            Self::Stream(_) => f.debug_tuple("Stream").field(&"dyn MessageBody").finish(),
+        }
+    }
+}
 
 impl BoxBody {
-    /// Boxes a `MessageBody` and any errors it generates.
+    /// Same as `MessageBody::boxed`.
+    ///
+    /// If the body type to wrap is unknown or generic it is better to use [`MessageBody::boxed`] to
+    /// avoid double boxing.
+    #[inline]
     pub fn new<B>(body: B) -> Self
     where
         B: MessageBody + 'static,
     {
-        let body = MessageBodyMapErr::new(body, Into::into);
+        match body.size() {
-        Self(Box::pin(body))
+            BodySize::None => Self(BoxBodyInner::None(body::None)),
+            _ => match body.try_into_bytes() {
+                Ok(bytes) => Self(BoxBodyInner::Bytes(bytes)),
+                Err(body) => {
+                    let body = MessageBodyMapErr::new(body, Into::into);
+                    Self(BoxBodyInner::Stream(Box::pin(body)))
+                }
+            },
+        }
     }
 
     /// Returns a mutable pinned reference to the inner message body type.
-    pub fn as_pin_mut(&mut self) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError>>)> {
+    #[inline]
-        self.0.as_mut()
+    pub fn as_pin_mut(&mut self) -> Pin<&mut Self> {
-    }
+        Pin::new(self)
-}
-
-impl fmt::Debug for BoxBody {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("BoxBody(dyn MessageBody)")
     }
 }
 
 impl MessageBody for BoxBody {
-    type Error = Error;
+    type Error = Box<dyn StdError>;
 
+    #[inline]
     fn size(&self) -> BodySize {
-        self.0.size()
+        match &self.0 {
+            BoxBodyInner::None(none) => none.size(),
+            BoxBodyInner::Bytes(bytes) => bytes.size(),
+            BoxBodyInner::Stream(stream) => stream.size(),
+        }
     }
 
+    #[inline]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-        self.0
+        match &mut self.0 {
-            .as_mut()
+            BoxBodyInner::None(body) => {
-            .poll_next(cx)
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
-            .map_err(|err| Error::new_body().with_cause(err))
-    }
-
-    fn is_complete_body(&self) -> bool {
-        self.0.is_complete_body()
-    }
-
-    fn take_complete_body(&mut self) -> Bytes {
-        debug_assert!(
-            self.is_complete_body(),
-            "boxed type does not allow taking complete body; caller should make sure to \
-            call `is_complete_body` first",
-        );
-
-        // we do not have DerefMut access to call take_complete_body directly but since
-        // is_complete_body is true we should expect the entire bytes chunk in one poll_next
-
-        let waker = futures_util::task::noop_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        match self.as_pin_mut().poll_next(&mut cx) {
-            Poll::Ready(Some(Ok(data))) => data,
-            _ => {
-                panic!(
-                    "boxed type indicated it allows taking complete body but failed to \
-                    return Bytes when polled",
-                );
             }
+            BoxBodyInner::Bytes(body) => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
+            }
+            BoxBodyInner::Stream(body) => Pin::new(body).poll_next(cx),
         }
     }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        match self.0 {
+            BoxBodyInner::None(body) => Ok(body.try_into_bytes().unwrap()),
+            BoxBodyInner::Bytes(body) => Ok(body.try_into_bytes().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    #[inline]
+    fn boxed(self) -> BoxBody {
+        self
+    }
 }
 
 #[cfg(test)]

actix-http/src/body/either.rs

@@ -23,6 +23,7 @@ pin_project! {
 
 impl<L> EitherBody<L, BoxBody> {
     /// Creates new `EitherBody` using left variant and boxed right variant.
+    #[inline]
     pub fn new(body: L) -> Self {
         Self::Left { body }
     }
@@ -30,11 +31,13 @@ impl<L> EitherBody<L, BoxBody> {
 
 impl<L, R> EitherBody<L, R> {
     /// Creates new `EitherBody` using left variant.
+    #[inline]
     pub fn left(body: L) -> Self {
         Self::Left { body }
     }
 
     /// Creates new `EitherBody` using right variant.
+    #[inline]
     pub fn right(body: R) -> Self {
         Self::Right { body }
     }
@@ -47,6 +50,7 @@ where
 {
     type Error = Error;
 
+    #[inline]
     fn size(&self) -> BodySize {
         match self {
             EitherBody::Left { body } => body.size(),
@@ -54,6 +58,7 @@ where
         }
     }
 
+    #[inline]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -68,17 +73,23 @@ where
         }
     }
 
-    fn is_complete_body(&self) -> bool {
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
         match self {
-            EitherBody::Left { body } => body.is_complete_body(),
+            EitherBody::Left { body } => body
-            EitherBody::Right { body } => body.is_complete_body(),
+                .try_into_bytes()
+                .map_err(|body| EitherBody::Left { body }),
+            EitherBody::Right { body } => body
+                .try_into_bytes()
+                .map_err(|body| EitherBody::Right { body }),
         }
     }
 
-    fn take_complete_body(&mut self) -> Bytes {
+    #[inline]
+    fn boxed(self) -> BoxBody {
         match self {
-            EitherBody::Left { body } => body.take_complete_body(),
+            EitherBody::Left { body } => body.boxed(),
-            EitherBody::Right { body } => body.take_complete_body(),
+            EitherBody::Right { body } => body.boxed(),
         }
     }
 }

actix-http/src/body/message_body.rs

@@ -12,16 +12,20 @@ use bytes::{Bytes, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 
-use super::BodySize;
+use super::{BodySize, BoxBody};
 
 /// An interface types that can converted to bytes and used as response bodies.
 // TODO: examples
 pub trait MessageBody {
-    // TODO: consider this bound to only fmt::Display since the error type is not really used
+    /// The type of error that will be returned if streaming body fails.
-    // and there is an impl for Into<Box<StdError>> on String
+    ///
+    /// Since it is not appropriate to generate a response mid-stream, it only requires `Error` for
+    /// internal use and logging.
     type Error: Into<Box<dyn StdError>>;
 
     /// Body size hint.
+    ///
+    /// If [`BodySize::None`] is returned, optimizations that skip reading the body are allowed.
     fn size(&self) -> BodySize;
 
     /// Attempt to pull out the next chunk of body bytes.
@@ -31,51 +35,32 @@ pub trait MessageBody {
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>>;
 
-    /// Returns true if entire body bytes chunk is obtainable in one call to `poll_next`.
+    /// Try to convert into the complete chunk of body bytes.
     ///
-    /// This method's implementation should agree with [`take_complete_body`] and should always be
+    /// Implement this method if the entire body can be trivially extracted. This is useful for
-    /// checked before taking the body.
+    /// optimizations where `poll_next` calls can be avoided.
     ///
-    /// The default implementation returns `false.
+    /// Body types with [`BodySize::None`] are allowed to return empty `Bytes`. Although, if calling
+    /// this method, it is recommended to check `size` first and return early.
     ///
-    /// [`take_complete_body`]: MessageBody::take_complete_body
+    /// # Errors
-    fn is_complete_body(&self) -> bool {
+    /// The default implementation will error and return the original type back to the caller for
-        false
+    /// further use.
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
+        Err(self)
     }
 
-    /// Returns the complete chunk of body bytes.
+    /// Converts this body into `BoxBody`.
-    ///
+    #[inline]
-    /// Implementors of this method should note the following:
+    fn boxed(self) -> BoxBody
-    /// - It is acceptable to skip the omit checks of [`is_complete_body`]. The responsibility of
+    where
-    ///   performing this check is delegated to the caller.
+        Self: Sized + 'static,
-    /// - If the result of [`is_complete_body`] is conditional, that condition should be given
+    {
-    ///   equivalent attention here.
+        BoxBody::new(self)
-    /// - A second call call to [`take_complete_body`] should return an empty `Bytes` or panic.
-    /// - A call to [`poll_next`] after calling [`take_complete_body`] should return `None` unless
-    ///   the chunk is guaranteed to be empty.
-    ///
-    /// The default implementation panics unconditionally, indicating a control flow bug in the
-    /// calling code.
-    ///
-    /// # Panics
-    /// With a correct implementation, panics if called without first checking [`is_complete_body`].
-    ///
-    /// [`is_complete_body`]: MessageBody::is_complete_body
-    /// [`take_complete_body`]: MessageBody::take_complete_body
-    /// [`poll_next`]: MessageBody::poll_next
-    fn take_complete_body(&mut self) -> Bytes {
-        assert!(
-            self.is_complete_body(),
-            "type ({}) allows taking complete body but did not provide an implementation \
-            of `take_complete_body`",
-            std::any::type_name::<Self>()
-        );
-
-        unimplemented!(
-            "type ({}) does not allow taking complete body; caller should make sure to \
-            check `is_complete_body` first",
-            std::any::type_name::<Self>()
-        );
     }
 }
 
@@ -85,26 +70,16 @@ mod foreign_impls {
     impl MessageBody for Infallible {
         type Error = Infallible;
 
-        #[inline]
         fn size(&self) -> BodySize {
             match *self {}
         }
 
-        #[inline]
         fn poll_next(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             match *self {}
         }
-
-        fn is_complete_body(&self) -> bool {
-            true
-        }
-
-        fn take_complete_body(&mut self) -> Bytes {
-            match *self {}
-        }
     }
 
     impl MessageBody for () {
@@ -124,19 +99,14 @@ mod foreign_impls {
         }
 
         #[inline]
-        fn is_complete_body(&self) -> bool {
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-            true
+            Ok(Bytes::new())
-        }
-
-        #[inline]
-        fn take_complete_body(&mut self) -> Bytes {
-            Bytes::new()
         }
     }
 
     impl<B> MessageBody for Box<B>
     where
-        B: MessageBody + Unpin,
+        B: MessageBody + Unpin + ?Sized,
     {
         type Error = B::Error;
 
@@ -152,21 +122,11 @@ mod foreign_impls {
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             Pin::new(self.get_mut().as_mut()).poll_next(cx)
         }
-
-        #[inline]
-        fn is_complete_body(&self) -> bool {
-            self.as_ref().is_complete_body()
-        }
-
-        #[inline]
-        fn take_complete_body(&mut self) -> Bytes {
-            self.as_mut().take_complete_body()
-        }
     }
 
     impl<B> MessageBody for Pin<Box<B>>
     where
-        B: MessageBody,
+        B: MessageBody + ?Sized,
     {
         type Error = B::Error;
 
@@ -177,160 +137,126 @@ mod foreign_impls {
 
         #[inline]
         fn poll_next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut Self>,
             cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
-            self.as_mut().poll_next(cx)
+            self.get_mut().as_mut().poll_next(cx)
-        }
-
-        #[inline]
-        fn is_complete_body(&self) -> bool {
-            self.as_ref().is_complete_body()
-        }
-
-        #[inline]
-        fn take_complete_body(&mut self) -> Bytes {
-            debug_assert!(
-                self.is_complete_body(),
-                "inner type \"{}\" does not allow taking complete body; caller should make sure to \
-                call `is_complete_body` first",
-                std::any::type_name::<B>(),
-            );
-
-            // we do not have DerefMut access to call take_complete_body directly but since
-            // is_complete_body is true we should expect the entire bytes chunk in one poll_next
-
-            let waker = futures_util::task::noop_waker();
-            let mut cx = Context::from_waker(&waker);
-
-            match self.as_mut().poll_next(&mut cx) {
-                Poll::Ready(Some(Ok(data))) => data,
-                _ => {
-                    panic!(
-                        "inner type \"{}\" indicated it allows taking complete body but failed to \
-                        return Bytes when polled",
-                        std::any::type_name::<B>()
-                    );
-                }
-            }
         }
     }
 
     impl MessageBody for &'static [u8] {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             if self.is_empty() {
                 Poll::Ready(None)
             } else {
-                Poll::Ready(Some(Ok(self.take_complete_body())))
+                Poll::Ready(Some(Ok(Bytes::from_static(mem::take(self.get_mut())))))
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(Bytes::from_static(self))
-
-        fn take_complete_body(&mut self) -> Bytes {
-            Bytes::from_static(mem::take(self))
         }
     }
 
     impl MessageBody for Bytes {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             if self.is_empty() {
                 Poll::Ready(None)
             } else {
-                Poll::Ready(Some(Ok(self.take_complete_body())))
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(self)
-
-        fn take_complete_body(&mut self) -> Bytes {
-            mem::take(self)
         }
     }
 
     impl MessageBody for BytesMut {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             if self.is_empty() {
                 Poll::Ready(None)
             } else {
-                Poll::Ready(Some(Ok(self.take_complete_body())))
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(self.freeze())
-
-        fn take_complete_body(&mut self) -> Bytes {
-            mem::take(self).freeze()
         }
     }
 
     impl MessageBody for Vec<u8> {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
-            mut self: Pin<&mut Self>,
+            self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
         ) -> Poll<Option<Result<Bytes, Self::Error>>> {
             if self.is_empty() {
                 Poll::Ready(None)
             } else {
-                Poll::Ready(Some(Ok(self.take_complete_body())))
+                Poll::Ready(Some(Ok(mem::take(self.get_mut()).into())))
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(Bytes::from(self))
-
-        fn take_complete_body(&mut self) -> Bytes {
-            Bytes::from(mem::take(self))
         }
     }
 
     impl MessageBody for &'static str {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
@@ -344,22 +270,21 @@ mod foreign_impls {
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(Bytes::from_static(self.as_bytes()))
-
-        fn take_complete_body(&mut self) -> Bytes {
-            Bytes::from_static(mem::take(self).as_bytes())
         }
     }
 
     impl MessageBody for String {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
@@ -372,22 +297,21 @@ mod foreign_impls {
             }
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(Bytes::from(self))
-
-        fn take_complete_body(&mut self) -> Bytes {
-            Bytes::from(mem::take(self))
         }
     }
 
     impl MessageBody for bytestring::ByteString {
         type Error = Infallible;
 
+        #[inline]
         fn size(&self) -> BodySize {
             BodySize::Sized(self.len() as u64)
         }
 
+        #[inline]
         fn poll_next(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
@@ -396,12 +320,9 @@ mod foreign_impls {
             Poll::Ready(Some(Ok(string.into_bytes())))
         }
 
-        fn is_complete_body(&self) -> bool {
+        #[inline]
-            true
+        fn try_into_bytes(self) -> Result<Bytes, Self> {
-        }
+            Ok(self.into_bytes())
-
-        fn take_complete_body(&mut self) -> Bytes {
-            mem::take(self).into_bytes()
         }
     }
 }
@@ -435,6 +356,7 @@ where
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         self.body.size()
     }
@@ -455,6 +377,12 @@ where
             None => Poll::Ready(None),
         }
     }
+
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
+        let Self { body, mapper } = self;
+        body.try_into_bytes().map_err(|body| Self { body, mapper })
+    }
 }
 
 #[cfg(test)]
@@ -464,6 +392,7 @@ mod tests {
     use bytes::{Bytes, BytesMut};
 
     use super::*;
+    use crate::body::{self, EitherBody};
 
     macro_rules! assert_poll_next {
         ($pin:expr, $exp:expr) => {
@@ -565,49 +494,45 @@ mod tests {
         assert_poll_next!(pl, Bytes::from("test"));
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn take_string() {
+    async fn complete_body_combinators() {
-        let mut data = "test".repeat(2);
+        let body = Bytes::from_static(b"test");
-        let data_bytes = Bytes::from(data.clone());
+        let body = BoxBody::new(body);
-        assert!(data.is_complete_body());
+        let body = EitherBody::<_, ()>::left(body);
-        assert_eq!(data.take_complete_body(), data_bytes);
+        let body = EitherBody::<(), _>::right(body);
+        // Do not support try_into_bytes:
+        // let body = Box::new(body);
+        // let body = Box::pin(body);
 
-        let mut big_data = "test".repeat(64 * 1024);
+        assert_eq!(body.try_into_bytes().unwrap(), Bytes::from("test"));
-        let data_bytes = Bytes::from(big_data.clone());
-        assert!(big_data.is_complete_body());
-        assert_eq!(big_data.take_complete_body(), data_bytes);
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn take_boxed_equivalence() {
+    async fn complete_body_combinators_poll() {
-        let mut data = Bytes::from_static(b"test");
+        let body = Bytes::from_static(b"test");
-        assert!(data.is_complete_body());
+        let body = BoxBody::new(body);
-        assert_eq!(data.take_complete_body(), b"test".as_ref());
+        let body = EitherBody::<_, ()>::left(body);
+        let body = EitherBody::<(), _>::right(body);
+        let mut body = body;
 
-        let mut data = Box::new(Bytes::from_static(b"test"));
+        assert_eq!(body.size(), BodySize::Sized(4));
-        assert!(data.is_complete_body());
+        assert_poll_next!(Pin::new(&mut body), Bytes::from("test"));
-        assert_eq!(data.take_complete_body(), b"test".as_ref());
+        assert_poll_next_none!(Pin::new(&mut body));
-
-        let mut data = Box::pin(Bytes::from_static(b"test"));
-        assert!(data.is_complete_body());
-        assert_eq!(data.take_complete_body(), b"test".as_ref());
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn take_policy() {
+    async fn none_body_combinators() {
-        let mut data = Bytes::from_static(b"test");
+        fn none_body() -> BoxBody {
-        // first call returns chunk
+            let body = body::None;
-        assert_eq!(data.take_complete_body(), b"test".as_ref());
+            let body = BoxBody::new(body);
-        // second call returns empty
+            let body = EitherBody::<_, ()>::left(body);
-        assert_eq!(data.take_complete_body(), b"".as_ref());
+            let body = EitherBody::<(), _>::right(body);
+            body.boxed()
+        }
 
-        let waker = futures_util::task::noop_waker();
+        assert_eq!(none_body().size(), BodySize::None);
-        let mut cx = Context::from_waker(&waker);
+        assert_eq!(none_body().try_into_bytes().unwrap(), Bytes::new());
-        let mut data = Bytes::from_static(b"test");
+        assert_poll_next_none!(Pin::new(&mut none_body()));
-        // take returns whole chunk
-        assert_eq!(data.take_complete_body(), b"test".as_ref());
-        // subsequent poll_next returns None
-        assert_eq!(Pin::new(&mut data).poll_next(&mut cx), Poll::Ready(None));
     }
 
     // down-casting used to be done with a method on MessageBody trait

actix-http/src/body/none.rs

@@ -42,12 +42,7 @@ impl MessageBody for None {
     }
 
     #[inline]
-    fn is_complete_body(&self) -> bool {
+    fn try_into_bytes(self) -> Result<Bytes, Self> {
-        true
+        Ok(Bytes::new())
-    }
-
-    #[inline]
-    fn take_complete_body(&mut self) -> Bytes {
-        Bytes::new()
     }
 }

actix-http/src/body/size.rs

@@ -1,9 +1,11 @@
 /// Body size hint.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BodySize {
-    /// Absence of body can be assumed from method or status code.
+    /// Implicitly empty body.
     ///
-    /// Will skip writing Content-Length header.
+    /// Will omit the Content-Length header. Used for responses to certain methods (e.g., `HEAD`) or
+    /// with particular status codes (e.g., 204 No Content). Consumers that read this as a body size
+    /// hint are allowed to make optimizations that skip reading or writing the payload.
     None,
 
     /// Known size body.
@@ -18,6 +20,9 @@ pub enum BodySize {
 }
 
 impl BodySize {
+    /// Equivalent to `BodySize::Sized(0)`;
+    pub const ZERO: Self = Self::Sized(0);
+
     /// Returns true if size hint indicates omitted or empty body.
     ///
     /// Streams will return false because it cannot be known without reading the stream.

actix-http/src/body/sized_stream.rs

@@ -27,6 +27,7 @@ where
     S: Stream<Item = Result<Bytes, E>>,
     E: Into<Box<dyn StdError>> + 'static,
 {
+    #[inline]
     pub fn new(size: u64, stream: S) -> Self {
         SizedStream { size, stream }
     }
@@ -41,6 +42,7 @@ where
 {
     type Error = E;
 
+    #[inline]
     fn size(&self) -> BodySize {
         BodySize::Sized(self.size as u64)
     }

actix-http/src/builder.rs

@@ -36,6 +36,7 @@ where
     <S::Service as Service<Request>>::Future: 'static,
 {
     /// Create instance of `ServiceConfigBuilder`
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         HttpServiceBuilder {
             keep_alive: KeepAlive::Timeout(5),

actix-http/src/encoding/decoder.rs

@@ -28,11 +28,14 @@ use crate::{
 
 const MAX_CHUNK_SIZE_DECODE_IN_PLACE: usize = 2049;
 
-pub struct Decoder<S> {
+pin_project_lite::pin_project! {
-    decoder: Option<ContentDecoder>,
+    pub struct Decoder<S> {
-    stream: S,
+        decoder: Option<ContentDecoder>,
-    eof: bool,
+        #[pin]
-    fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
+        stream: S,
+        eof: bool,
+        fut: Option<JoinHandle<Result<(Option<Bytes>, ContentDecoder), io::Error>>>,
+    }
 }
 
 impl<S> Decoder<S>
@@ -89,42 +92,44 @@ where
 
 impl<S> Stream for Decoder<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Result<Bytes, PayloadError>>,
 {
     type Item = Result<Bytes, PayloadError>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
         loop {
-            if let Some(ref mut fut) = self.fut {
+            if let Some(ref mut fut) = this.fut {
                 let (chunk, decoder) =
                     ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
 
-                self.decoder = Some(decoder);
+                *this.decoder = Some(decoder);
-                self.fut.take();
+                this.fut.take();
 
                 if let Some(chunk) = chunk {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
             }
 
-            if self.eof {
+            if *this.eof {
                 return Poll::Ready(None);
             }
 
-            match ready!(Pin::new(&mut self.stream).poll_next(cx)) {
+            match ready!(this.stream.as_mut().poll_next(cx)) {
                 Some(Err(err)) => return Poll::Ready(Some(Err(err))),
 
                 Some(Ok(chunk)) => {
-                    if let Some(mut decoder) = self.decoder.take() {
+                    if let Some(mut decoder) = this.decoder.take() {
                         if chunk.len() < MAX_CHUNK_SIZE_DECODE_IN_PLACE {
                             let chunk = decoder.feed_data(chunk)?;
-                            self.decoder = Some(decoder);
+                            *this.decoder = Some(decoder);
 
                             if let Some(chunk) = chunk {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
                         } else {
-                            self.fut = Some(spawn_blocking(move || {
+                            *this.fut = Some(spawn_blocking(move || {
                                 let chunk = decoder.feed_data(chunk)?;
                                 Ok((chunk, decoder))
                             }));
@@ -137,9 +142,9 @@ where
                 }
 
                 None => {
-                    self.eof = true;
+                    *this.eof = true;
 
-                    return if let Some(mut decoder) = self.decoder.take() {
+                    return if let Some(mut decoder) = this.decoder.take() {
                         match decoder.feed_eof() {
                             Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
                             Ok(None) => Poll::Ready(None),

actix-http/src/encoding/encoder.rs

@@ -25,7 +25,7 @@ use zstd::stream::write::Encoder as ZstdEncoder;
 
 use super::Writer;
 use crate::{
-    body::{BodySize, MessageBody},
+    body::{self, BodySize, MessageBody},
     error::BlockingError,
     header::{self, ContentEncoding, HeaderValue, CONTENT_ENCODING},
     ResponseHead, StatusCode,
@@ -46,14 +46,16 @@ pin_project! {
 impl<B: MessageBody> Encoder<B> {
     fn none() -> Self {
         Encoder {
-            body: EncoderBody::None,
+            body: EncoderBody::None {
+                body: body::None::new(),
+            },
             encoder: None,
             fut: None,
             eof: true,
         }
     }
 
-    pub fn response(encoding: ContentEncoding, head: &mut ResponseHead, mut body: B) -> Self {
+    pub fn response(encoding: ContentEncoding, head: &mut ResponseHead, body: B) -> Self {
         let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
             || head.status == StatusCode::SWITCHING_PROTOCOLS
             || head.status == StatusCode::NO_CONTENT
@@ -65,11 +67,9 @@ impl<B: MessageBody> Encoder<B> {
             return Self::none();
         }
 
-        let body = if body.is_complete_body() {
+        let body = match body.try_into_bytes() {
-            let body = body.take_complete_body();
+            Ok(body) => EncoderBody::Full { body },
-            EncoderBody::Full { body }
+            Err(body) => EncoderBody::Stream { body },
-        } else {
-            EncoderBody::Stream { body }
         };
 
         if can_encode {
@@ -98,7 +98,7 @@ impl<B: MessageBody> Encoder<B> {
 pin_project! {
     #[project = EncoderBodyProj]
     enum EncoderBody<B> {
-        None,
+        None { body: body::None },
         Full { body: Bytes },
         Stream { #[pin] body: B },
     }
@@ -110,9 +110,10 @@ where
 {
     type Error = EncoderError;
 
+    #[inline]
     fn size(&self) -> BodySize {
         match self {
-            EncoderBody::None => BodySize::None,
+            EncoderBody::None { body } => body.size(),
             EncoderBody::Full { body } => body.size(),
             EncoderBody::Stream { body } => body.size(),
         }
@@ -123,7 +124,9 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.project() {
-            EncoderBodyProj::None => Poll::Ready(None),
+            EncoderBodyProj::None { body } => {
+                Pin::new(body).poll_next(cx).map_err(|err| match err {})
+            }
             EncoderBodyProj::Full { body } => {
                 Pin::new(body).poll_next(cx).map_err(|err| match err {})
             }
@@ -133,21 +136,15 @@ where
         }
     }
 
-    fn is_complete_body(&self) -> bool {
+    #[inline]
+    fn try_into_bytes(self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
         match self {
-            EncoderBody::None => true,
+            EncoderBody::None { body } => Ok(body.try_into_bytes().unwrap()),
-            EncoderBody::Full { .. } => true,
+            EncoderBody::Full { body } => Ok(body.try_into_bytes().unwrap()),
-            EncoderBody::Stream { .. } => false,
+            _ => Err(self),
-        }
-    }
-
-    fn take_complete_body(&mut self) -> Bytes {
-        match self {
-            EncoderBody::None => Bytes::new(),
-            EncoderBody::Full { body } => body.take_complete_body(),
-            EncoderBody::Stream { .. } => {
-                panic!("EncoderBody::Stream variant cannot be taken")
-            }
         }
     }
 }
@@ -158,6 +155,7 @@ where
 {
     type Error = EncoderError;
 
+    #[inline]
     fn size(&self) -> BodySize {
         if self.encoder.is_some() {
             BodySize::Stream
@@ -234,19 +232,21 @@ where
         }
     }
 
-    fn is_complete_body(&self) -> bool {
+    #[inline]
+    fn try_into_bytes(mut self) -> Result<Bytes, Self>
+    where
+        Self: Sized,
+    {
         if self.encoder.is_some() {
-            false
+            Err(self)
         } else {
-            self.body.is_complete_body()
+            match self.body.try_into_bytes() {
-        }
+                Ok(body) => Ok(body),
-    }
+                Err(body) => {
-
+                    self.body = body;
-    fn take_complete_body(&mut self) -> Bytes {
+                    Err(self)
-        if self.encoder.is_some() {
+                }
-            panic!("compressed body stream cannot be taken")
+            }
-        } else {
-            self.body.take_complete_body()
         }
     }
 }

actix-http/src/error.rs

@@ -332,31 +332,28 @@ impl From<PayloadError> for Error {
 }
 
 /// A set of errors that can occur during dispatching HTTP requests.
-#[derive(Debug, Display, Error, From)]
+#[derive(Debug, Display, From)]
-#[non_exhaustive]
 pub enum DispatchError {
-    /// Service error
+    /// Service error.
-    // FIXME: display and error type
     #[display(fmt = "Service Error")]
-    Service(#[error(not(source))] Response<BoxBody>),
+    Service(Response<BoxBody>),
 
-    /// Body error
+    /// Body streaming error.
-    // FIXME: display and error type
+    #[display(fmt = "Body error: {}", _0)]
-    #[display(fmt = "Body Error")]
+    Body(Box<dyn StdError>),
-    Body(#[error(not(source))] Box<dyn StdError>),
 
-    /// Upgrade service error
+    /// Upgrade service error.
     Upgrade,
 
     /// An `io::Error` that occurred while trying to read or write to a network stream.
     #[display(fmt = "IO error: {}", _0)]
     Io(io::Error),
 
-    /// Http request parse error.
+    /// Request parse error.
-    #[display(fmt = "Parse error: {}", _0)]
+    #[display(fmt = "Request parse error: {}", _0)]
     Parse(ParseError),
 
-    /// Http/2 error
+    /// HTTP/2 error.
     #[display(fmt = "{}", _0)]
     H2(h2::Error),
 
@@ -368,21 +365,23 @@ pub enum DispatchError {
     #[display(fmt = "Connection shutdown timeout")]
     DisconnectTimeout,
 
-    /// Payload is not consumed
+    /// Internal error.
-    #[display(fmt = "Task is completed but request's payload is not consumed")]
-    PayloadIsNotConsumed,
-
-    /// Malformed request
-    #[display(fmt = "Malformed request")]
-    MalformedRequest,
-
-    /// Internal error
     #[display(fmt = "Internal error")]
     InternalError,
+}
 
-    /// Unknown error
+impl StdError for DispatchError {
-    #[display(fmt = "Unknown error")]
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-    Unknown,
+        match self {
+            // TODO: error source extraction?
+            DispatchError::Service(_res) => None,
+            DispatchError::Body(err) => Some(&**err),
+            DispatchError::Io(err) => Some(err),
+            DispatchError::Parse(err) => Some(err),
+            DispatchError::H2(err) => Some(err),
+            _ => None,
+        }
+    }
 }
 
 /// A set of error that can occur during parsing content type.

actix-http/src/h1/client.rs

@@ -5,13 +5,15 @@ use bitflags::bitflags;
 use bytes::{Bytes, BytesMut};
 use http::{Method, Version};
 
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
+use super::{
-use super::{decoder, encoder, reserve_readbuf};
+    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
-use super::{Message, MessageType};
+    encoder, reserve_readbuf, Message, MessageType,
-use crate::body::BodySize;
+};
-use crate::config::ServiceConfig;
+use crate::{
-use crate::error::{ParseError, PayloadError};
+    body::BodySize,
-use crate::message::{ConnectionType, RequestHeadType, ResponseHead};
+    error::{ParseError, PayloadError},
+    ConnectionType, RequestHeadType, ResponseHead, ServiceConfig,
+};
 
 bitflags! {
     struct Flags: u8 {

actix-http/src/h1/codec.rs

@@ -5,15 +5,13 @@ use bitflags::bitflags;
 use bytes::BytesMut;
 use http::{Method, Version};
 
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
+use super::{
-use super::{decoder, encoder};
+    decoder::{self, PayloadDecoder, PayloadItem, PayloadType},
-use super::{Message, MessageType};
+    encoder, Message, MessageType,
-use crate::body::BodySize;
+};
-use crate::config::ServiceConfig;
+use crate::{
-use crate::error::ParseError;
+    body::BodySize, error::ParseError, ConnectionType, Request, Response, ServiceConfig,
-use crate::message::ConnectionType;
+};
-use crate::request::Request;
-use crate::response::Response;
 
 bitflags! {
     struct Flags: u8 {
@@ -199,7 +197,7 @@ mod tests {
     use http::Method;
 
     use super::*;
-    use crate::HttpMessage;
+    use crate::HttpMessage as _;
 
     #[actix_rt::test]
     async fn test_http_request_chunked_payload_and_next_message() {

actix-http/src/h1/decoder.rs

@@ -2,17 +2,14 @@ use std::{convert::TryFrom, io, marker::PhantomData, mem::MaybeUninit, task::Pol
 
 use actix_codec::Decoder;
 use bytes::{Bytes, BytesMut};
-use http::header::{HeaderName, HeaderValue};
+use http::{
-use http::{header, Method, StatusCode, Uri, Version};
+    header::{self, HeaderName, HeaderValue},
+    Method, StatusCode, Uri, Version,
+};
 use log::{debug, error, trace};
 
 use super::chunked::ChunkedState;
-use crate::{
+use crate::{error::ParseError, header::HeaderMap, ConnectionType, Request, ResponseHead};
-    error::ParseError,
-    header::HeaderMap,
-    message::{ConnectionType, ResponseHead},
-    request::Request,
-};
 
 pub(crate) const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;
@@ -50,7 +47,7 @@ pub(crate) enum PayloadLength {
 }
 
 pub(crate) trait MessageType: Sized {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>);
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>);
 
     fn set_expect(&mut self);
 
@@ -193,8 +190,8 @@ pub(crate) trait MessageType: Sized {
 }
 
 impl MessageType for Request {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>) {
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
-        if let Some(ctype) = ctype {
+        if let Some(ctype) = conn_type {
             self.head_mut().set_connection_type(ctype);
         }
     }
@@ -278,8 +275,8 @@ impl MessageType for Request {
 }
 
 impl MessageType for ResponseHead {
-    fn set_connection_type(&mut self, ctype: Option<ConnectionType>) {
+    fn set_connection_type(&mut self, conn_type: Option<ConnectionType>) {
-        if let Some(ctype) = ctype {
+        if let Some(ctype) = conn_type {
             ResponseHead::set_connection_type(self, ctype);
         }
     }

actix-http/src/h1/dispatcher.rs

@@ -15,14 +15,14 @@ use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use futures_core::ready;
 use log::{error, trace};
-use pin_project::pin_project;
+use pin_project_lite::pin_project;
 
 use crate::{
     body::{BodySize, BoxBody, MessageBody},
     config::ServiceConfig,
     error::{DispatchError, ParseError, PayloadError},
     service::HttpFlow,
-    Extensions, OnConnectData, Request, Response, StatusCode,
+    Error, Extensions, OnConnectData, Request, Response, StatusCode,
 };
 
 use super::{
@@ -46,79 +46,111 @@ bitflags! {
     }
 }
 
-#[pin_project]
+// there's 2 versions of Dispatcher state because of:
-/// Dispatcher for HTTP/1.1 protocol
+// https://github.com/taiki-e/pin-project-lite/issues/3
-pub struct Dispatcher<T, S, B, X, U>
+//
-where
+// tl;dr: pin-project-lite doesn't play well with other attribute macros
-    S: Service<Request>,
-    S::Error: Into<Response<BoxBody>>,
 
-    B: MessageBody,
+#[cfg(not(test))]
+pin_project! {
+    /// Dispatcher for HTTP/1.1 protocol
+    pub struct Dispatcher<T, S, B, X, U>
+    where
+        S: Service<Request>,
+        S::Error: Into<Response<BoxBody>>,
 
-    X: Service<Request, Response = Request>,
+        B: MessageBody,
-    X::Error: Into<Response<BoxBody>>,
 
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
+        X: Service<Request, Response = Request>,
-    U::Error: fmt::Display,
+        X::Error: Into<Response<BoxBody>>,
-{
-    #[pin]
-    inner: DispatcherState<T, S, B, X, U>,
 
-    #[cfg(test)]
+        U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    poll_count: u64,
+        U::Error: fmt::Display,
+    {
+        #[pin]
+        inner: DispatcherState<T, S, B, X, U>,
+    }
 }
 
-#[pin_project(project = DispatcherStateProj)]
+#[cfg(test)]
-enum DispatcherState<T, S, B, X, U>
+pin_project! {
-where
+    /// Dispatcher for HTTP/1.1 protocol
-    S: Service<Request>,
+    pub struct Dispatcher<T, S, B, X, U>
-    S::Error: Into<Response<BoxBody>>,
+    where
+        S: Service<Request>,
+        S::Error: Into<Response<BoxBody>>,
 
-    B: MessageBody,
+        B: MessageBody,
 
-    X: Service<Request, Response = Request>,
+        X: Service<Request, Response = Request>,
-    X::Error: Into<Response<BoxBody>>,
+        X::Error: Into<Response<BoxBody>>,
 
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
+        U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
+        U::Error: fmt::Display,
-{
+    {
-    Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
+        #[pin]
-    Upgrade(#[pin] U::Future),
+        inner: DispatcherState<T, S, B, X, U>,
+
+        // used in tests
+        poll_count: u64,
+    }
 }
 
-#[pin_project(project = InnerDispatcherProj)]
+pin_project! {
-struct InnerDispatcher<T, S, B, X, U>
+    #[project = DispatcherStateProj]
-where
+    enum DispatcherState<T, S, B, X, U>
-    S: Service<Request>,
+    where
-    S::Error: Into<Response<BoxBody>>,
+        S: Service<Request>,
+        S::Error: Into<Response<BoxBody>>,
 
-    B: MessageBody,
+        B: MessageBody,
 
-    X: Service<Request, Response = Request>,
+        X: Service<Request, Response = Request>,
-    X::Error: Into<Response<BoxBody>>,
+        X::Error: Into<Response<BoxBody>>,
 
-    U: Service<(Request, Framed<T, Codec>), Response = ()>,
+        U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
+        U::Error: fmt::Display,
-{
+    {
-    flow: Rc<HttpFlow<S, X, U>>,
+        Normal { #[pin] inner: InnerDispatcher<T, S, B, X, U> },
-    flags: Flags,
+        Upgrade { #[pin] fut: U::Future },
-    peer_addr: Option<net::SocketAddr>,
+    }
-    conn_data: Option<Rc<Extensions>>,
+}
-    error: Option<DispatchError>,
 
-    #[pin]
+pin_project! {
-    state: State<S, B, X>,
+    #[project = InnerDispatcherProj]
-    payload: Option<PayloadSender>,
+    struct InnerDispatcher<T, S, B, X, U>
-    messages: VecDeque<DispatcherMessage>,
+    where
+        S: Service<Request>,
+        S::Error: Into<Response<BoxBody>>,
 
-    ka_expire: Instant,
+        B: MessageBody,
-    #[pin]
-    ka_timer: Option<Sleep>,
 
-    io: Option<T>,
+        X: Service<Request, Response = Request>,
-    read_buf: BytesMut,
+        X::Error: Into<Response<BoxBody>>,
-    write_buf: BytesMut,
+
-    codec: Codec,
+        U: Service<(Request, Framed<T, Codec>), Response = ()>,
+        U::Error: fmt::Display,
+    {
+        flow: Rc<HttpFlow<S, X, U>>,
+        flags: Flags,
+        peer_addr: Option<net::SocketAddr>,
+        conn_data: Option<Rc<Extensions>>,
+        error: Option<DispatchError>,
+
+        #[pin]
+        state: State<S, B, X>,
+        payload: Option<PayloadSender>,
+        messages: VecDeque<DispatcherMessage>,
+
+        ka_expire: Instant,
+        #[pin]
+        ka_timer: Option<Sleep>,
+
+        io: Option<T>,
+        read_buf: BytesMut,
+        write_buf: BytesMut,
+        codec: Codec,
+    }
 }
 
 enum DispatcherMessage {
@@ -127,19 +159,21 @@ enum DispatcherMessage {
     Error(Response<()>),
 }
 
-#[pin_project(project = StateProj)]
+pin_project! {
-enum State<S, B, X>
+    #[project = StateProj]
-where
+    enum State<S, B, X>
-    S: Service<Request>,
+    where
-    X: Service<Request, Response = Request>,
+        S: Service<Request>,
+        X: Service<Request, Response = Request>,
 
-    B: MessageBody,
+        B: MessageBody,
-{
+    {
-    None,
+        None,
-    ExpectCall(#[pin] X::Future),
+        ExpectCall { #[pin] fut: X::Future },
-    ServiceCall(#[pin] S::Future),
+        ServiceCall { #[pin] fut: S::Future },
-    SendPayload(#[pin] B),
+        SendPayload { #[pin] body: B },
-    SendErrorPayload(#[pin] BoxBody),
+        SendErrorPayload { #[pin] body: BoxBody },
+    }
 }
 
 impl<S, B, X> State<S, B, X>
@@ -198,25 +232,27 @@ where
         };
 
         Dispatcher {
-            inner: DispatcherState::Normal(InnerDispatcher {
+            inner: DispatcherState::Normal {
-                flow,
+                inner: InnerDispatcher {
-                flags,
+                    flow,
-                peer_addr,
+                    flags,
-                conn_data: conn_data.0.map(Rc::new),
+                    peer_addr,
-                error: None,
+                    conn_data: conn_data.0.map(Rc::new),
+                    error: None,
 
-                state: State::None,
+                    state: State::None,
-                payload: None,
+                    payload: None,
-                messages: VecDeque::new(),
+                    messages: VecDeque::new(),
 
-                ka_expire,
+                    ka_expire,
-                ka_timer,
+                    ka_timer,
 
-                io: Some(io),
+                    io: Some(io),
-                read_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
+                    read_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
-                write_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
+                    write_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
-                codec: Codec::new(config),
+                    codec: Codec::new(config),
-            }),
+                },
+            },
 
             #[cfg(test)]
             poll_count: 0,
@@ -316,7 +352,7 @@ where
         let size = self.as_mut().send_response_inner(message, &body)?;
         let state = match size {
             BodySize::None | BodySize::Sized(0) => State::None,
-            _ => State::SendPayload(body),
+            _ => State::SendPayload { body },
         };
         self.project().state.set(state);
         Ok(())
@@ -330,7 +366,7 @@ where
         let size = self.as_mut().send_response_inner(message, &body)?;
         let state = match size {
             BodySize::None | BodySize::Sized(0) => State::None,
-            _ => State::SendErrorPayload(body),
+            _ => State::SendErrorPayload { body },
         };
         self.project().state.set(state);
         Ok(())
@@ -356,12 +392,12 @@ where
                         // Handle `EXPECT: 100-Continue` header
                         if req.head().expect() {
                             // set InnerDispatcher state and continue loop to poll it.
-                            let task = this.flow.expect.call(req);
+                            let fut = this.flow.expect.call(req);
-                            this.state.set(State::ExpectCall(task));
+                            this.state.set(State::ExpectCall { fut });
                         } else {
                             // the same as expect call.
-                            let task = this.flow.service.call(req);
+                            let fut = this.flow.service.call(req);
-                            this.state.set(State::ServiceCall(task));
+                            this.state.set(State::ServiceCall { fut });
                         };
                     }
 
@@ -381,7 +417,7 @@ where
                     // all messages are dealt with.
                     None => return Ok(PollResponse::DoNothing),
                 },
-                StateProj::ServiceCall(fut) => match fut.poll(cx) {
+                StateProj::ServiceCall { fut } => match fut.poll(cx) {
                     // service call resolved. send response.
                     Poll::Ready(Ok(res)) => {
                         let (res, body) = res.into().replace_body(());
@@ -407,11 +443,11 @@ where
                     }
                 },
 
-                StateProj::SendPayload(mut stream) => {
+                StateProj::SendPayload { mut body } => {
                     // keep populate writer buffer until buffer size limit hit,
                     // get blocked or finished.
                     while this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
-                        match stream.as_mut().poll_next(cx) {
+                        match body.as_mut().poll_next(cx) {
                             Poll::Ready(Some(Ok(item))) => {
                                 this.codec
                                     .encode(Message::Chunk(Some(item)), this.write_buf)?;
@@ -437,13 +473,13 @@ where
                     return Ok(PollResponse::DrainWriteBuf);
                 }
 
-                StateProj::SendErrorPayload(mut stream) => {
+                StateProj::SendErrorPayload { mut body } => {
                     // TODO: de-dupe impl with SendPayload
 
                     // keep populate writer buffer until buffer size limit hit,
                     // get blocked or finished.
                     while this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
-                        match stream.as_mut().poll_next(cx) {
+                        match body.as_mut().poll_next(cx) {
                             Poll::Ready(Some(Ok(item))) => {
                                 this.codec
                                     .encode(Message::Chunk(Some(item)), this.write_buf)?;
@@ -458,7 +494,9 @@ where
                             }
 
                             Poll::Ready(Some(Err(err))) => {
-                                return Err(DispatchError::Service(err.into()))
+                                return Err(DispatchError::Body(
+                                    Error::new_body().with_cause(err).into(),
+                                ))
                             }
 
                             Poll::Pending => return Ok(PollResponse::DoNothing),
@@ -469,14 +507,14 @@ where
                     return Ok(PollResponse::DrainWriteBuf);
                 }
 
-                StateProj::ExpectCall(fut) => match fut.poll(cx) {
+                StateProj::ExpectCall { fut } => match fut.poll(cx) {
                     // expect resolved. write continue to buffer and set InnerDispatcher state
                     // to service call.
                     Poll::Ready(Ok(req)) => {
                         this.write_buf
                             .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
                         let fut = this.flow.service.call(req);
-                        this.state.set(State::ServiceCall(fut));
+                        this.state.set(State::ServiceCall { fut });
                     }
 
                     // send expect error as response
@@ -502,25 +540,25 @@ where
         let mut this = self.as_mut().project();
         if req.head().expect() {
             // set dispatcher state so the future is pinned.
-            let task = this.flow.expect.call(req);
+            let fut = this.flow.expect.call(req);
-            this.state.set(State::ExpectCall(task));
+            this.state.set(State::ExpectCall { fut });
         } else {
             // the same as above.
-            let task = this.flow.service.call(req);
+            let fut = this.flow.service.call(req);
-            this.state.set(State::ServiceCall(task));
+            this.state.set(State::ServiceCall { fut });
         };
 
         // eagerly poll the future for once(or twice if expect is resolved immediately).
         loop {
             match self.as_mut().project().state.project() {
-                StateProj::ExpectCall(fut) => {
+                StateProj::ExpectCall { fut } => {
                     match fut.poll(cx) {
                         // expect is resolved. continue loop and poll the service call branch.
                         Poll::Ready(Ok(req)) => {
                             self.as_mut().send_continue();
                             let mut this = self.as_mut().project();
-                            let task = this.flow.service.call(req);
+                            let fut = this.flow.service.call(req);
-                            this.state.set(State::ServiceCall(task));
+                            this.state.set(State::ServiceCall { fut });
                             continue;
                         }
                         // future is pending. return Ok(()) to notify that a new state is
@@ -536,7 +574,7 @@ where
                         }
                     }
                 }
-                StateProj::ServiceCall(fut) => {
+                StateProj::ServiceCall { fut } => {
                     // return no matter the service call future's result.
                     return match fut.poll(cx) {
                         // future is resolved. send response and return a result. On success
@@ -608,10 +646,11 @@ where
                                     Payload is attached to Request and passed to Service::call
                                     where the state can be collected and consumed.
                                     */
-                                    let (ps, pl) = Payload::create(false);
+                                    let (sender, payload) = Payload::create(false);
-                                    let (req1, _) = req.replace_payload(crate::Payload::H1(pl));
+                                    let (req1, _) =
+                                        req.replace_payload(crate::Payload::H1 { payload });
                                     req = req1;
-                                    *this.payload = Some(ps);
+                                    *this.payload = Some(sender);
                                 }
 
                                 // Request has no payload.
@@ -901,7 +940,7 @@ where
         }
 
         match this.inner.project() {
-            DispatcherStateProj::Normal(mut inner) => {
+            DispatcherStateProj::Normal { mut inner } => {
                 inner.as_mut().poll_keepalive(cx)?;
 
                 if inner.flags.contains(Flags::SHUTDOWN) {
@@ -941,7 +980,7 @@ where
                                 self.as_mut()
                                     .project()
                                     .inner
-                                    .set(DispatcherState::Upgrade(upgrade));
+                                    .set(DispatcherState::Upgrade { fut: upgrade });
                                 return self.poll(cx);
                             }
                         };
@@ -993,8 +1032,8 @@ where
                     }
                 }
             }
-            DispatcherStateProj::Upgrade(fut) => fut.poll(cx).map_err(|e| {
+            DispatcherStateProj::Upgrade { fut: upgrade } => upgrade.poll(cx).map_err(|err| {
-                error!("Upgrade handler error: {}", e);
+                error!("Upgrade handler error: {}", err);
                 DispatchError::Upgrade
             }),
         }
@@ -1088,7 +1127,7 @@ mod tests {
                 Poll::Ready(res) => assert!(res.is_err()),
             }
 
-            if let DispatcherStateProj::Normal(inner) = h1.project().inner.project() {
+            if let DispatcherStateProj::Normal { inner } = h1.project().inner.project() {
                 assert!(inner.flags.contains(Flags::READ_DISCONNECT));
                 assert_eq!(
                     &inner.project().io.take().unwrap().write_buf[..26],
@@ -1123,7 +1162,7 @@ mod tests {
 
             actix_rt::pin!(h1);
 
-            assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
+            assert!(matches!(&h1.inner, DispatcherState::Normal { .. }));
 
             match h1.as_mut().poll(cx) {
                 Poll::Pending => panic!("first poll should not be pending"),
@@ -1133,7 +1172,7 @@ mod tests {
             // polls: initial => shutdown
             assert_eq!(h1.poll_count, 2);
 
-            if let DispatcherStateProj::Normal(inner) = h1.project().inner.project() {
+            if let DispatcherStateProj::Normal { inner } = h1.project().inner.project() {
                 let res = &mut inner.project().io.take().unwrap().write_buf[..];
                 stabilize_date_header(res);
 
@@ -1177,7 +1216,7 @@ mod tests {
 
             actix_rt::pin!(h1);
 
-            assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
+            assert!(matches!(&h1.inner, DispatcherState::Normal { .. }));
 
             match h1.as_mut().poll(cx) {
                 Poll::Pending => panic!("first poll should not be pending"),
@@ -1187,7 +1226,7 @@ mod tests {
             // polls: initial => shutdown
             assert_eq!(h1.poll_count, 1);
 
-            if let DispatcherStateProj::Normal(inner) = h1.project().inner.project() {
+            if let DispatcherStateProj::Normal { inner } = h1.project().inner.project() {
                 let res = &mut inner.project().io.take().unwrap().write_buf[..];
                 stabilize_date_header(res);
 
@@ -1237,13 +1276,13 @@ mod tests {
             actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_pending());
-            assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
+            assert!(matches!(&h1.inner, DispatcherState::Normal { .. }));
 
             // polls: manual
             assert_eq!(h1.poll_count, 1);
             eprintln!("poll count: {}", h1.poll_count);
 
-            if let DispatcherState::Normal(ref inner) = h1.inner {
+            if let DispatcherState::Normal { ref inner } = h1.inner {
                 let io = inner.io.as_ref().unwrap();
                 let res = &io.write_buf()[..];
                 assert_eq!(
@@ -1258,7 +1297,7 @@ mod tests {
             // polls: manual manual shutdown
             assert_eq!(h1.poll_count, 3);
 
-            if let DispatcherState::Normal(ref inner) = h1.inner {
+            if let DispatcherState::Normal { ref inner } = h1.inner {
                 let io = inner.io.as_ref().unwrap();
                 let mut res = (&io.write_buf()[..]).to_owned();
                 stabilize_date_header(&mut res);
@@ -1309,12 +1348,12 @@ mod tests {
             actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_ready());
-            assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
+            assert!(matches!(&h1.inner, DispatcherState::Normal { .. }));
 
             // polls: manual shutdown
             assert_eq!(h1.poll_count, 2);
 
-            if let DispatcherState::Normal(ref inner) = h1.inner {
+            if let DispatcherState::Normal { ref inner } = h1.inner {
                 let io = inner.io.as_ref().unwrap();
                 let mut res = (&io.write_buf()[..]).to_owned();
                 stabilize_date_header(&mut res);
@@ -1386,7 +1425,7 @@ mod tests {
             actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_ready());
-            assert!(matches!(&h1.inner, DispatcherState::Upgrade(_)));
+            assert!(matches!(&h1.inner, DispatcherState::Upgrade { .. }));
 
             // polls: manual shutdown
             assert_eq!(h1.poll_count, 2);

actix-http/src/h1/encoder.rs

@@ -1,19 +1,19 @@
-use std::io::Write;
+use std::{
-use std::marker::PhantomData;
+    cmp,
-use std::ptr::copy_nonoverlapping;
+    io::{self, Write as _},
-use std::slice::from_raw_parts_mut;
+    marker::PhantomData,
-use std::{cmp, io};
+    ptr::copy_nonoverlapping,
+    slice::from_raw_parts_mut,
+};
 
 use bytes::{BufMut, BytesMut};
 
 use crate::{
     body::BodySize,
-    config::ServiceConfig,
+    header::{
-    header::{map::Value, HeaderMap, HeaderName},
+        map::Value, HeaderMap, HeaderName, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
-    header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
+    },
-    helpers,
+    helpers, ConnectionType, RequestHeadType, Response, ServiceConfig, StatusCode, Version,
-    message::{ConnectionType, RequestHeadType},
-    Response, StatusCode, Version,
 };
 
 const AVERAGE_HEADER_SIZE: usize = 30;

actix-http/src/h1/expect.rs

@@ -1,8 +1,7 @@
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ready, Ready};
 
-use crate::error::Error;
+use crate::{Error, Request};
-use crate::request::Request;
 
 pub struct ExpectHandler;
 

actix-http/src/h1/mod.rs

@@ -59,7 +59,7 @@ pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::request::Request;
+    use crate::Request;
 
     impl Message<Request> {
         pub fn message(self) -> Request {

actix-http/src/h1/payload.rs

@@ -1,9 +1,12 @@
 //! Payload stream
-use std::cell::RefCell;
+
-use std::collections::VecDeque;
+use std::{
-use std::pin::Pin;
+    cell::RefCell,
-use std::rc::{Rc, Weak};
+    collections::VecDeque,
-use std::task::{Context, Poll, Waker};
+    pin::Pin,
+    rc::{Rc, Weak},
+    task::{Context, Poll, Waker},
+};
 
 use bytes::Bytes;
 use futures_core::Stream;
@@ -22,39 +25,32 @@ pub enum PayloadStatus {
 
 /// Buffered stream of bytes chunks
 ///
-/// Payload stores chunks in a vector. First chunk can be received with
+/// Payload stores chunks in a vector. First chunk can be received with `poll_next`. Payload does
-/// `.readany()` method. Payload stream is not thread safe. Payload does not
+/// not notify current task when new data is available.
-/// notify current task when new data is available.
 ///
-/// Payload stream can be used as `Response` body stream.
+/// Payload can be used as `Response` body stream.
 #[derive(Debug)]
 pub struct Payload {
     inner: Rc<RefCell<Inner>>,
 }
 
 impl Payload {
-    /// Create payload stream.
+    /// Creates a payload stream.
     ///
-    /// This method construct two objects responsible for bytes stream
+    /// This method construct two objects responsible for bytes stream generation:
-    /// generation.
+    /// - `PayloadSender` - *Sender* side of the stream
-    ///
+    /// - `Payload` - *Receiver* side of the stream
-    /// * `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 {
+            PayloadSender::new(Rc::downgrade(&shared)),
-                inner: Rc::downgrade(&shared),
-            },
             Payload { inner: shared },
         )
     }
 
-    /// Create empty payload
+    /// Creates an empty payload.
-    #[doc(hidden)]
+    pub(crate) fn empty() -> Payload {
-    pub fn empty() -> Payload {
         Payload {
             inner: Rc::new(RefCell::new(Inner::new(true))),
         }
@@ -77,14 +73,6 @@ impl Payload {
     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 {
@@ -94,7 +82,7 @@ impl Stream for Payload {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
+        Pin::new(&mut *self.inner.borrow_mut()).poll_next(cx)
     }
 }
 
@@ -104,6 +92,10 @@ pub struct PayloadSender {
 }
 
 impl PayloadSender {
+    fn new(inner: Weak<RefCell<Inner>>) -> Self {
+        Self { inner }
+    }
+
     #[inline]
     pub fn set_error(&mut self, err: PayloadError) {
         if let Some(shared) = self.inner.upgrade() {
@@ -227,7 +219,10 @@ impl Inner {
         self.len
     }
 
-    fn readany(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, PayloadError>>> {
+    fn poll_next(
+        mut self: Pin<&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;
@@ -257,8 +252,18 @@ impl Inner {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
     use actix_utils::future::poll_fn;
+    use static_assertions::{assert_impl_all, assert_not_impl_any};
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin);
+    assert_not_impl_any!(Payload: Send, Sync, UnwindSafe, RefUnwindSafe);
+
+    assert_impl_all!(Inner: Unpin, Send, Sync);
+    assert_not_impl_any!(Inner: UnwindSafe, RefUnwindSafe);
 
     #[actix_rt::test]
     async fn test_unread_data() {
@@ -270,7 +275,10 @@ mod tests {
 
         assert_eq!(
             Bytes::from("data"),
-            poll_fn(|cx| payload.readany(cx)).await.unwrap().unwrap()
+            poll_fn(|cx| Pin::new(&mut payload).poll_next(cx))
+                .await
+                .unwrap()
+                .unwrap()
         );
     }
 }

actix-http/src/h1/service.rs

@@ -356,9 +356,9 @@ where
     type Future = Dispatcher<T, S, B, X, U>;
 
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self._poll_ready(cx).map_err(|e| {
+        self._poll_ready(cx).map_err(|err| {
-            log::error!("HTTP/1 service readiness error: {:?}", e);
+            log::error!("HTTP/1 service readiness error: {:?}", err);
-            DispatchError::Service(e)
+            DispatchError::Service(err)
         })
     }
 

actix-http/src/h1/upgrade.rs

@@ -2,9 +2,7 @@ use actix_codec::Framed;
 use actix_service::{Service, ServiceFactory};
 use futures_core::future::LocalBoxFuture;
 
-use crate::error::Error;
+use crate::{h1::Codec, Error, Request};
-use crate::h1::Codec;
-use crate::request::Request;
 
 pub struct UpgradeHandler;
 

actix-http/src/h1/utils.rs

@@ -9,9 +9,8 @@ use pin_project_lite::pin_project;
 
 use crate::{
     body::{BodySize, MessageBody},
-    error::Error,
     h1::{Codec, Message},
-    response::Response,
+    Error, Response,
 };
 
 pin_project! {
@@ -46,7 +45,7 @@ where
 impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    B: MessageBody + Unpin,
+    B: MessageBody,
     B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
@@ -82,7 +81,7 @@ where
                             // body is done when item is None
                             body_done = item.is_none();
                             if body_done {
-                                let _ = this.body.take();
+                                this.body.set(None);
                             }
                             let framed = this.framed.as_mut().as_pin_mut().unwrap();
                             framed

actix-http/src/h2/dispatcher.rs

@@ -108,8 +108,8 @@ where
             match Pin::new(&mut this.connection).poll_accept(cx)? {
                 Poll::Ready(Some((req, tx))) => {
                     let (parts, body) = req.into_parts();
-                    let pl = crate::h2::Payload::new(body);
+                    let payload = crate::h2::Payload::new(body);
-                    let pl = Payload::H2(pl);
+                    let pl = Payload::H2 { payload };
                     let mut req = Request::with_payload(pl);
 
                     let head = req.head_mut();
@@ -288,9 +288,11 @@ fn prepare_response(
     let _ = match size {
         BodySize::None | BodySize::Stream => None,
 
-        BodySize::Sized(0) => res
+        BodySize::Sized(0) => {
-            .headers_mut()
+            #[allow(clippy::declare_interior_mutable_const)]
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+            const HV_ZERO: HeaderValue = HeaderValue::from_static("0");
+            res.headers_mut().insert(CONTENT_LENGTH, HV_ZERO)
+        }
 
         BodySize::Sized(len) => {
             let mut buf = itoa::Buffer::new();

actix-http/src/h2/mod.rs

@@ -98,3 +98,14 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    use static_assertions::assert_impl_all;
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin, Send, Sync, UnwindSafe, RefUnwindSafe);
+}

actix-http/src/h2/service.rs

@@ -270,10 +270,10 @@ where
     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| {
+        self.flow.service.poll_ready(cx).map_err(|err| {
-            let e = e.into();
+            let err = err.into();
-            error!("Service readiness error: {:?}", e);
+            error!("Service readiness error: {:?}", err);
-            DispatchError::Service(e)
+            DispatchError::Service(err)
         })
     }
 
@@ -297,7 +297,6 @@ where
     T: AsyncRead + AsyncWrite + Unpin,
     S::Future: 'static,
 {
-    Incoming(Dispatcher<T, S, B, (), ()>),
     Handshake(
         Option<Rc<HttpFlow<S, (), ()>>>,
         Option<ServiceConfig>,
@@ -305,6 +304,7 @@ where
         OnConnectData,
         HandshakeWithTimeout<T>,
     ),
+    Established(Dispatcher<T, S, B, (), ()>),
 }
 
 pub struct H2ServiceHandlerResponse<T, S, B>
@@ -332,7 +332,6 @@ where
 
     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,
@@ -343,7 +342,7 @@ where
                 Ok((conn, timer)) => {
                     let on_connect_data = mem::take(conn_data);
 
-                    self.state = State::Incoming(Dispatcher::new(
+                    self.state = State::Established(Dispatcher::new(
                         conn,
                         srv.take().unwrap(),
                         config.take().unwrap(),
@@ -360,6 +359,8 @@ where
                     Poll::Ready(Err(err))
                 }
             },
+
+            State::Established(ref mut disp) => Pin::new(disp).poll(cx),
         }
     }
 }

actix-http/src/header/as_name.rs

@@ -16,6 +16,7 @@ pub trait Sealed {
 }
 
 impl Sealed for HeaderName {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(self))
     }
@@ -23,6 +24,7 @@ impl Sealed for HeaderName {
 impl AsHeaderName for HeaderName {}
 
 impl Sealed for &HeaderName {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(*self))
     }
@@ -30,6 +32,7 @@ impl Sealed for &HeaderName {
 impl AsHeaderName for &HeaderName {}
 
 impl Sealed for &str {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
@@ -37,6 +40,7 @@ impl Sealed for &str {
 impl AsHeaderName for &str {}
 
 impl Sealed for String {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
@@ -44,6 +48,7 @@ impl Sealed for String {
 impl AsHeaderName for String {}
 
 impl Sealed for &String {
+    #[inline]
     fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }

actix-http/src/header/into_pair.rs

@@ -1,22 +1,20 @@
-//! [`IntoHeaderPair`] trait and implementations.
+//! [`TryIntoHeaderPair`] trait and implementations.
 
 use std::convert::TryFrom as _;
 
-use http::{
+use super::{
-    header::{HeaderName, InvalidHeaderName, InvalidHeaderValue},
+    Header, HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue, TryIntoHeaderValue,
-    Error as HttpError, HeaderValue,
 };
+use crate::error::HttpError;
 
-use super::{Header, IntoHeaderValue};
+/// An interface for types that can be converted into a [`HeaderName`] + [`HeaderValue`] pair for
-
-/// An interface for types that can be converted into a [`HeaderName`]/[`HeaderValue`] pair for
 /// insertion into a [`HeaderMap`].
 ///
 /// [`HeaderMap`]: super::HeaderMap
-pub trait IntoHeaderPair: Sized {
+pub trait TryIntoHeaderPair: Sized {
     type Error: Into<HttpError>;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error>;
 }
 
 #[derive(Debug)]
@@ -34,14 +32,14 @@ impl From<InvalidHeaderPart> for HttpError {
     }
 }
 
-impl<V> IntoHeaderPair for (HeaderName, V)
+impl<V> TryIntoHeaderPair for (HeaderName, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let value = value
             .try_into_value()
@@ -50,14 +48,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&HeaderName, V)
+impl<V> TryIntoHeaderPair for (&HeaderName, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let value = value
             .try_into_value()
@@ -66,14 +64,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&[u8], V)
+impl<V> TryIntoHeaderPair for (&[u8], V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
         let value = value
@@ -83,14 +81,14 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (&str, V)
+impl<V> TryIntoHeaderPair for (&str, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
         let name = HeaderName::try_from(name).map_err(InvalidHeaderPart::Name)?;
         let value = value
@@ -100,23 +98,25 @@ where
     }
 }
 
-impl<V> IntoHeaderPair for (String, V)
+impl<V> TryIntoHeaderPair for (String, V)
 where
-    V: IntoHeaderValue,
+    V: TryIntoHeaderValue,
     V::Error: Into<InvalidHeaderValue>,
 {
     type Error = InvalidHeaderPart;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    #[inline]
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         let (name, value) = self;
-        (name.as_str(), value).try_into_header_pair()
+        (name.as_str(), value).try_into_pair()
     }
 }
 
-impl<T: Header> IntoHeaderPair for T {
+impl<T: Header> TryIntoHeaderPair for T {
-    type Error = <T as IntoHeaderValue>::Error;
+    type Error = <T as TryIntoHeaderValue>::Error;
 
-    fn try_into_header_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
+    #[inline]
+    fn try_into_pair(self) -> Result<(HeaderName, HeaderValue), Self::Error> {
         Ok((T::name(), self.try_into_value()?))
     }
 }

actix-http/src/header/into_value.rs

@@ -1,4 +1,4 @@
-//! [`IntoHeaderValue`] trait and implementations.
+//! [`TryIntoHeaderValue`] trait and implementations.
 
 use std::convert::TryFrom as _;
 
@@ -7,7 +7,7 @@ use http::{header::InvalidHeaderValue, Error as HttpError, HeaderValue};
 use mime::Mime;
 
 /// An interface for types that can be converted into a [`HeaderValue`].
-pub trait IntoHeaderValue: Sized {
+pub trait TryIntoHeaderValue: Sized {
     /// The type returned in the event of a conversion error.
     type Error: Into<HttpError>;
 
@@ -15,7 +15,7 @@ pub trait IntoHeaderValue: Sized {
     fn try_into_value(self) -> Result<HeaderValue, Self::Error>;
 }
 
-impl IntoHeaderValue for HeaderValue {
+impl TryIntoHeaderValue for HeaderValue {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -24,7 +24,7 @@ impl IntoHeaderValue for HeaderValue {
     }
 }
 
-impl IntoHeaderValue for &HeaderValue {
+impl TryIntoHeaderValue for &HeaderValue {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -33,7 +33,7 @@ impl IntoHeaderValue for &HeaderValue {
     }
 }
 
-impl IntoHeaderValue for &str {
+impl TryIntoHeaderValue for &str {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -42,7 +42,7 @@ impl IntoHeaderValue for &str {
     }
 }
 
-impl IntoHeaderValue for &[u8] {
+impl TryIntoHeaderValue for &[u8] {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -51,7 +51,7 @@ impl IntoHeaderValue for &[u8] {
     }
 }
 
-impl IntoHeaderValue for Bytes {
+impl TryIntoHeaderValue for Bytes {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -60,7 +60,7 @@ impl IntoHeaderValue for Bytes {
     }
 }
 
-impl IntoHeaderValue for Vec<u8> {
+impl TryIntoHeaderValue for Vec<u8> {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -69,7 +69,7 @@ impl IntoHeaderValue for Vec<u8> {
     }
 }
 
-impl IntoHeaderValue for String {
+impl TryIntoHeaderValue for String {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -78,7 +78,7 @@ impl IntoHeaderValue for String {
     }
 }
 
-impl IntoHeaderValue for usize {
+impl TryIntoHeaderValue for usize {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -87,7 +87,7 @@ impl IntoHeaderValue for usize {
     }
 }
 
-impl IntoHeaderValue for i64 {
+impl TryIntoHeaderValue for i64 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -96,7 +96,7 @@ impl IntoHeaderValue for i64 {
     }
 }
 
-impl IntoHeaderValue for u64 {
+impl TryIntoHeaderValue for u64 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -105,7 +105,7 @@ impl IntoHeaderValue for u64 {
     }
 }
 
-impl IntoHeaderValue for i32 {
+impl TryIntoHeaderValue for i32 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -114,7 +114,7 @@ impl IntoHeaderValue for i32 {
     }
 }
 
-impl IntoHeaderValue for u32 {
+impl TryIntoHeaderValue for u32 {
     type Error = InvalidHeaderValue;
 
     #[inline]
@@ -123,7 +123,7 @@ impl IntoHeaderValue for u32 {
     }
 }
 
-impl IntoHeaderValue for Mime {
+impl TryIntoHeaderValue for Mime {
     type Error = InvalidHeaderValue;
 
     #[inline]

actix-http/src/header/map.rs

@@ -306,8 +306,11 @@ impl HeaderMap {
     /// 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<'_> {
+    pub fn get_all(&self, key: impl AsHeaderName) -> std::slice::Iter<'_, HeaderValue> {
-        GetAll::new(self.get_value(key))
+        match self.get_value(key) {
+            Some(value) => value.iter(),
+            None => (&[]).iter(),
+        }
     }
 
     // TODO: get_all_mut ?
@@ -333,7 +336,7 @@ impl HeaderMap {
         }
     }
 
-    /// Inserts a name-value pair into the map.
+    /// Inserts (overrides) a name-value pair in 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;
@@ -372,7 +375,7 @@ impl HeaderMap {
         Removed::new(value)
     }
 
-    /// Inserts a name-value pair into the map.
+    /// Appends a name-value pair to 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
@@ -602,52 +605,6 @@ impl<'a> IntoIterator for &'a HeaderMap {
     }
 }
 
-/// Iterator over borrowed values with the same associated 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)),
-        }
-    }
-}
-
-impl ExactSizeIterator for GetAll<'_> {}
-
-impl iter::FusedIterator for GetAll<'_> {}
-
 /// Iterator over removed, owned values with the same associated name.
 ///
 /// Returned from methods that remove or replace items. See [`HeaderMap::insert`]
@@ -895,7 +852,7 @@ mod tests {
 
     assert_impl_all!(HeaderMap: IntoIterator);
     assert_impl_all!(Keys<'_>: Iterator, ExactSizeIterator, FusedIterator);
-    assert_impl_all!(GetAll<'_>: Iterator, ExactSizeIterator, FusedIterator);
+    assert_impl_all!(std::slice::Iter<'_, HeaderValue>: Iterator, ExactSizeIterator, FusedIterator);
     assert_impl_all!(Removed: Iterator, ExactSizeIterator, FusedIterator);
     assert_impl_all!(Iter<'_>: Iterator, ExactSizeIterator, FusedIterator);
     assert_impl_all!(IntoIter: Iterator, ExactSizeIterator, FusedIterator);

actix-http/src/header/mod.rs

@@ -37,8 +37,8 @@ mod shared;
 mod utils;
 
 pub use self::as_name::AsHeaderName;
-pub use self::into_pair::IntoHeaderPair;
+pub use self::into_pair::TryIntoHeaderPair;
-pub use self::into_value::IntoHeaderValue;
+pub use self::into_value::TryIntoHeaderValue;
 pub use self::map::HeaderMap;
 pub use self::shared::{
     parse_extended_value, q, Charset, ContentEncoding, ExtendedValue, HttpDate, LanguageTag,
@@ -49,7 +49,7 @@ pub use self::utils::{
 };
 
 /// An interface for types that already represent a valid header.
-pub trait Header: IntoHeaderValue {
+pub trait Header: TryIntoHeaderValue {
     /// Returns the name of the header field
     fn name() -> HeaderName;
 

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

@@ -5,7 +5,7 @@ use http::header::InvalidHeaderValue;
 
 use crate::{
     error::ParseError,
-    header::{self, from_one_raw_str, Header, HeaderName, HeaderValue, IntoHeaderValue},
+    header::{self, from_one_raw_str, Header, HeaderName, HeaderValue, TryIntoHeaderValue},
     HttpMessage,
 };
 
@@ -45,13 +45,13 @@ pub enum ContentEncoding {
 impl ContentEncoding {
     /// Is the content compressed?
     #[inline]
-    pub fn is_compression(self) -> bool {
+    pub const fn is_compression(self) -> bool {
         matches!(self, ContentEncoding::Identity | ContentEncoding::Auto)
     }
 
     /// Convert content encoding to string.
     #[inline]
-    pub fn as_str(self) -> &'static str {
+    pub const fn as_str(self) -> &'static str {
         match self {
             ContentEncoding::Br => "br",
             ContentEncoding::Gzip => "gzip",
@@ -96,7 +96,7 @@ impl TryFrom<&str> for ContentEncoding {
     }
 }
 
-impl IntoHeaderValue for ContentEncoding {
+impl TryIntoHeaderValue for ContentEncoding {
     type Error = InvalidHeaderValue;
 
     fn try_into_value(self) -> Result<http::HeaderValue, Self::Error> {

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

@@ -4,7 +4,8 @@ use bytes::BytesMut;
 use http::header::{HeaderValue, InvalidHeaderValue};
 
 use crate::{
-    config::DATE_VALUE_LENGTH, error::ParseError, header::IntoHeaderValue, helpers::MutWriter,
+    config::DATE_VALUE_LENGTH, error::ParseError, header::TryIntoHeaderValue,
+    helpers::MutWriter,
 };
 
 /// A timestamp with HTTP-style formatting and parsing.
@@ -29,7 +30,7 @@ impl fmt::Display for HttpDate {
     }
 }
 
-impl IntoHeaderValue for HttpDate {
+impl TryIntoHeaderValue for HttpDate {
     type Error = InvalidHeaderValue;
 
     fn try_into_value(self) -> Result<HeaderValue, Self::Error> {

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

@@ -87,7 +87,7 @@ impl fmt::Display for Quality {
 
                     // 0 is already handled so it's not possible to have a trailing 0 in this range
                     // we can just write the integer
-                    itoa::fmt(f, x)
+                    itoa_fmt(f, x)
                 } else if x < 100 {
                     // x in is range 10–99
 
@@ -95,21 +95,21 @@ impl fmt::Display for Quality {
 
                     if x % 10 == 0 {
                         // trailing 0, divide by 10 and write
-                        itoa::fmt(f, x / 10)
+                        itoa_fmt(f, x / 10)
                     } else {
-                        itoa::fmt(f, x)
+                        itoa_fmt(f, x)
                     }
                 } else {
                     // x is in range 100–999
 
                     if x % 100 == 0 {
                         // two trailing 0s, divide by 100 and write
-                        itoa::fmt(f, x / 100)
+                        itoa_fmt(f, x / 100)
                     } else if x % 10 == 0 {
                         // one trailing 0, divide by 10 and write
-                        itoa::fmt(f, x / 10)
+                        itoa_fmt(f, x / 10)
                     } else {
-                        itoa::fmt(f, x)
+                        itoa_fmt(f, x)
                     }
                 }
             }
@@ -117,6 +117,12 @@ impl fmt::Display for Quality {
     }
 }
 
+/// Write integer to a `fmt::Write`.
+pub fn itoa_fmt<W: fmt::Write, V: itoa::Integer>(mut wr: W, value: V) -> fmt::Result {
+    let mut buf = itoa::Buffer::new();
+    wr.write_str(buf.format(value))
+}
+
 #[derive(Debug, Clone, Display, Error)]
 #[display(fmt = "quality out of bounds")]
 #[non_exhaustive]

actix-http/src/lib.rs

@@ -19,7 +19,6 @@
 #![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")]
@@ -28,26 +27,26 @@
 #[macro_use]
 extern crate log;
 
+pub use ::http::{uri, uri::Uri};
+pub use ::http::{Method, StatusCode, Version};
+
 pub mod body;
 mod builder;
 mod config;
-
 #[cfg(feature = "__compress")]
 pub mod encoding;
+pub mod error;
 mod extensions;
+pub mod h1;
+pub mod h2;
 pub mod header;
 mod helpers;
 mod http_message;
 mod message;
 mod payload;
-mod request;
+mod requests;
-mod response;
+mod responses;
-mod response_builder;
 mod service;
-
-pub mod error;
-pub mod h1;
-pub mod h2;
 pub mod test;
 pub mod ws;
 
@@ -58,16 +57,13 @@ pub use self::extensions::Extensions;
 pub use self::header::ContentEncoding;
 pub use self::http_message::HttpMessage;
 pub use self::message::ConnectionType;
-pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
+pub use self::message::Message;
-pub use self::payload::{Payload, PayloadStream};
+#[allow(deprecated)]
-pub use self::request::Request;
+pub use self::payload::{BoxedPayloadStream, Payload, PayloadStream};
-pub use self::response::Response;
+pub use self::requests::{Request, RequestHead, RequestHeadType};
-pub use self::response_builder::ResponseBuilder;
+pub use self::responses::{Response, ResponseBuilder, ResponseHead};
 pub use self::service::HttpService;
 
-pub use ::http::{uri, uri::Uri};
-pub use ::http::{Method, StatusCode, Version};
-
 /// A major HTTP protocol version.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[non_exhaustive]

actix-http/src/message.rs

@@ -1,16 +1,7 @@
-use std::{
+use std::{cell::RefCell, ops, rc::Rc};
-    cell::{Ref, RefCell, RefMut},
-    net,
-    rc::Rc,
-};
 
 use bitflags::bitflags;
 
-use crate::{
-    header::{self, HeaderMap},
-    Extensions, Method, StatusCode, Uri, Version,
-};
-
 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum ConnectionType {
@@ -44,294 +35,6 @@ pub trait Head: Default + 'static {
         F: FnOnce(&MessagePool<Self>) -> R;
 }
 
-#[derive(Debug, Clone)]
-pub struct RequestHead {
-    pub method: Method,
-    pub uri: Uri,
-    pub version: Version,
-    pub headers: HeaderMap,
-    pub peer_addr: Option<net::SocketAddr>,
-    flags: Flags,
-}
-
-impl Default for RequestHead {
-    fn default() -> RequestHead {
-        RequestHead {
-            method: Method::default(),
-            uri: Uri::default(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::with_capacity(16),
-            peer_addr: None,
-            flags: Flags::empty(),
-        }
-    }
-}
-
-impl Head for RequestHead {
-    fn clear(&mut self) {
-        self.flags = Flags::empty();
-        self.headers.clear();
-    }
-
-    fn with_pool<F, R>(f: F) -> R
-    where
-        F: FnOnce(&MessagePool<Self>) -> R,
-    {
-        REQUEST_POOL.with(|p| f(p))
-    }
-}
-
-impl RequestHead {
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    /// Is to uppercase headers with Camel-Case.
-    /// Default is `false`
-    #[inline]
-    pub fn camel_case_headers(&self) -> bool {
-        self.flags.contains(Flags::CAMEL_CASE)
-    }
-
-    /// Set `true` to send headers which are formatted as Camel-Case.
-    #[inline]
-    pub fn set_camel_case_headers(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::CAMEL_CASE);
-        } else {
-            self.flags.remove(Flags::CAMEL_CASE);
-        }
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    /// Connection type
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Connection upgrade status
-    pub fn upgrade(&self) -> bool {
-        self.headers()
-            .get(header::CONNECTION)
-            .map(|hdr| {
-                if let Ok(s) = hdr.to_str() {
-                    s.to_ascii_lowercase().contains("upgrade")
-                } else {
-                    false
-                }
-            })
-            .unwrap_or(false)
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-
-    #[inline]
-    /// Request contains `EXPECT` header
-    pub fn expect(&self) -> bool {
-        self.flags.contains(Flags::EXPECT)
-    }
-
-    #[inline]
-    pub(crate) fn set_expect(&mut self) {
-        self.flags.insert(Flags::EXPECT);
-    }
-}
-
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum RequestHeadType {
-    Owned(RequestHead),
-    Rc(Rc<RequestHead>, Option<HeaderMap>),
-}
-
-impl RequestHeadType {
-    pub fn extra_headers(&self) -> Option<&HeaderMap> {
-        match self {
-            RequestHeadType::Owned(_) => None,
-            RequestHeadType::Rc(_, headers) => headers.as_ref(),
-        }
-    }
-}
-
-impl AsRef<RequestHead> for RequestHeadType {
-    fn as_ref(&self) -> &RequestHead {
-        match self {
-            RequestHeadType::Owned(head) => head,
-            RequestHeadType::Rc(head, _) => head.as_ref(),
-        }
-    }
-}
-
-impl From<RequestHead> for RequestHeadType {
-    fn from(head: RequestHead) -> Self {
-        RequestHeadType::Owned(head)
-    }
-}
-
-#[derive(Debug)]
-pub struct ResponseHead {
-    pub version: Version,
-    pub status: StatusCode,
-    pub headers: HeaderMap,
-    pub reason: Option<&'static str>,
-    pub(crate) extensions: RefCell<Extensions>,
-    flags: Flags,
-}
-
-impl ResponseHead {
-    /// Create new instance of `ResponseHead` type
-    #[inline]
-    pub fn new(status: StatusCode) -> ResponseHead {
-        ResponseHead {
-            status,
-            version: Version::default(),
-            headers: HeaderMap::with_capacity(12),
-            reason: None,
-            flags: Flags::empty(),
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    #[inline]
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    #[inline]
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Check if keep-alive is enabled
-    #[inline]
-    pub fn keep_alive(&self) -> bool {
-        self.connection_type() == ConnectionType::KeepAlive
-    }
-
-    /// Check upgrade status of this message
-    #[inline]
-    pub fn upgrade(&self) -> bool {
-        self.connection_type() == ConnectionType::Upgrade
-    }
-
-    /// Get custom reason for the response
-    #[inline]
-    pub fn reason(&self) -> &str {
-        self.reason.unwrap_or_else(|| {
-            self.status
-                .canonical_reason()
-                .unwrap_or("<unknown status code>")
-        })
-    }
-
-    #[inline]
-    pub(crate) fn conn_type(&self) -> Option<ConnectionType> {
-        if self.flags.contains(Flags::CLOSE) {
-            Some(ConnectionType::Close)
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            Some(ConnectionType::KeepAlive)
-        } else if self.flags.contains(Flags::UPGRADE) {
-            Some(ConnectionType::Upgrade)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    /// Set no chunking for payload
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-}
-
 pub struct Message<T: Head> {
     /// Rc here should not be cloned by anyone.
     /// It's used to reuse allocation of T and no shared ownership is allowed.
@@ -340,12 +43,13 @@ pub struct Message<T: Head> {
 
 impl<T: Head> Message<T> {
     /// Get new message from the pool of objects
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         T::with_pool(MessagePool::get_message)
     }
 }
 
-impl<T: Head> std::ops::Deref for Message<T> {
+impl<T: Head> ops::Deref for Message<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -353,7 +57,7 @@ impl<T: Head> std::ops::Deref for Message<T> {
     }
 }
 
-impl<T: Head> std::ops::DerefMut for Message<T> {
+impl<T: Head> ops::DerefMut for Message<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         Rc::get_mut(&mut self.head).expect("Multiple copies exist")
     }
@@ -365,53 +69,12 @@ impl<T: Head> Drop for Message<T> {
     }
 }
 
-pub(crate) struct BoxedResponseHead {
-    head: Option<Box<ResponseHead>>,
-}
-
-impl BoxedResponseHead {
-    /// Get new message from the pool of objects
-    pub fn new(status: StatusCode) -> Self {
-        RESPONSE_POOL.with(|p| p.get_message(status))
-    }
-}
-
-impl std::ops::Deref for BoxedResponseHead {
-    type Target = ResponseHead;
-
-    fn deref(&self) -> &Self::Target {
-        self.head.as_ref().unwrap()
-    }
-}
-
-impl std::ops::DerefMut for BoxedResponseHead {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.head.as_mut().unwrap()
-    }
-}
-
-impl Drop for BoxedResponseHead {
-    fn drop(&mut self) {
-        if let Some(head) = self.head.take() {
-            RESPONSE_POOL.with(move |p| p.release(head))
-        }
-    }
-}
-
 #[doc(hidden)]
 /// Request's objects pool
 pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
 
-#[doc(hidden)]
-#[allow(clippy::vec_box)]
-/// Request's objects pool
-pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);
-
-thread_local!(static REQUEST_POOL: MessagePool<RequestHead> = MessagePool::<RequestHead>::create());
-thread_local!(static RESPONSE_POOL: BoxedResponsePool = BoxedResponsePool::create());
-
 impl<T: Head> MessagePool<T> {
-    fn create() -> MessagePool<T> {
+    pub(crate) fn create() -> MessagePool<T> {
         MessagePool(RefCell::new(Vec::with_capacity(128)))
     }
 
@@ -433,43 +96,11 @@ impl<T: Head> MessagePool<T> {
     }
 
     #[inline]
-    /// Release request instance
+    /// Release message instance
     fn release(&self, msg: Rc<T>) {
-        let v = &mut self.0.borrow_mut();
+        let pool = &mut self.0.borrow_mut();
-        if v.len() < 128 {
+        if pool.len() < 128 {
-            v.push(msg);
+            pool.push(msg);
-        }
-    }
-}
-
-impl BoxedResponsePool {
-    fn create() -> BoxedResponsePool {
-        BoxedResponsePool(RefCell::new(Vec::with_capacity(128)))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&self, status: StatusCode) -> BoxedResponseHead {
-        if let Some(mut head) = self.0.borrow_mut().pop() {
-            head.reason = None;
-            head.status = status;
-            head.headers.clear();
-            head.flags = Flags::empty();
-            BoxedResponseHead { head: Some(head) }
-        } else {
-            BoxedResponseHead {
-                head: Some(Box::new(ResponseHead::new(status))),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, mut msg: Box<ResponseHead>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            msg.extensions.get_mut().clear();
-            v.push(msg);
         }
     }
 }

actix-http/src/payload.rs

@@ -1,67 +1,89 @@
-use std::pin::Pin;
+use std::{
-use std::task::{Context, Poll};
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use bytes::Bytes;
 use futures_core::Stream;
-use h2::RecvStream;
 
 use crate::error::PayloadError;
 
-/// Type represent boxed payload
+/// A boxed payload stream.
-pub type PayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
+pub type BoxedPayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
 
-/// Type represent streaming payload
+#[deprecated(since = "4.0.0", note = "Renamed to `BoxedPayloadStream`.")]
-pub enum Payload<S = PayloadStream> {
+pub type PayloadStream = BoxedPayloadStream;
-    None,
+
-    H1(crate::h1::Payload),
+pin_project_lite::pin_project! {
-    H2(crate::h2::Payload),
+    /// A streaming payload.
-    Stream(S),
+    #[project = PayloadProj]
+    pub enum Payload<S = BoxedPayloadStream> {
+        None,
+        H1 { payload: crate::h1::Payload },
+        H2 { payload: crate::h2::Payload },
+        Stream { #[pin] payload: S },
+    }
 }
 
 impl<S> From<crate::h1::Payload> for Payload<S> {
-    fn from(v: crate::h1::Payload) -> Self {
+    fn from(payload: crate::h1::Payload) -> Self {
-        Payload::H1(v)
+        Payload::H1 { payload }
     }
 }
 
 impl<S> From<crate::h2::Payload> for Payload<S> {
-    fn from(v: crate::h2::Payload) -> Self {
+    fn from(payload: crate::h2::Payload) -> Self {
-        Payload::H2(v)
+        Payload::H2 { payload }
     }
 }
 
-impl<S> From<RecvStream> for Payload<S> {
+impl<S> From<h2::RecvStream> for Payload<S> {
-    fn from(v: RecvStream) -> Self {
+    fn from(stream: h2::RecvStream) -> Self {
-        Payload::H2(crate::h2::Payload::new(v))
+        Payload::H2 {
+            payload: crate::h2::Payload::new(stream),
+        }
     }
 }
 
-impl From<PayloadStream> for Payload {
+impl From<BoxedPayloadStream> for Payload {
-    fn from(pl: PayloadStream) -> Self {
+    fn from(payload: BoxedPayloadStream) -> Self {
-        Payload::Stream(pl)
+        Payload::Stream { payload }
     }
 }
 
 impl<S> Payload<S> {
     /// Takes current payload and replaces it with `None` value
     pub fn take(&mut self) -> Payload<S> {
-        std::mem::replace(self, Payload::None)
+        mem::replace(self, Payload::None)
     }
 }
 
 impl<S> Stream for Payload<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Result<Bytes, PayloadError>>,
 {
     type Item = Result<Bytes, PayloadError>;
 
     #[inline]
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match self.get_mut() {
+        match self.project() {
-            Payload::None => Poll::Ready(None),
+            PayloadProj::None => Poll::Ready(None),
-            Payload::H1(ref mut pl) => pl.readany(cx),
+            PayloadProj::H1 { payload } => Pin::new(payload).poll_next(cx),
-            Payload::H2(ref mut pl) => Pin::new(pl).poll_next(cx),
+            PayloadProj::H2 { payload } => Pin::new(payload).poll_next(cx),
-            Payload::Stream(ref mut pl) => Pin::new(pl).poll_next(cx),
+            PayloadProj::Stream { payload } => payload.poll_next(cx),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    use static_assertions::{assert_impl_all, assert_not_impl_any};
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin);
+    assert_not_impl_any!(Payload: Send, Sync, UnwindSafe, RefUnwindSafe);
+}

actix-http/src/requests/head.rs

@@ -0,0 +1,174 @@
+use std::{net, rc::Rc};
+
+use crate::{
+    header::{self, HeaderMap},
+    message::{Flags, Head, MessagePool},
+    ConnectionType, Method, Uri, Version,
+};
+
+thread_local! {
+    static REQUEST_POOL: MessagePool<RequestHead> = MessagePool::<RequestHead>::create()
+}
+
+#[derive(Debug, Clone)]
+pub struct RequestHead {
+    pub method: Method,
+    pub uri: Uri,
+    pub version: Version,
+    pub headers: HeaderMap,
+    pub peer_addr: Option<net::SocketAddr>,
+    flags: Flags,
+}
+
+impl Default for RequestHead {
+    fn default() -> RequestHead {
+        RequestHead {
+            method: Method::default(),
+            uri: Uri::default(),
+            version: Version::HTTP_11,
+            headers: HeaderMap::with_capacity(16),
+            peer_addr: None,
+            flags: Flags::empty(),
+        }
+    }
+}
+
+impl Head for RequestHead {
+    fn clear(&mut self) {
+        self.flags = Flags::empty();
+        self.headers.clear();
+    }
+
+    fn with_pool<F, R>(f: F) -> R
+    where
+        F: FnOnce(&MessagePool<Self>) -> R,
+    {
+        REQUEST_POOL.with(|p| f(p))
+    }
+}
+
+impl RequestHead {
+    /// Read the message headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    /// Mutable reference to the message headers.
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
+    /// Is to uppercase headers with Camel-Case.
+    /// Default is `false`
+    #[inline]
+    pub fn camel_case_headers(&self) -> bool {
+        self.flags.contains(Flags::CAMEL_CASE)
+    }
+
+    /// Set `true` to send headers which are formatted as Camel-Case.
+    #[inline]
+    pub fn set_camel_case_headers(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::CAMEL_CASE);
+        } else {
+            self.flags.remove(Flags::CAMEL_CASE);
+        }
+    }
+
+    #[inline]
+    /// Set connection type of the message
+    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
+        match ctype {
+            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
+            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
+            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
+        }
+    }
+
+    #[inline]
+    /// Connection type
+    pub fn connection_type(&self) -> ConnectionType {
+        if self.flags.contains(Flags::CLOSE) {
+            ConnectionType::Close
+        } else if self.flags.contains(Flags::KEEP_ALIVE) {
+            ConnectionType::KeepAlive
+        } else if self.flags.contains(Flags::UPGRADE) {
+            ConnectionType::Upgrade
+        } else if self.version < Version::HTTP_11 {
+            ConnectionType::Close
+        } else {
+            ConnectionType::KeepAlive
+        }
+    }
+
+    /// Connection upgrade status
+    pub fn upgrade(&self) -> bool {
+        self.headers()
+            .get(header::CONNECTION)
+            .map(|hdr| {
+                if let Ok(s) = hdr.to_str() {
+                    s.to_ascii_lowercase().contains("upgrade")
+                } else {
+                    false
+                }
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    /// Get response body chunking state
+    pub fn chunked(&self) -> bool {
+        !self.flags.contains(Flags::NO_CHUNKING)
+    }
+
+    #[inline]
+    pub fn no_chunking(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::NO_CHUNKING);
+        } else {
+            self.flags.remove(Flags::NO_CHUNKING);
+        }
+    }
+
+    #[inline]
+    /// Request contains `EXPECT` header
+    pub fn expect(&self) -> bool {
+        self.flags.contains(Flags::EXPECT)
+    }
+
+    #[inline]
+    pub(crate) fn set_expect(&mut self) {
+        self.flags.insert(Flags::EXPECT);
+    }
+}
+
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum RequestHeadType {
+    Owned(RequestHead),
+    Rc(Rc<RequestHead>, Option<HeaderMap>),
+}
+
+impl RequestHeadType {
+    pub fn extra_headers(&self) -> Option<&HeaderMap> {
+        match self {
+            RequestHeadType::Owned(_) => None,
+            RequestHeadType::Rc(_, headers) => headers.as_ref(),
+        }
+    }
+}
+
+impl AsRef<RequestHead> for RequestHeadType {
+    fn as_ref(&self) -> &RequestHead {
+        match self {
+            RequestHeadType::Owned(head) => head,
+            RequestHeadType::Rc(head, _) => head.as_ref(),
+        }
+    }
+}
+
+impl From<RequestHead> for RequestHeadType {
+    fn from(head: RequestHead) -> Self {
+        RequestHeadType::Owned(head)
+    }
+}

actix-http/src/requests/mod.rs

@@ -0,0 +1,7 @@
+//! HTTP requests.
+
+mod head;
+mod request;
+
+pub use self::head::{RequestHead, RequestHeadType};
+pub use self::request::Request;

actix-http/src/requests/request.rs

@@ -10,15 +10,12 @@ use std::{
 use http::{header, Method, Uri, Version};
 
 use crate::{
-    extensions::Extensions,
+    header::HeaderMap, BoxedPayloadStream, Extensions, HttpMessage, Message, Payload,
-    header::HeaderMap,
+    RequestHead,
-    message::{Message, RequestHead},
-    payload::{Payload, PayloadStream},
-    HttpMessage,
 };
 
 /// An HTTP request.
-pub struct Request<P = PayloadStream> {
+pub struct Request<P = BoxedPayloadStream> {
     pub(crate) payload: Payload<P>,
     pub(crate) head: Message<RequestHead>,
     pub(crate) conn_data: Option<Rc<Extensions>>,
@@ -50,7 +47,7 @@ impl<P> HttpMessage for Request<P> {
     }
 }
 
-impl From<Message<RequestHead>> for Request<PayloadStream> {
+impl From<Message<RequestHead>> for Request<BoxedPayloadStream> {
     fn from(head: Message<RequestHead>) -> Self {
         Request {
             head,
@@ -61,9 +58,10 @@ impl From<Message<RequestHead>> for Request<PayloadStream> {
     }
 }
 
-impl Request<PayloadStream> {
+impl Request<BoxedPayloadStream> {
     /// Create new Request instance
-    pub fn new() -> Request<PayloadStream> {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Request<BoxedPayloadStream> {
         Request {
             head: Message::new(),
             payload: Payload::None,
@@ -206,7 +204,7 @@ impl<P> Request<P> {
 
     /// Returns the request data container, leaving an empty one in it's place.
     pub fn take_req_data(&mut self) -> Extensions {
-        mem::take(&mut self.req_data.get_mut())
+        mem::take(self.req_data.get_mut())
     }
 }
 

actix-http/src/responses/builder.rs

@@ -8,9 +8,9 @@ use std::{
 use crate::{
     body::{EitherBody, MessageBody},
     error::{Error, HttpError},
-    header::{self, IntoHeaderPair, IntoHeaderValue},
+    header::{self, TryIntoHeaderPair, TryIntoHeaderValue},
-    message::{BoxedResponseHead, ConnectionType, ResponseHead},
+    responses::{BoxedResponseHead, ResponseHead},
-    Extensions, Response, StatusCode,
+    ConnectionType, Extensions, Response, StatusCode,
 };
 
 /// An HTTP response builder.
@@ -90,12 +90,9 @@ impl ResponseBuilder {
     /// assert!(res.headers().contains_key("content-type"));
     /// assert!(res.headers().contains_key("x-test"));
     /// ```
-    pub fn insert_header<H>(&mut self, header: H) -> &mut Self
+    pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
-    where
-        H: IntoHeaderPair,
-    {
         if let Some(parts) = self.inner() {
-            match header.try_into_header_pair() {
+            match header.try_into_pair() {
                 Ok((key, value)) => {
                     parts.headers.insert(key, value);
                 }
@@ -121,12 +118,9 @@ impl ResponseBuilder {
     /// assert_eq!(res.headers().get_all("content-type").count(), 1);
     /// assert_eq!(res.headers().get_all("x-test").count(), 2);
     /// ```
-    pub fn append_header<H>(&mut self, header: H) -> &mut Self
+    pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
-    where
-        H: IntoHeaderPair,
-    {
         if let Some(parts) = self.inner() {
-            match header.try_into_header_pair() {
+            match header.try_into_pair() {
                 Ok((key, value)) => parts.headers.append(key, value),
                 Err(e) => self.err = Some(e.into()),
             };
@@ -157,7 +151,7 @@ impl ResponseBuilder {
     #[inline]
     pub fn upgrade<V>(&mut self, value: V) -> &mut Self
     where
-        V: IntoHeaderValue,
+        V: TryIntoHeaderValue,
     {
         if let Some(parts) = self.inner() {
             parts.set_connection_type(ConnectionType::Upgrade);
@@ -195,7 +189,7 @@ impl ResponseBuilder {
     #[inline]
     pub fn content_type<V>(&mut self, value: V) -> &mut Self
     where
-        V: IntoHeaderValue,
+        V: TryIntoHeaderValue,
     {
         if let Some(parts) = self.inner() {
             match value.try_into_value() {

actix-http/src/responses/head.rs

@@ -0,0 +1,208 @@
+//! Response head type and caching pool.
+
+use std::{
+    cell::{Ref, RefCell, RefMut},
+    ops,
+};
+
+use crate::{
+    header::HeaderMap, message::Flags, ConnectionType, Extensions, StatusCode, Version,
+};
+
+thread_local! {
+    static RESPONSE_POOL: BoxedResponsePool = BoxedResponsePool::create();
+}
+
+#[derive(Debug)]
+pub struct ResponseHead {
+    pub version: Version,
+    pub status: StatusCode,
+    pub headers: HeaderMap,
+    pub reason: Option<&'static str>,
+    pub(crate) extensions: RefCell<Extensions>,
+    flags: Flags,
+}
+
+impl ResponseHead {
+    /// Create new instance of `ResponseHead` type
+    #[inline]
+    pub fn new(status: StatusCode) -> ResponseHead {
+        ResponseHead {
+            status,
+            version: Version::HTTP_11,
+            headers: HeaderMap::with_capacity(12),
+            reason: None,
+            flags: Flags::empty(),
+            extensions: RefCell::new(Extensions::new()),
+        }
+    }
+
+    #[inline]
+    /// Read the message headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    #[inline]
+    /// Mutable reference to the message headers.
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
+    /// Message extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<'_, Extensions> {
+        self.extensions.borrow()
+    }
+
+    /// Mutable reference to a the message's extensions
+    #[inline]
+    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
+        self.extensions.borrow_mut()
+    }
+
+    #[inline]
+    /// Set connection type of the message
+    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
+        match ctype {
+            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
+            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
+            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
+        }
+    }
+
+    #[inline]
+    pub fn connection_type(&self) -> ConnectionType {
+        if self.flags.contains(Flags::CLOSE) {
+            ConnectionType::Close
+        } else if self.flags.contains(Flags::KEEP_ALIVE) {
+            ConnectionType::KeepAlive
+        } else if self.flags.contains(Flags::UPGRADE) {
+            ConnectionType::Upgrade
+        } else if self.version < Version::HTTP_11 {
+            ConnectionType::Close
+        } else {
+            ConnectionType::KeepAlive
+        }
+    }
+
+    /// Check if keep-alive is enabled
+    #[inline]
+    pub fn keep_alive(&self) -> bool {
+        self.connection_type() == ConnectionType::KeepAlive
+    }
+
+    /// Check upgrade status of this message
+    #[inline]
+    pub fn upgrade(&self) -> bool {
+        self.connection_type() == ConnectionType::Upgrade
+    }
+
+    /// Get custom reason for the response
+    #[inline]
+    pub fn reason(&self) -> &str {
+        self.reason.unwrap_or_else(|| {
+            self.status
+                .canonical_reason()
+                .unwrap_or("<unknown status code>")
+        })
+    }
+
+    #[inline]
+    pub(crate) fn conn_type(&self) -> Option<ConnectionType> {
+        if self.flags.contains(Flags::CLOSE) {
+            Some(ConnectionType::Close)
+        } else if self.flags.contains(Flags::KEEP_ALIVE) {
+            Some(ConnectionType::KeepAlive)
+        } else if self.flags.contains(Flags::UPGRADE) {
+            Some(ConnectionType::Upgrade)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    /// Get response body chunking state
+    pub fn chunked(&self) -> bool {
+        !self.flags.contains(Flags::NO_CHUNKING)
+    }
+
+    #[inline]
+    /// Set no chunking for payload
+    pub fn no_chunking(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::NO_CHUNKING);
+        } else {
+            self.flags.remove(Flags::NO_CHUNKING);
+        }
+    }
+}
+
+pub(crate) struct BoxedResponseHead {
+    head: Option<Box<ResponseHead>>,
+}
+
+impl BoxedResponseHead {
+    /// Get new message from the pool of objects
+    pub fn new(status: StatusCode) -> Self {
+        RESPONSE_POOL.with(|p| p.get_message(status))
+    }
+}
+
+impl ops::Deref for BoxedResponseHead {
+    type Target = ResponseHead;
+
+    fn deref(&self) -> &Self::Target {
+        self.head.as_ref().unwrap()
+    }
+}
+
+impl ops::DerefMut for BoxedResponseHead {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.head.as_mut().unwrap()
+    }
+}
+
+impl Drop for BoxedResponseHead {
+    fn drop(&mut self) {
+        if let Some(head) = self.head.take() {
+            RESPONSE_POOL.with(move |p| p.release(head))
+        }
+    }
+}
+
+/// Request's objects pool
+#[doc(hidden)]
+pub struct BoxedResponsePool(#[allow(clippy::vec_box)] RefCell<Vec<Box<ResponseHead>>>);
+
+impl BoxedResponsePool {
+    fn create() -> BoxedResponsePool {
+        BoxedResponsePool(RefCell::new(Vec::with_capacity(128)))
+    }
+
+    /// Get message from the pool
+    #[inline]
+    fn get_message(&self, status: StatusCode) -> BoxedResponseHead {
+        if let Some(mut head) = self.0.borrow_mut().pop() {
+            head.reason = None;
+            head.status = status;
+            head.headers.clear();
+            head.flags = Flags::empty();
+            BoxedResponseHead { head: Some(head) }
+        } else {
+            BoxedResponseHead {
+                head: Some(Box::new(ResponseHead::new(status))),
+            }
+        }
+    }
+
+    /// Release request instance
+    #[inline]
+    fn release(&self, mut msg: Box<ResponseHead>) {
+        let pool = &mut self.0.borrow_mut();
+        if pool.len() < 128 {
+            msg.extensions.get_mut().clear();
+            pool.push(msg);
+        }
+    }
+}

actix-http/src/responses/mod.rs

@@ -0,0 +1,11 @@
+//! HTTP response.
+
+mod builder;
+mod head;
+#[allow(clippy::module_inception)]
+mod response;
+
+pub use self::builder::ResponseBuilder;
+pub(crate) use self::head::BoxedResponseHead;
+pub use self::head::ResponseHead;
+pub use self::response::Response;

actix-http/src/responses/response.rs

@@ -10,10 +10,9 @@ use bytestring::ByteString;
 
 use crate::{
     body::{BoxBody, MessageBody},
-    extensions::Extensions,
+    header::{self, HeaderMap, TryIntoHeaderValue},
-    header::{self, HeaderMap, IntoHeaderValue},
+    responses::BoxedResponseHead,
-    message::{BoxedResponseHead, ResponseHead},
+    Error, Extensions, ResponseBuilder, ResponseHead, StatusCode,
-    Error, ResponseBuilder, StatusCode,
 };
 
 /// An HTTP response.
@@ -170,7 +169,7 @@ impl<B> Response<B> {
     /// Returns split head and body.
     ///
     /// # Implementation Notes
-    /// Due to internal performance optimisations, the first element of the returned tuple is a
+    /// Due to internal performance optimizations, the first element of the returned tuple is a
     /// `Response` as well but only contains the head of the response this was called on.
     pub fn into_parts(self) -> (Response<()>, B) {
         self.replace_body(())
@@ -194,7 +193,7 @@ impl<B> Response<B> {
     where
         B: MessageBody + 'static,
     {
-        self.map_body(|_, body| BoxBody::new(body))
+        self.map_body(|_, body| body.boxed())
     }
 
     /// Returns body, consuming this response.

actix-http/src/service.rs

@@ -493,9 +493,9 @@ where
     type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
 
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self._poll_ready(cx).map_err(|e| {
+        self._poll_ready(cx).map_err(|err| {
-            log::error!("HTTP service readiness error: {:?}", e);
+            log::error!("HTTP service readiness error: {:?}", err);
-            DispatchError::Service(e)
+            DispatchError::Service(err)
         })
     }
 

actix-http/src/test.rs

@@ -14,7 +14,7 @@ use bytes::{Bytes, BytesMut};
 use http::{Method, Uri, Version};
 
 use crate::{
-    header::{HeaderMap, IntoHeaderPair},
+    header::{HeaderMap, TryIntoHeaderPair},
     payload::Payload,
     Request,
 };
@@ -92,11 +92,8 @@ impl TestRequest {
     }
 
     /// Insert a header, replacing any that were set with an equivalent field name.
-    pub fn insert_header<H>(&mut self, header: H) -> &mut Self
+    pub fn insert_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
-    where
+        match header.try_into_pair() {
-        H: IntoHeaderPair,
-    {
-        match header.try_into_header_pair() {
             Ok((key, value)) => {
                 parts(&mut self.0).headers.insert(key, value);
             }
@@ -109,11 +106,8 @@ impl TestRequest {
     }
 
     /// Append a header, keeping any that were set with an equivalent field name.
-    pub fn append_header<H>(&mut self, header: H) -> &mut Self
+    pub fn append_header(&mut self, header: impl TryIntoHeaderPair) -> &mut Self {
-    where
+        match header.try_into_pair() {
-        H: IntoHeaderPair,
-    {
-        match header.try_into_header_pair() {
             Ok((key, value)) => {
                 parts(&mut self.0).headers.append(key, value);
             }
@@ -126,7 +120,7 @@ impl TestRequest {
     }
 
     /// Set request payload.
-    pub fn set_payload<B: Into<Bytes>>(&mut self, data: B) -> &mut Self {
+    pub fn set_payload(&mut self, data: impl Into<Bytes>) -> &mut Self {
         let mut payload = crate::h1::Payload::empty();
         payload.unread_data(data.into());
         parts(&mut self.0).payload = Some(payload.into());
@@ -270,7 +264,7 @@ impl TestSeqBuffer {
 
     /// Create new empty `TestBuffer` instance.
     pub fn empty() -> Self {
-        Self::new("")
+        Self::new(BytesMut::new())
     }
 
     pub fn read_buf(&self) -> Ref<'_, BytesMut> {

actix-http/src/ws/mod.rs

@@ -9,7 +9,7 @@ use derive_more::{Display, Error, From};
 use http::{header, Method, StatusCode};
 
 use crate::body::BoxBody;
-use crate::{header::HeaderValue, message::RequestHead, response::Response, ResponseBuilder};
+use crate::{header::HeaderValue, RequestHead, Response, ResponseBuilder};
 
 mod codec;
 mod dispatcher;
@@ -99,8 +99,9 @@ impl From<HandshakeError> for Response<BoxBody> {
         match err {
             HandshakeError::GetMethodRequired => {
                 let mut res = Response::new(StatusCode::METHOD_NOT_ALLOWED);
-                res.headers_mut()
+                #[allow(clippy::declare_interior_mutable_const)]
-                    .insert(header::ALLOW, HeaderValue::from_static("GET"));
+                const HV_GET: HeaderValue = HeaderValue::from_static("GET");
+                res.headers_mut().insert(header::ALLOW, HV_GET);
                 res
             }
 

actix-http/tests/test_rustls.rs

@@ -7,6 +7,7 @@ use std::{
     io::{self, BufReader, Write},
     net::{SocketAddr, TcpStream as StdTcpStream},
     sync::Arc,
+    task::Poll,
 };
 
 use actix_http::{
@@ -16,25 +17,37 @@ use actix_http::{
     Error, HttpService, Method, Request, Response, StatusCode, Version,
 };
 use actix_http_test::test_server;
+use actix_rt::pin;
 use actix_service::{fn_factory_with_config, fn_service};
 use actix_tls::connect::rustls::webpki_roots_cert_store;
-use actix_utils::future::{err, ok};
+use actix_utils::future::{err, ok, poll_fn};
 use bytes::{Bytes, BytesMut};
 use derive_more::{Display, Error};
-use futures_core::Stream;
+use futures_core::{ready, Stream};
-use futures_util::stream::{once, StreamExt as _};
+use futures_util::stream::once;
 use rustls::{Certificate, PrivateKey, ServerConfig as RustlsServerConfig, ServerName};
 use rustls_pemfile::{certs, pkcs8_private_keys};
 
-async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
+async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Result<Bytes, PayloadError>>,
 {
-    let mut body = BytesMut::new();
+    let mut buf = BytesMut::new();
-    while let Some(item) = stream.next().await {
+
-        body.extend_from_slice(&item?)
+    pin!(stream);
-    }
+
-    Ok(body)
+    poll_fn(|cx| loop {
+        let body = stream.as_mut();
+
+        match ready!(body.poll_next(cx)) {
+            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
+            None => return Poll::Ready(Ok(())),
+            Some(Err(err)) => return Poll::Ready(Err(err)),
+        }
+    })
+    .await?;
+
+    Ok(buf)
 }
 
 fn tls_config() -> RustlsServerConfig {

actix-multipart/CHANGES.md

@@ -3,120 +3,124 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.4.0-beta.11 - 2021-12-27
+* No significant changes since `0.4.0-beta.10`.
+
+
 ## 0.4.0-beta.10 - 2021-12-11
-* No significant changes since `0.4.0-beta.9`.
+- No significant changes since `0.4.0-beta.9`.
 
 
 ## 0.4.0-beta.9 - 2021-12-01
-* Polling `Field` after dropping `Multipart` now fails immediately instead of hanging forever. [#2463]
+- Polling `Field` after dropping `Multipart` now fails immediately instead of hanging forever. [#2463]
 
 [#2463]: https://github.com/actix/actix-web/pull/2463
 
 
 ## 0.4.0-beta.8 - 2021-11-22
-* Ensure a correct Content-Disposition header is included in every part of a multipart message. [#2451]
+- Ensure a correct Content-Disposition header is included in every part of a multipart message. [#2451]
-* Added `MultipartError::NoContentDisposition` variant. [#2451]
+- Added `MultipartError::NoContentDisposition` variant. [#2451]
-* Since Content-Disposition is now ensured, `Field::content_disposition` is now infallible. [#2451]
+- Since Content-Disposition is now ensured, `Field::content_disposition` is now infallible. [#2451]
-* Added `Field::name` method for getting the field name. [#2451]
+- Added `Field::name` method for getting the field name. [#2451]
-* `MultipartError` now marks variants with inner errors as the source. [#2451]
+- `MultipartError` now marks variants with inner errors as the source. [#2451]
-* `MultipartError` is now marked as non-exhaustive. [#2451]
+- `MultipartError` is now marked as non-exhaustive. [#2451]
 
 [#2451]: https://github.com/actix/actix-web/pull/2451
 
 
 ## 0.4.0-beta.7 - 2021-10-20
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 
 ## 0.4.0-beta.6 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.4.0-beta.5 - 2021-06-17
-* No notable changes.
+- No notable changes.
 
 
 ## 0.4.0-beta.4 - 2021-04-02
-* No notable changes.
+- No notable changes.
 
 
 ## 0.4.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 0.4.0-beta.2 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 0.4.0-beta.1 - 2021-01-07
-* Fix multipart consuming payload before header checks. [#1513]
+- Fix multipart consuming payload before header checks. [#1513]
-* Update `bytes` to `1.0`. [#1813]
+- Update `bytes` to `1.0`. [#1813]
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 [#1513]: https://github.com/actix/actix-web/pull/1513
 
 
 ## 0.3.0 - 2020-09-11
-* No significant changes from `0.3.0-beta.2`.
+- No significant changes from `0.3.0-beta.2`.
 
 
 ## 0.3.0-beta.2 - 2020-09-10
-* Update `actix-*` dependencies to latest versions.
+- Update `actix-*` dependencies to latest versions.
 
 
 ## 0.3.0-beta.1 - 2020-07-15
-* Update `actix-web` to 3.0.0-beta.1
+- Update `actix-web` to 3.0.0-beta.1
 
 
 ## 0.3.0-alpha.1 - 2020-05-25
-* Update `actix-web` to 3.0.0-alpha.3
+- Update `actix-web` to 3.0.0-alpha.3
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
-* Minimize `futures` dependencies
+- Minimize `futures` dependencies
-* Remove the unused `time` dependency
+- Remove the unused `time` dependency
-* Fix missing `std::error::Error` implement for `MultipartError`.
+- Fix missing `std::error::Error` implement for `MultipartError`.
 
 ## [0.2.0] - 2019-12-20
 
-* Release
+- Release
 
 ## [0.2.0-alpha.4] - 2019-12-xx
 
-* Multipart handling now handles Pending during read of boundary #1205
+- Multipart handling now handles Pending during read of boundary #1205
 
 ## [0.2.0-alpha.2] - 2019-12-03
 
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 ## [0.1.4] - 2019-09-12
 
-* Multipart handling now parses requests which do not end in CRLF #1038
+- Multipart handling now parses requests which do not end in CRLF #1038
 
 ## [0.1.3] - 2019-08-18
 
-* Fix ring dependency from actix-web default features for #741.
+- Fix ring dependency from actix-web default features for #741.
 
 ## [0.1.2] - 2019-06-02
 
-* Fix boundary parsing #876
+- Fix boundary parsing #876
 
 ## [0.1.1] - 2019-05-25
 
-* Fix disconnect handling #834
+- Fix disconnect handling #834
 
 ## [0.1.0] - 2019-05-18
 
-* Release
+- Release
 
 ## [0.1.0-beta.4] - 2019-05-12
 
-* Handle cancellation of uploads #736
+- Handle cancellation of uploads #736
 
-* Upgrade to actix-web 1.0.0-beta.4
+- Upgrade to actix-web 1.0.0-beta.4
 
 ## [0.1.0-beta.1] - 2019-04-21
 
-* Do not support nested multipart
+- Do not support nested multipart
 
-* Split multipart support to separate crate
+- Split multipart support to separate crate
 
-* Optimize multipart handling #634, #769
+- Optimize multipart handling #634, #769

actix-multipart/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.4.0-beta.10"
+version = "0.4.0-beta.11"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart form support for Actix Web"
 keywords = ["http", "web", "framework", "async", "futures"]
@@ -15,7 +15,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-utils = "3.0.0"
-actix-web = { version = "4.0.0-beta.14", default-features = false }
+actix-web = { version = "4.0.0-beta.17", default-features = false }
 
 bytes = "1"
 derive_more = "0.99.5"
@@ -28,7 +28,7 @@ twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
 futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
-tokio = { version = "1", features = ["sync"] }
+tokio = { version = "1.8.4", features = ["sync"] }
 tokio-stream = "0.1"

actix-multipart/README.md

@@ -3,11 +3,11 @@
 > Multipart form support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart?label=latest)](https://crates.io/crates/actix-multipart)
-[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.10)](https://docs.rs/actix-multipart/0.4.0-beta.10)
+[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.11)](https://docs.rs/actix-multipart/0.4.0-beta.11)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.10/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.10)
+[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.11/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.11)
 [![Download](https://img.shields.io/crates/d/actix-multipart.svg)](https://crates.io/crates/actix-multipart)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-multipart/src/server.rs

@@ -1233,7 +1233,7 @@ mod tests {
 
         // and should not consume the payload
         match payload {
-            actix_web::dev::Payload::H1(_) => {} //expected
+            actix_web::dev::Payload::H1 { .. } => {} //expected
             _ => unreachable!(),
         }
     }

actix-router/CHANGES.md

@@ -1,20 +1,23 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
-* Minimum supported Rust version (MSRV) is now 1.52.
+
+
+## 0.5.0-beta.3 - 2021-12-17
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 
 ## 0.5.0-beta.2 - 2021-09-09
-* Introduce `ResourceDef::join`. [#380]
+- Introduce `ResourceDef::join`. [#380]
-* Disallow prefix routes with tail segments. [#379]
+- Disallow prefix routes with tail segments. [#379]
-* Enforce path separators on dynamic prefixes. [#378]
+- Enforce path separators on dynamic prefixes. [#378]
-* Improve malformed path error message. [#384]
+- Improve malformed path error message. [#384]
-* Prefix segments now always end with with a segment delimiter or end-of-input. [#2355]
+- Prefix segments now always end with with a segment delimiter or end-of-input. [#2355]
-* Prefix segments with trailing slashes define a trailing empty segment. [#2355]
+- Prefix segments with trailing slashes define a trailing empty segment. [#2355]
-* Support multi-pattern prefixes and joins. [#2356]
+- Support multi-pattern prefixes and joins. [#2356]
-* `ResourceDef::pattern` now returns the first pattern in multi-pattern resources. [#2356]
+- `ResourceDef::pattern` now returns the first pattern in multi-pattern resources. [#2356]
-* Support `build_resource_path` on multi-pattern resources. [#2356]
+- Support `build_resource_path` on multi-pattern resources. [#2356]
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 [#378]: https://github.com/actix/actix-net/pull/378
 [#379]: https://github.com/actix/actix-net/pull/379
@@ -25,23 +28,23 @@
 
 
 ## 0.5.0-beta.1 - 2021-07-20
-* Fix a bug in multi-patterns where static patterns are interpreted as regex. [#366]
+- Fix a bug in multi-patterns where static patterns are interpreted as regex. [#366]
-* Introduce `ResourceDef::pattern_iter` to get an iterator over all patterns in a multi-pattern resource. [#373]
+- Introduce `ResourceDef::pattern_iter` to get an iterator over all patterns in a multi-pattern resource. [#373]
-* Fix segment interpolation leaving `Path` in unintended state after matching. [#368]
+- Fix segment interpolation leaving `Path` in unintended state after matching. [#368]
-* Fix `ResourceDef` `PartialEq` implementation. [#373]
+- Fix `ResourceDef` `PartialEq` implementation. [#373]
-* Re-work `IntoPatterns` trait, adding a `Patterns` enum. [#372]
+- Re-work `IntoPatterns` trait, adding a `Patterns` enum. [#372]
-* Implement `IntoPatterns` for `bytestring::ByteString`. [#372]
+- Implement `IntoPatterns` for `bytestring::ByteString`. [#372]
-* Rename `Path::{len => segment_count}` to be more descriptive of it's purpose. [#370]
+- Rename `Path::{len => segment_count}` to be more descriptive of it's purpose. [#370]
-* Rename `ResourceDef::{resource_path => resource_path_from_iter}`. [#371]
+- Rename `ResourceDef::{resource_path => resource_path_from_iter}`. [#371]
-* `ResourceDef::resource_path_from_iter` now takes an `IntoIterator`. [#373]
+- `ResourceDef::resource_path_from_iter` now takes an `IntoIterator`. [#373]
-* Rename `ResourceDef::{resource_path_named => resource_path_from_map}`. [#371]
+- Rename `ResourceDef::{resource_path_named => resource_path_from_map}`. [#371]
-* Rename `ResourceDef::{is_prefix_match => find_match}`. [#373]
+- Rename `ResourceDef::{is_prefix_match => find_match}`. [#373]
-* Rename `ResourceDef::{match_path => capture_match_info}`. [#373]
+- Rename `ResourceDef::{match_path => capture_match_info}`. [#373]
-* Rename `ResourceDef::{match_path_checked => capture_match_info_fn}`. [#373]
+- Rename `ResourceDef::{match_path_checked => capture_match_info_fn}`. [#373]
-* Remove `ResourceDef::name_mut` and introduce `ResourceDef::set_name`. [#373]
+- Remove `ResourceDef::name_mut` and introduce `ResourceDef::set_name`. [#373]
-* Rename `Router::{*_checked => *_fn}`. [#373]
+- Rename `Router::{*_checked => *_fn}`. [#373]
-* Return type of `ResourceDef::name` is now `Option<&str>`. [#373]
+- Return type of `ResourceDef::name` is now `Option<&str>`. [#373]
-* Return type of `ResourceDef::pattern` is now `Option<&str>`. [#373]
+- Return type of `ResourceDef::pattern` is now `Option<&str>`. [#373]
 
 [#368]: https://github.com/actix/actix-net/pull/368
 [#366]: https://github.com/actix/actix-net/pull/366
@@ -53,10 +56,10 @@
 
 
 ## 0.4.0 - 2021-06-06
-* When matching path parameters, `%25` is now kept in the percent-encoded form; no longer decoded to `%`. [#357]
+- When matching path parameters, `%25` is now kept in the percent-encoded form; no longer decoded to `%`. [#357]
-* Path tail patterns now match new lines (`\n`) in request URL. [#360]
+- Path tail patterns now match new lines (`\n`) in request URL. [#360]
-* Fixed a safety bug where `Path` could return a malformed string after percent decoding. [#359]
+- Fixed a safety bug where `Path` could return a malformed string after percent decoding. [#359]
-* Methods `Path::{add, add_static}` now take `impl Into<Cow<'static, str>>`. [#345]
+- Methods `Path::{add, add_static}` now take `impl Into<Cow<'static, str>>`. [#345]
 
 [#345]: https://github.com/actix/actix-net/pull/345
 [#357]: https://github.com/actix/actix-net/pull/357
@@ -65,68 +68,68 @@
 
 
 ## 0.3.0 - 2019-12-31
-* Version was yanked previously. See https://crates.io/crates/actix-router/0.3.0
+- Version was yanked previously. See https://crates.io/crates/actix-router/0.3.0
 
 
 ## 0.2.7 - 2021-02-06
-* Add `Router::recognize_checked` [#247]
+- Add `Router::recognize_checked` [#247]
 
 [#247]: https://github.com/actix/actix-net/pull/247
 
 
 ## 0.2.6 - 2021-01-09
-* Use `bytestring` version range compatible with Bytes v1.0. [#246]
+- Use `bytestring` version range compatible with Bytes v1.0. [#246]
 
 [#246]: https://github.com/actix/actix-net/pull/246
 
 
 ## 0.2.5 - 2020-09-20
-* Fix `from_hex()` method
+- Fix `from_hex()` method
 
 
 ## 0.2.4 - 2019-12-31
-* Add `ResourceDef::resource_path_named()` path generation method
+- Add `ResourceDef::resource_path_named()` path generation method
 
 
 ## 0.2.3 - 2019-12-25
-* Add impl `IntoPattern` for `&String`
+- Add impl `IntoPattern` for `&String`
 
 
 ## 0.2.2 - 2019-12-25
-* Use `IntoPattern` for `RouterBuilder::path()`
+- Use `IntoPattern` for `RouterBuilder::path()`
 
 
 ## 0.2.1 - 2019-12-25
-* Add `IntoPattern` trait
+- Add `IntoPattern` trait
-* Add multi-pattern resources
+- Add multi-pattern resources
 
 
 ## 0.2.0 - 2019-12-07
-* Update http to 0.2
+- Update http to 0.2
-* Update regex to 1.3
+- Update regex to 1.3
-* Use bytestring instead of string
+- Use bytestring instead of string
 
 
 ## 0.1.5 - 2019-05-15
-* Remove debug prints
+- Remove debug prints
 
 
 ## 0.1.4 - 2019-05-15
-* Fix checked resource match
+- Fix checked resource match
 
 
 ## 0.1.3 - 2019-04-22
-* Added support for `remainder match` (i.e "/path/{tail}*")
+- Added support for `remainder match` (i.e "/path/{tail}*")
 
 
 ## 0.1.2 - 2019-04-07
-* Export `Quoter` type
+- Export `Quoter` type
-* Allow to reset `Path` instance
+- Allow to reset `Path` instance
 
 
 ## 0.1.1 - 2019-04-03
-* Get dynamic segment by name instead of iterator.
+- Get dynamic segment by name instead of iterator.
 
 
 ## 0.1.0 - 2019-03-09
-* Initial release
+- Initial release

actix-router/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-router"
-version = "0.5.0-beta.2"
+version = "0.5.0-beta.3"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
@@ -21,7 +21,7 @@ default = ["http"]
 
 [dependencies]
 bytestring = ">=0.1.5, <2"
-firestorm = "0.4"
+firestorm = "0.5"
 http = { version = "0.2.3", optional = true }
 log = "0.4"
 regex = "1.5"
@@ -29,7 +29,7 @@ serde = "1"
 
 [dev-dependencies]
 criterion = { version = "0.3", features = ["html_reports"] }
-firestorm = { version = "0.4", features = ["enable_system_time"] }
+firestorm = { version = "0.5", features = ["enable_system_time"] }
 http = "0.2.5"
 serde = { version = "1", features = ["derive"] }
 

actix-router/src/lib.rs

@@ -7,144 +7,20 @@
 
 mod de;
 mod path;
+mod pattern;
 mod resource;
+mod resource_path;
 mod router;
 
-pub use self::de::PathDeserializer;
-pub use self::path::Path;
-pub use self::resource::ResourceDef;
-pub use self::router::{ResourceInfo, Router, RouterBuilder};
-
-// TODO: this trait is necessary, document it
-// see impl Resource for ServiceRequest
-pub trait Resource<T: ResourcePath> {
-    fn resource_path(&mut self) -> &mut Path<T>;
-}
-
-pub trait ResourcePath {
-    fn path(&self) -> &str;
-}
-
-impl ResourcePath for String {
-    fn path(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl<'a> ResourcePath for &'a str {
-    fn path(&self) -> &str {
-        self
-    }
-}
-
-impl ResourcePath for bytestring::ByteString {
-    fn path(&self) -> &str {
-        &*self
-    }
-}
-
-/// One or many patterns.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Patterns {
-    Single(String),
-    List(Vec<String>),
-}
-
-impl Patterns {
-    pub fn is_empty(&self) -> bool {
-        match self {
-            Patterns::Single(_) => false,
-            Patterns::List(pats) => pats.is_empty(),
-        }
-    }
-}
-
-/// Helper trait for type that could be converted to one or more path pattern.
-pub trait IntoPatterns {
-    fn patterns(&self) -> Patterns;
-}
-
-impl IntoPatterns for String {
-    fn patterns(&self) -> Patterns {
-        Patterns::Single(self.clone())
-    }
-}
-
-impl<'a> IntoPatterns for &'a String {
-    fn patterns(&self) -> Patterns {
-        Patterns::Single((*self).clone())
-    }
-}
-
-impl<'a> IntoPatterns for &'a str {
-    fn patterns(&self) -> Patterns {
-        Patterns::Single((*self).to_owned())
-    }
-}
-
-impl IntoPatterns for bytestring::ByteString {
-    fn patterns(&self) -> Patterns {
-        Patterns::Single(self.to_string())
-    }
-}
-
-impl IntoPatterns for Patterns {
-    fn patterns(&self) -> Patterns {
-        self.clone()
-    }
-}
-
-impl<T: AsRef<str>> IntoPatterns for Vec<T> {
-    fn patterns(&self) -> Patterns {
-        let mut patterns = self.iter().map(|v| v.as_ref().to_owned());
-
-        match patterns.size_hint() {
-            (1, _) => Patterns::Single(patterns.next().unwrap()),
-            _ => Patterns::List(patterns.collect()),
-        }
-    }
-}
-
-macro_rules! array_patterns_single (($tp:ty) => {
-    impl IntoPatterns for [$tp; 1] {
-        fn patterns(&self) -> Patterns {
-            Patterns::Single(self[0].to_owned())
-        }
-    }
-});
-
-macro_rules! array_patterns_multiple (($tp:ty, $str_fn:expr, $($num:tt) +) => {
-    // for each array length specified in $num
-    $(
-        impl IntoPatterns for [$tp; $num] {
-            fn patterns(&self) -> Patterns {
-                Patterns::List(self.iter().map($str_fn).collect())
-            }
-        }
-    )+
-});
-
-array_patterns_single!(&str);
-array_patterns_multiple!(&str, |&v| v.to_owned(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
-
-array_patterns_single!(String);
-array_patterns_multiple!(String, |v| v.clone(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
-
 #[cfg(feature = "http")]
 mod url;
 
+pub use self::de::PathDeserializer;
+pub use self::path::Path;
+pub use self::pattern::{IntoPatterns, Patterns};
+pub use self::resource::ResourceDef;
+pub use self::resource_path::{Resource, ResourcePath};
+pub use self::router::{ResourceInfo, Router, RouterBuilder};
+
 #[cfg(feature = "http")]
 pub use self::url::{Quoter, Url};
-
-#[cfg(feature = "http")]
-mod http_impls {
-    use http::Uri;
-
-    use super::ResourcePath;
-
-    impl ResourcePath for Uri {
-        fn path(&self) -> &str {
-            self.path()
-        }
-    }
-}

actix-router/src/pattern.rs

@@ -0,0 +1,92 @@
+/// One or many patterns.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Patterns {
+    Single(String),
+    List(Vec<String>),
+}
+
+impl Patterns {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Patterns::Single(_) => false,
+            Patterns::List(pats) => pats.is_empty(),
+        }
+    }
+}
+
+/// Helper trait for type that could be converted to one or more path patterns.
+pub trait IntoPatterns {
+    fn patterns(&self) -> Patterns;
+}
+
+impl IntoPatterns for String {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single(self.clone())
+    }
+}
+
+impl IntoPatterns for &String {
+    fn patterns(&self) -> Patterns {
+        (*self).patterns()
+    }
+}
+
+impl IntoPatterns for str {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single(self.to_owned())
+    }
+}
+
+impl IntoPatterns for &str {
+    fn patterns(&self) -> Patterns {
+        (*self).patterns()
+    }
+}
+
+impl IntoPatterns for bytestring::ByteString {
+    fn patterns(&self) -> Patterns {
+        Patterns::Single(self.to_string())
+    }
+}
+
+impl IntoPatterns for Patterns {
+    fn patterns(&self) -> Patterns {
+        self.clone()
+    }
+}
+
+impl<T: AsRef<str>> IntoPatterns for Vec<T> {
+    fn patterns(&self) -> Patterns {
+        let mut patterns = self.iter().map(|v| v.as_ref().to_owned());
+
+        match patterns.size_hint() {
+            (1, _) => Patterns::Single(patterns.next().unwrap()),
+            _ => Patterns::List(patterns.collect()),
+        }
+    }
+}
+
+macro_rules! array_patterns_single (($tp:ty) => {
+    impl IntoPatterns for [$tp; 1] {
+        fn patterns(&self) -> Patterns {
+            Patterns::Single(self[0].to_owned())
+        }
+    }
+});
+
+macro_rules! array_patterns_multiple (($tp:ty, $str_fn:expr, $($num:tt) +) => {
+    // for each array length specified in space-separated $num
+    $(
+        impl IntoPatterns for [$tp; $num] {
+            fn patterns(&self) -> Patterns {
+                Patterns::List(self.iter().map($str_fn).collect())
+            }
+        }
+    )+
+});
+
+array_patterns_single!(&str);
+array_patterns_multiple!(&str, |&v| v.to_owned(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
+
+array_patterns_single!(String);
+array_patterns_multiple!(String, |v| v.clone(), 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);

actix-router/src/resource.rs

@@ -29,26 +29,25 @@ const REGEX_FLAGS: &str = "(?s-m)";
 ///
 ///
 /// # Pattern Format and Matching Behavior
-///
 /// Resource pattern is defined as a string of zero or more _segments_ where each segment is
 /// preceded by a slash `/`.
 ///
-/// This means that pattern string __must__ either be empty or begin with a slash (`/`).
+/// This means that pattern string __must__ either be empty or begin with a slash (`/`). This also
-/// This also implies that a trailing slash in pattern defines an empty segment.
+/// implies that a trailing slash in pattern defines an empty segment. For example, the pattern
-/// For example, the pattern `"/user/"` has two segments: `["user", ""]`
+/// `"/user/"` has two segments: `["user", ""]`
 ///
-/// A key point to underhand is that `ResourceDef` matches segments, not strings.
+/// A key point to understand is that `ResourceDef` matches segments, not strings. Segments are
-/// It matches segments individually.
+/// matched individually. For example, the pattern `/user/` is not considered a prefix for the path
-/// For example, the pattern `/user/` is not considered a prefix for the path `/user/123/456`,
+/// `/user/123/456`, because the second segment doesn't match: `["user", ""]`
-/// because the second segment doesn't match: `["user", ""]` vs `["user", "123", "456"]`.
+/// vs `["user", "123", "456"]`.
 ///
 /// This definition is consistent with the definition of absolute URL path in
-/// [RFC 3986 (section 3.3)](https://datatracker.ietf.org/doc/html/rfc3986#section-3.3)
+/// [RFC 3986 §3.3](https://datatracker.ietf.org/doc/html/rfc3986#section-3.3)
 ///
 ///
 /// # Static Resources
-/// A static resource is the most basic type of definition. Pass a pattern to
+/// A static resource is the most basic type of definition. Pass a pattern to [new][Self::new].
-/// [new][Self::new]. Conforming paths must match the pattern exactly.
+/// Conforming paths must match the pattern exactly.
 ///
 /// ## Examples
 /// ```
@@ -63,7 +62,6 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert!(!resource.is_match("/search"));
 /// ```
 ///
-///
 /// # Dynamic Segments
 /// Also known as "path parameters". Resources can define sections of a pattern that be extracted
 /// from a conforming path, if it conforms to (one of) the resource pattern(s).
@@ -102,15 +100,15 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert_eq!(path.get("id").unwrap(), "123");
 /// ```
 ///
-///
 /// # Prefix Resources
 /// A prefix resource is defined as pattern that can match just the start of a path, up to a
 /// segment boundary.
 ///
 /// Prefix patterns with a trailing slash may have an unexpected, though correct, behavior.
-/// They define and therefore require an empty segment in order to match. Examples are given below.
+/// They define and therefore require an empty segment in order to match. It is easier to understand
+/// this behavior after reading the [matching behavior section]. Examples are given below.
 ///
-/// Empty pattern matches any path as a prefix.
+/// The empty pattern (`""`), as a prefix, matches any path.
 ///
 /// Prefix resources can contain dynamic segments.
 ///
@@ -130,7 +128,6 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert!(!resource.is_match("/user/123"));
 /// ```
 ///
-///
 /// # Custom Regex Segments
 /// Dynamic segments can be customised to only match a specific regular expression. It can be
 /// helpful to do this if resource definitions would otherwise conflict and cause one to
@@ -158,7 +155,6 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert!(!resource.is_match("/user/abc"));
 /// ```
 ///
-///
 /// # Tail Segments
 /// As a shortcut to defining a custom regex for matching _all_ remaining characters (not just those
 /// up until a `/` character), there is a special pattern to match (and capture) the remaining
@@ -179,7 +175,6 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert_eq!(path.get("tail").unwrap(), "main/LICENSE");
 /// ```
 ///
-///
 /// # Multi-Pattern Resources
 /// For resources that can map to multiple distinct paths, it may be suitable to use
 /// multi-pattern resources by passing an array/vec to [`new`][Self::new]. They will be combined
@@ -198,7 +193,6 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert!(resource.is_match("/index"));
 /// ```
 ///
-///
 /// # Trailing Slashes
 /// It should be noted that this library takes no steps to normalize intra-path or trailing slashes.
 /// As such, all resource definitions implicitly expect a pre-processing step to normalize paths if
@@ -212,6 +206,8 @@ const REGEX_FLAGS: &str = "(?s-m)";
 /// assert!(!ResourceDef::new("/root/").is_match("/root"));
 /// assert!(!ResourceDef::prefix("/root/").is_match("/root"));
 /// ```
+///
+/// [matching behavior section]: #pattern-format-and-matching-behavior
 #[derive(Clone, Debug)]
 pub struct ResourceDef {
     id: u16,
@@ -279,7 +275,7 @@ impl ResourceDef {
     /// ```
     pub fn new<T: IntoPatterns>(paths: T) -> Self {
         profile_method!(new);
-        Self::new2(paths, false)
+        Self::construct(paths, false)
     }
 
     /// Constructs a new resource definition using a pattern that performs prefix matching.
@@ -292,7 +288,7 @@ impl ResourceDef {
     /// resource definition with a tail segment; use [`new`][Self::new] in this case.
     ///
     /// # Panics
-    /// Panics if path regex pattern is malformed.
+    /// Panics if path pattern is malformed.
     ///
     /// # Examples
     /// ```
@@ -307,14 +303,14 @@ impl ResourceDef {
     /// ```
     pub fn prefix<T: IntoPatterns>(paths: T) -> Self {
         profile_method!(prefix);
-        ResourceDef::new2(paths, true)
+        ResourceDef::construct(paths, true)
     }
 
     /// Constructs a new resource definition using a string pattern that performs prefix matching,
-    /// inserting a `/` to beginning of the pattern if absent and pattern is not empty.
+    /// ensuring a leading `/` if pattern is not empty.
     ///
     /// # Panics
-    /// Panics if path regex pattern is malformed.
+    /// Panics if path pattern is malformed.
     ///
     /// # Examples
     /// ```
@@ -515,8 +511,8 @@ impl ResourceDef {
             .collect::<Vec<_>>();
 
         match patterns.len() {
-            1 => ResourceDef::new2(&patterns[0], other.is_prefix()),
+            1 => ResourceDef::construct(&patterns[0], other.is_prefix()),
-            _ => ResourceDef::new2(patterns, other.is_prefix()),
+            _ => ResourceDef::construct(patterns, other.is_prefix()),
         }
     }
 
@@ -881,8 +877,8 @@ impl ResourceDef {
         }
     }
 
-    fn new2<T: IntoPatterns>(paths: T, is_prefix: bool) -> Self {
+    fn construct<T: IntoPatterns>(paths: T, is_prefix: bool) -> Self {
-        profile_method!(new2);
+        profile_method!(construct);
 
         let patterns = paths.patterns();
         let (pat_type, segments) = match &patterns {
@@ -1814,7 +1810,7 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn prefix_plus_tail_match_is_allowed() {
+    fn prefix_plus_tail_match_disallowed() {
         ResourceDef::prefix("/user/{id}*");
     }
 }

actix-router/src/resource_path.rs

@@ -0,0 +1,36 @@
+use crate::Path;
+
+// TODO: this trait is necessary, document it
+// see impl Resource for ServiceRequest
+pub trait Resource<T: ResourcePath> {
+    fn resource_path(&mut self) -> &mut Path<T>;
+}
+
+pub trait ResourcePath {
+    fn path(&self) -> &str;
+}
+
+impl ResourcePath for String {
+    fn path(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'a> ResourcePath for &'a str {
+    fn path(&self) -> &str {
+        self
+    }
+}
+
+impl ResourcePath for bytestring::ByteString {
+    fn path(&self) -> &str {
+        &*self
+    }
+}
+
+#[cfg(feature = "http")]
+impl ResourcePath for http::Uri {
+    fn path(&self) -> &str {
+        self.path()
+    }
+}

actix-router/src/url.rs

@@ -2,22 +2,28 @@ use crate::ResourcePath;
 
 #[allow(dead_code)]
 const GEN_DELIMS: &[u8] = b":/?#[]@";
+
 #[allow(dead_code)]
 const SUB_DELIMS_WITHOUT_QS: &[u8] = b"!$'()*,";
+
 #[allow(dead_code)]
 const SUB_DELIMS: &[u8] = b"!$'()*,+?=;";
+
 #[allow(dead_code)]
 const RESERVED: &[u8] = b":/?#[]@!$'()*,+?=;";
+
 #[allow(dead_code)]
 const UNRESERVED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
     ABCDEFGHIJKLMNOPQRSTUVWXYZ
     1234567890
     -._~";
+
 const ALLOWED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
     ABCDEFGHIJKLMNOPQRSTUVWXYZ
     1234567890
     -._~
     !$'()*,";
+
 const QS: &[u8] = b"+&=;b";
 
 #[inline]
@@ -34,19 +40,20 @@ thread_local! {
     static DEFAULT_QUOTER: Quoter = Quoter::new(b"@:", b"%/+");
 }
 
-#[derive(Default, Clone, Debug)]
+#[derive(Debug, Clone, Default)]
 pub struct Url {
     uri: http::Uri,
     path: Option<String>,
 }
 
 impl Url {
+    #[inline]
     pub fn new(uri: http::Uri) -> Url {
         let path = DEFAULT_QUOTER.with(|q| q.requote(uri.path().as_bytes()));
-
         Url { uri, path }
     }
 
+    #[inline]
     pub fn with_quoter(uri: http::Uri, quoter: &Quoter) -> Url {
         Url {
             path: quoter.requote(uri.path().as_bytes()),
@@ -54,15 +61,16 @@ impl Url {
         }
     }
 
+    #[inline]
     pub fn uri(&self) -> &http::Uri {
         &self.uri
     }
 
+    #[inline]
     pub fn path(&self) -> &str {
-        if let Some(ref s) = self.path {
+        match self.path {
-            s
+            Some(ref path) => path,
-        } else {
+            _ => self.uri.path(),
-            self.uri.path()
         }
     }
 
@@ -86,6 +94,7 @@ impl ResourcePath for Url {
     }
 }
 
+/// A quoter
 pub struct Quoter {
     safe_table: [u8; 16],
     protected_table: [u8; 16],
@@ -93,7 +102,7 @@ pub struct Quoter {
 
 impl Quoter {
     pub fn new(safe: &[u8], protected: &[u8]) -> Quoter {
-        let mut q = Quoter {
+        let mut quoter = Quoter {
             safe_table: [0; 16],
             protected_table: [0; 16],
         };
@@ -101,24 +110,24 @@ impl Quoter {
         // prepare safe table
         for i in 0..128 {
             if ALLOWED.contains(&i) {
-                set_bit(&mut q.safe_table, i);
+                set_bit(&mut quoter.safe_table, i);
             }
             if QS.contains(&i) {
-                set_bit(&mut q.safe_table, i);
+                set_bit(&mut quoter.safe_table, i);
             }
         }
 
         for ch in safe {
-            set_bit(&mut q.safe_table, *ch)
+            set_bit(&mut quoter.safe_table, *ch)
         }
 
         // prepare protected table
         for ch in protected {
-            set_bit(&mut q.safe_table, *ch);
+            set_bit(&mut quoter.safe_table, *ch);
-            set_bit(&mut q.protected_table, *ch);
+            set_bit(&mut quoter.protected_table, *ch);
         }
 
-        q
+        quoter
     }
 
     pub fn requote(&self, val: &[u8]) -> Option<String> {
@@ -215,7 +224,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_url() {
+    fn parse_url() {
         let re = "/user/{id}/test";
 
         let path = match_url(re, "/user/2345/test");
@@ -231,24 +240,24 @@ mod tests {
     }
 
     #[test]
-    fn test_protected_chars() {
+    fn protected_chars() {
         let encoded = percent_encode(PROTECTED);
         let path = match_url("/user/{id}/test", format!("/user/{}/test", encoded));
         assert_eq!(path.get("id").unwrap(), &encoded);
     }
 
     #[test]
-    fn test_non_protecteed_ascii() {
+    fn non_protected_ascii() {
-        let nonprotected_ascii = ('\u{0}'..='\u{7F}')
+        let non_protected_ascii = ('\u{0}'..='\u{7F}')
             .filter(|&c| c.is_ascii() && !PROTECTED.contains(&(c as u8)))
             .collect::<String>();
-        let encoded = percent_encode(nonprotected_ascii.as_bytes());
+        let encoded = percent_encode(non_protected_ascii.as_bytes());
         let path = match_url("/user/{id}/test", format!("/user/{}/test", encoded));
-        assert_eq!(path.get("id").unwrap(), &nonprotected_ascii);
+        assert_eq!(path.get("id").unwrap(), &non_protected_ascii);
     }
 
     #[test]
-    fn test_valid_utf8_multibyte() {
+    fn valid_utf8_multibyte() {
         let test = ('\u{FF00}'..='\u{FFFF}').collect::<String>();
         let encoded = percent_encode(test.as_bytes());
         let path = match_url("/a/{id}/b", format!("/a/{}/b", &encoded));
@@ -256,7 +265,7 @@ mod tests {
     }
 
     #[test]
-    fn test_invalid_utf8() {
+    fn invalid_utf8() {
         let invalid_utf8 = percent_encode((0x80..=0xff).collect::<Vec<_>>().as_slice());
         let uri = Uri::try_from(format!("/{}", invalid_utf8)).unwrap();
         let path = Path::new(Url::new(uri));
@@ -266,7 +275,7 @@ mod tests {
     }
 
     #[test]
-    fn test_from_hex() {
+    fn hex_encoding() {
         let hex = b"0123456789abcdefABCDEF";
 
         for i in 0..256 {

actix-test/CHANGES.md

@@ -3,40 +3,51 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.1.0-beta.10 - 2021-12-27
+* No significant changes since `0.1.0-beta.9`.
+
+
+## 0.1.0-beta.9 - 2021-12-17
+- Re-export `actix_http::body::to_bytes`. [#2518]
+- Update `actix_web::test` re-exports. [#2518]
+
+[#2518]: https://github.com/actix/actix-web/pull/2518
+
+
 ## 0.1.0-beta.8 - 2021-12-11
-* No significant changes since `0.1.0-beta.7`.
+- No significant changes since `0.1.0-beta.7`.
 
 
 ## 0.1.0-beta.7 - 2021-11-22
-* Fix compatibility with experimental `io-uring` feature of `actix-rt`. [#2408]
+- Fix compatibility with experimental `io-uring` feature of `actix-rt`. [#2408]
 
 [#2408]: https://github.com/actix/actix-web/pull/2408
 
 
 ## 0.1.0-beta.6 - 2021-11-15
-* No significant changes from `0.1.0-beta.5`.
+- No significant changes from `0.1.0-beta.5`.
 
 
 ## 0.1.0-beta.5 - 2021-10-20
-* Updated rustls to v0.20. [#2414]
+- Updated rustls to v0.20. [#2414]
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 [#2414]: https://github.com/actix/actix-web/pull/2414
 
 
 ## 0.1.0-beta.4 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 0.1.0-beta.3 - 2021-06-20
-* No significant changes from `0.1.0-beta.2`.
+- No significant changes from `0.1.0-beta.2`.
 
 
 ## 0.1.0-beta.2 - 2021-04-17
-* No significant changes from `0.1.0-beta.1`.
+- No significant changes from `0.1.0-beta.1`.
 
 
 ## 0.1.0-beta.1 - 2021-04-02
-* Move integration testing structs from `actix-web`. [#2112]
+- Move integration testing structs from `actix-web`. [#2112]
 
 [#2112]: https://github.com/actix/actix-web/pull/2112

actix-test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-test"
-version = "0.1.0-beta.8"
+version = "0.1.0-beta.10"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
@@ -29,13 +29,13 @@ openssl = ["tls-openssl", "actix-http/openssl", "awc/openssl"]
 
 [dependencies]
 actix-codec = "0.4.1"
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
-actix-http-test = "3.0.0-beta.9"
+actix-http-test = "3.0.0-beta.10"
 actix-rt = "2.1"
 actix-service = "2.0.0"
 actix-utils = "3.0.0"
-actix-web = { version = "4.0.0-beta.14", default-features = false, features = ["cookies"] }
+actix-web = { version = "4.0.0-beta.17", default-features = false, features = ["cookies"] }
-awc = { version = "3.0.0-beta.13", default-features = false, features = ["cookies"] }
+awc = { version = "3.0.0-beta.16", default-features = false, features = ["cookies"] }
 
 futures-core = { version = "0.3.7", default-features = false, features = ["std"] }
 futures-util = { version = "0.3.7", default-features = false, features = [] }
@@ -45,4 +45,4 @@ serde_json = "1"
 serde_urlencoded = "0.7"
 tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
 tls-rustls = { package = "rustls", version = "0.20.0", optional = true }
-tokio = { version = "1.2", features = ["sync"] }
+tokio = { version = "1.8.4", features = ["sync"] }

actix-test/src/lib.rs

@@ -37,9 +37,14 @@ extern crate tls_rustls as rustls;
 use std::{fmt, net, thread, time::Duration};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-pub use actix_http::test::TestBuffer;
+pub use actix_http::{body::to_bytes, test::TestBuffer};
 use actix_http::{header::HeaderMap, ws, HttpService, Method, Request, Response};
+pub use actix_http_test::unused_addr;
 use actix_service::{map_config, IntoServiceFactory, ServiceFactory, ServiceFactoryExt as _};
+pub use actix_web::test::{
+    call_and_read_body, call_and_read_body_json, call_service, init_service, ok_service,
+    read_body, read_body_json, simple_service, TestRequest,
+};
 use actix_web::{
     body::MessageBody,
     dev::{AppConfig, Server, ServerHandle, Service},
@@ -48,12 +53,6 @@ use actix_web::{
 };
 use awc::{error::PayloadError, Client, ClientRequest, ClientResponse, Connector};
 use futures_core::Stream;
-
-pub use actix_http_test::unused_addr;
-pub use actix_web::test::{
-    call_service, default_service, init_service, load_stream, ok_service, read_body,
-    read_body_json, read_response, read_response_json, TestRequest,
-};
 use tokio::sync::mpsc;
 
 /// Start default [`TestServer`].
@@ -341,7 +340,7 @@ where
                 Connector::new()
                     .conn_lifetime(Duration::from_secs(0))
                     .timeout(Duration::from_millis(30000))
-                    .ssl(builder.build())
+                    .openssl(builder.build())
             }
             #[cfg(not(feature = "openssl"))]
             {

actix-web-actors/CHANGES.md

@@ -3,106 +3,110 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 4.0.0-beta.9 - 2021-12-27
+* No significant changes since `4.0.0-beta.8`.
+
+
 ## 4.0.0-beta.8 - 2021-12-11
-* Add `ws:WsResponseBuilder` for building WebSocket session response. [#1920]
+- Add `ws:WsResponseBuilder` for building WebSocket session response. [#1920]
-* Deprecate `ws::{start_with_addr, start_with_protocols}`. [#1920]
+- Deprecate `ws::{start_with_addr, start_with_protocols}`. [#1920]
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 [#1920]: https://github.com/actix/actix-web/pull/1920
 
 
 ## 4.0.0-beta.7 - 2021-09-09
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 
 ## 4.0.0-beta.6 - 2021-06-26
-* Update `actix` to `0.12`. [#2277]
+- Update `actix` to `0.12`. [#2277]
 
 [#2277]: https://github.com/actix/actix-web/pull/2277
 
 
 ## 4.0.0-beta.5 - 2021-06-17
-* No notable changes.
+- No notable changes.
 
 
 ## 4.0.0-beta.4 - 2021-04-02
-* No notable changes.
+- No notable changes.
 
 
 ## 4.0.0-beta.3 - 2021-03-09
-* No notable changes.
+- No notable changes.
 
 
 ## 4.0.0-beta.2 - 2021-02-10
-* No notable changes.
+- No notable changes.
 
 
 ## 4.0.0-beta.1 - 2021-01-07
-* Update `pin-project` to `1.0`.
+- Update `pin-project` to `1.0`.
-* Update `bytes` to `1.0`. [#1813]
+- Update `bytes` to `1.0`. [#1813]
-* `WebsocketContext::text` now takes an `Into<bytestring::ByteString>`. [#1864]
+- `WebsocketContext::text` now takes an `Into<bytestring::ByteString>`. [#1864]
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 [#1864]: https://github.com/actix/actix-web/pull/1864
 
 
 ## 3.0.0 - 2020-09-11
-* No significant changes from `3.0.0-beta.2`.
+- No significant changes from `3.0.0-beta.2`.
 
 
 ## 3.0.0-beta.2 - 2020-09-10
-* Update `actix-*` dependencies to latest versions.
+- Update `actix-*` dependencies to latest versions.
 
 
 ## [3.0.0-beta.1] - 2020-xx-xx
-* Update `actix-web` & `actix-http` dependencies to beta.1
+- Update `actix-web` & `actix-http` dependencies to beta.1
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
 
 
 ## [3.0.0-alpha.1] - 2020-05-08
-* Update the actix-web dependency to 3.0.0-alpha.1
+- Update the actix-web dependency to 3.0.0-alpha.1
-* Update the actix dependency to 0.10.0-alpha.2
+- Update the actix dependency to 0.10.0-alpha.2
-* Update the actix-http dependency to 2.0.0-alpha.3
+- Update the actix-http dependency to 2.0.0-alpha.3
 
 ## [2.0.0] - 2019-12-20
 
-* Release
+- Release
 
 ## [2.0.0-alpha.1] - 2019-12-15
 
-* Migrate to actix-web 2.0.0
+- Migrate to actix-web 2.0.0
 
 ## [1.0.4] - 2019-12-07
 
-* Allow comma-separated websocket subprotocols without spaces (#1172)
+- Allow comma-separated websocket subprotocols without spaces (#1172)
 
 ## [1.0.3] - 2019-11-14
 
-* Update actix-web and actix-http dependencies
+- Update actix-web and actix-http dependencies
 
 ## [1.0.2] - 2019-07-20
 
-* Add `ws::start_with_addr()`, returning the address of the created actor, along
+- Add `ws::start_with_addr()`, returning the address of the created actor, along
   with the `HttpResponse`.
 
-* Add support for specifying protocols on websocket handshake #835
+- Add support for specifying protocols on websocket handshake #835
 
 ## [1.0.1] - 2019-06-28
 
-* Allow to use custom ws codec with `WebsocketContext` #925
+- Allow to use custom ws codec with `WebsocketContext` #925
 
 ## [1.0.0] - 2019-05-29
 
-* Update actix-http and actix-web
+- Update actix-http and actix-web
 
 ## [0.1.0-alpha.3] - 2019-04-02
 
-* Update actix-http and actix-web
+- Update actix-http and actix-web
 
 ## [0.1.0-alpha.2] - 2019-03-29
 
-* Update actix-http and actix-web
+- Update actix-http and actix-web
 
 ## [0.1.0-alpha.1] - 2019-03-28
 
-* Initial impl
+- Initial impl

actix-web-actors/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "4.0.0-beta.8"
+version = "4.0.0-beta.9"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for Actix Web"
 keywords = ["actix", "http", "web", "framework", "async"]
@@ -16,19 +16,19 @@ path = "src/lib.rs"
 [dependencies]
 actix = { version = "0.12.0", default-features = false }
 actix-codec = "0.4.1"
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
-actix-web = { version = "4.0.0-beta.14", default-features = false }
+actix-web = { version = "4.0.0-beta.17", default-features = false }
 
 bytes = "1"
 bytestring = "1"
 futures-core = { version = "0.3.7", default-features = false }
 pin-project-lite = "0.2"
-tokio = { version = "1", features = ["sync"] }
+tokio = { version = "1.8.4", features = ["sync"] }
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-test = "0.1.0-beta.8"
+actix-test = "0.1.0-beta.10"
-awc = { version = "3.0.0-beta.13", default-features = false }
+awc = { version = "3.0.0-beta.16", default-features = false }
 
 env_logger = "0.9"
 futures-util = { version = "0.3.7", default-features = false }

actix-web-actors/README.md

@@ -3,11 +3,11 @@
 > Actix actors support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-actors?label=latest)](https://crates.io/crates/actix-web-actors)
-[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.8)](https://docs.rs/actix-web-actors/4.0.0-beta.8)
+[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.9)](https://docs.rs/actix-web-actors/4.0.0-beta.9)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.8/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.8)
+[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.9/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.9)
 [![Download](https://img.shields.io/crates/d/actix-web-actors.svg)](https://crates.io/crates/actix-web-actors)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

actix-web-codegen/CHANGES.md

@@ -4,101 +4,101 @@
 
 
 ## 0.5.0-beta.6 - 2021-12-11
-* No significant changes since `0.5.0-beta.5`.
+- No significant changes since `0.5.0-beta.5`.
 
 
 ## 0.5.0-beta.5 - 2021-10-20
-* Improve error recovery potential when macro input is invalid. [#2410]
+- Improve error recovery potential when macro input is invalid. [#2410]
-* Add `#[actix_web::test]` macro for setting up tests with a runtime. [#2409]
+- Add `#[actix_web::test]` macro for setting up tests with a runtime. [#2409]
-* Minimum supported Rust version (MSRV) is now 1.52.
+- Minimum supported Rust version (MSRV) is now 1.52.
 
 [#2410]: https://github.com/actix/actix-web/pull/2410
 [#2409]: https://github.com/actix/actix-web/pull/2409
 
 
 ## 0.5.0-beta.4 - 2021-09-09
-* In routing macros, paths are now validated at compile time. [#2350]
+- In routing macros, paths are now validated at compile time. [#2350]
-* Minimum supported Rust version (MSRV) is now 1.51.
+- Minimum supported Rust version (MSRV) is now 1.51.
 
 [#2350]: https://github.com/actix/actix-web/pull/2350
 
 
 ## 0.5.0-beta.3 - 2021-06-17
-* No notable changes.
+- No notable changes.
 
 
 ## 0.5.0-beta.2 - 2021-03-09
-* Preserve doc comments when using route macros. [#2022]
+- Preserve doc comments when using route macros. [#2022]
-* Add `name` attribute to `route` macro. [#1934]
+- Add `name` attribute to `route` macro. [#1934]
 
 [#2022]: https://github.com/actix/actix-web/pull/2022
 [#1934]: https://github.com/actix/actix-web/pull/1934
 
 
 ## 0.5.0-beta.1 - 2021-02-10
-* Use new call signature for `System::new`.
+- Use new call signature for `System::new`.
 
 
 ## 0.4.0 - 2020-09-20
-* Added compile success and failure testing. [#1677]
+- Added compile success and failure testing. [#1677]
-* Add `route` macro for supporting multiple HTTP methods guards. [#1674]
+- Add `route` macro for supporting multiple HTTP methods guards. [#1674]
 
 [#1677]: https://github.com/actix/actix-web/pull/1677
 [#1674]: https://github.com/actix/actix-web/pull/1674
 
 
 ## 0.3.0 - 2020-09-11
-* No significant changes from `0.3.0-beta.1`.
+- No significant changes from `0.3.0-beta.1`.
 
 
 ## 0.3.0-beta.1 - 2020-07-14
-* Add main entry-point macro that uses re-exported runtime. [#1559]
+- Add main entry-point macro that uses re-exported runtime. [#1559]
 
 [#1559]: https://github.com/actix/actix-web/pull/1559
 
 
 ## 0.2.2 - 2020-05-23
-* Add resource middleware on actix-web-codegen [#1467]
+- Add resource middleware on actix-web-codegen [#1467]
 
 [#1467]: https://github.com/actix/actix-web/pull/1467
 
 
 ## 0.2.1 - 2020-02-25
-* Add `#[allow(missing_docs)]` attribute to generated structs [#1368]
+- Add `#[allow(missing_docs)]` attribute to generated structs [#1368]
-* Allow the handler function to be named as `config` [#1290]
+- Allow the handler function to be named as `config` [#1290]
 
 [#1368]: https://github.com/actix/actix-web/issues/1368
 [#1290]: https://github.com/actix/actix-web/issues/1290
 
 
 ## 0.2.0 - 2019-12-13
-* Generate code for actix-web 2.0
+- Generate code for actix-web 2.0
 
 
 ## 0.1.3 - 2019-10-14
-* Bump up `syn` & `quote` to 1.0
+- Bump up `syn` & `quote` to 1.0
-* Provide better error message
+- Provide better error message
 
 
 ## 0.1.2 - 2019-06-04
-* Add macros for head, options, trace, connect and patch http methods
+- Add macros for head, options, trace, connect and patch http methods
 
 
 ## 0.1.1 - 2019-06-01
-* Add syn "extra-traits" feature
+- Add syn "extra-traits" feature
 
 
 ## 0.1.0 - 2019-05-18
-* Release
+- Release
 
 
 ## 0.1.0-beta.1 - 2019-04-20
-* Gen code for actix-web 1.0.0-beta.1
+- Gen code for actix-web 1.0.0-beta.1
 
 
 ## 0.1.0-alpha.6 - 2019-04-14
-* Gen code for actix-web 1.0.0-alpha.6
+- Gen code for actix-web 1.0.0-alpha.6
 
 
 ## 0.1.0-alpha.1 - 2019-03-28
-* Initial impl
+- Initial impl

actix-web-codegen/Cargo.toml

@@ -18,14 +18,14 @@ proc-macro = true
 quote = "1"
 syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"
-actix-router = "0.5.0-beta.2"
+actix-router = "0.5.0-beta.3"
 
 [dev-dependencies]
 actix-macros = "0.2.3"
 actix-rt = "2.2"
-actix-test = "0.1.0-beta.8"
+actix-test = "0.1.0-beta.10"
 actix-utils = "3.0.0"
-actix-web = "4.0.0-beta.14"
+actix-web = "4.0.0-beta.17"
 
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 trybuild = "1"

awc/CHANGES.md

@@ -3,64 +3,91 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 3.0.0-beta.16 - 2021-12-29
+- `*::send_json` and `*::send_form` methods now receive `impl Serialize`. [#2553]
+- `FrozenClientRequest::extra_header` now uses receives an `impl TryIntoHeaderPair`. [#2553]
+- Remove unnecessary `Unpin` bounds on `*::send_stream`. [#2553]
+
+[#2553]: https://github.com/actix/actix-web/pull/2553
+
+
+## 3.0.0-beta.15 - 2021-12-27
+- Rename `Connector::{ssl => openssl}`. [#2503]
+- Improve `Client` instantiation efficiency when using `openssl` by only building connectors once. [#2503]
+- `ClientRequest::send_body` now takes an `impl MessageBody`. [#2546]
+- Rename `MessageBody => ResponseBody` to avoid conflicts with `MessageBody` trait. [#2546]
+- `impl Future` for `ResponseBody` no longer requires the body type be `Unpin`. [#2546]
+- `impl Future` for `JsonBody` no longer requires the body type be `Unpin`. [#2546]
+- `impl Stream` for `ClientResponse` no longer requires the body type be `Unpin`. [#2546]
+
+[#2503]: https://github.com/actix/actix-web/pull/2503
+[#2546]: https://github.com/actix/actix-web/pull/2546
+
+
+## 3.0.0-beta.14 - 2021-12-17
+- Add `ClientBuilder::add_default_header` and deprecate `ClientBuilder::header`. [#2510]
+
+[#2510]: https://github.com/actix/actix-web/pull/2510
+
+
 ## 3.0.0-beta.13 - 2021-12-11
-* No significant changes since `3.0.0-beta.12`.
+- No significant changes since `3.0.0-beta.12`.
 
 
 ## 3.0.0-beta.12 - 2021-11-30
-* Update `actix-tls` to `3.0.0-rc.1`. [#2474]
+- Update `actix-tls` to `3.0.0-rc.1`. [#2474]
 
 [#2474]: https://github.com/actix/actix-web/pull/2474
 
 
 ## 3.0.0-beta.11 - 2021-11-22
-* No significant changes from `3.0.0-beta.10`.
+- No significant changes from `3.0.0-beta.10`.
 
 
 ## 3.0.0-beta.10 - 2021-11-15
-* No significant changes from `3.0.0-beta.9`.
+- No significant changes from `3.0.0-beta.9`.
 
 
 ## 3.0.0-beta.9 - 2021-10-20
-* Updated rustls to v0.20. [#2414]
+- Updated rustls to v0.20. [#2414]
 
 [#2414]: https://github.com/actix/actix-web/pull/2414
 
 
 ## 3.0.0-beta.8 - 2021-09-09
 ### Changed
-* Send headers within the redirect requests. [#2310]
+- Send headers within the redirect requests. [#2310]
 
 [#2310]: https://github.com/actix/actix-web/pull/2310
 
 
 ## 3.0.0-beta.7 - 2021-06-26
 ### Changed
-* Change compression algorithm features flags. [#2250]
+- Change compression algorithm features flags. [#2250]
 
 [#2250]: https://github.com/actix/actix-web/pull/2250
 
 
 ## 3.0.0-beta.6 - 2021-06-17
-* No significant changes since 3.0.0-beta.5.
+- No significant changes since 3.0.0-beta.5.
 
 
 ## 3.0.0-beta.5 - 2021-04-17
 ### Removed
-* Deprecated methods on `ClientRequest`: `if_true`, `if_some`. [#2148]
+- Deprecated methods on `ClientRequest`: `if_true`, `if_some`. [#2148]
 
 [#2148]: https://github.com/actix/actix-web/pull/2148
 
 
 ## 3.0.0-beta.4 - 2021-04-02
 ### Added
-* Add `Client::headers` to get default mut reference of `HeaderMap` of client object. [#2114]
+- Add `Client::headers` to get default mut reference of `HeaderMap` of client object. [#2114]
 
 ### Changed
-* `ConnectorService` type is renamed to `BoxConnectorService`. [#2081]
+- `ConnectorService` type is renamed to `BoxConnectorService`. [#2081]
-* Fix http/https encoding when enabling `compress` feature. [#2116]
+- Fix http/https encoding when enabling `compress` feature. [#2116]
-* Rename `TestResponse::header` to `append_header`, `set` to `insert_header`. `TestResponse` header
+- Rename `TestResponse::header` to `append_header`, `set` to `insert_header`. `TestResponse` header
-  methods now take `IntoHeaderPair` tuples. [#2094]
+  methods now take `TryIntoHeaderPair` tuples. [#2094]
 
 [#2081]: https://github.com/actix/actix-web/pull/2081
 [#2094]: https://github.com/actix/actix-web/pull/2094
@@ -70,16 +97,16 @@
 
 ## 3.0.0-beta.3 - 2021-03-08
 ### Added
-* `ClientResponse::timeout` for set the timeout of collecting response body. [#1931]
+- `ClientResponse::timeout` for set the timeout of collecting response body. [#1931]
-* `ClientBuilder::local_address` for bind to a local ip address for this client. [#2024]
+- `ClientBuilder::local_address` for bind to a local ip address for this client. [#2024]
 
 ### Changed
-* Feature `cookies` is now optional and enabled by default. [#1981]
+- Feature `cookies` is now optional and enabled by default. [#1981]
-* `ClientBuilder::connector` method would take `actix_http::client::Connector<T, U>` type. [#2008]
+- `ClientBuilder::connector` method would take `actix_http::client::Connector<T, U>` type. [#2008]
-* Basic auth password now takes blank passwords as an empty string instead of Option. [#2050]
+- Basic auth password now takes blank passwords as an empty string instead of Option. [#2050]
 
 ### Removed
-* `ClientBuilder::default` function [#2008]
+- `ClientBuilder::default` function [#2008]
 
 [#1931]: https://github.com/actix/actix-web/pull/1931
 [#1981]: https://github.com/actix/actix-web/pull/1981
@@ -90,18 +117,18 @@
 
 ## 3.0.0-beta.2 - 2021-02-10
 ### Added
-* `ClientRequest::insert_header` method which allows using typed headers. [#1869]
+- `ClientRequest::insert_header` method which allows using typed headers. [#1869]
-* `ClientRequest::append_header` method which allows using typed headers. [#1869]
+- `ClientRequest::append_header` method which allows using typed headers. [#1869]
-* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
+- `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
 
 ### Changed
-* Relax default timeout for `Connector` to 5 seconds(original 1 second). [#1905]
+- Relax default timeout for `Connector` to 5 seconds(original 1 second). [#1905]
 
 ### Removed
-* `ClientRequest::set`; use `ClientRequest::insert_header`. [#1869]
+- `ClientRequest::set`; use `ClientRequest::insert_header`. [#1869]
-* `ClientRequest::set_header`; use `ClientRequest::insert_header`. [#1869]
+- `ClientRequest::set_header`; use `ClientRequest::insert_header`. [#1869]
-* `ClientRequest::set_header_if_none`; use `ClientRequest::insert_header_if_none`. [#1869]
+- `ClientRequest::set_header_if_none`; use `ClientRequest::insert_header_if_none`. [#1869]
-* `ClientRequest::header`; use `ClientRequest::append_header`. [#1869]
+- `ClientRequest::header`; use `ClientRequest::append_header`. [#1869]
 
 [#1869]: https://github.com/actix/actix-web/pull/1869
 [#1905]: https://github.com/actix/actix-web/pull/1905
@@ -110,32 +137,32 @@
 
 ## 3.0.0-beta.1 - 2021-01-07
 ### Changed
-* Update `rand` to `0.8`
+- Update `rand` to `0.8`
-* Update `bytes` to `1.0`. [#1813]
+- Update `bytes` to `1.0`. [#1813]
-* Update `rust-tls` to `0.19`. [#1813]
+- Update `rust-tls` to `0.19`. [#1813]
 
 [#1813]: https://github.com/actix/actix-web/pull/1813
 
 
 ## 2.0.3 - 2020-11-29
 ### Fixed
-* Ensure `actix-http` dependency uses same `serde_urlencoded`.
+- Ensure `actix-http` dependency uses same `serde_urlencoded`.
 
 
 ## 2.0.2 - 2020-11-25
 ### Changed
-* Upgrade `serde_urlencoded` to `0.7`. [#1773]
+- Upgrade `serde_urlencoded` to `0.7`. [#1773]
 
 [#1773]: https://github.com/actix/actix-web/pull/1773
 
 
 ## 2.0.1 - 2020-10-30
 ### Changed
-* Upgrade `base64` to `0.13`. [#1744]
+- Upgrade `base64` to `0.13`. [#1744]
-* Deprecate `ClientRequest::{if_some, if_true}`. [#1760]
+- Deprecate `ClientRequest::{if_some, if_true}`. [#1760]
 
 ### Fixed
-* Use `Accept-Encoding: identity` instead of `Accept-Encoding: br` when no compression feature
+- Use `Accept-Encoding: identity` instead of `Accept-Encoding: br` when no compression feature
   is enabled [#1737]
 
 [#1737]: https://github.com/actix/actix-web/pull/1737
@@ -145,209 +172,209 @@
 
 ## 2.0.0 - 2020-09-11
 ### Changed
-* `Client::build` was renamed to `Client::builder`.
+- `Client::build` was renamed to `Client::builder`.
 
 
 ## 2.0.0-beta.4 - 2020-09-09
 ### Changed
-* Update actix-codec & actix-tls dependencies.
+- Update actix-codec & actix-tls dependencies.
 
 
 ## 2.0.0-beta.3 - 2020-08-17
 ### Changed
-* Update `rustls` to 0.18
+- Update `rustls` to 0.18
 
 
 ## 2.0.0-beta.2 - 2020-07-21
 ### Changed
-* Update `actix-http` dependency to 2.0.0-beta.2
+- Update `actix-http` dependency to 2.0.0-beta.2
 
 
 ## [2.0.0-beta.1] - 2020-07-14
 ### Changed
-* Update `actix-http` dependency to 2.0.0-beta.1
+- Update `actix-http` dependency to 2.0.0-beta.1
 
 ## [2.0.0-alpha.2] - 2020-05-21
 
 ### Changed
 
-* Implement `std::error::Error` for our custom errors [#1422]
+- Implement `std::error::Error` for our custom errors [#1422]
-* Bump minimum supported Rust version to 1.40
+- Bump minimum supported Rust version to 1.40
-* Update `base64` dependency to 0.12
+- Update `base64` dependency to 0.12
 
 [#1422]: https://github.com/actix/actix-web/pull/1422
 
 ## [2.0.0-alpha.1] - 2020-03-11
 
-* Update `actix-http` dependency to 2.0.0-alpha.2
+- Update `actix-http` dependency to 2.0.0-alpha.2
-* Update `rustls` dependency to 0.17
+- Update `rustls` dependency to 0.17
-* ClientBuilder accepts initial_window_size and initial_connection_window_size HTTP2 configuration
+- ClientBuilder accepts initial_window_size and initial_connection_window_size HTTP2 configuration
-* ClientBuilder allowing to set max_http_version to limit HTTP version to be used
+- ClientBuilder allowing to set max_http_version to limit HTTP version to be used
 
 ## [1.0.1] - 2019-12-15
 
-* Fix compilation with default features off
+- Fix compilation with default features off
 
 ## [1.0.0] - 2019-12-13
 
-* Release
+- Release
 
 ## [1.0.0-alpha.3]
 
-* Migrate to `std::future`
+- Migrate to `std::future`
 
 
 ## [0.2.8] - 2019-11-06
 
-* Add support for setting query from Serialize type for client request.
+- Add support for setting query from Serialize type for client request.
 
 
 ## [0.2.7] - 2019-09-25
 
 ### Added
 
-* Remaining getter methods for `ClientRequest`'s private `head` field #1101
+- Remaining getter methods for `ClientRequest`'s private `head` field #1101
 
 
 ## [0.2.6] - 2019-09-12
 
 ### Added
 
-* Export frozen request related types.
+- Export frozen request related types.
 
 
 ## [0.2.5] - 2019-09-11
 
 ### Added
 
-* Add `FrozenClientRequest` to support retries for sending HTTP requests
+- Add `FrozenClientRequest` to support retries for sending HTTP requests
 
 ### Changed
 
-* Ensure that the `Host` header is set when initiating a WebSocket client connection.
+- Ensure that the `Host` header is set when initiating a WebSocket client connection.
 
 
 ## [0.2.4] - 2019-08-13
 
 ### Changed
 
-* Update percent-encoding to "2.1"
+- Update percent-encoding to "2.1"
 
-* Update serde_urlencoded to "0.6.1"
+- Update serde_urlencoded to "0.6.1"
 
 
 ## [0.2.3] - 2019-08-01
 
 ### Added
 
-* Add `rustls` support
+- Add `rustls` support
 
 
 ## [0.2.2] - 2019-07-01
 
 ### Changed
 
-* Always append a colon after username in basic auth
+- Always append a colon after username in basic auth
 
-* Upgrade `rand` dependency version to 0.7
+- Upgrade `rand` dependency version to 0.7
 
 
 ## [0.2.1] - 2019-06-05
 
 ### Added
 
-* Add license files
+- Add license files
 
 ## [0.2.0] - 2019-05-12
 
 ### Added
 
-* Allow to send headers in `Camel-Case` form.
+- Allow to send headers in `Camel-Case` form.
 
 ### Changed
 
-* Upgrade actix-http dependency.
+- Upgrade actix-http dependency.
 
 
 ## [0.1.1] - 2019-04-19
 
 ### Added
 
-* Allow to specify server address for http and ws requests.
+- Allow to specify server address for http and ws requests.
 
 ### Changed
 
-* `ClientRequest::if_true()` and `ClientRequest::if_some()` use instance instead of ref
+- `ClientRequest::if_true()` and `ClientRequest::if_some()` use instance instead of ref
 
 
 ## [0.1.0] - 2019-04-16
 
-* No changes
+- No changes
 
 
 ## [0.1.0-alpha.6] - 2019-04-14
 
 ### Changed
 
-* Do not set default headers for websocket request
+- Do not set default headers for websocket request
 
 
 ## [0.1.0-alpha.5] - 2019-04-12
 
 ### Changed
 
-* Do not set any default headers
+- Do not set any default headers
 
 ### Added
 
-* Add Debug impl for BoxedSocket
+- Add Debug impl for BoxedSocket
 
 
 ## [0.1.0-alpha.4] - 2019-04-08
 
 ### Changed
 
-* Update actix-http dependency
+- Update actix-http dependency
 
 
 ## [0.1.0-alpha.3] - 2019-04-02
 
 ### Added
 
-* Export `MessageBody` type
+- Export `MessageBody` type
 
-* `ClientResponse::json()` - Loads and parse `application/json` encoded body
+- `ClientResponse::json()` - Loads and parse `application/json` encoded body
 
 
 ### Changed
 
-* `ClientRequest::json()` accepts reference instead of object.
+- `ClientRequest::json()` accepts reference instead of object.
 
-* `ClientResponse::body()` does not consume response object.
+- `ClientResponse::body()` does not consume response object.
 
-* Renamed `ClientRequest::close_connection()` to `ClientRequest::force_close()`
+- Renamed `ClientRequest::close_connection()` to `ClientRequest::force_close()`
 
 
 ## [0.1.0-alpha.2] - 2019-03-29
 
 ### Added
 
-* Per request and session wide request timeout.
+- Per request and session wide request timeout.
 
-* Session wide headers.
+- Session wide headers.
 
-* Session wide basic and bearer auth.
+- Session wide basic and bearer auth.
 
-* Re-export `actix_http::client::Connector`.
+- Re-export `actix_http::client::Connector`.
 
 
 ### Changed
 
-* Allow to override request's uri
+- Allow to override request's uri
 
-* Export `ws` sub-module with websockets related types
+- Export `ws` sub-module with websockets related types
 
 
 ## [0.1.0-alpha.1] - 2019-03-28
 
-* Initial impl
+- Initial impl

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "3.0.0-beta.13"
+version = "3.0.0-beta.16"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "fakeshadow <24548779@qq.com>",
@@ -60,9 +60,9 @@ dangerous-h2c = []
 [dependencies]
 actix-codec = "0.4.1"
 actix-service = "2.0.0"
-actix-http = "3.0.0-beta.15"
+actix-http = "3.0.0-beta.17"
 actix-rt = { version = "2.1", default-features = false }
-actix-tls = { version = "3.0.0-rc.1", features = ["connect", "uri"] }
+actix-tls = { version = "3.0.0", features = ["connect", "uri"] }
 actix-utils = "3.0.0"
 
 ahash = "0.7"
@@ -70,11 +70,11 @@ base64 = "0.13"
 bytes = "1"
 cfg-if = "1"
 derive_more = "0.99.5"
-futures-core = { version = "0.3.7", default-features = false }
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false }
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
 h2 = "0.3.9"
 http = "0.2.5"
-itoa = "0.4"
+itoa = "1"
 log =" 0.4"
 mime = "0.3"
 percent-encoding = "2.1"
@@ -83,7 +83,7 @@ rand = "0.8"
 serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.7"
-tokio = { version = "1", features = ["sync"] }
+tokio = { version = "1.8.4", features = ["sync"] }
 
 cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 
@@ -93,13 +93,13 @@ tls-rustls = { package = "rustls", version = "0.20.0", optional = true, features
 trust-dns-resolver = { version = "0.20.0", optional = true }
 
 [dev-dependencies]
-actix-http = { version = "3.0.0-beta.15", features = ["openssl"] }
+actix-http = { version = "3.0.0-beta.17", features = ["openssl"] }
-actix-http-test = { version = "3.0.0-beta.9", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.10", features = ["openssl"] }
-actix-server = "2.0.0-rc.1"
+actix-server = "2.0.0-rc.2"
-actix-test = { version = "0.1.0-beta.8", features = ["openssl", "rustls"] }
+actix-test = { version = "0.1.0-beta.10", features = ["openssl", "rustls"] }
-actix-tls = { version = "3.0.0-rc.1", features = ["openssl", "rustls"] }
+actix-tls = { version = "3.0.0", features = ["openssl", "rustls"] }
 actix-utils = "3.0.0"
-actix-web = { version = "4.0.0-beta.14", features = ["openssl"] }
+actix-web = { version = "4.0.0-beta.17", features = ["openssl"] }
 
 brotli2 = "0.3.2"
 env_logger = "0.9"

awc/README.md

@@ -3,9 +3,9 @@
 > Async HTTP and WebSocket client library.
 
 [![crates.io](https://img.shields.io/crates/v/awc?label=latest)](https://crates.io/crates/awc)
-[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.13)](https://docs.rs/awc/3.0.0-beta.13)
+[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.16)](https://docs.rs/awc/3.0.0-beta.16)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/awc)
-[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.13/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.13)
+[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.16/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.16)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 ## Documentation & Resources

awc/src/any_body.rs

@@ -1,17 +1,13 @@
 use std::{
-    borrow::Cow,
     fmt, mem,
     pin::Pin,
     task::{Context, Poll},
 };
 
-use bytes::{Bytes, BytesMut};
+use bytes::Bytes;
-use futures_core::Stream;
 use pin_project_lite::pin_project;
 
-use actix_http::body::{BodySize, BodyStream, BoxBody, MessageBody, SizedStream};
+use actix_http::body::{BodySize, BoxBody, MessageBody};
-
-use crate::BoxError;
 
 pin_project! {
     /// Represents various types of HTTP message body.
@@ -45,9 +41,7 @@ impl AnyBody {
     where
         B: MessageBody + 'static,
     {
-        Self::Body {
+        Self::Body { body: body.boxed() }
-            body: BoxBody::new(body),
-        }
     }
 
     /// Constructs new `AnyBody` instance from a slice of bytes by copying it.
@@ -79,10 +73,27 @@ impl<B> AnyBody<B>
 where
     B: MessageBody + 'static,
 {
+    /// Converts a [`MessageBody`] type into the best possible representation.
+    ///
+    /// Checks size for `None` and tries to convert to `Bytes`. Otherwise, uses the `Body` variant.
+    pub fn from_message_body(body: B) -> Self
+    where
+        B: MessageBody,
+    {
+        if matches!(body.size(), BodySize::None) {
+            return Self::None;
+        }
+
+        match body.try_into_bytes() {
+            Ok(body) => Self::Bytes { body },
+            Err(body) => Self::new(body),
+        }
+    }
+
     pub fn into_boxed(self) -> AnyBody {
         match self {
             Self::None => AnyBody::None,
-            Self::Bytes { body: bytes } => AnyBody::Bytes { body: bytes },
+            Self::Bytes { body } => AnyBody::Bytes { body },
             Self::Body { body } => AnyBody::new_boxed(body),
         }
     }
@@ -145,91 +156,6 @@ impl<S: fmt::Debug> fmt::Debug for AnyBody<S> {
     }
 }
 
-impl<B> From<&'static str> for AnyBody<B> {
-    fn from(string: &'static str) -> Self {
-        Self::Bytes {
-            body: Bytes::from_static(string.as_ref()),
-        }
-    }
-}
-
-impl<B> From<&'static [u8]> for AnyBody<B> {
-    fn from(bytes: &'static [u8]) -> Self {
-        Self::Bytes {
-            body: Bytes::from_static(bytes),
-        }
-    }
-}
-
-impl<B> From<Vec<u8>> for AnyBody<B> {
-    fn from(vec: Vec<u8>) -> Self {
-        Self::Bytes {
-            body: Bytes::from(vec),
-        }
-    }
-}
-
-impl<B> From<String> for AnyBody<B> {
-    fn from(string: String) -> Self {
-        Self::Bytes {
-            body: Bytes::from(string),
-        }
-    }
-}
-
-impl<B> From<&'_ String> for AnyBody<B> {
-    fn from(string: &String) -> Self {
-        Self::Bytes {
-            body: Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&string)),
-        }
-    }
-}
-
-impl<B> From<Cow<'_, str>> for AnyBody<B> {
-    fn from(string: Cow<'_, str>) -> Self {
-        match string {
-            Cow::Owned(s) => Self::from(s),
-            Cow::Borrowed(s) => Self::Bytes {
-                body: Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)),
-            },
-        }
-    }
-}
-
-impl<B> From<Bytes> for AnyBody<B> {
-    fn from(bytes: Bytes) -> Self {
-        Self::Bytes { body: bytes }
-    }
-}
-
-impl<B> From<BytesMut> for AnyBody<B> {
-    fn from(bytes: BytesMut) -> Self {
-        Self::Bytes {
-            body: bytes.freeze(),
-        }
-    }
-}
-
-impl<S, E> From<SizedStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<BoxError> + 'static,
-{
-    fn from(stream: SizedStream<S>) -> Self {
-        AnyBody::new_boxed(stream)
-    }
-}
-
-impl<S, E> From<BodyStream<S>> for AnyBody
-where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<BoxError> + 'static,
-{
-    fn from(stream: BodyStream<S>) -> Self {
-        AnyBody::new_boxed(stream)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::marker::PhantomPinned;

awc/src/builder.rs

@@ -2,18 +2,20 @@ use std::{convert::TryFrom, fmt, net::IpAddr, rc::Rc, time::Duration};
 
 use actix_http::{
     error::HttpError,
-    header::{self, HeaderMap, HeaderName},
+    header::{self, HeaderMap, HeaderName, TryIntoHeaderPair},
     Uri,
 };
 use actix_rt::net::{ActixStream, TcpStream};
 use actix_service::{boxed, Service};
 
 use crate::{
-    client::{ConnectInfo, Connector, ConnectorService, TcpConnectError, TcpConnection},
+    client::{
+        ClientConfig, ConnectInfo, Connector, ConnectorService, TcpConnectError, TcpConnection,
+    },
     connect::DefaultConnector,
     error::SendRequestError,
     middleware::{NestTransform, Redirect, Transform},
-    Client, ClientConfig, ConnectRequest, ConnectResponse,
+    Client, ConnectRequest, ConnectResponse,
 };
 
 /// An HTTP Client builder
@@ -21,11 +23,11 @@ use crate::{
 /// This type can be used to construct an instance of `Client` through a
 /// builder-like pattern.
 pub struct ClientBuilder<S = (), M = ()> {
-    default_headers: bool,
     max_http_version: Option<http::Version>,
     stream_window_size: Option<u32>,
     conn_window_size: Option<u32>,
-    headers: HeaderMap,
+    fundamental_headers: bool,
+    default_headers: HeaderMap,
     timeout: Option<Duration>,
     connector: Connector<S>,
     middleware: M,
@@ -44,15 +46,15 @@ impl ClientBuilder {
         (),
     > {
         ClientBuilder {
-            middleware: (),
-            default_headers: true,
-            headers: HeaderMap::new(),
-            timeout: Some(Duration::from_secs(5)),
-            local_address: None,
-            connector: Connector::new(),
             max_http_version: None,
             stream_window_size: None,
             conn_window_size: None,
+            fundamental_headers: true,
+            default_headers: HeaderMap::new(),
+            timeout: Some(Duration::from_secs(5)),
+            connector: Connector::new(),
+            middleware: (),
+            local_address: None,
             max_redirects: 10,
         }
     }
@@ -78,8 +80,8 @@ where
     {
         ClientBuilder {
             middleware: self.middleware,
+            fundamental_headers: self.fundamental_headers,
             default_headers: self.default_headers,
-            headers: self.headers,
             timeout: self.timeout,
             local_address: self.local_address,
             connector,
@@ -153,30 +155,46 @@ where
         self
     }
 
-    /// Do not add default request headers.
+    /// Do not add fundamental default request headers.
+    ///
     /// By default `Date` and `User-Agent` headers are set.
     pub fn no_default_headers(mut self) -> Self {
-        self.default_headers = false;
+        self.fundamental_headers = false;
         self
     }
 
-    /// Add default header. Headers added by this method
+    /// Add default header.
-    /// get added to every request.
+    ///
+    /// Headers added by this method get added to every request unless overriden by .
+    ///
+    /// # Panics
+    /// Panics if header name or value is invalid.
+    pub fn add_default_header(mut self, header: impl TryIntoHeaderPair) -> Self {
+        match header.try_into_pair() {
+            Ok((key, value)) => self.default_headers.append(key, value),
+            Err(err) => panic!("Header error: {:?}", err.into()),
+        }
+
+        self
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "3.0.0", note = "Prefer `add_default_header((key, value))`.")]
     pub fn header<K, V>(mut self, key: K, value: V) -> Self
     where
         HeaderName: TryFrom<K>,
         <HeaderName as TryFrom<K>>::Error: fmt::Debug + Into<HttpError>,
-        V: header::IntoHeaderValue,
+        V: header::TryIntoHeaderValue,
         V::Error: fmt::Debug,
     {
         match HeaderName::try_from(key) {
             Ok(key) => match value.try_into_value() {
                 Ok(value) => {
-                    self.headers.append(key, value);
+                    self.default_headers.append(key, value);
                 }
-                Err(e) => log::error!("Header value error: {:?}", e),
+                Err(err) => log::error!("Header value error: {:?}", err),
             },
-            Err(e) => log::error!("Header name error: {:?}", e),
+            Err(err) => log::error!("Header name error: {:?}", err),
         }
         self
     }
@@ -190,10 +208,10 @@ where
             Some(password) => format!("{}:{}", username, password),
             None => format!("{}:", username),
         };
-        self.header(
+        self.add_default_header((
             header::AUTHORIZATION,
             format!("Basic {}", base64::encode(&auth)),
-        )
+        ))
     }
 
     /// Set client wide HTTP bearer authentication header
@@ -201,13 +219,12 @@ where
     where
         T: fmt::Display,
     {
-        self.header(header::AUTHORIZATION, format!("Bearer {}", token))
+        self.add_default_header((header::AUTHORIZATION, format!("Bearer {}", token)))
     }
 
-    /// Registers middleware, in the form of a middleware component (type),
+    /// Registers middleware, in the form of a middleware component (type), that runs during inbound
-    /// that runs during inbound and/or outbound processing in the request
+    /// and/or outbound processing in the request life-cycle (request -> response),
-    /// life-cycle (request -> response), modifying request/response as
+    /// modifying request/response as necessary, across all requests managed by the `Client`.
-    /// necessary, across all requests managed by the Client.
     pub fn wrap<S1, M1>(
         self,
         mw: M1,
@@ -218,11 +235,11 @@ where
     {
         ClientBuilder {
             middleware: NestTransform::new(self.middleware, mw),
-            default_headers: self.default_headers,
+            fundamental_headers: self.fundamental_headers,
             max_http_version: self.max_http_version,
             stream_window_size: self.stream_window_size,
             conn_window_size: self.conn_window_size,
-            headers: self.headers,
+            default_headers: self.default_headers,
             timeout: self.timeout,
             connector: self.connector,
             local_address: self.local_address,
@@ -237,10 +254,10 @@ where
         M::Transform:
             Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError>,
     {
-        let redirect_time = self.max_redirects;
+        let max_redirects = self.max_redirects;
 
-        if redirect_time > 0 {
+        if max_redirects > 0 {
-            self.wrap(Redirect::new().max_redirect_times(redirect_time))
+            self.wrap(Redirect::new().max_redirect_times(max_redirects))
                 ._finish()
         } else {
             self._finish()
@@ -272,7 +289,7 @@ where
         let connector = boxed::rc_service(self.middleware.new_transform(connector));
 
         Client(ClientConfig {
-            headers: Rc::new(self.headers),
+            default_headers: Rc::new(self.default_headers),
             timeout: self.timeout,
             connector,
         })
@@ -288,7 +305,7 @@ mod tests {
         let client = ClientBuilder::new().basic_auth("username", Some("password"));
         assert_eq!(
             client
-                .headers
+                .default_headers
                 .get(header::AUTHORIZATION)
                 .unwrap()
                 .to_str()
@@ -299,7 +316,7 @@ mod tests {
         let client = ClientBuilder::new().basic_auth("username", None);
         assert_eq!(
             client
-                .headers
+                .default_headers
                 .get(header::AUTHORIZATION)
                 .unwrap()
                 .to_str()
@@ -313,7 +330,7 @@ mod tests {
         let client = ClientBuilder::new().bearer_auth("someS3cr3tAutht0k3n");
         assert_eq!(
             client
-                .headers
+                .default_headers
                 .get(header::AUTHORIZATION)
                 .unwrap()
                 .to_str()

awc/src/client/connection.rs

@@ -267,7 +267,9 @@ where
                 Connection::Tls(ConnectionType::H2(conn)) => {
                     h2proto::send_request(conn, head.into(), body).await
                 }
-                _ => unreachable!("Plain Tcp connection can be used only in Http1 protocol"),
+                _ => {
+                    unreachable!("Plain TCP connection can be used only with HTTP/1.1 protocol")
+                }
             }
         })
     }

awc/src/client/connector.rs

@@ -22,11 +22,13 @@ use futures_core::{future::LocalBoxFuture, ready};
 use http::Uri;
 use pin_project_lite::pin_project;
 
-use super::config::ConnectorConfig;
+use super::{
-use super::connection::{Connection, ConnectionIo};
+    config::ConnectorConfig,
-use super::error::ConnectError;
+    connection::{Connection, ConnectionIo},
-use super::pool::ConnectionPool;
+    error::ConnectError,
-use super::Connect;
+    pool::ConnectionPool,
+    Connect,
+};
 
 enum OurTlsConnector {
     #[allow(dead_code)] // only dead when no TLS feature is enabled
@@ -35,6 +37,12 @@ enum OurTlsConnector {
     #[cfg(feature = "openssl")]
     Openssl(actix_tls::connect::openssl::reexports::SslConnector),
 
+    /// Provided because building the OpenSSL context on newer versions can be very slow.
+    /// This prevents unnecessary calls to `.build()` while constructing the client connector.
+    #[cfg(feature = "openssl")]
+    #[allow(dead_code)] // false positive; used in build_ssl
+    OpensslBuilder(actix_tls::connect::openssl::reexports::SslConnectorBuilder),
+
     #[cfg(feature = "rustls")]
     Rustls(std::sync::Arc<actix_tls::connect::rustls::reexports::ClientConfig>),
 }
@@ -57,7 +65,7 @@ pub struct Connector<T> {
     config: ConnectorConfig,
 
     #[allow(dead_code)] // only dead when no TLS feature is enabled
-    ssl: OurTlsConnector,
+    tls: OurTlsConnector,
 }
 
 impl Connector<()> {
@@ -72,7 +80,7 @@ impl Connector<()> {
         Connector {
             connector: TcpConnector::new(resolver::resolver()).service(),
             config: ConnectorConfig::default(),
-            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
+            tls: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
         }
     }
 
@@ -116,7 +124,7 @@ impl Connector<()> {
             log::error!("Can not set ALPN protocol: {:?}", err);
         }
 
-        OurTlsConnector::Openssl(ssl.build())
+        OurTlsConnector::OpensslBuilder(ssl)
     }
 }
 
@@ -134,7 +142,7 @@ impl<S> Connector<S> {
         Connector {
             connector,
             config: self.config,
-            ssl: self.ssl,
+            tls: self.tls,
         }
     }
 }
@@ -167,23 +175,35 @@ where
         self
     }
 
+    /// Use custom OpenSSL `SslConnector` instance.
     #[cfg(feature = "openssl")]
-    /// Use custom `SslConnector` instance.
+    pub fn openssl(
+        mut self,
+        connector: actix_tls::connect::openssl::reexports::SslConnector,
+    ) -> Self {
+        self.tls = OurTlsConnector::Openssl(connector);
+        self
+    }
+
+    /// See docs for [`Connector::openssl`].
+    #[doc(hidden)]
+    #[cfg(feature = "openssl")]
+    #[deprecated(since = "3.0.0", note = "Renamed to `Connector::openssl`.")]
     pub fn ssl(
         mut self,
         connector: actix_tls::connect::openssl::reexports::SslConnector,
     ) -> Self {
-        self.ssl = OurTlsConnector::Openssl(connector);
+        self.tls = OurTlsConnector::Openssl(connector);
         self
     }
 
+    /// Use custom Rustls `ClientConfig` instance.
     #[cfg(feature = "rustls")]
-    /// Use custom `ClientConfig` instance.
     pub fn rustls(
         mut self,
         connector: std::sync::Arc<actix_tls::connect::rustls::reexports::ClientConfig>,
     ) -> Self {
-        self.ssl = OurTlsConnector::Rustls(connector);
+        self.tls = OurTlsConnector::Rustls(connector);
         self
     }
 
@@ -198,7 +218,7 @@ where
                 unimplemented!("actix-http client only supports versions http/1.1 & http/2")
             }
         };
-        self.ssl = Connector::build_ssl(versions);
+        self.tls = Connector::build_ssl(versions);
         self
     }
 
@@ -270,8 +290,8 @@ where
     }
 
     /// Finish configuration process and create connector service.
-    /// The Connector builder always concludes by calling `finish()` last in
+    ///
-    /// its combinator chain.
+    /// The `Connector` builder always concludes by calling `finish()` last in its combinator chain.
     pub fn finish(self) -> ConnectorService<S, IO> {
         let local_address = self.config.local_address;
         let timeout = self.config.timeout;
@@ -284,7 +304,15 @@ where
             service: tcp_service_inner.clone(),
         };
 
-        let tls_service = match self.ssl {
+        let tls = match self.tls {
+            #[cfg(feature = "openssl")]
+            OurTlsConnector::OpensslBuilder(builder) => {
+                OurTlsConnector::Openssl(builder.build())
+            }
+            tls => tls,
+        };
+
+        let tls_service = match tls {
             OurTlsConnector::None => {
                 #[cfg(not(feature = "dangerous-h2c"))]
                 {
@@ -374,6 +402,11 @@ where
                 Some(actix_service::boxed::rc_service(tls_service))
             }
 
+            #[cfg(feature = "openssl")]
+            OurTlsConnector::OpensslBuilder(_) => {
+                unreachable!("OpenSSL builder is built before this match.");
+            }
+
             #[cfg(feature = "rustls")]
             OurTlsConnector::Rustls(tls) => {
                 const H2: &[u8] = b"h2";
@@ -853,7 +886,7 @@ mod tests {
         let connector = Connector {
             connector: TcpConnector::new(resolver::resolver()).service(),
             config: ConnectorConfig::default(),
-            ssl: OurTlsConnector::None,
+            tls: OurTlsConnector::None,
         };
 
         let client = Client::builder().connector(connector).finish();

awc/src/client/h1proto.rs

@@ -9,20 +9,21 @@ use actix_http::{
     body::{BodySize, MessageBody},
     error::PayloadError,
     h1,
-    header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
+    header::{HeaderMap, TryIntoHeaderValue, EXPECT, HOST},
     Payload, RequestHeadType, ResponseHead, StatusCode,
 };
 use actix_utils::future::poll_fn;
-use bytes::buf::BufMut;
+use bytes::{buf::BufMut, Bytes, BytesMut};
-use bytes::{Bytes, BytesMut};
 use futures_core::{ready, Stream};
 use futures_util::SinkExt as _;
 use pin_project_lite::pin_project;
 
 use crate::BoxError;
 
-use super::connection::{ConnectionIo, H1Connection};
+use super::{
-use super::error::{ConnectError, SendRequestError};
+    connection::{ConnectionIo, H1Connection},
+    error::{ConnectError, SendRequestError},
+};
 
 pub(crate) async fn send_request<Io, B>(
     io: H1Connection<Io>,
@@ -123,7 +124,12 @@ where
 
             Ok((head, Payload::None))
         }
-        _ => Ok((head, Payload::Stream(Box::pin(PlStream::new(framed))))),
+        _ => Ok((
+            head,
+            Payload::Stream {
+                payload: Box::pin(PlStream::new(framed)),
+            },
+        )),
     }
 }
 

awc/src/client/h2proto.rs

@@ -52,9 +52,11 @@ where
     let _ = match length {
         BodySize::None => None,
 
-        BodySize::Sized(0) => req
+        BodySize::Sized(0) => {
-            .headers_mut()
+            #[allow(clippy::declare_interior_mutable_const)]
-            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+            const HV_ZERO: HeaderValue = HeaderValue::from_static("0");
+            req.headers_mut().insert(CONTENT_LENGTH, HV_ZERO)
+        }
 
         BodySize::Sized(len) => {
             let mut buf = itoa::Buffer::new();

awc/src/client/mod.rs

@@ -1,6 +1,15 @@
 //! HTTP client.
 
-use http::Uri;
+use std::{convert::TryFrom, rc::Rc, time::Duration};
+
+use actix_http::{error::HttpError, header::HeaderMap, Method, RequestHead, Uri};
+use actix_rt::net::TcpStream;
+use actix_service::Service;
+pub use actix_tls::connect::{
+    ConnectError as TcpConnectError, ConnectInfo, Connection as TcpConnection,
+};
+
+use crate::{ws, BoxConnectorService, ClientBuilder, ClientRequest};
 
 mod config;
 mod connection;
@@ -10,10 +19,6 @@ mod h1proto;
 mod h2proto;
 mod pool;
 
-pub use actix_tls::connect::{
-    ConnectError as TcpConnectError, ConnectInfo, Connection as TcpConnection,
-};
-
 pub use self::connection::{Connection, ConnectionIo};
 pub use self::connector::{Connector, ConnectorService};
 pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
@@ -23,3 +28,176 @@ pub struct Connect {
     pub uri: Uri,
     pub addr: Option<std::net::SocketAddr>,
 }
+
+/// An asynchronous HTTP and WebSocket client.
+///
+/// You should take care to create, at most, one `Client` per thread. Otherwise, expect higher CPU
+/// and memory usage.
+///
+/// # Examples
+/// ```
+/// use awc::Client;
+///
+/// #[actix_rt::main]
+/// async fn main() {
+///     let mut client = Client::default();
+///
+///     let res = client.get("http://www.rust-lang.org")
+///         .insert_header(("User-Agent", "my-app/1.2"))
+///         .send()
+///         .await;
+///
+///      println!("Response: {:?}", res);
+/// }
+/// ```
+#[derive(Clone)]
+pub struct Client(pub(crate) ClientConfig);
+
+#[derive(Clone)]
+pub(crate) struct ClientConfig {
+    pub(crate) connector: BoxConnectorService,
+    pub(crate) default_headers: Rc<HeaderMap>,
+    pub(crate) timeout: Option<Duration>,
+}
+
+impl Default for Client {
+    fn default() -> Self {
+        ClientBuilder::new().finish()
+    }
+}
+
+impl Client {
+    /// Create new client instance with default settings.
+    pub fn new() -> Client {
+        Client::default()
+    }
+
+    /// Create `Client` builder.
+    /// This function is equivalent of `ClientBuilder::new()`.
+    pub fn builder() -> ClientBuilder<
+        impl Service<
+                ConnectInfo<Uri>,
+                Response = TcpConnection<Uri, TcpStream>,
+                Error = TcpConnectError,
+            > + Clone,
+    > {
+        ClientBuilder::new()
+    }
+
+    /// Construct HTTP request.
+    pub fn request<U>(&self, method: Method, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        let mut req = ClientRequest::new(method, url, self.0.clone());
+
+        for header in self.0.default_headers.iter() {
+            // header map is empty
+            // TODO: probably append instead
+            req = req.insert_header_if_none(header);
+        }
+        req
+    }
+
+    /// Create `ClientRequest` from `RequestHead`
+    ///
+    /// It is useful for proxy requests. This implementation
+    /// copies all headers and the method.
+    pub fn request_from<U>(&self, url: U, head: &RequestHead) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        let mut req = self.request(head.method.clone(), url);
+        for header in head.headers.iter() {
+            req = req.insert_header_if_none(header);
+        }
+        req
+    }
+
+    /// Construct HTTP *GET* request.
+    pub fn get<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::GET, url)
+    }
+
+    /// Construct HTTP *HEAD* request.
+    pub fn head<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::HEAD, url)
+    }
+
+    /// Construct HTTP *PUT* request.
+    pub fn put<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::PUT, url)
+    }
+
+    /// Construct HTTP *POST* request.
+    pub fn post<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::POST, url)
+    }
+
+    /// Construct HTTP *PATCH* request.
+    pub fn patch<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::PATCH, url)
+    }
+
+    /// Construct HTTP *DELETE* request.
+    pub fn delete<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::DELETE, url)
+    }
+
+    /// Construct HTTP *OPTIONS* request.
+    pub fn options<U>(&self, url: U) -> ClientRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        self.request(Method::OPTIONS, url)
+    }
+
+    /// Initialize a WebSocket connection.
+    /// Returns a WebSocket connection builder.
+    pub fn ws<U>(&self, url: U) -> ws::WebsocketsRequest
+    where
+        Uri: TryFrom<U>,
+        <Uri as TryFrom<U>>::Error: Into<HttpError>,
+    {
+        let mut req = ws::WebsocketsRequest::new(url, self.0.clone());
+        for (key, value) in self.0.default_headers.iter() {
+            req.head.headers.insert(key.clone(), value.clone());
+        }
+        req
+    }
+
+    /// Get default HeaderMap of Client.
+    ///
+    /// Returns Some(&mut HeaderMap) when Client object is unique
+    /// (No other clone of client exists at the same time).
+    pub fn headers(&mut self) -> Option<&mut HeaderMap> {
+        Rc::get_mut(&mut self.0.default_headers)
+    }
+}

awc/src/connect.rs

@@ -16,7 +16,7 @@ use crate::{
     client::{
         Connect as ClientConnect, ConnectError, Connection, ConnectionIo, SendRequestError,
     },
-    response::ClientResponse,
+    ClientResponse,
 };
 
 pub type BoxConnectorService = Rc<

awc/src/error.rs

@@ -1,5 +1,6 @@
 //! HTTP client errors
 
+// TODO: figure out how best to expose http::Error vs actix_http::Error
 pub use actix_http::{
     error::{HttpError, PayloadError},
     header::HeaderValue,

awc/src/frozen.rs

@@ -1,22 +1,24 @@
-use std::{convert::TryFrom, net, rc::Rc, time::Duration};
+use std::{net, rc::Rc, time::Duration};
 
 use bytes::Bytes;
 use futures_core::Stream;
 use serde::Serialize;
 
 use actix_http::{
+    body::MessageBody,
     error::HttpError,
-    header::{HeaderMap, HeaderName, IntoHeaderValue},
+    header::{HeaderMap, TryIntoHeaderPair},
     Method, RequestHead, Uri,
 };
 
 use crate::{
-    any_body::AnyBody,
+    client::ClientConfig,
     sender::{RequestSender, SendClientRequest},
-    BoxError, ClientConfig,
+    BoxError,
 };
 
 /// `FrozenClientRequest` struct represents cloneable client request.
+///
 /// It could be used to send same request multiple times.
 #[derive(Clone)]
 pub struct FrozenClientRequest {
@@ -46,7 +48,7 @@ impl FrozenClientRequest {
     /// Send a body.
     pub fn send_body<B>(&self, body: B) -> SendClientRequest
     where
-        B: Into<AnyBody>,
+        B: MessageBody + 'static,
     {
         RequestSender::Rc(self.head.clone(), None).send_body(
             self.addr,
@@ -82,7 +84,7 @@ impl FrozenClientRequest {
     /// Send a streaming body.
     pub fn send_stream<S, E>(&self, stream: S) -> SendClientRequest
     where
-        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+        S: Stream<Item = Result<Bytes, E>> + 'static,
         E: Into<BoxError> + 'static,
     {
         RequestSender::Rc(self.head.clone(), None).send_stream(
@@ -104,20 +106,14 @@ impl FrozenClientRequest {
         )
     }
 
-    /// Create a `FrozenSendBuilder` with extra headers
+    /// Clones this `FrozenClientRequest`, returning a new one with extra headers added.
     pub fn extra_headers(&self, extra_headers: HeaderMap) -> FrozenSendBuilder {
         FrozenSendBuilder::new(self.clone(), extra_headers)
     }
 
-    /// Create a `FrozenSendBuilder` with an extra header
+    /// Clones this `FrozenClientRequest`, returning a new one with the extra header added.
-    pub fn extra_header<K, V>(&self, key: K, value: V) -> FrozenSendBuilder
+    pub fn extra_header(&self, header: impl TryIntoHeaderPair) -> FrozenSendBuilder {
-    where
+        self.extra_headers(HeaderMap::new()).extra_header(header)
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
-        V: IntoHeaderValue,
-    {
-        self.extra_headers(HeaderMap::new())
-            .extra_header(key, value)
     }
 }
 
@@ -138,29 +134,20 @@ impl FrozenSendBuilder {
     }
 
     /// Insert a header, it overrides existing header in `FrozenClientRequest`.
-    pub fn extra_header<K, V>(mut self, key: K, value: V) -> Self
+    pub fn extra_header(mut self, header: impl TryIntoHeaderPair) -> Self {
-    where
+        match header.try_into_pair() {
-        HeaderName: TryFrom<K>,
+            Ok((key, value)) => {
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
+                self.extra_headers.insert(key, value);
-        V: IntoHeaderValue,
+            }
-    {
+
-        match HeaderName::try_from(key) {
+            Err(err) => self.err = Some(err.into()),
-            Ok(key) => match value.try_into_value() {
-                Ok(value) => {
-                    self.extra_headers.insert(key, value);
-                }
-                Err(e) => self.err = Some(e.into()),
-            },
-            Err(e) => self.err = Some(e.into()),
         }
+
         self
     }
 
     /// Complete request construction and send a body.
-    pub fn send_body<B>(self, body: B) -> SendClientRequest
+    pub fn send_body(self, body: impl MessageBody + 'static) -> SendClientRequest {
-    where
-        B: Into<AnyBody>,
-    {
         if let Some(e) = self.err {
             return e.into();
         }
@@ -175,9 +162,9 @@ impl FrozenSendBuilder {
     }
 
     /// Complete request construction and send a json body.
-    pub fn send_json<T: Serialize>(self, value: &T) -> SendClientRequest {
+    pub fn send_json(self, value: impl Serialize) -> SendClientRequest {
-        if let Some(e) = self.err {
+        if let Some(err) = self.err {
-            return e.into();
+            return err.into();
         }
 
         RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_json(
@@ -190,7 +177,7 @@ impl FrozenSendBuilder {
     }
 
     /// Complete request construction and send an urlencoded body.
-    pub fn send_form<T: Serialize>(self, value: &T) -> SendClientRequest {
+    pub fn send_form(self, value: impl Serialize) -> SendClientRequest {
         if let Some(e) = self.err {
             return e.into();
         }
@@ -207,7 +194,7 @@ impl FrozenSendBuilder {
     /// Complete request construction and send a streaming body.
     pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
     where
-        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+        S: Stream<Item = Result<Bytes, E>> + 'static,
         E: Into<BoxError> + 'static,
     {
         if let Some(e) = self.err {