Various refactorings (#8)

* update doc comments

* rename server ServiceFactory to StreamServiceFactory

* refactor web service factories

* run tarpaulin on 1.42

* re-enable extractos tests

.github/workflows/linux.yml

@@ -49,10 +49,10 @@ jobs:
           key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo tarpaulin
-        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         uses: actions/cache@v1
         with:
-          path: ~/.cargo/bin/cargo-tarpaulin
+          path: ~/.cargo/bin
           key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-tarpaulin
 
       - name: check build
@@ -69,13 +69,13 @@ jobs:
           args: --all --all-features --no-fail-fast -- --nocapture
 
       - name: Generate coverage file
-        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         run: |
           cargo install cargo-tarpaulin
           cargo tarpaulin --out Xml --all --all-features
 
       - name: Upload to Codecov
-        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         uses: codecov/codecov-action@v1
         with:
           file: cobertura.xml

README.md

@@ -1,9 +1,9 @@
 <div align="center">
  <p><h1>ntex</h1> </p>
-  <p><strong>This is personal project, please, do not use it</strong> </p>
+  <p><strong>This is personal project, do not use it</strong> </p>
   <p>
 
-![Build Status](https://github.com/ntex-rs/ntex/workflows/CI%20(Linux)/badge.svg) 
+[![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)") 
 [![codecov](https://codecov.io/gh/ntex-rs/ntex/branch/master/graph/badge.svg)](https://codecov.io/gh/ntex-rs/ntex) 
 [![crates.io](https://meritbadge.herokuapp.com/ntex)](https://crates.io/crates/ntex) 
 [![Documentation](https://docs.rs/ntex/badge.svg)](https://docs.rs/ntex) 
@@ -13,6 +13,19 @@
   </p>
 </div>
 
+## Build statuses
+
+| Platform         | Build Status |
+| ---------------- | ------------ |
+| Linux            | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)") |
+| macOS            | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28OSX%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(OSX)") |
+| Windows          | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Windows)") |
+
+## Documentation & community resources
+
+* [Documentation](https://docs.rs/ntex)
+* Minimum supported Rust version: 1.42 or later
+
 ## License
 
 This project is licensed under

ntex/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.2] - 2020-04-05
+
+* HTTP1 dispatcher refactoring
+
 ## [0.1.1] - 2020-04-01
 
 * Project fork

ntex/src/connect/mod.rs

@@ -1,9 +1,4 @@
-//! Actix connect - tcp connector service
+//! Tcp connector service
-//!
-//! ## Package feature
-//!
-//! * `openssl` - enables ssl support via `openssl` crate
-//! * `rustls` - enables ssl support via `rustls` crate
 
 mod error;
 mod message;

ntex/src/framed/service.rs

@@ -90,7 +90,7 @@ where
     <Codec as Encoder>::Error: std::fmt::Debug,
     Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    /// Construct framed handler new service with specified connect service
+    /// Construct framed handler service factory with specified connect service
     pub fn new<F>(connect: F) -> FactoryBuilder<St, C, Io, Codec, Out>
     where
         F: IntoServiceFactory<C>,

ntex/src/http/test.rs

@@ -12,7 +12,7 @@ use coo_kie::{Cookie, CookieJar};
 
 use crate::codec::{AsyncRead, AsyncWrite, Framed};
 use crate::rt::{net::TcpStream, System};
-use crate::server::{Server, ServiceFactory};
+use crate::server::{Server, StreamServiceFactory};
 
 use super::client::error::WsClientError;
 use super::client::{Client, ClientRequest, ClientResponse, Connector};
@@ -213,7 +213,7 @@ fn parts(parts: &mut Option<Inner>) -> &mut Inner {
 ///     assert!(response.status().is_success());
 /// }
 /// ```
-pub fn server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+pub fn server<F: StreamServiceFactory<TcpStream>>(factory: F) -> TestServer {
     let (tx, rx) = mpsc::channel();
 
     // run server in separate thread

ntex/src/lib.rs

@@ -1,3 +1,12 @@
+//! ntex - framework for composable network services
+//!
+//! ## Package feature
+//!
+//! * `openssl` - enables ssl support via `openssl` crate
+//! * `rustls` - enables ssl support via `rustls` crate
+//! * `compress` - enables compression support in http and web modules
+//! * `cookie` - enables cookie support in http and web modules
+
 #![warn(
     rust_2018_idioms,
     unreachable_pub,

ntex/src/server/builder.rs

@@ -18,7 +18,7 @@ use crate::rt::{spawn, System};
 
 use super::accept::{AcceptLoop, AcceptNotify, Command};
 use super::config::{ConfiguredService, ServiceConfig};
-use super::service::{InternalServiceFactory, ServiceFactory, StreamNewService};
+use super::service::{Factory, InternalServiceFactory, StreamServiceFactory};
 use super::signals::{Signal, Signals};
 use super::socket::StdListener;
 use super::worker::{self, Worker, WorkerAvailability, WorkerClient};
@@ -164,14 +164,14 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServiceFactory<TcpStream>,
+        F: StreamServiceFactory<TcpStream>,
         U: net::ToSocketAddrs,
     {
         let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
             let token = self.token.next();
-            self.services.push(StreamNewService::create(
+            self.services.push(Factory::create(
                 name.as_ref().to_string(),
                 token,
                 factory.clone(),
@@ -187,7 +187,7 @@ impl ServerBuilder {
     /// Add new unix domain service to the server.
     pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
-        F: ServiceFactory<crate::rt::net::UnixStream>,
+        F: StreamServiceFactory<crate::rt::net::UnixStream>,
         N: AsRef<str>,
         U: AsRef<std::path::Path>,
     {
@@ -217,12 +217,12 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServiceFactory<crate::rt::net::UnixStream>,
+        F: StreamServiceFactory<crate::rt::net::UnixStream>,
     {
         use std::net::{IpAddr, Ipv4Addr, SocketAddr};
         let token = self.token.next();
         let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
-        self.services.push(StreamNewService::create(
+        self.services.push(Factory::create(
             name.as_ref().to_string(),
             token,
             factory,
@@ -241,10 +241,10 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServiceFactory<TcpStream>,
+        F: StreamServiceFactory<TcpStream>,
     {
         let token = self.token.next();
-        self.services.push(StreamNewService::create(
+        self.services.push(Factory::create(
             name.as_ref().to_string(),
             token,
             factory,

ntex/src/server/config.rs

@@ -39,7 +39,7 @@ impl ServiceConfig {
         self.threads = num;
     }
 
-    /// Add new service to server
+    /// Add new service to a server
     pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
     where
         U: net::ToSocketAddrs,
@@ -53,7 +53,7 @@ impl ServiceConfig {
         Ok(self)
     }
 
-    /// Add new service to server
+    /// Add new service to a server
     pub fn listen<N: AsRef<str>>(
         &mut self,
         name: N,

ntex/src/server/mod.rs

@@ -29,7 +29,7 @@ pub mod rustls;
 
 pub use self::builder::ServerBuilder;
 pub use self::config::{ServiceConfig, ServiceRuntime};
-pub use self::service::ServiceFactory;
+pub use self::service::StreamServiceFactory;
 pub use self::test::{build_test_server, test_server, TestServer};
 
 #[doc(hidden)]
@@ -48,7 +48,7 @@ impl Token {
 }
 
 /// Start server building process
-pub fn new() -> ServerBuilder {
+pub fn build() -> ServerBuilder {
     ServerBuilder::default()
 }
 

ntex/src/server/service.rs

@@ -15,7 +15,7 @@ use super::socket::{FromStream, StdStream};
 use super::Token;
 
 /// Server message
-pub(crate) enum ServerMessage {
+pub(super) enum ServerMessage {
     /// New stream
     Connect(StdStream),
     /// Gracefull shutdown
@@ -24,13 +24,13 @@ pub(crate) enum ServerMessage {
     ForceShutdown,
 }
 
-pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
+pub trait StreamServiceFactory<Stream: FromStream>: Send + Clone + 'static {
     type Factory: ActixServiceFactory<Config = (), Request = Stream>;
 
     fn create(&self) -> Self::Factory;
 }
 
-pub(crate) trait InternalServiceFactory: Send {
+pub(super) trait InternalServiceFactory: Send {
     fn name(&self, token: Token) -> &str;
 
     fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
@@ -40,7 +40,7 @@ pub(crate) trait InternalServiceFactory: Send {
     ) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>>;
 }
 
-pub(crate) type BoxedServerService = Box<
+pub(super) type BoxedServerService = Box<
     dyn Service<
         Request = (Option<CounterGuard>, ServerMessage),
         Response = (),
@@ -49,7 +49,7 @@ pub(crate) type BoxedServerService = Box<
     >,
 >;
 
-pub(crate) struct StreamService<T> {
+pub(super) struct StreamService<T> {
     service: T,
 }
 
@@ -104,7 +104,7 @@ where
     }
 }
 
-pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
+pub(super) struct Factory<F: StreamServiceFactory<Io>, Io: FromStream> {
     name: String,
     inner: F,
     token: Token,
@@ -112,9 +112,9 @@ pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
     _t: PhantomData<Io>,
 }
 
-impl<F, Io> StreamNewService<F, Io>
+impl<F, Io> Factory<F, Io>
 where
-    F: ServiceFactory<Io>,
+    F: StreamServiceFactory<Io>,
     Io: FromStream + Send + 'static,
 {
     pub(crate) fn create(
@@ -133,9 +133,9 @@ where
     }
 }
 
-impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
+impl<F, Io> InternalServiceFactory for Factory<F, Io>
 where
-    F: ServiceFactory<Io>,
+    F: StreamServiceFactory<Io>,
     Io: FromStream + Send + 'static,
 {
     fn name(&self, _: Token) -> &str {
@@ -184,7 +184,7 @@ impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
     }
 }
 
-impl<F, T, I> ServiceFactory<I> for F
+impl<F, T, I> StreamServiceFactory<I> for F
 where
     F: Fn() -> T + Send + Clone + 'static,
     T: ActixServiceFactory<Config = (), Request = I>,

ntex/src/server/test.rs

@@ -5,7 +5,7 @@ use std::{io, net, thread};
 use net2::TcpBuilder;
 
 use crate::rt::{net::TcpStream, System};
-use crate::server::{Server, ServerBuilder, ServiceFactory};
+use crate::server::{Server, ServerBuilder, StreamServiceFactory};
 
 /// Start test server
 ///
@@ -38,7 +38,7 @@ use crate::server::{Server, ServerBuilder, ServiceFactory};
 ///     assert!(response.status().is_success());
 /// }
 /// ```
-pub fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+pub fn test_server<F: StreamServiceFactory<TcpStream>>(factory: F) -> TestServer {
     let (tx, rx) = mpsc::channel();
 
     // run server in separate thread

ntex/src/util/either.rs

@@ -6,7 +6,7 @@ use futures::{future, ready, Future};
 
 use crate::service::{Service, ServiceFactory};
 
-/// Construct `Either` service factor.
+/// Construct `Either` service factory.
 ///
 /// Either service allow to combine two different services into a single service.
 pub fn either<A, B>(left: A, right: B) -> Either<A, B>

ntex/src/util/inflight.rs

@@ -1,3 +1,5 @@
+//! Service that limits number of in-flight async requests.
+
 use std::convert::Infallible;
 use std::future::Future;
 use std::pin::Pin;
@@ -8,7 +10,7 @@ use futures::future::{ok, Ready};
 use super::counter::{Counter, CounterGuard};
 use crate::service::{IntoService, Service, Transform};
 
-/// InFlight - new service for service that can limit number of in-flight
+/// InFlight - service factory for service that can limit number of in-flight
 /// async requests.
 ///
 /// Default number of in-flight requests is 15

ntex/src/util/order.rs

@@ -19,7 +19,7 @@ struct Record<I, E> {
     tx: oneshot::Sender<Result<I, E>>,
 }
 
-/// Timeout error
+/// InOrder error
 pub enum InOrderError<E> {
     /// Service error
     Service(E),

ntex/src/util/timeout.rs

@@ -161,6 +161,7 @@ where
 }
 
 /// `TimeoutService` response future
+#[doc(hidden)]
 #[pin_project::pin_project]
 #[derive(Debug)]
 pub struct TimeoutServiceResponse<T: Service> {
@@ -194,6 +195,7 @@ where
 }
 
 /// `TimeoutService` response future
+#[doc(hidden)]
 #[pin_project::pin_project]
 #[derive(Debug)]
 pub struct TimeoutServiceResponse2<T: Service> {

ntex/src/web/app.rs

@@ -17,12 +17,11 @@ use crate::service::{
 use super::app_service::{AppEntry, AppFactory, AppRoutingFactory};
 use super::config::ServiceConfig;
 use super::data::{Data, DataFactory};
+use super::request::WebRequest;
 use super::resource::Resource;
+use super::response::WebResponse;
 use super::route::Route;
-use super::service::{
+use super::service::{AppServiceFactory, ServiceFactoryWrapper, WebServiceFactory};
-    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
-    WebResponse,
-};
 use super::{DefaultError, ErrorRenderer};
 
 type HttpNewService<Err: ErrorRenderer> =
@@ -242,7 +241,7 @@ where
 
     /// Register http service.
     ///
-    /// Http service is any type that implements `HttpServiceFactory` trait.
+    /// Http service is any type that implements `WebServiceFactory` trait.
     ///
     /// Actix web provides several services implementations:
     ///
@@ -251,7 +250,7 @@ where
     /// * "StaticFiles" is a service for static files support
     pub fn service<F>(mut self, factory: F) -> Self
     where
-        F: HttpServiceFactory<Err> + 'static,
+        F: WebServiceFactory<Err> + 'static,
     {
         self.services
             .push(Box::new(ServiceFactoryWrapper::new(factory)));
@@ -522,7 +521,7 @@ mod tests {
     use crate::http::header::{self, HeaderValue};
     use crate::http::{Method, StatusCode};
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::WebRequest;
+    use crate::web::request::WebRequest;
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::{self, DefaultError, HttpRequest, HttpResponse};
     use crate::Service;

ntex/src/web/app_service.rs

@@ -12,13 +12,15 @@ use crate::router::{Path, ResourceDef, ResourceInfo, Router};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
 use crate::{fn_service, Service, ServiceFactory};
 
-use super::config::{AppConfig, AppService};
+use super::config::AppConfig;
 use super::data::DataFactory;
 use super::error::ErrorRenderer;
 use super::guard::Guard;
-use super::request::{HttpRequest, HttpRequestPool};
+use super::httprequest::{HttpRequest, HttpRequestPool};
+use super::request::WebRequest;
+use super::response::WebResponse;
 use super::rmap::ResourceMap;
-use super::service::{AppServiceFactory, WebRequest, WebResponse};
+use super::service::{AppServiceFactory, WebServiceConfig};
 
 type Guards = Vec<Box<dyn Guard>>;
 type HttpService<Err: ErrorRenderer> =
@@ -82,7 +84,8 @@ where
         });
 
         // App config
-        let mut config = AppService::new(config, default.clone(), self.data.clone());
+        let mut config =
+            WebServiceConfig::new(config, default.clone(), self.data.clone());
 
         // register services
         std::mem::replace(&mut *self.services.borrow_mut(), Vec::new())

ntex/src/web/config.rs

@@ -1,128 +1,15 @@
 use std::net::SocketAddr;
 use std::rc::Rc;
 
-use crate::http::Extensions;
 use crate::router::ResourceDef;
-use crate::service::{boxed, IntoServiceFactory, ServiceFactory};
 
 use super::data::{Data, DataFactory};
-use super::guard::Guard;
 use super::resource::Resource;
-use super::rmap::ResourceMap;
 use super::route::Route;
-use super::service::{
+use super::service::{AppServiceFactory, ServiceFactoryWrapper, WebServiceFactory};
-    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
-    WebResponse,
-};
 use super::{DefaultError, ErrorRenderer};
 
-type Guards = Vec<Box<dyn Guard>>;
-type HttpNewService<Err: ErrorRenderer> =
-    boxed::BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
-
 /// Application configuration
-pub struct AppService<Err: ErrorRenderer> {
-    config: AppConfig,
-    root: bool,
-    default: Rc<HttpNewService<Err>>,
-    services: Vec<(
-        ResourceDef,
-        HttpNewService<Err>,
-        Option<Guards>,
-        Option<Rc<ResourceMap>>,
-    )>,
-    service_data: Rc<Vec<Box<dyn DataFactory>>>,
-}
-
-impl<Err: ErrorRenderer> AppService<Err> {
-    /// Crate server settings instance
-    pub(crate) fn new(
-        config: AppConfig,
-        default: Rc<HttpNewService<Err>>,
-        service_data: Rc<Vec<Box<dyn DataFactory>>>,
-    ) -> Self {
-        AppService {
-            config,
-            default,
-            service_data,
-            root: true,
-            services: Vec::new(),
-        }
-    }
-
-    /// Check if root is beeing configured
-    pub fn is_root(&self) -> bool {
-        self.root
-    }
-
-    pub(crate) fn into_services(
-        self,
-    ) -> (
-        AppConfig,
-        Vec<(
-            ResourceDef,
-            HttpNewService<Err>,
-            Option<Guards>,
-            Option<Rc<ResourceMap>>,
-        )>,
-    ) {
-        (self.config, self.services)
-    }
-
-    pub(crate) fn clone_config(&self) -> Self {
-        AppService {
-            config: self.config.clone(),
-            default: self.default.clone(),
-            services: Vec::new(),
-            root: false,
-            service_data: self.service_data.clone(),
-        }
-    }
-
-    /// Service configuration
-    pub fn config(&self) -> &AppConfig {
-        &self.config
-    }
-
-    /// Default resource
-    pub fn default_service(&self) -> Rc<HttpNewService<Err>> {
-        self.default.clone()
-    }
-
-    /// Set global route data
-    pub fn set_service_data(&self, extensions: &mut Extensions) -> bool {
-        for f in self.service_data.iter() {
-            f.create(extensions);
-        }
-        !self.service_data.is_empty()
-    }
-
-    /// Register http service
-    pub fn register_service<F, S>(
-        &mut self,
-        rdef: ResourceDef,
-        guards: Option<Vec<Box<dyn Guard>>>,
-        factory: F,
-        nested: Option<Rc<ResourceMap>>,
-    ) where
-        F: IntoServiceFactory<S>,
-        S: ServiceFactory<
-                Config = (),
-                Request = WebRequest<Err>,
-                Response = WebResponse,
-                Error = Err::Container,
-                InitError = (),
-            > + 'static,
-    {
-        self.services.push((
-            rdef,
-            boxed::factory(factory.into_factory()),
-            guards,
-            nested,
-        ));
-    }
-}
-
 #[derive(Clone)]
 pub struct AppConfig(Rc<AppConfigInner>);
 
@@ -213,7 +100,7 @@ impl<Err: ErrorRenderer> ServiceConfig<Err> {
     /// This is same as `App::service()` method.
     pub fn service<F>(&mut self, factory: F) -> &mut Self
     where
-        F: HttpServiceFactory<Err> + 'static,
+        F: WebServiceFactory<Err> + 'static,
     {
         self.services
             .push(Box::new(ServiceFactoryWrapper::new(factory)));
@@ -250,7 +137,7 @@ mod tests {
     use crate::Service;
 
     #[ntex_rt::test]
-    async fn test_data() {
+    async fn test_configure_data() {
         let cfg = |cfg: &mut ServiceConfig<_>| {
             cfg.data(10usize);
         };
@@ -264,40 +151,8 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
-    // #[ntex_rt::test]
-    // async fn test_data_factory() {
-    //     let cfg = |cfg: &mut ServiceConfig| {
-    //         cfg.data_factory(|| {
-    //             sleep(std::time::Duration::from_millis(50)).then(|_| {
-    //                 println!("READY");
-    //                 Ok::<_, ()>(10usize)
-    //             })
-    //         });
-    //     };
-
-    //     let mut srv =
-    //         init_service(App::new().configure(cfg).service(
-    //             web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
-    //         ));
-    //     let req = TestRequest::default().to_request();
-    //     let resp = srv.call(req).await.unwrap();
-    //     assert_eq!(resp.status(), StatusCode::OK);
-
-    //     let cfg2 = |cfg: &mut ServiceConfig| {
-    //         cfg.data_factory(|| Ok::<_, ()>(10u32));
-    //     };
-    //     let mut srv = init_service(
-    //         App::new()
-    //             .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()))
-    //             .configure(cfg2),
-    //     );
-    //     let req = TestRequest::default().to_request();
-    //     let resp = srv.call(req).await.unwrap();
-    //     assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    // }
-
     #[ntex_rt::test]
-    async fn test_external_resource() {
+    async fn test_configure_external_resource() {
         let mut srv = init_service(
             App::new()
                 .configure(|cfg| {
@@ -325,7 +180,7 @@ mod tests {
     }
 
     #[ntex_rt::test]
-    async fn test_service() {
+    async fn test_configure_service() {
         let mut srv = init_service(App::new().configure(|cfg| {
             cfg.service(
                 web::resource("/test")

ntex/src/web/data.rs

@@ -7,7 +7,7 @@ use crate::http::{Extensions, Payload};
 
 use super::error::{DataExtractorError, ErrorRenderer};
 use super::extract::FromRequest;
-use super::request::HttpRequest;
+use super::httprequest::HttpRequest;
 
 /// Application data factory
 pub(crate) trait DataFactory {

ntex/src/web/error_default.rs

@@ -16,7 +16,7 @@ use super::HttpResponse;
 #[derive(Clone, Copy, Default)]
 pub struct DefaultError;
 
-/// Generic error for error that supports `DefaultError` renderer.
+/// Generic error container for errors that supports `DefaultError` renderer.
 pub struct Error {
     cause: Box<dyn WebResponseError<DefaultError>>,
 }

ntex/src/web/extract.rs

@@ -8,7 +8,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
 use crate::http::Payload;
 
 use super::error::ErrorRenderer;
-use super::request::HttpRequest;
+use super::httprequest::HttpRequest;
 
 /// Trait implemented by types that can be extracted from request.
 ///
@@ -258,105 +258,98 @@ tuple_from_req!(TupleFromRequest9, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F
 tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use bytes::Bytes;
+    use bytes::Bytes;
-//     use serde_derive::Deserialize;
+    use serde_derive::Deserialize;
 
-//     use super::*;
+    use crate::http::header;
-//     use crate::http::header;
+    use crate::web::error::UrlencodedError;
-//     use crate::web::error::DefaultError;
+    use crate::web::test::{from_request, TestRequest};
-//     use crate::web::test::TestRequest;
+    use crate::web::types::{Form, FormConfig};
-//     use crate::web::types::{Form, FormConfig};
 
-//     #[derive(Deserialize, Debug, PartialEq)]
+    #[derive(Deserialize, Debug, PartialEq)]
-//     struct Info {
+    struct Info {
-//         hello: String,
+        hello: String,
-//     }
+    }
 
-//     fn extract<T: FromRequest<DefaultError>>(
+    #[ntex_rt::test]
-//         extract: T,
+    async fn test_option() {
-//     ) -> impl FromRequest<DefaultError, Error = T::Error> {
+        let (req, mut pl) = TestRequest::with_header(
-//         extract
+            header::CONTENT_TYPE,
-//     }
+            "application/x-www-form-urlencoded",
+        )
+        .data(FormConfig::default().limit(4096))
+        .to_http_parts();
 
-//     #[ntex_rt::test]
+        let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
-//     async fn test_option() {
+            .await
-//         let (req, mut pl) = TestRequest::with_header(
+            .unwrap();
-//             header::CONTENT_TYPE,
+        assert_eq!(r, None);
-//             "application/x-www-form-urlencoded",
-//         )
-//         .data(FormConfig::default().limit(4096))
-//         .to_http_parts();
 
-//         let r = Option::<Form<Info>>::from_request(&req, &mut pl)
+        let (req, mut pl) = TestRequest::with_header(
-//             .await
+            header::CONTENT_TYPE,
-//             .unwrap();
+            "application/x-www-form-urlencoded",
-//         assert_eq!(r, None);
+        )
+        .header(header::CONTENT_LENGTH, "9")
+        .set_payload(Bytes::from_static(b"hello=world"))
+        .to_http_parts();
 
-//         let (req, mut pl) = TestRequest::with_header(
+        let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
-//             header::CONTENT_TYPE,
+            .await
-//             "application/x-www-form-urlencoded",
+            .unwrap();
-//         )
+        assert_eq!(
-//         .header(header::CONTENT_LENGTH, "9")
+            r,
-//         .set_payload(Bytes::from_static(b"hello=world"))
+            Some(Form(Info {
-//         .to_http_parts();
+                hello: "world".into()
+            }))
+        );
 
-//         let r = Option::<Form<Info>>::from_request(&req, &mut pl)
+        let (req, mut pl) = TestRequest::with_header(
-//             .await
+            header::CONTENT_TYPE,
-//             .unwrap();
+            "application/x-www-form-urlencoded",
-//         assert_eq!(
+        )
-//             r,
+        .header(header::CONTENT_LENGTH, "9")
-//             Some(Form(Info {
+        .set_payload(Bytes::from_static(b"bye=world"))
-//                 hello: "world".into()
+        .to_http_parts();
-//             }))
-//         );
 
-//         let (req, mut pl) = TestRequest::with_header(
+        let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
-//             header::CONTENT_TYPE,
+            .await
-//             "application/x-www-form-urlencoded",
+            .unwrap();
-//         )
+        assert_eq!(r, None);
-//         .header(header::CONTENT_LENGTH, "9")
+    }
-//         .set_payload(Bytes::from_static(b"bye=world"))
-//         .to_http_parts();
 
-//         let r = Option::<Form<Info>>::from_request(&req, &mut pl)
+    #[ntex_rt::test]
-//             .await
+    async fn test_result() {
-//             .unwrap();
+        let (req, mut pl) = TestRequest::with_header(
-//         assert_eq!(r, None);
+            header::CONTENT_TYPE,
-//     }
+            "application/x-www-form-urlencoded",
+        )
+        .header(header::CONTENT_LENGTH, "11")
+        .set_payload(Bytes::from_static(b"hello=world"))
+        .to_http_parts();
 
-//     #[ntex_rt::test]
+        let r = from_request::<Result<Form<Info>, UrlencodedError>>(&req, &mut pl)
-//     async fn test_result() {
+            .await
-//         let (req, mut pl) = TestRequest::with_header(
+            .unwrap();
-//             header::CONTENT_TYPE,
+        assert_eq!(
-//             "application/x-www-form-urlencoded",
+            r.unwrap(),
-//         )
+            Form(Info {
-//         .header(header::CONTENT_LENGTH, "11")
+                hello: "world".into()
-//         .set_payload(Bytes::from_static(b"hello=world"))
+            })
-//         .to_http_parts();
+        );
 
-//         let r: Result<Form<Info>, WebError> = FromRequest::<DefaultError>::from_request(&req, &mut pl)
+        let (req, mut pl) = TestRequest::with_header(
-//             .await
+            header::CONTENT_TYPE,
-//             .unwrap();
+            "application/x-www-form-urlencoded",
-//         assert_eq!(
+        )
-//             r.unwrap(),
+        .header(header::CONTENT_LENGTH, "9")
-//             Form(Info {
+        .set_payload(Bytes::from_static(b"bye=world"))
-//                 hello: "world".into()
+        .to_http_parts();
-//             })
-//         );
 
-//         let (req, mut pl) = TestRequest::with_header(
+        let r = from_request::<Result<Form<Info>, UrlencodedError>>(&req, &mut pl)
-//             header::CONTENT_TYPE,
+            .await
-//             "application/x-www-form-urlencoded",
+            .unwrap();
-//         )
+        assert!(r.is_err());
-//         .header(header::CONTENT_LENGTH, "9")
+    }
-//         .set_payload(Bytes::from_static(b"bye=world"))
+}
-//         .to_http_parts();
-
-//         let r: Result::<Form<Info>, WebError> = FromRequest::from_request(&req, &mut pl)
-//             .await
-//             .unwrap();
-//         assert!(r.is_err());
-//     }
-// }

ntex/src/web/handler.rs

@@ -8,9 +8,10 @@ use pin_project::pin_project;
 
 use super::error::ErrorRenderer;
 use super::extract::FromRequest;
-use super::request::HttpRequest;
+use super::httprequest::HttpRequest;
+use super::request::WebRequest;
 use super::responder::Responder;
-use super::service::{WebRequest, WebResponse};
+use super::response::WebResponse;
 
 /// Async fn handler
 pub trait Handler<T, Err>: Clone + 'static

ntex/src/web/httprequest.rs

@@ -0,0 +1,530 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::rc::Rc;
+use std::{fmt, net};
+
+use futures::future::{ok, Ready};
+
+use crate::http::{
+    Extensions, HeaderMap, HttpMessage, Message, Method, Payload, RequestHead, Uri,
+    Version,
+};
+use crate::router::Path;
+
+use super::config::AppConfig;
+use super::error::{ErrorRenderer, UrlGenerationError};
+use super::extract::FromRequest;
+use super::info::ConnectionInfo;
+use super::rmap::ResourceMap;
+
+#[derive(Clone)]
+/// An HTTP Request
+pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
+
+pub(crate) struct HttpRequestInner {
+    pub(crate) head: Message<RequestHead>,
+    pub(crate) path: Path<Uri>,
+    pub(crate) payload: Payload,
+    pub(crate) app_data: Rc<Extensions>,
+    rmap: Rc<ResourceMap>,
+    config: AppConfig,
+    pool: &'static HttpRequestPool,
+}
+
+impl HttpRequest {
+    #[inline]
+    pub(crate) fn new(
+        path: Path<Uri>,
+        head: Message<RequestHead>,
+        payload: Payload,
+        rmap: Rc<ResourceMap>,
+        config: AppConfig,
+        app_data: Rc<Extensions>,
+        pool: &'static HttpRequestPool,
+    ) -> HttpRequest {
+        HttpRequest(Rc::new(HttpRequestInner {
+            head,
+            path,
+            payload,
+            rmap,
+            config,
+            app_data,
+            pool,
+        }))
+    }
+}
+
+impl HttpRequest {
+    /// This method returns reference to the request head
+    #[inline]
+    pub fn head(&self) -> &RequestHead {
+        &self.0.head
+    }
+
+    /// This method returns muttable reference to the request head.
+    /// panics if multiple references of http request exists.
+    #[inline]
+    pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
+        &mut Rc::get_mut(&mut self.0).unwrap().head
+    }
+
+    /// Request's uri.
+    #[inline]
+    pub fn uri(&self) -> &Uri {
+        &self.head().uri
+    }
+
+    /// Read the Request method.
+    #[inline]
+    pub fn method(&self) -> &Method {
+        &self.head().method
+    }
+
+    /// Read the Request Version.
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.head().version
+    }
+
+    #[inline]
+    /// Returns request's headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.head().headers
+    }
+
+    /// The target path of this Request.
+    #[inline]
+    pub fn path(&self) -> &str {
+        self.head().uri.path()
+    }
+
+    /// The query string in the URL.
+    ///
+    /// E.g., id=10
+    #[inline]
+    pub fn query_string(&self) -> &str {
+        if let Some(query) = self.uri().query().as_ref() {
+            query
+        } else {
+            ""
+        }
+    }
+
+    /// Get a reference to the Path parameters.
+    ///
+    /// Params is a container for url parameters.
+    /// A variable segment is specified in the form `{identifier}`,
+    /// where the identifier can be used later in a request handler to
+    /// access the matched value for that segment.
+    #[inline]
+    pub fn match_info(&self) -> &Path<Uri> {
+        &self.0.path
+    }
+
+    #[inline]
+    pub(crate) fn match_info_mut(&mut self) -> &mut Path<Uri> {
+        &mut Rc::get_mut(&mut self.0).unwrap().path
+    }
+
+    /// Request extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<'_, Extensions> {
+        self.head().extensions()
+    }
+
+    /// Mutable reference to a the request's extensions
+    #[inline]
+    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
+        self.head().extensions_mut()
+    }
+
+    /// Generate url for named resource
+    ///
+    /// ```rust
+    /// # use ntex::web::{self, App, HttpRequest, HttpResponse};
+    /// #
+    /// async fn index(req: HttpRequest) -> HttpResponse {
+    ///     let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
+    ///     HttpResponse::Ok().into()
+    /// }
+    ///
+    /// fn main() {
+    ///     let app = App::new()
+    ///         .service(web::resource("/test/{one}/{two}/{three}")
+    ///              .name("foo")  // <- set resource name, then it could be used in `url_for`
+    ///              .route(web::get().to(index))
+    ///         );
+    /// }
+    /// ```
+    pub fn url_for<U, I>(
+        &self,
+        name: &str,
+        elements: U,
+    ) -> Result<url::Url, UrlGenerationError>
+    where
+        U: IntoIterator<Item = I>,
+        I: AsRef<str>,
+    {
+        self.0.rmap.url_for(&self, name, elements)
+    }
+
+    /// Generate url for named resource
+    ///
+    /// This method is similar to `HttpRequest::url_for()` but it can be used
+    /// for urls that do not contain variable parts.
+    pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenerationError> {
+        const NO_PARAMS: [&str; 0] = [];
+        self.url_for(name, &NO_PARAMS)
+    }
+
+    #[inline]
+    /// Get a reference to a `ResourceMap` of current application.
+    pub fn resource_map(&self) -> &ResourceMap {
+        &self.0.rmap
+    }
+
+    /// Peer socket address
+    ///
+    /// Peer address is actual socket address, if proxy is used in front of
+    /// actix http server, then peer address would be address of this proxy.
+    ///
+    /// To get client connection information `.connection_info()` should be used.
+    #[inline]
+    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.head().peer_addr
+    }
+
+    /// Get *ConnectionInfo* for the current request.
+    ///
+    /// This method panics if request's extensions container is already
+    /// borrowed.
+    #[inline]
+    pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
+        ConnectionInfo::get(self.head(), &*self.app_config())
+    }
+
+    /// App config
+    #[inline]
+    pub fn app_config(&self) -> &AppConfig {
+        &self.0.config
+    }
+
+    /// Get an application data object stored with `App::data` or `App::app_data`
+    /// methods during application configuration.
+    ///
+    /// If `App::data` was used to store object, use `Data<T>`:
+    ///
+    /// ```rust,ignore
+    /// let opt_t = req.app_data::<Data<T>>();
+    /// ```
+    pub fn app_data<T: 'static>(&self) -> Option<&T> {
+        if let Some(st) = self.0.app_data.get::<T>() {
+            Some(&st)
+        } else {
+            None
+        }
+    }
+}
+
+impl HttpMessage for HttpRequest {
+    #[inline]
+    /// Returns Request's headers.
+    fn message_headers(&self) -> &HeaderMap {
+        &self.head().headers
+    }
+
+    /// Request extensions
+    #[inline]
+    fn message_extensions(&self) -> Ref<'_, Extensions> {
+        self.0.head.extensions()
+    }
+
+    /// Mutable reference to a the request's extensions
+    #[inline]
+    fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
+        self.0.head.extensions_mut()
+    }
+}
+
+impl Drop for HttpRequest {
+    fn drop(&mut self) {
+        if Rc::strong_count(&self.0) == 1 {
+            let v = &mut self.0.pool.0.borrow_mut();
+            if v.len() < 128 {
+                self.extensions_mut().clear();
+                v.push(self.0.clone());
+            }
+        }
+    }
+}
+
+/// It is possible to get `HttpRequest` as an extractor handler parameter
+///
+/// ## Example
+///
+/// ```rust
+/// use ntex::web::{self, App, HttpRequest};
+/// use serde_derive::Deserialize;
+///
+/// /// extract `Thing` from request
+/// async fn index(req: HttpRequest) -> String {
+///    format!("Got thing: {:?}", req)
+/// }
+///
+/// fn main() {
+///     let app = App::new().service(
+///         web::resource("/users/{first}").route(
+///             web::get().to(index))
+///     );
+/// }
+/// ```
+impl<Err: ErrorRenderer> FromRequest<Err> for HttpRequest {
+    type Error = Err::Container;
+    type Future = Ready<Result<Self, Self::Error>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        ok(req.clone())
+    }
+}
+
+impl fmt::Debug for HttpRequest {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            f,
+            "\nHttpRequest {:?} {}:{}",
+            self.0.head.version,
+            self.0.head.method,
+            self.path()
+        )?;
+        if !self.query_string().is_empty() {
+            writeln!(f, "  query: ?{:?}", self.query_string())?;
+        }
+        if !self.match_info().is_empty() {
+            writeln!(f, "  params: {:?}", self.match_info())?;
+        }
+        writeln!(f, "  headers:")?;
+        for (key, val) in self.headers().iter() {
+            writeln!(f, "    {:?}: {:?}", key, val)?;
+        }
+        Ok(())
+    }
+}
+
+/// Request's objects pool
+pub(crate) struct HttpRequestPool(RefCell<Vec<Rc<HttpRequestInner>>>);
+
+impl HttpRequestPool {
+    pub(crate) fn create() -> &'static HttpRequestPool {
+        let pool = HttpRequestPool(RefCell::new(Vec::with_capacity(128)));
+        Box::leak(Box::new(pool))
+    }
+
+    /// Get message from the pool
+    #[inline]
+    pub(crate) fn get_request(&self) -> Option<HttpRequest> {
+        if let Some(inner) = self.0.borrow_mut().pop() {
+            Some(HttpRequest(inner))
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn clear(&self) {
+        self.0.borrow_mut().clear()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::ready;
+
+    use super::*;
+    use crate::http::{header, StatusCode};
+    use crate::router::ResourceDef;
+    use crate::web::dev::ResourceMap;
+    use crate::web::test::{call_service, init_service, TestRequest};
+    use crate::web::{self, App, HttpResponse};
+
+    #[test]
+    fn test_debug() {
+        let req =
+            TestRequest::with_header("content-type", "text/plain").to_http_request();
+        let dbg = format!("{:?}", req);
+        assert!(dbg.contains("HttpRequest"));
+    }
+
+    #[cfg(feature = "cookie")]
+    #[test]
+    fn test_no_request_cookies() {
+        let req = TestRequest::default().to_http_request();
+        assert!(req.cookies().unwrap().is_empty());
+    }
+
+    #[cfg(feature = "cookie")]
+    #[test]
+    fn test_request_cookies() {
+        let req = TestRequest::default()
+            .header(header::COOKIE, "cookie1=value1")
+            .header(header::COOKIE, "cookie2=value2")
+            .to_http_request();
+        {
+            let cookies = req.cookies().unwrap();
+            assert_eq!(cookies.len(), 2);
+            assert_eq!(cookies[0].name(), "cookie2");
+            assert_eq!(cookies[0].value(), "value2");
+            assert_eq!(cookies[1].name(), "cookie1");
+            assert_eq!(cookies[1].value(), "value1");
+        }
+
+        let cookie = req.cookie("cookie1");
+        assert!(cookie.is_some());
+        let cookie = cookie.unwrap();
+        assert_eq!(cookie.name(), "cookie1");
+        assert_eq!(cookie.value(), "value1");
+
+        let cookie = req.cookie("cookie-unknown");
+        assert!(cookie.is_none());
+    }
+
+    #[test]
+    fn test_request_query() {
+        let req = TestRequest::with_uri("/?id=test").to_http_request();
+        assert_eq!(req.query_string(), "id=test");
+    }
+
+    #[test]
+    fn test_url_for() {
+        let mut res = ResourceDef::new("/user/{name}.{ext}");
+        *res.name_mut() = "index".to_string();
+
+        let mut rmap = ResourceMap::new(ResourceDef::new(""));
+        rmap.add(&mut res, None);
+        //assert!(rmap.has_resource("/user/test.html"));
+        //assert!(!rmap.has_resource("/test/unknown"));
+
+        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
+            .rmap(rmap)
+            .to_http_request();
+
+        assert_eq!(
+            req.url_for("unknown", &["test"]),
+            Err(UrlGenerationError::ResourceNotFound)
+        );
+        assert_eq!(
+            req.url_for("index", &["test"]),
+            Err(UrlGenerationError::NotEnoughElements)
+        );
+        let url = req.url_for("index", &["test", "html"]);
+        assert_eq!(
+            url.ok().unwrap().as_str(),
+            "http://www.rust-lang.org/user/test.html"
+        );
+    }
+
+    #[test]
+    fn test_url_for_static() {
+        let mut rdef = ResourceDef::new("/index.html");
+        *rdef.name_mut() = "index".to_string();
+
+        let mut rmap = ResourceMap::new(ResourceDef::new(""));
+        rmap.add(&mut rdef, None);
+
+        // assert!(rmap.has_resource("/index.html"));
+
+        let req = TestRequest::with_uri("/test")
+            .header(header::HOST, "www.rust-lang.org")
+            .rmap(rmap)
+            .to_http_request();
+        let url = req.url_for_static("index");
+        assert_eq!(
+            url.ok().unwrap().as_str(),
+            "http://www.rust-lang.org/index.html"
+        );
+    }
+
+    #[test]
+    fn test_url_for_external() {
+        let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");
+
+        *rdef.name_mut() = "youtube".to_string();
+
+        let mut rmap = ResourceMap::new(ResourceDef::new(""));
+        rmap.add(&mut rdef, None);
+        // assert!(rmap.has_resource("https://youtube.com/watch/unknown"));
+
+        let req = TestRequest::default().rmap(rmap).to_http_request();
+        let url = req.url_for("youtube", &["oHg5SJYRHA0"]);
+        assert_eq!(
+            url.ok().unwrap().as_str(),
+            "https://youtube.com/watch/oHg5SJYRHA0"
+        );
+    }
+
+    #[ntex_rt::test]
+    async fn test_data() {
+        let mut srv = init_service(App::new().app_data(10usize).service(
+            web::resource("/").to(|req: HttpRequest| {
+                ready(if req.app_data::<usize>().is_some() {
+                    HttpResponse::Ok()
+                } else {
+                    HttpResponse::BadRequest()
+                })
+            }),
+        ))
+        .await;
+
+        let req = TestRequest::default().to_request();
+        let resp = call_service(&mut srv, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let mut srv = init_service(App::new().app_data(10u32).service(
+            web::resource("/").to(|req: HttpRequest| async move {
+                if req.app_data::<usize>().is_some() {
+                    HttpResponse::Ok()
+                } else {
+                    HttpResponse::BadRequest()
+                }
+            }),
+        ))
+        .await;
+
+        let req = TestRequest::default().to_request();
+        let resp = call_service(&mut srv, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[ntex_rt::test]
+    async fn test_extensions_dropped() {
+        struct Tracker {
+            dropped: bool,
+        }
+        struct Foo {
+            tracker: Rc<RefCell<Tracker>>,
+        }
+        impl Drop for Foo {
+            fn drop(&mut self) {
+                self.tracker.borrow_mut().dropped = true;
+            }
+        }
+
+        let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
+        {
+            let tracker2 = Rc::clone(&tracker);
+            let mut srv = init_service(App::new().data(10u32).service(
+                web::resource("/").to(move |req: HttpRequest| {
+                    req.extensions_mut().insert(Foo {
+                        tracker: Rc::clone(&tracker2),
+                    });
+                    ready(HttpResponse::Ok())
+                }),
+            ))
+            .await;
+
+            let req = TestRequest::default().to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+        }
+
+        assert!(tracker.borrow().dropped);
+    }
+}

ntex/src/web/middleware/compress.rs

@@ -14,9 +14,8 @@ use crate::http::encoding::Encoder;
 use crate::http::header::{ContentEncoding, ACCEPT_ENCODING};
 use crate::service::{Service, Transform};
 
-use crate::web::dev::BodyEncoding;
+use crate::web::dev::{WebRequest, WebResponse};
-use crate::web::service::{WebRequest, WebResponse};
+use crate::web::{BodyEncoding, ErrorRenderer};
-use crate::web::ErrorRenderer;
 
 #[derive(Debug, Clone)]
 /// `Middleware` for compressing response body.

ntex/src/web/middleware/defaultheaders.rs

@@ -9,7 +9,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
 use crate::http::error::HttpError;
 use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
 use crate::service::{Service, Transform};
-use crate::web::service::{WebRequest, WebResponse};
+use crate::web::dev::{WebRequest, WebResponse};
 
 /// `Middleware` for setting default response headers.
 ///
@@ -172,7 +172,7 @@ mod tests {
     use super::*;
     use crate::http::header::CONTENT_TYPE;
     use crate::service::IntoService;
-    use crate::web::service::WebRequest;
+    use crate::web::request::WebRequest;
     use crate::web::test::{ok_service, TestRequest};
     use crate::web::{DefaultError, Error, HttpResponse};
 

ntex/src/web/middleware/logger.rs

@@ -18,7 +18,7 @@ use time::OffsetDateTime;
 use crate::http::body::{BodySize, MessageBody, ResponseBody};
 use crate::http::header::HeaderName;
 use crate::service::{Service, Transform};
-use crate::web::service::{WebRequest, WebResponse};
+use crate::web::dev::{WebRequest, WebResponse};
 use crate::web::HttpResponse;
 
 /// `Middleware` for logging request and response info to the terminal.

ntex/src/web/mod.rs

@@ -71,11 +71,13 @@ mod error_default;
 mod extract;
 pub mod guard;
 mod handler;
+mod httprequest;
 mod info;
 pub mod middleware;
 mod request;
 mod resource;
 mod responder;
+mod response;
 mod rmap;
 mod route;
 mod scope;
@@ -94,13 +96,12 @@ pub use self::data::Data;
 pub use self::error::{DefaultError, Error, ErrorRenderer, WebResponseError};
 pub use self::extract::FromRequest;
 pub use self::handler::Handler;
-pub use self::request::HttpRequest;
+pub use self::httprequest::HttpRequest;
 pub use self::resource::Resource;
 pub use self::responder::{Either, Responder};
 pub use self::route::Route;
 pub use self::scope::Scope;
 pub use self::server::HttpServer;
-pub use self::service::WebService;
 pub use self::util::*;
 
 pub mod dev {
@@ -110,11 +111,13 @@ pub mod dev {
     //! traits by adding a glob import to the top of ntex::web heavy modules:
 
     use super::Handler;
-    pub use crate::web::config::{AppConfig, AppService};
+    pub use crate::web::config::AppConfig;
     pub use crate::web::info::ConnectionInfo;
+    pub use crate::web::request::WebRequest;
+    pub use crate::web::response::WebResponse;
     pub use crate::web::rmap::ResourceMap;
     pub use crate::web::service::{
-        HttpServiceFactory, WebRequest, WebResponse, WebService,
+        WebServiceAdapter, WebServiceConfig, WebServiceFactory,
     };
 
     pub(crate) fn insert_slesh(mut patterns: Vec<String>) -> Vec<String> {
@@ -126,50 +129,6 @@ pub mod dev {
         patterns
     }
 
-    use crate::http::header::ContentEncoding;
-    use crate::http::{Response, ResponseBuilder};
-
-    struct Enc(ContentEncoding);
-
-    /// Helper trait that allows to set specific encoding for response.
-    pub trait BodyEncoding {
-        /// Get content encoding
-        fn get_encoding(&self) -> Option<ContentEncoding>;
-
-        /// Set content encoding
-        fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self;
-    }
-
-    impl BodyEncoding for ResponseBuilder {
-        fn get_encoding(&self) -> Option<ContentEncoding> {
-            if let Some(ref enc) = self.extensions().get::<Enc>() {
-                Some(enc.0)
-            } else {
-                None
-            }
-        }
-
-        fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
-            self.extensions_mut().insert(Enc(encoding));
-            self
-        }
-    }
-
-    impl<B> BodyEncoding for Response<B> {
-        fn get_encoding(&self) -> Option<ContentEncoding> {
-            if let Some(ref enc) = self.extensions().get::<Enc>() {
-                Some(enc.0)
-            } else {
-                None
-            }
-        }
-
-        fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
-            self.extensions_mut().insert(Enc(encoding));
-            self
-        }
-    }
-
     #[doc(hidden)]
     #[inline(always)]
     pub fn __assert_extractor<Err, T>()

ntex/src/web/request.rs

@@ -1,70 +1,97 @@
-use std::cell::{Ref, RefCell, RefMut};
+use std::cell::{Ref, RefMut};
+use std::marker::PhantomData;
 use std::rc::Rc;
 use std::{fmt, net};
 
-use futures::future::{ok, Ready};
-
 use crate::http::{
-    Extensions, HeaderMap, HttpMessage, Message, Method, Payload, RequestHead, Uri,
+    Extensions, HeaderMap, HttpMessage, Method, Payload, PayloadStream, RequestHead,
-    Version,
+    Response, Uri, Version,
 };
-use crate::router::Path;
+use crate::router::{Path, Resource};
 
 use super::config::AppConfig;
-use super::error::{ErrorRenderer, UrlGenerationError};
+use super::data::Data;
-use super::extract::FromRequest;
+use super::error::ErrorRenderer;
+use super::httprequest::HttpRequest;
 use super::info::ConnectionInfo;
+use super::response::WebResponse;
 use super::rmap::ResourceMap;
 
-#[derive(Clone)]
+/// An service http request
-/// An HTTP Request
+///
-pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
+/// WebRequest allows mutable access to request's internal structures
-
+pub struct WebRequest<Err> {
-pub(crate) struct HttpRequestInner {
+    req: HttpRequest,
-    pub(crate) head: Message<RequestHead>,
+    _t: PhantomData<Err>,
-    pub(crate) path: Path<Uri>,
-    pub(crate) payload: Payload,
-    pub(crate) app_data: Rc<Extensions>,
-    rmap: Rc<ResourceMap>,
-    config: AppConfig,
-    pool: &'static HttpRequestPool,
 }
 
-impl HttpRequest {
+impl<Err: ErrorRenderer> WebRequest<Err> {
+    /// Create web response for error
     #[inline]
-    pub(crate) fn new(
+    pub fn error_response<B, E: Into<Err::Container>>(self, err: E) -> WebResponse<B> {
-        path: Path<Uri>,
+        WebResponse::from_err::<Err, E>(err, self.req)
-        head: Message<RequestHead>,
-        payload: Payload,
-        rmap: Rc<ResourceMap>,
-        config: AppConfig,
-        app_data: Rc<Extensions>,
-        pool: &'static HttpRequestPool,
-    ) -> HttpRequest {
-        HttpRequest(Rc::new(HttpRequestInner {
-            head,
-            path,
-            payload,
-            rmap,
-            config,
-            app_data,
-            pool,
-        }))
     }
 }
 
-impl HttpRequest {
+impl<Err> WebRequest<Err> {
+    /// Construct web request
+    pub(crate) fn new(req: HttpRequest) -> Self {
+        WebRequest {
+            req,
+            _t: PhantomData,
+        }
+    }
+
+    /// Deconstruct request into parts
+    pub fn into_parts(mut self) -> (HttpRequest, Payload) {
+        let pl = Rc::get_mut(&mut (self.req).0).unwrap().payload.take();
+        (self.req, pl)
+    }
+
+    /// Construct request from parts.
+    ///
+    /// `WebRequest` can be re-constructed only if `req` hasnt been cloned.
+    pub fn from_parts(
+        mut req: HttpRequest,
+        pl: Payload,
+    ) -> Result<Self, (HttpRequest, Payload)> {
+        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
+            Rc::get_mut(&mut req.0).unwrap().payload = pl;
+            Ok(WebRequest::new(req))
+        } else {
+            Err((req, pl))
+        }
+    }
+
+    /// Construct request from request.
+    ///
+    /// `HttpRequest` implements `Clone` trait via `Rc` type. `WebRequest`
+    /// can be re-constructed only if rc's strong pointers count eq 1 and
+    /// weak pointers count is 0.
+    pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
+        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
+            Ok(WebRequest::new(req))
+        } else {
+            Err(req)
+        }
+    }
+
+    /// Create web response
+    #[inline]
+    pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
+        WebResponse::new(self.req, res.into())
+    }
+
     /// This method returns reference to the request head
     #[inline]
     pub fn head(&self) -> &RequestHead {
-        &self.0.head
+        &self.req.head()
     }
 
-    /// This method returns muttable reference to the request head.
+    /// This method returns reference to the request head
-    /// panics if multiple references of http request exists.
     #[inline]
-    pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
+    pub fn head_mut(&mut self) -> &mut RequestHead {
-        &mut Rc::get_mut(&mut self.0).unwrap().head
+        self.req.head_mut()
     }
 
     /// Request's uri.
@@ -91,6 +118,12 @@ impl HttpRequest {
         &self.head().headers
     }
 
+    #[inline]
+    /// Returns mutable request's headers.
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.head_mut().headers
+    }
+
     /// The target path of this Request.
     #[inline]
     pub fn path(&self) -> &str {
@@ -109,6 +142,23 @@ impl HttpRequest {
         }
     }
 
+    /// Peer socket address
+    ///
+    /// Peer address is actual socket address, if proxy is used in front of
+    /// actix http server, then peer address would be address of this proxy.
+    ///
+    /// To get client connection information `ConnectionInfo` should be used.
+    #[inline]
+    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.head().peer_addr
+    }
+
+    /// Get *ConnectionInfo* for the current request.
+    #[inline]
+    pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
+        ConnectionInfo::get(self.head(), &*self.app_config())
+    }
+
     /// Get a reference to the Path parameters.
     ///
     /// Params is a container for url parameters.
@@ -117,115 +167,80 @@ impl HttpRequest {
     /// access the matched value for that segment.
     #[inline]
     pub fn match_info(&self) -> &Path<Uri> {
-        &self.0.path
+        self.req.match_info()
     }
 
     #[inline]
-    pub(crate) fn match_info_mut(&mut self) -> &mut Path<Uri> {
+    /// Get a mutable reference to the Path parameters.
-        &mut Rc::get_mut(&mut self.0).unwrap().path
+    pub fn match_info_mut(&mut self) -> &mut Path<Uri> {
-    }
+        self.req.match_info_mut()
-
-    /// Request extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
-        self.head().extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.head().extensions_mut()
-    }
-
-    /// Generate url for named resource
-    ///
-    /// ```rust
-    /// # use ntex::web::{self, App, HttpRequest, HttpResponse};
-    /// #
-    /// async fn index(req: HttpRequest) -> HttpResponse {
-    ///     let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
-    ///     HttpResponse::Ok().into()
-    /// }
-    ///
-    /// fn main() {
-    ///     let app = App::new()
-    ///         .service(web::resource("/test/{one}/{two}/{three}")
-    ///              .name("foo")  // <- set resource name, then it could be used in `url_for`
-    ///              .route(web::get().to(index))
-    ///         );
-    /// }
-    /// ```
-    pub fn url_for<U, I>(
-        &self,
-        name: &str,
-        elements: U,
-    ) -> Result<url::Url, UrlGenerationError>
-    where
-        U: IntoIterator<Item = I>,
-        I: AsRef<str>,
-    {
-        self.0.rmap.url_for(&self, name, elements)
-    }
-
-    /// Generate url for named resource
-    ///
-    /// This method is similar to `HttpRequest::url_for()` but it can be used
-    /// for urls that do not contain variable parts.
-    pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenerationError> {
-        const NO_PARAMS: [&str; 0] = [];
-        self.url_for(name, &NO_PARAMS)
     }
 
     #[inline]
     /// Get a reference to a `ResourceMap` of current application.
     pub fn resource_map(&self) -> &ResourceMap {
-        &self.0.rmap
+        self.req.resource_map()
     }
 
-    /// Peer socket address
+    /// Service configuration
-    ///
-    /// Peer address is actual socket address, if proxy is used in front of
-    /// actix http server, then peer address would be address of this proxy.
-    ///
-    /// To get client connection information `.connection_info()` should be used.
-    #[inline]
-    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.head().peer_addr
-    }
-
-    /// Get *ConnectionInfo* for the current request.
-    ///
-    /// This method panics if request's extensions container is already
-    /// borrowed.
-    #[inline]
-    pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
-        ConnectionInfo::get(self.head(), &*self.app_config())
-    }
-
-    /// App config
     #[inline]
     pub fn app_config(&self) -> &AppConfig {
-        &self.0.config
+        self.req.app_config()
     }
 
-    /// Get an application data object stored with `App::data` or `App::app_data`
+    #[inline]
-    /// methods during application configuration.
+    /// Get an application data stored with `App::data()` method during
-    ///
+    /// application configuration.
-    /// If `App::data` was used to store object, use `Data<T>`:
+    pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
-    ///
+        if let Some(st) = (self.req).0.app_data.get::<Data<T>>() {
-    /// ```rust,ignore
+            Some(st.clone())
-    /// let opt_t = req.app_data::<Data<T>>();
-    /// ```
-    pub fn app_data<T: 'static>(&self) -> Option<&T> {
-        if let Some(st) = self.0.app_data.get::<T>() {
-            Some(&st)
         } else {
             None
         }
     }
+
+    #[inline]
+    /// Get request's payload
+    pub fn take_payload(&mut self) -> Payload<PayloadStream> {
+        Rc::get_mut(&mut (self.req).0).unwrap().payload.take()
     }
 
-impl HttpMessage for HttpRequest {
+    #[inline]
+    /// Set request payload.
+    pub fn set_payload(&mut self, payload: Payload) {
+        Rc::get_mut(&mut (self.req).0).unwrap().payload = payload;
+    }
+
+    #[doc(hidden)]
+    /// Set new app data container
+    pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
+        Rc::get_mut(&mut (self.req).0).unwrap().app_data = extensions;
+    }
+
+    /// Request extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<'_, Extensions> {
+        self.req.extensions()
+    }
+
+    /// Mutable reference to a the request's extensions
+    #[inline]
+    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
+        self.req.extensions_mut()
+    }
+}
+
+impl<Err> Resource<Uri> for WebRequest<Err> {
+    fn path(&self) -> &str {
+        self.match_info().path()
+    }
+
+    fn resource_path(&mut self) -> &mut Path<Uri> {
+        self.match_info_mut()
+    }
+}
+
+impl<Err> HttpMessage for WebRequest<Err> {
     #[inline]
     /// Returns Request's headers.
     fn message_headers(&self) -> &HeaderMap {
@@ -235,65 +250,23 @@ impl HttpMessage for HttpRequest {
     /// Request extensions
     #[inline]
     fn message_extensions(&self) -> Ref<'_, Extensions> {
-        self.0.head.extensions()
+        self.req.extensions()
     }
 
     /// Mutable reference to a the request's extensions
     #[inline]
     fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.0.head.extensions_mut()
+        self.req.extensions_mut()
     }
 }
 
-impl Drop for HttpRequest {
+impl<Err: ErrorRenderer> fmt::Debug for WebRequest<Err> {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.0) == 1 {
-            let v = &mut self.0.pool.0.borrow_mut();
-            if v.len() < 128 {
-                self.extensions_mut().clear();
-                v.push(self.0.clone());
-            }
-        }
-    }
-}
-
-/// It is possible to get `HttpRequest` as an extractor handler parameter
-///
-/// ## Example
-///
-/// ```rust
-/// use ntex::web::{self, App, HttpRequest};
-/// use serde_derive::Deserialize;
-///
-/// /// extract `Thing` from request
-/// async fn index(req: HttpRequest) -> String {
-///    format!("Got thing: {:?}", req)
-/// }
-///
-/// fn main() {
-///     let app = App::new().service(
-///         web::resource("/users/{first}").route(
-///             web::get().to(index))
-///     );
-/// }
-/// ```
-impl<Err: ErrorRenderer> FromRequest<Err> for HttpRequest {
-    type Error = Err::Container;
-    type Future = Ready<Result<Self, Self::Error>>;
-
-    #[inline]
-    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
-        ok(req.clone())
-    }
-}
-
-impl fmt::Debug for HttpRequest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(
             f,
-            "\nHttpRequest {:?} {}:{}",
+            "\nWebRequest {:?} {}:{}",
-            self.0.head.version,
+            self.head().version,
-            self.0.head.method,
+            self.head().method,
             self.path()
         )?;
         if !self.query_string().is_empty() {
@@ -309,222 +282,3 @@ impl fmt::Debug for HttpRequest {
         Ok(())
     }
 }
-
-/// Request's objects pool
-pub(crate) struct HttpRequestPool(RefCell<Vec<Rc<HttpRequestInner>>>);
-
-impl HttpRequestPool {
-    pub(crate) fn create() -> &'static HttpRequestPool {
-        let pool = HttpRequestPool(RefCell::new(Vec::with_capacity(128)));
-        Box::leak(Box::new(pool))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    pub(crate) fn get_request(&self) -> Option<HttpRequest> {
-        if let Some(inner) = self.0.borrow_mut().pop() {
-            Some(HttpRequest(inner))
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn clear(&self) {
-        self.0.borrow_mut().clear()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use futures::future::ready;
-
-    use super::*;
-    use crate::http::{header, StatusCode};
-    use crate::router::ResourceDef;
-    use crate::web::dev::ResourceMap;
-    use crate::web::test::{call_service, init_service, TestRequest};
-    use crate::web::{self, App, HttpResponse};
-
-    #[test]
-    fn test_debug() {
-        let req =
-            TestRequest::with_header("content-type", "text/plain").to_http_request();
-        let dbg = format!("{:?}", req);
-        assert!(dbg.contains("HttpRequest"));
-    }
-
-    #[cfg(feature = "cookie")]
-    #[test]
-    fn test_no_request_cookies() {
-        let req = TestRequest::default().to_http_request();
-        assert!(req.cookies().unwrap().is_empty());
-    }
-
-    #[cfg(feature = "cookie")]
-    #[test]
-    fn test_request_cookies() {
-        let req = TestRequest::default()
-            .header(header::COOKIE, "cookie1=value1")
-            .header(header::COOKIE, "cookie2=value2")
-            .to_http_request();
-        {
-            let cookies = req.cookies().unwrap();
-            assert_eq!(cookies.len(), 2);
-            assert_eq!(cookies[0].name(), "cookie2");
-            assert_eq!(cookies[0].value(), "value2");
-            assert_eq!(cookies[1].name(), "cookie1");
-            assert_eq!(cookies[1].value(), "value1");
-        }
-
-        let cookie = req.cookie("cookie1");
-        assert!(cookie.is_some());
-        let cookie = cookie.unwrap();
-        assert_eq!(cookie.name(), "cookie1");
-        assert_eq!(cookie.value(), "value1");
-
-        let cookie = req.cookie("cookie-unknown");
-        assert!(cookie.is_none());
-    }
-
-    #[test]
-    fn test_request_query() {
-        let req = TestRequest::with_uri("/?id=test").to_http_request();
-        assert_eq!(req.query_string(), "id=test");
-    }
-
-    #[test]
-    fn test_url_for() {
-        let mut res = ResourceDef::new("/user/{name}.{ext}");
-        *res.name_mut() = "index".to_string();
-
-        let mut rmap = ResourceMap::new(ResourceDef::new(""));
-        rmap.add(&mut res, None);
-        //assert!(rmap.has_resource("/user/test.html"));
-        //assert!(!rmap.has_resource("/test/unknown"));
-
-        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
-            .rmap(rmap)
-            .to_http_request();
-
-        assert_eq!(
-            req.url_for("unknown", &["test"]),
-            Err(UrlGenerationError::ResourceNotFound)
-        );
-        assert_eq!(
-            req.url_for("index", &["test"]),
-            Err(UrlGenerationError::NotEnoughElements)
-        );
-        let url = req.url_for("index", &["test", "html"]);
-        assert_eq!(
-            url.ok().unwrap().as_str(),
-            "http://www.rust-lang.org/user/test.html"
-        );
-    }
-
-    #[test]
-    fn test_url_for_static() {
-        let mut rdef = ResourceDef::new("/index.html");
-        *rdef.name_mut() = "index".to_string();
-
-        let mut rmap = ResourceMap::new(ResourceDef::new(""));
-        rmap.add(&mut rdef, None);
-
-        // assert!(rmap.has_resource("/index.html"));
-
-        let req = TestRequest::with_uri("/test")
-            .header(header::HOST, "www.rust-lang.org")
-            .rmap(rmap)
-            .to_http_request();
-        let url = req.url_for_static("index");
-        assert_eq!(
-            url.ok().unwrap().as_str(),
-            "http://www.rust-lang.org/index.html"
-        );
-    }
-
-    #[test]
-    fn test_url_for_external() {
-        let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");
-
-        *rdef.name_mut() = "youtube".to_string();
-
-        let mut rmap = ResourceMap::new(ResourceDef::new(""));
-        rmap.add(&mut rdef, None);
-        // assert!(rmap.has_resource("https://youtube.com/watch/unknown"));
-
-        let req = TestRequest::default().rmap(rmap).to_http_request();
-        let url = req.url_for("youtube", &["oHg5SJYRHA0"]);
-        assert_eq!(
-            url.ok().unwrap().as_str(),
-            "https://youtube.com/watch/oHg5SJYRHA0"
-        );
-    }
-
-    #[ntex_rt::test]
-    async fn test_data() {
-        let mut srv = init_service(App::new().app_data(10usize).service(
-            web::resource("/").to(|req: HttpRequest| {
-                ready(if req.app_data::<usize>().is_some() {
-                    HttpResponse::Ok()
-                } else {
-                    HttpResponse::BadRequest()
-                })
-            }),
-        ))
-        .await;
-
-        let req = TestRequest::default().to_request();
-        let resp = call_service(&mut srv, req).await;
-        assert_eq!(resp.status(), StatusCode::OK);
-
-        let mut srv = init_service(App::new().app_data(10u32).service(
-            web::resource("/").to(|req: HttpRequest| async move {
-                if req.app_data::<usize>().is_some() {
-                    HttpResponse::Ok()
-                } else {
-                    HttpResponse::BadRequest()
-                }
-            }),
-        ))
-        .await;
-
-        let req = TestRequest::default().to_request();
-        let resp = call_service(&mut srv, req).await;
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-    }
-
-    #[ntex_rt::test]
-    async fn test_extensions_dropped() {
-        struct Tracker {
-            dropped: bool,
-        }
-        struct Foo {
-            tracker: Rc<RefCell<Tracker>>,
-        }
-        impl Drop for Foo {
-            fn drop(&mut self) {
-                self.tracker.borrow_mut().dropped = true;
-            }
-        }
-
-        let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
-        {
-            let tracker2 = Rc::clone(&tracker);
-            let mut srv = init_service(App::new().data(10u32).service(
-                web::resource("/").to(move |req: HttpRequest| {
-                    req.extensions_mut().insert(Foo {
-                        tracker: Rc::clone(&tracker2),
-                    });
-                    ready(HttpResponse::Ok())
-                }),
-            ))
-            .await;
-
-            let req = TestRequest::default().to_request();
-            let resp = call_service(&mut srv, req).await;
-            assert_eq!(resp.status(), StatusCode::OK);
-        }
-
-        assert!(tracker.borrow().dropped);
-    }
-}

ntex/src/web/resource.rs

@@ -15,14 +15,15 @@ use crate::service::{
 };
 
 use super::data::Data;
-use super::dev::{insert_slesh, AppService, HttpServiceFactory};
+use super::dev::{insert_slesh, WebServiceConfig, WebServiceFactory};
 use super::error::ErrorRenderer;
 use super::extract::FromRequest;
 use super::guard::Guard;
 use super::handler::Handler;
+use super::request::WebRequest;
 use super::responder::Responder;
+use super::response::WebResponse;
 use super::route::{Route, RouteService};
-use super::service::{WebRequest, WebResponse};
 
 type HttpService<Err: ErrorRenderer> =
     BoxService<WebRequest<Err>, WebResponse, Err::Container>;
@@ -369,7 +370,7 @@ where
     }
 }
 
-impl<Err, T> HttpServiceFactory<Err> for Resource<Err, T>
+impl<Err, T> WebServiceFactory<Err> for Resource<Err, T>
 where
     T: ServiceFactory<
             Config = (),
@@ -380,7 +381,7 @@ where
         > + 'static,
     Err: ErrorRenderer,
 {
-    fn register(mut self, config: &mut AppService<Err>) {
+    fn register(mut self, config: &mut WebServiceConfig<Err>) {
         let guards = if self.guards.is_empty() {
             None
         } else {
@@ -563,7 +564,7 @@ mod tests {
     use crate::http::{Method, StatusCode};
     use crate::rt::time::delay_for;
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::WebRequest;
+    use crate::web::request::WebRequest;
     use crate::web::test::{call_service, init_service, TestRequest};
     use crate::web::{self, guard, App, DefaultError, Error, HttpResponse};
     use crate::Service;

ntex/src/web/responder.rs

@@ -14,7 +14,7 @@ use crate::http::header::{HeaderMap, HeaderName, IntoHeaderValue};
 use crate::http::{Response, ResponseBuilder, StatusCode};
 
 use super::error::{DefaultError, ErrorRenderer, InternalError, WebResponseError};
-use super::request::HttpRequest;
+use super::httprequest::HttpRequest;
 
 /// Trait implemented by types that can be converted to a http response.
 ///

ntex/src/web/response.rs

@@ -0,0 +1,153 @@
+use std::fmt;
+
+use crate::http::body::{Body, MessageBody, ResponseBody};
+use crate::http::{HeaderMap, Response, ResponseHead, StatusCode};
+
+use super::error::ErrorRenderer;
+use super::httprequest::HttpRequest;
+
+/// An service http response
+pub struct WebResponse<B = Body> {
+    request: HttpRequest,
+    response: Response<B>,
+}
+
+impl<B> WebResponse<B> {
+    /// Create web response instance
+    pub fn new(request: HttpRequest, response: Response<B>) -> Self {
+        WebResponse { request, response }
+    }
+
+    /// Create web response from the error
+    pub fn from_err<Err: ErrorRenderer, E: Into<Err::Container>>(
+        err: E,
+        request: HttpRequest,
+    ) -> Self {
+        use crate::http::error::ResponseError;
+
+        let err = err.into();
+        let res: Response = err.error_response();
+
+        if res.head().status == StatusCode::INTERNAL_SERVER_ERROR {
+            log::error!("Internal Server Error: {:?}", err);
+        } else {
+            log::debug!("Error in response: {:?}", err);
+        }
+
+        WebResponse {
+            request,
+            response: res.into_body(),
+        }
+    }
+
+    /// Create web response for error
+    #[inline]
+    pub fn error_response<Err: ErrorRenderer, E: Into<Err::Container>>(
+        self,
+        err: E,
+    ) -> Self {
+        Self::from_err::<Err, E>(err, self.request)
+    }
+
+    /// Create web response
+    #[inline]
+    pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
+        WebResponse::new(self.request, response)
+    }
+
+    /// Get reference to original request
+    #[inline]
+    pub fn request(&self) -> &HttpRequest {
+        &self.request
+    }
+
+    /// Get reference to response
+    #[inline]
+    pub fn response(&self) -> &Response<B> {
+        &self.response
+    }
+
+    /// Get mutable reference to response
+    #[inline]
+    pub fn response_mut(&mut self) -> &mut Response<B> {
+        &mut self.response
+    }
+
+    /// Get the response status code
+    #[inline]
+    pub fn status(&self) -> StatusCode {
+        self.response.status()
+    }
+
+    #[inline]
+    /// Returns response's headers.
+    pub fn headers(&self) -> &HeaderMap {
+        self.response.headers()
+    }
+
+    #[inline]
+    /// Returns mutable response's headers.
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        self.response.headers_mut()
+    }
+
+    /// Execute closure and in case of error convert it to response.
+    pub fn checked_expr<F, E, Err>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&mut Self) -> Result<(), E>,
+        E: Into<Err::Container>,
+        Err: ErrorRenderer,
+    {
+        match f(&mut self) {
+            Ok(_) => self,
+            Err(err) => {
+                let res: Response = err.into().into();
+                WebResponse::new(self.request, res.into_body())
+            }
+        }
+    }
+
+    /// Extract response body
+    pub fn take_body(&mut self) -> ResponseBody<B> {
+        self.response.take_body()
+    }
+}
+
+impl<B> WebResponse<B> {
+    /// Set a new body
+    pub fn map_body<F, B2>(self, f: F) -> WebResponse<B2>
+    where
+        F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
+    {
+        let response = self.response.map_body(f);
+
+        WebResponse {
+            response,
+            request: self.request,
+        }
+    }
+}
+
+impl<B> Into<Response<B>> for WebResponse<B> {
+    fn into(self) -> Response<B> {
+        self.response
+    }
+}
+
+impl<B: MessageBody> fmt::Debug for WebResponse<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let res = writeln!(
+            f,
+            "\nWebResponse {:?} {}{}",
+            self.response.head().version,
+            self.response.head().status,
+            self.response.head().reason.unwrap_or(""),
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.response.head().headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        let _ = writeln!(f, "  body: {:?}", self.response.body().size());
+        res
+    }
+}

ntex/src/web/rmap.rs

@@ -6,7 +6,7 @@ use url::Url;
 
 use crate::router::ResourceDef;
 use crate::web::error::UrlGenerationError;
-use crate::web::request::HttpRequest;
+use crate::web::httprequest::HttpRequest;
 
 #[derive(Clone, Debug)]
 pub struct ResourceMap {

ntex/src/web/route.rs

@@ -12,8 +12,9 @@ use super::error_default::DefaultError;
 use super::extract::FromRequest;
 use super::guard::{self, Guard};
 use super::handler::{Handler, HandlerFn, HandlerWrapper};
+use super::request::WebRequest;
 use super::responder::Responder;
-use super::service::{WebRequest, WebResponse};
+use super::response::WebResponse;
 use super::HttpResponse;
 
 /// Resource route definition

ntex/src/web/scope.rs

@@ -15,15 +15,15 @@ use crate::service::{
 
 use super::config::ServiceConfig;
 use super::data::Data;
-use super::dev::{AppService, HttpServiceFactory};
+use super::dev::{WebServiceConfig, WebServiceFactory};
 use super::error::ErrorRenderer;
 use super::guard::Guard;
+use super::request::WebRequest;
 use super::resource::Resource;
+use super::response::WebResponse;
 use super::rmap::ResourceMap;
 use super::route::Route;
-use super::service::{
+use super::service::{AppServiceFactory, ServiceFactoryWrapper};
-    AppServiceFactory, ServiceFactoryWrapper, WebRequest, WebResponse,
-};
 
 type Guards = Vec<Box<dyn Guard>>;
 type HttpService<Err: ErrorRenderer> =
@@ -245,7 +245,7 @@ where
     /// ```
     pub fn service<F>(mut self, factory: F) -> Self
     where
-        F: HttpServiceFactory<Err> + 'static,
+        F: WebServiceFactory<Err> + 'static,
     {
         self.services
             .push(Box::new(ServiceFactoryWrapper::new(factory)));
@@ -410,7 +410,7 @@ where
     }
 }
 
-impl<Err, T> HttpServiceFactory<Err> for Scope<Err, T>
+impl<Err, T> WebServiceFactory<Err> for Scope<Err, T>
 where
     T: ServiceFactory<
             Config = (),
@@ -421,7 +421,7 @@ where
         > + 'static,
     Err: ErrorRenderer,
 {
-    fn register(mut self, config: &mut AppService<Err>) {
+    fn register(mut self, config: &mut WebServiceConfig<Err>) {
         // update default resource if needed
         if self.default.borrow().is_none() {
             *self.default.borrow_mut() = Some(config.default_service());
@@ -685,7 +685,7 @@ mod tests {
     use crate::http::{Method, StatusCode};
     use crate::service::Service;
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::WebRequest;
+    use crate::web::request::WebRequest;
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::DefaultError;
     use crate::web::{self, guard, App, HttpRequest, HttpResponse};

ntex/src/web/service.rs

@@ -1,31 +1,24 @@
-use std::cell::{Ref, RefMut};
-use std::marker::PhantomData;
 use std::rc::Rc;
-use std::{fmt, net};
 
-use crate::http::body::{Body, MessageBody, ResponseBody};
+use crate::http::Extensions;
-use crate::http::{
+use crate::router::{IntoPattern, ResourceDef};
-    Extensions, HeaderMap, HttpMessage, Method, Payload, PayloadStream, RequestHead,
+use crate::service::{boxed, IntoServiceFactory, ServiceFactory};
-    Response, ResponseHead, StatusCode, Uri, Version,
-};
-use crate::router::{IntoPattern, Path, Resource, ResourceDef};
-use crate::{IntoServiceFactory, ServiceFactory};
 
-use super::config::{AppConfig, AppService};
+use super::config::AppConfig;
-use super::data::Data;
+use super::data::DataFactory;
 use super::dev::insert_slesh;
 use super::error::ErrorRenderer;
 use super::guard::Guard;
-use super::info::ConnectionInfo;
+use super::request::WebRequest;
-use super::request::HttpRequest;
+use super::response::WebResponse;
 use super::rmap::ResourceMap;
 
-pub trait HttpServiceFactory<Err: ErrorRenderer> {
+pub trait WebServiceFactory<Err: ErrorRenderer> {
-    fn register(self, config: &mut AppService<Err>);
+    fn register(self, config: &mut WebServiceConfig<Err>);
 }
 
 pub(super) trait AppServiceFactory<Err: ErrorRenderer> {
-    fn register(&mut self, config: &mut AppService<Err>);
+    fn register(&mut self, config: &mut WebServiceConfig<Err>);
 }
 
 pub(super) struct ServiceFactoryWrapper<T> {
@@ -42,437 +35,148 @@ impl<T> ServiceFactoryWrapper<T> {
 
 impl<T, Err> AppServiceFactory<Err> for ServiceFactoryWrapper<T>
 where
-    T: HttpServiceFactory<Err>,
+    T: WebServiceFactory<Err>,
     Err: ErrorRenderer,
 {
-    fn register(&mut self, config: &mut AppService<Err>) {
+    fn register(&mut self, config: &mut WebServiceConfig<Err>) {
         if let Some(item) = self.factory.take() {
             item.register(config)
         }
     }
 }
 
-/// An service http request
+type Guards = Vec<Box<dyn Guard>>;
-///
+type HttpServiceFactory<Err: ErrorRenderer> =
-/// WebRequest allows mutable access to request's internal structures
+    boxed::BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
-pub struct WebRequest<Err> {
+
-    req: HttpRequest,
+/// Application service configuration
-    _t: PhantomData<Err>,
+pub struct WebServiceConfig<Err: ErrorRenderer> {
+    config: AppConfig,
+    root: bool,
+    default: Rc<HttpServiceFactory<Err>>,
+    services: Vec<(
+        ResourceDef,
+        HttpServiceFactory<Err>,
+        Option<Guards>,
+        Option<Rc<ResourceMap>>,
+    )>,
+    service_data: Rc<Vec<Box<dyn DataFactory>>>,
 }
 
-impl<Err: ErrorRenderer> WebRequest<Err> {
+impl<Err: ErrorRenderer> WebServiceConfig<Err> {
-    /// Create web response for error
+    /// Crate server settings instance
-    #[inline]
+    pub(crate) fn new(
-    pub fn error_response<B, E: Into<Err::Container>>(self, err: E) -> WebResponse<B> {
+        config: AppConfig,
-        WebResponse::from_err::<Err, E>(err, self.req)
+        default: Rc<HttpServiceFactory<Err>>,
+        service_data: Rc<Vec<Box<dyn DataFactory>>>,
+    ) -> Self {
+        WebServiceConfig {
+            config,
+            default,
+            service_data,
+            root: true,
+            services: Vec::new(),
         }
     }
 
-impl<Err> WebRequest<Err> {
+    /// Check if root is beeing configured
-    /// Construct web request
+    pub fn is_root(&self) -> bool {
-    pub(crate) fn new(req: HttpRequest) -> Self {
+        self.root
-        WebRequest {
-            req,
-            _t: PhantomData,
-        }
     }
 
-    /// Deconstruct request into parts
+    pub(crate) fn into_services(
-    pub fn into_parts(mut self) -> (HttpRequest, Payload) {
+        self,
-        let pl = Rc::get_mut(&mut (self.req).0).unwrap().payload.take();
+    ) -> (
-        (self.req, pl)
+        AppConfig,
+        Vec<(
+            ResourceDef,
+            HttpServiceFactory<Err>,
+            Option<Guards>,
+            Option<Rc<ResourceMap>>,
+        )>,
+    ) {
+        (self.config, self.services)
     }
 
-    /// Construct request from parts.
+    pub(crate) fn clone_config(&self) -> Self {
-    ///
+        WebServiceConfig {
-    /// `WebRequest` can be re-constructed only if `req` hasnt been cloned.
+            config: self.config.clone(),
-    pub fn from_parts(
+            default: self.default.clone(),
-        mut req: HttpRequest,
+            services: Vec::new(),
-        pl: Payload,
+            root: false,
-    ) -> Result<Self, (HttpRequest, Payload)> {
+            service_data: self.service_data.clone(),
-        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
-            Rc::get_mut(&mut req.0).unwrap().payload = pl;
-            Ok(WebRequest::new(req))
-        } else {
-            Err((req, pl))
         }
     }
 
-    /// Construct request from request.
-    ///
-    /// `HttpRequest` implements `Clone` trait via `Rc` type. `WebRequest`
-    /// can be re-constructed only if rc's strong pointers count eq 1 and
-    /// weak pointers count is 0.
-    pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
-        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
-            Ok(WebRequest::new(req))
-        } else {
-            Err(req)
-        }
-    }
-
-    /// Create web response
-    #[inline]
-    pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
-        WebResponse::new(self.req, res.into())
-    }
-
-    /// This method returns reference to the request head
-    #[inline]
-    pub fn head(&self) -> &RequestHead {
-        &self.req.head()
-    }
-
-    /// This method returns reference to the request head
-    #[inline]
-    pub fn head_mut(&mut self) -> &mut RequestHead {
-        self.req.head_mut()
-    }
-
-    /// Request's uri.
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.head().uri
-    }
-
-    /// Read the Request method.
-    #[inline]
-    pub fn method(&self) -> &Method {
-        &self.head().method
-    }
-
-    /// Read the Request Version.
-    #[inline]
-    pub fn version(&self) -> Version {
-        self.head().version
-    }
-
-    #[inline]
-    /// Returns request's headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    #[inline]
-    /// Returns mutable request's headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.head_mut().headers
-    }
-
-    /// The target path of this Request.
-    #[inline]
-    pub fn path(&self) -> &str {
-        self.head().uri.path()
-    }
-
-    /// The query string in the URL.
-    ///
-    /// E.g., id=10
-    #[inline]
-    pub fn query_string(&self) -> &str {
-        if let Some(query) = self.uri().query().as_ref() {
-            query
-        } else {
-            ""
-        }
-    }
-
-    /// Peer socket address
-    ///
-    /// Peer address is actual socket address, if proxy is used in front of
-    /// actix http server, then peer address would be address of this proxy.
-    ///
-    /// To get client connection information `ConnectionInfo` should be used.
-    #[inline]
-    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.head().peer_addr
-    }
-
-    /// Get *ConnectionInfo* for the current request.
-    #[inline]
-    pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
-        ConnectionInfo::get(self.head(), &*self.app_config())
-    }
-
-    /// Get a reference to the Path parameters.
-    ///
-    /// Params is a container for url parameters.
-    /// A variable segment is specified in the form `{identifier}`,
-    /// where the identifier can be used later in a request handler to
-    /// access the matched value for that segment.
-    #[inline]
-    pub fn match_info(&self) -> &Path<Uri> {
-        self.req.match_info()
-    }
-
-    #[inline]
-    /// Get a mutable reference to the Path parameters.
-    pub fn match_info_mut(&mut self) -> &mut Path<Uri> {
-        self.req.match_info_mut()
-    }
-
-    #[inline]
-    /// Get a reference to a `ResourceMap` of current application.
-    pub fn resource_map(&self) -> &ResourceMap {
-        self.req.resource_map()
-    }
-
     /// Service configuration
-    #[inline]
+    pub fn config(&self) -> &AppConfig {
-    pub fn app_config(&self) -> &AppConfig {
+        &self.config
-        self.req.app_config()
     }
 
-    #[inline]
+    /// Default resource
-    /// Get an application data stored with `App::data()` method during
+    pub fn default_service(&self) -> Rc<HttpServiceFactory<Err>> {
-    /// application configuration.
+        self.default.clone()
-    pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
-        if let Some(st) = (self.req).0.app_data.get::<Data<T>>() {
-            Some(st.clone())
-        } else {
-            None
-        }
     }
 
-    #[inline]
+    /// Set global route data
-    /// Get request's payload
+    pub fn set_service_data(&self, extensions: &mut Extensions) -> bool {
-    pub fn take_payload(&mut self) -> Payload<PayloadStream> {
+        for f in self.service_data.iter() {
-        Rc::get_mut(&mut (self.req).0).unwrap().payload.take()
+            f.create(extensions);
+        }
+        !self.service_data.is_empty()
     }
 
-    #[inline]
+    /// Register http service
-    /// Set request payload.
+    pub fn register_service<F, S>(
-    pub fn set_payload(&mut self, payload: Payload) {
+        &mut self,
-        Rc::get_mut(&mut (self.req).0).unwrap().payload = payload;
+        rdef: ResourceDef,
-    }
+        guards: Option<Vec<Box<dyn Guard>>>,
-
+        factory: F,
-    #[doc(hidden)]
+        nested: Option<Rc<ResourceMap>>,
-    /// Set new app data container
+    ) where
-    pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
+        F: IntoServiceFactory<S>,
-        Rc::get_mut(&mut (self.req).0).unwrap().app_data = extensions;
+        S: ServiceFactory<
-    }
+                Config = (),
-
+                Request = WebRequest<Err>,
-    /// Request extensions
+                Response = WebResponse,
-    #[inline]
+                Error = Err::Container,
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
+                InitError = (),
-        self.req.extensions()
+            > + 'static,
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.req.extensions_mut()
-    }
-}
-
-impl<Err> Resource<Uri> for WebRequest<Err> {
-    fn path(&self) -> &str {
-        self.match_info().path()
-    }
-
-    fn resource_path(&mut self) -> &mut Path<Uri> {
-        self.match_info_mut()
-    }
-}
-
-impl<Err> HttpMessage for WebRequest<Err> {
-    #[inline]
-    /// Returns Request's headers.
-    fn message_headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    /// Request extensions
-    #[inline]
-    fn message_extensions(&self) -> Ref<'_, Extensions> {
-        self.req.extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
-        self.req.extensions_mut()
-    }
-}
-
-impl<Err: ErrorRenderer> fmt::Debug for WebRequest<Err> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(
-            f,
-            "\nWebRequest {:?} {}:{}",
-            self.head().version,
-            self.head().method,
-            self.path()
-        )?;
-        if !self.query_string().is_empty() {
-            writeln!(f, "  query: ?{:?}", self.query_string())?;
-        }
-        if !self.match_info().is_empty() {
-            writeln!(f, "  params: {:?}", self.match_info())?;
-        }
-        writeln!(f, "  headers:")?;
-        for (key, val) in self.headers().iter() {
-            writeln!(f, "    {:?}: {:?}", key, val)?;
-        }
-        Ok(())
-    }
-}
-
-pub struct WebResponse<B = Body> {
-    request: HttpRequest,
-    response: Response<B>,
-}
-
-impl<B> WebResponse<B> {
-    /// Create web response instance
-    pub fn new(request: HttpRequest, response: Response<B>) -> Self {
-        WebResponse { request, response }
-    }
-
-    /// Create web response from the error
-    pub fn from_err<Err: ErrorRenderer, E: Into<Err::Container>>(
-        err: E,
-        request: HttpRequest,
-    ) -> Self {
-        use crate::http::error::ResponseError;
-
-        let err = err.into();
-        let res: Response = err.error_response();
-
-        if res.head().status == StatusCode::INTERNAL_SERVER_ERROR {
-            log::error!("Internal Server Error: {:?}", err);
-        } else {
-            log::debug!("Error in response: {:?}", err);
-        }
-
-        WebResponse {
-            request,
-            response: res.into_body(),
-        }
-    }
-
-    /// Create web response for error
-    #[inline]
-    pub fn error_response<Err: ErrorRenderer, E: Into<Err::Container>>(
-        self,
-        err: E,
-    ) -> Self {
-        Self::from_err::<Err, E>(err, self.request)
-    }
-
-    /// Create web response
-    #[inline]
-    pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
-        WebResponse::new(self.request, response)
-    }
-
-    /// Get reference to original request
-    #[inline]
-    pub fn request(&self) -> &HttpRequest {
-        &self.request
-    }
-
-    /// Get reference to response
-    #[inline]
-    pub fn response(&self) -> &Response<B> {
-        &self.response
-    }
-
-    /// Get mutable reference to response
-    #[inline]
-    pub fn response_mut(&mut self) -> &mut Response<B> {
-        &mut self.response
-    }
-
-    /// Get the response status code
-    #[inline]
-    pub fn status(&self) -> StatusCode {
-        self.response.status()
-    }
-
-    #[inline]
-    /// Returns response's headers.
-    pub fn headers(&self) -> &HeaderMap {
-        self.response.headers()
-    }
-
-    #[inline]
-    /// Returns mutable response's headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        self.response.headers_mut()
-    }
-
-    /// Execute closure and in case of error convert it to response.
-    pub fn checked_expr<F, E, Err>(mut self, f: F) -> Self
-    where
-        F: FnOnce(&mut Self) -> Result<(), E>,
-        E: Into<Err::Container>,
-        Err: ErrorRenderer,
     {
-        match f(&mut self) {
+        self.services.push((
-            Ok(_) => self,
+            rdef,
-            Err(err) => {
+            boxed::factory(factory.into_factory()),
-                let res: Response = err.into().into();
+            guards,
-                WebResponse::new(self.request, res.into_body())
+            nested,
-            }
+        ));
-        }
-    }
-
-    /// Extract response body
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        self.response.take_body()
     }
 }
 
-impl<B> WebResponse<B> {
+/// Create service adapter for a specific path.
-    /// Set a new body
+///
-    pub fn map_body<F, B2>(self, f: F) -> WebResponse<B2>
+/// ```rust
-    where
+/// use ntex::web::{self, dev, guard, App, HttpResponse, Error, DefaultError};
-        F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
+///
-    {
+/// async fn my_service(req: dev::WebRequest<DefaultError>) -> Result<dev::WebResponse, Error> {
-        let response = self.response.map_body(f);
+///     Ok(req.into_response(HttpResponse::Ok().finish()))
-
+/// }
-        WebResponse {
+///
-            response,
+/// let app = App::new().service(
-            request: self.request,
+///     web::service("/users/*")
-        }
+///         .guard(guard::Header("content-type", "text/plain"))
-    }
+///         .finish(my_service)
-}
+/// );
-
+/// ```
-impl<B> Into<Response<B>> for WebResponse<B> {
+pub struct WebServiceAdapter {
-    fn into(self) -> Response<B> {
-        self.response
-    }
-}
-
-impl<B: MessageBody> fmt::Debug for WebResponse<B> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let res = writeln!(
-            f,
-            "\nWebResponse {:?} {}{}",
-            self.response.head().version,
-            self.response.head().status,
-            self.response.head().reason.unwrap_or(""),
-        );
-        let _ = writeln!(f, "  headers:");
-        for (key, val) in self.response.head().headers.iter() {
-            let _ = writeln!(f, "    {:?}: {:?}", key, val);
-        }
-        let _ = writeln!(f, "  body: {:?}", self.response.body().size());
-        res
-    }
-}
-
-pub struct WebService {
     rdef: Vec<String>,
     name: Option<String>,
     guards: Vec<Box<dyn Guard>>,
 }
 
-impl WebService {
+impl WebServiceAdapter {
-    /// Create new `WebService` instance.
+    /// Create new `WebServiceAdapter` instance.
     pub fn new<T: IntoPattern>(path: T) -> Self {
-        WebService {
+        WebServiceAdapter {
             rdef: path.patterns(),
             name: None,
             guards: Vec::new(),
@@ -511,7 +215,7 @@ impl WebService {
     }
 
     /// Set a service factory implementation and generate web service.
-    pub fn finish<T, F, Err>(self, service: F) -> impl HttpServiceFactory<Err>
+    pub fn finish<T, F, Err>(self, service: F) -> impl WebServiceFactory<Err>
     where
         F: IntoServiceFactory<T>,
         T: ServiceFactory<
@@ -539,7 +243,7 @@ struct WebServiceImpl<T> {
     guards: Vec<Box<dyn Guard>>,
 }
 
-impl<T, Err> HttpServiceFactory<Err> for WebServiceImpl<T>
+impl<T, Err> WebServiceFactory<Err> for WebServiceImpl<T>
 where
     T: ServiceFactory<
             Config = (),
@@ -550,7 +254,7 @@ where
         > + 'static,
     Err: ErrorRenderer,
 {
-    fn register(mut self, config: &mut AppService<Err>) {
+    fn register(mut self, config: &mut WebServiceConfig<Err>) {
         let guards = if self.guards.is_empty() {
             None
         } else {

ntex/src/web/test.rs

@@ -33,11 +33,11 @@ use crate::server::Server;
 use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 use crate::web::config::AppConfig;
-use crate::web::error::ErrorRenderer;
+use crate::web::dev::{WebRequest, WebResponse};
-use crate::web::request::HttpRequestPool;
+use crate::web::error::{DefaultError, ErrorRenderer};
+use crate::web::httprequest::{HttpRequest, HttpRequestPool};
 use crate::web::rmap::ResourceMap;
-use crate::web::service::{WebRequest, WebResponse};
+use crate::web::{FromRequest, HttpResponse, Responder};
-use crate::web::{DefaultError, HttpRequest, HttpResponse};
 
 /// Create service that always responds with `HttpResponse::Ok()`
 pub fn ok_service<Err: ErrorRenderer>() -> impl Service<
@@ -216,6 +216,7 @@ where
     bytes.freeze()
 }
 
+/// Reads response's body and combines it to a Bytes objects
 pub async fn load_stream<S>(mut stream: S) -> Result<Bytes, Box<dyn Error>>
 where
     S: Stream<Item = Result<Bytes, Box<dyn Error>>> + Unpin,
@@ -274,6 +275,22 @@ where
         .unwrap_or_else(|_| panic!("read_response_json failed during deserialization"))
 }
 
+/// Helper method for extractors testing
+pub async fn from_request<T: FromRequest<DefaultError>>(
+    req: &HttpRequest,
+    payload: &mut Payload,
+) -> Result<T, T::Error> {
+    T::from_request(req, payload).await
+}
+
+/// Helper method for responders testing
+pub async fn respond_to<T: Responder<DefaultError>>(
+    slf: T,
+    req: &HttpRequest,
+) -> Result<HttpResponse, T::Error> {
+    T::respond_to(slf, req).await
+}
+
 /// Test `Request` builder.
 ///
 /// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern.
@@ -757,6 +774,7 @@ where
 }
 
 #[derive(Clone)]
+/// Test server configuration
 pub struct TestServerConfig {
     tp: HttpVer,
     stream: StreamType,

ntex/src/web/types/form.rs

@@ -17,9 +17,7 @@ use crate::http::encoding::Decoder;
 use crate::http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use crate::http::{HttpMessage, Payload, Response, StatusCode};
 use crate::web::error::{ErrorRenderer, UrlencodedError};
-use crate::web::extract::FromRequest;
+use crate::web::{FromRequest, HttpRequest, Responder};
-use crate::web::request::HttpRequest;
-use crate::web::responder::Responder;
 
 /// Form data helper (`application/x-www-form-urlencoded`)
 ///
@@ -347,133 +345,133 @@ where
     }
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use bytes::Bytes;
+    use bytes::Bytes;
-//     use serde::{Deserialize, Serialize};
+    use serde::{Deserialize, Serialize};
 
-//     use super::*;
+    use super::*;
-//     use crate::http::header::{HeaderValue, CONTENT_TYPE};
+    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-//     use crate::web::test::TestRequest;
+    use crate::web::test::{from_request, respond_to, TestRequest};
 
-//     #[derive(Deserialize, Serialize, Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
-//     struct Info {
+    struct Info {
-//         hello: String,
+        hello: String,
-//         counter: i64,
+        counter: i64,
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_form() {
+    async fn test_form() {
-//         let (req, mut pl) =
+        let (req, mut pl) =
-//             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
+            TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
-//                 .header(CONTENT_LENGTH, "11")
+                .header(CONTENT_LENGTH, "11")
-//                 .set_payload(Bytes::from_static(b"hello=world&counter=123"))
+                .set_payload(Bytes::from_static(b"hello=world&counter=123"))
-//                 .to_http_parts();
+                .to_http_parts();
 
-//         let Form(s) = Form::<Info>::from_request(&req, &mut pl).await.unwrap();
+        let Form(s) = from_request::<Form<Info>>(&req, &mut pl).await.unwrap();
-//         assert_eq!(
+        assert_eq!(
-//             s,
+            s,
-//             Info {
+            Info {
-//                 hello: "world".into(),
+                hello: "world".into(),
-//                 counter: 123
+                counter: 123
-//             }
+            }
-//         );
+        );
-//     }
+    }
 
-//     fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
+    fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
-//         match err {
+        match err {
-//             UrlencodedError::Overflow { .. } => match other {
+            UrlencodedError::Overflow { .. } => match other {
-//                 UrlencodedError::Overflow { .. } => true,
+                UrlencodedError::Overflow { .. } => true,
-//                 _ => false,
+                _ => false,
-//             },
+            },
-//             UrlencodedError::UnknownLength => match other {
+            UrlencodedError::UnknownLength => match other {
-//                 UrlencodedError::UnknownLength => true,
+                UrlencodedError::UnknownLength => true,
-//                 _ => false,
+                _ => false,
-//             },
+            },
-//             UrlencodedError::ContentType => match other {
+            UrlencodedError::ContentType => match other {
-//                 UrlencodedError::ContentType => true,
+                UrlencodedError::ContentType => true,
-//                 _ => false,
+                _ => false,
-//             },
+            },
-//             _ => false,
+            _ => false,
-//         }
+        }
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_urlencoded_error() {
+    async fn test_urlencoded_error() {
-//         let (req, mut pl) =
+        let (req, mut pl) =
-//             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
+            TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
-//                 .header(CONTENT_LENGTH, "xxxx")
+                .header(CONTENT_LENGTH, "xxxx")
-//                 .to_http_parts();
+                .to_http_parts();
-//         let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
+        let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
-//         assert!(eq(info.err().unwrap(), UrlencodedError::UnknownLength));
+        assert!(eq(info.err().unwrap(), UrlencodedError::UnknownLength));
 
-//         let (req, mut pl) =
+        let (req, mut pl) =
-//             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
+            TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
-//                 .header(CONTENT_LENGTH, "1000000")
+                .header(CONTENT_LENGTH, "1000000")
-//                 .to_http_parts();
+                .to_http_parts();
-//         let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
+        let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
-//         assert!(eq(
+        assert!(eq(
-//             info.err().unwrap(),
+            info.err().unwrap(),
-//             UrlencodedError::Overflow { size: 0, limit: 0 }
+            UrlencodedError::Overflow { size: 0, limit: 0 }
-//         ));
+        ));
 
-//         let (req, mut pl) = TestRequest::with_header(CONTENT_TYPE, "text/plain")
+        let (req, mut pl) = TestRequest::with_header(CONTENT_TYPE, "text/plain")
-//             .header(CONTENT_LENGTH, "10")
+            .header(CONTENT_LENGTH, "10")
-//             .to_http_parts();
+            .to_http_parts();
-//         let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
+        let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
-//         assert!(eq(info.err().unwrap(), UrlencodedError::ContentType));
+        assert!(eq(info.err().unwrap(), UrlencodedError::ContentType));
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_urlencoded() {
+    async fn test_urlencoded() {
-//         let (req, mut pl) =
+        let (req, mut pl) =
-//             TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
+            TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
-//                 .header(CONTENT_LENGTH, "11")
+                .header(CONTENT_LENGTH, "11")
-//                 .set_payload(Bytes::from_static(b"hello=world&counter=123"))
+                .set_payload(Bytes::from_static(b"hello=world&counter=123"))
-//                 .to_http_parts();
+                .to_http_parts();
 
-//         let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
+        let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
-//         assert_eq!(
+        assert_eq!(
-//             info,
+            info,
-//             Info {
+            Info {
-//                 hello: "world".to_owned(),
+                hello: "world".to_owned(),
-//                 counter: 123
+                counter: 123
-//             }
+            }
-//         );
+        );
 
-//         let (req, mut pl) = TestRequest::with_header(
+        let (req, mut pl) = TestRequest::with_header(
-//             CONTENT_TYPE,
+            CONTENT_TYPE,
-//             "application/x-www-form-urlencoded; charset=utf-8",
+            "application/x-www-form-urlencoded; charset=utf-8",
-//         )
+        )
-//         .header(CONTENT_LENGTH, "11")
+        .header(CONTENT_LENGTH, "11")
-//         .set_payload(Bytes::from_static(b"hello=world&counter=123"))
+        .set_payload(Bytes::from_static(b"hello=world&counter=123"))
-//         .to_http_parts();
+        .to_http_parts();
 
-//         let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
+        let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
-//         assert_eq!(
+        assert_eq!(
-//             info,
+            info,
-//             Info {
+            Info {
-//                 hello: "world".to_owned(),
+                hello: "world".to_owned(),
-//                 counter: 123
+                counter: 123
-//             }
+            }
-//         );
+        );
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_responder() {
+    async fn test_responder() {
-//         let req = TestRequest::default().to_http_request();
+        let req = TestRequest::default().to_http_request();
 
-//         let form = Form(Info {
+        let form = Form(Info {
-//             hello: "world".to_string(),
+            hello: "world".to_string(),
-//             counter: 123,
+            counter: 123,
-//         });
+        });
-//         let resp = form.respond_to(&req).await.unwrap();
+        let resp = respond_to(form, &req).await.unwrap();
-//         assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(resp.status(), StatusCode::OK);
-//         assert_eq!(
+        assert_eq!(
-//             resp.headers().get(CONTENT_TYPE).unwrap(),
+            resp.headers().get(CONTENT_TYPE).unwrap(),
-//             HeaderValue::from_static("application/x-www-form-urlencoded")
+            HeaderValue::from_static("application/x-www-form-urlencoded")
-//         );
+        );
 
-//         assert_eq!(resp.body().bin_ref(), b"hello=world&counter=123");
+        assert_eq!(resp.body().bin_ref(), b"hello=world&counter=123");
-//     }
+    }
-// }
+}

ntex/src/web/types/json.rs

@@ -13,16 +13,12 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 use serde_json;
 
-use crate::http::header::CONTENT_LENGTH;
-use crate::http::{HttpMessage, Payload, Response, StatusCode};
-
 #[cfg(feature = "compress")]
 use crate::http::encoding::Decoder;
-
+use crate::http::header::CONTENT_LENGTH;
+use crate::http::{HttpMessage, Payload, Response, StatusCode};
 use crate::web::error::{ErrorRenderer, JsonError, JsonPayloadError};
-use crate::web::extract::FromRequest;
+use crate::web::{FromRequest, HttpRequest, Responder};
-use crate::web::request::HttpRequest;
-use crate::web::responder::Responder;
 
 /// Json helper
 ///
@@ -384,251 +380,199 @@ where
     }
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use bytes::Bytes;
+    use bytes::Bytes;
-//     use serde_derive::{Deserialize, Serialize};
+    use serde_derive::{Deserialize, Serialize};
 
-//     use super::*;
+    use super::*;
-//     use crate::http::error::InternalError;
+    use crate::http::header;
-//     use crate::http::header;
+    use crate::web::test::{from_request, respond_to, TestRequest};
-//     use crate::web::test::{load_stream, TestRequest};
-//     use crate::web::HttpResponse;
 
-//     #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-//     struct MyObject {
+    struct MyObject {
-//         name: String,
+        name: String,
-//     }
+    }
 
-//     fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
+    fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
-//         match err {
+        match err {
-//             JsonPayloadError::Overflow => match other {
+            JsonPayloadError::Overflow => match other {
-//                 JsonPayloadError::Overflow => true,
+                JsonPayloadError::Overflow => true,
-//                 _ => false,
+                _ => false,
-//             },
+            },
-//             JsonPayloadError::ContentType => match other {
+            JsonPayloadError::ContentType => match other {
-//                 JsonPayloadError::ContentType => true,
+                JsonPayloadError::ContentType => true,
-//                 _ => false,
+                _ => false,
-//             },
+            },
-//             _ => false,
+            _ => false,
-//         }
+        }
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_responder() {
+    async fn test_responder() {
-//         let req = TestRequest::default().to_http_request();
+        let req = TestRequest::default().to_http_request();
 
-//         let j = Json(MyObject {
+        let j = Json(MyObject {
-//             name: "test".to_string(),
+            name: "test".to_string(),
-//         });
+        });
-//         let resp = j.respond_to(&req).await.unwrap();
+        let resp = respond_to(j, &req).await.unwrap();
-//         assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(resp.status(), StatusCode::OK);
-//         assert_eq!(
+        assert_eq!(
-//             resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-//             header::HeaderValue::from_static("application/json")
+            header::HeaderValue::from_static("application/json")
-//         );
+        );
 
-//         assert_eq!(resp.body().bin_ref(), b"{\"name\":\"test\"}");
+        assert_eq!(resp.body().bin_ref(), b"{\"name\":\"test\"}");
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_custom_error_responder() {
+    async fn test_extract() {
-//         let (req, mut pl) = TestRequest::default()
+        let (req, mut pl) = TestRequest::default()
-//             .header(
+            .header(
-//                 header::CONTENT_TYPE,
+                header::CONTENT_TYPE,
-//                 header::HeaderValue::from_static("application/json"),
+                header::HeaderValue::from_static("application/json"),
-//             )
+            )
-//             .header(
+            .header(
-//                 header::CONTENT_LENGTH,
+                header::CONTENT_LENGTH,
-//                 header::HeaderValue::from_static("16"),
+                header::HeaderValue::from_static("16"),
-//             )
+            )
-//             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-//             .data(JsonConfig::default().limit(10).error_handler(|err, _| {
+            .to_http_parts();
-//                 let msg = MyObject {
-//                     name: "invalid request".to_string(),
-//                 };
-//                 let resp = HttpResponse::BadRequest()
-//                     .body(serde_json::to_string(&msg).unwrap());
-//                 InternalError::from_response(err, resp).into()
-//             }))
-//             .to_http_parts();
 
-//         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
+        let s = from_request::<Json<MyObject>>(&req, &mut pl).await.unwrap();
-//         let mut resp = Response::from_error(s.err().unwrap().into());
+        assert_eq!(s.name, "test");
-//         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+        assert_eq!(
+            s.into_inner(),
+            MyObject {
+                name: "test".to_string()
+            }
+        );
 
-//         let body = load_stream(resp.take_body()).await.unwrap();
+        let (req, mut pl) = TestRequest::default()
-//         let msg: MyObject = serde_json::from_slice(&body).unwrap();
+            .header(
-//         assert_eq!(msg.name, "invalid request");
+                header::CONTENT_TYPE,
-//     }
+                header::HeaderValue::from_static("application/json"),
+            )
+            .header(
+                header::CONTENT_LENGTH,
+                header::HeaderValue::from_static("16"),
+            )
+            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+            .data(JsonConfig::default().limit(10))
+            .to_http_parts();
 
-//     #[ntex_rt::test]
+        let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
-//     async fn test_extract() {
+        assert!(format!("{}", s.err().unwrap())
-//         let (req, mut pl) = TestRequest::default()
+            .contains("Json payload size is bigger than allowed"));
-//             .header(
+    }
-//                 header::CONTENT_TYPE,
-//                 header::HeaderValue::from_static("application/json"),
-//             )
-//             .header(
-//                 header::CONTENT_LENGTH,
-//                 header::HeaderValue::from_static("16"),
-//             )
-//             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-//             .to_http_parts();
 
-//         let s = Json::<MyObject>::from_request(&req, &mut pl).await.unwrap();
+    #[ntex_rt::test]
-//         assert_eq!(s.name, "test");
+    async fn test_json_body() {
-//         assert_eq!(
+        let (req, mut pl) = TestRequest::default().to_http_parts();
-//             s.into_inner(),
+        let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
-//             MyObject {
+        assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
-//                 name: "test".to_string()
-//             }
-//         );
 
-//         let (req, mut pl) = TestRequest::default()
+        let (req, mut pl) = TestRequest::default()
-//             .header(
+            .header(
-//                 header::CONTENT_TYPE,
+                header::CONTENT_TYPE,
-//                 header::HeaderValue::from_static("application/json"),
+                header::HeaderValue::from_static("application/text"),
-//             )
+            )
-//             .header(
+            .to_http_parts();
-//                 header::CONTENT_LENGTH,
+        let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
-//                 header::HeaderValue::from_static("16"),
+        assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
-//             )
-//             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-//             .data(JsonConfig::default().limit(10))
-//             .to_http_parts();
 
-//         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
+        let (req, mut pl) = TestRequest::default()
-//         assert!(format!("{}", s.err().unwrap())
+            .header(
-//             .contains("Json payload size is bigger than allowed"));
+                header::CONTENT_TYPE,
+                header::HeaderValue::from_static("application/json"),
+            )
+            .header(
+                header::CONTENT_LENGTH,
+                header::HeaderValue::from_static("10000"),
+            )
+            .to_http_parts();
 
-//         let (req, mut pl) = TestRequest::default()
+        let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
-//             .header(
+            .limit(100)
-//                 header::CONTENT_TYPE,
+            .await;
-//                 header::HeaderValue::from_static("application/json"),
+        assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
-//             )
-//             .header(
-//                 header::CONTENT_LENGTH,
-//                 header::HeaderValue::from_static("16"),
-//             )
-//             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-//             .data(
-//                 JsonConfig::default()
-//                     .limit(10)
-//                     .error_handler(|_, _| JsonPayloadError::ContentType.into()),
-//             )
-//             .to_http_parts();
-//         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
-//         assert!(format!("{}", s.err().unwrap()).contains("Content type error"));
-//     }
 
-//     #[ntex_rt::test]
+        let (req, mut pl) = TestRequest::default()
-//     async fn test_json_body() {
+            .header(
-//         let (req, mut pl) = TestRequest::default().to_http_parts();
+                header::CONTENT_TYPE,
-//         let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
+                header::HeaderValue::from_static("application/json"),
-//         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
+            )
+            .header(
+                header::CONTENT_LENGTH,
+                header::HeaderValue::from_static("16"),
+            )
+            .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+            .to_http_parts();
 
-//         let (req, mut pl) = TestRequest::default()
+        let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
-//             .header(
+        assert_eq!(
-//                 header::CONTENT_TYPE,
+            json.ok().unwrap(),
-//                 header::HeaderValue::from_static("application/text"),
+            MyObject {
-//             )
+                name: "test".to_owned()
-//             .to_http_parts();
+            }
-//         let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
+        );
-//         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
+    }
 
-//         let (req, mut pl) = TestRequest::default()
+    #[ntex_rt::test]
-//             .header(
+    async fn test_with_json_and_bad_content_type() {
-//                 header::CONTENT_TYPE,
+        let (req, mut pl) = TestRequest::with_header(
-//                 header::HeaderValue::from_static("application/json"),
+            header::CONTENT_TYPE,
-//             )
+            header::HeaderValue::from_static("text/plain"),
-//             .header(
+        )
-//                 header::CONTENT_LENGTH,
+        .header(
-//                 header::HeaderValue::from_static("10000"),
+            header::CONTENT_LENGTH,
-//             )
+            header::HeaderValue::from_static("16"),
-//             .to_http_parts();
+        )
+        .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        .data(JsonConfig::default().limit(4096))
+        .to_http_parts();
 
-//         let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
+        let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
-//             .limit(100)
+        assert!(s.is_err())
-//             .await;
+    }
-//         assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
 
-//         let (req, mut pl) = TestRequest::default()
+    #[ntex_rt::test]
-//             .header(
+    async fn test_with_json_and_good_custom_content_type() {
-//                 header::CONTENT_TYPE,
+        let (req, mut pl) = TestRequest::with_header(
-//                 header::HeaderValue::from_static("application/json"),
+            header::CONTENT_TYPE,
-//             )
+            header::HeaderValue::from_static("text/plain"),
-//             .header(
+        )
-//                 header::CONTENT_LENGTH,
+        .header(
-//                 header::HeaderValue::from_static("16"),
+            header::CONTENT_LENGTH,
-//             )
+            header::HeaderValue::from_static("16"),
-//             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        )
-//             .to_http_parts();
+        .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 json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
+        let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
-//         assert_eq!(
+        assert!(s.is_ok())
-//             json.ok().unwrap(),
+    }
-//             MyObject {
-//                 name: "test".to_owned()
-//             }
-//         );
-//     }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_with_json_and_bad_content_type() {
+    async fn test_with_json_and_bad_custom_content_type() {
-//         let (req, mut pl) = TestRequest::with_header(
+        let (req, mut pl) = TestRequest::with_header(
-//             header::CONTENT_TYPE,
+            header::CONTENT_TYPE,
-//             header::HeaderValue::from_static("text/plain"),
+            header::HeaderValue::from_static("text/html"),
-//         )
+        )
-//         .header(
+        .header(
-//             header::CONTENT_LENGTH,
+            header::CONTENT_LENGTH,
-//             header::HeaderValue::from_static("16"),
+            header::HeaderValue::from_static("16"),
-//         )
+        )
-//         .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
+        .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
-//         .data(JsonConfig::default().limit(4096))
+        .data(JsonConfig::default().content_type(|mime: mime::Mime| {
-//         .to_http_parts();
+            mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
+        }))
+        .to_http_parts();
 
-//         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
+        let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
-//         assert!(s.is_err())
+        assert!(s.is_err())
-//     }
+    }
-
+}
-//     #[ntex_rt::test]
-//     async 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 = Json::<MyObject>::from_request(&req, &mut pl).await;
-//         assert!(s.is_ok())
-//     }
-
-//     #[ntex_rt::test]
-//     async 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 = Json::<MyObject>::from_request(&req, &mut pl).await;
-//         assert!(s.is_err())
-//     }
-// }

ntex/src/web/types/path.rs

@@ -7,8 +7,7 @@ use serde::de;
 use crate::http::Payload;
 use crate::router::PathDeserializer;
 use crate::web::error::{ErrorRenderer, PathError};
-use crate::web::request::HttpRequest;
+use crate::web::{FromRequest, HttpRequest};
-use crate::web::FromRequest;
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 /// Extract typed information from the request's path.
@@ -178,134 +177,117 @@ where
     }
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use actix_router::ResourceDef;
+    use derive_more::Display;
-//     use derive_more::Display;
+    use serde_derive::Deserialize;
-//     use serde_derive::Deserialize;
 
-//     use super::*;
+    use super::*;
-//     use crate::http::{error, StatusCode};
+    use crate::router::Router;
-//     use crate::web::test::TestRequest;
+    use crate::web::test::{from_request, TestRequest};
-//     use crate::web::HttpResponse;
 
-//     #[derive(Deserialize, Debug, Display)]
+    #[derive(Deserialize, Debug, Display)]
-//     #[display(fmt = "MyStruct({}, {})", key, value)]
+    #[display(fmt = "MyStruct({}, {})", key, value)]
-//     struct MyStruct {
+    struct MyStruct {
-//         key: String,
+        key: String,
-//         value: String,
+        value: String,
-//     }
+    }
 
-//     #[derive(Deserialize)]
+    #[derive(Deserialize)]
-//     struct Test2 {
+    struct Test2 {
-//         key: String,
+        key: String,
-//         value: u32,
+        value: u32,
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_extract_path_single() {
+    async fn test_extract_path_single() {
-//         let resource = ResourceDef::new("/{value}/");
+        let mut router = Router::<usize>::build();
+        router.path("/{value}/", 10).0.set_id(0);
+        let router = router.finish();
 
-//         let mut req = TestRequest::with_uri("/32/").to_srv_request();
+        let mut req = TestRequest::with_uri("/32/").to_srv_request();
-//         resource.match_path(req.match_info_mut());
+        router.recognize(req.match_info_mut());
 
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
-//         assert_eq!(*Path::<i8>::from_request(&req, &mut pl).await.unwrap(), 32);
+        assert_eq!(*from_request::<Path<i8>>(&req, &mut pl).await.unwrap(), 32);
-//         assert!(Path::<MyStruct>::from_request(&req, &mut pl).await.is_err());
+        assert!(from_request::<Path<MyStruct>>(&req, &mut pl).await.is_err());
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_tuple_extract() {
+    async fn test_tuple_extract() {
-//         let resource = ResourceDef::new("/{key}/{value}/");
+        let mut router = Router::<usize>::build();
+        router.path("/{key}/{value}/", 10).0.set_id(0);
+        let router = router.finish();
 
-//         let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-//         resource.match_path(req.match_info_mut());
+        router.recognize(req.match_info_mut());
 
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
-//         let res = <(Path<(String, String)>,)>::from_request(&req, &mut pl)
+        let res = from_request::<(Path<(String, String)>,)>(&req, &mut pl)
-//             .await
+            .await
-//             .unwrap();
+            .unwrap();
-//         assert_eq!((res.0).0, "name");
+        assert_eq!((res.0).0, "name");
-//         assert_eq!((res.0).1, "user1");
+        assert_eq!((res.0).1, "user1");
 
-//         let res = <(Path<(String, String)>, Path<(String, String)>)>::from_request(
+        let res = from_request::<(Path<(String, String)>, Path<(String, String)>)>(
-//             &req, &mut pl,
+            &req, &mut pl,
-//         )
+        )
-//         .await
+        .await
-//         .unwrap();
+        .unwrap();
-//         assert_eq!((res.0).0, "name");
+        assert_eq!((res.0).0, "name");
-//         assert_eq!((res.0).1, "user1");
+        assert_eq!((res.0).1, "user1");
-//         assert_eq!((res.1).0, "name");
+        assert_eq!((res.1).0, "name");
-//         assert_eq!((res.1).1, "user1");
+        assert_eq!((res.1).1, "user1");
 
-//         let () = <()>::from_request(&req, &mut pl).await.unwrap();
+        let () = from_request::<()>(&req, &mut pl).await.unwrap();
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_request_extract() {
+    async fn test_request_extract() {
-//         let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let mut router = Router::<usize>::build();
+        router.path("/{key}/{value}/", 10).0.set_id(0);
+        let router = router.finish();
 
-//         let resource = ResourceDef::new("/{key}/{value}/");
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-//         resource.match_path(req.match_info_mut());
+        router.recognize(req.match_info_mut());
 
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
-//         let mut s = Path::<MyStruct>::from_request(&req, &mut pl).await.unwrap();
+        let mut s = from_request::<Path<MyStruct>>(&req, &mut pl).await.unwrap();
-//         assert_eq!(s.key, "name");
+        assert_eq!(s.key, "name");
-//         assert_eq!(s.value, "user1");
+        assert_eq!(s.value, "user1");
-//         s.value = "user2".to_string();
+        s.value = "user2".to_string();
-//         assert_eq!(s.value, "user2");
+        assert_eq!(s.value, "user2");
-//         assert_eq!(
+        assert_eq!(
-//             format!("{}, {:?}", s, s),
+            format!("{}, {:?}", s, s),
-//             "MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
+            "MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
-//         );
+        );
-//         let s = s.into_inner();
+        let s = s.into_inner();
-//         assert_eq!(s.value, "user2");
+        assert_eq!(s.value, "user2");
 
-//         let s = Path::<(String, String)>::from_request(&req, &mut pl)
+        let s = from_request::<Path<(String, String)>>(&req, &mut pl)
-//             .await
+            .await
-//             .unwrap();
+            .unwrap();
-//         assert_eq!(s.0, "name");
+        assert_eq!(s.0, "name");
-//         assert_eq!(s.1, "user1");
+        assert_eq!(s.1, "user1");
 
-//         let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
+        let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
-//         let resource = ResourceDef::new("/{key}/{value}/");
+        router.recognize(req.match_info_mut());
-//         resource.match_path(req.match_info_mut());
 
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
-//         let s = Path::<Test2>::from_request(&req, &mut pl).await.unwrap();
+        let s = from_request::<Path<Test2>>(&req, &mut pl).await.unwrap();
-//         assert_eq!(s.as_ref().key, "name");
+        assert_eq!(s.as_ref().key, "name");
-//         assert_eq!(s.value, 32);
+        assert_eq!(s.value, 32);
 
-//         let s = Path::<(String, u8)>::from_request(&req, &mut pl)
+        let s = from_request::<Path<(String, u8)>>(&req, &mut pl)
-//             .await
+            .await
-//             .unwrap();
+            .unwrap();
-//         assert_eq!(s.0, "name");
+        assert_eq!(s.0, "name");
-//         assert_eq!(s.1, 32);
+        assert_eq!(s.1, 32);
 
-//         let res = Path::<Vec<String>>::from_request(&req, &mut pl)
+        let res = from_request::<Path<Vec<String>>>(&req, &mut pl)
-//             .await
+            .await
-//             .unwrap();
+            .unwrap();
-//         assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[0], "name".to_owned());
-//         assert_eq!(res[1], "32".to_owned());
+        assert_eq!(res[1], "32".to_owned());
-//     }
+    }
-
+}
-//     #[ntex_rt::test]
-//     async 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 = Path::<(usize,)>::from_request(&req, &mut pl)
-//             .await
-//             .unwrap_err();
-//         let res: HttpResponse = s.into();
-
-//         assert_eq!(res.status(), StatusCode::CONFLICT);
-//     }
-// }

ntex/src/web/types/payload.rs

@@ -12,8 +12,7 @@ use mime::Mime;
 
 use crate::http::{error, header, HttpMessage};
 use crate::web::error::{ErrorRenderer, PayloadError};
-use crate::web::extract::FromRequest;
+use crate::web::{FromRequest, HttpRequest};
-use crate::web::request::HttpRequest;
 
 /// Payload extractor returns request 's payload stream.
 ///
@@ -414,85 +413,85 @@ impl Future for HttpMessageBody {
     }
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use bytes::Bytes;
+    use bytes::Bytes;
 
-//     use super::*;
+    use super::*;
-//     use crate::http::header;
+    use crate::http::header;
-//     use crate::web::test::TestRequest;
+    use crate::web::test::{from_request, TestRequest};
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_payload_config() {
+    async fn test_payload_config() {
-//         let req = TestRequest::default().to_http_request();
+        let req = TestRequest::default().to_http_request();
-//         let cfg = PayloadConfig::default().mimetype(mime::APPLICATION_JSON);
+        let cfg = PayloadConfig::default().mimetype(mime::APPLICATION_JSON);
-//         assert!(cfg.check_mimetype(&req).is_err());
+        assert!(cfg.check_mimetype(&req).is_err());
 
-//         let req = TestRequest::with_header(
+        let req = TestRequest::with_header(
-//             header::CONTENT_TYPE,
+            header::CONTENT_TYPE,
-//             "application/x-www-form-urlencoded",
+            "application/x-www-form-urlencoded",
-//         )
+        )
-//         .to_http_request();
+        .to_http_request();
-//         assert!(cfg.check_mimetype(&req).is_err());
+        assert!(cfg.check_mimetype(&req).is_err());
 
-//         let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json")
+        let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json")
-//             .to_http_request();
+            .to_http_request();
-//         assert!(cfg.check_mimetype(&req).is_ok());
+        assert!(cfg.check_mimetype(&req).is_ok());
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_bytes() {
+    async fn test_bytes() {
-//         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
+        let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
-//             .set_payload(Bytes::from_static(b"hello=world"))
+            .set_payload(Bytes::from_static(b"hello=world"))
-//             .to_http_parts();
+            .to_http_parts();
 
-//         let s = Bytes::from_request(&req, &mut pl).await.unwrap();
+        let s = from_request::<Bytes>(&req, &mut pl).await.unwrap();
-//         assert_eq!(s, Bytes::from_static(b"hello=world"));
+        assert_eq!(s, Bytes::from_static(b"hello=world"));
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_string() {
+    async fn test_string() {
-//         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
+        let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
-//             .set_payload(Bytes::from_static(b"hello=world"))
+            .set_payload(Bytes::from_static(b"hello=world"))
-//             .to_http_parts();
+            .to_http_parts();
 
-//         let s = String::from_request(&req, &mut pl).await.unwrap();
+        let s = from_request::<String>(&req, &mut pl).await.unwrap();
-//         assert_eq!(s, "hello=world");
+        assert_eq!(s, "hello=world");
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_message_body() {
+    async fn test_message_body() {
-//         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx")
+        let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx")
-//             .to_srv_request()
+            .to_srv_request()
-//             .into_parts();
+            .into_parts();
-//         let res = HttpMessageBody::new(&req, &mut pl).await;
+        let res = HttpMessageBody::new(&req, &mut pl).await;
-//         match res.err().unwrap() {
+        match res.err().unwrap() {
-//             PayloadError::Payload(error::PayloadError::UnknownLength) => (),
+            PayloadError::Payload(error::PayloadError::UnknownLength) => (),
-//             _ => unreachable!("error"),
+            _ => unreachable!("error"),
-//         }
+        }
 
-//         let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "1000000")
+        let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "1000000")
-//             .to_srv_request()
+            .to_srv_request()
-//             .into_parts();
+            .into_parts();
-//         let res = HttpMessageBody::new(&req, &mut pl).await;
+        let res = HttpMessageBody::new(&req, &mut pl).await;
-//         match res.err().unwrap() {
+        match res.err().unwrap() {
-//             PayloadError::Payload(error::PayloadError::Overflow) => (),
+            PayloadError::Payload(error::PayloadError::Overflow) => (),
-//             _ => unreachable!("error"),
+            _ => unreachable!("error"),
-//         }
+        }
 
-//         let (req, mut pl) = TestRequest::default()
+        let (req, mut pl) = TestRequest::default()
-//             .set_payload(Bytes::from_static(b"test"))
+            .set_payload(Bytes::from_static(b"test"))
-//             .to_http_parts();
+            .to_http_parts();
-//         let res = HttpMessageBody::new(&req, &mut pl).await;
+        let res = HttpMessageBody::new(&req, &mut pl).await;
-//         assert_eq!(res.ok().unwrap(), Bytes::from_static(b"test"));
+        assert_eq!(res.ok().unwrap(), Bytes::from_static(b"test"));
 
-//         let (req, mut pl) = TestRequest::default()
+        let (req, mut pl) = TestRequest::default()
-//             .set_payload(Bytes::from_static(b"11111111111111"))
+            .set_payload(Bytes::from_static(b"11111111111111"))
-//             .to_http_parts();
+            .to_http_parts();
-//         let res = HttpMessageBody::new(&req, &mut pl).limit(5).await;
+        let res = HttpMessageBody::new(&req, &mut pl).limit(5).await;
-//         match res.err().unwrap() {
+        match res.err().unwrap() {
-//             PayloadError::Payload(error::PayloadError::Overflow) => (),
+            PayloadError::Payload(error::PayloadError::Overflow) => (),
-//             _ => unreachable!("error"),
+            _ => unreachable!("error"),
-//         }
+        }
-//     }
+    }
-// }
+}

ntex/src/web/types/query.rs

@@ -8,8 +8,7 @@ use serde_urlencoded;
 
 use crate::http::Payload;
 use crate::web::error::{ErrorRenderer, QueryPayloadError};
-use crate::web::extract::FromRequest;
+use crate::web::{FromRequest, HttpRequest};
-use crate::web::request::HttpRequest;
 
 /// Extract typed information from the request's query.
 ///
@@ -153,55 +152,51 @@ where
     }
 }
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod tests {
+mod tests {
-//     use derive_more::Display;
+    use derive_more::Display;
-//     use serde_derive::Deserialize;
+    use serde_derive::Deserialize;
 
-//     use super::*;
+    use super::*;
-//     use crate::http::error::InternalError;
+    use crate::web::test::{from_request, TestRequest};
-//     use crate::http::StatusCode;
-//     use crate::web::test::TestRequest;
-//     use crate::web::{DefaultError, HttpResponse};
 
-//     #[derive(Deserialize, Debug, Display)]
+    #[derive(Deserialize, Debug, Display)]
-//     struct Id {
+    struct Id {
-//         id: String,
+        id: String,
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_service_request_extract() {
+    async fn test_service_request_extract() {
-//         let req = TestRequest::with_uri("/name/user1/").to_srv_request();
+        let req = TestRequest::with_uri("/name/user1/").to_srv_request();
-//         assert!(Query::<Id>::from_query(&req.query_string()).is_err());
+        assert!(Query::<Id>::from_query(&req.query_string()).is_err());
 
-//         let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-//         let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
+        let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
 
-//         assert_eq!(s.id, "test");
+        assert_eq!(s.id, "test");
-//         assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
+        assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
 
-//         s.id = "test1".to_string();
+        s.id = "test1".to_string();
-//         let s = s.into_inner();
+        let s = s.into_inner();
-//         assert_eq!(s.id, "test1");
+        assert_eq!(s.id, "test1");
-//     }
+    }
 
-//     #[ntex_rt::test]
+    #[ntex_rt::test]
-//     async fn test_request_extract() {
+    async fn test_request_extract() {
-//         let req = TestRequest::with_uri("/name/user1/").to_srv_request();
+        let req = TestRequest::with_uri("/name/user1/").to_srv_request();
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
-//         let res: Result<Query<Id>, QueryPayloadError> = FromRequest::from_request(&req, &mut pl).await;
+        let res = from_request::<Query<Id>>(&req, &mut pl).await;
-//         assert!(res.is_err());
+        assert!(res.is_err());
 
-//         let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-//         let (req, mut pl) = req.into_parts();
+        let (req, mut pl) = req.into_parts();
 
-//         let mut s: Result<Query<Id>, QueryPayloadError> = FromRequest::<DefaultError>::from_request(&req, &mut pl).await;
+        let mut s = from_request::<Query<Id>>(&req, &mut pl).await.unwrap();
-//         let s = s.unwrap();
+        assert_eq!(s.id, "test");
-//         assert_eq!(s.id, "test");
+        assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
-//         assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
 
-//         s.id = "test1".to_string();
+        s.id = "test1".to_string();
-//         let s = s.into_inner();
+        let s = s.into_inner();
-//         assert_eq!(s.id, "test1");
+        assert_eq!(s.id, "test1");
-//     }
+    }
-// }
+}

ntex/src/web/util.rs

@@ -5,6 +5,7 @@ use ntex_router::IntoPattern;
 
 use crate::http::body::MessageBody;
 use crate::http::error::{BlockingError, ResponseError};
+use crate::http::header::ContentEncoding;
 use crate::http::{Method, Request, Response};
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
@@ -17,7 +18,8 @@ use super::responder::Responder;
 use super::route::Route;
 use super::scope::Scope;
 use super::server::HttpServer;
-use super::service::WebService;
+use super::service::WebServiceAdapter;
+use super::{HttpResponse, HttpResponseBuilder};
 
 /// Create resource for a specific path.
 ///
@@ -232,7 +234,7 @@ where
     Route::new().to(handler)
 }
 
-/// Create raw service for a specific path.
+/// Create service adapter for a specific path.
 ///
 /// ```rust
 /// use ntex::web::{self, dev, guard, App, HttpResponse, Error, DefaultError};
@@ -247,8 +249,8 @@ where
 ///         .finish(my_service)
 /// );
 /// ```
-pub fn service<T: IntoPattern>(path: T) -> WebService {
+pub fn service<T: IntoPattern>(path: T) -> WebServiceAdapter {
-    WebService::new(path)
+    WebServiceAdapter::new(path)
 }
 
 /// Execute blocking function on a thread pool, returns future that resolves
@@ -290,3 +292,44 @@ where
 {
     HttpServer::new(factory)
 }
+
+struct Enc(ContentEncoding);
+
+/// Helper trait that allows to set specific encoding for response.
+pub trait BodyEncoding {
+    /// Get content encoding
+    fn get_encoding(&self) -> Option<ContentEncoding>;
+
+    /// Set content encoding
+    fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self;
+}
+
+impl BodyEncoding for HttpResponseBuilder {
+    fn get_encoding(&self) -> Option<ContentEncoding> {
+        if let Some(ref enc) = self.extensions().get::<Enc>() {
+            Some(enc.0)
+        } else {
+            None
+        }
+    }
+
+    fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
+        self.extensions_mut().insert(Enc(encoding));
+        self
+    }
+}
+
+impl<B> BodyEncoding for HttpResponse<B> {
+    fn get_encoding(&self) -> Option<ContentEncoding> {
+        if let Some(ref enc) = self.extensions().get::<Enc>() {
+            Some(enc.0)
+        } else {
+            None
+        }
+    }
+
+    fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
+        self.extensions_mut().insert(Enc(encoding));
+        self
+    }
+}

ntex/tests/http_awc_client.rs

@@ -15,9 +15,9 @@ use ntex::http::client::{error::SendRequestError, Client, Connector};
 use ntex::http::test::server as test_server;
 use ntex::http::{header, HttpMessage, HttpService};
 use ntex::service::{map_config, pipeline_factory, Service};
-use ntex::web::dev::{AppConfig, BodyEncoding};
+use ntex::web::dev::AppConfig;
 use ntex::web::middleware::Compress;
-use ntex::web::{self, test, App, Error, HttpRequest, HttpResponse};
+use ntex::web::{self, test, App, BodyEncoding, Error, HttpRequest, HttpResponse};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \

ntex/tests/web_server.rs

@@ -19,9 +19,8 @@ use ntex::http::header::{
 };
 use ntex::http::{Method, StatusCode};
 
-use ntex::web::dev::BodyEncoding;
 use ntex::web::middleware::Compress;
-use ntex::web::{self, test, App, HttpResponse, WebResponseError};
+use ntex::web::{self, test, App, BodyEncoding, HttpResponse, WebResponseError};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \