Migrate to ntex-service 1.2 (#209)

* Migrate to ntex-service 1.2

Cargo.toml

@@ -26,7 +26,7 @@ ntex-io = { path = "ntex-io" }
 ntex-http = { path = "ntex-http" }
 ntex-router = { path = "ntex-router" }
 ntex-rt = { path = "ntex-rt" }
-#ntex-service = { path = "ntex-service" }
+ntex-service = { path = "ntex-service" }
 ntex-tls = { path = "ntex-tls" }
 ntex-macros = { path = "ntex-macros" }
 ntex-util = { path = "ntex-util" }
@@ -34,3 +34,5 @@ ntex-util = { path = "ntex-util" }
 ntex-glommio = { path = "ntex-glommio" }
 ntex-tokio = { path = "ntex-tokio" }
 ntex-async-std = { path = "ntex-async-std" }
+
+ntex-h2 = { git = "https://github.com/ntex-rs/ntex-h2.git", branch = "0-3" }

ntex-async-std/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-async-std"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "async-std intergration for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,8 +17,8 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.2.4"
+ntex-io = "0.3.0"
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"
 async-oneshot = "0.5.0"
 log = "0.4"
 pin-project-lite = "0.2"

ntex-bytes/Cargo.toml

@@ -27,4 +27,4 @@ simdutf8 = { version = "0.1.4", optional = true }
 [dev-dependencies]
 serde_test = "1.0"
 serde_json = "1.0"
-ntex = { version = "0.6.0", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }

ntex-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-connect"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork connect utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -34,28 +34,28 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
 async-std = ["ntex-rt/async-std", "ntex-async-std"]
 
 [dependencies]
-ntex-service = "1.0.0"
+ntex-service = "1.2.0"
 ntex-bytes = "0.1.19"
 ntex-http = "0.1.8"
-ntex-io = "0.2.1"
+ntex-io = "0.3.0"
 ntex-rt = "0.4.7"
-ntex-tls = "0.2.1"
+ntex-tls = "0.3.0"
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"
 log = "0.4"
 thiserror = "1.0"
 
-ntex-tokio = { version = "0.2.3", optional = true }
+ntex-tokio = { version = "0.3.0", optional = true }
-ntex-glommio = { version = "0.2.4", optional = true }
+ntex-glommio = { version = "0.3.0", optional = true }
-ntex-async-std = { version = "0.2.2", optional = true }
+ntex-async-std = { version = "0.3.0", optional = true }
 
 # openssl
 tls-openssl = { version="0.10", package = "openssl", optional = true }
 
 # rustls
-tls-rustls = { version = "0.20", package = "rustls", optional = true }
+tls-rustls = { version = "0.21", package = "rustls", optional = true }
-webpki-roots = { version = "0.22", optional = true }
+webpki-roots = { version = "0.23", optional = true }
 
 [dev-dependencies]
 rand = "0.8"
 env_logger = "0.10"
-ntex = { version = "0.6.0", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }

ntex-connect/src/lib.rs

@@ -20,7 +20,6 @@ pub use self::resolve::Resolver;
 pub use self::service::Connector;
 
 use ntex_io::Io;
-use ntex_service::Service;
 
 /// Resolve and connect to remote host
 pub async fn connect<T, U>(message: U) -> Result<Io, ConnectError>
@@ -28,7 +27,8 @@ where
     T: Address,
     Connect<T>: From<U>,
 {
-    service::ConnectServiceResponse::new(Resolver::new().call(message.into())).await
+    service::ConnectServiceResponse::new(Box::pin(Resolver::new().lookup(message.into())))
+        .await
 }
 
 #[allow(unused_imports)]

ntex-connect/src/openssl.rs

@@ -5,22 +5,22 @@ pub use tls_openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslM
 
 use ntex_bytes::PoolId;
 use ntex_io::{FilterFactory, Io, Layer};
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Container, Ctx, Service, ServiceFactory};
 use ntex_tls::openssl::SslConnector as IoSslConnector;
 use ntex_util::future::{BoxFuture, Ready};
 
 use super::{Address, Connect, ConnectError, Connector as BaseConnector};
 
 pub struct Connector<T> {
-    connector: BaseConnector<T>,
+    connector: Container<BaseConnector<T>>,
     openssl: SslConnector,
 }
 
-impl<T> Connector<T> {
+impl<T: Address> Connector<T> {
     /// Construct new OpensslConnectService factory
     pub fn new(connector: SslConnector) -> Self {
         Connector {
-            connector: BaseConnector::default(),
+            connector: BaseConnector::default().into(),
             openssl: connector,
         }
     }
@@ -30,8 +30,15 @@ impl<T> Connector<T> {
     /// Use specified memory pool for memory allocations. By default P0
     /// memory pool is used.
     pub fn memory_pool(self, id: PoolId) -> Self {
+        let connector = self
+            .connector
+            .into_service()
+            .expect("Connector has been cloned")
+            .memory_pool(id)
+            .into();
+
         Self {
-            connector: self.connector.memory_pool(id),
+            connector,
             openssl: self.openssl,
         }
     }
@@ -100,7 +107,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
     #[inline]
-    fn call(&self, req: Connect<T>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         Box::pin(self.connect(req))
     }
 }
@@ -108,7 +115,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ntex_service::{Service, ServiceFactory};
+    use ntex_service::ServiceFactory;
 
     #[ntex::test]
     async fn test_openssl_connect() {
@@ -117,9 +124,9 @@ mod tests {
         });
 
         let ssl = SslConnector::builder(SslMethod::tls()).unwrap();
-        let factory = Connector::new(ssl.build()).clone().memory_pool(PoolId::P5);
+        let factory = Connector::new(ssl.build()).memory_pool(PoolId::P5).clone();
 
-        let srv = factory.create(&()).await.unwrap();
+        let srv = factory.container(&()).await.unwrap();
         let result = srv
             .call(Connect::new("").set_addr(Some(server.addr())))
             .await;

ntex-connect/src/resolve.rs

@@ -1,7 +1,7 @@
 use std::{fmt, io, marker, net};
 
 use ntex_rt::spawn_blocking;
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Ctx, Service, ServiceFactory};
 use ntex_util::future::{BoxFuture, Either, Ready};
 
 use crate::{Address, Connect, ConnectError};
@@ -115,7 +115,7 @@ impl<T: Address> Service<Connect<T>> for Resolver<T> {
     type Future<'f> = BoxFuture<'f, Result<Connect<T>, Self::Error>>;
 
     #[inline]
-    fn call(&self, req: Connect<T>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'_> {
         Box::pin(self.lookup(req))
     }
 }
@@ -129,7 +129,7 @@ mod tests {
     async fn resolver() {
         let resolver = Resolver::default().clone();
         assert!(format!("{:?}", resolver).contains("Resolver"));
-        let srv = resolver.create(()).await.unwrap();
+        let srv = resolver.container(()).await.unwrap();
         assert!(lazy(|cx| srv.poll_ready(cx)).await.is_ready());
 
         let res = srv.call(Connect::new("www.rust-lang.org")).await;

ntex-connect/src/rustls.rs

@@ -5,7 +5,7 @@ pub use tls_rustls::{ClientConfig, ServerName};
 
 use ntex_bytes::PoolId;
 use ntex_io::{FilterFactory, Io, Layer};
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Container, Ctx, Service, ServiceFactory};
 use ntex_tls::rustls::TlsConnector;
 use ntex_util::future::{BoxFuture, Ready};
 
@@ -13,24 +13,24 @@ use super::{Address, Connect, ConnectError, Connector as BaseConnector};
 
 /// Rustls connector factory
 pub struct Connector<T> {
-    connector: BaseConnector<T>,
+    connector: Container<BaseConnector<T>>,
     inner: TlsConnector,
 }
 
-impl<T> From<std::sync::Arc<ClientConfig>> for Connector<T> {
+impl<T: Address> From<std::sync::Arc<ClientConfig>> for Connector<T> {
     fn from(cfg: std::sync::Arc<ClientConfig>) -> Self {
         Connector {
             inner: TlsConnector::new(cfg),
-            connector: BaseConnector::default(),
+            connector: BaseConnector::default().into(),
         }
     }
 }
 
-impl<T> Connector<T> {
+impl<T: Address> Connector<T> {
     pub fn new(config: ClientConfig) -> Self {
         Connector {
             inner: TlsConnector::new(std::sync::Arc::new(config)),
-            connector: BaseConnector::default(),
+            connector: BaseConnector::default().into(),
         }
     }
 
@@ -39,8 +39,14 @@ impl<T> Connector<T> {
     /// Use specified memory pool for memory allocations. By default P0
     /// memory pool is used.
     pub fn memory_pool(self, id: PoolId) -> Self {
+        let connector = self
+            .connector
+            .into_service()
+            .unwrap()
+            .memory_pool(id)
+            .into();
         Self {
-            connector: self.connector.memory_pool(id),
+            connector,
             inner: self.inner,
         }
     }
@@ -104,7 +110,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Error = ConnectError;
     type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
-    fn call(&self, req: Connect<T>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         Box::pin(self.connect(req))
     }
 }
@@ -115,7 +121,7 @@ mod tests {
     use tls_rustls::{OwnedTrustAnchor, RootCertStore};
 
     use super::*;
-    use ntex_service::{Service, ServiceFactory};
+    use ntex_service::ServiceFactory;
     use ntex_util::future::lazy;
 
     #[ntex::test]
@@ -139,9 +145,11 @@ mod tests {
             .with_root_certificates(cert_store)
             .with_no_client_auth();
         let _ = Connector::<&'static str>::new(config.clone()).clone();
-        let factory = Connector::from(Arc::new(config)).memory_pool(PoolId::P5);
+        let factory = Connector::from(Arc::new(config))
+            .memory_pool(PoolId::P5)
+            .clone();
 
-        let srv = factory.create(&()).await.unwrap();
+        let srv = factory.container(&()).await.unwrap();
         // always ready
         assert!(lazy(|cx| srv.poll_ready(cx)).await.is_ready());
         let result = srv

ntex-connect/src/service.rs

@@ -3,7 +3,7 @@ use std::{collections::VecDeque, future::Future, io, net::SocketAddr, pin::Pin};
 
 use ntex_bytes::{PoolId, PoolRef};
 use ntex_io::{types, Io};
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Ctx, Service, ServiceFactory};
 use ntex_util::future::{BoxFuture, Either, Ready};
 
 use crate::{net::tcp_connect_in, Address, Connect, ConnectError, Resolver};
@@ -39,7 +39,7 @@ impl<T: Address> Connector<T> {
         Connect<T>: From<U>,
     {
         ConnectServiceResponse {
-            state: ConnectState::Resolve(self.resolver.call(message.into())),
+            state: ConnectState::Resolve(Box::pin(self.resolver.lookup(message.into()))),
             pool: self.pool,
         }
         .await
@@ -80,13 +80,13 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Future<'f> = ConnectServiceResponse<'f, T>;
 
     #[inline]
-    fn call(&self, req: Connect<T>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
-        ConnectServiceResponse::new(self.resolver.call(req))
+        ConnectServiceResponse::new(Box::pin(self.resolver.lookup(req)))
     }
 }
 
 enum ConnectState<'f, T: Address> {
-    Resolve(<Resolver<T> as Service<Connect<T>>>::Future<'f>),
+    Resolve(BoxFuture<'f, Result<Connect<T>, ConnectError>>),
     Connect(TcpConnectorResponse<T>),
 }
 
@@ -97,7 +97,7 @@ pub struct ConnectServiceResponse<'f, T: Address> {
 }
 
 impl<'f, T: Address> ConnectServiceResponse<'f, T> {
-    pub(super) fn new(fut: <Resolver<T> as Service<Connect<T>>>::Future<'f>) -> Self {
+    pub(super) fn new(fut: BoxFuture<'f, Result<Connect<T>, ConnectError>>) -> Self {
         Self {
             state: ConnectState::Resolve(fut),
             pool: PoolId::P0.pool_ref(),

ntex-glommio/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-glommio"
-version = "0.2.4"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "glommio intergration for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,8 +17,8 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.2.4"
+ntex-io = "0.3.0"
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"
 async-oneshot = "0.5.0"
 futures-lite = "1.12"
 log = "0.4"

ntex-http/src/value.rs

@@ -1,5 +1,4 @@
 #![allow(
-    clippy::derive_hash_xor_eq,
     clippy::should_implement_trait,
     clippy::no_effect,
     clippy::missing_safety_doc
@@ -8,6 +7,7 @@ use std::{cmp, error::Error, fmt, str, str::FromStr};
 
 use ntex_bytes::{ByteString, Bytes};
 
+#[allow(clippy::derived_hash_with_manual_eq)]
 /// Represents an HTTP header field value.
 ///
 /// In practice, HTTP header field values are usually valid ASCII. However, the
@@ -17,7 +17,7 @@ use ntex_bytes::{ByteString, Bytes};
 /// To handle this, the `HeaderValue` is useable as a type and can be compared
 /// with strings and implements `Debug`. A `to_str` fn is provided that returns
 /// an `Err` if the header value contains non visible ascii characters.
-#[derive(Clone, Hash)]
+#[derive(Clone, Hash, Eq)]
 pub struct HeaderValue {
     inner: Bytes,
     is_sensitive: bool,
@@ -542,8 +542,6 @@ impl PartialEq for HeaderValue {
     }
 }
 
-impl Eq for HeaderValue {}
-
 impl PartialOrd for HeaderValue {
     #[inline]
     fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {

ntex-io/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.2.10"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,8 +18,8 @@ path = "src/lib.rs"
 [dependencies]
 ntex-codec = "0.6.2"
 ntex-bytes = "0.1.19"
-ntex-util = "0.2.2"
+ntex-util = "0.3.0"
-ntex-service = "1.0.2"
+ntex-service = "1.2.0"
 
 bitflags = "1.3"
 log = "0.4"
@@ -29,4 +29,4 @@ pin-project-lite = "0.2"
 rand = "0.8"
 env_logger = "0.10"
 
-ntex = { version = "0.6.3", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }

ntex-io/src/buf.rs

@@ -376,14 +376,12 @@ impl<'a> ReadBuf<'a> {
         if let Some(dst) = dst {
             if dst.is_empty() {
                 self.io.memory_pool().release_read_buf(dst);
+            } else if let Some(mut buf) = self.curr.0.take() {
+                buf.extend_from_slice(&dst);
+                self.curr.0.set(Some(buf));
+                self.io.memory_pool().release_read_buf(dst);
             } else {
-                if let Some(mut buf) = self.curr.0.take() {
+                self.curr.0.set(Some(dst));
-                    buf.extend_from_slice(&dst);
-                    self.curr.0.set(Some(buf));
-                    self.io.memory_pool().release_read_buf(dst);
-                } else {
-                    self.curr.0.set(Some(dst));
-                }
             }
         }
     }

ntex-io/src/dispatcher.rs

@@ -3,7 +3,7 @@ use std::{cell::Cell, future, pin::Pin, rc::Rc, task::Context, task::Poll, time}
 
 use ntex_bytes::Pool;
 use ntex_codec::{Decoder, Encoder};
-use ntex_service::{IntoService, Service};
+use ntex_service::{Container, IntoService, Service};
 use ntex_util::time::Seconds;
 use ntex_util::{future::Either, ready, spawn};
 
@@ -51,7 +51,7 @@ where
 {
     io: IoBoxed,
     codec: U,
-    service: S,
+    service: Container<S>,
     error: Cell<Option<DispatcherError<S::Error, <U as Encoder>::Error>>>,
     inflight: Cell<usize>,
 }
@@ -107,7 +107,7 @@ where
             codec,
             error: Cell::new(None),
             inflight: Cell::new(0),
-            service: service.into_service(),
+            service: Container::new(service.into_service()),
         });
 
         Dispatcher {
@@ -340,7 +340,7 @@ where
 {
     fn poll_service(
         &self,
-        srv: &S,
+        srv: &Container<S>,
         cx: &mut Context<'_>,
         io: &IoBoxed,
     ) -> Poll<PollService<U>> {
@@ -426,6 +426,7 @@ mod tests {
 
     use ntex_bytes::{Bytes, PoolId, PoolRef};
     use ntex_codec::BytesCodec;
+    use ntex_service::Ctx;
     use ntex_util::{future::Ready, time::sleep, time::Millis, time::Seconds};
 
     use super::*;
@@ -475,7 +476,7 @@ mod tests {
                 io: state.into(),
                 error: Cell::new(None),
                 inflight: Cell::new(0),
-                service: service.into_service(),
+                service: Container::new(service.into_service()),
             });
 
             (
@@ -621,7 +622,11 @@ mod tests {
                 Poll::Ready(Err(()))
             }
 
-            fn call(&self, _: DispatchItem<BytesCodec>) -> Self::Future<'_> {
+            fn call<'a>(
+                &'a self,
+                _: DispatchItem<BytesCodec>,
+                _: Ctx<'a, Self>,
+            ) -> Self::Future<'a> {
                 Ready::Ok(None)
             }
         }

ntex-io/src/testing.rs

@@ -80,20 +80,15 @@ impl Default for IoTestFlags {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 enum IoTestState {
+    #[default]
     Ok,
     Pending,
     Close,
     Err(io::Error),
 }
 
-impl Default for IoTestState {
-    fn default() -> Self {
-        IoTestState::Ok
-    }
-}
-
 impl IoTest {
     /// Create a two interconnected streams
     pub fn create() -> (IoTest, IoTest) {

ntex-io/src/utils.rs

@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use ntex_service::{fn_service, pipeline_factory, Service, ServiceFactory};
+use ntex_service::{fn_service, pipeline_factory, Ctx, Service, ServiceFactory};
 use ntex_util::future::Ready;
 
 use crate::{Filter, FilterFactory, Io, IoBoxed, Layer};
@@ -75,7 +75,7 @@ where
     type Future<'f> = T::Future where T: 'f, F: 'f;
 
     #[inline]
-    fn call(&self, req: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         self.filter.clone().create(req)
     }
 }
@@ -106,7 +106,7 @@ mod tests {
                 .unwrap();
             Ok::<_, ()>(())
         }))
-        .create(())
+        .container(())
         .await
         .unwrap();
         let _ = svc.call(Io::new(server)).await;
@@ -152,7 +152,7 @@ mod tests {
             let _ = io.recv(&BytesCodec).await;
             Ok::<_, ()>(())
         })))
-        .create(())
+        .container(())
         .await
         .unwrap();
         let _ = svc.call(Io::new(server)).await;

ntex-macros/Cargo.toml

@@ -16,6 +16,6 @@ syn = { version = "^1", features = ["full", "parsing"] }
 proc-macro2 = "^1"
 
 [dev-dependencies]
-ntex = { version = "0.6.0-alpha.0", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }
 futures = "0.3"
 env_logger = "0.10"

ntex-router/src/quoter.rs

@@ -50,7 +50,7 @@ pub(super) fn requote(val: &[u8]) -> Option<String> {
 
 #[inline]
 fn from_hex(v: u8) -> Option<u8> {
-    if (b'0'..=b'9').contains(&v) {
+    if v.is_ascii_digit() {
         Some(v - 0x30) // ord('0') == 0x30
     } else if (b'A'..=b'F').contains(&v) {
         Some(v - 0x41 + 10) // ord('A') == 0x41

ntex-service/Cargo.toml

@@ -20,5 +20,5 @@ pin-project-lite = "0.2.6"
 slab = "0.4"
 
 [dev-dependencies]
-ntex = { version = "0.6.0", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"

ntex-service/src/and_then.rs

@@ -59,10 +59,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         AndThenServiceResponse {
             slf: self,
             state: State::A {
@@ -253,10 +250,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            &'static str: 'a,
-        {
             Ready::Ok(req)
         }
     }
@@ -274,10 +268,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            &'static str: 'a,
-        {
             Ready::Ok((req, "srv2"))
         }
     }

ntex-service/src/apply.rs

@@ -101,10 +101,7 @@ where
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: In, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: In, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        In: 'a,
-    {
         let (index, waiters) = ctx.into_inner();
         let svc = ApplyService {
             index,
@@ -235,10 +232,7 @@ mod tests {
         type Error = ();
         type Future<'f> = Ready<(), ()>;
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            (): 'a,
-        {
             Ready::Ok(())
         }
     }

ntex-service/src/boxed.rs

@@ -62,9 +62,7 @@ pub trait ServiceObj<Req> {
         req: Req,
         idx: usize,
         waiters: &'a Rc<RefCell<slab::Slab<Option<Waker>>>>,
-    ) -> BoxFuture<'a, Self::Response, Self::Error>
+    ) -> BoxFuture<'a, Self::Response, Self::Error>;
-    where
-        Req: 'a;
 }
 
 impl<S, Req> ServiceObj<Req> for S
@@ -91,10 +89,7 @@ where
         req: Req,
         idx: usize,
         waiters: &'a Rc<RefCell<slab::Slab<Option<Waker>>>>,
-    ) -> BoxFuture<'a, Self::Response, Self::Error>
+    ) -> BoxFuture<'a, Self::Response, Self::Error> {
-    where
-        Req: 'a,
-    {
         Box::pin(Ctx::<'a, S>::new(idx, waiters).call_nowait(self, req))
     }
 }
@@ -194,10 +189,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         let (index, waiters) = ctx.into_inner();
         self.0.call(req, index, waiters)
     }
@@ -230,10 +222,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         let (index, waiters) = ctx.into_inner();
         self.0.call(req, index, waiters)
     }

ntex-service/src/ctx.rs

@@ -1,18 +1,14 @@
-use std::{cell::RefCell, future::Future, marker, pin::Pin, rc::Rc, task, task::Poll};
+use std::{cell::RefCell, future::Future, marker, ops, pin::Pin, rc::Rc, task, task::Poll};
 
 use crate::{Service, ServiceFactory};
 
-pub struct Container<S, R> {
+pub struct Container<S> {
     svc: Rc<S>,
     index: usize,
     waiters: Rc<RefCell<slab::Slab<Option<task::Waker>>>>,
-    _t: marker::PhantomData<R>,
 }
 
-impl<S, R> Container<S, R>
+impl<S> Container<S> {
-where
-    S: Service<R>,
-{
     #[inline]
     pub fn new(svc: S) -> Self {
         let mut waiters = slab::Slab::new();
@@ -21,13 +17,15 @@ where
             index,
             svc: Rc::new(svc),
             waiters: Rc::new(RefCell::new(waiters)),
-            _t: marker::PhantomData,
         }
     }
 
     #[inline]
     /// Returns `Ready` when the service is able to process requests.
-    pub fn poll_ready(&self, cx: &mut task::Context<'_>) -> Poll<Result<(), S::Error>> {
+    pub fn poll_ready<R>(&self, cx: &mut task::Context<'_>) -> Poll<Result<(), S::Error>>
+    where
+        S: Service<R>,
+    {
         let res = self.svc.poll_ready(cx);
 
         if res.is_pending() {
@@ -38,13 +36,19 @@ where
 
     #[inline]
     /// Shutdown enclosed service.
-    pub fn poll_shutdown(&self, cx: &mut task::Context<'_>) -> Poll<()> {
+    pub fn poll_shutdown<R>(&self, cx: &mut task::Context<'_>) -> Poll<()>
+    where
+        S: Service<R>,
+    {
         self.svc.poll_shutdown(cx)
     }
 
     #[inline]
     /// Process the request and return the response asynchronously.
-    pub fn call<'a>(&'a self, req: R) -> ServiceCall<'a, S, R> {
+    pub fn call<'a, R>(&'a self, req: R) -> ServiceCall<'a, S, R>
+    where
+        S: Service<R>,
+    {
         let ctx = Ctx::<'a, S> {
             index: self.index,
             waiters: &self.waiters,
@@ -53,7 +57,7 @@ where
         ctx.call(self.svc.as_ref(), req)
     }
 
-    pub(crate) fn create<F: ServiceFactory<R, C>, C>(
+    pub(crate) fn create<F: ServiceFactory<R, C>, R, C>(
         f: &F,
         cfg: C,
     ) -> ContainerFactory<'_, F, R, C> {
@@ -62,9 +66,15 @@ where
             _t: marker::PhantomData,
         }
     }
+
+    pub fn into_service(self) -> Option<S> {
+        let svc = self.svc.clone();
+        drop(self);
+        Rc::try_unwrap(svc).ok()
+    }
 }
 
-impl<S, R> Clone for Container<S, R> {
+impl<S> Clone for Container<S> {
     fn clone(&self) -> Self {
         let index = self.waiters.borrow_mut().insert(None);
 
@@ -72,21 +82,26 @@ impl<S, R> Clone for Container<S, R> {
             index,
             svc: self.svc.clone(),
             waiters: self.waiters.clone(),
-            _t: marker::PhantomData,
         }
     }
 }
 
-impl<S, R> From<S> for Container<S, R>
+impl<S> From<S> for Container<S> {
-where
-    S: Service<R>,
-{
     fn from(svc: S) -> Self {
         Container::new(svc)
     }
 }
 
-impl<S, R> Drop for Container<S, R> {
+impl<S> ops::Deref for Container<S> {
+    type Target = S;
+
+    #[inline]
+    fn deref(&self) -> &S {
+        self.svc.as_ref()
+    }
+}
+
+impl<S> Drop for Container<S> {
     fn drop(&mut self) {
         let mut waiters = self.waiters.borrow_mut();
 
@@ -268,7 +283,7 @@ impl<'f, F, R, C> Future for ContainerFactory<'f, F, R, C>
 where
     F: ServiceFactory<R, C> + 'f,
 {
-    type Output = Result<Container<F::Service, R>, F::InitError>;
+    type Output = Result<Container<F::Service>, F::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
         Poll::Ready(Ok(Container::new(task::ready!(self
@@ -297,10 +312,7 @@ mod tests {
             self.1.poll_ready(cx).map(|_| Ok(()))
         }
 
-        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            &'static str: 'a,
-        {
             Ready::Ok(req)
         }
     }

ntex-service/src/fn_service.rs

@@ -128,10 +128,7 @@ where
     type Future<'f> = Fut where Self: 'f, Req: 'f;
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         (self.f)(req)
     }
 }
@@ -193,10 +190,7 @@ where
     type Future<'f> = Fut where Self: 'f;
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         (self.f)(req)
     }
 }

ntex-service/src/fn_shutdown.rs

@@ -60,10 +60,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         ready(Ok(req))
     }
 }

ntex-service/src/lib.rs

@@ -54,7 +54,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 /// simple API surfaces. This leads to simpler design of each service, improves test-ability and
 /// makes composition easier.
 ///
-/// ```rust,ignore
+/// ```rust
 /// # use std::convert::Infallible;
 /// # use std::future::Future;
 /// # use std::pin::Pin;
@@ -101,9 +101,7 @@ pub trait Service<Req> {
     ///
     /// Invoking `call` without first invoking `poll_ready` is permitted. Implementations must be
     /// resilient to this fact.
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>;
-    where
-        Req: 'a;
 
     #[inline]
     /// Returns `Ready` when the service is able to process requests.
@@ -203,7 +201,7 @@ pub trait ServiceFactory<Req, Cfg = ()> {
     where
         Self: Sized,
     {
-        Container::<Self::Service, Req>::create(self, cfg)
+        Container::<Self::Service>::create(self, cfg)
     }
 
     #[inline]
@@ -260,10 +258,7 @@ where
     }
 
     #[inline]
-    fn call<'s>(&'s self, request: Req, ctx: Ctx<'s, Self>) -> S::Future<'s>
+    fn call<'s>(&'s self, request: Req, ctx: Ctx<'s, Self>) -> S::Future<'s> {
-    where
-        Req: 's,
-    {
         ctx.call_nowait(&**self, request)
     }
 }
@@ -287,10 +282,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, request: Req, ctx: Ctx<'a, Self>) -> S::Future<'a>
+    fn call<'a>(&'a self, request: Req, ctx: Ctx<'a, Self>) -> S::Future<'a> {
-    where
-        Req: 'a,
-    {
         ctx.call_nowait(&**self, request)
     }
 }

ntex-service/src/map.rs

@@ -54,10 +54,7 @@ where
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         MapFuture {
             fut: ctx.call(&self.service, req),
             slf: self,
@@ -209,10 +206,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            (): 'a,
-        {
             Ready::Ok(())
         }
     }

ntex-service/src/map_err.rs

@@ -57,10 +57,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        R: 'a,
-    {
         MapErrFuture {
             slf: self,
             fut: ctx.call(&self.service, req),
@@ -217,10 +214,7 @@ mod tests {
             }
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            (): 'a,
-        {
             Ready::Err(())
         }
     }

ntex-service/src/middleware.rs

@@ -239,10 +239,7 @@ mod tests {
             self.0.poll_ready(cx)
         }
 
-        fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-        where
-            R: 'a,
-        {
             ctx.call(&self.0, req)
         }
     }

ntex-service/src/pipeline.rs

@@ -118,7 +118,7 @@ impl<Req, Svc: Service<Req>> Pipeline<Req, Svc> {
     }
 
     /// Create service container
-    pub fn container(self) -> Container<Svc, Req> {
+    pub fn container(self) -> Container<Svc> {
         Container::new(self.service)
     }
 }
@@ -144,10 +144,7 @@ impl<Req, Svc: Service<Req>> Service<Req> for Pipeline<Req, Svc> {
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        Req: 'a,
-    {
         ctx.call(&self.service, req)
     }
 }

ntex-service/src/then.rs

@@ -60,10 +60,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
-    where
-        R: 'a,
-    {
         ThenServiceResponse {
             slf: self,
             state: State::A {
@@ -270,10 +267,7 @@ mod tests {
             &'a self,
             req: Result<&'static str, &'static str>,
             _: Ctx<'a, Self>,
-        ) -> Self::Future<'a>
+        ) -> Self::Future<'a> {
-        where
-            Result<&'static str, &'static str>: 'a,
-        {
             match req {
                 Ok(msg) => Ready::Ok(msg),
                 Err(_) => Ready::Err(()),
@@ -298,10 +292,7 @@ mod tests {
             &'a self,
             req: Result<&'static str, ()>,
             _: Ctx<'a, Self>,
-        ) -> Self::Future<'a>
+        ) -> Self::Future<'a> {
-        where
-            Result<&'static str, ()>: 'a,
-        {
             match req {
                 Ok(msg) => Ready::Ok((msg, "ok")),
                 Err(()) => Ready::Ok(("srv2", "err")),
@@ -329,7 +320,6 @@ mod tests {
             .container();
 
         let res = srv.call(Ok("srv1")).await;
-        println!("=========== {:?}", res);
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv1", "ok"));
 

ntex-tls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "0.2.4"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "An implementation of SSL streams for ntex backed by OpenSSL"
 keywords = ["network", "framework", "async", "futures"]
@@ -26,20 +26,20 @@ rustls = ["tls_rust"]
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.2.7"
+ntex-io = "0.3.0"
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"
-ntex-service = "1.0.0"
+ntex-service = "1.2.0"
 log = "0.4"
 pin-project-lite = "0.2"
 
 # openssl
-tls_openssl = { version="0.10", package = "openssl", optional = true }
+tls_openssl = { version = "0.10", package = "openssl", optional = true }
 
 # rustls
 tls_rust = { version = "0.21", package = "rustls", optional = true }
 
 [dev-dependencies]
-ntex = { version = "0.6.3", features = ["openssl", "rustls", "tokio"] }
+ntex = { version = "0.7.0", features = ["openssl", "rustls", "tokio"] }
 env_logger = "0.10"
 rustls-pemfile = { version = "1.0" }
-webpki-roots = { version = "0.22" }
+webpki-roots = { version = "0.23" }

ntex-tls/src/openssl/accept.rs

@@ -2,7 +2,7 @@ use std::task::{Context, Poll};
 use std::{error::Error, future::Future, marker::PhantomData, pin::Pin};
 
 use ntex_io::{Filter, FilterFactory, Io, Layer};
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Ctx, Service, ServiceFactory};
 use ntex_util::{future::Ready, time::Millis};
 use tls_openssl::ssl::SslAcceptor;
 
@@ -95,7 +95,7 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
     }
 
     #[inline]
-    fn call(&self, req: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         AcceptorServiceResponse {
             _guard: self.conns.get(),
             fut: self.acceptor.clone().create(req),

ntex-tls/src/rustls/accept.rs

@@ -4,7 +4,7 @@ use std::{future::Future, io, marker::PhantomData, pin::Pin, sync::Arc};
 use tls_rust::ServerConfig;
 
 use ntex_io::{Filter, FilterFactory, Io, Layer};
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Ctx, Service, ServiceFactory};
 use ntex_util::{future::Ready, time::Millis};
 
 use super::{TlsAcceptor, TlsFilter};
@@ -93,7 +93,7 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
     }
 
     #[inline]
-    fn call(&self, req: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         AcceptorServiceFut {
             _guard: self.conns.get(),
             fut: self.acceptor.clone().create(req),

ntex-tokio/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tokio"
-version = "0.2.3"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "tokio intergration for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,8 +17,8 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.2.4"
+ntex-io = "0.3.0"
-ntex-util = "0.2.0"
+ntex-util = "0.3.0"
 log = "0.4"
 pin-project-lite = "0.2"
 tokio = { version = "1", default-features = false, features = ["rt", "net", "sync", "signal"] }

ntex-util/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.0] - 2023-06-xx
+
+* Upgrade to ntex-service 1.2
+
 ## [0.2.3] - 2023-06-04
 
 * Refactor timer driver

ntex-util/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-util"
-version = "0.2.3"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,7 +17,7 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-rt = "0.4.7"
-ntex-service = "1.0.0"
+ntex-service = "1.2.0"
 bitflags = "1.3"
 fxhash = "0.2.1"
 log = "0.4"
@@ -28,7 +28,7 @@ futures-sink = { version = "0.3", default-features = false, features = ["alloc"]
 pin-project-lite = "0.2.9"
 
 [dev-dependencies]
-ntex = { version = "0.6.0", features = ["tokio"] }
+ntex = { version = "0.7.0", features = ["tokio"] }
 ntex-bytes = "0.1.18"
 ntex-macros = "0.1.3"
 futures-util = { version = "0.3", default-features = false, features = ["alloc"] }

ntex-util/src/services/buffer.rs

@@ -1,63 +1,59 @@
 //! Service that buffers incomming requests.
 use std::cell::{Cell, RefCell};
-use std::task::{Context, Poll};
+use std::task::{ready, Context, Poll};
-use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
+use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin};
 
-use ntex_service::{IntoService, Middleware, Service};
+use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
 
 use crate::{channel::oneshot, future::Either, task::LocalWaker};
 
 /// Buffer - service factory for service that can buffer incoming request.
 ///
 /// Default number of buffered requests is 16
-pub struct Buffer<R, E> {
+pub struct Buffer<R> {
     buf_size: usize,
-    err: Rc<dyn Fn() -> E>,
     _t: PhantomData<R>,
 }
 
-impl<R, E> Buffer<R, E> {
+impl<R> Default for Buffer<R> {
-    pub fn new<F>(f: F) -> Self
+    fn default() -> Self {
-    where
-        F: Fn() -> E + 'static,
-    {
         Self {
             buf_size: 16,
-            err: Rc::new(f),
             _t: PhantomData,
         }
     }
+}
 
+impl<R> Buffer<R> {
     pub fn buf_size(mut self, size: usize) -> Self {
         self.buf_size = size;
         self
     }
 }
 
-impl<R, E> Clone for Buffer<R, E> {
+impl<R> Clone for Buffer<R> {
     fn clone(&self) -> Self {
         Self {
             buf_size: self.buf_size,
-            err: self.err.clone(),
             _t: PhantomData,
         }
     }
 }
 
-impl<R, S, E> Middleware<S> for Buffer<R, E>
+impl<R, S> Middleware<S> for Buffer<R>
 where
-    S: Service<R, Error = E>,
+    S: Service<R>,
 {
-    type Service = BufferService<R, S, E>;
+    type Service = BufferService<R, S>;
 
     fn create(&self, service: S) -> Self::Service {
         BufferService {
             service,
             size: self.buf_size,
-            err: self.err.clone(),
             ready: Cell::new(false),
             waker: LocalWaker::default(),
             buf: RefCell::new(VecDeque::with_capacity(self.buf_size)),
+            _t: PhantomData,
         }
     }
 }
@@ -65,58 +61,57 @@ where
 /// Buffer service - service that can buffer incoming requests.
 ///
 /// Default number of buffered requests is 16
-pub struct BufferService<R, S: Service<R, Error = E>, E> {
+pub struct BufferService<R, S: Service<R>> {
     size: usize,
     ready: Cell<bool>,
     service: S,
     waker: LocalWaker,
-    err: Rc<dyn Fn() -> E>,
+    buf: RefCell<VecDeque<oneshot::Sender<()>>>,
-    buf: RefCell<VecDeque<(oneshot::Sender<R>, R)>>,
+    _t: PhantomData<R>,
 }
 
-impl<R, S, E> BufferService<R, S, E>
+impl<R, S> BufferService<R, S>
 where
-    S: Service<R, Error = E>,
+    S: Service<R>,
 {
-    pub fn new<U, F>(size: usize, err: F, service: U) -> Self
+    pub fn new<U>(size: usize, service: U) -> Self
     where
         U: IntoService<S, R>,
-        F: Fn() -> E + 'static,
     {
         Self {
             size,
-            err: Rc::new(err),
             ready: Cell::new(false),
             service: service.into_service(),
             waker: LocalWaker::default(),
             buf: RefCell::new(VecDeque::with_capacity(size)),
+            _t: PhantomData,
         }
     }
 }
 
-impl<R, S, E> Clone for BufferService<R, S, E>
+impl<R, S> Clone for BufferService<R, S>
 where
-    S: Service<R, Error = E> + Clone,
+    S: Service<R> + Clone,
 {
     fn clone(&self) -> Self {
         Self {
             size: self.size,
-            err: self.err.clone(),
             ready: Cell::new(false),
             service: self.service.clone(),
             waker: LocalWaker::default(),
             buf: RefCell::new(VecDeque::with_capacity(self.size)),
+            _t: PhantomData,
         }
     }
 }
 
-impl<R, S, E> Service<R> for BufferService<R, S, E>
+impl<R, S> Service<R> for BufferService<R, S>
 where
-    S: Service<R, Error = E>,
+    S: Service<R>,
 {
     type Response = S::Response;
     type Error = S::Error;
-    type Future<'f> = Either<S::Future<'f>, BufferServiceResponse<'f, R, S, E>> where Self: 'f, R: 'f;
+    type Future<'f> = Either<ServiceCall<'f, S, R>, BufferServiceResponse<'f, R, S>> where Self: 'f, R: 'f;
 
     #[inline]
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -132,8 +127,8 @@ where
                 log::trace!("Buffer limit exceeded");
                 Poll::Pending
             }
-        } else if let Some((sender, req)) = buffer.pop_front() {
+        } else if let Some(sender) = buffer.pop_front() {
-            let _ = sender.send(req);
+            let _ = sender.send(());
             self.ready.set(false);
             Poll::Ready(Ok(()))
         } else {
@@ -143,17 +138,18 @@ where
     }
 
     #[inline]
-    fn call(&self, req: R) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         if self.ready.get() {
             self.ready.set(false);
-            Either::Left(self.service.call(req))
+            Either::Left(ctx.call(&self.service, req))
         } else {
             let (tx, rx) = oneshot::channel();
-            self.buf.borrow_mut().push_back((tx, req));
+            self.buf.borrow_mut().push_back(tx);
 
             Either::Right(BufferServiceResponse {
                 slf: self,
-                state: State::Tx { rx },
+                fut: ctx.call(&self.service, req),
+                rx: Some(rx),
             })
         }
     }
@@ -163,63 +159,40 @@ where
 
 pin_project_lite::pin_project! {
     #[doc(hidden)]
-    pub struct BufferServiceResponse<'f, R, S: Service<R, Error = E>, E>
+    #[must_use = "futures do nothing unless polled"]
+    pub struct BufferServiceResponse<'f, R, S: Service<R>>
     {
-        slf: &'f BufferService<R, S, E>,
         #[pin]
-        state: State<R, S::Future<'f>>,
+        fut: ServiceCall<'f, S, R>,
+        slf: &'f BufferService<R, S>,
+        rx: Option<oneshot::Receiver<()>>,
     }
 }
 
-pin_project_lite::pin_project! {
+impl<'f, R, S> Future for BufferServiceResponse<'f, R, S>
-    #[project = StateProject]
-    enum State<R, F>
-    where F: Future,
-    {
-        Tx { rx: oneshot::Receiver<R> },
-        Srv { #[pin] fut: F },
-    }
-}
-
-impl<'f, R, S, E> Future for BufferServiceResponse<'f, R, S, E>
 where
-    S: Service<R, Error = E>,
+    S: Service<R>,
 {
     type Output = Result<S::Response, S::Error>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
+        let this = self.as_mut().project();
 
-        loop {
+        if let Some(ref rx) = this.rx {
-            match this.state.project() {
+            let _ = ready!(rx.poll_recv(cx));
-                StateProject::Tx { rx } => match Pin::new(rx).poll(cx) {
+            this.rx.take();
-                    Poll::Ready(Ok(req)) => {
-                        let state = State::Srv {
-                            fut: this.slf.service.call(req),
-                        };
-                        this = self.as_mut().project();
-                        this.state.set(state);
-                    }
-                    Poll::Ready(Err(_)) => return Poll::Ready(Err((*this.slf.err)())),
-                    Poll::Pending => return Poll::Pending,
-                },
-                StateProject::Srv { fut } => {
-                    let res = match fut.poll(cx) {
-                        Poll::Ready(res) => res,
-                        Poll::Pending => return Poll::Pending,
-                    };
-                    this.slf.waker.wake();
-                    return Poll::Ready(res);
-                }
-            }
         }
+
+        let res = ready!(this.fut.poll(cx));
+        this.slf.waker.wake();
+        Poll::Ready(res)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Service, ServiceFactory};
-    use std::task::{Context, Poll};
+    use std::{rc::Rc, task::Context, task::Poll, time::Duration};
 
     use super::*;
     use crate::future::{lazy, Ready};
@@ -247,7 +220,7 @@ mod tests {
             }
         }
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
             self.0.ready.set(false);
             self.0.count.set(self.0.count.get() + 1);
             Ready::Ok(())
@@ -255,21 +228,29 @@ mod tests {
     }
 
     #[ntex_macros::rt_test2]
-    async fn test_transform() {
+    async fn test_service() {
         let inner = Rc::new(Inner {
             ready: Cell::new(false),
             waker: LocalWaker::default(),
             count: Cell::new(0),
         });
 
-        let srv = BufferService::new(2, || (), TestService(inner.clone())).clone();
+        let srv = Container::new(BufferService::new(2, TestService(inner.clone())).clone());
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let fut1 = srv.call(());
+        let srv1 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv1.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 0);
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let fut2 = srv.call(());
+        let srv1 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv1.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 0);
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
@@ -277,14 +258,14 @@ mod tests {
         inner.waker.wake();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let _ = fut1.await;
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 1);
 
         inner.ready.set(true);
         inner.waker.wake();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let _ = fut2.await;
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 2);
 
         let inner = Rc::new(Inner {
@@ -293,7 +274,7 @@ mod tests {
             count: Cell::new(0),
         });
 
-        let srv = BufferService::new(2, || (), TestService(inner.clone()));
+        let srv = Container::new(BufferService::new(2, TestService(inner.clone())));
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
         let _ = srv.call(()).await;
         assert_eq!(inner.count.get(), 1);
@@ -303,7 +284,7 @@ mod tests {
 
     #[ntex_macros::rt_test2]
     #[allow(clippy::redundant_clone)]
-    async fn test_newtransform() {
+    async fn test_middleware() {
         let inner = Rc::new(Inner {
             ready: Cell::new(false),
             waker: LocalWaker::default(),
@@ -311,18 +292,26 @@ mod tests {
         });
 
         let srv = apply(
-            Buffer::new(|| ()).buf_size(2).clone(),
+            Buffer::default().buf_size(2).clone(),
             fn_factory(|| async { Ok::<_, ()>(TestService(inner.clone())) }),
         );
 
-        let srv = srv.create(&()).await.unwrap();
+        let srv = srv.container(&()).await.unwrap();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let fut1 = srv.call(());
+        let srv1 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv1.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 0);
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let fut2 = srv.call(());
+        let srv1 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv1.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 0);
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
@@ -330,14 +319,14 @@ mod tests {
         inner.waker.wake();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let _ = fut1.await;
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 1);
 
         inner.ready.set(true);
         inner.waker.wake();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let _ = fut2.await;
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(inner.count.get(), 2);
     }
 }

ntex-util/src/services/inflight.rs

@@ -1,7 +1,7 @@
 //! Service that limits number of in-flight async requests.
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use ntex_service::{IntoService, Middleware, Service};
+use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
 
 use super::counter::{Counter, CounterGuard};
 
@@ -76,9 +76,9 @@ where
     }
 
     #[inline]
-    fn call(&self, req: R) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         InFlightServiceResponse {
-            fut: self.service.call(req),
+            fut: ctx.call(&self.service, req),
             _guard: self.count.get(),
             _t: PhantomData,
         }
@@ -93,7 +93,7 @@ pin_project_lite::pin_project! {
     where T: 'f, R: 'f
     {
         #[pin]
-        fut: T::Future<'f>,
+        fut: ServiceCall<'f, T, R>,
         _guard: CounterGuard,
         _t: PhantomData<R>
     }
@@ -109,39 +109,43 @@ impl<'f, T: Service<R>, R> Future for InFlightServiceResponse<'f, T, R> {
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
-    use std::{task::Poll, time::Duration};
+    use std::{cell::RefCell, task::Poll, time::Duration};
 
     use super::*;
-    use crate::future::{lazy, BoxFuture};
+    use crate::{channel::oneshot, future::lazy, future::BoxFuture};
 
-    struct SleepService(Duration);
+    struct SleepService(oneshot::Receiver<()>);
 
     impl Service<()> for SleepService {
         type Response = ();
         type Error = ();
         type Future<'f> = BoxFuture<'f, Result<(), ()>>;
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
-            let fut = crate::time::sleep(self.0);
             Box::pin(async move {
-                fut.await;
+                let _ = self.0.recv().await;
                 Ok::<_, ()>(())
             })
         }
     }
 
     #[ntex_macros::rt_test2]
-    async fn test_inflight() {
+    async fn test_service() {
-        let wait_time = Duration::from_millis(50);
+        let (tx, rx) = oneshot::channel();
 
-        let srv = InFlightService::new(1, SleepService(wait_time));
+        let srv = Container::new(InFlightService::new(1, SleepService(rx)));
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let res = srv.call(());
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
-        let _ = res.await;
+        let _ = tx.send(());
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
         assert!(lazy(|cx| srv.poll_shutdown(cx)).await.is_ready());
     }
@@ -154,19 +158,28 @@ mod tests {
             "InFlight { max_inflight: 1 }"
         );
 
-        let wait_time = Duration::from_millis(50);
+        let (tx, rx) = oneshot::channel();
+        let rx = RefCell::new(Some(rx));
         let srv = apply(
             InFlight::new(1),
-            fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }),
+            fn_factory(move || {
+                let rx = rx.borrow_mut().take().unwrap();
+                async move { Ok::<_, ()>(SleepService(rx)) }
+            }),
         );
 
-        let srv = srv.create(&()).await.unwrap();
+        let srv = srv.container(&()).await.unwrap();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let res = srv.call(());
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
-        let _ = res.await;
+        let _ = tx.send(());
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
     }
 }

ntex-util/src/services/keepalive.rs

@@ -1,7 +1,7 @@
 use std::task::{Context, Poll};
 use std::{cell::Cell, convert::Infallible, marker, time::Duration, time::Instant};
 
-use ntex_service::{Service, ServiceFactory};
+use ntex_service::{Ctx, Service, ServiceFactory};
 
 use crate::future::Ready;
 use crate::time::{now, sleep, Millis, Sleep};
@@ -113,7 +113,7 @@ where
         }
     }
 
-    fn call(&self, req: R) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: R, _: Ctx<'a, Self>) -> Self::Future<'a> {
         self.expire.set(now());
         Ready::Ok(req)
     }
@@ -121,7 +121,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{Service, ServiceFactory};
+    use ntex_service::ServiceFactory;
 
     use super::*;
     use crate::future::lazy;
@@ -134,7 +134,7 @@ mod tests {
         let factory = KeepAlive::new(Millis(100), || TestErr);
         let _ = factory.clone();
 
-        let service = factory.create(&()).await.unwrap();
+        let service = factory.container(&()).await.unwrap();
 
         assert_eq!(service.call(1usize).await, Ok(1usize));
         assert!(lazy(|cx| service.poll_ready(cx)).await.is_ready());

ntex-util/src/services/mod.rs

@@ -4,7 +4,6 @@ mod extensions;
 pub mod inflight;
 pub mod keepalive;
 pub mod onerequest;
-pub mod shared;
 pub mod timeout;
 pub mod variant;
 

ntex-util/src/services/onerequest.rs

@@ -1,7 +1,7 @@
 //! Service that limits number of in-flight async requests to 1.
 use std::{cell::Cell, future::Future, pin::Pin, task::Context, task::Poll};
 
-use ntex_service::{IntoService, Middleware, Service};
+use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
 
 use crate::task::LocalWaker;
 
@@ -63,11 +63,11 @@ where
     }
 
     #[inline]
-    fn call(&self, req: R) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         self.ready.set(false);
 
         OneRequestServiceResponse {
-            fut: self.service.call(req),
+            fut: ctx.call(&self.service, req),
             service: self,
         }
     }
@@ -81,7 +81,7 @@ pin_project_lite::pin_project! {
     where T: 'f, R: 'f
     {
         #[pin]
-        fut: T::Future<'f>,
+        fut: ServiceCall<'f, T, R>,
         service: &'f OneRequestService<T>,
     }
 }
@@ -101,23 +101,22 @@ impl<'f, T: Service<R>, R> Future for OneRequestServiceResponse<'f, T, R> {
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
-    use std::{task::Poll, time::Duration};
+    use std::{cell::RefCell, task::Poll, time::Duration};
 
     use super::*;
-    use crate::future::{lazy, BoxFuture};
+    use crate::{channel::oneshot, future::lazy, future::BoxFuture};
 
-    struct SleepService(Duration);
+    struct SleepService(oneshot::Receiver<()>);
 
     impl Service<()> for SleepService {
         type Response = ();
         type Error = ();
         type Future<'f> = BoxFuture<'f, Result<(), ()>>;
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
-            let fut = crate::time::sleep(self.0);
             Box::pin(async move {
-                fut.await;
+                let _ = self.0.recv().await;
                 Ok::<_, ()>(())
             })
         }
@@ -125,15 +124,20 @@ mod tests {
 
     #[ntex_macros::rt_test2]
     async fn test_oneshot() {
-        let wait_time = Duration::from_millis(50);
+        let (tx, rx) = oneshot::channel();
 
-        let srv = OneRequestService::new(SleepService(wait_time));
+        let srv = Container::new(OneRequestService::new(SleepService(rx)));
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let res = srv.call(());
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
-        let _ = res.await;
+        let _ = tx.send(());
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
         assert!(lazy(|cx| srv.poll_shutdown(cx)).await.is_ready());
     }
@@ -142,19 +146,28 @@ mod tests {
     async fn test_middleware() {
         assert_eq!(format!("{:?}", OneRequest), "OneRequest");
 
-        let wait_time = Duration::from_millis(50);
+        let (tx, rx) = oneshot::channel();
+        let rx = RefCell::new(Some(rx));
         let srv = apply(
             OneRequest,
-            fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }),
+            fn_factory(move || {
+                let rx = rx.borrow_mut().take().unwrap();
+                async move { Ok::<_, ()>(SleepService(rx)) }
+            }),
         );
 
-        let srv = srv.create(&()).await.unwrap();
+        let srv = srv.container(&()).await.unwrap();
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 
-        let res = srv.call(());
+        let srv2 = srv.clone();
+        ntex::rt::spawn(async move {
+            let _ = srv2.call(()).await;
+        });
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
 
-        let _ = res.await;
+        let _ = tx.send(());
+        crate::time::sleep(Duration::from_millis(25)).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
     }
 }

ntex-util/src/services/shared.rs

@@ -1,169 +0,0 @@
-/// A service that can be checked for readiness by multiple tasks
-use std::{
-    cell::Cell, cell::RefCell, marker::PhantomData, rc::Rc, task::Context, task::Poll,
-};
-
-use ntex_service::{Middleware, Service};
-
-use crate::channel::{condition, oneshot};
-use crate::future::{poll_fn, select, Either};
-
-/// A middleware that construct sharable service
-pub struct Shared<R>(PhantomData<R>);
-
-impl<R> Shared<R> {
-    pub fn new() -> Self {
-        Self(PhantomData)
-    }
-}
-
-impl<R> Default for Shared<R> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<S: Service<R>, R> Middleware<S> for Shared<R> {
-    type Service = SharedService<S, R>;
-
-    fn create(&self, service: S) -> Self::Service {
-        SharedService::new(service)
-    }
-}
-
-/// A service that can be checked for readiness by multiple tasks
-pub struct SharedService<S: Service<R>, R> {
-    inner: Rc<Inner<S, R>>,
-    readiness: condition::Waiter,
-}
-
-struct Inner<S: Service<R>, R> {
-    service: S,
-    ready: condition::Condition,
-    driver_stop: Cell<Option<oneshot::Sender<()>>>,
-    driver_running: Cell<bool>,
-    error: RefCell<Option<S::Error>>,
-}
-
-impl<S: Service<R>, R> SharedService<S, R> {
-    pub fn new(service: S) -> Self {
-        let condition = condition::Condition::default();
-        Self {
-            readiness: condition.wait(),
-            inner: Rc::new(Inner {
-                service,
-                ready: condition,
-                driver_stop: Cell::default(),
-                driver_running: Cell::default(),
-                error: RefCell::default(),
-            }),
-        }
-    }
-}
-
-impl<S: Service<R>, R> Clone for SharedService<S, R> {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-            readiness: self.readiness.clone(),
-        }
-    }
-}
-
-impl<S: Service<R>, R> Drop for SharedService<S, R> {
-    fn drop(&mut self) {
-        if self.inner.driver_running.get() {
-            // the only live references to inner are in this SharedService instance and the driver task
-            if Rc::strong_count(&self.inner) == 2 {
-                if let Some(stop) = self.inner.driver_stop.take() {
-                    let _ = stop.send(());
-                }
-            }
-        }
-    }
-}
-
-impl<S, R> Service<R> for SharedService<S, R>
-where
-    S: Service<R> + 'static,
-    S::Error: Clone,
-    R: 'static,
-{
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future<'f> = S::Future<'f> where Self: 'f, R: 'f;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        // if there is an error, it should be returned to all tasks checking readiness
-        if let Some(error) = self.inner.error.borrow().as_ref() {
-            return Poll::Ready(Err(error.clone()));
-        }
-
-        // if the service is being driven to readiness we must register our waker and wait
-        if self.inner.driver_running.get() {
-            log::trace!("polled SharedService driver, driver is already running");
-            // register waker to be notified, regardless of any previous notification
-            let _ = self.readiness.poll_ready(cx);
-            return Poll::Pending;
-        }
-
-        // driver is not running, check the inner service is ready
-        let result = self.inner.service.poll_ready(cx);
-        log::trace!(
-            "polled SharedService, ready: {}, errored: {}",
-            result.is_ready(),
-            matches!(result, Poll::Ready(Err(_)))
-        );
-
-        match result {
-            // pass through service is ready, allow call
-            Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
-            // capture error, all future readiness checks will fail
-            Poll::Ready(Err(e)) => {
-                *self.inner.error.borrow_mut() = Some(e.clone());
-                Poll::Ready(Err(e))
-            }
-            // start driver and elide all poll_ready calls until it is complete
-            Poll::Pending => {
-                let inner = self.inner.clone();
-                let (tx, rx) = oneshot::channel();
-                inner.driver_running.set(true);
-                inner.driver_stop.set(Some(tx));
-
-                ntex_rt::spawn(async move {
-                    log::trace!("SharedService driver has started");
-                    let service_ready = poll_fn(|cx| inner.service.poll_ready(cx));
-                    let clients_gone = rx;
-                    let result = select(service_ready, clients_gone).await;
-                    if let Either::Left(result) = result {
-                        log::trace!(
-                            "SharedService driver completed, errored: {}",
-                            result.is_err()
-                        );
-                        if let Err(e) = result {
-                            inner.error.borrow_mut().replace(e);
-                        }
-                        inner.driver_running.set(false);
-                        inner.driver_stop.set(None);
-                        inner.ready.notify();
-                    } else {
-                        log::trace!("SharedService driver task stopped because all clients are gone");
-                    }
-                });
-
-                // register waker to be notified, regardless of any previous notification
-                let _ = self.readiness.poll_ready(cx);
-
-                Poll::Pending
-            }
-        }
-    }
-
-    fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
-        self.inner.service.poll_shutdown(cx)
-    }
-
-    fn call(&self, req: R) -> Self::Future<'_> {
-        self.inner.service.call(req)
-    }
-}

ntex-util/src/services/timeout.rs

@@ -2,11 +2,9 @@
 //!
 //! If the response does not complete within the specified timeout, the response
 //! will be aborted.
-use std::{
+use std::{fmt, future::Future, marker, pin::Pin, task::Context, task::Poll};
-    fmt, future::Future, marker, marker::PhantomData, pin::Pin, task::Context, task::Poll,
-};
 
-use ntex_service::{IntoService, Middleware, Service};
+use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
 
 use crate::future::Either;
 use crate::time::{sleep, Millis, Sleep};
@@ -127,17 +125,17 @@ where
     type Error = TimeoutError<S::Error>;
     type Future<'f> = Either<TimeoutServiceResponse<'f, S, R>, TimeoutServiceResponse2<'f, S, R>> where Self: 'f, R: 'f;
 
-    fn call(&self, request: R) -> Self::Future<'_> {
+    fn call<'a>(&'a self, request: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         if self.timeout.is_zero() {
             Either::Right(TimeoutServiceResponse2 {
-                fut: self.service.call(request),
+                fut: ctx.call(&self.service, request),
-                _t: PhantomData,
+                _t: marker::PhantomData,
             })
         } else {
             Either::Left(TimeoutServiceResponse {
-                fut: self.service.call(request),
+                fut: ctx.call(&self.service, request),
                 sleep: sleep(self.timeout),
-                _t: PhantomData,
+                _t: marker::PhantomData,
             })
         }
     }
@@ -149,14 +147,14 @@ where
 pin_project_lite::pin_project! {
     /// `TimeoutService` response future
     #[doc(hidden)]
-    #[derive(Debug)]
+    #[must_use = "futures do nothing unless polled"]
     pub struct TimeoutServiceResponse<'f, T: Service<R>, R>
     where T: 'f, R: 'f,
     {
         #[pin]
-        fut: T::Future<'f>,
+        fut: ServiceCall<'f, T, R>,
         sleep: Sleep,
-        _t: PhantomData<R>
+        _t: marker::PhantomData<R>
     }
 }
 
@@ -187,13 +185,13 @@ where
 pin_project_lite::pin_project! {
     /// `TimeoutService` response future
     #[doc(hidden)]
-    #[derive(Debug)]
+    #[must_use = "futures do nothing unless polled"]
     pub struct TimeoutServiceResponse2<'f, T: Service<R>, R>
     where T: 'f, R: 'f,
     {
         #[pin]
-        fut: T::Future<'f>,
+        fut: ServiceCall<'f, T, R>,
-        _t: PhantomData<R>,
+        _t: marker::PhantomData<R>,
     }
 }
 
@@ -216,7 +214,7 @@ where
 mod tests {
     use std::{fmt, time::Duration};
 
-    use ntex_service::{apply, fn_factory, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Service, ServiceFactory};
 
     use super::*;
     use crate::future::{lazy, BoxFuture};
@@ -238,7 +236,7 @@ mod tests {
         type Error = SrvError;
         type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
             let fut = crate::time::sleep(self.0);
             Box::pin(async move {
                 fut.await;
@@ -252,7 +250,9 @@ mod tests {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(50);
 
-        let timeout = TimeoutService::new(resolution, SleepService(wait_time)).clone();
+        let timeout = Container::new(
+            TimeoutService::new(resolution, SleepService(wait_time)).clone(),
+        );
         assert_eq!(timeout.call(()).await, Ok(()));
         assert!(lazy(|cx| timeout.poll_ready(cx)).await.is_ready());
         assert!(lazy(|cx| timeout.poll_shutdown(cx)).await.is_ready());
@@ -263,7 +263,8 @@ mod tests {
         let wait_time = Duration::from_millis(50);
         let resolution = Duration::from_millis(0);
 
-        let timeout = TimeoutService::new(resolution, SleepService(wait_time));
+        let timeout =
+            Container::new(TimeoutService::new(resolution, SleepService(wait_time)));
         assert_eq!(timeout.call(()).await, Ok(()));
         assert!(lazy(|cx| timeout.poll_ready(cx)).await.is_ready());
     }
@@ -273,7 +274,8 @@ mod tests {
         let resolution = Duration::from_millis(100);
         let wait_time = Duration::from_millis(500);
 
-        let timeout = TimeoutService::new(resolution, SleepService(wait_time));
+        let timeout =
+            Container::new(TimeoutService::new(resolution, SleepService(wait_time)));
         assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout));
     }
 
@@ -287,7 +289,7 @@ mod tests {
             Timeout::new(resolution).clone(),
             fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }),
         );
-        let srv = timeout.create(&()).await.unwrap();
+        let srv = timeout.container(&()).await.unwrap();
 
         let res = srv.call(()).await.unwrap_err();
         assert_eq!(res, TimeoutError::Timeout);

ntex-util/src/services/variant.rs

@@ -1,7 +1,7 @@
 //! Contains `Variant` service and related types and functions.
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use ntex_service::{IntoServiceFactory, Service, ServiceFactory};
+use ntex_service::{Ctx, IntoServiceFactory, Service, ServiceCall, ServiceFactory};
 
 /// Construct `Variant` service factory.
 ///
@@ -103,7 +103,8 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
     {
         type Response = V1::Response;
         type Error = V1::Error;
-        type Future<'f> = $mod_name::ServiceResponse<V1::Future<'f>, $($T::Future<'f>),+> where Self: 'f, V1: 'f;
+        type Future<'f> = $mod_name::ServiceResponse<
+            ServiceCall<'f, V1, V1R>, $(ServiceCall<'f, $T, $R>),+> where Self: 'f, V1: 'f;
 
         fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             let mut ready = self.V1.poll_ready(cx)?.is_ready();
@@ -127,10 +128,11 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
             }
         }
 
-        fn call(&self, req: $enum_type<V1R, $($R,)+>) -> Self::Future<'_> {
+        fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+        {
             match req {
-                $enum_type::V1(req) => $mod_name::ServiceResponse::V1 { fut: self.V1.call(req) },
+                $enum_type::V1(req) => $mod_name::ServiceResponse::V1 { fut: ctx.call(&self.V1, req) },
-                $($enum_type::$T(req) => $mod_name::ServiceResponse::$T { fut: self.$T.call(req) },)+
+                $($enum_type::$T(req) => $mod_name::ServiceResponse::$T { fut: ctx.call(&self.$T, req) },)+
             }
         }
     }
@@ -319,7 +321,7 @@ mod tests {
             Poll::Ready(())
         }
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
             Ready::<_, ()>::Ok(1)
         }
     }
@@ -340,7 +342,7 @@ mod tests {
             Poll::Ready(())
         }
 
-        fn call(&self, _: ()) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
             Ready::<_, ()>::Ok(2)
         }
     }
@@ -352,7 +354,7 @@ mod tests {
             .clone()
             .v3(fn_factory(|| async { Ok::<_, ()>(Srv2) }))
             .clone();
-        let service = factory.create(&()).await.unwrap().clone();
+        let service = factory.container(&()).await.unwrap().clone();
 
         assert!(lazy(|cx| service.poll_ready(cx)).await.is_ready());
         assert!(lazy(|cx| service.poll_shutdown(cx)).await.is_ready());

ntex-util/src/time/wheel.rs

@@ -711,7 +711,7 @@ impl Future for LowresTimerDriver {
             flags.remove(Flags::LOWRES_TIMER);
             self.0.flags.set(flags);
         }
-        return Poll::Pending;
+        Poll::Pending
     }
 }
 

ntex/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex"
-version = "0.6.7"
+version = "0.7.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Framework for composable network services"
 readme = "README.md"
@@ -49,20 +49,20 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
 
 [dependencies]
 ntex-codec = "0.6.2"
-ntex-connect = "0.2.1"
+ntex-connect = "0.3.0"
 ntex-http = "0.1.9"
 ntex-router = "0.5.1"
-ntex-service = "1.0.2"
+ntex-service = "1.2.0"
 ntex-macros = "0.1.3"
-ntex-util = "0.2.3"
+ntex-util = "0.3.0"
 ntex-bytes = "0.1.19"
-ntex-h2 = "0.2.3"
+ntex-h2 = "0.3.0"
 ntex-rt = "0.4.9"
-ntex-io = "0.2.10"
+ntex-io = "0.3.0"
-ntex-tls = "0.2.4"
+ntex-tls = "0.3.0"
-ntex-tokio = { version = "0.2.3", optional = true }
+ntex-tokio = { version = "0.3.0", optional = true }
-ntex-glommio = { version = "0.2.4", optional = true }
+ntex-glommio = { version = "0.3.0", optional = true }
-ntex-async-std = { version = "0.2.1", optional = true }
+ntex-async-std = { version = "0.3.0", optional = true }
 
 async-oneshot = "0.5.0"
 async-channel = "1.8.0"
@@ -94,8 +94,8 @@ coo-kie = { version = "0.17", package = "cookie", optional = true }
 tls-openssl = { version="0.10", package = "openssl", optional = true }
 
 # rustls
-tls-rustls = { version = "0.20", package = "rustls", optional = true }
+tls-rustls = { version = "0.21", package = "rustls", optional = true }
-webpki-roots = { version = "0.22", optional = true }
+webpki-roots = { version = "0.23", optional = true }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
@@ -107,6 +107,6 @@ rand = "0.8"
 time = "0.3"
 futures-util = "0.3"
 tls-openssl = { version="0.10", package = "openssl" }
-tls-rustls = { version = "0.20", package="rustls", features = ["dangerous_configuration"]  }
+tls-rustls = { version = "0.21", package="rustls", features = ["dangerous_configuration"]  }
 rustls-pemfile = { version = "1.0" }
-webpki-roots = { version = "0.22" }
+webpki-roots = { version = "0.23" }

ntex/src/http/body.rs

@@ -55,6 +55,7 @@ impl<T: MessageBody> MessageBody for Box<T> {
     }
 }
 
+#[derive(Debug)]
 pub enum ResponseBody<B> {
     Body(B),
     Other(Body),

ntex/src/http/client/builder.rs

@@ -36,7 +36,7 @@ impl ClientBuilder {
             config: ClientConfig {
                 headers: HeaderMap::new(),
                 timeout: Millis(5_000),
-                connector: Box::new(ConnectorWrapper(Connector::default().finish())),
+                connector: Box::new(ConnectorWrapper(Connector::default().finish().into())),
             },
         }
     }
@@ -46,7 +46,7 @@ impl ClientBuilder {
     where
         T: Service<Connect, Response = Connection, Error = ConnectError> + 'static,
     {
-        self.config.connector = Box::new(ConnectorWrapper(connector));
+        self.config.connector = Box::new(ConnectorWrapper(connector.into()));
         self
     }
 

ntex/src/http/client/connect.rs

@@ -1,13 +1,13 @@
 use std::net;
 
 use crate::http::{body::Body, RequestHeadType};
-use crate::{service::Service, util::BoxFuture};
+use crate::{service::Container, service::Service, util::BoxFuture};
 
 use super::error::{ConnectError, SendRequestError};
 use super::response::ClientResponse;
 use super::{Connect as ClientConnect, Connection};
 
-pub(super) struct ConnectorWrapper<T>(pub(crate) T);
+pub(super) struct ConnectorWrapper<T>(pub(crate) Container<T>);
 
 pub(super) trait Connect {
     fn send_request(

ntex/src/http/client/connector.rs

@@ -3,11 +3,9 @@ use std::{task::Context, task::Poll, time::Duration};
 use ntex_h2::{self as h2};
 
 use crate::connect::{Connect as TcpConnect, Connector as TcpConnector};
-use crate::service::{apply_fn, boxed, Service};
+use crate::service::{apply_fn, boxed, Ctx, Service, ServiceCall};
 use crate::time::{Millis, Seconds};
-use crate::util::{
+use crate::util::{timeout::TimeoutError, timeout::TimeoutService, Either, Ready};
-    shared::SharedService, timeout::TimeoutError, timeout::TimeoutService, Either, Ready,
-};
 use crate::{http::Uri, io::IoBoxed};
 
 use super::{connection::Connection, error::ConnectError, pool::ConnectionPool, Connect};
@@ -216,7 +214,7 @@ impl Connector {
     /// its combinator chain.
     pub fn finish(
         self,
-    ) -> impl Service<Connect, Response = Connection, Error = ConnectError> + Clone {
+    ) -> impl Service<Connect, Response = Connection, Error = ConnectError> {
         let tcp_service = connector(self.connector, self.timeout, self.disconnect_timeout);
 
         let ssl_pool = if let Some(ssl_connector) = self.ssl_connector {
@@ -233,7 +231,7 @@ impl Connector {
             None
         };
 
-        SharedService::new(InnerConnector {
+        InnerConnector {
             tcp_pool: ConnectionPool::new(
                 tcp_service,
                 self.conn_lifetime,
@@ -243,7 +241,7 @@ impl Connector {
                 self.h2config.clone(),
             ),
             ssl_pool,
-        })
+        }
     }
 }
 
@@ -283,7 +281,7 @@ where
     type Response = <ConnectionPool<T> as Service<Connect>>::Response;
     type Error = ConnectError;
     type Future<'f> = Either<
-        <ConnectionPool<T> as Service<Connect>>::Future<'f>,
+        ServiceCall<'f, ConnectionPool<T>, Connect>,
         Ready<Self::Response, Self::Error>,
     >;
 
@@ -317,16 +315,16 @@ where
         }
     }
 
-    fn call(&self, req: Connect) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect, ctx: Ctx<'a, Self>) -> Self::Future<'_> {
         match req.uri.scheme_str() {
             Some("https") | Some("wss") => {
                 if let Some(ref conn) = self.ssl_pool {
-                    Either::Left(conn.call(req))
+                    Either::Left(ctx.call(conn, req))
                 } else {
                     Either::Right(Ready::Err(ConnectError::SslIsNotSupported))
                 }
             }
-            _ => Either::Left(self.tcp_pool.call(req)),
+            _ => Either::Left(ctx.call(&self.tcp_pool, req)),
         }
     }
 }

ntex/src/http/client/h2proto.rs

@@ -7,7 +7,7 @@ use crate::http::header::{self, HeaderMap, HeaderValue};
 use crate::http::message::{RequestHeadType, ResponseHead};
 use crate::http::{h2::payload, payload::Payload, Method, Version};
 use crate::util::{poll_fn, ByteString, Bytes, HashMap, Ready};
-use crate::{channel::oneshot, service::Service};
+use crate::{channel::oneshot, service::Ctx, service::Service};
 
 use super::error::SendRequestError;
 
@@ -226,7 +226,7 @@ impl Service<h2::Message> for H2PublishService {
     type Error = &'static str;
     type Future<'f> = Ready<Self::Response, Self::Error>;
 
-    fn call(&self, mut msg: h2::Message) -> Self::Future<'_> {
+    fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
         match msg.kind().take() {
             h2::MessageKind::Headers {
                 pseudo,

ntex/src/http/client/mod.rs

@@ -82,7 +82,7 @@ pub(self) struct ClientConfig {
 impl Default for Client {
     fn default() -> Self {
         Client(Rc::new(ClientConfig {
-            connector: Box::new(ConnectorWrapper(Connector::default().finish())),
+            connector: Box::new(ConnectorWrapper(Connector::default().finish().into())),
             headers: HeaderMap::new(),
             timeout: Millis(5_000),
         }))

ntex/src/http/client/pool.rs

@@ -6,9 +6,10 @@ use ntex_h2::{self as h2};
 
 use crate::http::uri::{Authority, Scheme, Uri};
 use crate::io::{types::HttpProtocol, IoBoxed};
+use crate::service::{Container, Ctx, Service, ServiceCall};
 use crate::time::{now, Millis};
 use crate::util::{ready, BoxFuture, ByteString, HashMap, HashSet};
-use crate::{channel::pool, rt::spawn, service::Service, task::LocalWaker};
+use crate::{channel::pool, rt::spawn, task::LocalWaker};
 
 use super::connection::{Connection, ConnectionType};
 use super::h2proto::{H2Client, H2PublishService};
@@ -43,7 +44,7 @@ struct AvailableConnection {
 
 /// Connections pool
 pub(super) struct ConnectionPool<T> {
-    connector: Rc<T>,
+    connector: Container<T>,
     inner: Rc<RefCell<Inner>>,
     waiters: Rc<RefCell<Waiters>>,
 }
@@ -60,7 +61,7 @@ where
         limit: usize,
         h2config: h2::Config,
     ) -> Self {
-        let connector = Rc::new(connector);
+        let connector = Container::new(connector);
         let waiters = Rc::new(RefCell::new(Waiters {
             waiters: HashMap::default(),
             pool: pool::new(),
@@ -120,10 +121,8 @@ where
     crate::forward_poll_ready!(connector);
     crate::forward_poll_shutdown!(connector);
 
-    #[inline]
+    fn call<'a>(&'a self, req: Connect, _: Ctx<'a, Self>) -> Self::Future<'_> {
-    fn call(&self, req: Connect) -> Self::Future<'_> {
         trace!("Get connection for {:?}", req.uri);
-        let connector = self.connector.clone();
         let inner = self.inner.clone();
         let waiters = self.waiters.clone();
 
@@ -151,7 +150,7 @@ where
                     trace!("Connecting to {:?}", req.uri);
                     let uri = req.uri.clone();
                     let (tx, rx) = waiters.borrow_mut().pool.channel();
-                    OpenConnection::spawn(key, tx, uri, inner, connector, req);
+                    OpenConnection::spawn(key, tx, uri, inner, self.connector.clone(), req);
 
                     match rx.await {
                         Err(_) => Err(ConnectError::Disconnected(None)),
@@ -308,7 +307,7 @@ impl Inner {
 }
 
 struct ConnectionPoolSupport<T> {
-    connector: Rc<T>,
+    connector: Container<T>,
     inner: Rc<RefCell<Inner>>,
     waiters: Rc<RefCell<Waiters>>,
 }
@@ -391,7 +390,7 @@ pin_project_lite::pin_project! {
     {
         key: Key,
         #[pin]
-        fut: T::Future<'f>,
+        fut: ServiceCall<'f, T, Connect>,
         uri: Uri,
         tx: Option<Waiter>,
         guard: Option<OpenGuard>,
@@ -409,11 +408,12 @@ where
         tx: Waiter,
         uri: Uri,
         inner: Rc<RefCell<Inner>>,
-        connector: Rc<T>,
+        connector: Container<T>,
         msg: Connect,
     ) {
         let disconnect_timeout = inner.borrow().disconnect_timeout;
 
+        #[allow(clippy::redundant_async_block)]
         spawn(async move {
             OpenConnection::<T> {
                 fut: connector.call(msg),
@@ -629,19 +629,21 @@ mod tests {
         let store = Rc::new(RefCell::new(Vec::new()));
         let store2 = store.clone();
 
-        let pool = ConnectionPool::new(
+        let pool = Container::new(
-            fn_service(move |req| {
+            ConnectionPool::new(
-                let (client, server) = Io::create();
+                fn_service(move |req| {
-                store2.borrow_mut().push((req, server));
+                    let (client, server) = Io::create();
-                Box::pin(async move { Ok(IoBoxed::from(nio::Io::new(client))) })
+                    store2.borrow_mut().push((req, server));
-            }),
+                    Box::pin(async move { Ok(IoBoxed::from(nio::Io::new(client))) })
-            Duration::from_secs(10),
+                }),
-            Duration::from_secs(10),
+                Duration::from_secs(10),
-            Millis::ZERO,
+                Duration::from_secs(10),
-            1,
+                Millis::ZERO,
-            h2::Config::client(),
+                1,
-        )
+                h2::Config::client(),
-        .clone();
+            )
+            .clone(),
+        );
 
         // uri must contain authority
         let req = Connect {

ntex/src/http/config.rs

@@ -3,8 +3,9 @@ use std::{cell::Cell, ptr::copy_nonoverlapping, rc::Rc, time, time::Duration};
 use ntex_h2::{self as h2};
 
 use crate::http::{Request, Response};
+use crate::service::{boxed::BoxService, Container};
 use crate::time::{sleep, Millis, Seconds};
-use crate::{io::IoRef, service::boxed::BoxService, util::BytesMut};
+use crate::{io::IoRef, util::BytesMut};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 /// Server keep-alive setting
@@ -101,16 +102,16 @@ impl ServiceConfig {
 pub(super) type OnRequest = BoxService<(Request, IoRef), Request, Response>;
 
 pub(super) struct DispatcherConfig<S, X, U> {
-    pub(super) service: S,
+    pub(super) service: Container<S>,
-    pub(super) expect: X,
+    pub(super) expect: Container<X>,
-    pub(super) upgrade: Option<U>,
+    pub(super) upgrade: Option<Container<U>>,
     pub(super) keep_alive: Duration,
     pub(super) client_timeout: Duration,
     pub(super) client_disconnect: Seconds,
     pub(super) h2config: h2::Config,
     pub(super) ka_enabled: bool,
     pub(super) timer: DateService,
-    pub(super) on_request: Option<OnRequest>,
+    pub(super) on_request: Option<Container<OnRequest>>,
 }
 
 impl<S, X, U> DispatcherConfig<S, X, U> {
@@ -122,10 +123,10 @@ impl<S, X, U> DispatcherConfig<S, X, U> {
         on_request: Option<OnRequest>,
     ) -> Self {
         DispatcherConfig {
-            service,
+            service: service.into(),
-            expect,
+            expect: expect.into(),
-            upgrade,
+            upgrade: upgrade.map(|v| v.into()),
-            on_request,
+            on_request: on_request.map(|v| v.into()),
             keep_alive: Duration::from(cfg.0.keep_alive),
             client_timeout: Duration::from(cfg.0.client_timeout),
             client_disconnect: cfg.0.client_disconnect,

ntex/src/http/h1/dispatcher.rs

@@ -2,8 +2,9 @@
 use std::task::{Context, Poll};
 use std::{cell::RefCell, error::Error, future::Future, io, marker, mem, pin::Pin, rc::Rc};
 
-use crate::io::{Filter, Io, IoBoxed, IoStatusUpdate, RecvError};
+use crate::io::{Filter, Io, IoBoxed, IoRef, IoStatusUpdate, RecvError};
-use crate::{service::Service, util::ready, util::BoxFuture, util::Bytes};
+use crate::service::{Container, Service, ServiceCall};
+use crate::util::{ready, Bytes};
 
 use crate::http;
 use crate::http::body::{BodySize, MessageBody, ResponseBody};
@@ -46,7 +47,7 @@ pin_project_lite::pin_project! {
     }
 }
 
-#[derive(thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 enum State<B> {
     #[error("State::Call")]
     Call,
@@ -77,10 +78,10 @@ pin_project_lite::pin_project! {
     where S: 'static, X: 'static
     {
         None,
-        Service { #[pin] fut: S::Future<'static> },
+        Service { #[pin] fut: ServiceCall<'static, S, Request> },
-        ServiceUpgrade { #[pin] fut: S::Future<'static> },
+        ServiceUpgrade { #[pin] fut: ServiceCall<'static, S, Request>  },
-        Expect { #[pin] fut: X::Future<'static> },
+        Expect { #[pin] fut: ServiceCall<'static, X, Request> },
-        Filter { fut: BoxFuture<'static, Result<Request, Response>> }
+        Filter { fut: ServiceCall<'static, OnRequest, (Request, IoRef)> }
     }
 }
 
@@ -485,7 +486,7 @@ where
         st
     }
 
-    fn service_filter(&self, req: Request, f: &OnRequest) -> CallState<S, X> {
+    fn service_filter(&self, req: Request, f: &Container<OnRequest>) -> CallState<S, X> {
         // Handle filter fut
         let fut = f.call((req, self.io.get_ref()));
         let st = CallState::Filter {

ntex/src/http/h1/expect.rs

@@ -1,7 +1,7 @@
 use std::io;
 
-use crate::http::request::Request;
+use crate::service::{Ctx, Service, ServiceFactory};
-use crate::{service::Service, service::ServiceFactory, util::Ready};
+use crate::{http::request::Request, util::Ready};
 
 pub struct ExpectHandler;
 
@@ -24,7 +24,7 @@ impl Service<Request> for ExpectHandler {
     type Future<'f> = Ready<Self::Response, Self::Error>;
 
     #[inline]
-    fn call(&self, req: Request) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Request, _: Ctx<'a, Self>) -> Self::Future<'_> {
         Ready::Ok(req)
     }
 }

ntex/src/http/h1/service.rs

@@ -5,7 +5,7 @@ use crate::http::config::{DispatcherConfig, OnRequest, ServiceConfig};
 use crate::http::error::{DispatchError, ResponseError};
 use crate::http::{request::Request, response::Response};
 use crate::io::{types, Filter, Io};
-use crate::service::{IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{Ctx, IntoServiceFactory, Service, ServiceFactory};
 use crate::{time::Millis, util::BoxFuture};
 
 use super::codec::Codec;
@@ -331,7 +331,7 @@ where
         }
     }
 
-    fn call(&self, io: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
         log::trace!(
             "New http1 connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()

ntex/src/http/h1/upgrade.rs

@@ -1,7 +1,7 @@
 use std::{io, marker::PhantomData};
 
 use crate::http::{h1::Codec, request::Request};
-use crate::{io::Io, service::Service, service::ServiceFactory, util::Ready};
+use crate::{io::Io, service::Ctx, service::Service, service::ServiceFactory, util::Ready};
 
 pub struct UpgradeHandler<F>(PhantomData<F>);
 
@@ -25,7 +25,11 @@ impl<F> Service<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
     type Future<'f> = Ready<Self::Response, Self::Error> where F: 'f;
 
     #[inline]
-    fn call(&self, _: (Request, Io<F>, Codec)) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        _: (Request, Io<F>, Codec),
+        _: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         unimplemented!()
     }
 }

ntex/src/http/h2/service.rs

@@ -10,7 +10,7 @@ use crate::http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use crate::http::message::{CurrentIo, ResponseHead};
 use crate::http::{DateService, Method, Request, Response, StatusCode, Uri, Version};
 use crate::io::{types, Filter, Io, IoBoxed, IoRef};
-use crate::service::{IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{Ctx, IntoServiceFactory, Service, ServiceFactory};
 use crate::util::{poll_fn, BoxFuture, Bytes, BytesMut, Either, HashMap, Ready};
 
 use super::payload::{Payload, PayloadSender};
@@ -181,7 +181,7 @@ where
         self.config.service.poll_shutdown(cx)
     }
 
-    fn call(&self, io: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
         log::trace!(
             "New http2 connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()
@@ -230,7 +230,11 @@ impl Service<h2::ControlMessage<H2Error>> for ControlService {
     type Error = ();
     type Future<'f> = Ready<Self::Response, Self::Error>;
 
-    fn call(&self, msg: h2::ControlMessage<H2Error>) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        msg: h2::ControlMessage<H2Error>,
+        _: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         log::trace!("Control message: {:?}", msg);
         Ready::Ok::<_, ()>(msg.ack())
     }
@@ -276,7 +280,7 @@ where
         Ready<Self::Response, Self::Error>,
     >;
 
-    fn call(&self, mut msg: h2::Message) -> Self::Future<'_> {
+    fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
         let (io, pseudo, headers, eof, payload) = match msg.kind().take() {
             h2::MessageKind::Headers {
                 pseudo,

ntex/src/http/payload.rs

@@ -7,19 +7,15 @@ use crate::util::{poll_fn, Bytes, Stream};
 pub type PayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;
 
 /// Type represent streaming payload
+#[derive(Default)]
 pub enum Payload {
+    #[default]
     None,
     H1(h1::Payload),
     H2(h2::Payload),
     Stream(PayloadStream),
 }
 
-impl Default for Payload {
-    fn default() -> Self {
-        Payload::None
-    }
-}
-
 impl From<h1::Payload> for Payload {
     fn from(v: h1::Payload) -> Self {
         Payload::H1(v)

ntex/src/http/service.rs

@@ -2,7 +2,7 @@ use std::task::{Context, Poll};
 use std::{cell, error, fmt, future, marker, pin::Pin, rc::Rc};
 
 use crate::io::{types, Filter, Io};
-use crate::service::{IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{Ctx, IntoServiceFactory, Service, ServiceFactory};
 use crate::time::{Millis, Seconds};
 use crate::util::BoxFuture;
 
@@ -368,7 +368,7 @@ where
         }
     }
 
-    fn call(&self, io: Io<F>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         log::trace!(
             "New http connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()

ntex/src/lib.rs

@@ -38,12 +38,11 @@ pub mod web;
 pub mod ws;
 
 pub use self::service::{
-    fn_service, into_service, pipeline, pipeline_factory, IntoService, IntoServiceFactory,
+    fn_service, into_service, pipeline, pipeline_factory, Container, Ctx, IntoService,
-    Middleware, Service, ServiceFactory,
+    IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory,
 };
 
-pub use ntex_util::channel;
+pub use ntex_util::{channel, task};
-pub use ntex_util::task;
 
 pub mod codec {
     //! Utilities for encoding and decoding frames.

ntex/src/server/config.rs

@@ -1,19 +1,15 @@
-use std::{
+use std::{cell::Cell, cell::RefCell, fmt, future::Future, io, marker, mem, net, rc::Rc};
-    cell::Cell, cell::RefCell, fmt, future::Future, io, marker::PhantomData, mem, net,
-    rc::Rc,
-};
 
 use log::error;
 
+use crate::io::Io;
 use crate::service::{self, boxed, ServiceFactory as NServiceFactory};
-use crate::util::{BoxFuture, HashMap, Ready};
+use crate::util::{BoxFuture, HashMap, PoolId, Ready};
-use crate::{io::Io, util::PoolId};
 
 use super::service::{
     BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
 };
-use super::Token;
+use super::{builder::bind_addr, counter::CounterGuard, Token};
-use super::{builder::bind_addr, counter::CounterGuard};
 
 #[derive(Clone)]
 pub struct Config(Rc<InnerServiceConfig>);
@@ -66,7 +62,7 @@ impl ServiceConfig {
                     not_configured();
                     Ready::Ok::<_, &'static str>(())
                 },
-                _t: PhantomData,
+                _t: marker::PhantomData,
             })),
         })))
     }
@@ -95,7 +91,7 @@ impl ServiceConfig {
                         not_configured();
                         Ready::Ok::<_, &'static str>(())
                     },
-                    _t: PhantomData,
+                    _t: marker::PhantomData,
                 }));
             }
             inner.services.push((name.as_ref().to_string(), lst));
@@ -114,7 +110,10 @@ impl ServiceConfig {
         E: fmt::Display + 'static,
     {
         self.0.borrow_mut().applied = true;
-        self.0.borrow_mut().apply = Some(Box::new(ConfigWrapper { f, _t: PhantomData }));
+        self.0.borrow_mut().apply = Some(Box::new(ConfigWrapper {
+            f,
+            _t: marker::PhantomData,
+        }));
         Ok(())
     }
 }
@@ -192,7 +191,7 @@ impl InternalServiceFactory for ConfiguredService {
                     let name = names.remove(&token).unwrap().0;
                     res.push((
                         token,
-                        boxed::rcservice(StreamService::new(
+                        boxed::service(StreamService::new(
                             service::fn_service(move |_: Io| {
                                 error!("Service {:?} is not configured", name);
                                 Ready::<_, ()>::Ok(())
@@ -215,7 +214,7 @@ pub(super) trait ServiceRuntimeConfiguration {
 
 pub(super) struct ConfigWrapper<F, R, E> {
     pub(super) f: F,
-    pub(super) _t: PhantomData<(R, E)>,
+    pub(super) _t: marker::PhantomData<(R, E)>,
 }
 
 // SAFETY: we dont store R or E in ConfigWrapper
@@ -230,7 +229,7 @@ where
     fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration + Send> {
         Box::new(ConfigWrapper {
             f: self.f.clone(),
-            _t: PhantomData,
+            _t: marker::PhantomData,
         })
     }
 
@@ -304,7 +303,7 @@ impl ServiceRuntime {
             let token = *token;
             inner.services.insert(
                 token,
-                boxed::rcfactory(ServiceFactory {
+                boxed::factory(ServiceFactory {
                     pool,
                     inner: service.into_factory(),
                 }),
@@ -323,8 +322,13 @@ impl ServiceRuntime {
     }
 }
 
-type BoxServiceFactory =
+type BoxServiceFactory = service::boxed::BoxServiceFactory<
-    service::boxed::RcServiceFactory<(), (Option<CounterGuard>, ServerMessage), (), (), ()>;
+    (),
+    (Option<CounterGuard>, ServerMessage),
+    (),
+    (),
+    (),
+>;
 
 struct ServiceFactory<T> {
     inner: T,
@@ -349,7 +353,7 @@ where
         let fut = self.inner.create(());
         Box::pin(async move {
             match fut.await {
-                Ok(s) => Ok(boxed::rcservice(StreamService::new(s, pool))),
+                Ok(s) => Ok(boxed::service(StreamService::new(s, pool))),
                 Err(e) => {
                     error!("Cannot construct service: {:?}", e);
                     Err(())

ntex/src/server/service.rs

@@ -2,10 +2,9 @@ use std::{net::SocketAddr, rc::Rc, task::Context, task::Poll};
 
 use log::error;
 
-use crate::io::Io;
+use crate::service::{boxed, Ctx, Service, ServiceFactory};
-use crate::service::{boxed, Service, ServiceFactory};
+use crate::util::{BoxFuture, Pool, PoolId};
-use crate::util::{BoxFuture, Pool, PoolId, Ready};
+use crate::{io::Io, time::Millis};
-use crate::{rt::spawn, time::Millis};
 
 use super::{counter::CounterGuard, socket::Stream, Config, Token};
 
@@ -34,7 +33,7 @@ pub(super) trait InternalServiceFactory: Send {
 }
 
 pub(super) type BoxedServerService =
-    boxed::RcService<(Option<CounterGuard>, ServerMessage), (), ()>;
+    boxed::BoxService<(Option<CounterGuard>, ServerMessage), (), ()>;
 
 #[derive(Clone)]
 pub(super) struct StreamService<T> {
@@ -53,12 +52,11 @@ impl<T> StreamService<T> {
 
 impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
 where
-    T: Service<Io> + 'static,
+    T: Service<Io>,
-    T::Error: 'static,
 {
     type Response = ();
     type Error = ();
-    type Future<'f> = Ready<(), ()> where T: 'f;
+    type Future<'f> = BoxFuture<'f, Result<(), ()>> where T: 'f;
 
     crate::forward_poll_shutdown!(service);
 
@@ -73,31 +71,31 @@ where
         }
     }
 
-    fn call(
+    fn call<'a>(
-        &self,
+        &'a self,
         (guard, req): (Option<CounterGuard>, ServerMessage),
-    ) -> Self::Future<'_> {
+        ctx: Ctx<'a, Self>,
-        match req {
+    ) -> Self::Future<'a> {
-            ServerMessage::Connect(stream) => {
+        Box::pin(async move {
-                let stream = stream.try_into().map_err(|e| {
+            match req {
-                    error!("Cannot convert to an async io stream: {}", e);
+                ServerMessage::Connect(stream) => {
-                });
+                    let stream = stream.try_into().map_err(|e| {
-
+                        error!("Cannot convert to an async io stream: {}", e);
-                if let Ok(stream) = stream {
-                    let stream: Io<_> = stream;
-                    stream.set_memory_pool(self.pool.pool_ref());
-                    let svc = self.service.clone();
-                    spawn(async move {
-                        let _ = svc.call(stream).await;
-                        drop(guard);
                     });
-                    Ready::Ok(())
+
-                } else {
+                    if let Ok(stream) = stream {
-                    Ready::Err(())
+                        let stream: Io<_> = stream;
+                        stream.set_memory_pool(self.pool.pool_ref());
+                        let _ = ctx.call(self.service.as_ref(), stream).await;
+                        drop(guard);
+                        Ok(())
+                    } else {
+                        Err(())
+                    }
                 }
+                _ => Ok(()),
             }
-            _ => Ready::Ok(()),
+        })
-        }
     }
 }
 
@@ -153,8 +151,7 @@ where
         Box::pin(async move {
             match factory.create(()).await {
                 Ok(inner) => {
-                    let service: BoxedServerService =
+                    let service = boxed::service(StreamService::new(inner, pool));
-                        boxed::rcservice(StreamService::new(inner, pool));
                     Ok(vec![(token, service)])
                 }
                 Err(_) => Err(()),

ntex/src/server/worker.rs

@@ -5,7 +5,7 @@ use async_channel::{unbounded, Receiver, Sender};
 use async_oneshot as oneshot;
 
 use crate::rt::{spawn, Arbiter};
-use crate::service::Service;
+use crate::service::Container;
 use crate::time::{sleep, Millis, Sleep};
 use crate::util::{
     join_all, ready, select, stream_recv, BoxFuture, Either, Stream as FutStream,
@@ -138,12 +138,12 @@ pub(super) struct Worker {
 struct WorkerService {
     factory: usize,
     status: WorkerServiceStatus,
-    service: BoxedServerService,
+    service: Container<BoxedServerService>,
 }
 
 impl WorkerService {
     fn created(&mut self, service: BoxedServerService) {
-        self.service = service;
+        self.service = Container::new(service);
         self.status = WorkerServiceStatus::Unavailable;
     }
 }
@@ -239,7 +239,7 @@ impl Worker {
                         assert_eq!(token.0, wrk.services.len());
                         wrk.services.push(WorkerService {
                             factory,
-                            service,
+                            service: service.into(),
                             status: WorkerServiceStatus::Unavailable,
                         });
                     }
@@ -490,9 +490,12 @@ impl Future for Worker {
                                 self.factories[srv.factory].name(msg.token)
                             );
                         }
-                        let _ = srv
+                        let srv = srv.service.clone();
-                            .service
+                        spawn(async move {
-                            .call((Some(guard), ServerMessage::Connect(msg.io)));
+                            let _ = srv
+                                .call((Some(guard), ServerMessage::Connect(msg.io)))
+                                .await;
+                        });
                     } else {
                         return Poll::Ready(());
                     }
@@ -509,7 +512,7 @@ mod tests {
     use super::*;
     use crate::io::Io;
     use crate::server::service::Factory;
-    use crate::service::{Service, ServiceFactory};
+    use crate::service::{Ctx, Service, ServiceFactory};
     use crate::util::{lazy, Ready};
 
     #[derive(Clone, Copy, Debug)]
@@ -569,7 +572,7 @@ mod tests {
             }
         }
 
-        fn call(&self, _: Io) -> Self::Future<'_> {
+        fn call<'a>(&'a self, _: Io, _: Ctx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }

ntex/src/web/app.rs

@@ -4,7 +4,7 @@ use crate::http::Request;
 use crate::router::ResourceDef;
 use crate::service::boxed::{self, BoxServiceFactory};
 use crate::service::{map_config, pipeline_factory, IntoServiceFactory, PipelineFactory};
-use crate::service::{Identity, Middleware, Service, ServiceFactory, Stack};
+use crate::service::{Ctx, Identity, Middleware, Service, ServiceFactory, Stack};
 use crate::util::{BoxFuture, Extensions, Ready};
 
 use super::app_service::{AppFactory, AppService};
@@ -581,7 +581,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
     type Future<'f> = Ready<WebRequest<Err>, Err::Container>;
 
     #[inline]
-    fn call(&self, req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         Ready::Ok(req)
     }
 }
@@ -591,7 +591,7 @@ mod tests {
     use super::*;
     use crate::http::header::{self, HeaderValue};
     use crate::http::{Method, StatusCode};
-    use crate::service::{fn_service, Service};
+    use crate::service::fn_service;
     use crate::util::{Bytes, Ready};
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::{
@@ -604,7 +604,7 @@ mod tests {
         let srv = App::new()
             .service(web::resource("/test").to(|| async { HttpResponse::Ok() }))
             .finish()
-            .create(())
+            .container(())
             .await
             .unwrap();
         let req = TestRequest::with_uri("/test").to_request();
@@ -628,7 +628,7 @@ mod tests {
                 Ok(r.into_response(HttpResponse::MethodNotAllowed()))
             })
             .with_config(Default::default())
-            .create(())
+            .container(())
             .await
             .unwrap();
 

ntex/src/web/app_service.rs

@@ -4,8 +4,10 @@ use std::{cell::RefCell, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
 use crate::http::{Request, Response};
 use crate::router::{Path, ResourceDef, Router};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
-use crate::service::{fn_service, Middleware, PipelineFactory, Service, ServiceFactory};
+use crate::service::{
-use crate::util::{BoxFuture, Extensions};
+    fn_service, Ctx, Middleware, PipelineFactory, Service, ServiceCall, ServiceFactory,
+};
+use crate::util::{BoxFuture, Either, Extensions};
 
 use super::config::AppConfig;
 use super::error::ErrorRenderer;
@@ -21,8 +23,8 @@ type HttpService<Err: ErrorRenderer> =
     BoxService<WebRequest<Err>, WebResponse, Err::Container>;
 type HttpNewService<Err: ErrorRenderer> =
     BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
-type BoxResponse<'f, Err: ErrorRenderer> =
+type BoxResponse<'a, Err: ErrorRenderer> =
-    BoxFuture<'f, Result<WebResponse, Err::Container>>;
+    ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
 type FnStateFactory = Box<dyn Fn(Extensions) -> BoxFuture<'static, Result<Extensions, ()>>>;
 
 /// Service factory to convert `Request` to a `WebRequest<S>`.
@@ -198,12 +200,12 @@ where
 {
     type Response = WebResponse;
     type Error = T::Error;
-    type Future<'f> = T::Future<'f> where T: 'f;
+    type Future<'f> = ServiceCall<'f, T, WebRequest<Err>> where T: 'f;
 
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call(&self, req: Request) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Request, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         let (head, payload) = req.into_parts();
 
         let req = if let Some(mut req) = self.pool.get_request() {
@@ -223,7 +225,7 @@ where
                 self.pool,
             )
         };
-        self.service.call(WebRequest::new(req))
+        ctx.call(&self.service, WebRequest::new(req))
     }
 }
 
@@ -245,9 +247,14 @@ struct AppRouting<Err: ErrorRenderer> {
 impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
     type Response = WebResponse;
     type Error = Err::Container;
-    type Future<'f> = BoxResponse<'f, Err>;
+    type Future<'f> =
+        Either<BoxResponse<'f, Err>, BoxFuture<'f, Result<WebResponse, Err::Container>>>;
 
-    fn call(&self, mut req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        mut req: WebRequest<Err>,
+        ctx: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         let res = self.router.recognize_checked(&mut req, |req, guards| {
             if let Some(guards) = guards {
                 for f in guards {
@@ -260,12 +267,14 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
         });
 
         if let Some((srv, _info)) = res {
-            srv.call(req)
+            Either::Left(ctx.call(srv, req))
         } else if let Some(ref default) = self.default {
-            default.call(req)
+            Either::Left(ctx.call(default, req))
         } else {
             let req = req.into_parts().0;
-            Box::pin(async { Ok(WebResponse::new(Response::NotFound().finish(), req)) })
+            Either::Right(Box::pin(async {
+                Ok(WebResponse::new(Response::NotFound().finish(), req))
+            }))
         }
     }
 }
@@ -296,23 +305,28 @@ where
         }
     }
 
-    fn call(&self, req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         AppServiceResponse {
-            filter: self.filter.call(req),
+            filter: ctx.call(&self.filter, req),
             routing: &self.routing,
             endpoint: None,
+            ctx,
         }
     }
 }
 
+type BoxAppServiceResponse<'a, Err: ErrorRenderer> =
+    ServiceCall<'a, AppRouting<Err>, WebRequest<Err>>;
+
 pin_project_lite::pin_project! {
     pub struct AppServiceResponse<'f, F: Service<WebRequest<Err>>, Err: ErrorRenderer>
     where F: 'f
     {
         #[pin]
-        filter: F::Future<'f>,
+        filter: ServiceCall<'f, F, WebRequest<Err>>,
         routing: &'f AppRouting<Err>,
-        endpoint: Option<BoxResponse<'f, Err>>,
+        endpoint: Option<BoxAppServiceResponse<'f, Err>>,
+        ctx: Ctx<'f, AppService<F, Err>>,
     }
 }
 
@@ -335,7 +349,7 @@ where
                 } else {
                     return Poll::Pending;
                 };
-                *this.endpoint = Some(this.routing.call(res));
+                *this.endpoint = Some(this.ctx.call(this.routing, res));
                 this = self.as_mut().project();
             }
         }
@@ -347,7 +361,6 @@ mod tests {
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::Arc;
 
-    use crate::service::Service;
     use crate::web::test::{init_service, TestRequest};
     use crate::web::{self, App, HttpResponse};
 

ntex/src/web/config.rs

@@ -129,9 +129,9 @@ impl<Err: ErrorRenderer> ServiceConfig<Err> {
 mod tests {
     use super::*;
     use crate::http::{Method, StatusCode};
+    use crate::util::Bytes;
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::{self, App, HttpRequest, HttpResponse};
-    use crate::{service::Service, util::Bytes};
 
     #[crate::rt_test]
     async fn test_configure_state() {

ntex/src/web/middleware/compress.rs

@@ -4,7 +4,7 @@ use std::{cmp, future::Future, marker, pin::Pin, str::FromStr};
 
 use crate::http::encoding::Encoder;
 use crate::http::header::{ContentEncoding, ACCEPT_ENCODING};
-use crate::service::{Middleware, Service};
+use crate::service::{Ctx, Middleware, Service, ServiceCall};
 use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
 
 #[derive(Debug, Clone)]
@@ -71,7 +71,7 @@ where
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call(&self, req: WebRequest<E>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         // negotiate content-encoding
         let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
             if let Ok(enc) = val.to_str() {
@@ -85,7 +85,7 @@ where
 
         CompressResponse {
             encoding,
-            fut: self.service.call(req),
+            fut: ctx.call(&self.service, req),
             _t: marker::PhantomData,
         }
     }
@@ -97,7 +97,7 @@ pin_project_lite::pin_project! {
     where S: 'f, E: 'f
     {
         #[pin]
-        fut: S::Future<'f>,
+        fut: ServiceCall<'f, S, WebRequest<E>>,
         encoding: ContentEncoding,
         _t: marker::PhantomData<E>,
     }

ntex/src/web/middleware/defaultheaders.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use crate::http::error::HttpError;
 use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
-use crate::service::{Middleware, Service};
+use crate::service::{Ctx, Middleware, Service};
 use crate::util::BoxFuture;
 use crate::web::{WebRequest, WebResponse};
 
@@ -115,9 +115,9 @@ where
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call(&self, req: WebRequest<E>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         Box::pin(async move {
-            let mut res = self.service.call(req).await?;
+            let mut res = ctx.call(&self.service, req).await?;
 
             // set response headers
             for (key, value) in self.inner.headers.iter() {
@@ -141,7 +141,7 @@ where
 mod tests {
     use super::*;
     use crate::http::header::CONTENT_TYPE;
-    use crate::service::IntoService;
+    use crate::service::{Container, IntoService};
     use crate::util::lazy;
     use crate::web::request::WebRequest;
     use crate::web::test::{ok_service, TestRequest};
@@ -149,9 +149,11 @@ mod tests {
 
     #[crate::rt_test]
     async fn test_default_headers() {
-        let mw = DefaultHeaders::new()
+        let mw = Container::new(
-            .header(CONTENT_TYPE, "0001")
+            DefaultHeaders::new()
-            .create(ok_service());
+                .header(CONTENT_TYPE, "0001")
+                .create(ok_service()),
+        );
 
         assert!(lazy(|cx| mw.poll_ready(cx).is_ready()).await);
         assert!(lazy(|cx| mw.poll_shutdown(cx).is_ready()).await);
@@ -166,9 +168,11 @@ mod tests {
                 req.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()),
             )
         };
-        let mw = DefaultHeaders::new()
+        let mw = Container::new(
-            .header(CONTENT_TYPE, "0001")
+            DefaultHeaders::new()
-            .create(srv.into_service());
+                .header(CONTENT_TYPE, "0001")
+                .create(srv.into_service()),
+        );
         let resp = mw.call(req).await.unwrap();
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0002");
     }
@@ -178,9 +182,11 @@ mod tests {
         let srv = |req: WebRequest<DefaultError>| async move {
             Ok::<_, Error>(req.into_response(HttpResponse::Ok().finish()))
         };
-        let mw = DefaultHeaders::new()
+        let mw = Container::new(
-            .content_type()
+            DefaultHeaders::new()
-            .create(srv.into_service());
+                .content_type()
+                .create(srv.into_service()),
+        );
 
         let req = TestRequest::default().to_srv_request();
         let resp = mw.call(req).await.unwrap();

ntex/src/web/middleware/logger.rs

@@ -7,7 +7,7 @@ use regex::Regex;
 
 use crate::http::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::header::HeaderName;
-use crate::service::{Middleware, Service};
+use crate::service::{Ctx, Middleware, Service, ServiceCall};
 use crate::util::{Bytes, Either, HashSet};
 use crate::web::{HttpResponse, WebRequest, WebResponse};
 
@@ -136,15 +136,15 @@ where
 {
     type Response = WebResponse;
     type Error = S::Error;
-    type Future<'f> = Either<LoggerResponse<'f, S, E>, S::Future<'f>> where S: 'f, E: 'f;
+    type Future<'f> = Either<LoggerResponse<'f, S, E>, ServiceCall<'f, S, WebRequest<E>>> where S: 'f, E: 'f;
 
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call(&self, req: WebRequest<E>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         if self.inner.exclude.contains(req.path()) {
-            Either::Right(self.service.call(req))
+            Either::Right(ctx.call(&self.service, req))
         } else {
             let time = time::SystemTime::now();
             let mut format = self.inner.format.clone();
@@ -155,7 +155,7 @@ where
             Either::Left(LoggerResponse {
                 time,
                 format: Some(format),
-                fut: self.service.call(req),
+                fut: ctx.call(&self.service, req),
                 _t: PhantomData,
             })
         }
@@ -168,7 +168,7 @@ pin_project_lite::pin_project! {
     where S: 'f, E: 'f
     {
         #[pin]
-        fut: S::Future<'f>,
+        fut: ServiceCall<'f, S, WebRequest<E>>,
         time: time::SystemTime,
         format: Option<Format>,
         _t: PhantomData<E>
@@ -448,7 +448,7 @@ impl<'a> fmt::Display for FormatDisplay<'a> {
 mod tests {
     use super::*;
     use crate::http::{header, StatusCode};
-    use crate::service::{IntoService, Middleware};
+    use crate::service::{Container, IntoService, Middleware};
     use crate::util::lazy;
     use crate::web::test::{self, TestRequest};
     use crate::web::{DefaultError, Error};
@@ -468,7 +468,7 @@ mod tests {
         let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D %% test")
             .exclude("/test");
 
-        let srv = Middleware::create(&logger, srv.into_service());
+        let srv = Container::new(Middleware::create(&logger, srv.into_service()));
         assert!(lazy(|cx| srv.poll_ready(cx).is_ready()).await);
         assert!(lazy(|cx| srv.poll_shutdown(cx).is_ready()).await);
 

ntex/src/web/resource.rs

@@ -3,9 +3,11 @@ use std::{cell::RefCell, fmt, rc::Rc};
 use crate::http::Response;
 use crate::router::{IntoPattern, ResourceDef};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
-use crate::service::{dev::AndThen, pipeline, pipeline_factory, Pipeline, PipelineFactory};
 use crate::service::{
-    Identity, IntoServiceFactory, Middleware, Service, ServiceFactory, Stack,
+    dev::AndThen, pipeline, pipeline_factory, Ctx, Pipeline, PipelineFactory,
+};
+use crate::service::{
+    Identity, IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory, Stack,
 };
 use crate::util::{BoxFuture, Either, Extensions, Ready};
 
@@ -22,6 +24,8 @@ type HttpService<Err: ErrorRenderer> =
 type HttpNewService<Err: ErrorRenderer> =
     BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
 type ResourcePipeline<F, Err> = Pipeline<WebRequest<Err>, AndThen<F, ResourceRouter<Err>>>;
+type BoxResponse<'a, Err: ErrorRenderer> =
+    ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
 
 /// *Resource* is an entry in resources table which corresponds to requested URL.
 ///
@@ -456,6 +460,9 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ResourceRouterFacto
     }
 }
 
+type BoxResourceRouterResponse<'a, Err: ErrorRenderer> =
+    ServiceCall<'a, RouteService<Err>, WebRequest<Err>>;
+
 pub struct ResourceRouter<Err: ErrorRenderer> {
     state: Option<AppState>,
     routes: Vec<RouteService<Err>>,
@@ -466,26 +473,30 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
     type Response = WebResponse;
     type Error = Err::Container;
     type Future<'f> = Either<
-        Ready<WebResponse, Err::Container>,
+        BoxResourceRouterResponse<'f, Err>,
-        BoxFuture<'f, Result<WebResponse, Err::Container>>,
+        Either<Ready<WebResponse, Err::Container>, BoxResponse<'f, Err>>,
     >;
 
-    fn call(&self, mut req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        mut req: WebRequest<Err>,
+        ctx: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         for route in self.routes.iter() {
             if route.check(&mut req) {
                 if let Some(ref state) = self.state {
                     req.set_state_container(state.clone());
                 }
-                return Either::Right(route.call(req));
+                return Either::Left(ctx.call(route, req));
             }
         }
         if let Some(ref default) = self.default {
-            Either::Right(default.call(req))
+            Either::Right(Either::Right(ctx.call(default, req)))
         } else {
-            Either::Left(Ready::Ok(WebResponse::new(
+            Either::Right(Either::Left(Ready::Ok(WebResponse::new(
                 Response::MethodNotAllowed().finish(),
                 req.into_parts().0,
-            )))
+            ))))
         }
     }
 }

ntex/src/web/responder.rs

@@ -404,7 +404,7 @@ pub(crate) mod tests {
     use crate::http::header::{HeaderValue, CONTENT_TYPE};
     use crate::http::{Response as HttpResponse, StatusCode};
     use crate::web::test::{init_service, TestRequest};
-    use crate::{service::Service, util::Bytes, util::BytesMut, web};
+    use crate::{util::Bytes, util::BytesMut, web};
 
     fn responder<T: Responder<DefaultError>>(responder: T) -> impl Responder<DefaultError> {
         responder

ntex/src/web/route.rs

@@ -1,7 +1,7 @@
 use std::{mem, rc::Rc};
 
 use crate::util::{BoxFuture, Ready};
-use crate::{http::Method, service::Service, service::ServiceFactory};
+use crate::{http::Method, service::Ctx, service::Service, service::ServiceFactory};
 
 use super::error::ErrorRenderer;
 use super::error_default::DefaultError;
@@ -90,7 +90,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for RouteService<Err> {
     type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
     #[inline]
-    fn call(&self, req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
         self.handler.call(req)
     }
 }

ntex/src/web/scope.rs

@@ -6,7 +6,9 @@ use crate::http::Response;
 use crate::router::{IntoPattern, ResourceDef, Router};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
 use crate::service::{pipeline_factory, IntoServiceFactory, PipelineFactory};
-use crate::service::{Identity, Middleware, Service, ServiceFactory, Stack};
+use crate::service::{
+    Ctx, Identity, Middleware, Service, ServiceCall, ServiceFactory, Stack,
+};
 use crate::util::{BoxFuture, Either, Extensions, Ready};
 
 use super::app::Filter;
@@ -27,7 +29,7 @@ type HttpService<Err: ErrorRenderer> =
 type HttpNewService<Err: ErrorRenderer> =
     BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
 type BoxResponse<'a, Err: ErrorRenderer> =
-    BoxFuture<'a, Result<WebResponse, Err::Container>>;
+    ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
 
 /// Resources scope.
 ///
@@ -503,11 +505,12 @@ where
         }
     }
 
-    fn call(&self, req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
         ScopeServiceResponse {
-            filter: self.filter.call(req),
+            filter: ctx.call(&self.filter, req),
             routing: &self.routing,
             endpoint: None,
+            ctx,
         }
     }
 }
@@ -517,9 +520,10 @@ pin_project_lite::pin_project! {
     where F: 'f
     {
         #[pin]
-        filter: F::Future<'f>,
+        filter: ServiceCall<'f, F, WebRequest<Err>>,
         routing: &'f ScopeRouter<Err>,
-        endpoint: Option<<ScopeRouter<Err> as Service<WebRequest<Err>>>::Future<'f>>,
+        ctx: Ctx<'f, ScopeService<F, Err>>,
+        endpoint: Option<ServiceCall<'f, ScopeRouter<Err>, WebRequest<Err>>>,
     }
 }
 
@@ -536,15 +540,15 @@ where
         loop {
             if let Some(fut) = this.endpoint.as_mut() {
                 return Pin::new(fut).poll(cx);
-            } else {
-                let res = if let Poll::Ready(res) = this.filter.poll(cx) {
-                    res?
-                } else {
-                    return Poll::Pending;
-                };
-                *this.endpoint = Some(this.routing.call(res));
-                this = self.as_mut().project();
             }
+
+            let res = if let Poll::Ready(res) = this.filter.poll(cx) {
+                res?
+            } else {
+                return Poll::Pending;
+            };
+            *this.endpoint = Some(this.ctx.call(this.routing, res));
+            this = self.as_mut().project();
         }
     }
 }
@@ -601,7 +605,11 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
     type Error = Err::Container;
     type Future<'f> = Either<BoxResponse<'f, Err>, Ready<Self::Response, Self::Error>>;
 
-    fn call(&self, mut req: WebRequest<Err>) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        mut req: WebRequest<Err>,
+        ctx: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         let res = self.router.recognize_checked(&mut req, |req, guards| {
             if let Some(guards) = guards {
                 for f in guards {
@@ -617,9 +625,9 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
             if let Some(ref state) = self.state {
                 req.set_state_container(state.clone());
             }
-            Either::Left(srv.call(req))
+            Either::Left(ctx.call(srv, req))
         } else if let Some(ref default) = self.default {
-            Either::Left(default.call(req))
+            Either::Left(ctx.call(default, req))
         } else {
             let req = req.into_parts().0;
             Either::Right(Ready::Ok(WebResponse::new(
@@ -635,7 +643,7 @@ mod tests {
     use crate::http::body::{Body, ResponseBody};
     use crate::http::header::{HeaderValue, CONTENT_TYPE};
     use crate::http::{Method, StatusCode};
-    use crate::service::{fn_service, Service};
+    use crate::service::fn_service;
     use crate::util::{Bytes, Ready};
     use crate::web::middleware::DefaultHeaders;
     use crate::web::request::WebRequest;

ntex/src/web/service.rs

@@ -392,7 +392,6 @@ tuple_web_service!((0,A),(1,B),(2,C),(3,D),(4,E),(5,F),(6,G),(7,H),(8,I),(9,J),(
 mod tests {
     use super::*;
     use crate::http::{Method, StatusCode};
-    use crate::service::Service;
     use crate::web::test::{init_service, TestRequest};
     use crate::web::{self, guard, App, DefaultError, HttpResponse};
 

ntex/src/web/test.rs

@@ -3,8 +3,7 @@ use std::{fmt, net, net::SocketAddr, rc::Rc, sync::mpsc, thread};
 
 #[cfg(feature = "cookie")]
 use coo_kie::Cookie;
-use serde::de::DeserializeOwned;
+use serde::{de::DeserializeOwned, Serialize};
-use serde::Serialize;
 
 use crate::http::body::MessageBody;
 use crate::http::client::{Client, ClientRequest, ClientResponse, Connector};
@@ -14,7 +13,7 @@ use crate::http::test::TestRequest as HttpTestRequest;
 use crate::http::{HttpService, Method, Payload, Request, StatusCode, Uri, Version};
 use crate::router::{Path, ResourceDef};
 use crate::service::{
-    map_config, IntoService, IntoServiceFactory, Service, ServiceFactory,
+    map_config, Container, IntoService, IntoServiceFactory, Service, ServiceFactory,
 };
 use crate::time::{sleep, Millis, Seconds};
 use crate::util::{stream_recv, Bytes, BytesMut, Extensions, Ready, Stream};
@@ -70,14 +69,14 @@ pub fn default_service<Err: ErrorRenderer>(
 /// ```
 pub async fn init_service<R, S, E>(
     app: R,
-) -> impl Service<Request, Response = WebResponse, Error = E>
+) -> Container<impl Service<Request, Response = WebResponse, Error = E>>
 where
     R: IntoServiceFactory<S, Request, AppConfig>,
     S: ServiceFactory<Request, AppConfig, Response = WebResponse, Error = E>,
     S::InitError: std::fmt::Debug,
 {
     let srv = app.into_factory();
-    srv.create(AppConfig::default()).await.unwrap()
+    srv.container(AppConfig::default()).await.unwrap()
 }
 
 /// Calls service and waits for response future completion.
@@ -103,7 +102,7 @@ where
 ///     assert_eq!(resp.status(), StatusCode::OK);
 /// }
 /// ```
-pub async fn call_service<S, R, E>(app: &S, req: R) -> S::Response
+pub async fn call_service<S, R, E>(app: &Container<S>, req: R) -> S::Response
 where
     S: Service<R, Response = WebResponse, Error = E>,
     E: std::fmt::Debug,
@@ -136,7 +135,7 @@ where
 ///     assert_eq!(result, Bytes::from_static(b"welcome!"));
 /// }
 /// ```
-pub async fn read_response<S>(app: &S, req: Request) -> Bytes
+pub async fn read_response<S>(app: &Container<S>, req: Request) -> Bytes
 where
     S: Service<Request, Response = WebResponse>,
 {
@@ -235,7 +234,7 @@ where
 ///     let result: Person = test::read_response_json(&mut app, req).await;
 /// }
 /// ```
-pub async fn read_response_json<S, T>(app: &S, req: Request) -> T
+pub async fn read_response_json<S, T>(app: &Container<S>, req: Request) -> T
 where
     S: Service<Request, Response = WebResponse>,
     T: DeserializeOwned,

ntex/src/web/types/payload.rs

@@ -159,8 +159,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for Bytes {
         }
 
         let limit = cfg.limit;
-        let fut = HttpMessageBody::new(req, payload).limit(limit);
+        Either::Left(Box::pin(HttpMessageBody::new(req, payload).limit(limit)))
-        Either::Left(Box::pin(async move { fut.await }))
     }
 }
 

ntex/src/web/types/state.rs

@@ -101,7 +101,6 @@ mod tests {
 
     use super::*;
     use crate::http::StatusCode;
-    use crate::service::Service;
     use crate::web::test::{self, init_service, TestRequest};
     use crate::web::{self, App, HttpResponse};
 

ntex/src/web/ws.rs

@@ -5,7 +5,7 @@ pub use crate::ws::{CloseCode, CloseReason, Frame, Message, WsSink};
 
 use crate::http::{body::BodySize, h1, StatusCode};
 use crate::service::{
-    apply_fn, fn_factory_with_config, IntoServiceFactory, Service, ServiceFactory,
+    apply_fn, fn_factory_with_config, IntoServiceFactory, ServiceFactory,
 };
 use crate::web::{HttpRequest, HttpResponse};
 use crate::ws::{self, error::HandshakeError, error::WsError, handshake};

ntex/src/ws/client.rs

@@ -16,7 +16,7 @@ use crate::http::header::{self, HeaderMap, HeaderName, HeaderValue, AUTHORIZATIO
 use crate::http::{body::BodySize, client::ClientResponse, error::HttpError, h1};
 use crate::http::{ConnectionType, RequestHead, RequestHeadType, StatusCode, Uri};
 use crate::io::{Base, DispatchItem, Dispatcher, Filter, Io, Layer, Sealed};
-use crate::service::{apply_fn, into_service, IntoService, Service};
+use crate::service::{apply_fn, into_service, Container, IntoService, Service};
 use crate::time::{timeout, Millis, Seconds};
 use crate::{channel::mpsc, rt, util::Ready, ws};
 
@@ -25,7 +25,7 @@ use super::transport::WsTransport;
 
 /// `WebSocket` client builder
 pub struct WsClient<F, T> {
-    connector: T,
+    connector: Container<T>,
     head: Rc<RequestHead>,
     addr: Option<net::SocketAddr>,
     max_size: usize,
@@ -630,7 +630,7 @@ where
         }
 
         Ok(WsClient {
-            connector: inner.connector,
+            connector: inner.connector.into(),
             head: Rc::new(inner.head),
             addr: inner.addr,
             max_size: inner.max_size,

ntex/tests/connect.rs

@@ -3,7 +3,7 @@ use std::{io, rc::Rc, sync::Arc};
 use ntex::codec::BytesCodec;
 use ntex::connect::Connect;
 use ntex::io::{types::PeerAddr, Io};
-use ntex::service::{fn_service, pipeline_factory, Service, ServiceFactory};
+use ntex::service::{fn_service, pipeline_factory, Container, ServiceFactory};
 use ntex::{server::test_server, time, util::Bytes};
 
 #[cfg(feature = "openssl")]
@@ -97,7 +97,7 @@ async fn test_openssl_string() {
     let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
     builder.set_verify(SslVerifyMode::NONE);
 
-    let conn = ntex::connect::openssl::Connector::new(builder.build());
+    let conn = Container::new(ntex::connect::openssl::Connector::new(builder.build()));
     let addr = format!("127.0.0.1:{}", srv.addr().port());
     let io = conn.call(addr.into()).await.unwrap();
     assert_eq!(io.query::<PeerAddr>().get().unwrap(), srv.addr().into());
@@ -140,7 +140,7 @@ async fn test_openssl_read_before_error() {
     let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
     builder.set_verify(SslVerifyMode::NONE);
 
-    let conn = ntex::connect::openssl::Connector::new(builder.build());
+    let conn = Container::new(ntex::connect::openssl::Connector::new(builder.build()));
     let addr = format!("127.0.0.1:{}", srv.addr().port());
     let io = conn.call(addr.into()).await.unwrap();
     let item = io.recv(&Rc::new(BytesCodec)).await.unwrap().unwrap();
@@ -185,7 +185,7 @@ async fn test_rustls_string() {
         .with_custom_certificate_verifier(Arc::new(danger::NoCertificateVerification {}))
         .with_no_client_auth();
 
-    let conn = ntex::connect::rustls::Connector::new(config);
+    let conn = Container::new(ntex::connect::rustls::Connector::new(config));
     let addr = format!("localhost:{}", srv.addr().port());
     let io = conn.call(addr.into()).await.unwrap();
     assert_eq!(io.query::<PeerAddr>().get().unwrap(), srv.addr().into());
@@ -225,13 +225,13 @@ async fn test_static_str() {
         })
     });
 
-    let conn = ntex::connect::Connector::new();
+    let conn = Container::new(ntex::connect::Connector::new());
 
     let io = conn.call(Connect::with("10", srv.addr())).await.unwrap();
     assert_eq!(io.query::<PeerAddr>().get().unwrap(), srv.addr().into());
 
     let connect = Connect::new("127.0.0.1".to_owned());
-    let conn = ntex::connect::Connector::new();
+    let conn = Container::new(ntex::connect::Connector::new());
     let io = conn.call(connect).await;
     assert!(io.is_err());
 }
@@ -248,7 +248,7 @@ async fn test_create() {
     });
 
     let factory = ntex::connect::Connector::new();
-    let conn = factory.create(()).await.unwrap();
+    let conn = factory.container(()).await.unwrap();
     let io = conn.call(Connect::with("10", srv.addr())).await.unwrap();
     assert_eq!(io.query::<PeerAddr>().get().unwrap(), srv.addr().into());
 }
@@ -265,7 +265,7 @@ async fn test_uri() {
         })
     });
 
-    let conn = ntex::connect::Connector::default();
+    let conn = Container::new(ntex::connect::Connector::default());
     let addr =
         ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port()))
             .unwrap();
@@ -285,7 +285,7 @@ async fn test_rustls_uri() {
         })
     });
 
-    let conn = ntex::connect::Connector::default();
+    let conn = Container::new(ntex::connect::Connector::default());
     let addr =
         ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port()))
             .unwrap();

ntex/tests/http_ws.rs

@@ -4,7 +4,7 @@ use ntex::codec::BytesCodec;
 use ntex::http::test::server as test_server;
 use ntex::http::{body, h1, test, HttpService, Request, Response, StatusCode};
 use ntex::io::{DispatchItem, Dispatcher, Io};
-use ntex::service::{fn_factory, Service};
+use ntex::service::{fn_factory, Ctx, Service};
 use ntex::util::{BoxFuture, ByteString, Bytes, Ready};
 use ntex::ws::{self, handshake, handshake_response};
 
@@ -40,7 +40,11 @@ impl Service<(Request, Io, h1::Codec)> for WsService {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&self, (req, io, codec): (Request, Io, h1::Codec)) -> Self::Future<'_> {
+    fn call<'a>(
+        &'a self,
+        (req, io, codec): (Request, Io, h1::Codec),
+        _: Ctx<'a, Self>,
+    ) -> Self::Future<'a> {
         let fut = async move {
             let res = handshake(req.head()).unwrap().message_body(());