prepare awc release 2.0.1

prepare http release 2.1.0
deprecate builder if-x methods (#1760 )
2025-07-05 18:35:22 +02:00 · 2020-10-30 02:50:53 +00:00 · 2020-10-30 02:19:56 +00:00 · 2020-10-30 02:10:05 +00:00 · 2020-10-30 02:03:26 +00:00 · 2020-10-29 18:38:49 +00:00
82 changed files with 2837 additions and 1178 deletions
--- a/CHANGES.md
+++ b/CHANGES.md
@ -1,6 +1,46 @@
 # Changes

 ## Unreleased - 2020-xx-xx
+### Added
+* Implement `exclude_regex` for Logger middleware. [#1723]
+* Add request-local data extractor `web::ReqData`. [#1748]
+* Add ability to register closure for request middleware logging. [#1749]
+* Add `app_data` to `ServiceConfig`. [#1757]
+* Expose `on_connect` for access to the connection stream before request is handled. [#1754]
+
+### Changed
+* Print non-configured `Data<T>` type when attempting extraction. [#1743]
+* Re-export bytes::Buf{Mut} in web module. [#1750]
+* Upgrade `pin-project` to `1.0`.
+
+[#1723]: https://github.com/actix/actix-web/pull/1723
+[#1743]: https://github.com/actix/actix-web/pull/1743
+[#1748]: https://github.com/actix/actix-web/pull/1748
+[#1750]: https://github.com/actix/actix-web/pull/1750
+[#1754]: https://github.com/actix/actix-web/pull/1754
+[#1749]: https://github.com/actix/actix-web/pull/1749
+
+
+## 3.1.0 - 2020-09-29
+### Changed
+* Add `TrailingSlash::MergeOnly` behaviour to `NormalizePath`, which allows `NormalizePath`
+  to retain any trailing slashes. [#1695]
+* Remove bound `std::marker::Sized` from `web::Data` to support storing `Arc<dyn Trait>`
+  via `web::Data::from` [#1710]
+
+### Fixed
+* `ResourceMap` debug printing is no longer infinitely recursive. [#1708]
+
+[#1695]: https://github.com/actix/actix-web/pull/1695
+[#1708]: https://github.com/actix/actix-web/pull/1708
+[#1710]: https://github.com/actix/actix-web/pull/1710
+
+
+## 3.0.2 - 2020-09-15
+### Fixed
+* `NormalizePath` when used with `TrailingSlash::Trim` no longer trims the root path "/". [#1678]
+
+[#1678]: https://github.com/actix/actix-web/pull/1678


 ## 3.0.1 - 2020-09-13
@ -164,7 +204,7 @@

 ### Deleted

-* Delete HttpServer::run(), it is not useful witht async/await
+* Delete HttpServer::run(), it is not useful with async/await

 ## [2.0.0-alpha.3] - 2019-12-07

@ -209,7 +249,7 @@

 ### Changed

-* Make UrlEncodedError::Overflow more informativve
+* Make UrlEncodedError::Overflow more informative

 * Use actix-testing for testing utils

@ -227,7 +267,7 @@

 * Re-implement Host predicate (#989)

-* Form immplements Responder, returning a `application/x-www-form-urlencoded` response
+* Form implements Responder, returning a `application/x-www-form-urlencoded` response

 * Add `into_inner` to `Data`

--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "3.0.1"
+version = "3.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a powerful, pragmatic, and extremely fast web framework for Rust."
 readme = "README.md"
@ -64,6 +64,14 @@ required-features = ["compress"]
 name = "test_server"
 required-features = ["compress"]

+[[example]]
+name = "on_connect"
+required-features = []
+
+[[example]]
+name = "client"
+required-features = ["rustls"]
+
 [dependencies]
 actix-codec = "0.3.0"
 actix-service = "1.0.6"
@ -90,8 +98,8 @@ fxhash = "0.2.1"
 log = "0.4"
 mime = "0.3"
 socket2 = "0.3"
-pin-project = "0.4.17"
-regex = "1.3"
+pin-project = "1.0.0"
+regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.6.1"
@ -99,13 +107,13 @@ time = { version = "0.2.7", default-features = false, features = ["std"] }
 url = "2.1"
 open-ssl = { package = "openssl", version = "0.10", optional = true }
 rust-tls = { package = "rustls", version = "0.18.0", optional = true }
-tinyvec = { version = "0.3", features = ["alloc"] }
+tinyvec = { version = "1", features = ["alloc"] }

 [dev-dependencies]
 actix = "0.10.0"
-actix-http = { version = "2.0.0-beta.4", features = ["actors"] }
+actix-http = { version = "2.0.0", features = ["actors"] }
 rand = "0.7"
-env_logger = "0.7"
+env_logger = "0.8"
 serde_derive = "1.0"
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
@ -125,10 +133,6 @@ actix-files = { path = "actix-files" }
 actix-multipart = { path = "actix-multipart" }
 awc = { path = "awc" }

-[[example]]
-name = "client"
-required-features = ["rustls"]
-
 [[bench]]
 name = "server"
 harness = false
--- a/MIGRATION.md
+++ b/MIGRATION.md
@ -3,12 +3,23 @@

 ## 3.0.0

+* The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to
+  simply a `T`. To access a `Data<T>` use `ServiceRequest::app_data::<Data<T>>()`.
+
+* Cookie handling has been offloaded to the `cookie` crate:
+  * `USERINFO_ENCODE_SET` is no longer exposed. Percent-encoding is still supported; check docs.
+  * Some types now require lifetime parameters.
+
+* The time crate was updated to `v0.2`, a major breaking change to the time crate, which affects
+  any `actix-web` method previously expecting a time v0.1 input.
+
 * Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
  result in `SameSite=None` being sent with the response Set-Cookie header.
  To create a cookie without a SameSite attribute, remove any calls setting same_site.

 * actix-http support for Actors messages was moved to actix-http crate and is enabled 
  with feature `actors`
+
 * content_length function is removed from actix-http.
  You can set Content-Length by normally setting the response body or calling no_chunking function. 

@ -37,7 +48,7 @@

 * `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
  It will need `middleware::normalize::TrailingSlash` when being constructed with `NormalizePath::new(...)`,
-  or for an easier migration you can replace `wrap(middleware::NormalizePath)` with `wrap(middleware::NormalizePath::default())`.
+  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`.

--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -1,12 +1,24 @@
 # Changes

-## [Unreleased] - 2020-xx-xx
+## Unreleased - 2020-xx-xx

-## [0.3.0-beta.1] - 2020-07-15
+
+## 0.4.0 - 2020-10-06
+* Add `Files::prefer_utf8` option that adds UTF-8 charset on certain response types. [#1714]
+
+[#1714]: https://github.com/actix/actix-web/pull/1714
+
+
+## 0.3.0 - 2020-09-11
+* No significant changes from 0.3.0-beta.1.
+
+
+## 0.3.0-beta.1 - 2020-07-15
 * Update `v_htmlescape` to 0.10
 * Update `actix-web` and `actix-http` dependencies to beta.1

-## [0.3.0-alpha.1] - 2020-05-23
+
+## 0.3.0-alpha.1 - 2020-05-23
 * Update `actix-web` and `actix-http` dependencies to alpha
 * Fix some typos in the docs
 * Bump minimum supported Rust version to 1.40
@ -14,77 +26,73 @@

 [#1384]: https://github.com/actix/actix-web/pull/1384

-## [0.2.1] - 2019-12-22

+## 0.2.1 - 2019-12-22
 * Use the same format for file URLs regardless of platforms

-## [0.2.0] - 2019-12-20

+## 0.2.0 - 2019-12-20
 * Fix BodyEncoding trait import #1220

-## [0.2.0-alpha.1] - 2019-12-07

+## 0.2.0-alpha.1 - 2019-12-07
 * Migrate to `std::future`

-## [0.1.7] - 2019-11-06

-* Add an additional `filename*` param in the `Content-Disposition` header of `actix_files::NamedFile` to be more compatible. (#1151)
-
-## [0.1.6] - 2019-10-14
+## 0.1.7 - 2019-11-06
+* Add an additional `filename*` param in the `Content-Disposition` header of
+  `actix_files::NamedFile` to be more compatible. (#1151)

+## 0.1.6 - 2019-10-14
 * Add option to redirect to a slash-ended path `Files` #1132

-## [0.1.5] - 2019-10-08

+## 0.1.5 - 2019-10-08
 * Bump up `mime_guess` crate version to 2.0.1
-
 * Bump up `percent-encoding` crate version to 2.1
-
 * Allow user defined request guards for `Files` #1113

-## [0.1.4] - 2019-07-20

+## 0.1.4 - 2019-07-20
 * Allow to disable `Content-Disposition` header #686

-## [0.1.3] - 2019-06-28

+## 0.1.3 - 2019-06-28
 * Do not set `Content-Length` header, let actix-http set it #930

-## [0.1.2] - 2019-06-13

+## 0.1.2 - 2019-06-13
 * Content-Length is 0 for NamedFile HEAD request #914
-
 * Fix ring dependency from actix-web default features for #741

-## [0.1.1] - 2019-06-01

+## 0.1.1 - 2019-06-01
 * Static files are incorrectly served as both chunked and with length #812

-## [0.1.0] - 2019-05-25

-* NamedFile last-modified check always fails due to nano-seconds
-  in file modified date #820
+## 0.1.0 - 2019-05-25
+* NamedFile last-modified check always fails due to nano-seconds in file modified date #820

-## [0.1.0-beta.4] - 2019-05-12

+## 0.1.0-beta.4 - 2019-05-12
 * Update actix-web to beta.4

-## [0.1.0-beta.1] - 2019-04-20

+## 0.1.0-beta.1 - 2019-04-20
 * Update actix-web to beta.1

-## [0.1.0-alpha.6] - 2019-04-14

+## 0.1.0-alpha.6 - 2019-04-14
 * Update actix-web to alpha6

-## [0.1.0-alpha.4] - 2019-04-08

+## 0.1.0-alpha.4 - 2019-04-08
 * Update actix-web to alpha4

-## [0.1.0-alpha.2] - 2019-04-02

+## 0.1.0-alpha.2 - 2019-04-02
 * Add default handler support

-## [0.1.0-alpha.1] - 2019-03-28

+## 0.1.0-alpha.1 - 2019-03-28
 * Initial impl
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -1,8 +1,8 @@
 [package]
 name = "actix-files"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static files support for actix web."
+description = "Static file serving for Actix Web"
 readme = "README.md"
 keywords = ["actix", "http", "async", "futures"]
 homepage = "https://actix.rs"
@ -18,7 +18,6 @@ path = "src/lib.rs"

 [dependencies]
 actix-web = { version = "3.0.0", default-features = false }
-actix-http = "2.0.0"
 actix-service = "1.0.6"
 bitflags = "1"
 bytes = "0.5.3"
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -1,9 +1,19 @@
-# Static files support for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-files)](https://crates.io/crates/actix-files) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# actix-files

-## Documentation & community resources
+> Static file serving for Actix Web

-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-files/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-files](https://crates.io/crates/actix-files)
-* Minimum supported Rust version: 1.40 or later
+[![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-files)
+[![Documentation](https://docs.rs/actix-files/badge.svg)](https://docs.rs/actix-files)
+[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
+![License](https://img.shields.io/crates/l/actix-files.svg)
+<br />
+[![dependency status](https://deps.rs/crate/actix-files/0.4.0/status.svg)](https://deps.rs/crate/actix-files/0.4.0)
+[![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
+[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+## Documentation & Resources
+
+- [API Documentation](https://docs.rs/actix-files/)
+- [Example Project](https://github.com/actix/examples/tree/master/static_index)
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Minimum supported Rust version: 1.42 or later
--- a/actix-files/src/chunked.rs
+++ b/actix-files/src/chunked.rs
@ -0,0 +1,94 @@
+use std::{
+    cmp, fmt,
+    fs::File,
+    future::Future,
+    io::{self, Read, Seek},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    error::{BlockingError, Error},
+    web,
+};
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+use futures_util::future::{FutureExt, LocalBoxFuture};
+
+use crate::handle_error;
+
+type ChunkedBoxFuture =
+    LocalBoxFuture<'static, Result<(File, Bytes), BlockingError<io::Error>>>;
+
+#[doc(hidden)]
+/// A helper created from a `std::fs::File` which reads the file
+/// chunk-by-chunk on a `ThreadPool`.
+pub struct ChunkedReadFile {
+    pub(crate) size: u64,
+    pub(crate) offset: u64,
+    pub(crate) file: Option<File>,
+    pub(crate) fut: Option<ChunkedBoxFuture>,
+    pub(crate) counter: u64,
+}
+
+impl fmt::Debug for ChunkedReadFile {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("ChunkedReadFile")
+    }
+}
+
+impl Stream for ChunkedReadFile {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if let Some(ref mut fut) = self.fut {
+            return match ready!(Pin::new(fut).poll(cx)) {
+                Ok((file, bytes)) => {
+                    self.fut.take();
+                    self.file = Some(file);
+
+                    self.offset += bytes.len() as u64;
+                    self.counter += bytes.len() as u64;
+
+                    Poll::Ready(Some(Ok(bytes)))
+                }
+                Err(e) => Poll::Ready(Some(Err(handle_error(e)))),
+            };
+        }
+
+        let size = self.size;
+        let offset = self.offset;
+        let counter = self.counter;
+
+        if size == counter {
+            Poll::Ready(None)
+        } else {
+            let mut file = self.file.take().expect("Use after completion");
+
+            self.fut = Some(
+                web::block(move || {
+                    let max_bytes =
+                        cmp::min(size.saturating_sub(counter), 65_536) as usize;
+
+                    let mut buf = Vec::with_capacity(max_bytes);
+                    file.seek(io::SeekFrom::Start(offset))?;
+
+                    let n_bytes =
+                        file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
+
+                    if n_bytes == 0 {
+                        return Err(io::ErrorKind::UnexpectedEof.into());
+                    }
+
+                    Ok((file, Bytes::from(buf)))
+                })
+                .boxed_local(),
+            );
+
+            self.poll_next(cx)
+        }
+    }
+}
--- a/actix-files/src/directory.rs
+++ b/actix-files/src/directory.rs
@ -0,0 +1,114 @@
+use std::{fmt::Write, fs::DirEntry, io, path::Path, path::PathBuf};
+
+use actix_web::{dev::ServiceResponse, HttpRequest, HttpResponse};
+use percent_encoding::{utf8_percent_encode, CONTROLS};
+use v_htmlescape::escape as escape_html_entity;
+
+/// A directory; responds with the generated directory listing.
+#[derive(Debug)]
+pub struct Directory {
+    /// Base directory.
+    pub base: PathBuf,
+
+    /// Path of subdirectory to generate listing for.
+    pub path: PathBuf,
+}
+
+impl Directory {
+    /// Create a new directory
+    pub fn new(base: PathBuf, path: PathBuf) -> Directory {
+        Directory { base, path }
+    }
+
+    /// Is this entry visible from this directory?
+    pub fn is_visible(&self, entry: &io::Result<DirEntry>) -> bool {
+        if let Ok(ref entry) = *entry {
+            if let Some(name) = entry.file_name().to_str() {
+                if name.starts_with('.') {
+                    return false;
+                }
+            }
+            if let Ok(ref md) = entry.metadata() {
+                let ft = md.file_type();
+                return ft.is_dir() || ft.is_file() || ft.is_symlink();
+            }
+        }
+        false
+    }
+}
+
+pub(crate) type DirectoryRenderer =
+    dyn Fn(&Directory, &HttpRequest) -> Result<ServiceResponse, io::Error>;
+
+// show file url as relative to static path
+macro_rules! encode_file_url {
+    ($path:ident) => {
+        utf8_percent_encode(&$path, CONTROLS)
+    };
+}
+
+// " -- &quot;  & -- &amp;  ' -- &#x27;  < -- &lt;  > -- &gt;  / -- &#x2f;
+macro_rules! encode_file_name {
+    ($entry:ident) => {
+        escape_html_entity(&$entry.file_name().to_string_lossy())
+    };
+}
+
+pub(crate) fn directory_listing(
+    dir: &Directory,
+    req: &HttpRequest,
+) -> Result<ServiceResponse, io::Error> {
+    let index_of = format!("Index of {}", req.path());
+    let mut body = String::new();
+    let base = Path::new(req.path());
+
+    for entry in dir.path.read_dir()? {
+        if dir.is_visible(&entry) {
+            let entry = entry.unwrap();
+            let p = match entry.path().strip_prefix(&dir.path) {
+                Ok(p) if cfg!(windows) => {
+                    base.join(p).to_string_lossy().replace("\\", "/")
+                }
+                Ok(p) => base.join(p).to_string_lossy().into_owned(),
+                Err(_) => continue,
+            };
+
+            // if file is a directory, add '/' to the end of the name
+            if let Ok(metadata) = entry.metadata() {
+                if metadata.is_dir() {
+                    let _ = write!(
+                        body,
+                        "<li><a href=\"{}\">{}/</a></li>",
+                        encode_file_url!(p),
+                        encode_file_name!(entry),
+                    );
+                } else {
+                    let _ = write!(
+                        body,
+                        "<li><a href=\"{}\">{}</a></li>",
+                        encode_file_url!(p),
+                        encode_file_name!(entry),
+                    );
+                }
+            } else {
+                continue;
+            }
+        }
+    }
+
+    let html = format!(
+        "<html>\
+         <head><title>{}</title></head>\
+         <body><h1>{}</h1>\
+         <ul>\
+         {}\
+         </ul></body>\n</html>",
+        index_of, index_of, body
+    );
+    Ok(ServiceResponse::new(
+        req.clone(),
+        HttpResponse::Ok()
+            .content_type("text/html; charset=utf-8")
+            .body(html),
+    ))
+}
--- a/actix-files/src/encoding.rs
+++ b/actix-files/src/encoding.rs
@ -0,0 +1,52 @@
+use mime::Mime;
+
+/// Transforms MIME `text/*` types into their UTF-8 equivalent, if supported.
+///
+/// MIME types that are converted
+/// - application/javascript
+/// - text/html
+/// - text/css
+/// - text/plain
+/// - text/csv
+/// - text/tab-separated-values
+pub(crate) fn equiv_utf8_text(ct: Mime) -> Mime {
+    // use (roughly) order of file-type popularity for a web server
+
+    if ct == mime::APPLICATION_JAVASCRIPT {
+        return mime::APPLICATION_JAVASCRIPT_UTF_8;
+    }
+
+    if ct == mime::TEXT_HTML {
+        return mime::TEXT_HTML_UTF_8;
+    }
+
+    if ct == mime::TEXT_CSS {
+        return mime::TEXT_CSS_UTF_8;
+    }
+
+    if ct == mime::TEXT_PLAIN {
+        return mime::TEXT_PLAIN_UTF_8;
+    }
+
+    if ct == mime::TEXT_CSV {
+        return mime::TEXT_CSV_UTF_8;
+    }
+
+    if ct == mime::TEXT_TAB_SEPARATED_VALUES {
+        return mime::TEXT_TAB_SEPARATED_VALUES_UTF_8;
+    }
+
+    ct
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_equiv_utf8_text() {
+        assert_eq!(equiv_utf8_text(mime::TEXT_PLAIN), mime::TEXT_PLAIN_UTF_8);
+        assert_eq!(equiv_utf8_text(mime::TEXT_XML), mime::TEXT_XML);
+        assert_eq!(equiv_utf8_text(mime::IMAGE_PNG), mime::IMAGE_PNG);
+    }
+}
--- a/actix-files/src/files.rs
+++ b/actix-files/src/files.rs
@ -0,0 +1,259 @@
+use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
+
+use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
+use actix_web::{
+    dev::{
+        AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
+    },
+    error::Error,
+    guard::Guard,
+    http::header::DispositionType,
+    HttpRequest,
+};
+use futures_util::future::{ok, FutureExt, LocalBoxFuture};
+
+use crate::{
+    directory_listing, named, Directory, DirectoryRenderer, FilesService,
+    HttpNewService, MimeOverride,
+};
+
+/// Static files handling service.
+///
+/// `Files` service must be registered with `App::service()` method.
+///
+/// ```rust
+/// use actix_web::App;
+/// use actix_files::Files;
+///
+/// let app = App::new()
+///     .service(Files::new("/static", "."));
+/// ```
+pub struct Files {
+    path: String,
+    directory: PathBuf,
+    index: Option<String>,
+    show_index: bool,
+    redirect_to_slash: bool,
+    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
+    renderer: Rc<DirectoryRenderer>,
+    mime_override: Option<Rc<MimeOverride>>,
+    file_flags: named::Flags,
+    guards: Option<Rc<dyn Guard>>,
+}
+
+impl fmt::Debug for Files {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Files")
+    }
+}
+
+impl Clone for Files {
+    fn clone(&self) -> Self {
+        Self {
+            directory: self.directory.clone(),
+            index: self.index.clone(),
+            show_index: self.show_index,
+            redirect_to_slash: self.redirect_to_slash,
+            default: self.default.clone(),
+            renderer: self.renderer.clone(),
+            file_flags: self.file_flags,
+            path: self.path.clone(),
+            mime_override: self.mime_override.clone(),
+            guards: self.guards.clone(),
+        }
+    }
+}
+
+impl Files {
+    /// Create new `Files` instance for specified base directory.
+    ///
+    /// `File` uses `ThreadPool` for blocking filesystem operations.
+    /// By default pool with 5x threads of available cpus is used.
+    /// Pool size can be changed by setting ACTIX_THREADPOOL environment variable.
+    pub fn new<T: Into<PathBuf>>(path: &str, dir: T) -> Files {
+        let orig_dir = dir.into();
+        let dir = match orig_dir.canonicalize() {
+            Ok(canon_dir) => canon_dir,
+            Err(_) => {
+                log::error!("Specified path is not a directory: {:?}", orig_dir);
+                PathBuf::new()
+            }
+        };
+
+        Files {
+            path: path.to_string(),
+            directory: dir,
+            index: None,
+            show_index: false,
+            redirect_to_slash: false,
+            default: Rc::new(RefCell::new(None)),
+            renderer: Rc::new(directory_listing),
+            mime_override: None,
+            file_flags: named::Flags::default(),
+            guards: None,
+        }
+    }
+
+    /// Show files listing for directories.
+    ///
+    /// By default show files listing is disabled.
+    pub fn show_files_listing(mut self) -> Self {
+        self.show_index = true;
+        self
+    }
+
+    /// Redirects to a slash-ended path when browsing a directory.
+    ///
+    /// By default never redirect.
+    pub fn redirect_to_slash_directory(mut self) -> Self {
+        self.redirect_to_slash = true;
+        self
+    }
+
+    /// Set custom directory renderer
+    pub fn files_listing_renderer<F>(mut self, f: F) -> Self
+    where
+        for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
+            + 'static,
+    {
+        self.renderer = Rc::new(f);
+        self
+    }
+
+    /// Specifies mime override callback
+    pub fn mime_override<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&mime::Name<'_>) -> DispositionType + 'static,
+    {
+        self.mime_override = Some(Rc::new(f));
+        self
+    }
+
+    /// Set index file
+    ///
+    /// Shows specific index file for directory "/" instead of
+    /// showing files listing.
+    pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
+        self.index = Some(index.into());
+        self
+    }
+
+    /// Specifies whether to use ETag or not.
+    ///
+    /// Default is true.
+    #[inline]
+    pub fn use_etag(mut self, value: bool) -> Self {
+        self.file_flags.set(named::Flags::ETAG, value);
+        self
+    }
+
+    /// Specifies whether to use Last-Modified or not.
+    ///
+    /// Default is true.
+    #[inline]
+    pub fn use_last_modified(mut self, value: bool) -> Self {
+        self.file_flags.set(named::Flags::LAST_MD, value);
+        self
+    }
+
+    /// Specifies whether text responses should signal a UTF-8 encoding.
+    ///
+    /// Default is false (but will default to true in a future version).
+    #[inline]
+    pub fn prefer_utf8(mut self, value: bool) -> Self {
+        self.file_flags.set(named::Flags::PREFER_UTF8, value);
+        self
+    }
+
+    /// Specifies custom guards to use for directory listings and files.
+    ///
+    /// Default behaviour allows GET and HEAD.
+    #[inline]
+    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
+        self.guards = Some(Rc::new(guards));
+        self
+    }
+
+    /// Disable `Content-Disposition` header.
+    ///
+    /// By default Content-Disposition` header is enabled.
+    #[inline]
+    pub fn disable_content_disposition(mut self) -> Self {
+        self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
+        self
+    }
+
+    /// Sets default handler which is used when no matched file could be found.
+    pub fn default_handler<F, U>(mut self, f: F) -> Self
+    where
+        F: IntoServiceFactory<U>,
+        U: ServiceFactory<
+                Config = (),
+                Request = ServiceRequest,
+                Response = ServiceResponse,
+                Error = Error,
+            > + 'static,
+    {
+        // create and configure default resource
+        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
+            f.into_factory().map_init_err(|_| ()),
+        )))));
+
+        self
+    }
+}
+
+impl HttpServiceFactory for Files {
+    fn register(self, config: &mut AppService) {
+        if self.default.borrow().is_none() {
+            *self.default.borrow_mut() = Some(config.default_service());
+        }
+
+        let rdef = if config.is_root() {
+            ResourceDef::root_prefix(&self.path)
+        } else {
+            ResourceDef::prefix(&self.path)
+        };
+
+        config.register_service(rdef, None, self, None)
+    }
+}
+
+impl ServiceFactory for Files {
+    type Request = ServiceRequest;
+    type Response = ServiceResponse;
+    type Error = Error;
+    type Config = ();
+    type Service = FilesService;
+    type InitError = ();
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        let mut srv = FilesService {
+            directory: self.directory.clone(),
+            index: self.index.clone(),
+            show_index: self.show_index,
+            redirect_to_slash: self.redirect_to_slash,
+            default: None,
+            renderer: self.renderer.clone(),
+            mime_override: self.mime_override.clone(),
+            file_flags: self.file_flags,
+            guards: self.guards.clone(),
+        };
+
+        if let Some(ref default) = *self.default.borrow() {
+            default
+                .new_service(())
+                .map(move |result| match result {
+                    Ok(default) => {
+                        srv.default = Some(default);
+                        Ok(srv)
+                    }
+                    Err(_) => Err(()),
+                })
+                .boxed_local()
+        } else {
+            ok(srv).boxed_local()
+        }
+    }
+}
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@ -1,44 +1,49 @@
-//! Static files support
+//! Static file serving for Actix Web.
+//!
+//! Provides a non-blocking service for serving static files from disk.
+//!
+//! # Example
+//! ```rust
+//! use actix_web::App;
+//! use actix_files::Files;
+//!
+//! let app = App::new()
+//!     .service(Files::new("/static", ".").prefer_utf8(true));
+//! ```

 #![deny(rust_2018_idioms)]
-#![allow(clippy::borrow_interior_mutable_const)]
+#![warn(missing_docs, missing_debug_implementations)]

-use std::cell::RefCell;
-use std::fmt::Write;
-use std::fs::{DirEntry, File};
-use std::future::Future;
-use std::io::{Read, Seek};
-use std::path::{Path, PathBuf};
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{cmp, io};
+use std::io;

-use actix_service::boxed::{self, BoxService, BoxServiceFactory};
-use actix_service::{IntoServiceFactory, Service, ServiceFactory};
-use actix_web::dev::{
-    AppService, HttpServiceFactory, Payload, ResourceDef, ServiceRequest,
-    ServiceResponse,
+use actix_service::boxed::{BoxService, BoxServiceFactory};
+use actix_web::{
+    dev::{ServiceRequest, ServiceResponse},
+    error::{BlockingError, Error, ErrorInternalServerError},
+    http::header::DispositionType,
 };
-use actix_web::error::{BlockingError, Error, ErrorInternalServerError};
-use actix_web::guard::Guard;
-use actix_web::http::header::{self, DispositionType};
-use actix_web::http::Method;
-use actix_web::{web, FromRequest, HttpRequest, HttpResponse};
-use bytes::Bytes;
-use futures_core::Stream;
-use futures_util::future::{ok, ready, Either, FutureExt, LocalBoxFuture, Ready};
 use mime_guess::from_ext;
-use percent_encoding::{utf8_percent_encode, CONTROLS};
-use v_htmlescape::escape as escape_html_entity;

+mod chunked;
+mod directory;
+mod encoding;
 mod error;
+mod files;
 mod named;
+mod path_buf;
 mod range;
+mod service;

-use self::error::{FilesError, UriSegmentError};
+pub use crate::chunked::ChunkedReadFile;
+pub use crate::directory::Directory;
+pub use crate::files::Files;
 pub use crate::named::NamedFile;
 pub use crate::range::HttpRange;
+pub use crate::service::FilesService;
+
+use self::directory::{directory_listing, DirectoryRenderer};
+use self::error::FilesError;
+use self::path_buf::PathBufWrap;

 type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
 type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
@ -51,615 +56,43 @@ pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
    from_ext(ext).first_or_octet_stream()
 }

-fn handle_error(err: BlockingError<io::Error>) -> Error {
+pub(crate) fn handle_error(err: BlockingError<io::Error>) -> Error {
    match err {
        BlockingError::Error(err) => err.into(),
        BlockingError::Canceled => ErrorInternalServerError("Unexpected error"),
    }
 }
-#[doc(hidden)]
-/// A helper created from a `std::fs::File` which reads the file
-/// chunk-by-chunk on a `ThreadPool`.
-pub struct ChunkedReadFile {
-    size: u64,
-    offset: u64,
-    file: Option<File>,
-    #[allow(clippy::type_complexity)]
-    fut:
-        Option<LocalBoxFuture<'static, Result<(File, Bytes), BlockingError<io::Error>>>>,
-    counter: u64,
-}
-
-impl Stream for ChunkedReadFile {
-    type Item = Result<Bytes, Error>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        if let Some(ref mut fut) = self.fut {
-            return match Pin::new(fut).poll(cx) {
-                Poll::Ready(Ok((file, bytes))) => {
-                    self.fut.take();
-                    self.file = Some(file);
-                    self.offset += bytes.len() as u64;
-                    self.counter += bytes.len() as u64;
-                    Poll::Ready(Some(Ok(bytes)))
-                }
-                Poll::Ready(Err(e)) => Poll::Ready(Some(Err(handle_error(e)))),
-                Poll::Pending => Poll::Pending,
-            };
-        }
-
-        let size = self.size;
-        let offset = self.offset;
-        let counter = self.counter;
-
-        if size == counter {
-            Poll::Ready(None)
-        } else {
-            let mut file = self.file.take().expect("Use after completion");
-            self.fut = Some(
-                web::block(move || {
-                    let max_bytes: usize;
-                    max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
-                    let mut buf = Vec::with_capacity(max_bytes);
-                    file.seek(io::SeekFrom::Start(offset))?;
-                    let nbytes =
-                        file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
-                    if nbytes == 0 {
-                        return Err(io::ErrorKind::UnexpectedEof.into());
-                    }
-                    Ok((file, Bytes::from(buf)))
-                })
-                .boxed_local(),
-            );
-            self.poll_next(cx)
-        }
-    }
-}
-
-type DirectoryRenderer =
-    dyn Fn(&Directory, &HttpRequest) -> Result<ServiceResponse, io::Error>;
-
-/// A directory; responds with the generated directory listing.
-#[derive(Debug)]
-pub struct Directory {
-    /// Base directory
-    pub base: PathBuf,
-    /// Path of subdirectory to generate listing for
-    pub path: PathBuf,
-}
-
-impl Directory {
-    /// Create a new directory
-    pub fn new(base: PathBuf, path: PathBuf) -> Directory {
-        Directory { base, path }
-    }
-
-    /// Is this entry visible from this directory?
-    pub fn is_visible(&self, entry: &io::Result<DirEntry>) -> bool {
-        if let Ok(ref entry) = *entry {
-            if let Some(name) = entry.file_name().to_str() {
-                if name.starts_with('.') {
-                    return false;
-                }
-            }
-            if let Ok(ref md) = entry.metadata() {
-                let ft = md.file_type();
-                return ft.is_dir() || ft.is_file() || ft.is_symlink();
-            }
-        }
-        false
-    }
-}
-
-// show file url as relative to static path
-macro_rules! encode_file_url {
-    ($path:ident) => {
-        utf8_percent_encode(&$path, CONTROLS)
-    };
-}
-
-// " -- &quot;  & -- &amp;  ' -- &#x27;  < -- &lt;  > -- &gt;  / -- &#x2f;
-macro_rules! encode_file_name {
-    ($entry:ident) => {
-        escape_html_entity(&$entry.file_name().to_string_lossy())
-    };
-}
-
-fn directory_listing(
-    dir: &Directory,
-    req: &HttpRequest,
-) -> Result<ServiceResponse, io::Error> {
-    let index_of = format!("Index of {}", req.path());
-    let mut body = String::new();
-    let base = Path::new(req.path());
-
-    for entry in dir.path.read_dir()? {
-        if dir.is_visible(&entry) {
-            let entry = entry.unwrap();
-            let p = match entry.path().strip_prefix(&dir.path) {
-                Ok(p) if cfg!(windows) => {
-                    base.join(p).to_string_lossy().replace("\\", "/")
-                }
-                Ok(p) => base.join(p).to_string_lossy().into_owned(),
-                Err(_) => continue,
-            };
-
-            // if file is a directory, add '/' to the end of the name
-            if let Ok(metadata) = entry.metadata() {
-                if metadata.is_dir() {
-                    let _ = write!(
-                        body,
-                        "<li><a href=\"{}\">{}/</a></li>",
-                        encode_file_url!(p),
-                        encode_file_name!(entry),
-                    );
-                } else {
-                    let _ = write!(
-                        body,
-                        "<li><a href=\"{}\">{}</a></li>",
-                        encode_file_url!(p),
-                        encode_file_name!(entry),
-                    );
-                }
-            } else {
-                continue;
-            }
-        }
-    }
-
-    let html = format!(
-        "<html>\
-         <head><title>{}</title></head>\
-         <body><h1>{}</h1>\
-         <ul>\
-         {}\
-         </ul></body>\n</html>",
-        index_of, index_of, body
-    );
-    Ok(ServiceResponse::new(
-        req.clone(),
-        HttpResponse::Ok()
-            .content_type("text/html; charset=utf-8")
-            .body(html),
-    ))
-}

 type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;

-/// Static files handling
-///
-/// `Files` service must be registered with `App::service()` method.
-///
-/// ```rust
-/// use actix_web::App;
-/// use actix_files::Files;
-///
-/// let app = App::new()
-///     .service(Files::new("/static", "."));
-/// ```
-pub struct Files {
-    path: String,
-    directory: PathBuf,
-    index: Option<String>,
-    show_index: bool,
-    redirect_to_slash: bool,
-    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
-    renderer: Rc<DirectoryRenderer>,
-    mime_override: Option<Rc<MimeOverride>>,
-    file_flags: named::Flags,
-    // FIXME: Should re-visit later.
-    #[allow(clippy::redundant_allocation)]
-    guards: Option<Rc<Box<dyn Guard>>>,
-}
-
-impl Clone for Files {
-    fn clone(&self) -> Self {
-        Self {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            default: self.default.clone(),
-            renderer: self.renderer.clone(),
-            file_flags: self.file_flags,
-            path: self.path.clone(),
-            mime_override: self.mime_override.clone(),
-            guards: self.guards.clone(),
-        }
-    }
-}
-
-impl Files {
-    /// Create new `Files` instance for specified base directory.
-    ///
-    /// `File` uses `ThreadPool` for blocking filesystem operations.
-    /// By default pool with 5x threads of available cpus is used.
-    /// Pool size can be changed by setting ACTIX_THREADPOOL environment variable.
-    pub fn new<T: Into<PathBuf>>(path: &str, dir: T) -> Files {
-        let orig_dir = dir.into();
-        let dir = match orig_dir.canonicalize() {
-            Ok(canon_dir) => canon_dir,
-            Err(_) => {
-                log::error!("Specified path is not a directory: {:?}", orig_dir);
-                PathBuf::new()
-            }
-        };
-
-        Files {
-            path: path.to_string(),
-            directory: dir,
-            index: None,
-            show_index: false,
-            redirect_to_slash: false,
-            default: Rc::new(RefCell::new(None)),
-            renderer: Rc::new(directory_listing),
-            mime_override: None,
-            file_flags: named::Flags::default(),
-            guards: None,
-        }
-    }
-
-    /// Show files listing for directories.
-    ///
-    /// By default show files listing is disabled.
-    pub fn show_files_listing(mut self) -> Self {
-        self.show_index = true;
-        self
-    }
-
-    /// Redirects to a slash-ended path when browsing a directory.
-    ///
-    /// By default never redirect.
-    pub fn redirect_to_slash_directory(mut self) -> Self {
-        self.redirect_to_slash = true;
-        self
-    }
-
-    /// Set custom directory renderer
-    pub fn files_listing_renderer<F>(mut self, f: F) -> Self
-    where
-        for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
-            + 'static,
-    {
-        self.renderer = Rc::new(f);
-        self
-    }
-
-    /// Specifies mime override callback
-    pub fn mime_override<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&mime::Name<'_>) -> DispositionType + 'static,
-    {
-        self.mime_override = Some(Rc::new(f));
-        self
-    }
-
-    /// Set index file
-    ///
-    /// Shows specific index file for directory "/" instead of
-    /// showing files listing.
-    pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
-        self.index = Some(index.into());
-        self
-    }
-
-    #[inline]
-    /// Specifies whether to use ETag or not.
-    ///
-    /// Default is true.
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::ETAG, value);
-        self
-    }
-
-    #[inline]
-    /// Specifies whether to use Last-Modified or not.
-    ///
-    /// Default is true.
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.file_flags.set(named::Flags::LAST_MD, value);
-        self
-    }
-
-    /// Specifies custom guards to use for directory listings and files.
-    ///
-    /// Default behaviour allows GET and HEAD.
-    #[inline]
-    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
-        self.guards = Some(Rc::new(Box::new(guards)));
-        self
-    }
-
-    /// Disable `Content-Disposition` header.
-    ///
-    /// By default Content-Disposition` header is enabled.
-    #[inline]
-    pub fn disable_content_disposition(mut self) -> Self {
-        self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Sets default handler which is used when no matched file could be found.
-    pub fn default_handler<F, U>(mut self, f: F) -> Self
-    where
-        F: IntoServiceFactory<U>,
-        U: ServiceFactory<
-                Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
-                Error = Error,
-            > + 'static,
-    {
-        // create and configure default resource
-        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
-            f.into_factory().map_init_err(|_| ()),
-        )))));
-
-        self
-    }
-}
-
-impl HttpServiceFactory for Files {
-    fn register(self, config: &mut AppService) {
-        if self.default.borrow().is_none() {
-            *self.default.borrow_mut() = Some(config.default_service());
-        }
-        let rdef = if config.is_root() {
-            ResourceDef::root_prefix(&self.path)
-        } else {
-            ResourceDef::prefix(&self.path)
-        };
-        config.register_service(rdef, None, self, None)
-    }
-}
-
-impl ServiceFactory for Files {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
-    type Error = Error;
-    type Config = ();
-    type Service = FilesService;
-    type InitError = ();
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let mut srv = FilesService {
-            directory: self.directory.clone(),
-            index: self.index.clone(),
-            show_index: self.show_index,
-            redirect_to_slash: self.redirect_to_slash,
-            default: None,
-            renderer: self.renderer.clone(),
-            mime_override: self.mime_override.clone(),
-            file_flags: self.file_flags,
-            guards: self.guards.clone(),
-        };
-
-        if let Some(ref default) = *self.default.borrow() {
-            default
-                .new_service(())
-                .map(move |result| match result {
-                    Ok(default) => {
-                        srv.default = Some(default);
-                        Ok(srv)
-                    }
-                    Err(_) => Err(()),
-                })
-                .boxed_local()
-        } else {
-            ok(srv).boxed_local()
-        }
-    }
-}
-
-pub struct FilesService {
-    directory: PathBuf,
-    index: Option<String>,
-    show_index: bool,
-    redirect_to_slash: bool,
-    default: Option<HttpService>,
-    renderer: Rc<DirectoryRenderer>,
-    mime_override: Option<Rc<MimeOverride>>,
-    file_flags: named::Flags,
-    // FIXME: Should re-visit later.
-    #[allow(clippy::redundant_allocation)]
-    guards: Option<Rc<Box<dyn Guard>>>,
-}
-
-impl FilesService {
-    #[allow(clippy::type_complexity)]
-    fn handle_err(
-        &mut self,
-        e: io::Error,
-        req: ServiceRequest,
-    ) -> Either<
-        Ready<Result<ServiceResponse, Error>>,
-        LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
-    > {
-        log::debug!("Files: Failed to handle {}: {}", req.path(), e);
-        if let Some(ref mut default) = self.default {
-            Either::Right(default.call(req))
-        } else {
-            Either::Left(ok(req.error_response(e)))
-        }
-    }
-}
-
-impl Service for FilesService {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
-    type Error = Error;
-    #[allow(clippy::type_complexity)]
-    type Future = Either<
-        Ready<Result<Self::Response, Self::Error>>,
-        LocalBoxFuture<'static, Result<Self::Response, Self::Error>>,
-    >;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
-        let is_method_valid = if let Some(guard) = &self.guards {
-            // execute user defined guards
-            (**guard).check(req.head())
-        } else {
-            // default behavior
-            matches!(*req.method(), Method::HEAD | Method::GET)
-        };
-
-        if !is_method_valid {
-            return Either::Left(ok(req.into_response(
-                actix_web::HttpResponse::MethodNotAllowed()
-                    .header(header::CONTENT_TYPE, "text/plain")
-                    .body("Request did not meet this resource's requirements."),
-            )));
-        }
-
-        let real_path = match PathBufWrp::get_pathbuf(req.match_info().path()) {
-            Ok(item) => item,
-            Err(e) => return Either::Left(ok(req.error_response(e))),
-        };
-
-        // full file path
-        let path = match self.directory.join(&real_path.0).canonicalize() {
-            Ok(path) => path,
-            Err(e) => return self.handle_err(e, req),
-        };
-
-        if path.is_dir() {
-            if let Some(ref redir_index) = self.index {
-                if self.redirect_to_slash && !req.path().ends_with('/') {
-                    let redirect_to = format!("{}/", req.path());
-                    return Either::Left(ok(req.into_response(
-                        HttpResponse::Found()
-                            .header(header::LOCATION, redirect_to)
-                            .body("")
-                            .into_body(),
-                    )));
-                }
-
-                let path = path.join(redir_index);
-
-                match NamedFile::open(path) {
-                    Ok(mut named_file) => {
-                        if let Some(ref mime_override) = self.mime_override {
-                            let new_disposition =
-                                mime_override(&named_file.content_type.type_());
-                            named_file.content_disposition.disposition = new_disposition;
-                        }
-
-                        named_file.flags = self.file_flags;
-                        let (req, _) = req.into_parts();
-                        Either::Left(ok(match named_file.into_response(&req) {
-                            Ok(item) => ServiceResponse::new(req, item),
-                            Err(e) => ServiceResponse::from_err(e, req),
-                        }))
-                    }
-                    Err(e) => self.handle_err(e, req),
-                }
-            } else if self.show_index {
-                let dir = Directory::new(self.directory.clone(), path);
-                let (req, _) = req.into_parts();
-                let x = (self.renderer)(&dir, &req);
-                match x {
-                    Ok(resp) => Either::Left(ok(resp)),
-                    Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
-                }
-            } else {
-                Either::Left(ok(ServiceResponse::from_err(
-                    FilesError::IsDirectory,
-                    req.into_parts().0,
-                )))
-            }
-        } else {
-            match NamedFile::open(path) {
-                Ok(mut named_file) => {
-                    if let Some(ref mime_override) = self.mime_override {
-                        let new_disposition =
-                            mime_override(&named_file.content_type.type_());
-                        named_file.content_disposition.disposition = new_disposition;
-                    }
-
-                    named_file.flags = self.file_flags;
-                    let (req, _) = req.into_parts();
-                    match named_file.into_response(&req) {
-                        Ok(item) => {
-                            Either::Left(ok(ServiceResponse::new(req.clone(), item)))
-                        }
-                        Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
-                    }
-                }
-                Err(e) => self.handle_err(e, req),
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-struct PathBufWrp(PathBuf);
-
-impl PathBufWrp {
-    fn get_pathbuf(path: &str) -> Result<Self, UriSegmentError> {
-        let mut buf = PathBuf::new();
-        for segment in path.split('/') {
-            if segment == ".." {
-                buf.pop();
-            } else if segment.starts_with('.') {
-                return Err(UriSegmentError::BadStart('.'));
-            } else if segment.starts_with('*') {
-                return Err(UriSegmentError::BadStart('*'));
-            } else if segment.ends_with(':') {
-                return Err(UriSegmentError::BadEnd(':'));
-            } else if segment.ends_with('>') {
-                return Err(UriSegmentError::BadEnd('>'));
-            } else if segment.ends_with('<') {
-                return Err(UriSegmentError::BadEnd('<'));
-            } else if segment.is_empty() {
-                continue;
-            } else if cfg!(windows) && segment.contains('\\') {
-                return Err(UriSegmentError::BadChar('\\'));
-            } else {
-                buf.push(segment)
-            }
-        }
-
-        Ok(PathBufWrp(buf))
-    }
-}
-
-impl FromRequest for PathBufWrp {
-    type Error = UriSegmentError;
-    type Future = Ready<Result<Self, Self::Error>>;
-    type Config = ();
-
-    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        ready(PathBufWrp::get_pathbuf(req.match_info().path()))
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use std::fs;
-    use std::iter::FromIterator;
-    use std::ops::Add;
-    use std::time::{Duration, SystemTime};
+    use std::{
+        fs::{self, File},
+        ops::Add,
+        time::{Duration, SystemTime},
+    };
+
+    use actix_service::ServiceFactory;
+    use actix_web::{
+        guard,
+        http::{
+            header::{self, ContentDisposition, DispositionParam, DispositionType},
+            Method, StatusCode,
+        },
+        middleware::Compress,
+        test::{self, TestRequest},
+        web, App, HttpResponse, Responder,
+    };
+    use futures_util::future::ok;

    use super::*;
-    use actix_web::guard;
-    use actix_web::http::header::{
-        self, ContentDisposition, DispositionParam, DispositionType,
-    };
-    use actix_web::http::{Method, StatusCode};
-    use actix_web::middleware::Compress;
-    use actix_web::test::{self, TestRequest};
-    use actix_web::{App, Responder};

    #[actix_rt::test]
    async fn test_file_extension_to_mime() {
+        let m = file_extension_to_mime("");
+        assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
+
        let m = file_extension_to_mime("jpg");
        assert_eq!(m, mime::IMAGE_JPEG);

@ -1013,7 +446,7 @@ mod tests {

        // Check file contents
        let bytes = response.body().await.unwrap();
-        let data = Bytes::from(fs::read("tests/test.binary").unwrap());
+        let data = web::Bytes::from(fs::read("tests/test.binary").unwrap());
        assert_eq!(bytes, data);
    }

@ -1046,7 +479,7 @@ mod tests {
        assert_eq!(response.status(), StatusCode::OK);

        let bytes = test::read_body(response).await;
-        let data = Bytes::from(fs::read("tests/test space.binary").unwrap());
+        let data = web::Bytes::from(fs::read("tests/test space.binary").unwrap());
        assert_eq!(bytes, data);
    }

@ -1224,7 +657,7 @@ mod tests {
        let resp = test::call_service(&mut st, req).await;
        assert_eq!(resp.status(), StatusCode::OK);
        let bytes = test::read_body(resp).await;
-        assert_eq!(bytes, Bytes::from_static(b"default content"));
+        assert_eq!(bytes, web::Bytes::from_static(b"default content"));
    }

    //     #[actix_rt::test]
@ -1340,36 +773,4 @@ mod tests {
    //         let response = srv.execute(request.send()).unwrap();
    //         assert_eq!(response.status(), StatusCode::OK);
    //     }
-
-    #[actix_rt::test]
-    async fn test_path_buf() {
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/test/.tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('.'))
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/test/*tt").map(|t| t.0),
-            Err(UriSegmentError::BadStart('*'))
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/test/tt:").map(|t| t.0),
-            Err(UriSegmentError::BadEnd(':'))
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/test/tt<").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('<'))
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/test/tt>").map(|t| t.0),
-            Err(UriSegmentError::BadEnd('>'))
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/seg1/seg2/").unwrap().0,
-            PathBuf::from_iter(vec!["seg1", "seg2"])
-        );
-        assert_eq!(
-            PathBufWrp::get_pathbuf("/seg1/../seg2/").unwrap().0,
-            PathBuf::from_iter(vec!["seg2"])
-        );
-    }
 }
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@ -7,32 +7,36 @@ use std::time::{SystemTime, UNIX_EPOCH};
 #[cfg(unix)]
 use std::os::unix::fs::MetadataExt;

+use actix_web::{
+    dev::{BodyEncoding, SizedStream},
+    http::{
+        header::{
+            self, Charset, ContentDisposition, DispositionParam, DispositionType,
+            ExtendedValue,
+        },
+        ContentEncoding, StatusCode,
+    },
+    Error, HttpMessage, HttpRequest, HttpResponse, Responder,
+};
 use bitflags::bitflags;
+use futures_util::future::{ready, Ready};
 use mime_guess::from_path;

-use actix_http::body::SizedStream;
-use actix_web::dev::BodyEncoding;
-use actix_web::http::header::{
-    self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
-};
-use actix_web::http::{ContentEncoding, StatusCode};
-use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};
-use futures_util::future::{ready, Ready};
-
-use crate::range::HttpRange;
 use crate::ChunkedReadFile;
+use crate::{encoding::equiv_utf8_text, range::HttpRange};

 bitflags! {
    pub(crate) struct Flags: u8 {
-        const ETAG = 0b0000_0001;
-        const LAST_MD = 0b0000_0010;
+        const ETAG =                0b0000_0001;
+        const LAST_MD =             0b0000_0010;
        const CONTENT_DISPOSITION = 0b0000_0100;
+        const PREFER_UTF8 =         0b0000_1000;
    }
 }

 impl Default for Flags {
    fn default() -> Self {
-        Flags::all()
+        Flags::from_bits_truncate(0b0000_0111)
    }
 }

@ -89,12 +93,15 @@ impl NamedFile {
            };

            let ct = from_path(&path).first_or_octet_stream();
+
            let disposition = match ct.type_() {
                mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
                _ => DispositionType::Attachment,
            };
+
            let mut parameters =
                vec![DispositionParam::Filename(String::from(filename.as_ref()))];
+
            if !filename.is_ascii() {
                parameters.push(DispositionParam::FilenameExt(ExtendedValue {
                    charset: Charset::Ext(String::from("UTF-8")),
@ -102,16 +109,19 @@ impl NamedFile {
                    value: filename.into_owned().into_bytes(),
                }))
            }
+
            let cd = ContentDisposition {
                disposition,
                parameters,
            };
+
            (ct, cd)
        };

        let md = file.metadata()?;
        let modified = md.modified().ok();
        let encoding = None;
+
        Ok(NamedFile {
            path,
            file,
@ -207,24 +217,33 @@ impl NamedFile {
        self
    }

-    #[inline]
-    ///Specifies whether to use ETag or not.
+    /// Specifies whether to use ETag or not.
    ///
-    ///Default is true.
+    /// Default is true.
+    #[inline]
    pub fn use_etag(mut self, value: bool) -> Self {
        self.flags.set(Flags::ETAG, value);
        self
    }

-    #[inline]
-    ///Specifies whether to use Last-Modified or not.
+    /// Specifies whether to use Last-Modified or not.
    ///
-    ///Default is true.
+    /// Default is true.
+    #[inline]
    pub fn use_last_modified(mut self, value: bool) -> Self {
        self.flags.set(Flags::LAST_MD, value);
        self
    }

+    /// Specifies whether text responses should signal a UTF-8 encoding.
+    ///
+    /// Default is false (but will default to true in a future version).
+    #[inline]
+    pub fn prefer_utf8(mut self, value: bool) -> Self {
+        self.flags.set(Flags::PREFER_UTF8, value);
+        self
+    }
+
    pub(crate) fn etag(&self) -> Option<header::EntityTag> {
        // This etag format is similar to Apache's.
        self.modified.as_ref().map(|mtime| {
@ -242,6 +261,7 @@ impl NamedFile {
            let dur = mtime
                .duration_since(UNIX_EPOCH)
                .expect("modification time must be after epoch");
+
            header::EntityTag::strong(format!(
                "{:x}:{:x}:{:x}:{:x}",
                ino,
@ -256,19 +276,29 @@ impl NamedFile {
        self.modified.map(|mtime| mtime.into())
    }

+    /// Creates an `HttpResponse` with file as a streaming body.
    pub fn into_response(self, req: &HttpRequest) -> Result<HttpResponse, Error> {
        if self.status_code != StatusCode::OK {
-            let mut resp = HttpResponse::build(self.status_code);
-            resp.set(header::ContentType(self.content_type.clone()))
-                .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                    res.header(
-                        header::CONTENT_DISPOSITION,
-                        self.content_disposition.to_string(),
-                    );
-                });
-            if let Some(current_encoding) = self.encoding {
-                resp.encoding(current_encoding);
+            let mut res = HttpResponse::build(self.status_code);
+
+            if self.flags.contains(Flags::PREFER_UTF8) {
+                let ct = equiv_utf8_text(self.content_type.clone());
+                res.header(header::CONTENT_TYPE, ct.to_string());
+            } else {
+                res.header(header::CONTENT_TYPE, self.content_type.to_string());
            }
+
+            if self.flags.contains(Flags::CONTENT_DISPOSITION) {
+                res.header(
+                    header::CONTENT_DISPOSITION,
+                    self.content_disposition.to_string(),
+                );
+            }
+
+            if let Some(current_encoding) = self.encoding {
+                res.encoding(current_encoding);
+            }
+
            let reader = ChunkedReadFile {
                size: self.md.len(),
                offset: 0,
@ -276,7 +306,8 @@ impl NamedFile {
                fut: None,
                counter: 0,
            };
-            return Ok(resp.streaming(reader));
+
+            return Ok(res.streaming(reader));
        }

        let etag = if self.flags.contains(Flags::ETAG) {
@ -284,6 +315,7 @@ impl NamedFile {
        } else {
            None
        };
+
        let last_modified = if self.flags.contains(Flags::LAST_MD) {
            self.last_modified()
        } else {
@ -298,6 +330,7 @@ impl NamedFile {
        {
            let t1: SystemTime = m.clone().into();
            let t2: SystemTime = since.clone().into();
+
            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
                (Ok(t1), Ok(t2)) => t1 > t2,
                _ => false,
@ -309,13 +342,14 @@ impl NamedFile {
        // check last modified
        let not_modified = if !none_match(etag.as_ref(), req) {
            true
-        } else if req.headers().contains_key(&header::IF_NONE_MATCH) {
+        } else if req.headers().contains_key(header::IF_NONE_MATCH) {
            false
        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
            (last_modified, req.get_header())
        {
            let t1: SystemTime = m.clone().into();
            let t2: SystemTime = since.clone().into();
+
            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
                (Ok(t1), Ok(t2)) => t1 <= t2,
                _ => false,
@ -325,24 +359,33 @@ impl NamedFile {
        };

        let mut resp = HttpResponse::build(self.status_code);
-        resp.set(header::ContentType(self.content_type.clone()))
-            .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                res.header(
-                    header::CONTENT_DISPOSITION,
-                    self.content_disposition.to_string(),
-                );
-            });
+
+        if self.flags.contains(Flags::PREFER_UTF8) {
+            let ct = equiv_utf8_text(self.content_type.clone());
+            resp.header(header::CONTENT_TYPE, ct.to_string());
+        } else {
+            resp.header(header::CONTENT_TYPE, self.content_type.to_string());
+        }
+
+        if self.flags.contains(Flags::CONTENT_DISPOSITION) {
+            resp.header(
+                header::CONTENT_DISPOSITION,
+                self.content_disposition.to_string(),
+            );
+        }
+
        // default compressing
        if let Some(current_encoding) = self.encoding {
            resp.encoding(current_encoding);
        }

-        resp.if_some(last_modified, |lm, resp| {
-            resp.set(header::LastModified(lm));
-        })
-        .if_some(etag, |etag, resp| {
-            resp.set(header::ETag(etag));
-        });
+        if let Some(lm) = last_modified {
+            resp.header(header::LAST_MODIFIED, lm.to_string());
+        }
+
+        if let Some(etag) = etag {
+            resp.header(header::ETAG, etag.to_string());
+        }

        resp.header(header::ACCEPT_RANGES, "bytes");

@ -350,11 +393,12 @@ impl NamedFile {
        let mut offset = 0;

        // check for range header
-        if let Some(ranges) = req.headers().get(&header::RANGE) {
-            if let Ok(rangesheader) = ranges.to_str() {
-                if let Ok(rangesvec) = HttpRange::parse(rangesheader, length) {
-                    length = rangesvec[0].length;
-                    offset = rangesvec[0].start;
+        if let Some(ranges) = req.headers().get(header::RANGE) {
+            if let Ok(ranges_header) = ranges.to_str() {
+                if let Ok(ranges) = HttpRange::parse(ranges_header, length) {
+                    length = ranges[0].length;
+                    offset = ranges[0].start;
+
                    resp.encoding(ContentEncoding::Identity);
                    resp.header(
                        header::CONTENT_RANGE,
@ -414,6 +458,7 @@ impl DerefMut for NamedFile {
 fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
    match req.get_header::<header::IfMatch>() {
        None | Some(header::IfMatch::Any) => true,
+
        Some(header::IfMatch::Items(ref items)) => {
            if let Some(some_etag) = etag {
                for item in items {
@ -422,6 +467,7 @@ fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
                    }
                }
            }
+
            false
        }
    }
@ -431,6 +477,7 @@ fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
 fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
    match req.get_header::<header::IfNoneMatch>() {
        Some(header::IfNoneMatch::Any) => false,
+
        Some(header::IfNoneMatch::Items(ref items)) => {
            if let Some(some_etag) = etag {
                for item in items {
@ -439,8 +486,10 @@ fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
                    }
                }
            }
+
            true
        }
+
        None => true,
    }
 }
--- a/actix-files/src/path_buf.rs
+++ b/actix-files/src/path_buf.rs
@ -0,0 +1,99 @@
+use std::{
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+
+use actix_web::{dev::Payload, FromRequest, HttpRequest};
+use futures_util::future::{ready, Ready};
+
+use crate::error::UriSegmentError;
+
+#[derive(Debug)]
+pub(crate) struct PathBufWrap(PathBuf);
+
+impl FromStr for PathBufWrap {
+    type Err = UriSegmentError;
+
+    fn from_str(path: &str) -> Result<Self, Self::Err> {
+        let mut buf = PathBuf::new();
+
+        for segment in path.split('/') {
+            if segment == ".." {
+                buf.pop();
+            } else if segment.starts_with('.') {
+                return Err(UriSegmentError::BadStart('.'));
+            } else if segment.starts_with('*') {
+                return Err(UriSegmentError::BadStart('*'));
+            } else if segment.ends_with(':') {
+                return Err(UriSegmentError::BadEnd(':'));
+            } else if segment.ends_with('>') {
+                return Err(UriSegmentError::BadEnd('>'));
+            } else if segment.ends_with('<') {
+                return Err(UriSegmentError::BadEnd('<'));
+            } else if segment.is_empty() {
+                continue;
+            } else if cfg!(windows) && segment.contains('\\') {
+                return Err(UriSegmentError::BadChar('\\'));
+            } else {
+                buf.push(segment)
+            }
+        }
+
+        Ok(PathBufWrap(buf))
+    }
+}
+
+impl AsRef<Path> for PathBufWrap {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref()
+    }
+}
+
+impl FromRequest for PathBufWrap {
+    type Error = UriSegmentError;
+    type Future = Ready<Result<Self, Self::Error>>;
+    type Config = ();
+
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        ready(req.match_info().path().parse())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::iter::FromIterator;
+
+    use super::*;
+
+    #[test]
+    fn test_path_buf() {
+        assert_eq!(
+            PathBufWrap::from_str("/test/.tt").map(|t| t.0),
+            Err(UriSegmentError::BadStart('.'))
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/test/*tt").map(|t| t.0),
+            Err(UriSegmentError::BadStart('*'))
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/test/tt:").map(|t| t.0),
+            Err(UriSegmentError::BadEnd(':'))
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/test/tt<").map(|t| t.0),
+            Err(UriSegmentError::BadEnd('<'))
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/test/tt>").map(|t| t.0),
+            Err(UriSegmentError::BadEnd('>'))
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/seg1/seg2/").unwrap().0,
+            PathBuf::from_iter(vec!["seg1", "seg2"])
+        );
+        assert_eq!(
+            PathBufWrap::from_str("/seg1/../seg2/").unwrap().0,
+            PathBuf::from_iter(vec!["seg2"])
+        );
+    }
+}
--- a/actix-files/src/range.rs
+++ b/actix-files/src/range.rs
@ -1,11 +1,14 @@
 /// HTTP Range header representation.
 #[derive(Debug, Clone, Copy)]
 pub struct HttpRange {
+    /// Start of range.
    pub start: u64,
+
+    /// Length of range.
    pub length: u64,
 }

-static PREFIX: &str = "bytes=";
+const PREFIX: &str = "bytes=";
 const PREFIX_LEN: usize = 6;

 impl HttpRange {
--- a/actix-files/src/service.rs
+++ b/actix-files/src/service.rs
@ -0,0 +1,167 @@
+use std::{
+    fmt, io,
+    path::PathBuf,
+    rc::Rc,
+    task::{Context, Poll},
+};
+
+use actix_service::Service;
+use actix_web::{
+    dev::{ServiceRequest, ServiceResponse},
+    error::Error,
+    guard::Guard,
+    http::{header, Method},
+    HttpResponse,
+};
+use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
+
+use crate::{
+    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride,
+    NamedFile, PathBufWrap,
+};
+
+/// Assembled file serving service.
+pub struct FilesService {
+    pub(crate) directory: PathBuf,
+    pub(crate) index: Option<String>,
+    pub(crate) show_index: bool,
+    pub(crate) redirect_to_slash: bool,
+    pub(crate) default: Option<HttpService>,
+    pub(crate) renderer: Rc<DirectoryRenderer>,
+    pub(crate) mime_override: Option<Rc<MimeOverride>>,
+    pub(crate) file_flags: named::Flags,
+    pub(crate) guards: Option<Rc<dyn Guard>>,
+}
+
+type FilesServiceFuture = Either<
+    Ready<Result<ServiceResponse, Error>>,
+    LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
+>;
+
+impl FilesService {
+    fn handle_err(&mut self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
+        log::debug!("Failed to handle {}: {}", req.path(), e);
+
+        if let Some(ref mut default) = self.default {
+            Either::Right(default.call(req))
+        } else {
+            Either::Left(ok(req.error_response(e)))
+        }
+    }
+}
+
+impl fmt::Debug for FilesService {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("FilesService")
+    }
+}
+
+impl Service for FilesService {
+    type Request = ServiceRequest;
+    type Response = ServiceResponse;
+    type Error = Error;
+    type Future = FilesServiceFuture;
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+        let is_method_valid = if let Some(guard) = &self.guards {
+            // execute user defined guards
+            (**guard).check(req.head())
+        } else {
+            // default behavior
+            matches!(*req.method(), Method::HEAD | Method::GET)
+        };
+
+        if !is_method_valid {
+            return Either::Left(ok(req.into_response(
+                actix_web::HttpResponse::MethodNotAllowed()
+                    .header(header::CONTENT_TYPE, "text/plain")
+                    .body("Request did not meet this resource's requirements."),
+            )));
+        }
+
+        let real_path: PathBufWrap = match req.match_info().path().parse() {
+            Ok(item) => item,
+            Err(e) => return Either::Left(ok(req.error_response(e))),
+        };
+
+        // full file path
+        let path = match self.directory.join(&real_path).canonicalize() {
+            Ok(path) => path,
+            Err(e) => return self.handle_err(e, req),
+        };
+
+        if path.is_dir() {
+            if let Some(ref redir_index) = self.index {
+                if self.redirect_to_slash && !req.path().ends_with('/') {
+                    let redirect_to = format!("{}/", req.path());
+
+                    return Either::Left(ok(req.into_response(
+                        HttpResponse::Found()
+                            .header(header::LOCATION, redirect_to)
+                            .body("")
+                            .into_body(),
+                    )));
+                }
+
+                let path = path.join(redir_index);
+
+                match NamedFile::open(path) {
+                    Ok(mut named_file) => {
+                        if let Some(ref mime_override) = self.mime_override {
+                            let new_disposition =
+                                mime_override(&named_file.content_type.type_());
+                            named_file.content_disposition.disposition = new_disposition;
+                        }
+                        named_file.flags = self.file_flags;
+
+                        let (req, _) = req.into_parts();
+                        Either::Left(ok(match named_file.into_response(&req) {
+                            Ok(item) => ServiceResponse::new(req, item),
+                            Err(e) => ServiceResponse::from_err(e, req),
+                        }))
+                    }
+                    Err(e) => self.handle_err(e, req),
+                }
+            } else if self.show_index {
+                let dir = Directory::new(self.directory.clone(), path);
+
+                let (req, _) = req.into_parts();
+                let x = (self.renderer)(&dir, &req);
+
+                match x {
+                    Ok(resp) => Either::Left(ok(resp)),
+                    Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
+                }
+            } else {
+                Either::Left(ok(ServiceResponse::from_err(
+                    FilesError::IsDirectory,
+                    req.into_parts().0,
+                )))
+            }
+        } else {
+            match NamedFile::open(path) {
+                Ok(mut named_file) => {
+                    if let Some(ref mime_override) = self.mime_override {
+                        let new_disposition =
+                            mime_override(&named_file.content_type.type_());
+                        named_file.content_disposition.disposition = new_disposition;
+                    }
+                    named_file.flags = self.file_flags;
+
+                    let (req, _) = req.into_parts();
+                    match named_file.into_response(&req) {
+                        Ok(item) => {
+                            Either::Left(ok(ServiceResponse::new(req.clone(), item)))
+                        }
+                        Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
+                    }
+                }
+                Err(e) => self.handle_err(e, req),
+            }
+        }
+    }
+}
--- a/actix-files/tests/encoding.rs
+++ b/actix-files/tests/encoding.rs
@ -0,0 +1,40 @@
+use actix_files::Files;
+use actix_web::{
+    http::{
+        header::{self, HeaderValue},
+        StatusCode,
+    },
+    test::{self, TestRequest},
+    App,
+};
+
+#[actix_rt::test]
+async fn test_utf8_file_contents() {
+    // use default ISO-8859-1 encoding
+    let mut srv =
+        test::init_service(App::new().service(Files::new("/", "./tests"))).await;
+
+    let req = TestRequest::with_uri("/utf8.txt").to_request();
+    let res = test::call_service(&mut srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(
+        res.headers().get(header::CONTENT_TYPE),
+        Some(&HeaderValue::from_static("text/plain")),
+    );
+
+    // prefer UTF-8 encoding
+    let mut srv = test::init_service(
+        App::new().service(Files::new("/", "./tests").prefer_utf8(true)),
+    )
+    .await;
+
+    let req = TestRequest::with_uri("/utf8.txt").to_request();
+    let res = test::call_service(&mut srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(
+        res.headers().get(header::CONTENT_TYPE),
+        Some(&HeaderValue::from_static("text/plain; charset=utf-8")),
+    );
+}
--- a/actix-files/tests/utf8.txt
+++ b/actix-files/tests/utf8.txt
@ -0,0 +1,3 @@
+中文内容显示正确。
+
+English is OK.
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -3,6 +3,21 @@
 ## Unreleased - 2020-xx-xx


+## 2.1.0 - 2020-10-30
+### Added
+* Added more flexible `on_connect_ext` methods for on-connect handling. [#1754]
+
+### Changed
+* Upgrade `base64` to `0.13`. [#1744]
+* Upgrade `pin-project` to `1.0`. [#1733]
+* Deprecate `ResponseBuilder::{if_some, if_true}`. [#1760]
+
+[#1760]: https://github.com/actix/actix-web/pull/1760
+[#1754]: https://github.com/actix/actix-web/pull/1754
+[#1733]: https://github.com/actix/actix-web/pull/1733
+[#1744]: https://github.com/actix/actix-web/pull/1744
+
+
 ## 2.0.0 - 2020-09-11
 * No significant changes from `2.0.0-beta.4`.

--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,8 +1,8 @@
 [package]
 name = "actix-http"
-version = "2.0.0"
+version = "2.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix HTTP primitives"
+description = "HTTP primitives for the Actix ecosystem"
 readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
@ -49,7 +49,7 @@ actix-threadpool = "0.3.1"
 actix-tls = { version = "2.0.0", optional = true }
 actix = { version = "0.10.0", optional = true }

-base64 = "0.12"
+base64 = "0.13"
 bitflags = "1.2"
 bytes = "0.5.3"
 cookie = { version = "0.14.1", features = ["percent-encode"] }
@ -71,7 +71,7 @@ language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "0.4.17"
+pin-project = "1.0.0"
 rand = "0.7"
 regex = "1.3"
 serde = "1.0"
--- a/actix-http/README.md
+++ b/actix-http/README.md
@ -1,24 +1,27 @@
-# Actix http [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)  [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-http)](https://crates.io/crates/actix-http) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# actix-http

-Actix http
+> HTTP primitives for the Actix ecosystem.

-## Documentation & community resources
+[![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=2.1.0)](https://docs.rs/actix-http/2.1.0)
+![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/actix-http)
+[![Dependency Status](https://deps.rs/crate/actix-http/2.1.0/status.svg)](https://deps.rs/crate/actix-http/2.1.0)
+[![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-http/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-http](https://crates.io/crates/actix-http)
-* Minimum supported Rust version: 1.40 or later
+## Documentation & Resources
+
+- [API Documentation](https://docs.rs/actix-http/2.1.0)
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Minimum Supported Rust Version (MSRV): 1.42.0

 ## Example

 ```rust
-// see examples/framed_hello.rs for complete list of used crates.
 use std::{env, io};

 use actix_http::{HttpService, Response};
 use actix_server::Server;
-use futures::future;
+use futures_util::future;
 use http::header::HeaderValue;
 use log::info;

--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -14,10 +14,11 @@ use crate::helpers::{Data, DataFactory};
 use crate::request::Request;
 use crate::response::Response;
 use crate::service::HttpService;
+use crate::{ConnectCallback, Extensions};

-/// A http service builder
+/// A HTTP service builder
 ///
-/// This type can be used to construct an instance of `http service` through a
+/// This type can be used to construct an instance of [`HttpService`] through a
 /// builder-like pattern.
 pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
    keep_alive: KeepAlive,
@ -27,7 +28,9 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
    local_addr: Option<net::SocketAddr>,
    expect: X,
    upgrade: Option<U>,
+    // DEPRECATED: in favor of on_connect_ext
    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, S)>,
 }

@ -49,6 +52,7 @@ where
            expect: ExpectHandler,
            upgrade: None,
            on_connect: None,
+            on_connect_ext: None,
            _t: PhantomData,
        }
    }
@ -138,6 +142,7 @@ where
            expect: expect.into_factory(),
            upgrade: self.upgrade,
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }
@ -167,14 +172,16 @@ where
            expect: self.expect,
            upgrade: Some(upgrade.into_factory()),
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }

    /// Set on-connect callback.
    ///
-    /// It get called once per connection and result of the call
-    /// get stored to the request's extensions.
+    /// Called once per connection. Return value of the call is stored in request extensions.
+    ///
+    /// *SOFT DEPRECATED*: Prefer the `on_connect_ext` style callback.
    pub fn on_connect<F, I>(mut self, f: F) -> Self
    where
        F: Fn(&T) -> I + 'static,
@ -184,7 +191,20 @@ where
        self
    }

-    /// Finish service configuration and create *http service* for HTTP/1 protocol.
+    /// Sets the callback to be run on connection establishment.
+    ///
+    /// Has mutable access to a data container that will be merged into request extensions.
+    /// This enables transport layer data (like client certificates) to be accessed in middleware
+    /// and handlers.
+    pub fn on_connect_ext<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&T, &mut Extensions) + 'static,
+    {
+        self.on_connect_ext = Some(Rc::new(f));
+        self
+    }
+
+    /// Finish service configuration and create a HTTP Service for HTTP/1 protocol.
    pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
    where
        B: MessageBody,
@ -200,13 +220,15 @@ where
            self.secure,
            self.local_addr,
        );
+
        H1Service::with_config(cfg, service.into_factory())
            .expect(self.expect)
            .upgrade(self.upgrade)
            .on_connect(self.on_connect)
+            .on_connect_ext(self.on_connect_ext)
    }

-    /// Finish service configuration and create *http service* for HTTP/2 protocol.
+    /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
    pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
    where
        B: MessageBody + 'static,
@ -223,7 +245,10 @@ where
            self.secure,
            self.local_addr,
        );
-        H2Service::with_config(cfg, service.into_factory()).on_connect(self.on_connect)
+
+        H2Service::with_config(cfg, service.into_factory())
+            .on_connect(self.on_connect)
+            .on_connect_ext(self.on_connect_ext)
    }

    /// Finish service configuration and create `HttpService` instance.
@ -243,9 +268,11 @@ where
            self.secure,
            self.local_addr,
        );
+
        HttpService::with_config(cfg, service.into_factory())
            .expect(self.expect)
            .upgrade(self.upgrade)
            .on_connect(self.on_connect)
+            .on_connect_ext(self.on_connect_ext)
    }
 }
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@ -1,5 +1,5 @@
 use std::any::{Any, TypeId};
-use std::fmt;
+use std::{fmt, mem};

 use fxhash::FxHashMap;

@ -61,6 +61,16 @@ impl Extensions {
    pub fn clear(&mut self) {
        self.map.clear();
    }
+
+    /// Extends self with the items from another `Extensions`.
+    pub fn extend(&mut self, other: Extensions) {
+        self.map.extend(other.map);
+    }
+
+    /// Sets (or overrides) items from `other` into this map.
+    pub(crate) fn drain_from(&mut self, other: &mut Self) {
+        self.map.extend(mem::take(&mut other.map));
+    }
 }

 impl fmt::Debug for Extensions {
@ -178,4 +188,57 @@ mod tests {
        assert_eq!(extensions.get::<bool>(), None);
        assert_eq!(extensions.get(), Some(&MyType(10)));
    }
+
+    #[test]
+    fn test_extend() {
+        #[derive(Debug, PartialEq)]
+        struct MyType(i32);
+
+        let mut extensions = Extensions::new();
+
+        extensions.insert(5i32);
+        extensions.insert(MyType(10));
+
+        let mut other = Extensions::new();
+
+        other.insert(15i32);
+        other.insert(20u8);
+
+        extensions.extend(other);
+
+        assert_eq!(extensions.get(), Some(&15i32));
+        assert_eq!(extensions.get_mut(), Some(&mut 15i32));
+
+        assert_eq!(extensions.remove::<i32>(), Some(15i32));
+        assert!(extensions.get::<i32>().is_none());
+
+        assert_eq!(extensions.get::<bool>(), None);
+        assert_eq!(extensions.get(), Some(&MyType(10)));
+
+        assert_eq!(extensions.get(), Some(&20u8));
+        assert_eq!(extensions.get_mut(), Some(&mut 20u8));
+    }
+
+    #[test]
+    fn test_drain_from() {
+        let mut ext = Extensions::new();
+        ext.insert(2isize);
+
+        let mut more_ext = Extensions::new();
+
+        more_ext.insert(5isize);
+        more_ext.insert(5usize);
+
+        assert_eq!(ext.get::<isize>(), Some(&2isize));
+        assert_eq!(ext.get::<usize>(), None);
+        assert_eq!(more_ext.get::<isize>(), Some(&5isize));
+        assert_eq!(more_ext.get::<usize>(), Some(&5usize));
+
+        ext.drain_from(&mut more_ext);
+
+        assert_eq!(ext.get::<isize>(), Some(&5isize));
+        assert_eq!(ext.get::<usize>(), Some(&5usize));
+        assert_eq!(more_ext.get::<isize>(), None);
+        assert_eq!(more_ext.get::<usize>(), None);
+    }
 }
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@ -12,7 +12,6 @@ use bytes::{Buf, BytesMut};
 use log::{error, trace};
 use pin_project::pin_project;

-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::cloneable::CloneableService;
 use crate::config::ServiceConfig;
 use crate::error::{DispatchError, Error};
@ -21,6 +20,10 @@ use crate::helpers::DataFactory;
 use crate::httpmessage::HttpMessage;
 use crate::request::Request;
 use crate::response::Response;
+use crate::{
+    body::{Body, BodySize, MessageBody, ResponseBody},
+    Extensions,
+};

 use super::codec::Codec;
 use super::payload::{Payload, PayloadSender, PayloadStatus};
@ -88,6 +91,7 @@ where
    expect: CloneableService<X>,
    upgrade: Option<CloneableService<U>>,
    on_connect: Option<Box<dyn DataFactory>>,
+    on_connect_data: Extensions,
    flags: Flags,
    peer_addr: Option<net::SocketAddr>,
    error: Option<DispatchError>,
@ -167,7 +171,7 @@ where
    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
-    /// Create http/1 dispatcher.
+    /// Create HTTP/1 dispatcher.
    pub(crate) fn new(
        stream: T,
        config: ServiceConfig,
@ -175,6 +179,7 @@ where
        expect: CloneableService<X>,
        upgrade: Option<CloneableService<U>>,
        on_connect: Option<Box<dyn DataFactory>>,
+        on_connect_data: Extensions,
        peer_addr: Option<net::SocketAddr>,
    ) -> Self {
        Dispatcher::with_timeout(
@ -187,6 +192,7 @@ where
            expect,
            upgrade,
            on_connect,
+            on_connect_data,
            peer_addr,
        )
    }
@ -202,6 +208,7 @@ where
        expect: CloneableService<X>,
        upgrade: Option<CloneableService<U>>,
        on_connect: Option<Box<dyn DataFactory>>,
+        on_connect_data: Extensions,
        peer_addr: Option<net::SocketAddr>,
    ) -> Self {
        let keepalive = config.keep_alive_enabled();
@ -234,6 +241,7 @@ where
                expect,
                upgrade,
                on_connect,
+                on_connect_data,
                flags,
                peer_addr,
                ka_expire,
@ -526,11 +534,15 @@ where
                            let pl = this.codec.message_type();
                            req.head_mut().peer_addr = *this.peer_addr;

+                            // DEPRECATED
                            // set on_connect data
                            if let Some(ref on_connect) = this.on_connect {
                                on_connect.set(&mut req.extensions_mut());
                            }

+                            // merge on_connect_ext data into request extensions
+                            req.extensions_mut().drain_from(this.on_connect_data);
+
                            if pl == MessageType::Stream && this.upgrade.is_some() {
                                this.messages.push_back(DispatcherMessage::Upgrade(req));
                                break;
@ -927,8 +939,10 @@ mod tests {
                CloneableService::new(ExpectHandler),
                None,
                None,
+                Extensions::new(),
                None,
            );
+
            match Pin::new(&mut h1).poll(cx) {
                Poll::Pending => panic!(),
                Poll::Ready(res) => assert!(res.is_err()),
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@ -18,6 +18,7 @@ use crate::error::{DispatchError, Error, ParseError};
 use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;
+use crate::{ConnectCallback, Extensions};

 use super::codec::Codec;
 use super::dispatcher::Dispatcher;
@ -30,6 +31,7 @@ pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
    expect: X,
    upgrade: Option<U>,
    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B)>,
 }

@ -52,6 +54,7 @@ where
            expect: ExpectHandler,
            upgrade: None,
            on_connect: None,
+            on_connect_ext: None,
            _t: PhantomData,
        }
    }
@ -213,6 +216,7 @@ where
            srv: self.srv,
            upgrade: self.upgrade,
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }
@ -229,6 +233,7 @@ where
            srv: self.srv,
            expect: self.expect,
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }
@ -241,6 +246,12 @@ where
        self.on_connect = f;
        self
    }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
+        self.on_connect_ext = f;
+        self
+    }
 }

 impl<T, S, B, X, U> ServiceFactory for H1Service<T, S, B, X, U>
@ -274,6 +285,7 @@ where
            expect: None,
            upgrade: None,
            on_connect: self.on_connect.clone(),
+            on_connect_ext: self.on_connect_ext.clone(),
            cfg: Some(self.cfg.clone()),
            _t: PhantomData,
        }
@ -303,6 +315,7 @@ where
    expect: Option<X::Service>,
    upgrade: Option<U::Service>,
    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    cfg: Option<ServiceConfig>,
    _t: PhantomData<(T, B)>,
 }
@ -352,23 +365,26 @@ where

        Poll::Ready(result.map(|service| {
            let this = self.as_mut().project();
+
            H1ServiceHandler::new(
                this.cfg.take().unwrap(),
                service,
                this.expect.take().unwrap(),
                this.upgrade.take(),
                this.on_connect.clone(),
+                this.on_connect_ext.clone(),
            )
        }))
    }
 }

-/// `Service` implementation for HTTP1 transport
+/// `Service` implementation for HTTP/1 transport
 pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
    srv: CloneableService<S>,
    expect: CloneableService<X>,
    upgrade: Option<CloneableService<U>>,
    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    cfg: ServiceConfig,
    _t: PhantomData<(T, B)>,
 }
@ -390,6 +406,7 @@ where
        expect: X,
        upgrade: Option<U>,
        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    ) -> H1ServiceHandler<T, S, B, X, U> {
        H1ServiceHandler {
            srv: CloneableService::new(srv),
@ -397,6 +414,7 @@ where
            upgrade: upgrade.map(CloneableService::new),
            cfg,
            on_connect,
+            on_connect_ext,
            _t: PhantomData,
        }
    }
@ -462,11 +480,13 @@ where
    }

    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
+        let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
+
+        let mut connect_extensions = Extensions::new();
+        if let Some(ref handler) = self.on_connect_ext {
+            // run on_connect_ext callback, populating connect extensions
+            handler(&io, &mut connect_extensions);
+        }

        Dispatcher::new(
            io,
@ -474,7 +494,8 @@ where
            self.srv.clone(),
            self.expect.clone(),
            self.upgrade.clone(),
-            on_connect,
+            deprecated_on_connect,
+            connect_extensions,
            addr,
        )
    }
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -24,6 +24,7 @@ use crate::message::ResponseHead;
 use crate::payload::Payload;
 use crate::request::Request;
 use crate::response::Response;
+use crate::Extensions;

 const CHUNK_SIZE: usize = 16_384;

@ -36,6 +37,7 @@ where
    service: CloneableService<S>,
    connection: Connection<T, Bytes>,
    on_connect: Option<Box<dyn DataFactory>>,
+    on_connect_data: Extensions,
    config: ServiceConfig,
    peer_addr: Option<net::SocketAddr>,
    ka_expire: Instant,
@ -56,6 +58,7 @@ where
        service: CloneableService<S>,
        connection: Connection<T, Bytes>,
        on_connect: Option<Box<dyn DataFactory>>,
+        on_connect_data: Extensions,
        config: ServiceConfig,
        timeout: Option<Delay>,
        peer_addr: Option<net::SocketAddr>,
@ -82,6 +85,7 @@ where
            peer_addr,
            connection,
            on_connect,
+            on_connect_data,
            ka_expire,
            ka_timer,
            _t: PhantomData,
@ -130,11 +134,15 @@ where
                    head.headers = parts.headers.into();
                    head.peer_addr = this.peer_addr;

+                    // DEPRECATED
                    // set on_connect data
                    if let Some(ref on_connect) = this.on_connect {
                        on_connect.set(&mut req.extensions_mut());
                    }

+                    // merge on_connect_ext data into request extensions
+                    req.extensions_mut().drain_from(&mut this.on_connect_data);
+
                    actix_rt::spawn(ServiceResponse::<
                        S::Future,
                        S::Response,
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@ -2,7 +2,7 @@ use std::future::Future;
 use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::{net, rc};
+use std::{net, rc::Rc};

 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
@ -23,6 +23,7 @@ use crate::error::{DispatchError, Error};
 use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;
+use crate::{ConnectCallback, Extensions};

 use super::dispatcher::Dispatcher;

@ -30,7 +31,8 @@ use super::dispatcher::Dispatcher;
 pub struct H2Service<T, S, B> {
    srv: S,
    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B)>,
 }

@ -50,19 +52,27 @@ where
        H2Service {
            cfg,
            on_connect: None,
+            on_connect_ext: None,
            srv: service.into_factory(),
            _t: PhantomData,
        }
    }

    /// Set on connect callback.
+
    pub(crate) fn on_connect(
        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
    ) -> Self {
        self.on_connect = f;
        self
    }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
+        self.on_connect_ext = f;
+        self
+    }
 }

 impl<S, B> H2Service<TcpStream, S, B>
@ -203,6 +213,7 @@ where
            fut: self.srv.new_service(()),
            cfg: Some(self.cfg.clone()),
            on_connect: self.on_connect.clone(),
+            on_connect_ext: self.on_connect_ext.clone(),
            _t: PhantomData,
        }
    }
@ -214,7 +225,8 @@ pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
    #[pin]
    fut: S::Future,
    cfg: Option<ServiceConfig>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B)>,
 }

@ -237,6 +249,7 @@ where
            H2ServiceHandler::new(
                this.cfg.take().unwrap(),
                this.on_connect.clone(),
+                this.on_connect_ext.clone(),
                service,
            )
        }))
@ -247,7 +260,8 @@ where
 pub struct H2ServiceHandler<T, S: Service, B> {
    srv: CloneableService<S>,
    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B)>,
 }

@ -261,12 +275,14 @@ where
 {
    fn new(
        cfg: ServiceConfig,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
        srv: S,
    ) -> H2ServiceHandler<T, S, B> {
        H2ServiceHandler {
            cfg,
            on_connect,
+            on_connect_ext,
            srv: CloneableService::new(srv),
            _t: PhantomData,
        }
@ -296,18 +312,21 @@ where
    }

    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
+        let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
+
+        let mut connect_extensions = Extensions::new();
+        if let Some(ref handler) = self.on_connect_ext {
+            // run on_connect_ext callback, populating connect extensions
+            handler(&io, &mut connect_extensions);
+        }

        H2ServiceHandlerResponse {
            state: State::Handshake(
                Some(self.srv.clone()),
                Some(self.cfg.clone()),
                addr,
-                on_connect,
+                deprecated_on_connect,
+                Some(connect_extensions),
                server::handshake(io),
            ),
        }
@ -325,6 +344,7 @@ where
        Option<ServiceConfig>,
        Option<net::SocketAddr>,
        Option<Box<dyn DataFactory>>,
+        Option<Extensions>,
        Handshake<T, Bytes>,
    ),
 }
@ -360,6 +380,7 @@ where
                ref mut config,
                ref peer_addr,
                ref mut on_connect,
+                ref mut on_connect_data,
                ref mut handshake,
            ) => match Pin::new(handshake).poll(cx) {
                Poll::Ready(Ok(conn)) => {
@ -367,6 +388,7 @@ where
                        srv.take().unwrap(),
                        conn,
                        on_connect.take(),
+                        on_connect_data.take().unwrap(),
                        config.take().unwrap(),
                        None,
                        *peer_addr,
--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@ -50,6 +50,7 @@ impl<'a> io::Write for Writer<'a> {
        self.0.extend_from_slice(buf);
        Ok(buf.len())
    }
+
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -1,4 +1,4 @@
-//! Basic http primitives for actix-net framework.
+//! HTTP primitives for the Actix ecosystem.

 #![deny(rust_2018_idioms)]
 #![allow(
@ -7,6 +7,9 @@
    clippy::new_without_default,
    clippy::borrow_interior_mutable_const
 )]
+#![allow(clippy::manual_strip)] // Allow this to keep MSRV(1.42).
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]

 #[macro_use]
 extern crate log;
@ -77,3 +80,5 @@ pub enum Protocol {
    Http1,
    Http2,
 }
+
+type ConnectCallback<IO> = dyn Fn(&IO, &mut Extensions);
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
@ -554,8 +554,9 @@ impl ResponseBuilder {
        self
    }

-    /// This method calls provided closure with builder reference if value is
-    /// true.
+    /// This method calls provided closure with builder reference if value is `true`.
+    #[doc(hidden)]
+    #[deprecated = "Use an if statement."]
    pub fn if_true<F>(&mut self, value: bool, f: F) -> &mut Self
    where
        F: FnOnce(&mut ResponseBuilder),
@ -566,8 +567,9 @@ impl ResponseBuilder {
        self
    }

-    /// This method calls provided closure with builder reference if value is
-    /// Some.
+    /// This method calls provided closure with builder reference if value is `Some`.
+    #[doc(hidden)]
+    #[deprecated = "Use an if-let construction."]
    pub fn if_some<T, F>(&mut self, value: Option<T>, f: F) -> &mut Self
    where
        F: FnOnce(T, &mut ResponseBuilder),
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::{fmt, net, rc};
+use std::{fmt, net, rc::Rc};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
@ -20,15 +20,17 @@ use crate::error::{DispatchError, Error};
 use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;
-use crate::{h1, h2::Dispatcher, Protocol};
+use crate::{h1, h2::Dispatcher, ConnectCallback, Extensions, Protocol};

-/// `ServiceFactory` HTTP1.1/HTTP2 transport implementation
+/// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
 pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>> {
    srv: S,
    cfg: ServiceConfig,
    expect: X,
    upgrade: Option<U>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    // DEPRECATED: in favor of on_connect_ext
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B)>,
 }

@ -66,6 +68,7 @@ where
            expect: h1::ExpectHandler,
            upgrade: None,
            on_connect: None,
+            on_connect_ext: None,
            _t: PhantomData,
        }
    }
@ -81,6 +84,7 @@ where
            expect: h1::ExpectHandler,
            upgrade: None,
            on_connect: None,
+            on_connect_ext: None,
            _t: PhantomData,
        }
    }
@ -113,6 +117,7 @@ where
            srv: self.srv,
            upgrade: self.upgrade,
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }
@ -138,6 +143,7 @@ where
            srv: self.srv,
            expect: self.expect,
            on_connect: self.on_connect,
+            on_connect_ext: self.on_connect_ext,
            _t: PhantomData,
        }
    }
@ -145,11 +151,17 @@ where
    /// Set on connect callback.
    pub(crate) fn on_connect(
        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
    ) -> Self {
        self.on_connect = f;
        self
    }
+
+    /// Set connect callback with mutable access to request data container.
+    pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
+        self.on_connect_ext = f;
+        self
+    }
 }

 impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
@ -355,6 +367,7 @@ where
            expect: None,
            upgrade: None,
            on_connect: self.on_connect.clone(),
+            on_connect_ext: self.on_connect_ext.clone(),
            cfg: self.cfg.clone(),
            _t: PhantomData,
        }
@ -378,7 +391,8 @@ pub struct HttpServiceResponse<
    fut_upg: Option<U::Future>,
    expect: Option<X::Service>,
    upgrade: Option<U::Service>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    cfg: ServiceConfig,
    _t: PhantomData<(T, B)>,
 }
@ -429,6 +443,7 @@ where
            .fut
            .poll(cx)
            .map_err(|e| log::error!("Init http service error: {:?}", e)));
+
        Poll::Ready(result.map(|service| {
            let this = self.as_mut().project();
            HttpServiceHandler::new(
@ -437,6 +452,7 @@ where
                this.expect.take().unwrap(),
                this.upgrade.take(),
                this.on_connect.clone(),
+                this.on_connect_ext.clone(),
            )
        }))
    }
@ -448,7 +464,8 @@ pub struct HttpServiceHandler<T, S: Service, B, X: Service, U: Service> {
    expect: CloneableService<X>,
    upgrade: Option<CloneableService<U>>,
    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+    on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    _t: PhantomData<(T, B, X)>,
 }

@ -469,11 +486,13 @@ where
        srv: S,
        expect: X,
        upgrade: Option<U>,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
+        on_connect_ext: Option<Rc<ConnectCallback<T>>>,
    ) -> HttpServiceHandler<T, S, B, X, U> {
        HttpServiceHandler {
            cfg,
            on_connect,
+            on_connect_ext,
            srv: CloneableService::new(srv),
            expect: CloneableService::new(expect),
            upgrade: upgrade.map(CloneableService::new),
@ -543,11 +562,12 @@ where
    }

    fn call(&mut self, (io, proto, peer_addr): Self::Request) -> Self::Future {
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
+        let mut connect_extensions = Extensions::new();
+
+        let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
+        if let Some(ref handler) = self.on_connect_ext {
+            handler(&io, &mut connect_extensions);
+        }

        match proto {
            Protocol::Http2 => HttpServiceHandlerResponse {
@ -555,10 +575,12 @@ where
                    server::handshake(io),
                    self.cfg.clone(),
                    self.srv.clone(),
-                    on_connect,
+                    deprecated_on_connect,
+                    connect_extensions,
                    peer_addr,
                ))),
            },
+
            Protocol::Http1 => HttpServiceHandlerResponse {
                state: State::H1(h1::Dispatcher::new(
                    io,
@ -566,7 +588,8 @@ where
                    self.srv.clone(),
                    self.expect.clone(),
                    self.upgrade.clone(),
-                    on_connect,
+                    deprecated_on_connect,
+                    connect_extensions,
                    peer_addr,
                )),
            },
@ -595,6 +618,7 @@ where
            ServiceConfig,
            CloneableService<S>,
            Option<Box<dyn DataFactory>>,
+            Extensions,
            Option<net::SocketAddr>,
        )>,
    ),
@ -670,9 +694,16 @@ where
                } else {
                    panic!()
                };
-                let (_, cfg, srv, on_connect, peer_addr) = data.take().unwrap();
+                let (_, cfg, srv, on_connect, on_connect_data, peer_addr) =
+                    data.take().unwrap();
                self.set(State::H2(Dispatcher::new(
-                    srv, conn, on_connect, cfg, None, peer_addr,
+                    srv,
+                    conn,
+                    on_connect,
+                    on_connect_data,
+                    cfg,
+                    None,
+                    peer_addr,
                )));
                self.poll(cx)
            }
--- a/actix-http/src/ws/mask.rs
+++ b/actix-http/src/ws/mask.rs
@ -4,7 +4,9 @@ use std::ptr::copy_nonoverlapping;
 use std::slice;

 // Holds a slice guaranteed to be shorter than 8 bytes
-struct ShortSlice<'a>(&'a mut [u8]);
+struct ShortSlice<'a> {
+    inner: &'a mut [u8],
+}

 impl<'a> ShortSlice<'a> {
    /// # Safety
@ -12,10 +14,11 @@ impl<'a> ShortSlice<'a> {
    unsafe fn new(slice: &'a mut [u8]) -> Self {
        // Sanity check for debug builds
        debug_assert!(slice.len() < 8);
-        ShortSlice(slice)
+        ShortSlice { inner: slice }
    }
+
    fn len(&self) -> usize {
-        self.0.len()
+        self.inner.len()
    }
 }

@ -56,7 +59,7 @@ pub(crate) fn apply_mask(buf: &mut [u8], mask_u32: u32) {
 fn xor_short(buf: ShortSlice<'_>, mask: u64) {
    // SAFETY: we know that a `ShortSlice` fits in a u64
    unsafe {
-        let (ptr, len) = (buf.0.as_mut_ptr(), buf.0.len());
+        let (ptr, len) = (buf.inner.as_mut_ptr(), buf.len());
        let mut b: u64 = 0;
        #[allow(trivial_casts)]
        copy_nonoverlapping(ptr, &mut b as *mut _ as *mut u8, len);
@ -96,7 +99,13 @@ fn align_buf(buf: &mut [u8]) -> (ShortSlice<'_>, &mut [u64], ShortSlice<'_>) {

        // SAFETY: we know the middle section is correctly aligned, and the outer
        // sections are smaller than 8 bytes
-        unsafe { (ShortSlice::new(head), cast_slice(mid), ShortSlice(tail)) }
+        unsafe {
+            (
+                ShortSlice::new(head),
+                cast_slice(mid),
+                ShortSlice::new(tail),
+            )
+        }
    } else {
        // We didn't cross even one aligned boundary!

--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@ -411,8 +411,10 @@ async fn test_h2_on_connect() {
    let srv = test_server(move || {
        HttpService::build()
            .on_connect(|_| 10usize)
+            .on_connect_ext(|_, data| data.insert(20isize))
            .h2(|req: Request| {
                assert!(req.extensions().contains::<usize>());
+                assert!(req.extensions().contains::<isize>());
                ok::<_, ()>(Response::Ok().finish())
            })
            .openssl(ssl_acceptor())
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -663,8 +663,10 @@ async fn test_h1_on_connect() {
    let srv = test_server(|| {
        HttpService::build()
            .on_connect(|_| 10usize)
+            .on_connect_ext(|_, data| data.insert(20isize))
            .h1(|req: Request| {
                assert!(req.extensions().contains::<usize>());
+                assert!(req.extensions().contains::<isize>());
                future::ok::<_, ()>(Response::Ok().finish())
            })
            .tcp()
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@ -1,6 +1,7 @@
 # Changes

 ## Unreleased - 2020-xx-xx
+* Fix multipart consuming payload before header checks #1513


 ## 3.0.0 - 2020-09-11
--- a/actix-multipart/src/extractor.rs
+++ b/actix-multipart/src/extractor.rs
@ -36,6 +36,9 @@ impl FromRequest for Multipart {

    #[inline]
    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-        ok(Multipart::new(req.headers(), payload.take()))
+        ok(match Multipart::boundary(req.headers()) {
+            Ok(boundary) => Multipart::from_boundary(boundary, payload.take()),
+            Err(err) => Multipart::from_error(err),
+        })
    }
 }
--- a/actix-multipart/src/server.rs
+++ b/actix-multipart/src/server.rs
@ -64,26 +64,13 @@ impl Multipart {
        S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
    {
        match Self::boundary(headers) {
-            Ok(boundary) => Multipart {
-                error: None,
-                safety: Safety::new(),
-                inner: Some(Rc::new(RefCell::new(InnerMultipart {
-                    boundary,
-                    payload: PayloadRef::new(PayloadBuffer::new(Box::new(stream))),
-                    state: InnerState::FirstBoundary,
-                    item: InnerMultipartItem::None,
-                }))),
-            },
-            Err(err) => Multipart {
-                error: Some(err),
-                safety: Safety::new(),
-                inner: None,
-            },
+            Ok(boundary) => Multipart::from_boundary(boundary, stream),
+            Err(err) => Multipart::from_error(err),
        }
    }

    /// Extract boundary info from headers.
-    fn boundary(headers: &HeaderMap) -> Result<String, MultipartError> {
+    pub(crate) fn boundary(headers: &HeaderMap) -> Result<String, MultipartError> {
        if let Some(content_type) = headers.get(&header::CONTENT_TYPE) {
            if let Ok(content_type) = content_type.to_str() {
                if let Ok(ct) = content_type.parse::<mime::Mime>() {
@ -102,6 +89,32 @@ impl Multipart {
            Err(MultipartError::NoContentType)
        }
    }
+
+    /// Create multipart instance for given boundary and stream
+    pub(crate) fn from_boundary<S>(boundary: String, stream: S) -> Multipart
+    where
+        S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
+    {
+        Multipart {
+            error: None,
+            safety: Safety::new(),
+            inner: Some(Rc::new(RefCell::new(InnerMultipart {
+                boundary,
+                payload: PayloadRef::new(PayloadBuffer::new(Box::new(stream))),
+                state: InnerState::FirstBoundary,
+                item: InnerMultipartItem::None,
+            }))),
+        }
+    }
+
+    /// Create Multipart instance from MultipartError
+    pub(crate) fn from_error(err: MultipartError) -> Multipart {
+        Multipart {
+            error: Some(err),
+            safety: Safety::new(),
+            inner: None,
+        }
+    }
 }

 impl Stream for Multipart {
@ -815,6 +828,8 @@ mod tests {
    use actix_http::h1::Payload;
    use actix_utils::mpsc;
    use actix_web::http::header::{DispositionParam, DispositionType};
+    use actix_web::test::TestRequest;
+    use actix_web::FromRequest;
    use bytes::Bytes;
    use futures_util::future::lazy;

@ -1151,4 +1166,38 @@ mod tests {
        );
        assert_eq!(payload.buf.len(), 0);
    }
+
+    #[actix_rt::test]
+    async fn test_multipart_from_error() {
+        let err = MultipartError::NoContentType;
+        let mut multipart = Multipart::from_error(err);
+        assert!(multipart.next().await.unwrap().is_err())
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_from_boundary() {
+        let (_, payload) = create_stream();
+        let (_, headers) = create_simple_request_with_header();
+        let boundary = Multipart::boundary(&headers);
+        assert!(boundary.is_ok());
+        let _ = Multipart::from_boundary(boundary.unwrap(), payload);
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_payload_consumption() {
+        // with sample payload and HttpRequest with no headers
+        let (_, inner_payload) = Payload::create(false);
+        let mut payload = actix_web::dev::Payload::from(inner_payload);
+        let req = TestRequest::default().to_http_request();
+
+        // multipart should generate an error
+        let mut mp = Multipart::from_request(&req, &mut payload).await.unwrap();
+        assert!(mp.next().await.unwrap().is_err());
+
+        // and should not consume the payload
+        match payload {
+            actix_web::dev::Payload::H1(_) => {} //expected
+            _ => unreachable!(),
+        }
+    }
 }
--- a/actix-web-actors/CHANGES.md
+++ b/actix-web-actors/CHANGES.md
@ -1,7 +1,7 @@
 # Changes

 ## Unreleased - 2020-xx-xx
-
+* Upgrade `pin-project` to `1.0`.

 ## 3.0.0 - 2020-09-11
 * No significant changes from `3.0.0-beta.2`.
--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@ -23,7 +23,7 @@ actix-codec = "0.3.0"
 bytes = "0.5.2"
 futures-channel = { version = "0.3.5", default-features = false }
 futures-core = { version = "0.3.5", default-features = false }
-pin-project = "0.4.17"
+pin-project = "1.0.0"

 [dev-dependencies]
 actix-rt = "1.1.1"
--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@ -3,6 +3,14 @@
 ## Unreleased - 2020-xx-xx


+## 0.4.0 - 2020-09-20
+* Added compile success and failure testing. [#1677]
+* 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`.

@ -13,47 +21,48 @@
 [#1559]: https://github.com/actix/actix-web/pull/1559


-## [0.2.2] - 2020-05-23
+## 0.2.2 - 2020-05-23
 * Add resource middleware on actix-web-codegen [#1467]

 [#1467]: https://github.com/actix/actix-web/pull/1467

-## [0.2.1] - 2020-02-25
+
+## 0.2.1 - 2020-02-25
 * Add `#[allow(missing_docs)]` attribute to generated structs [#1368]
 * 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

+## 0.2.0 - 2019-12-13
 * Generate code for actix-web 2.0

-## [0.1.3] - 2019-10-14

+## 0.1.3 - 2019-10-14
 * Bump up `syn` & `quote` to 1.0
 * Provide better error message

-## [0.1.2] - 2019-06-04

+## 0.1.2 - 2019-06-04
 * Add macros for head, options, trace, connect and patch http methods

-## [0.1.1] - 2019-06-01

+## 0.1.1 - 2019-06-01
 * Add syn "extra-traits" feature

-## [0.1.0] - 2019-05-18

+## 0.1.0 - 2019-05-18
 * Release

-## [0.1.0-beta.1] - 2019-04-20

+## 0.1.0-beta.1 - 2019-04-20
 * Gen code for actix-web 1.0.0-beta.1

-## [0.1.0-alpha.6] - 2019-04-14

+## 0.1.0-alpha.6 - 2019-04-14
 * Gen code for actix-web 1.0.0-alpha.6

-## [0.1.0-alpha.1] - 2019-03-28

+## 0.1.0-alpha.1 - 2019-03-28
 * Initial impl
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.3.0"
+version = "0.4.0"
 description = "Actix web proc macros"
 readme = "README.md"
 homepage = "https://actix.rs"
@ -19,6 +19,8 @@ syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"

 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "1.1.1"
 actix-web = "3.0.0"
 futures-util = { version = "0.3.5", default-features = false }
+trybuild = "1"
+rustversion = "1"
--- a/actix-web-codegen/README.md
+++ b/actix-web-codegen/README.md
@ -1,8 +1,22 @@
-# Helper and convenience macros for Actix-web. [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web-codegen)](https://crates.io/crates/actix-web-codegen) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# actix-web-codegen
+
+> Helper and convenience macros for Actix Web
+
+[![crates.io](https://meritbadge.herokuapp.com/actix-web-codegen)](https://crates.io/crates/actix-web-codegen)
+[![Documentation](https://docs.rs/actix-web-codegen/badge.svg)](https://docs.rs/actix-web)
+[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
+[![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)
+[![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web)
+[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

 ## Documentation & Resources

-* [API Documentation](https://docs.rs/actix-web-codegen/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-web-codegen](https://crates.io/crates/actix-web-codegen)
-* Minimum supported Rust version: 1.40 or later
+- [API Documentation](https://docs.rs/actix-web-codegen)
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Cargo package: [actix-web-codegen](https://crates.io/crates/actix-web-codegen)
+- Minimum supported Rust version: 1.42 or later.
+
+## Compile Testing
+Uses the [`trybuild`] crate. All compile fail tests should include a stderr file generated by `trybuild`. See the [workflow section](https://github.com/dtolnay/trybuild#workflow) of the trybuild docs for info on how to do this.
+
+[`trybuild`]: https://github.com/dtolnay/trybuild
--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@ -1,158 +1,174 @@
-#![recursion_limit = "512"]
-
-//! Helper and convenience macros for Actix-web.
+//! Macros for reducing boilerplate code in Actix Web applications.
 //!
-//! ## Runtime Setup
+//! ## Actix Web Re-exports
+//! Actix Web re-exports a version of this crate in it's entirety so you usually don't have to
+//! specify a dependency on this crate explicitly. Sometimes, however, updates are made to this
+//! crate before the actix-web dependency is updated. Therefore, code examples here will show
+//! explicit imports. Check the latest [actix-web attributes docs] to see which macros
+//! are re-exported.
 //!
-//! - [main](attr.main.html)
-//!
-//! ## Resource Macros:
-//!
-//! - [get](attr.get.html)
-//! - [post](attr.post.html)
-//! - [put](attr.put.html)
-//! - [delete](attr.delete.html)
-//! - [head](attr.head.html)
-//! - [connect](attr.connect.html)
-//! - [options](attr.options.html)
-//! - [trace](attr.trace.html)
-//! - [patch](attr.patch.html)
-//!
-//! ### Attributes:
-//!
-//! - `"path"` - Raw literal string with path for which to register handle. Mandatory.
-//! - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
-//! - `wrap="Middleware"` - Registers a resource middleware.
-//!
-//! ### Notes
-//!
-//! Function name can be specified as any expression that is going to be accessible to the generate
-//! code (e.g `my_guard` or `my_module::my_guard`)
-//!
-//! ### Example:
+//! # Runtime Setup
+//! Used for setting up the actix async runtime. See [main] macro docs.
 //!
 //! ```rust
-//! use actix_web::HttpResponse;
-//! use actix_web_codegen::get;
-//!
-//! #[get("/test")]
-//! async fn async_test() -> Result<HttpResponse, actix_web::Error> {
-//!     Ok(HttpResponse::Ok().finish())
+//! #[actix_web_codegen::main] // or `#[actix_web::main]` in Actix Web apps
+//! async fn main() {
+//!     async { println!("Hello world"); }.await
 //! }
 //! ```
+//!
+//! # Single Method Handler
+//! There is a macro to set up a handler for each of the most common HTTP methods that also define
+//! additional guards and route-specific middleware.
+//!
+//! See docs for: [GET], [POST], [PATCH], [PUT], [DELETE], [HEAD], [CONNECT], [OPTIONS], [TRACE]
+//!
+//! ```rust
+//! # use actix_web::HttpResponse;
+//! # use actix_web_codegen::get;
+//! #[get("/test")]
+//! async fn get_handler() -> HttpResponse {
+//!     HttpResponse::Ok().finish()
+//! }
+//! ```
+//!
+//! # Multiple Method Handlers
+//! Similar to the single method handler macro but takes one or more arguments for the HTTP methods
+//! it should respond to. See [route] macro docs.
+//!
+//! ```rust
+//! # use actix_web::HttpResponse;
+//! # use actix_web_codegen::route;
+//! #[route("/test", method="GET", method="HEAD")]
+//! async fn get_and_head_handler() -> HttpResponse {
+//!     HttpResponse::Ok().finish()
+//! }
+//! ```
+//!
+//! [actix-web attributes docs]: https://docs.rs/actix-web/*/actix_web/#attributes
+//! [main]: attr.main.html
+//! [route]: attr.route.html
+//! [GET]: attr.get.html
+//! [POST]: attr.post.html
+//! [PUT]: attr.put.html
+//! [DELETE]: attr.delete.html
+//! [HEAD]: attr.head.html
+//! [CONNECT]: attr.connect.html
+//! [OPTIONS]: attr.options.html
+//! [TRACE]: attr.trace.html
+//! [PATCH]: attr.patch.html

-extern crate proc_macro;
-
-mod route;
+#![recursion_limit = "512"]

 use proc_macro::TokenStream;

-/// Creates route handler with `GET` method guard.
+mod route;
+
+/// Creates resource handler, allowing multiple HTTP method guards.
 ///
-/// Syntax: `#[get("path"[, attributes])]`
+/// # Syntax
+/// ```text
+/// #[route("path", method="HTTP_METHOD"[, attributes])]
+/// ```
 ///
-/// ## Attributes:
-///
-/// - `"path"` - Raw literal string with path for which to register handler. Mandatory.
+/// # Attributes
+/// - `"path"` - Raw literal string with path for which to register handler.
+/// - `method="HTTP_METHOD"` - Registers HTTP method to provide guard for. Upper-case string, "GET", "POST" for example.
 /// - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
 /// - `wrap="Middleware"` - Registers a resource middleware.
+///
+/// # Notes
+/// Function name can be specified as any expression that is going to be accessible to the generate
+/// code, e.g `my_guard` or `my_module::my_guard`.
+///
+/// # Example
+///
+/// ```rust
+/// # use actix_web::HttpResponse;
+/// # use actix_web_codegen::route;
+/// #[route("/test", method="GET", method="HEAD")]
+/// async fn example() -> HttpResponse {
+///     HttpResponse::Ok().finish()
+/// }
+/// ```
 #[proc_macro_attribute]
-pub fn get(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Get)
+pub fn route(args: TokenStream, input: TokenStream) -> TokenStream {
+    route::with_method(None, args, input)
 }

-/// Creates route handler with `POST` method guard.
-///
-/// Syntax: `#[post("path"[, attributes])]`
-///
-/// Attributes are the same as in [get](attr.get.html)
-#[proc_macro_attribute]
-pub fn post(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Post)
+macro_rules! doc_comment {
+    ($x:expr; $($tt:tt)*) => {
+        #[doc = $x]
+        $($tt)*
+    };
 }

-/// Creates route handler with `PUT` method guard.
-///
-/// Syntax: `#[put("path"[, attributes])]`
-///
-/// Attributes are the same as in [get](attr.get.html)
-#[proc_macro_attribute]
-pub fn put(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Put)
+macro_rules! method_macro {
+    (
+        $($variant:ident, $method:ident,)+
+    ) => {
+        $(doc_comment! {
+concat!("
+Creates route handler with `actix_web::guard::", stringify!($variant), "`.
+
+# Syntax
+```text
+#[", stringify!($method), r#"("path"[, attributes])]
+```
+
+# Attributes
+- `"path"` - Raw literal string with path for which to register handler.
+- `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`.
+- `wrap="Middleware"` - Registers a resource middleware.
+
+# Notes
+Function name can be specified as any expression that is going to be accessible to the generate
+code, e.g `my_guard` or `my_module::my_guard`.
+
+# Example
+
+```rust
+# use actix_web::HttpResponse;
+# use actix_web_codegen::"#, stringify!($method), ";
+#[", stringify!($method), r#"("/")]
+async fn example() -> HttpResponse {
+    HttpResponse::Ok().finish()
+}
+```
+"#);
+            #[proc_macro_attribute]
+            pub fn $method(args: TokenStream, input: TokenStream) -> TokenStream {
+                route::with_method(Some(route::MethodType::$variant), args, input)
+            }
+        })+
+    };
 }

-/// Creates route handler with `DELETE` method guard.
-///
-/// Syntax: `#[delete("path"[, attributes])]`
-///
-/// Attributes are the same as in [get](attr.get.html)
-#[proc_macro_attribute]
-pub fn delete(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Delete)
-}
-
-/// Creates route handler with `HEAD` method guard.
-///
-/// Syntax: `#[head("path"[, attributes])]`
-///
-/// Attributes are the same as in [head](attr.head.html)
-#[proc_macro_attribute]
-pub fn head(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Head)
-}
-
-/// Creates route handler with `CONNECT` method guard.
-///
-/// Syntax: `#[connect("path"[, attributes])]`
-///
-/// Attributes are the same as in [connect](attr.connect.html)
-#[proc_macro_attribute]
-pub fn connect(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Connect)
-}
-
-/// Creates route handler with `OPTIONS` method guard.
-///
-/// Syntax: `#[options("path"[, attributes])]`
-///
-/// Attributes are the same as in [options](attr.options.html)
-#[proc_macro_attribute]
-pub fn options(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Options)
-}
-
-/// Creates route handler with `TRACE` method guard.
-///
-/// Syntax: `#[trace("path"[, attributes])]`
-///
-/// Attributes are the same as in [trace](attr.trace.html)
-#[proc_macro_attribute]
-pub fn trace(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Trace)
-}
-
-/// Creates route handler with `PATCH` method guard.
-///
-/// Syntax: `#[patch("path"[, attributes])]`
-///
-/// Attributes are the same as in [patch](attr.patch.html)
-#[proc_macro_attribute]
-pub fn patch(args: TokenStream, input: TokenStream) -> TokenStream {
-    route::generate(args, input, route::GuardType::Patch)
+method_macro! {
+    Get,       get,
+    Post,      post,
+    Put,       put,
+    Delete,    delete,
+    Head,      head,
+    Connect,   connect,
+    Options,   options,
+    Trace,     trace,
+    Patch,     patch,
 }

 /// Marks async main function as the actix system entry-point.
 ///
-/// ## Usage
+/// # Actix Web Re-export
+/// This macro can be applied with `#[actix_web::main]` when used in Actix Web applications.
 ///
+/// # Usage
 /// ```rust
-/// #[actix_web::main]
+/// #[actix_web_codegen::main]
 /// async fn main() {
 ///     async { println!("Hello world"); }.await
 /// }
 /// ```
 #[proc_macro_attribute]
-#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
    use quote::quote;

--- a/actix-web-codegen/src/route.rs
+++ b/actix-web-codegen/src/route.rs
@ -1,5 +1,8 @@
 extern crate proc_macro;

+use std::collections::HashSet;
+use std::convert::TryFrom;
+
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote, ToTokens, TokenStreamExt};
@ -17,53 +20,81 @@ impl ToTokens for ResourceType {
    }
 }

-#[derive(PartialEq)]
-pub enum GuardType {
-    Get,
-    Post,
-    Put,
-    Delete,
-    Head,
-    Connect,
-    Options,
-    Trace,
-    Patch,
-}
-
-impl GuardType {
-    fn as_str(&self) -> &'static str {
-        match self {
-            GuardType::Get => "Get",
-            GuardType::Post => "Post",
-            GuardType::Put => "Put",
-            GuardType::Delete => "Delete",
-            GuardType::Head => "Head",
-            GuardType::Connect => "Connect",
-            GuardType::Options => "Options",
-            GuardType::Trace => "Trace",
-            GuardType::Patch => "Patch",
+macro_rules! method_type {
+    (
+        $($variant:ident, $upper:ident,)+
+    ) => {
+        #[derive(Debug, PartialEq, Eq, Hash)]
+        pub enum MethodType {
+            $(
+                $variant,
+            )+
        }
-    }
+
+        impl MethodType {
+            fn as_str(&self) -> &'static str {
+                match self {
+                    $(Self::$variant => stringify!($variant),)+
+                }
+            }
+
+            fn parse(method: &str) -> Result<Self, String> {
+                match method {
+                    $(stringify!($upper) => Ok(Self::$variant),)+
+                    _ => Err(format!("Unexpected HTTP method: `{}`", method)),
+                }
+            }
+        }
+    };
 }

-impl ToTokens for GuardType {
+method_type! {
+    Get,       GET,
+    Post,      POST,
+    Put,       PUT,
+    Delete,    DELETE,
+    Head,      HEAD,
+    Connect,   CONNECT,
+    Options,   OPTIONS,
+    Trace,     TRACE,
+    Patch,     PATCH,
+}
+
+impl ToTokens for MethodType {
    fn to_tokens(&self, stream: &mut TokenStream2) {
        let ident = Ident::new(self.as_str(), Span::call_site());
        stream.append(ident);
    }
 }

+impl TryFrom<&syn::LitStr> for MethodType {
+    type Error = syn::Error;
+
+    fn try_from(value: &syn::LitStr) -> Result<Self, Self::Error> {
+        Self::parse(value.value().as_str())
+            .map_err(|message| syn::Error::new_spanned(value, message))
+    }
+}
+
 struct Args {
    path: syn::LitStr,
    guards: Vec<Ident>,
    wrappers: Vec<syn::Type>,
+    methods: HashSet<MethodType>,
 }

 impl Args {
-    fn new(args: AttributeArgs) -> syn::Result<Self> {
+    fn new(args: AttributeArgs, method: Option<MethodType>) -> syn::Result<Self> {
        let mut path = None;
        let mut guards = Vec::new();
        let mut wrappers = Vec::new();
+        let mut methods = HashSet::new();
+
+        let is_route_macro = method.is_none();
+        if let Some(method) = method {
+            methods.insert(method);
+        }
+
        for arg in args {
            match arg {
                NestedMeta::Lit(syn::Lit::Str(lit)) => match path {
@ -96,10 +127,33 @@ impl Args {
                                "Attribute wrap expects type",
                            ));
                        }
+                    } else if nv.path.is_ident("method") {
+                        if !is_route_macro {
+                            return Err(syn::Error::new_spanned(
+                                &nv,
+                                "HTTP method forbidden here. To handle multiple methods, use `route` instead",
+                            ));
+                        } else if let syn::Lit::Str(ref lit) = nv.lit {
+                            let method = MethodType::try_from(lit)?;
+                            if !methods.insert(method) {
+                                return Err(syn::Error::new_spanned(
+                                    &nv.lit,
+                                    &format!(
+                                        "HTTP method defined more than once: `{}`",
+                                        lit.value()
+                                    ),
+                                ));
+                            }
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                nv.lit,
+                                "Attribute method expects literal string!",
+                            ));
+                        }
                    } else {
                        return Err(syn::Error::new_spanned(
                            nv.path,
-                            "Unknown attribute key is specified. Allowed: guard and wrap",
+                            "Unknown attribute key is specified. Allowed: guard, method and wrap",
                        ));
                    }
                }
@ -112,6 +166,7 @@ impl Args {
            path: path.unwrap(),
            guards,
            wrappers,
+            methods,
        })
    }
 }
@ -121,7 +176,6 @@ pub struct Route {
    args: Args,
    ast: syn::ItemFn,
    resource_type: ResourceType,
-    guard: GuardType,
 }

 fn guess_resource_type(typ: &syn::Type) -> ResourceType {
@ -150,21 +204,30 @@ impl Route {
    pub fn new(
        args: AttributeArgs,
        input: TokenStream,
-        guard: GuardType,
+        method: Option<MethodType>,
    ) -> syn::Result<Self> {
        if args.is_empty() {
            return Err(syn::Error::new(
                Span::call_site(),
                format!(
-                    r#"invalid server definition, expected #[{}("<some path>")]"#,
-                    guard.as_str().to_ascii_lowercase()
+                    r#"invalid service definition, expected #[{}("<some path>")]"#,
+                    method
+                        .map(|it| it.as_str())
+                        .unwrap_or("route")
+                        .to_ascii_lowercase()
                ),
            ));
        }
        let ast: syn::ItemFn = syn::parse(input)?;
        let name = ast.sig.ident.clone();

-        let args = Args::new(args)?;
+        let args = Args::new(args, method)?;
+        if args.methods.is_empty() {
+            return Err(syn::Error::new(
+                Span::call_site(),
+                "The #[route(..)] macro requires at least one `method` attribute",
+            ));
+        }

        let resource_type = if ast.sig.asyncness.is_some() {
            ResourceType::Async
@ -185,7 +248,6 @@ impl Route {
            args,
            ast,
            resource_type,
-            guard,
        })
    }
 }
@ -194,17 +256,36 @@ impl ToTokens for Route {
    fn to_tokens(&self, output: &mut TokenStream2) {
        let Self {
            name,
-            guard,
            ast,
            args:
                Args {
                    path,
                    guards,
                    wrappers,
+                    methods,
                },
            resource_type,
        } = self;
        let resource_name = name.to_string();
+        let method_guards = {
+            let mut others = methods.iter();
+            // unwrapping since length is checked to be at least one
+            let first = others.next().unwrap();
+
+            if methods.len() > 1 {
+                quote! {
+                    .guard(
+                        actix_web::guard::Any(actix_web::guard::#first())
+                            #(.or(actix_web::guard::#others()))*
+                    )
+                }
+            } else {
+                quote! {
+                    .guard(actix_web::guard::#first())
+                }
+            }
+        };
+
        let stream = quote! {
            #[allow(non_camel_case_types, missing_docs)]
            pub struct #name;
@ -214,7 +295,7 @@ impl ToTokens for Route {
                    #ast
                    let __resource = actix_web::Resource::new(#path)
                        .name(#resource_name)
-                        .guard(actix_web::guard::#guard())
+                        #method_guards
                        #(.guard(actix_web::guard::fn_guard(#guards)))*
                        #(.wrap(#wrappers))*
                        .#resource_type(#name);
@ -228,13 +309,13 @@ impl ToTokens for Route {
    }
 }

-pub(crate) fn generate(
+pub(crate) fn with_method(
+    method: Option<MethodType>,
    args: TokenStream,
    input: TokenStream,
-    guard: GuardType,
 ) -> TokenStream {
    let args = parse_macro_input!(args as syn::AttributeArgs);
-    match Route::new(args, input, guard) {
+    match Route::new(args, input, method) {
        Ok(route) => route.into_token_stream().into(),
        Err(err) => err.to_compile_error().into(),
    }
--- a/actix-web-codegen/tests/test_macro.rs
+++ b/actix-web-codegen/tests/test_macro.rs
@ -5,7 +5,9 @@ use std::task::{Context, Poll};
 use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
 use actix_web::http::header::{HeaderName, HeaderValue};
 use actix_web::{http, test, web::Path, App, Error, HttpResponse, Responder};
-use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, trace};
+use actix_web_codegen::{
+    connect, delete, get, head, options, patch, post, put, route, trace,
+};
 use futures_util::future;

 // Make sure that we can name function as 'config'
@ -79,6 +81,11 @@ async fn get_param_test(_: Path<String>) -> impl Responder {
    HttpResponse::Ok()
 }

+#[route("/multi", method = "GET", method = "POST", method = "HEAD")]
+async fn route_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
 pub struct ChangeStatusCode;

 impl<S, B> Transform<S> for ChangeStatusCode
@ -172,6 +179,7 @@ async fn test_body() {
            .service(trace_test)
            .service(patch_test)
            .service(test_handler)
+            .service(route_test)
    });
    let request = srv.request(http::Method::GET, srv.url("/test"));
    let response = request.send().await.unwrap();
@ -210,6 +218,22 @@ async fn test_body() {
    let request = srv.request(http::Method::GET, srv.url("/test"));
    let response = request.send().await.unwrap();
    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/multi"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::POST, srv.url("/multi"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::HEAD, srv.url("/multi"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::PATCH, srv.url("/multi"));
+    let response = request.send().await.unwrap();
+    assert!(!response.status().is_success());
 }

 #[actix_rt::test]
--- a/actix-web-codegen/tests/trybuild.rs
+++ b/actix-web-codegen/tests/trybuild.rs
@ -0,0 +1,36 @@
+#[test]
+fn compile_macros() {
+    let t = trybuild::TestCases::new();
+
+    t.pass("tests/trybuild/simple.rs");
+    t.compile_fail("tests/trybuild/simple-fail.rs");
+
+    t.pass("tests/trybuild/route-ok.rs");
+
+    test_route_duplicate_unexpected_method(&t);
+    test_route_missing_method(&t)
+}
+
+#[rustversion::stable(1.42)]
+fn test_route_missing_method(t: &trybuild::TestCases) {
+    t.compile_fail("tests/trybuild/route-missing-method-fail-msrv.rs");
+}
+
+#[rustversion::not(stable(1.42))]
+#[rustversion::not(nightly)]
+fn test_route_missing_method(t: &trybuild::TestCases) {
+    t.compile_fail("tests/trybuild/route-missing-method-fail.rs");
+}
+
+#[rustversion::nightly]
+fn test_route_missing_method(_t: &trybuild::TestCases) {}
+
+// FIXME: Re-test them on nightly once rust-lang/rust#77993 is fixed.
+#[rustversion::not(nightly)]
+fn test_route_duplicate_unexpected_method(t: &trybuild::TestCases) {
+    t.compile_fail("tests/trybuild/route-duplicate-method-fail.rs");
+    t.compile_fail("tests/trybuild/route-unexpected-method-fail.rs");
+}
+
+#[rustversion::nightly]
+fn test_route_duplicate_unexpected_method(_t: &trybuild::TestCases) {}
--- a/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.rs
+++ b/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.rs
@ -0,0 +1,17 @@
+use actix_web_codegen::*;
+
+#[route("/", method="GET", method="GET")]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::{App, test};
+
+    let srv = test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
--- a/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
@ -0,0 +1,11 @@
+error: HTTP method defined more than once: `GET`
+ --> $DIR/route-duplicate-method-fail.rs:3:35
+  |
+3 | #[route("/", method="GET", method="GET")]
+  |                                   ^^^^^
+
+error[E0425]: cannot find value `index` in this scope
+  --> $DIR/route-duplicate-method-fail.rs:12:49
+   |
+12 |     let srv = test::start(|| App::new().service(index));
+   |                                                 ^^^^^ not found in this scope
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail-msrv.rs
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail-msrv.rs
@ -0,0 +1 @@
+route-missing-method-fail.rs
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail-msrv.stderr
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail-msrv.stderr
@ -0,0 +1,11 @@
+error: The #[route(..)] macro requires at least one `method` attribute
+ --> $DIR/route-missing-method-fail-msrv.rs:3:1
+  |
+3 | #[route("/")]
+  | ^^^^^^^^^^^^^
+
+error[E0425]: cannot find value `index` in this scope
+  --> $DIR/route-missing-method-fail-msrv.rs:12:49
+   |
+12 |     let srv = test::start(|| App::new().service(index));
+   |                                                 ^^^^^ not found in this scope
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail.rs
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail.rs
@ -0,0 +1,17 @@
+use actix_web_codegen::*;
+
+#[route("/")]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::{App, test};
+    
+    let srv = test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
@ -0,0 +1,13 @@
+error: The #[route(..)] macro requires at least one `method` attribute
+ --> $DIR/route-missing-method-fail.rs:3:1
+  |
+3 | #[route("/")]
+  | ^^^^^^^^^^^^^
+  |
+  = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0425]: cannot find value `index` in this scope
+  --> $DIR/route-missing-method-fail.rs:12:49
+   |
+12 |     let srv = test::start(|| App::new().service(index));
+   |                                                 ^^^^^ not found in this scope
--- a/actix-web-codegen/tests/trybuild/route-ok.rs
+++ b/actix-web-codegen/tests/trybuild/route-ok.rs
@ -0,0 +1,17 @@
+use actix_web_codegen::*;
+
+#[route("/", method="GET", method="HEAD")]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::{App, test};
+
+    let srv = test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
--- a/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.rs
+++ b/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.rs
@ -0,0 +1,17 @@
+use actix_web_codegen::*;
+
+#[route("/", method="UNEXPECTED")]
+async fn index() -> String {
+    "Hello World!".to_owned()
+}
+
+#[actix_web::main]
+async fn main() {
+    use actix_web::{App, test};
+
+    let srv = test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
--- a/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-unexpected-method-fail.stderr
@ -0,0 +1,11 @@
+error: Unexpected HTTP method: `UNEXPECTED`
+ --> $DIR/route-unexpected-method-fail.rs:3:21
+  |
+3 | #[route("/", method="UNEXPECTED")]
+  |                     ^^^^^^^^^^^^
+
+error[E0425]: cannot find value `index` in this scope
+  --> $DIR/route-unexpected-method-fail.rs:12:49
+   |
+12 |     let srv = test::start(|| App::new().service(index));
+   |                                                 ^^^^^ not found in this scope
--- a/actix-web-codegen/tests/trybuild/simple-fail.rs
+++ b/actix-web-codegen/tests/trybuild/simple-fail.rs
@ -0,0 +1,30 @@
+use actix_web_codegen::*;
+
+#[get("/one", other)]
+async fn one() -> String {
+    "Hello World!".to_owned()
+}
+
+#[post(/two)]
+async fn two() -> String {
+    "Hello World!".to_owned()
+}
+
+static PATCH_PATH: &str = "/three";
+
+#[patch(PATCH_PATH)]
+async fn three() -> String {
+    "Hello World!".to_owned()
+}
+
+#[delete("/four", "/five")]
+async fn four() -> String {
+    "Hello World!".to_owned()
+}
+
+#[delete("/five", method="GET")]
+async fn five() -> String {
+    "Hello World!".to_owned()
+}
+
+fn main() {}
--- a/actix-web-codegen/tests/trybuild/simple-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/simple-fail.stderr
@ -0,0 +1,29 @@
+error: Unknown attribute.
+ --> $DIR/simple-fail.rs:3:15
+  |
+3 | #[get("/one", other)]
+  |               ^^^^^
+
+error: expected identifier or literal
+ --> $DIR/simple-fail.rs:8:8
+  |
+8 | #[post(/two)]
+  |        ^
+
+error: Unknown attribute.
+  --> $DIR/simple-fail.rs:15:9
+   |
+15 | #[patch(PATCH_PATH)]
+   |         ^^^^^^^^^^
+
+error: Multiple paths specified! Should be only one!
+  --> $DIR/simple-fail.rs:20:19
+   |
+20 | #[delete("/four", "/five")]
+   |                   ^^^^^^^
+
+error: HTTP method forbidden here. To handle multiple methods, use `route` instead
+  --> $DIR/simple-fail.rs:25:19
+   |
+25 | #[delete("/five", method="GET")]
+   |                   ^^^^^^^^^^^^
--- a/actix-web-codegen/tests/trybuild/simple.rs
+++ b/actix-web-codegen/tests/trybuild/simple.rs
@ -0,0 +1,16 @@
+use actix_web::{Responder, HttpResponse, App, test};
+use actix_web_codegen::*;
+
+#[get("/config")]
+async fn config() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[actix_web::main]
+async fn main() {
+    let srv = test::start(|| App::new().service(config));
+
+    let request = srv.get("/config");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
--- a/awc/CHANGES.md
+++ b/awc/CHANGES.md
@ -3,6 +3,20 @@
 ## Unreleased - 2020-xx-xx


+## 2.0.1 - 2020-xx-xx
+### Changed
+* Upgrade `base64` to `0.13`. [#1744]
+* Deprecate `ClientRequest::{if_some, if_true}`. [#1760]
+
+### Fixed
+* 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
+[#1760]: https://github.com/actix/actix-web/pull/1760
+[#1744]: https://github.com/actix/actix-web/pull/1744
+
+
 ## 2.0.0 - 2020-09-11
 ### Changed
 * `Client::build` was renamed to `Client::builder`.
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@ -1,8 +1,8 @@
 [package]
 name = "awc"
-version = "2.0.0"
+version = "2.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Async HTTP client library that uses the Actix runtime."
+description = "Async HTTP and WebSocket client library built on the Actix ecosystem"
 readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "web"]
 homepage = "https://actix.rs"
@ -42,8 +42,9 @@ actix-service = "1.0.6"
 actix-http = "2.0.0"
 actix-rt = "1.0.0"

-base64 = "0.12"
+base64 = "0.13"
 bytes = "0.5.3"
+cfg-if = "1.0"
 derive_more = "0.99.2"
 futures-core = { version = "0.3.5", default-features = false }
 log =" 0.4"
--- a/awc/README.md
+++ b/awc/README.md
@ -1,14 +1,19 @@
-# Actix http client [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/awc)](https://crates.io/crates/awc) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# awc (Actix Web Client)

-An HTTP Client
+> Async HTTP and WebSocket client library.

-## Documentation & community resources
+[![crates.io](https://img.shields.io/crates/v/awc?label=latest)](https://crates.io/crates/awc)
+[![Documentation](https://docs.rs/awc/badge.svg?version=2.0.1)](https://docs.rs/awc/2.0.1)
+![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/awc)
+[![Dependency Status](https://deps.rs/crate/awc/2.0.1/status.svg)](https://deps.rs/crate/awc/2.0.1)
+[![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/awc/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [awc](https://crates.io/crates/awc)
-* Minimum supported Rust version: 1.40 or later
+## Documentation & Resources
+
+- [API Documentation](https://docs.rs/awc/2.0.1)
+- [Example Project](https://github.com/actix/examples/tree/HEAD/awc_https)
+- [Chat on Gitter](https://gitter.im/actix/actix-web)
+- Minimum Supported Rust Version (MSRV): 1.42.0

 ## Example

--- a/awc/src/lib.rs
+++ b/awc/src/lib.rs
@ -1,11 +1,4 @@
-#![deny(rust_2018_idioms)]
-#![allow(
-    clippy::type_complexity,
-    clippy::borrow_interior_mutable_const,
-    clippy::needless_doctest_main
-)]
-
-//! `awc` is a HTTP and WebSocket client library built using the Actix ecosystem.
+//! `awc` is a HTTP and WebSocket client library built on the Actix ecosystem.
 //!
 //! ## Making a GET request
 //!
@ -91,6 +84,15 @@
 //! # }
 //! ```

+#![deny(rust_2018_idioms)]
+#![allow(
+    clippy::type_complexity,
+    clippy::borrow_interior_mutable_const,
+    clippy::needless_doctest_main
+)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
 use std::cell::RefCell;
 use std::convert::TryFrom;
 use std::rc::Rc;
--- a/awc/src/request.rs
+++ b/awc/src/request.rs
@ -21,10 +21,15 @@ use crate::frozen::FrozenClientRequest;
 use crate::sender::{PrepForSendingError, RequestSender, SendClientRequest};
 use crate::ClientConfig;

-#[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-const HTTPS_ENCODING: &str = "br, gzip, deflate";
-#[cfg(not(any(feature = "flate2-zlib", feature = "flate2-rust")))]
-const HTTPS_ENCODING: &str = "br";
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))] {
+        const HTTPS_ENCODING: &str = "br, gzip, deflate";
+    } else if #[cfg(feature = "compress")] {
+        const HTTPS_ENCODING: &str = "br";
+    } else {
+        const HTTPS_ENCODING: &str = "identity";
+    }
+}

 /// An HTTP Client request builder
 ///
@ -349,8 +354,9 @@ impl ClientRequest {
        self
    }

-    /// This method calls provided closure with builder reference if
-    /// value is `true`.
+    /// This method calls provided closure with builder reference if value is `true`.
+    #[doc(hidden)]
+    #[deprecated = "Use an if statement."]
    pub fn if_true<F>(self, value: bool, f: F) -> Self
    where
        F: FnOnce(ClientRequest) -> ClientRequest,
@ -362,8 +368,9 @@ impl ClientRequest {
        }
    }

-    /// This method calls provided closure with builder reference if
-    /// value is `Some`.
+    /// This method calls provided closure with builder reference if value is `Some`.
+    #[doc(hidden)]
+    #[deprecated = "Use an if-let construction."]
    pub fn if_some<T, F>(self, value: Option<T>, f: F) -> Self
    where
        F: FnOnce(T, ClientRequest) -> ClientRequest,
@ -596,20 +603,27 @@ mod tests {

    #[actix_rt::test]
    async fn test_basics() {
-        let mut req = Client::new()
+        let req = Client::new()
            .put("/")
            .version(Version::HTTP_2)
            .set(header::Date(SystemTime::now().into()))
            .content_type("plain/text")
-            .if_true(true, |req| req.header(header::SERVER, "awc"))
-            .if_true(false, |req| req.header(header::EXPECT, "awc"))
-            .if_some(Some("server"), |val, req| {
-                req.header(header::USER_AGENT, val)
-            })
-            .if_some(Option::<&str>::None, |_, req| {
-                req.header(header::ALLOW, "1")
-            })
-            .content_length(100);
+            .header(header::SERVER, "awc");
+
+        let req = if let Some(val) = Some("server") {
+            req.header(header::USER_AGENT, val)
+        } else {
+            req
+        };
+
+        let req = if let Some(_val) = Option::<&str>::None {
+            req.header(header::ALLOW, "1")
+        } else {
+            req
+        };
+
+        let mut req = req.content_length(100);
+
        assert!(req.headers().contains_key(header::CONTENT_TYPE));
        assert!(req.headers().contains_key(header::DATE));
        assert!(req.headers().contains_key(header::SERVER));
@ -617,6 +631,7 @@ mod tests {
        assert!(!req.headers().contains_key(header::ALLOW));
        assert!(!req.headers().contains_key(header::EXPECT));
        assert_eq!(req.head.version, Version::HTTP_2);
+
        let _ = req.headers_mut();
        let _ = req.send_body("");
    }
--- a/examples/on_connect.rs
+++ b/examples/on_connect.rs
@ -0,0 +1,51 @@
+//! This example shows how to use `actix_web::HttpServer::on_connect` to access a lower-level socket
+//! properties and pass them to a handler through request-local data.
+//!
+//! For an example of extracting a client TLS certificate, see:
+//! <https://github.com/actix/examples/tree/HEAD/rustls-client-cert>
+
+use std::{any::Any, env, io, net::SocketAddr};
+
+use actix_web::{dev::Extensions, rt::net::TcpStream, web, App, HttpServer};
+
+#[derive(Debug, Clone)]
+struct ConnectionInfo {
+    bind: SocketAddr,
+    peer: SocketAddr,
+    ttl: Option<u32>,
+}
+
+async fn route_whoami(conn_info: web::ReqData<ConnectionInfo>) -> String {
+    format!(
+        "Here is some info about your connection:\n\n{:#?}",
+        conn_info
+    )
+}
+
+fn get_conn_info(connection: &dyn Any, data: &mut Extensions) {
+    if let Some(sock) = connection.downcast_ref::<TcpStream>() {
+        data.insert(ConnectionInfo {
+            bind: sock.local_addr().unwrap(),
+            peer: sock.peer_addr().unwrap(),
+            ttl: sock.ttl().ok(),
+        });
+    } else {
+        unreachable!("connection should only be plaintext since no TLS is set up");
+    }
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    if env::var("RUST_LOG").is_err() {
+        env::set_var("RUST_LOG", "info");
+    }
+
+    env_logger::init();
+
+    HttpServer::new(|| App::new().default_service(web::to(route_whoami)))
+        .on_connect(get_conn_info)
+        .bind(("127.0.0.1", 8080))?
+        .workers(1)
+        .run()
+        .await
+}
--- a/1
+++ b/1
@ -1 +0,0 @@
-1.42.0
--- a/src/app.rs
+++ b/src/app.rs
@ -183,6 +183,7 @@ where
        self.data.extend(cfg.data);
        self.services.extend(cfg.services);
        self.external.extend(cfg.external);
+        self.extensions.extend(cfg.extensions);
        self
    }

@ -459,8 +460,8 @@ where
 {
    fn into_factory(self) -> AppInit<T, B> {
        AppInit {
-            data: Rc::new(self.data),
-            data_factories: Rc::new(self.data_factories),
+            data: self.data.into_boxed_slice().into(),
+            data_factories: self.data_factories.into_boxed_slice().into(),
            endpoint: self.endpoint,
            services: Rc::new(RefCell::new(self.services)),
            external: RefCell::new(self.external),
--- a/src/app_service.rs
+++ b/src/app_service.rs
@ -39,8 +39,8 @@ where
 {
    pub(crate) endpoint: T,
    pub(crate) extensions: RefCell<Option<Extensions>>,
-    pub(crate) data: Rc<Vec<Box<dyn DataFactory>>>,
-    pub(crate) data_factories: Rc<Vec<FnDataFactory>>,
+    pub(crate) data: Rc<[Box<dyn DataFactory>]>,
+    pub(crate) data_factories: Rc<[FnDataFactory]>,
    pub(crate) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
    pub(crate) default: Option<Rc<HttpNewService>>,
    pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
@ -88,15 +88,15 @@ where
        // complete pipeline creation
        *self.factory_ref.borrow_mut() = Some(AppRoutingFactory {
            default,
-            services: Rc::new(
-                services
-                    .into_iter()
-                    .map(|(mut rdef, srv, guards, nested)| {
-                        rmap.add(&mut rdef, nested);
-                        (rdef, srv, RefCell::new(guards))
-                    })
-                    .collect(),
-            ),
+            services: services
+                .into_iter()
+                .map(|(mut rdef, srv, guards, nested)| {
+                    rmap.add(&mut rdef, nested);
+                    (rdef, srv, RefCell::new(guards))
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+                .into(),
        });

        // external resources
@ -147,7 +147,7 @@ where

    rmap: Rc<ResourceMap>,
    config: AppConfig,
-    data: Rc<Vec<Box<dyn DataFactory>>>,
+    data: Rc<[Box<dyn DataFactory>]>,
    extensions: Option<Extensions>,

    _t: PhantomData<B>,
@ -273,7 +273,7 @@ where
 }

 pub struct AppRoutingFactory {
-    services: Rc<Vec<(ResourceDef, HttpNewService, RefCell<Option<Guards>>)>>,
+    services: Rc<[(ResourceDef, HttpNewService, RefCell<Option<Guards>>)]>,
    default: Rc<HttpNewService>,
 }

--- a/src/config.rs
+++ b/src/config.rs
@ -31,7 +31,7 @@ pub struct AppService {
        Option<Guards>,
        Option<Rc<ResourceMap>>,
    )>,
-    service_data: Rc<Vec<Box<dyn DataFactory>>>,
+    service_data: Rc<[Box<dyn DataFactory>]>,
 }

 impl AppService {
@ -39,7 +39,7 @@ impl AppService {
    pub(crate) fn new(
        config: AppConfig,
        default: Rc<HttpNewService>,
-        service_data: Rc<Vec<Box<dyn DataFactory>>>,
+        service_data: Rc<[Box<dyn DataFactory>]>,
    ) -> Self {
        AppService {
            config,
@ -178,6 +178,7 @@ pub struct ServiceConfig {
    pub(crate) services: Vec<Box<dyn AppServiceFactory>>,
    pub(crate) data: Vec<Box<dyn DataFactory>>,
    pub(crate) external: Vec<ResourceDef>,
+    pub(crate) extensions: Extensions,
 }

 impl ServiceConfig {
@ -186,6 +187,7 @@ impl ServiceConfig {
            services: Vec::new(),
            data: Vec::new(),
            external: Vec::new(),
+            extensions: Extensions::new(),
        }
    }

@ -198,6 +200,14 @@ impl ServiceConfig {
        self
    }

+    /// Set arbitrary data item.
+    ///
+    /// This is same as `App::data()` method.
+    pub fn app_data<U: 'static>(&mut self, ext: U) -> &mut Self {
+        self.extensions.insert(ext);
+        self
+    }
+
    /// Configure route for a specific path.
    ///
    /// This is same as `App::route()` method.
@ -254,13 +264,16 @@ mod tests {
    async fn test_data() {
        let cfg = |cfg: &mut ServiceConfig| {
            cfg.data(10usize);
+            cfg.app_data(15u8);
        };

-        let mut srv =
-            init_service(App::new().configure(cfg).service(
-                web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
-            ))
-            .await;
+        let mut srv = init_service(App::new().configure(cfg).service(
+            web::resource("/").to(|_: web::Data<usize>, req: HttpRequest| {
+                assert_eq!(*req.app_data::<u8>().unwrap(), 15u8);
+                HttpResponse::Ok()
+            }),
+        ))
+        .await;
        let req = TestRequest::default().to_request();
        let resp = srv.call(req).await.unwrap();
        assert_eq!(resp.status(), StatusCode::OK);
--- a/src/data.rs
+++ b/src/data.rs
@ -1,3 +1,4 @@
+use std::any::type_name;
 use std::ops::Deref;
 use std::sync::Arc;

@ -19,25 +20,20 @@ pub(crate) type FnDataFactory =

 /// Application data.
 ///
-/// Application data is an arbitrary data attached to the app.
-/// Application data is available to all routes and could be added
-/// during application configuration process
-/// with `App::data()` method.
+/// Application level data is a piece of arbitrary data attached to the app, scope, or resource.
+/// Application data is available to all routes and can be added during the application
+/// configuration process via `App::data()`.
 ///
-/// Application data could be accessed by using `Data<T>`
-/// extractor where `T` is data type.
+/// Application data can be accessed by using `Data<T>` extractor where `T` is data type.
 ///
-/// **Note**: http server accepts an application factory rather than
-/// an application instance. Http server constructs an application
-/// instance for each thread, thus application data must be constructed
-/// multiple times. If you want to share data between different
-/// threads, a shareable object should be used, e.g. `Send + Sync`. Application
-/// data does not need to be `Send` or `Sync`. Internally `Data` type
-/// uses `Arc`. if your data implements `Send` + `Sync` traits you can
-/// use `web::Data::new()` and avoid double `Arc`.
+/// **Note**: http server accepts an application factory rather than an application instance. HTTP
+/// server constructs an application instance for each thread, thus application data must be
+/// constructed multiple times. If you want to share data between different threads, a shareable
+/// object should be used, e.g. `Send + Sync`. Application data does not need to be `Send`
+/// or `Sync`. Internally `Data` uses `Arc`.
 ///
-/// If route data is not set for a handler, using `Data<T>` extractor would
-/// cause *Internal Server Error* response.
+/// If route data is not set for a handler, using `Data<T>` extractor would cause *Internal
+/// Server Error* response.
 ///
 /// ```rust
 /// use std::sync::Mutex;
@ -47,7 +43,7 @@ pub(crate) type FnDataFactory =
 ///     counter: usize,
 /// }
 ///
-/// /// Use `Data<T>` extractor to access data in handler.
+/// /// Use the `Data<T>` extractor to access data in a handler.
 /// async fn index(data: web::Data<Mutex<MyData>>) -> impl Responder {
 ///     let mut data = data.lock().unwrap();
 ///     data.counter += 1;
@ -66,14 +62,10 @@ pub(crate) type FnDataFactory =
 /// }
 /// ```
 #[derive(Debug)]
-pub struct Data<T>(Arc<T>);
+pub struct Data<T: ?Sized>(Arc<T>);

 impl<T> Data<T> {
    /// Create new `Data` instance.
-    ///
-    /// Internally `Data` type uses `Arc`. if your data implements
-    /// `Send` + `Sync` traits you can use `web::Data::new()` and
-    /// avoid double `Arc`.
    pub fn new(state: T) -> Data<T> {
        Data(Arc::new(state))
    }
@ -89,7 +81,7 @@ impl<T> Data<T> {
    }
 }

-impl<T> Deref for Data<T> {
+impl<T: ?Sized> Deref for Data<T> {
    type Target = Arc<T>;

    fn deref(&self) -> &Arc<T> {
@ -97,19 +89,19 @@ impl<T> Deref for Data<T> {
    }
 }

-impl<T> Clone for Data<T> {
+impl<T: ?Sized> Clone for Data<T> {
    fn clone(&self) -> Data<T> {
        Data(self.0.clone())
    }
 }

-impl<T> From<Arc<T>> for Data<T> {
+impl<T: ?Sized> From<Arc<T>> for Data<T> {
    fn from(arc: Arc<T>) -> Self {
        Data(arc)
    }
 }

-impl<T: 'static> FromRequest for Data<T> {
+impl<T: ?Sized + 'static> FromRequest for Data<T> {
    type Config = ();
    type Error = Error;
    type Future = Ready<Result<Self, Error>>;
@ -121,8 +113,9 @@ impl<T: 'static> FromRequest for Data<T> {
        } else {
            log::debug!(
                "Failed to construct App-level Data extractor. \
-                 Request path: {:?}",
-                req.path()
+                 Request path: {:?} (type: {})",
+                req.path(),
+                type_name::<T>(),
            );
            err(ErrorInternalServerError(
                "App data is not configured, to configure use App::data()",
@ -131,7 +124,7 @@ impl<T: 'static> FromRequest for Data<T> {
    }
 }

-impl<T: 'static> DataFactory for Data<T> {
+impl<T: ?Sized + 'static> DataFactory for Data<T> {
    fn create(&self, extensions: &mut Extensions) -> bool {
        if !extensions.contains::<Data<T>>() {
            extensions.insert(Data(self.0.clone()));
@ -293,4 +286,24 @@ mod tests {
        let data_from_arc = Data::from(Arc::new(String::from("test-123")));
        assert_eq!(data_new.0, data_from_arc.0)
    }
+
+    #[actix_rt::test]
+    async fn test_data_from_dyn_arc() {
+        trait TestTrait {
+            fn get_num(&self) -> i32;
+        }
+        struct A {}
+        impl TestTrait for A {
+            fn get_num(&self) -> i32 {
+                42
+            }
+        }
+        // This works when Sized is required
+        let dyn_arc_box: Arc<Box<dyn TestTrait>> = Arc::new(Box::new(A {}));
+        let data_arc_box = Data::from(dyn_arc_box);
+        // This works when Data Sized Bound is removed
+        let dyn_arc: Arc<dyn TestTrait> = Arc::new(A {});
+        let data_arc = Data::from(dyn_arc);
+        assert_eq!(data_arc_box.get_num(), data_arc.get_num())
+    }
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@ -81,6 +81,7 @@ mod handler;
 mod info;
 pub mod middleware;
 mod request;
+mod request_data;
 mod resource;
 mod responder;
 mod rmap;
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@ -13,7 +13,7 @@ use actix_service::{Service, Transform};
 use bytes::Bytes;
 use futures_util::future::{ok, Ready};
 use log::debug;
-use regex::Regex;
+use regex::{Regex, RegexSet};
 use time::OffsetDateTime;

 use crate::dev::{BodySize, MessageBody, ResponseBody};
@ -34,21 +34,19 @@ use crate::HttpResponse;
 /// Default `Logger` could be created with `default` method, it uses the
 /// default format:
 ///
-/// ```ignore
-///  %a "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
+/// ```plain
+/// %a "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
 /// ```
+///
 /// ```rust
-/// use actix_web::middleware::Logger;
-/// use actix_web::App;
+/// use actix_web::{middleware::Logger, App};
 ///
-/// fn main() {
-///     std::env::set_var("RUST_LOG", "actix_web=info");
-///     env_logger::init();
+/// std::env::set_var("RUST_LOG", "actix_web=info");
+/// env_logger::init();
 ///
-///     let app = App::new()
-///         .wrap(Logger::default())
-///         .wrap(Logger::new("%a %{User-Agent}i"));
-/// }
+/// let app = App::new()
+///     .wrap(Logger::default())
+///     .wrap(Logger::new("%a %{User-Agent}i"));
 /// ```
 ///
 /// ## Format
@ -80,6 +78,8 @@ use crate::HttpResponse;
 ///
 /// `%{FOO}e`  os.environ['FOO']
 ///
+/// `%{FOO}xi`  [custom request replacement](Logger::custom_request_replace) labelled "FOO"
+///
 /// # Security
 ///  **\*** It is calculated using
 ///  [`ConnectionInfo::realip_remote_addr()`](../dev/struct.ConnectionInfo.html#method.realip_remote_addr)
@ -92,6 +92,7 @@ pub struct Logger(Rc<Inner>);
 struct Inner {
    format: Format,
    exclude: HashSet<String>,
+    exclude_regex: RegexSet,
 }

 impl Logger {
@ -100,6 +101,7 @@ impl Logger {
        Logger(Rc::new(Inner {
            format: Format::new(format),
            exclude: HashSet::new(),
+            exclude_regex: RegexSet::empty(),
        }))
    }

@ -111,18 +113,69 @@ impl Logger {
            .insert(path.into());
        self
    }
+
+    /// Ignore and do not log access info for paths that match regex
+    pub fn exclude_regex<T: Into<String>>(mut self, path: T) -> Self {
+        let inner = Rc::get_mut(&mut self.0).unwrap();
+        let mut patterns = inner.exclude_regex.patterns().to_vec();
+        patterns.push(path.into());
+        let regex_set = RegexSet::new(patterns).unwrap();
+        inner.exclude_regex = regex_set;
+        self
+    }
+
+    /// Register a function that receives a ServiceRequest and returns a String for use in the
+    /// log line. The label passed as the first argument should match a replacement substring in
+    /// the logger format like `%{label}xi`.
+    ///
+    /// It is convention to print "-" to indicate no output instead of an empty string.
+    ///
+    /// # Example
+    /// ```rust
+    /// # use actix_web::{http::HeaderValue, middleware::Logger};
+    /// # fn parse_jwt_id (_req: Option<&HeaderValue>) -> String { "jwt_uid".to_owned() }
+    /// Logger::new("example %{JWT_ID}xi")
+    ///     .custom_request_replace("JWT_ID", |req| parse_jwt_id(req.headers().get("Authorization")));
+    /// ```
+    pub fn custom_request_replace(
+        mut self,
+        label: &str,
+        f: impl Fn(&ServiceRequest) -> String + 'static,
+    ) -> Self {
+        let inner = Rc::get_mut(&mut self.0).unwrap();
+
+        let ft = inner.format.0.iter_mut().find(|ft| {
+            matches!(ft, FormatText::CustomRequest(unit_label, _) if label == unit_label)
+        });
+
+        if let Some(FormatText::CustomRequest(_, request_fn)) = ft {
+            // replace into None or previously registered fn using same label
+            request_fn.replace(CustomRequestFn {
+                inner_fn: Rc::new(f),
+            });
+        } else {
+            // non-printed request replacement function diagnostic
+            debug!(
+                "Attempted to register custom request logging function for nonexistent label: {}",
+                label
+            );
+        }
+
+        self
+    }
 }

 impl Default for Logger {
    /// Create `Logger` middleware with format:
    ///
-    /// ```ignore
+    /// ```plain
    /// %a "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
    /// ```
    fn default() -> Logger {
        Logger(Rc::new(Inner {
            format: Format::default(),
            exclude: HashSet::new(),
+            exclude_regex: RegexSet::empty(),
        }))
    }
 }
@ -140,6 +193,17 @@ where
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
+        for unit in &self.0.format.0 {
+            // missing request replacement function diagnostic
+            if let FormatText::CustomRequest(label, None) = unit {
+                debug!(
+                    "No custom request replacement function was registered for label {} in\
+                    logger format.",
+                    label
+                );
+            }
+        }
+
        ok(LoggerMiddleware {
            service,
            inner: self.0.clone(),
@ -168,7 +232,9 @@ where
    }

    fn call(&mut self, req: ServiceRequest) -> Self::Future {
-        if self.inner.exclude.contains(req.path()) {
+        if self.inner.exclude.contains(req.path())
+            || self.inner.exclude_regex.is_match(req.path())
+        {
            LoggerResponse {
                fut: self.service.call(req),
                format: None,
@ -296,7 +362,6 @@ impl<B: MessageBody> MessageBody for StreamLog<B> {
 /// A formatting style for the `Logger`, consisting of multiple
 /// `FormatText`s concatenated into one line.
 #[derive(Clone)]
-#[doc(hidden)]
 struct Format(Vec<FormatText>);

 impl Default for Format {
@ -312,7 +377,8 @@ impl Format {
    /// Returns `None` if the format string syntax is incorrect.
    pub fn new(s: &str) -> Format {
        log::trace!("Access log format: {}", s);
-        let fmt = Regex::new(r"%(\{([A-Za-z0-9\-_]+)\}([aioe])|[atPrUsbTD]?)").unwrap();
+        let fmt =
+            Regex::new(r"%(\{([A-Za-z0-9\-_]+)\}([aioe]|xi)|[atPrUsbTD]?)").unwrap();

        let mut idx = 0;
        let mut results = Vec::new();
@ -340,6 +406,7 @@ impl Format {
                        HeaderName::try_from(key.as_str()).unwrap(),
                    ),
                    "e" => FormatText::EnvironHeader(key.as_str().to_owned()),
+                    "xi" => FormatText::CustomRequest(key.as_str().to_owned(), None),
                    _ => unreachable!(),
                })
            } else {
@ -369,7 +436,9 @@ impl Format {
 /// A string of text to be logged. This is either one of the data
 /// fields supported by the `Logger`, or a custom `String`.
 #[doc(hidden)]
+#[non_exhaustive]
 #[derive(Debug, Clone)]
+// TODO: remove pub on next breaking change
 pub enum FormatText {
    Str(String),
    Percent,
@ -385,6 +454,26 @@ pub enum FormatText {
    RequestHeader(HeaderName),
    ResponseHeader(HeaderName),
    EnvironHeader(String),
+    CustomRequest(String, Option<CustomRequestFn>),
+}
+
+// TODO: remove pub on next breaking change
+#[doc(hidden)]
+#[derive(Clone)]
+pub struct CustomRequestFn {
+    inner_fn: Rc<dyn Fn(&ServiceRequest) -> String>,
+}
+
+impl CustomRequestFn {
+    fn call(&self, req: &ServiceRequest) -> String {
+        (self.inner_fn)(req)
+    }
+}
+
+impl fmt::Debug for CustomRequestFn {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("custom_request_fn")
+    }
 }

 impl FormatText {
@ -441,7 +530,7 @@ impl FormatText {
    }

    fn render_request(&mut self, now: OffsetDateTime, req: &ServiceRequest) {
-        match *self {
+        match &*self {
            FormatText::RequestLine => {
                *self = if req.query_string().is_empty() {
                    FormatText::Str(format!(
@ -493,11 +582,20 @@ impl FormatText {
                };
                *self = s;
            }
+            FormatText::CustomRequest(_, request_fn) => {
+                let s = match request_fn {
+                    Some(f) => FormatText::Str(f.call(req)),
+                    None => FormatText::Str("-".to_owned()),
+                };
+
+                *self = s;
+            }
            _ => (),
        }
    }
 }

+/// Converter to get a String from something that writes to a Formatter.
 pub(crate) struct FormatDisplay<'a>(
    &'a dyn Fn(&mut Formatter<'_>) -> Result<(), fmt::Error>,
 );
@ -515,7 +613,7 @@ mod tests {

    use super::*;
    use crate::http::{header, StatusCode};
-    use crate::test::TestRequest;
+    use crate::test::{self, TestRequest};

    #[actix_rt::test]
    async fn test_logger() {
@ -538,6 +636,28 @@ mod tests {
        let _res = srv.call(req).await;
    }

+    #[actix_rt::test]
+    async fn test_logger_exclude_regex() {
+        let srv = |req: ServiceRequest| {
+            ok(req.into_response(
+                HttpResponse::build(StatusCode::OK)
+                    .header("X-Test", "ttt")
+                    .finish(),
+            ))
+        };
+        let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test")
+            .exclude_regex("\\w");
+
+        let mut srv = logger.new_transform(srv.into_service()).await.unwrap();
+
+        let req = TestRequest::with_header(
+            header::USER_AGENT,
+            header::HeaderValue::from_static("ACTIX-WEB"),
+        )
+        .to_srv_request();
+        let _res = srv.call(req).await.unwrap();
+    }
+
    #[actix_rt::test]
    async fn test_url_path() {
        let mut format = Format::new("%T %U");
@ -662,4 +782,45 @@ mod tests {
        println!("{}", s);
        assert!(s.contains("192.0.2.60"));
    }
+
+    #[actix_rt::test]
+    async fn test_custom_closure_log() {
+        let mut logger = Logger::new("test %{CUSTOM}xi")
+            .custom_request_replace("CUSTOM", |_req: &ServiceRequest| -> String {
+                String::from("custom_log")
+            });
+        let mut unit = Rc::get_mut(&mut logger.0).unwrap().format.0[1].clone();
+
+        let label = match &unit {
+            FormatText::CustomRequest(label, _) => label,
+            ft => panic!("expected CustomRequest, found {:?}", ft),
+        };
+
+        assert_eq!(label, "CUSTOM");
+
+        let req = TestRequest::default().to_srv_request();
+        let now = OffsetDateTime::now_utc();
+
+        unit.render_request(now, &req);
+
+        let render = |fmt: &mut Formatter<'_>| unit.render(fmt, 1024, now);
+
+        let log_output = FormatDisplay(&render).to_string();
+        assert_eq!(log_output, "custom_log");
+    }
+
+    #[actix_rt::test]
+    async fn test_closure_logger_in_middleware() {
+        let captured = "custom log replacement";
+
+        let logger = Logger::new("%{CUSTOM}xi")
+            .custom_request_replace("CUSTOM", move |_req: &ServiceRequest| -> String {
+                captured.to_owned()
+            });
+
+        let mut srv = logger.new_transform(test::ok_service()).await.unwrap();
+
+        let req = TestRequest::default().to_srv_request();
+        srv.call(req).await.unwrap();
+    }
 }
--- a/src/middleware/normalize.rs
+++ b/src/middleware/normalize.rs
@ -17,6 +17,10 @@ pub enum TrailingSlash {
    /// Always add a trailing slash to the end of the path.
    /// This will require all routes to end in a trailing slash for them to be accessible.
    Always,
+    /// Only merge any present multiple trailing slashes.
+    ///
+    /// Note: This option provides the best compatibility with the v2 version of this middlware.
+    MergeOnly,
    /// Trim trailing slashes from the end of the path.
    Trim,
 }
@ -33,7 +37,8 @@ impl Default for TrailingSlash {
 /// Performs following:
 ///
 /// - Merges multiple slashes into one.
-/// - Appends a trailing slash if one is not present, or removes one if present, depending on the supplied `TrailingSlash`.
+/// - Appends a trailing slash if one is not present, removes one if present, or keeps trailing
+///   slashes as-is, depending on the supplied `TrailingSlash` variant.
 ///
 /// ```rust
 /// use actix_web::{web, http, middleware, App, HttpResponse};
@ -79,6 +84,7 @@ where
    }
 }

+#[doc(hidden)]
 pub struct NormalizePathNormalization<S> {
    service: S,
    merge_slash: Regex,
@ -107,12 +113,17 @@ where
        // Either adds a string to the end (duplicates will be removed anyways) or trims all slashes from the end
        let path = match self.trailing_slash_behavior {
            TrailingSlash::Always => original_path.to_string() + "/",
+            TrailingSlash::MergeOnly => original_path.to_string(),
            TrailingSlash::Trim => original_path.trim_end_matches('/').to_string(),
        };

        // normalize multiple /'s to one /
        let path = self.merge_slash.replace_all(&path, "/");

+        // Ensure root paths are still resolvable. If resulting path is blank after previous step
+        // it means the path was one or more slashes. Reduce to single slash.
+        let path = if path.is_empty() { "/" } else { path.as_ref() };
+
        // Check whether the path has been changed
        //
        // This check was previously implemented as string length comparison
@ -158,10 +169,23 @@ mod tests {
        let mut app = init_service(
            App::new()
                .wrap(NormalizePath::default())
+                .service(web::resource("/").to(HttpResponse::Ok))
                .service(web::resource("/v1/something/").to(HttpResponse::Ok)),
        )
        .await;

+        let req = TestRequest::with_uri("/").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
+        let req = TestRequest::with_uri("/?query=test").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
+        let req = TestRequest::with_uri("///").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
        let req = TestRequest::with_uri("/v1//something////").to_request();
        let res = call_service(&mut app, req).await;
        assert!(res.status().is_success());
@ -184,10 +208,24 @@ mod tests {
        let mut app = init_service(
            App::new()
                .wrap(NormalizePath(TrailingSlash::Trim))
+                .service(web::resource("/").to(HttpResponse::Ok))
                .service(web::resource("/v1/something").to(HttpResponse::Ok)),
        )
        .await;

+        // root paths should still work
+        let req = TestRequest::with_uri("/").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
+        let req = TestRequest::with_uri("/?query=test").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
+        let req = TestRequest::with_uri("///").to_request();
+        let res = call_service(&mut app, req).await;
+        assert!(res.status().is_success());
+
        let req = TestRequest::with_uri("/v1/something////").to_request();
        let res = call_service(&mut app, req).await;
        assert!(res.status().is_success());
@ -205,6 +243,38 @@ mod tests {
        assert!(res4.status().is_success());
    }

+    #[actix_rt::test]
+    async fn keep_trailing_slash_unchange() {
+        let mut app = init_service(
+            App::new()
+                .wrap(NormalizePath(TrailingSlash::MergeOnly))
+                .service(web::resource("/").to(HttpResponse::Ok))
+                .service(web::resource("/v1/something").to(HttpResponse::Ok))
+                .service(web::resource("/v1/").to(HttpResponse::Ok)),
+        )
+        .await;
+
+        let tests = vec![
+            ("/", true), // root paths should still work
+            ("/?query=test", true),
+            ("///", true),
+            ("/v1/something////", false),
+            ("/v1/something/", false),
+            ("//v1//something", true),
+            ("/v1/", true),
+            ("/v1", false),
+            ("/v1////", true),
+            ("//v1//", true),
+            ("///v1", false),
+        ];
+
+        for (path, success) in tests {
+            let req = TestRequest::with_uri(path).to_request();
+            let res = call_service(&mut app, req).await;
+            assert_eq!(res.status().is_success(), success);
+        }
+    }
+
    #[actix_rt::test]
    async fn test_in_place_normalization() {
        let srv = |req: ServiceRequest| {
--- a/src/request_data.rs
+++ b/src/request_data.rs
@ -0,0 +1,175 @@
+use std::{any::type_name, ops::Deref};
+
+use actix_http::error::{Error, ErrorInternalServerError};
+use futures_util::future;
+
+use crate::{dev::Payload, FromRequest, HttpRequest};
+
+/// Request-local data extractor.
+///
+/// Request-local data is arbitrary data attached to an individual request, usually
+/// by middleware. It can be set via `extensions_mut` on [`HttpRequest`][htr_ext_mut]
+/// or [`ServiceRequest`][srv_ext_mut].
+///
+/// Unlike app data, request data is dropped when the request has finished processing. This makes it
+/// useful as a kind of messaging system between middleware and request handlers. It uses the same
+/// types-as-keys storage system as app data.
+///
+/// # Mutating Request Data
+/// Note that since extractors must output owned data, only types that `impl Clone` can use this
+/// extractor. A clone is taken of the required request data and can, therefore, not be directly
+/// mutated in-place. To mutate request data, continue to use [`HttpRequest::extensions_mut`] or
+/// re-insert the cloned data back into the extensions map. A `DerefMut` impl is intentionally not
+/// provided to make this potential foot-gun more obvious.
+///
+/// # Example
+/// ```rust,no_run
+/// # use actix_web::{web, HttpResponse, HttpRequest, Responder};
+///
+/// #[derive(Debug, Clone, PartialEq)]
+/// struct FlagFromMiddleware(String);
+///
+/// /// Use the `ReqData<T>` extractor to access request data in a handler.
+/// async fn handler(
+///     req: HttpRequest,
+///     opt_flag: Option<web::ReqData<FlagFromMiddleware>>,
+/// ) -> impl Responder {
+///     // use an optional extractor if the middleware is
+///     // not guaranteed to add this type of requests data
+///     if let Some(flag) = opt_flag {
+///         assert_eq!(&flag.into_inner(), req.extensions().get::<FlagFromMiddleware>().unwrap());
+///     }
+///     
+///     HttpResponse::Ok()
+/// }
+/// ```
+///
+/// [htr_ext_mut]: crate::HttpRequest::extensions_mut
+/// [srv_ext_mut]: crate::dev::ServiceRequest::extensions_mut
+#[derive(Debug, Clone)]
+pub struct ReqData<T: Clone + 'static>(T);
+
+impl<T: Clone + 'static> ReqData<T> {
+    /// Consumes the `ReqData`, returning it's wrapped data.
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T: Clone + 'static> Deref for ReqData<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T: Clone + 'static> FromRequest for ReqData<T> {
+    type Config = ();
+    type Error = Error;
+    type Future = future::Ready<Result<Self, Error>>;
+
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        if let Some(st) = req.extensions().get::<T>() {
+            future::ok(ReqData(st.clone()))
+        } else {
+            log::debug!(
+                "Failed to construct App-level ReqData extractor. \
+                 Request path: {:?} (type: {})",
+                req.path(),
+                type_name::<T>(),
+            );
+            future::err(ErrorInternalServerError(
+                "Missing expected request extension data",
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{cell::RefCell, rc::Rc};
+
+    use futures_util::TryFutureExt as _;
+
+    use super::*;
+    use crate::{
+        dev::Service,
+        http::{Method, StatusCode},
+        test::{init_service, TestRequest},
+        web, App, HttpMessage, HttpResponse,
+    };
+
+    #[actix_rt::test]
+    async fn req_data_extractor() {
+        let mut srv = init_service(
+            App::new()
+                .wrap_fn(|req, srv| {
+                    if req.method() == Method::POST {
+                        req.extensions_mut().insert(42u32);
+                    }
+
+                    srv.call(req)
+                })
+                .service(web::resource("/test").to(
+                    |req: HttpRequest, data: Option<ReqData<u32>>| {
+                        if req.method() != Method::POST {
+                            assert!(data.is_none());
+                        }
+
+                        if let Some(data) = data {
+                            assert_eq!(*data, 42);
+                            assert_eq!(
+                                Some(data.into_inner()),
+                                req.extensions().get::<u32>().copied()
+                            );
+                        }
+
+                        HttpResponse::Ok()
+                    },
+                )),
+        )
+        .await;
+
+        let req = TestRequest::get().uri("/test").to_request();
+        let resp = srv.call(req).await.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let req = TestRequest::post().uri("/test").to_request();
+        let resp = srv.call(req).await.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    #[actix_rt::test]
+    async fn req_data_internal_mutability() {
+        let mut srv = init_service(
+            App::new()
+                .wrap_fn(|req, srv| {
+                    let data_before = Rc::new(RefCell::new(42u32));
+                    req.extensions_mut().insert(data_before);
+
+                    srv.call(req).map_ok(|res| {
+                        {
+                            let ext = res.request().extensions();
+                            let data_after = ext.get::<Rc<RefCell<u32>>>().unwrap();
+                            assert_eq!(*data_after.borrow(), 53u32);
+                        }
+
+                        res
+                    })
+                })
+                .default_service(web::to(|data: ReqData<Rc<RefCell<u32>>>| {
+                    assert_eq!(*data.borrow(), 42);
+                    *data.borrow_mut() += 11;
+                    assert_eq!(*data.borrow(), 53);
+
+                    HttpResponse::Ok()
+                })),
+        )
+        .await;
+
+        let req = TestRequest::get().uri("/test").to_request();
+        let resp = srv.call(req).await.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+}
--- a/src/rmap.rs
+++ b/src/rmap.rs
@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use std::rc::Rc;
+use std::rc::{Rc, Weak};

 use actix_router::ResourceDef;
 use fxhash::FxHashMap;
@ -11,7 +11,7 @@ use crate::request::HttpRequest;
 #[derive(Clone, Debug)]
 pub struct ResourceMap {
    root: ResourceDef,
-    parent: RefCell<Option<Rc<ResourceMap>>>,
+    parent: RefCell<Weak<ResourceMap>>,
    named: FxHashMap<String, ResourceDef>,
    patterns: Vec<(ResourceDef, Option<Rc<ResourceMap>>)>,
 }
@ -20,7 +20,7 @@ impl ResourceMap {
    pub fn new(root: ResourceDef) -> Self {
        ResourceMap {
            root,
-            parent: RefCell::new(None),
+            parent: RefCell::new(Weak::new()),
            named: FxHashMap::default(),
            patterns: Vec::new(),
        }
@ -38,7 +38,7 @@ impl ResourceMap {
    pub(crate) fn finish(&self, current: Rc<ResourceMap>) {
        for (_, nested) in &self.patterns {
            if let Some(ref nested) = nested {
-                *nested.parent.borrow_mut() = Some(current.clone());
+                *nested.parent.borrow_mut() = Rc::downgrade(&current);
                nested.finish(nested.clone());
            }
        }
@ -210,7 +210,7 @@ impl ResourceMap {
        U: Iterator<Item = I>,
        I: AsRef<str>,
    {
-        if let Some(ref parent) = *self.parent.borrow() {
+        if let Some(ref parent) = self.parent.borrow().upgrade() {
            parent.fill_root(path, elements)?;
        }
        if self.root.resource_path(path, elements) {
@ -230,7 +230,7 @@ impl ResourceMap {
        U: Iterator<Item = I>,
        I: AsRef<str>,
    {
-        if let Some(ref parent) = *self.parent.borrow() {
+        if let Some(ref parent) = self.parent.borrow().upgrade() {
            if let Some(pattern) = parent.named.get(name) {
                self.fill_root(path, elements)?;
                if pattern.resource_path(path, elements) {
@ -367,4 +367,42 @@ mod tests {
        assert_eq!(root.match_name("/user/22/"), None);
        assert_eq!(root.match_name("/user/22/post/55"), Some("user_post"));
    }
+
+    #[test]
+    fn bug_fix_issue_1582_debug_print_exits() {
+        // ref: https://github.com/actix/actix-web/issues/1582
+        let mut root = ResourceMap::new(ResourceDef::root_prefix(""));
+
+        let mut user_map = ResourceMap::new(ResourceDef::root_prefix(""));
+        user_map.add(&mut ResourceDef::new("/"), None);
+        user_map.add(&mut ResourceDef::new("/profile"), None);
+        user_map.add(&mut ResourceDef::new("/article/{id}"), None);
+        user_map.add(&mut ResourceDef::new("/post/{post_id}"), None);
+        user_map.add(
+            &mut ResourceDef::new("/post/{post_id}/comment/{comment_id}"),
+            None,
+        );
+
+        root.add(
+            &mut ResourceDef::root_prefix("/user/{id}"),
+            Some(Rc::new(user_map)),
+        );
+
+        let root = Rc::new(root);
+        root.finish(Rc::clone(&root));
+
+        // check root has no parent
+        assert!(root.parent.borrow().upgrade().is_none());
+        // check child has parent reference
+        assert!(root.patterns[0].1.is_some());
+        // check child's parent root id matches root's root id
+        assert_eq!(
+            root.patterns[0].1.as_ref().unwrap().root.id(),
+            root.root.id()
+        );
+
+        let output = format!("{:?}", root);
+        assert!(output.starts_with("ResourceMap {"));
+        assert!(output.ends_with(" }"));
+    }
 }
--- a/src/route.rs
+++ b/src/route.rs
@ -1,3 +1,5 @@
+#![allow(clippy::rc_buffer)] // inner value is mutated before being shared (`Rc::get_mut`)
+
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
--- a/src/scope.rs
+++ b/src/scope.rs
@ -58,7 +58,6 @@ type BoxedResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
 ///  * /{project_id}/path1 - responds to all http method
 ///  * /{project_id}/path2 - `GET` requests
 ///  * /{project_id}/path3 - `HEAD` requests
-///
 pub struct Scope<T = ScopeEndpoint> {
    endpoint: T,
    rdef: String,
@ -210,6 +209,9 @@ where

            self.data = Some(data);
        }
+        self.data
+            .get_or_insert_with(Extensions::new)
+            .extend(cfg.extensions);
        self
    }

@ -443,16 +445,17 @@ where
        *self.factory_ref.borrow_mut() = Some(ScopeFactory {
            data: self.data.take().map(Rc::new),
            default: self.default.clone(),
-            services: Rc::new(
-                cfg.into_services()
-                    .1
-                    .into_iter()
-                    .map(|(mut rdef, srv, guards, nested)| {
-                        rmap.add(&mut rdef, nested);
-                        (rdef, srv, RefCell::new(guards))
-                    })
-                    .collect(),
-            ),
+            services: cfg
+                .into_services()
+                .1
+                .into_iter()
+                .map(|(mut rdef, srv, guards, nested)| {
+                    rmap.add(&mut rdef, nested);
+                    (rdef, srv, RefCell::new(guards))
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice()
+                .into(),
        });

        // get guards
@ -474,7 +477,7 @@ where

 pub struct ScopeFactory {
    data: Option<Rc<Extensions>>,
-    services: Rc<Vec<(ResourceDef, HttpNewService, RefCell<Option<Guards>>)>>,
+    services: Rc<[(ResourceDef, HttpNewService, RefCell<Option<Guards>>)]>,
    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }

--- a/src/server.rs
+++ b/src/server.rs
@ -1,8 +1,14 @@
-use std::marker::PhantomData;
-use std::sync::{Arc, Mutex};
-use std::{fmt, io, net};
+use std::{
+    any::Any,
+    fmt, io,
+    marker::PhantomData,
+    net,
+    sync::{Arc, Mutex},
+};

-use actix_http::{body::MessageBody, Error, HttpService, KeepAlive, Request, Response};
+use actix_http::{
+    body::MessageBody, Error, Extensions, HttpService, KeepAlive, Request, Response,
+};
 use actix_server::{Server, ServerBuilder};
 use actix_service::{map_config, IntoServiceFactory, Service, ServiceFactory};

@ -64,6 +70,7 @@ where
    backlog: i32,
    sockets: Vec<Socket>,
    builder: ServerBuilder,
+    on_connect_fn: Option<Arc<dyn Fn(&dyn Any, &mut Extensions) + Send + Sync>>,
    _t: PhantomData<(S, B)>,
 }

@ -91,6 +98,32 @@ where
            backlog: 1024,
            sockets: Vec::new(),
            builder: ServerBuilder::default(),
+            on_connect_fn: None,
+            _t: PhantomData,
+        }
+    }
+
+    /// Sets function that will be called once before each connection is handled.
+    /// It will receive a `&std::any::Any`, which contains underlying connection type and an
+    /// [Extensions] container so that request-local data can be passed to middleware and handlers.
+    ///
+    /// For example:
+    /// - `actix_tls::openssl::SslStream<actix_web::rt::net::TcpStream>` when using openssl.
+    /// - `actix_tls::rustls::TlsStream<actix_web::rt::net::TcpStream>` when using rustls.
+    /// - `actix_web::rt::net::TcpStream` when no encryption is used.
+    ///
+    /// See `on_connect` example for additional details.
+    pub fn on_connect<CB>(self, f: CB) -> HttpServer<F, I, S, B>
+    where
+        CB: Fn(&dyn Any, &mut Extensions) + Send + Sync + 'static,
+    {
+        HttpServer {
+            factory: self.factory,
+            config: self.config,
+            backlog: self.backlog,
+            sockets: self.sockets,
+            builder: self.builder,
+            on_connect_fn: Some(Arc::new(f)),
            _t: PhantomData,
        }
    }
@ -240,6 +273,7 @@ where
            addr,
            scheme: "http",
        });
+        let on_connect_fn = self.on_connect_fn.clone();

        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
@ -252,11 +286,20 @@ where
                    c.host.clone().unwrap_or_else(|| format!("{}", addr)),
                );

-                HttpService::build()
+                let svc = HttpService::build()
                    .keep_alive(c.keep_alive)
                    .client_timeout(c.client_timeout)
-                    .local_addr(addr)
-                    .finish(map_config(factory(), move |_| cfg.clone()))
+                    .local_addr(addr);
+
+                let svc = if let Some(handler) = on_connect_fn.clone() {
+                    svc.on_connect_ext(move |io: &_, ext: _| {
+                        (handler)(io as &dyn Any, ext)
+                    })
+                } else {
+                    svc
+                };
+
+                svc.finish(map_config(factory(), move |_| cfg.clone()))
                    .tcp()
            },
        )?;
@ -289,6 +332,8 @@ where
            scheme: "https",
        });

+        let on_connect_fn = self.on_connect_fn.clone();
+
        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
            lst,
@ -299,11 +344,21 @@ where
                    addr,
                    c.host.clone().unwrap_or_else(|| format!("{}", addr)),
                );
-                HttpService::build()
+
+                let svc = HttpService::build()
                    .keep_alive(c.keep_alive)
                    .client_timeout(c.client_timeout)
-                    .client_disconnect(c.client_shutdown)
-                    .finish(map_config(factory(), move |_| cfg.clone()))
+                    .client_disconnect(c.client_shutdown);
+
+                let svc = if let Some(handler) = on_connect_fn.clone() {
+                    svc.on_connect_ext(move |io: &_, ext: _| {
+                        (&*handler)(io as &dyn Any, ext)
+                    })
+                } else {
+                    svc
+                };
+
+                svc.finish(map_config(factory(), move |_| cfg.clone()))
                    .openssl(acceptor.clone())
            },
        )?;
@ -336,6 +391,8 @@ where
            scheme: "https",
        });

+        let on_connect_fn = self.on_connect_fn.clone();
+
        self.builder = self.builder.listen(
            format!("actix-web-service-{}", addr),
            lst,
@ -346,11 +403,21 @@ where
                    addr,
                    c.host.clone().unwrap_or_else(|| format!("{}", addr)),
                );
-                HttpService::build()
+
+                let svc = HttpService::build()
                    .keep_alive(c.keep_alive)
                    .client_timeout(c.client_timeout)
-                    .client_disconnect(c.client_shutdown)
-                    .finish(map_config(factory(), move |_| cfg.clone()))
+                    .client_disconnect(c.client_shutdown);
+
+                let svc = if let Some(handler) = on_connect_fn.clone() {
+                    svc.on_connect_ext(move |io: &_, ext: _| {
+                        (handler)(io as &dyn Any, ext)
+                    })
+                } else {
+                    svc
+                };
+
+                svc.finish(map_config(factory(), move |_| cfg.clone()))
                    .rustls(config.clone())
            },
        )?;
@ -441,7 +508,7 @@ where
    }

    #[cfg(unix)]
-    /// Start listening for unix domain connections on existing listener.
+    /// Start listening for unix domain (UDS) connections on existing listener.
    pub fn listen_uds(
        mut self,
        lst: std::os::unix::net::UnixListener,
@ -460,6 +527,7 @@ where
        });

        let addr = format!("actix-web-service-{:?}", lst.local_addr()?);
+        let on_connect_fn = self.on_connect_fn.clone();

        self.builder = self.builder.listen_uds(addr, lst, move || {
            let c = cfg.lock().unwrap();
@ -468,11 +536,23 @@ where
                socket_addr,
                c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
            );
+
            pipeline_factory(|io: UnixStream| ok((io, Protocol::Http1, None))).and_then(
-                HttpService::build()
-                    .keep_alive(c.keep_alive)
-                    .client_timeout(c.client_timeout)
-                    .finish(map_config(factory(), move |_| config.clone())),
+                {
+                    let svc = HttpService::build()
+                        .keep_alive(c.keep_alive)
+                        .client_timeout(c.client_timeout);
+
+                    let svc = if let Some(handler) = on_connect_fn.clone() {
+                        svc.on_connect_ext(move |io: &_, ext: _| {
+                            (&*handler)(io as &dyn Any, ext)
+                        })
+                    } else {
+                        svc
+                    };
+
+                    svc.finish(map_config(factory(), move |_| config.clone()))
+                },
            )
        })?;
        Ok(self)
--- a/src/types/json.rs
+++ b/src/types/json.rs
@ -283,7 +283,7 @@ impl JsonConfig {
    fn from_req(req: &HttpRequest) -> &Self {
        req.app_data::<Self>()
            .or_else(|| req.app_data::<web::Data<Self>>().map(|d| d.as_ref()))
-            .unwrap_or_else(|| &DEFAULT_CONFIG)
+            .unwrap_or(&DEFAULT_CONFIG)
    }
 }

--- a/src/types/payload.rs
+++ b/src/types/payload.rs
@ -284,7 +284,7 @@ impl PayloadConfig {
    fn from_req(req: &HttpRequest) -> &Self {
        req.app_data::<Self>()
            .or_else(|| req.app_data::<web::Data<Self>>().map(|d| d.as_ref()))
-            .unwrap_or_else(|| &DEFAULT_CONFIG)
+            .unwrap_or(&DEFAULT_CONFIG)
    }
 }

--- a/src/web.rs
+++ b/src/web.rs
@ -4,7 +4,7 @@ use actix_router::IntoPattern;
 use std::future::Future;

 pub use actix_http::Response as HttpResponse;
-pub use bytes::{Bytes, BytesMut};
+pub use bytes::{Buf, BufMut, Bytes, BytesMut};
 pub use futures_channel::oneshot::Canceled;

 use crate::error::BlockingError;
@ -19,6 +19,7 @@ use crate::service::WebService;
 pub use crate::config::ServiceConfig;
 pub use crate::data::Data;
 pub use crate::request::HttpRequest;
+pub use crate::request_data::ReqData;
 pub use crate::types::*;

 /// Create resource for a specific path.
--- a/test-server/CHANGES.md
+++ b/test-server/CHANGES.md
@ -2,11 +2,14 @@

 ## Unreleased - 2020-xx-xx

+* add ability to set address for `TestServer` [#1645]
+* Upgrade `base64` to `0.13`.
+
+[#1645]: https://github.com/actix/actix-web/pull/1645

 ## 2.0.0 - 2020-09-11
 * Update actix-codec and actix-utils dependencies.

-
 ## 2.0.0-alpha.1 - 2020-05-23
 * Update the `time` dependency to 0.2.7
 * Update `actix-connect` dependency to 2.0.0-alpha.2
--- a/test-server/Cargo.toml
+++ b/test-server/Cargo.toml
@ -38,7 +38,7 @@ actix-server = "1.0.0"
 actix-testing = "1.0.0"
 awc = "2.0.0"

-base64 = "0.12"
+base64 = "0.13"
 bytes = "0.5.3"
 futures-core = { version = "0.3.5", default-features = false }
 http = "0.2.0"
--- a/test-server/src/lib.rs
+++ b/test-server/src/lib.rs
@ -44,12 +44,20 @@ pub use actix_testing::*;
 /// }
 /// ```
 pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+    let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
+    test_server_with_addr(tcp, factory).await
+}
+
+/// Start [`test server`](./fn.test_server.html) on a concrete Address
+pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
+    tcp: net::TcpListener,
+    factory: F,
+) -> TestServer {
    let (tx, rx) = mpsc::channel();

    // run server in separate thread
    thread::spawn(move || {
        let sys = System::new("actix-test-server");
-        let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
        let local_addr = tcp.local_addr().unwrap();

        Server::build()
Author	SHA1	Message	Date
Rob Ede	156c97cef2	prepare awc release 2.0.1	2020-10-30 02:50:53 +00:00
Rob Ede	798d744eef	prepare http release 2.1.0	2020-10-30 02:19:56 +00:00
Rob Ede	4cb833616a	deprecate builder if-x methods (#1760 )	2020-10-30 02:10:05 +00:00
Rob Ede	9963a5ef54	expose on_connect v2 (#1754 ) Co-authored-by: Mikail Bagishov <bagishov.mikail@yandex.ru>	2020-10-30 02:03:26 +00:00
Joshua Parkin	4519db36b2	register fns for custom request-derived logging units (#1749 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-10-29 18:38:49 +00:00
Augusto César Dias	7030bf5fe8	Adding app_data to ServiceConfig (#1758 ) Co-authored-by: Rob Ede <robjtede@icloud.com> Co-authored-by: Augusto <augusto@flowciety.de>	2020-10-26 17:02:45 +00:00
ghizzo01	20078fe603	Bump pin-project to 1.0 (#1733 )	2020-10-25 19:41:44 +09:00
Jonas	06e5042b94	use idenity encoding on client if no compression features are enabled (#1737 ) Co-authored-by: Yuki Okushi <huyuumi.dev@gmail.com> Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-10-24 21:15:01 +01:00
Daniel Egger	41e7cec72f	Re-export bytes::Buf and bytes::BufMut as well (#1750 ) Co-authored-by: Daniel Egger <daniel.egger@axiros.com> Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-10-24 20:31:23 +01:00
Rob Ede	d45a1aa6b6	Add `web::ReqData<T>` extractor (#1748 ) Co-authored-by: Jonas Platte <jonas@lumeo.com>	2020-10-24 18:49:50 +01:00
cquintana-verbio	98243db9f1	Print unconfigured `Data<T>` type when attempting extraction (#1743 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-10-20 17:35:34 +01:00
ghizzo01	f92742bdac	Bump base64 to 0.13 (#1744 )	2020-10-19 18:24:22 +01:00
Rob Ede	e563025b16	always construct shortslice using debug checked new constructor (#1741 )	2020-10-19 12:51:30 +01:00
Matt Gathu	cfd5b381f1	Implement Logger middleware regex exclude pattern (#1723 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-10-19 07:18:16 +01:00
Yuki Okushi	2f84914146	Skip some tests that cause ICE on nightly (#1740 )	2020-10-19 11:52:05 +09:00
Jonas Platte	d765e9099d	Fix clippy::rc_buffer (#1728 )	2020-10-10 09:26:05 +09:00
Rob Ede	34b23f31c9	prepare files release 0.4.0	2020-10-06 22:08:33 +01:00
Rob Ede	26c1a901d9	add files preference for utf8 text responses (#1714 )	2020-10-06 21:56:28 +01:00
Yuki Okushi	c2c71cc626	Fix/suppress clippy warnings (#1720 )	2020-10-01 18:19:09 +09:00
Rob Ede	aa11231ee5	prepare web release 3.1.0 (#1716 )	2020-09-30 11:07:35 +01:00
PeterUlb	b5812b15f0	Remove Sized Bound for web::Data (#1712 )	2020-09-29 22:44:12 +01:00
Matt Gathu	b4e02fe29a	Fix cyclic references in ResourceMap (#1708 )	2020-09-25 17:42:49 +01:00
Matt Gathu	37c76a39ab	Fix Multipart consuming payload before header checks (#1704 ) * Fix Multipart consuming payload before header checks What -- Split up logic in the constructor into two functions: - from_boundary: build Multipart from boundary and stream - from_error: build Multipart for MultipartError Also we make the `boundary`, `from_boundary`, `from_error` methods public within the crate so that we can use them in the extractor. The extractor is then able to perform header checks and only consume the payload if the checks pass. * Add tests * Add payload consumption test Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-09-25 14:50:37 +01:00
LIU An (劉安)	60e7e52276	Add TrailingSlash::MergeOnly behavior (#1695 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-09-25 12:50:59 +01:00
Rob Ede	c53e9468bc	prepare codegen 0.4.0 release (#1702 )	2020-09-24 23:54:01 +01:00
Arniu Tseng	162121bf8d	Unify route macros (#1705 )	2020-09-22 22:42:51 +01:00
Rob Ede	f7bcad9567	split up files lib (#1685 )	2020-09-20 23:18:25 +01:00
Igor Aleksanov	f9e3f78e45	eemove non-relevant comment from actix-http README.md (#1701 )	2020-09-20 17:21:53 +01:00
Silentdoer	1596893ef7	update actix-http dev-dependencies (#1696 ) Co-authored-by: luojinming <luojm@hxsmart.com>	2020-09-19 23:20:34 +09:00
Lokathor	2a2474ca09	Update `tinyvec` to 1.0 (#1689 )	2020-09-17 18:09:42 +01:00
Matt Gathu	509b2e6eec	Provide attribute macro for multiple HTTP methods (#1674 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-09-16 22:37:41 +01:00
Rob Ede	d707704556	prepare web release 3.0.2 (#1681 )	2020-09-15 13:14:14 +01:00
Aleksandrov Vladimir	a429ee6646	Add possibility to set address for test_server (#1645 )	2020-09-15 12:09:16 +01:00
Rob Ede	7f8073233a	fix trimming to inaccessible root path (#1678 )	2020-09-15 11:32:31 +01:00
Rob Ede	4b4c9d1b93	update migration guide closes #1680	2020-09-14 22:26:03 +01:00
Rob Ede	3fde3be3d8	add trybuild tests to routing codegen (#1677 )	2020-09-13 16:31:08 +01:00