Content-Length is 0 for NamedFile HEAD request #914

* get_identity from HttpMessage

* more doc for RequestIdentity

CHANGES.md

@@ -1,5 +1,24 @@
 # Changes
 
+## [1.0.1] - 2019-06-xx
+
+### Add
+
+* Add support for PathConfig #903
+
+* Add `middleware::identity::RequestIdentity` trait to `get_identity` from `HttpMessage`.
+
+### Changes
+
+* Disable default feature `secure-cookies`.
+
+* Move identity middleware to `actix-identity` crate.
+
+* Allow to test an app that uses async actors #897
+
+* Re-apply patch from #637 #894
+
+
 ## [1.0.0] - 2019-06-05
 
 ### Add

Cargo.toml

@@ -34,6 +34,7 @@ members = [
   "actix-files",
   "actix-framed",
   "actix-session",
+  "actix-identity",
   "actix-multipart",
   "actix-web-actors",
   "actix-web-codegen",
@@ -41,7 +42,7 @@ members = [
 ]
 
 [features]
-default = ["brotli", "flate2-zlib", "secure-cookies", "client", "fail"]
+default = ["brotli", "flate2-zlib", "client", "fail"]
 
 # http client
 client = ["awc"]
@@ -77,7 +78,7 @@ actix-http = "0.2.3"
 actix-server = "0.5.1"
 actix-server-config = "0.1.1"
 actix-threadpool = "0.1.1"
-awc = { version = "0.2.0", optional = true }
+awc = { version = "0.2.1", optional = true }
 
 bytes = "0.4"
 derive_more = "0.14"
@@ -102,7 +103,8 @@ rustls = { version = "0.15", optional = true }
 [dev-dependencies]
 actix-http = { version = "0.2.3", features=["ssl", "brotli", "flate2-zlib"] }
 actix-http-test = { version = "0.2.0", features=["ssl"] }
-actix-files = { version = "0.1.1" }
+actix-files = "0.1.1"
+actix = { version = "0.8.3" }
 rand = "0.6"
 env_logger = "0.6"
 serde_derive = "1.0"

MIGRATION.md

@@ -1,4 +1,21 @@
-## 1.0
+## 1.0.1
+
+* Identity middleware has been moved to `actix-identity` crate
+
+  instead of
+
+  ```rust
+  use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
+  ```
+
+  use
+
+  ```rust
+  use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
+  ```
+
+
+## 1.0.0
 
 * Resource registration. 1.0 version uses generalized resource
   registration via `.service()` method.

actix-files/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.1.2] - 2019-06-13
+
+* Content-Length is 0 for NamedFile HEAD request #914
+
+* Fix ring dependency from actix-web default features for #741
+
 ## [0.1.1] - 2019-06-01
 
 * Static files are incorrectly served as both chunked and with length #812

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@@ -18,7 +18,7 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = "1.0.0-rc"
+actix-web = { version = "1.0.0", default-features = false }
 actix-http = "0.2.3"
 actix-service = "0.4.0"
 bitflags = "1"
@@ -32,4 +32,4 @@ percent-encoding = "1.0"
 v_htmlescape = "0.4"
 
 [dev-dependencies]
-actix-web = { version = "1.0.0-rc", features=["ssl"] }
+actix-web = { version = "1.0.0", features=["ssl"] }

actix-files/src/lib.rs

@@ -926,6 +926,29 @@ mod tests {
         assert_eq!(bytes.freeze(), data);
     }
 
+    #[test]
+    fn test_head_content_length_headers() {
+        let mut srv = test::init_service(
+            App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
+        );
+
+        // Valid range header
+        let request = TestRequest::default()
+            .method(Method::HEAD)
+            .uri("/t%65st/tests/test.binary")
+            .to_request();
+        let response = test::call_service(&mut srv, request);
+
+        let contentlength = response
+            .headers()
+            .get(header::CONTENT_LENGTH)
+            .unwrap()
+            .to_str()
+            .unwrap();
+
+        assert_eq!(contentlength, "100");
+    }
+
     #[test]
     fn test_static_files_with_spaces() {
         let mut srv = test::init_service(

actix-files/src/named.rs

@@ -422,20 +422,16 @@ impl Responder for NamedFile {
             return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
         }
 
-        if *req.method() == Method::HEAD {
-            Ok(resp.finish())
-        } else {
-            let reader = ChunkedReadFile {
-                offset,
-                size: length,
-                file: Some(self.file),
-                fut: None,
-                counter: 0,
-            };
-            if offset != 0 || length != self.md.len() {
-                return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
-            };
-            Ok(resp.body(SizedStream::new(length, reader)))
-        }
+        let reader = ChunkedReadFile {
+            offset,
+            size: length,
+            file: Some(self.file),
+            fut: None,
+            counter: 0,
+        };
+        if offset != 0 || length != self.md.len() {
+            return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
+        };
+        Ok(resp.body(SizedStream::new(length, reader)))
     }
 }

actix-identity/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## [0.1.0] - 2019-06-xx
+
+* Move identity middleware to separate crate

actix-identity/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "actix-identity"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Identity service for actix web framework."
+readme = "README.md"
+keywords = ["http", "web", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-identity/"
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_identity"
+path = "src/lib.rs"
+
+[dependencies]
+actix-web = { version = "1.0.0", default-features = false, features = ["secure-cookies"] }
+actix-service = "0.4.0"
+futures = "0.1.25"
+serde = "1.0"
+serde_json = "1.0"
+time = "0.1.42"
+
+[dev-dependencies]
+actix-rt = "0.2.2"
+actix-http = "0.2.3"
+bytes = "0.4"

actix-identity/LICENSE-APACHE

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

actix-identity/LICENSE-MIT

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

actix-identity/README.md

@@ -0,0 +1,9 @@
+# Identity service for actix web framework [![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-identity)](https://crates.io/crates/actix-identity) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/actix-identity/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-session](https://crates.io/crates/actix-identity)
+* Minimum supported Rust version: 1.34 or later

actix-identity/src/lib.rs

@@ -10,12 +10,11 @@
 //! uses cookies as identity storage.
 //!
 //! To access current request identity
-//! [**Identity**](trait.Identity.html) extractor should be used.
+//! [**Identity**](struct.Identity.html) extractor should be used.
 //!
 //! ```rust
-//! use actix_web::middleware::identity::Identity;
-//! use actix_web::middleware::identity::{CookieIdentityPolicy, IdentityService};
 //! use actix_web::*;
+//! use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
 //!
 //! fn index(id: Identity) -> String {
 //!     // access request identity
@@ -39,7 +38,7 @@
 //! fn main() {
 //!     let app = App::new().wrap(IdentityService::new(
 //!         // <- create identity middleware
-//!         CookieIdentityPolicy::new(&[0; 32])    // <- create cookie session backend
+//!         CookieIdentityPolicy::new(&[0; 32])    // <- create cookie identity policy
 //!               .name("auth-cookie")
 //!               .secure(false)))
 //!         .service(web::resource("/index.html").to(index))
@@ -57,17 +56,17 @@ use futures::{Future, IntoFuture, Poll};
 use serde::{Deserialize, Serialize};
 use time::Duration;
 
-use crate::cookie::{Cookie, CookieJar, Key, SameSite};
-use crate::error::{Error, Result};
-use crate::http::header::{self, HeaderValue};
-use crate::service::{ServiceRequest, ServiceResponse};
-use crate::{dev::Payload, FromRequest, HttpMessage, HttpRequest};
+use actix_web::cookie::{Cookie, CookieJar, Key, SameSite};
+use actix_web::dev::{Extensions, Payload, ServiceRequest, ServiceResponse};
+use actix_web::error::{Error, Result};
+use actix_web::http::header::{self, HeaderValue};
+use actix_web::{FromRequest, HttpMessage, HttpRequest};
 
 /// The extractor type to obtain your identity from a request.
 ///
 /// ```rust
 /// use actix_web::*;
-/// use actix_web::middleware::identity::Identity;
+/// use actix_identity::Identity;
 ///
 /// fn index(id: Identity) -> Result<String> {
 ///     // access request identity
@@ -96,11 +95,7 @@ impl Identity {
     /// Return the claimed identity of the user associated request or
     /// ``None`` if no identity can be found associated with the request.
     pub fn identity(&self) -> Option<String> {
-        if let Some(id) = self.0.extensions().get::<IdentityItem>() {
-            id.id.clone()
-        } else {
-            None
-        }
+        Identity::get_identity(&self.0.extensions())
     }
 
     /// Remember identity.
@@ -119,6 +114,14 @@ impl Identity {
             id.changed = true;
         }
     }
+
+    fn get_identity(extensions: &Extensions) -> Option<String> {
+        if let Some(id) = extensions.get::<IdentityItem>() {
+            id.id.clone()
+        } else {
+            None
+        }
+    }
 }
 
 struct IdentityItem {
@@ -126,11 +129,28 @@ struct IdentityItem {
     changed: bool,
 }
 
+/// Helper trait that allows to get Identity.
+///
+/// It could be used in middleware but identity policy must be set before any other middleware that needs identity
+/// RequestIdentity is implemented both for `ServiceRequest` and `HttpRequest`.
+pub trait RequestIdentity {
+    fn get_identity(&self) -> Option<String>;
+}
+
+impl<T> RequestIdentity for T
+where
+    T: HttpMessage,
+{
+    fn get_identity(&self) -> Option<String> {
+        Identity::get_identity(&self.extensions())
+    }
+}
+
 /// Extractor implementation for Identity type.
 ///
 /// ```rust
 /// # use actix_web::*;
-/// use actix_web::middleware::identity::Identity;
+/// use actix_identity::Identity;
 ///
 /// fn index(id: Identity) -> String {
 ///     // access request identity
@@ -177,7 +197,7 @@ pub trait IdentityPolicy: Sized + 'static {
 ///
 /// ```rust
 /// use actix_web::App;
-/// use actix_web::middleware::identity::{CookieIdentityPolicy, IdentityService};
+/// use actix_identity::{CookieIdentityPolicy, IdentityService};
 ///
 /// fn main() {
 ///     let app = App::new().wrap(IdentityService::new(
@@ -442,9 +462,8 @@ impl CookieIdentityInner {
 /// # Example
 ///
 /// ```rust
-/// # extern crate actix_web;
-/// use actix_web::middleware::identity::{CookieIdentityPolicy, IdentityService};
 /// use actix_web::App;
+/// use actix_identity::{CookieIdentityPolicy, IdentityService};
 ///
 /// fn main() {
 ///     let app = App::new().wrap(IdentityService::new(
@@ -590,13 +609,13 @@ impl IdentityPolicy for CookieIdentityPolicy {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::http::StatusCode;
-    use crate::test::{self, TestRequest};
-    use crate::{web, App, HttpResponse};
-
     use std::borrow::Borrow;
 
+    use super::*;
+    use actix_web::http::StatusCode;
+    use actix_web::test::{self, TestRequest};
+    use actix_web::{web, App, Error, HttpResponse};
+
     const COOKIE_KEY_MASTER: [u8; 32] = [0; 32];
     const COOKIE_NAME: &'static str = "actix_auth";
     const COOKIE_LOGIN: &'static str = "test";
@@ -717,8 +736,8 @@ mod tests {
         f: F,
     ) -> impl actix_service::Service<
         Request = actix_http::Request,
-        Response = ServiceResponse<actix_http::body::Body>,
-        Error = actix_http::Error,
+        Response = ServiceResponse<actix_web::body::Body>,
+        Error = Error,
     > {
         test::init_service(
             App::new()

actix-multipart/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.3] - 2019-06-06
+
+* Fix ring dependency from actix-web default features for #741.
+
 ## [0.1.2] - 2019-06-02
 
 * Fix boundary parsing #876

actix-multipart/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart support for actix web framework."
 readme = "README.md"
@@ -18,7 +18,7 @@ name = "actix_multipart"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = "1.0.0-rc"
+actix-web = { version = "1.0.0", default-features = false }
 actix-service = "0.4.0"
 bytes = "0.4"
 derive_more = "0.14"

awc/src/lib.rs

@@ -38,6 +38,7 @@ pub mod test;
 pub mod ws;
 
 pub use self::builder::ClientBuilder;
+pub use self::connect::BoxedSocket;
 pub use self::request::ClientRequest;
 pub use self::response::{ClientResponse, JsonBody, MessageBody};
 

src/error.rs

@@ -92,6 +92,23 @@ impl ResponseError for JsonPayloadError {
     }
 }
 
+/// A set of errors that can occur during parsing request paths
+#[derive(Debug, Display, From)]
+pub enum PathError {
+    /// Deserialize error
+    #[display(fmt = "Path deserialize error: {}", _0)]
+    Deserialize(de::Error),
+}
+
+/// Return `BadRequest` for `PathError`
+impl ResponseError for PathError {
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            PathError::Deserialize(_) => HttpResponse::new(StatusCode::BAD_REQUEST),
+        }
+    }
+}
+
 /// A set of errors that can occur during parsing query strings
 #[derive(Debug, Display, From)]
 pub enum QueryPayloadError {

src/lib.rs

@@ -66,15 +66,15 @@
 //!
 //! ## Package feature
 //!
-//! * `client` - enables http client
+//! * `client` - enables http client (default enabled)
 //! * `ssl` - enables ssl support via `openssl` crate, supports `http/2`
 //! * `rust-tls` - enables ssl support via `rustls` crate, supports `http/2`
 //! * `secure-cookies` - enables secure cookies support, includes `ring` crate as
 //!   dependency
 //! * `brotli` - enables `brotli` compression support, requires `c`
-//!   compiler
+//!   compiler (default enabled)
 //! * `flate2-zlib` - enables `gzip`, `deflate` compression support, requires
-//!   `c` compiler
+//!   `c` compiler (default enabled)
 //! * `flate2-rust` - experimental rust based implementation for
 //!   `gzip`, `deflate` compression.
 //!

src/middleware/mod.rs

@@ -11,6 +11,3 @@ mod normalize;
 pub use self::defaultheaders::DefaultHeaders;
 pub use self::logger::Logger;
 pub use self::normalize::NormalizePath;
-
-#[cfg(feature = "secure-cookies")]
-pub mod identity;

src/test.rs

@@ -7,7 +7,7 @@ use actix_http::http::{HttpTryFrom, Method, StatusCode, Uri, Version};
 use actix_http::test::TestRequest as HttpTestRequest;
 use actix_http::{cookie::Cookie, Extensions, Request};
 use actix_router::{Path, ResourceDef, Url};
-use actix_rt::Runtime;
+use actix_rt::{System, SystemRunner};
 use actix_server_config::ServerConfig;
 use actix_service::{IntoNewService, IntoService, NewService, Service};
 use bytes::{Bytes, BytesMut};
@@ -29,14 +29,14 @@ use crate::{Error, HttpRequest, HttpResponse};
 
 thread_local! {
     static RT: RefCell<Inner> = {
-        RefCell::new(Inner(Some(Runtime::new().unwrap())))
+        RefCell::new(Inner(Some(System::builder().build())))
     };
 }
 
-struct Inner(Option<Runtime>);
+struct Inner(Option<SystemRunner>);
 
 impl Inner {
-    fn get_mut(&mut self) -> &mut Runtime {
+    fn get_mut(&mut self) -> &mut SystemRunner {
         self.0.as_mut().unwrap()
     }
 }
@@ -714,4 +714,42 @@ mod tests {
         let res = block_fn(|| app.call(req)).unwrap();
         assert!(res.status().is_success());
     }
+
+    #[test]
+    fn test_actor() {
+        use actix::Actor;
+
+        struct MyActor;
+
+        struct Num(usize);
+        impl actix::Message for Num {
+            type Result = usize;
+        }
+        impl actix::Actor for MyActor {
+            type Context = actix::Context<Self>;
+        }
+        impl actix::Handler<Num> for MyActor {
+            type Result = usize;
+            fn handle(&mut self, msg: Num, _: &mut Self::Context) -> Self::Result {
+                msg.0
+            }
+        }
+
+        let addr = run_on(|| MyActor.start());
+        let mut app = init_service(App::new().service(
+            web::resource("/index.html").to_async(move || {
+                addr.send(Num(1)).from_err().and_then(|res| {
+                    if res == 1 {
+                        HttpResponse::Ok()
+                    } else {
+                        HttpResponse::BadRequest()
+                    }
+                })
+            }),
+        ));
+
+        let req = TestRequest::post().uri("/index.html").to_request();
+        let res = block_fn(|| app.call(req)).unwrap();
+        assert!(res.status().is_success());
+    }
 }

src/types/json.rs

@@ -175,15 +175,15 @@ where
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
         let req2 = req.clone();
-        let (limit, err) = req
+        let (limit, err, ctype) = req
             .app_data::<Self::Config>()
-            .map(|c| (c.limit, c.ehandler.clone()))
-            .unwrap_or((32768, None));
+            .map(|c| (c.limit, c.ehandler.clone(), c.content_type.clone()))
+            .unwrap_or((32768, None, None));
 
         let path = req.path().to_string();
 
         Box::new(
-            JsonBody::new(req, payload)
+            JsonBody::new(req, payload, ctype)
                 .limit(limit)
                 .map_err(move |e| {
                     log::debug!(
@@ -224,6 +224,9 @@ where
 ///             // change json extractor configuration
 ///             web::Json::<Info>::configure(|cfg| {
 ///                 cfg.limit(4096)
+///                    .content_type(|mime| {  // <- accept text/plain content type
+///                         mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
+///                    })
 ///                    .error_handler(|err, req| {  // <- create custom error response
 ///                         error::InternalError::from_response(
 ///                             err, HttpResponse::Conflict().finish()).into()
@@ -237,6 +240,7 @@ where
 pub struct JsonConfig {
     limit: usize,
     ehandler: Option<Arc<dyn Fn(JsonPayloadError, &HttpRequest) -> Error + Send + Sync>>,
+    content_type: Option<Arc<dyn Fn(mime::Mime) -> bool + Send + Sync>>,
 }
 
 impl JsonConfig {
@@ -254,6 +258,15 @@ impl JsonConfig {
         self.ehandler = Some(Arc::new(f));
         self
     }
+
+    /// Set predicate for allowed content types
+    pub fn content_type<F>(mut self, predicate: F) -> Self
+    where
+        F: Fn(mime::Mime) -> bool + Send + Sync + 'static,
+    {
+        self.content_type = Some(Arc::new(predicate));
+        self
+    }
 }
 
 impl Default for JsonConfig {
@@ -261,6 +274,7 @@ impl Default for JsonConfig {
         JsonConfig {
             limit: 32768,
             ehandler: None,
+            content_type: None,
         }
     }
 }
@@ -271,6 +285,7 @@ impl Default for JsonConfig {
 /// Returns error:
 ///
 /// * content type is not `application/json`
+///   (unless specified in [`JsonConfig`](struct.JsonConfig.html))
 /// * content length is greater than 256k
 pub struct JsonBody<U> {
     limit: usize,
@@ -285,13 +300,20 @@ where
     U: DeserializeOwned + 'static,
 {
     /// Create `JsonBody` for request.
-    pub fn new(req: &HttpRequest, payload: &mut Payload) -> Self {
+    pub fn new(
+        req: &HttpRequest,
+        payload: &mut Payload,
+        ctype: Option<Arc<dyn Fn(mime::Mime) -> bool + Send + Sync>>,
+    ) -> Self {
         // check content-type
         let json = if let Ok(Some(mime)) = req.mime_type() {
-            mime.subtype() == mime::JSON || mime.suffix() == Some(mime::JSON)
+            mime.subtype() == mime::JSON
+                || mime.suffix() == Some(mime::JSON)
+                || ctype.as_ref().map_or(false, |predicate| predicate(mime))
         } else {
             false
         };
+
         if !json {
             return JsonBody {
                 limit: 262_144,
@@ -512,7 +534,7 @@ mod tests {
     #[test]
     fn test_json_body() {
         let (req, mut pl) = TestRequest::default().to_http_parts();
-        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl));
+        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl, None));
         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
 
         let (req, mut pl) = TestRequest::default()
@@ -521,7 +543,7 @@ mod tests {
                 header::HeaderValue::from_static("application/text"),
             )
             .to_http_parts();
-        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl));
+        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl, None));
         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
 
         let (req, mut pl) = TestRequest::default()
@@ -535,7 +557,7 @@ mod tests {
             )
             .to_http_parts();
 
-        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl).limit(100));
+        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl, None).limit(100));
         assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
 
         let (req, mut pl) = TestRequest::default()
@@ -550,7 +572,7 @@ mod tests {
             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
             .to_http_parts();
 
-        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl));
+        let json = block_on(JsonBody::<MyObject>::new(&req, &mut pl, None));
         assert_eq!(
             json.ok().unwrap(),
             MyObject {
@@ -558,4 +580,62 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_with_json_and_bad_content_type() {
+        let (req, mut pl) = TestRequest::with_header(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain"),
+        )
+        .header(
+            header::CONTENT_LENGTH,
+            header::HeaderValue::from_static("16"),
+        )
+        .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        .data(JsonConfig::default().limit(4096))
+        .to_http_parts();
+
+        let s = block_on(Json::<MyObject>::from_request(&req, &mut pl));
+        assert!(s.is_err())
+    }
+
+    #[test]
+    fn test_with_json_and_good_custom_content_type() {
+        let (req, mut pl) = TestRequest::with_header(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain"),
+        )
+        .header(
+            header::CONTENT_LENGTH,
+            header::HeaderValue::from_static("16"),
+        )
+        .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        .data(JsonConfig::default().content_type(|mime: mime::Mime| {
+            mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
+        }))
+        .to_http_parts();
+
+        let s = block_on(Json::<MyObject>::from_request(&req, &mut pl));
+        assert!(s.is_ok())
+    }
+
+    #[test]
+    fn test_with_json_and_bad_custom_content_type() {
+        let (req, mut pl) = TestRequest::with_header(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/html"),
+        )
+        .header(
+            header::CONTENT_LENGTH,
+            header::HeaderValue::from_static("16"),
+        )
+        .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        .data(JsonConfig::default().content_type(|mime: mime::Mime| {
+            mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
+        }))
+        .to_http_parts();
+
+        let s = block_on(Json::<MyObject>::from_request(&req, &mut pl));
+        assert!(s.is_err())
+    }
 }

src/types/mod.rs

@@ -9,6 +9,6 @@ pub(crate) mod readlines;
 
 pub use self::form::{Form, FormConfig};
 pub use self::json::{Json, JsonConfig};
-pub use self::path::Path;
+pub use self::path::{Path, PathConfig};
 pub use self::payload::{Payload, PayloadConfig};
 pub use self::query::{Query, QueryConfig};

src/types/path.rs

@@ -1,5 +1,6 @@
 //! Path extractor
 
+use std::sync::Arc;
 use std::{fmt, ops};
 
 use actix_http::error::{Error, ErrorNotFound};
@@ -7,6 +8,7 @@ use actix_router::PathDeserializer;
 use serde::de;
 
 use crate::dev::Payload;
+use crate::error::PathError;
 use crate::request::HttpRequest;
 use crate::FromRequest;
 
@@ -156,15 +158,89 @@ impl<T> FromRequest for Path<T>
 where
     T: de::DeserializeOwned,
 {
-    type Config = ();
     type Error = Error;
     type Future = Result<Self, Error>;
+    type Config = PathConfig;
 
     #[inline]
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        let error_handler = req
+            .app_data::<Self::Config>()
+            .map(|c| c.ehandler.clone())
+            .unwrap_or(None);
+
         de::Deserialize::deserialize(PathDeserializer::new(req.match_info()))
             .map(|inner| Path { inner })
-            .map_err(ErrorNotFound)
+            .map_err(move |e| {
+                log::debug!(
+                    "Failed during Path extractor deserialization. \
+                     Request path: {:?}",
+                    req.path()
+                );
+                if let Some(error_handler) = error_handler {
+                    let e = PathError::Deserialize(e);
+                    (error_handler)(e, req)
+                } else {
+                    ErrorNotFound(e)
+                }
+            })
+    }
+}
+
+/// Path extractor configuration
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_derive;
+/// use actix_web::web::PathConfig;
+/// use actix_web::{error, web, App, FromRequest, HttpResponse};
+///
+/// #[derive(Deserialize, Debug)]
+/// enum Folder {
+///     #[serde(rename = "inbox")]
+///     Inbox,
+///     #[serde(rename = "outbox")]
+///     Outbox,
+/// }
+///
+/// // deserialize `Info` from request's path
+/// fn index(folder: web::Path<Folder>) -> String {
+///     format!("Selected folder: {:?}!", folder)
+/// }
+///
+/// fn main() {
+///     let app = App::new().service(
+///         web::resource("/messages/{folder}")
+///             .data(PathConfig::default().error_handler(|err, req| {
+///                 error::InternalError::from_response(
+///                     err,
+///                     HttpResponse::Conflict().finish(),
+///                 )
+///                 .into()
+///             }))
+///             .route(web::post().to(index)),
+///     );
+/// }
+/// ```
+#[derive(Clone)]
+pub struct PathConfig {
+    ehandler: Option<Arc<Fn(PathError, &HttpRequest) -> Error + Send + Sync>>,
+}
+
+impl PathConfig {
+    /// Set custom error handler
+    pub fn error_handler<F>(mut self, f: F) -> Self
+    where
+        F: Fn(PathError, &HttpRequest) -> Error + Send + Sync + 'static,
+    {
+        self.ehandler = Some(Arc::new(f));
+        self
+    }
+}
+
+impl Default for PathConfig {
+    fn default() -> Self {
+        PathConfig { ehandler: None }
     }
 }
 
@@ -176,6 +252,7 @@ mod tests {
 
     use super::*;
     use crate::test::{block_on, TestRequest};
+    use crate::{error, http, HttpResponse};
 
     #[derive(Deserialize, Debug, Display)]
     #[display(fmt = "MyStruct({}, {})", key, value)]
@@ -271,4 +348,21 @@ mod tests {
         assert_eq!(res[1], "32".to_owned());
     }
 
+    #[test]
+    fn test_custom_err_handler() {
+        let (req, mut pl) = TestRequest::with_uri("/name/user1/")
+            .data(PathConfig::default().error_handler(|err, _| {
+                error::InternalError::from_response(
+                    err,
+                    HttpResponse::Conflict().finish(),
+                )
+                .into()
+            }))
+            .to_http_parts();
+
+        let s = block_on(Path::<(usize,)>::from_request(&req, &mut pl)).unwrap_err();
+        let res: HttpResponse = s.into();
+
+        assert_eq!(res.status(), http::StatusCode::CONFLICT);
+    }
 }

test-server/src/lib.rs

@@ -255,6 +255,16 @@ impl TestServerRuntime {
         self.client.head(self.surl(path.as_ref()).as_str())
     }
 
+    /// Create `PUT` request
+    pub fn put<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.put(self.url(path.as_ref()).as_str())
+    }
+
+    /// Create https `PUT` request
+    pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
+        self.client.put(self.surl(path.as_ref()).as_str())
+    }
+
     /// Connect to test http server
     pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
         self.client.request(method, path.as_ref())