From 108e2ac20aa303c845487b3b1d94f058630eadab Mon Sep 17 00:00:00 2001
From: Nikolay Kim <fafhrd91@gmail.com>
Date: Mon, 19 Jun 2023 18:38:23 +0600
Subject: [PATCH] Rename Ctx to ServiceCtx

---
 ntex-connect/Cargo.toml                   | 10 +++++-----
 ntex-connect/src/openssl.rs               |  4 ++--
 ntex-connect/src/resolve.rs               |  4 ++--
 ntex-connect/src/rustls.rs                |  4 ++--
 ntex-connect/src/service.rs               |  4 ++--
 ntex-io/Cargo.toml                        |  6 +++---
 ntex-io/src/dispatcher.rs                 |  4 ++--
 ntex-io/src/utils.rs                      |  4 ++--
 ntex-service/CHANGES.md                   |  4 ++++
 ntex-service/Cargo.toml                   |  2 +-
 ntex-service/src/and_then.rs              | 22 ++++++++++++++++------
 ntex-service/src/apply.rs                 | 10 +++++-----
 ntex-service/src/boxed.rs                 |  6 +++---
 ntex-service/src/ctx.rs                   | 20 ++++++++++++--------
 ntex-service/src/fn_service.rs            |  6 +++---
 ntex-service/src/fn_shutdown.rs           |  4 ++--
 ntex-service/src/lib.rs                   | 12 ++++++------
 ntex-service/src/map.rs                   |  8 ++++----
 ntex-service/src/map_err.rs               |  8 ++++----
 ntex-service/src/middleware.rs            |  4 ++--
 ntex-service/src/pipeline.rs              |  4 ++--
 ntex-service/src/then.rs                  | 12 ++++++------
 ntex-tls/Cargo.toml                       | 10 +++++-----
 ntex-tls/src/openssl/accept.rs            |  4 ++--
 ntex-tls/src/rustls/accept.rs             |  4 ++--
 ntex-util/Cargo.toml                      |  4 ++--
 ntex-util/src/services/buffer.rs          |  6 +++---
 ntex-util/src/services/inflight.rs        |  8 ++++----
 ntex-util/src/services/keepalive.rs       |  4 ++--
 ntex-util/src/services/onerequest.rs      |  8 ++++----
 ntex-util/src/services/timeout.rs         |  6 +++---
 ntex-util/src/services/variant.rs         |  8 ++++----
 ntex/CHANGES.md                           |  4 ++++
 ntex/Cargo.toml                           | 14 +++++++-------
 ntex/src/http/client/connector.rs         |  4 ++--
 ntex/src/http/client/h2proto.rs           |  8 ++++++--
 ntex/src/http/client/pool.rs              |  4 ++--
 ntex/src/http/h1/expect.rs                |  4 ++--
 ntex/src/http/h1/service.rs               |  4 ++--
 ntex/src/http/h1/upgrade.rs               |  5 +++--
 ntex/src/http/h2/service.rs               | 12 ++++++++----
 ntex/src/http/service.rs                  |  4 ++--
 ntex/src/lib.rs                           |  4 ++--
 ntex/src/server/service.rs                |  4 ++--
 ntex/src/server/worker.rs                 |  4 ++--
 ntex/src/web/app.rs                       |  8 ++++++--
 ntex/src/web/app_service.rs               | 15 ++++++++++-----
 ntex/src/web/middleware/compress.rs       |  8 ++++++--
 ntex/src/web/middleware/defaultheaders.rs |  8 ++++++--
 ntex/src/web/middleware/logger.rs         |  8 ++++++--
 ntex/src/web/resource.rs                  |  4 ++--
 ntex/src/web/route.rs                     |  8 ++++++--
 ntex/src/web/scope.rs                     | 12 ++++++++----
 ntex/tests/http_ws.rs                     |  4 ++--
 54 files changed, 217 insertions(+), 157 deletions(-)

diff --git a/ntex-connect/Cargo.toml b/ntex-connect/Cargo.toml
index 22a8f6d5..b243d51f 100644
--- a/ntex-connect/Cargo.toml
+++ b/ntex-connect/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-connect"
-version = "0.3.0-beta.0"
+version = "0.3.0-beta.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork connect utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -34,13 +34,13 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
 async-std = ["ntex-rt/async-std", "ntex-async-std"]
 
 [dependencies]
-ntex-service = "1.2.0-beta.0"
+ntex-service = "1.2.0-beta.1"
 ntex-bytes = "0.1.19"
 ntex-http = "0.1.8"
-ntex-io = "0.3.0-beta.0"
+ntex-io = "0.3.0-beta.1"
 ntex-rt = "0.4.7"
-ntex-tls = "0.3.0-beta.0"
-ntex-util = "0.3.0-beta.0"
+ntex-tls = "0.3.0-beta.1"
+ntex-util = "0.3.0-beta.1"
 log = "0.4"
 thiserror = "1.0"
 
diff --git a/ntex-connect/src/openssl.rs b/ntex-connect/src/openssl.rs
index c3695468..58ed7ca0 100644
--- a/ntex-connect/src/openssl.rs
+++ b/ntex-connect/src/openssl.rs
@@ -5,7 +5,7 @@ pub use tls_openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslM
 
 use ntex_bytes::PoolId;
 use ntex_io::{FilterFactory, Io, Layer};
-use ntex_service::{Container, Ctx, Service, ServiceFactory};
+use ntex_service::{Container, Service, ServiceCtx, ServiceFactory};
 use ntex_tls::openssl::SslConnector as IoSslConnector;
 use ntex_util::future::{BoxFuture, Ready};
 
@@ -107,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<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         Box::pin(self.connect(req))
     }
 }
diff --git a/ntex-connect/src/resolve.rs b/ntex-connect/src/resolve.rs
index 7fcf7244..acef3418 100644
--- a/ntex-connect/src/resolve.rs
+++ b/ntex-connect/src/resolve.rs
@@ -1,7 +1,7 @@
 use std::{fmt, io, marker, net};
 
 use ntex_rt::spawn_blocking;
-use ntex_service::{Ctx, Service, ServiceFactory};
+use ntex_service::{Service, ServiceCtx, 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<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         Box::pin(self.lookup(req))
     }
 }
diff --git a/ntex-connect/src/rustls.rs b/ntex-connect/src/rustls.rs
index de271d3b..b13125d7 100644
--- a/ntex-connect/src/rustls.rs
+++ b/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::{Container, Ctx, Service, ServiceFactory};
+use ntex_service::{Container, Service, ServiceCtx, ServiceFactory};
 use ntex_tls::rustls::TlsConnector;
 use ntex_util::future::{BoxFuture, Ready};
 
@@ -110,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<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         Box::pin(self.connect(req))
     }
 }
diff --git a/ntex-connect/src/service.rs b/ntex-connect/src/service.rs
index 9e408257..e2273344 100644
--- a/ntex-connect/src/service.rs
+++ b/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::{Ctx, Service, ServiceFactory};
+use ntex_service::{Service, ServiceCtx, ServiceFactory};
 use ntex_util::future::{BoxFuture, Either, Ready};
 
 use crate::{net::tcp_connect_in, Address, Connect, ConnectError, Resolver};
@@ -80,7 +80,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Future<'f> = ConnectServiceResponse<'f, T>;
 
     #[inline]
-    fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ConnectServiceResponse::new(Box::pin(self.resolver.lookup(req)))
     }
 }
diff --git a/ntex-io/Cargo.toml b/ntex-io/Cargo.toml
index 9c271b27..15fc386d 100644
--- a/ntex-io/Cargo.toml
+++ b/ntex-io/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.3.0-beta.0"
+version = "0.3.0-beta.1"
 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.3.0-beta.0"
-ntex-service = "1.2.0-beta.0"
+ntex-util = "0.3.0-beta.1"
+ntex-service = "1.2.0-beta.1"
 
 bitflags = "1.3"
 log = "0.4"
diff --git a/ntex-io/src/dispatcher.rs b/ntex-io/src/dispatcher.rs
index 2fa79ce7..2236a1e1 100644
--- a/ntex-io/src/dispatcher.rs
+++ b/ntex-io/src/dispatcher.rs
@@ -426,7 +426,7 @@ mod tests {
 
     use ntex_bytes::{Bytes, PoolId, PoolRef};
     use ntex_codec::BytesCodec;
-    use ntex_service::Ctx;
+    use ntex_service::ServiceCtx;
     use ntex_util::{future::Ready, time::sleep, time::Millis, time::Seconds};
 
     use super::*;
@@ -625,7 +625,7 @@ mod tests {
             fn call<'a>(
                 &'a self,
                 _: DispatchItem<BytesCodec>,
-                _: Ctx<'a, Self>,
+                _: ServiceCtx<'a, Self>,
             ) -> Self::Future<'a> {
                 Ready::Ok(None)
             }
diff --git a/ntex-io/src/utils.rs b/ntex-io/src/utils.rs
index 78d1343c..042b1d55 100644
--- a/ntex-io/src/utils.rs
+++ b/ntex-io/src/utils.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use ntex_service::{fn_service, pipeline_factory, Ctx, Service, ServiceFactory};
+use ntex_service::{fn_service, pipeline_factory, Service, ServiceCtx, 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<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         self.filter.clone().create(req)
     }
 }
diff --git a/ntex-service/CHANGES.md b/ntex-service/CHANGES.md
index 80a6c436..c9c81d7c 100644
--- a/ntex-service/CHANGES.md
+++ b/ntex-service/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [1.2.0-beta.1] - 2023-06-19
+
+* Rename Ctx to ServiceCtx
+
 ## [1.2.0-beta.0] - 2023-06-16
 
 * Enforce service readiness during call
diff --git a/ntex-service/Cargo.toml b/ntex-service/Cargo.toml
index c4fbae9c..aca254e4 100644
--- a/ntex-service/Cargo.toml
+++ b/ntex-service/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "1.2.0-beta.0"
+version = "1.2.0-beta.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]
diff --git a/ntex-service/src/and_then.rs b/ntex-service/src/and_then.rs
index a3e9c3da..c590ef51 100644
--- a/ntex-service/src/and_then.rs
+++ b/ntex-service/src/and_then.rs
@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
@@ -59,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         AndThenServiceResponse {
             slf: self,
             state: State::A {
@@ -93,7 +93,7 @@ pin_project_lite::pin_project! {
         B: Service<A::Response, Error = A::Error>,
         B: 'f,
     {
-        A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<Ctx<'f, AndThen<A, B>>> },
+        A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<ServiceCtx<'f, AndThen<A, B>>> },
         B { #[pin] fut: ServiceCall<'f, B, A::Response> },
         Empty,
     }
@@ -234,7 +234,9 @@ where
 mod tests {
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::{fn_factory, pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{
+        fn_factory, pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory,
+    };
     use ntex_util::future::{lazy, Ready};
 
     #[derive(Clone)]
@@ -250,7 +252,11 @@ 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,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok(req)
         }
     }
@@ -268,7 +274,11 @@ 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,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok((req, "srv2"))
         }
     }
diff --git a/ntex-service/src/apply.rs b/ntex-service/src/apply.rs
index f5d60849..85c011aa 100644
--- a/ntex-service/src/apply.rs
+++ b/ntex-service/src/apply.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::type_complexity)]
 use std::{future::Future, marker, pin::Pin, rc::Rc, task, task::Poll};
 
-use super::ctx::{Ctx, ServiceCall, Waiters};
+use super::ctx::{ServiceCall, ServiceCtx, Waiters};
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform function to a service.
@@ -83,7 +83,7 @@ impl<S> ApplyService<S> {
     where
         S: Service<R>,
     {
-        Ctx::<S>::new(&self.waiters).call(&self.svc, req)
+        ServiceCtx::<S>::new(&self.waiters).call(&self.svc, req)
     }
 }
 
@@ -101,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         let svc = ApplyService {
             svc: self.service.clone(),
             waiters: ctx.waiters().clone(),
@@ -221,7 +221,7 @@ mod tests {
     use std::task::Poll;
 
     use super::*;
-    use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
@@ -231,7 +231,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, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }
diff --git a/ntex-service/src/boxed.rs b/ntex-service/src/boxed.rs
index b3ff4c97..f5027e0c 100644
--- a/ntex-service/src/boxed.rs
+++ b/ntex-service/src/boxed.rs
@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use crate::ctx::{Ctx, Waiters};
+use crate::ctx::{ServiceCtx, Waiters};
 
 pub type BoxFuture<'a, I, E> = Pin<Box<dyn Future<Output = Result<I, E>> + 'a>>;
 
@@ -71,7 +71,7 @@ where
         req: Req,
         waiters: &'a Waiters,
     ) -> BoxFuture<'a, Self::Response, Self::Error> {
-        Box::pin(Ctx::<'a, S>::new(waiters).call_nowait(self, req))
+        Box::pin(ServiceCtx::<'a, S>::new(waiters).call_nowait(self, req))
     }
 }
 
@@ -131,7 +131,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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         self.0.call(req, ctx.waiters())
     }
 }
diff --git a/ntex-service/src/ctx.rs b/ntex-service/src/ctx.rs
index 1397f237..c9c70e65 100644
--- a/ntex-service/src/ctx.rs
+++ b/ntex-service/src/ctx.rs
@@ -12,7 +12,7 @@ pub struct Container<S> {
     waiters: Waiters,
 }
 
-pub struct Ctx<'a, S: ?Sized> {
+pub struct ServiceCtx<'a, S: ?Sized> {
     waiters: &'a Waiters,
     _t: marker::PhantomData<Rc<S>>,
 }
@@ -103,7 +103,7 @@ impl<S> Container<S> {
     where
         S: Service<R>,
     {
-        let ctx = Ctx::<'a, S> {
+        let ctx = ServiceCtx::<'a, S> {
             waiters: &self.waiters,
             _t: marker::PhantomData,
         };
@@ -151,7 +151,7 @@ impl<S> ops::Deref for Container<S> {
     }
 }
 
-impl<'a, S: ?Sized> Ctx<'a, S> {
+impl<'a, S: ?Sized> ServiceCtx<'a, S> {
     pub(crate) fn new(waiters: &'a Waiters) -> Self {
         Self {
             waiters,
@@ -171,7 +171,7 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
     {
         svc.call(
             req,
-            Ctx {
+            ServiceCtx {
                 waiters: self.waiters,
                 _t: marker::PhantomData,
             },
@@ -195,9 +195,9 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
     }
 }
 
-impl<'a, S: ?Sized> Copy for Ctx<'a, S> {}
+impl<'a, S: ?Sized> Copy for ServiceCtx<'a, S> {}
 
-impl<'a, S: ?Sized> Clone for Ctx<'a, S> {
+impl<'a, S: ?Sized> Clone for ServiceCtx<'a, S> {
     #[inline]
     fn clone(&self) -> Self {
         Self {
@@ -256,7 +256,7 @@ where
 
                         let fut = svc.call(
                             req.take().unwrap(),
-                            Ctx {
+                            ServiceCtx {
                                 waiters,
                                 _t: marker::PhantomData,
                             },
@@ -327,7 +327,11 @@ 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,
+            _: ServiceCtx<'a, Self>,
+        ) -> Self::Future<'a> {
             Ready::Ok(req)
         }
     }
diff --git a/ntex-service/src/fn_service.rs b/ntex-service/src/fn_service.rs
index dc3bafb3..b8673f7b 100644
--- a/ntex-service/src/fn_service.rs
+++ b/ntex-service/src/fn_service.rs
@@ -1,6 +1,6 @@
 use std::{future::ready, future::Future, future::Ready, marker::PhantomData};
 
-use crate::{Ctx, IntoService, IntoServiceFactory, Service, ServiceFactory};
+use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 
 #[inline]
 /// Create `ServiceFactory` for function that can act as a `Service`
@@ -128,7 +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, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         (self.f)(req)
     }
 }
@@ -190,7 +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, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         (self.f)(req)
     }
 }
diff --git a/ntex-service/src/fn_shutdown.rs b/ntex-service/src/fn_shutdown.rs
index 3b549877..e90d9d49 100644
--- a/ntex-service/src/fn_shutdown.rs
+++ b/ntex-service/src/fn_shutdown.rs
@@ -3,7 +3,7 @@ use std::future::{ready, Ready};
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
-use crate::{Ctx, Service};
+use crate::{Service, ServiceCtx};
 
 #[inline]
 /// Create `FnShutdown` for function that can act as a `on_shutdown` callback.
@@ -60,7 +60,7 @@ where
     }
 
     #[inline]
-    fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ready(Ok(req))
     }
 }
diff --git a/ntex-service/src/lib.rs b/ntex-service/src/lib.rs
index 364ffbac..1e5e98be 100644
--- a/ntex-service/src/lib.rs
+++ b/ntex-service/src/lib.rs
@@ -22,7 +22,7 @@ mod pipeline;
 mod then;
 
 pub use self::apply::{apply_fn, apply_fn_factory};
-pub use self::ctx::{Container, ContainerFactory, Ctx, ServiceCall};
+pub use self::ctx::{Container, ContainerFactory, ServiceCall, ServiceCtx};
 pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
 pub use self::fn_shutdown::fn_shutdown;
 pub use self::map_config::{map_config, unit_config};
@@ -59,7 +59,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 /// # use std::future::Future;
 /// # use std::pin::Pin;
 /// #
-/// # use ntex_service::{Ctx, Service};
+/// # use ntex_service::{Service, ServiceCtx};
 ///
 /// struct MyService;
 ///
@@ -68,7 +68,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 ///     type Error = Infallible;
 ///     type Future<'f> = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
 ///
-///     fn call<'a>(&'a self, req: u8, _: Ctx<'a, Self>) -> Self::Future<'a> {
+///     fn call<'a>(&'a self, req: u8, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
 ///         Box::pin(std::future::ready(Ok(req as u64)))
 ///     }
 /// }
@@ -103,7 +103,7 @@ pub trait Service<Req> {
     /// should take care to not call `poll_ready`. Caller of the service verifies readiness,
     /// Only way to make a `call` is to use `ctx` argument, it enforces readiness before calling
     /// service.
-    fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>;
+    fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>;
 
     #[inline]
     /// Returns `Ready` when the service is able to process requests.
@@ -261,7 +261,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: ServiceCtx<'s, Self>) -> S::Future<'s> {
         ctx.call_nowait(&**self, request)
     }
 }
@@ -285,7 +285,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: ServiceCtx<'a, Self>) -> S::Future<'a> {
         ctx.call_nowait(&**self, request)
     }
 }
diff --git a/ntex-service/src/map.rs b/ntex-service/src/map.rs
index 4133fc4d..d57daa47 100644
--- a/ntex-service/src/map.rs
+++ b/ntex-service/src/map.rs
@@ -1,6 +1,6 @@
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
@@ -54,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         MapFuture {
             fut: ctx.call(&self.service, req),
             slf: self,
@@ -192,7 +192,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
 
     use super::*;
-    use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
+    use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
@@ -206,7 +206,7 @@ mod tests {
             Poll::Ready(Ok(()))
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }
diff --git a/ntex-service/src/map_err.rs b/ntex-service/src/map_err.rs
index f02513a4..b10bd4e1 100644
--- a/ntex-service/src/map_err.rs
+++ b/ntex-service/src/map_err.rs
@@ -1,6 +1,6 @@
 use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `map_err` combinator, changing the type of a service's
 /// error.
@@ -57,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         MapErrFuture {
             slf: self,
             fut: ctx.call(&self.service, req),
@@ -196,7 +196,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
 
     use super::*;
-    use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
+    use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv(bool);
@@ -214,7 +214,7 @@ mod tests {
             }
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Err(())
         }
     }
diff --git a/ntex-service/src/middleware.rs b/ntex-service/src/middleware.rs
index 5468c278..fa9f1596 100644
--- a/ntex-service/src/middleware.rs
+++ b/ntex-service/src/middleware.rs
@@ -214,7 +214,7 @@ mod tests {
     use std::marker;
 
     use super::*;
-    use crate::{fn_service, Container, Ctx, Service, ServiceCall, ServiceFactory};
+    use crate::{fn_service, Container, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Tr<R>(marker::PhantomData<R>);
@@ -239,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             ctx.call(&self.0, req)
         }
     }
diff --git a/ntex-service/src/pipeline.rs b/ntex-service/src/pipeline.rs
index d3fe5a09..70d91c94 100644
--- a/ntex-service/src/pipeline.rs
+++ b/ntex-service/src/pipeline.rs
@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use crate::and_then::{AndThen, AndThenFactory};
-use crate::ctx::{Container, Ctx, ServiceCall};
+use crate::ctx::{Container, ServiceCall, ServiceCtx};
 use crate::map::{Map, MapFactory};
 use crate::map_err::{MapErr, MapErrFactory};
 use crate::map_init_err::MapInitErr;
@@ -144,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ctx.call(&self.service, req)
     }
 }
diff --git a/ntex-service/src/then.rs b/ntex-service/src/then.rs
index fd0ec8ba..092a218a 100644
--- a/ntex-service/src/then.rs
+++ b/ntex-service/src/then.rs
@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
-use super::{Ctx, Service, ServiceCall, ServiceFactory};
+use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
@@ -60,7 +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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         ThenServiceResponse {
             slf: self,
             state: State::A {
@@ -95,7 +95,7 @@ pin_project_lite::pin_project! {
         B: 'f,
         R: 'f,
     {
-        A { #[pin] fut: ServiceCall<'f, A, R>, ctx: Ctx<'f, Then<A, B>> },
+        A { #[pin] fut: ServiceCall<'f, A, R>, ctx: ServiceCtx<'f, Then<A, B>> },
         B { #[pin] fut: ServiceCall<'f, B, Result<A::Response, A::Error>> },
         Empty,
     }
@@ -248,7 +248,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
     use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
 
-    use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
+    use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
@@ -266,7 +266,7 @@ mod tests {
         fn call<'a>(
             &'a self,
             req: Result<&'static str, &'static str>,
-            _: Ctx<'a, Self>,
+            _: ServiceCtx<'a, Self>,
         ) -> Self::Future<'a> {
             match req {
                 Ok(msg) => Ready::Ok(msg),
@@ -291,7 +291,7 @@ mod tests {
         fn call<'a>(
             &'a self,
             req: Result<&'static str, ()>,
-            _: Ctx<'a, Self>,
+            _: ServiceCtx<'a, Self>,
         ) -> Self::Future<'a> {
             match req {
                 Ok(msg) => Ready::Ok((msg, "ok")),
diff --git a/ntex-tls/Cargo.toml b/ntex-tls/Cargo.toml
index 4e99892c..87816fa0 100644
--- a/ntex-tls/Cargo.toml
+++ b/ntex-tls/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "0.3.0-beta.0"
+version = "0.3.0-beta.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "An implementation of SSL streams for ntex backed by OpenSSL"
 keywords = ["network", "framework", "async", "futures"]
@@ -26,9 +26,9 @@ rustls = ["tls_rust"]
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.3.0-beta.0"
-ntex-util = "0.3.0-beta.0"
-ntex-service = "1.2.0-beta.0"
+ntex-io = "0.3.0-beta.1"
+ntex-util = "0.3.0-beta.1"
+ntex-service = "1.2.0-beta.1"
 log = "0.4"
 pin-project-lite = "0.2"
 
@@ -39,7 +39,7 @@ tls_openssl = { version = "0.10", package = "openssl", optional = true }
 tls_rust = { version = "0.21", package = "rustls", optional = true }
 
 [dev-dependencies]
-ntex = { version = "0.7.0-beta.0", features = ["openssl", "rustls", "tokio"] }
+ntex = { version = "0.7.0-beta.1", features = ["openssl", "rustls", "tokio"] }
 env_logger = "0.10"
 rustls-pemfile = { version = "1.0" }
 webpki-roots = { version = "0.23" }
diff --git a/ntex-tls/src/openssl/accept.rs b/ntex-tls/src/openssl/accept.rs
index 582de060..fd68aff3 100644
--- a/ntex-tls/src/openssl/accept.rs
+++ b/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::{Ctx, Service, ServiceFactory};
+use ntex_service::{Service, ServiceCtx, 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<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         AcceptorServiceResponse {
             _guard: self.conns.get(),
             fut: self.acceptor.clone().create(req),
diff --git a/ntex-tls/src/rustls/accept.rs b/ntex-tls/src/rustls/accept.rs
index ae30db87..3be86df4 100644
--- a/ntex-tls/src/rustls/accept.rs
+++ b/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::{Ctx, Service, ServiceFactory};
+use ntex_service::{Service, ServiceCtx, 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<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         AcceptorServiceFut {
             _guard: self.conns.get(),
             fut: self.acceptor.clone().create(req),
diff --git a/ntex-util/Cargo.toml b/ntex-util/Cargo.toml
index 2b68383d..a3927a7d 100644
--- a/ntex-util/Cargo.toml
+++ b/ntex-util/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-util"
-version = "0.3.0-beta.0"
+version = "0.3.0-beta.1"
 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.2.0-beta.0"
+ntex-service = "1.2.0-beta.1"
 bitflags = "1.3"
 fxhash = "0.2.1"
 log = "0.4"
diff --git a/ntex-util/src/services/buffer.rs b/ntex-util/src/services/buffer.rs
index 0d935eab..35775448 100644
--- a/ntex-util/src/services/buffer.rs
+++ b/ntex-util/src/services/buffer.rs
@@ -3,7 +3,7 @@ use std::cell::{Cell, RefCell};
 use std::task::{ready, Context, Poll};
 use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin};
 
-use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
+use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
 
 use crate::{channel::oneshot, future::Either, task::LocalWaker};
 
@@ -138,7 +138,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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         if self.ready.get() {
             self.ready.set(false);
             Either::Left(ctx.call(&self.service, req))
@@ -220,7 +220,7 @@ mod tests {
             }
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             self.0.ready.set(false);
             self.0.count.set(self.0.count.get() + 1);
             Ready::Ok(())
diff --git a/ntex-util/src/services/inflight.rs b/ntex-util/src/services/inflight.rs
index 01d28506..83f93bec 100644
--- a/ntex-util/src/services/inflight.rs
+++ b/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::{Ctx, IntoService, Middleware, Service, ServiceCall};
+use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
 
 use super::counter::{Counter, CounterGuard};
 
@@ -76,7 +76,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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         InFlightServiceResponse {
             fut: ctx.call(&self.service, req),
             _guard: self.count.get(),
@@ -109,7 +109,7 @@ impl<'f, T: Service<R>, R> Future for InFlightServiceResponse<'f, T, R> {
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Service, ServiceCtx, ServiceFactory};
     use std::{cell::RefCell, task::Poll, time::Duration};
 
     use super::*;
@@ -122,7 +122,7 @@ mod tests {
         type Error = ();
         type Future<'f> = BoxFuture<'f, Result<(), ()>>;
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Box::pin(async move {
                 let _ = self.0.recv().await;
                 Ok::<_, ()>(())
diff --git a/ntex-util/src/services/keepalive.rs b/ntex-util/src/services/keepalive.rs
index f27e3ac0..024e70ad 100644
--- a/ntex-util/src/services/keepalive.rs
+++ b/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::{Ctx, Service, ServiceFactory};
+use ntex_service::{Service, ServiceCtx, ServiceFactory};
 
 use crate::future::Ready;
 use crate::time::{now, sleep, Millis, Sleep};
@@ -113,7 +113,7 @@ where
         }
     }
 
-    fn call<'a>(&'a self, req: R, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: R, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         self.expire.set(now());
         Ready::Ok(req)
     }
diff --git a/ntex-util/src/services/onerequest.rs b/ntex-util/src/services/onerequest.rs
index 0554ba7b..e9a37098 100644
--- a/ntex-util/src/services/onerequest.rs
+++ b/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::{Ctx, IntoService, Middleware, Service, ServiceCall};
+use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
 
 use crate::task::LocalWaker;
 
@@ -63,7 +63,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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         self.ready.set(false);
 
         OneRequestServiceResponse {
@@ -101,7 +101,7 @@ impl<'f, T: Service<R>, R> Future for OneRequestServiceResponse<'f, T, R> {
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Container, Service, ServiceCtx, ServiceFactory};
     use std::{cell::RefCell, task::Poll, time::Duration};
 
     use super::*;
@@ -114,7 +114,7 @@ mod tests {
         type Error = ();
         type Future<'f> = BoxFuture<'f, Result<(), ()>>;
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Box::pin(async move {
                 let _ = self.0.recv().await;
                 Ok::<_, ()>(())
diff --git a/ntex-util/src/services/timeout.rs b/ntex-util/src/services/timeout.rs
index 3e3c6de5..d2a02e05 100644
--- a/ntex-util/src/services/timeout.rs
+++ b/ntex-util/src/services/timeout.rs
@@ -4,7 +4,7 @@
 //! will be aborted.
 use std::{fmt, future::Future, marker, pin::Pin, task::Context, task::Poll};
 
-use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
+use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
 
 use crate::future::Either;
 use crate::time::{sleep, Millis, Sleep};
@@ -125,7 +125,7 @@ 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<'a>(&'a self, request: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, request: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         if self.timeout.is_zero() {
             Either::Right(TimeoutServiceResponse2 {
                 fut: ctx.call(&self.service, request),
@@ -236,7 +236,7 @@ mod tests {
         type Error = SrvError;
         type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             let fut = crate::time::sleep(self.0);
             Box::pin(async move {
                 fut.await;
diff --git a/ntex-util/src/services/variant.rs b/ntex-util/src/services/variant.rs
index 35f9f319..a5158480 100644
--- a/ntex-util/src/services/variant.rs
+++ b/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::{Ctx, IntoServiceFactory, Service, ServiceCall, ServiceFactory};
+use ntex_service::{IntoServiceFactory, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
 /// Construct `Variant` service factory.
 ///
@@ -128,7 +128,7 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
             }
         }
 
-        fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: Ctx<'a, Self>) -> Self::Future<'a>
+        fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>
         {
             match req {
                 $enum_type::V1(req) => $mod_name::ServiceResponse::V1 { fut: ctx.call(&self.V1, req) },
@@ -321,7 +321,7 @@ mod tests {
             Poll::Ready(())
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::<_, ()>::Ok(1)
         }
     }
@@ -342,7 +342,7 @@ mod tests {
             Poll::Ready(())
         }
 
-        fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::<_, ()>::Ok(2)
         }
     }
diff --git a/ntex/CHANGES.md b/ntex/CHANGES.md
index bb53943f..3e6a94cf 100644
--- a/ntex/CHANGES.md
+++ b/ntex/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [0.7.0-beta.1] - 2023-06-19
+
+* Rename Ctx to ServiceCtx
+
 ## [0.7.0-beta.0] - 2023-06-16
 
 * Migrate to ntex-service 1.2
diff --git a/ntex/Cargo.toml b/ntex/Cargo.toml
index ca77993e..8de59592 100644
--- a/ntex/Cargo.toml
+++ b/ntex/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex"
-version = "0.7.0-beta.0"
+version = "0.7.0-beta.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Framework for composable network services"
 readme = "README.md"
@@ -49,17 +49,17 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
 
 [dependencies]
 ntex-codec = "0.6.2"
-ntex-connect = "0.3.0-beta.0"
+ntex-connect = "0.3.0-beta.1"
 ntex-http = "0.1.9"
 ntex-router = "0.5.1"
-ntex-service = "1.2.0-beta.0"
+ntex-service = "1.2.0-beta.1"
 ntex-macros = "0.1.3"
-ntex-util = "0.3.0-beta.0"
+ntex-util = "0.3.0-beta.1"
 ntex-bytes = "0.1.19"
-ntex-h2 = "0.3.0-beta.0"
+ntex-h2 = "0.3.0-beta.1"
 ntex-rt = "0.4.9"
-ntex-io = "0.3.0-beta.0"
-ntex-tls = "0.3.0-beta.0"
+ntex-io = "0.3.0-beta.1"
+ntex-tls = "0.3.0-beta.1"
 ntex-tokio = { version = "0.3.0-beta.0", optional = true }
 ntex-glommio = { version = "0.3.0-beta.0", optional = true }
 ntex-async-std = { version = "0.3.0-beta.0", optional = true }
diff --git a/ntex/src/http/client/connector.rs b/ntex/src/http/client/connector.rs
index e8e6d7f2..83cad5a4 100644
--- a/ntex/src/http/client/connector.rs
+++ b/ntex/src/http/client/connector.rs
@@ -3,7 +3,7 @@ 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, Ctx, Service, ServiceCall};
+use crate::service::{apply_fn, boxed, Service, ServiceCall, ServiceCtx};
 use crate::time::{Millis, Seconds};
 use crate::util::{timeout::TimeoutError, timeout::TimeoutService, Either, Ready};
 use crate::{http::Uri, io::IoBoxed};
@@ -315,7 +315,7 @@ where
         }
     }
 
-    fn call<'a>(&'a self, req: Connect, ctx: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect, ctx: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         match req.uri.scheme_str() {
             Some("https") | Some("wss") => {
                 if let Some(ref conn) = self.ssl_pool {
diff --git a/ntex/src/http/client/h2proto.rs b/ntex/src/http/client/h2proto.rs
index 46ac5435..d430ab80 100644
--- a/ntex/src/http/client/h2proto.rs
+++ b/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::Ctx, service::Service};
+use crate::{channel::oneshot, Service, ServiceCtx};
 
 use super::error::SendRequestError;
 
@@ -226,7 +226,11 @@ impl Service<h2::Message> for H2PublishService {
     type Error = &'static str;
     type Future<'f> = Ready<Self::Response, Self::Error>;
 
-    fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        mut msg: h2::Message,
+        _: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         match msg.kind().take() {
             h2::MessageKind::Headers {
                 pseudo,
diff --git a/ntex/src/http/client/pool.rs b/ntex/src/http/client/pool.rs
index dbda2292..aa69b279 100644
--- a/ntex/src/http/client/pool.rs
+++ b/ntex/src/http/client/pool.rs
@@ -6,7 +6,7 @@ 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::service::{Container, Service, ServiceCall, ServiceCtx};
 use crate::time::{now, Millis};
 use crate::util::{ready, BoxFuture, ByteString, HashMap, HashSet};
 use crate::{channel::pool, rt::spawn, task::LocalWaker};
@@ -121,7 +121,7 @@ where
     crate::forward_poll_ready!(connector);
     crate::forward_poll_shutdown!(connector);
 
-    fn call<'a>(&'a self, req: Connect, _: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Connect, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         trace!("Get connection for {:?}", req.uri);
         let inner = self.inner.clone();
         let waiters = self.waiters.clone();
diff --git a/ntex/src/http/h1/expect.rs b/ntex/src/http/h1/expect.rs
index d32b83ab..1f36603c 100644
--- a/ntex/src/http/h1/expect.rs
+++ b/ntex/src/http/h1/expect.rs
@@ -1,6 +1,6 @@
 use std::io;
 
-use crate::service::{Ctx, Service, ServiceFactory};
+use crate::service::{Service, ServiceCtx, ServiceFactory};
 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<'a>(&'a self, req: Request, _: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, req: Request, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         Ready::Ok(req)
     }
 }
diff --git a/ntex/src/http/h1/service.rs b/ntex/src/http/h1/service.rs
index af973f7a..4bdafc0c 100644
--- a/ntex/src/http/h1/service.rs
+++ b/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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 use crate::{time::Millis, util::BoxFuture};
 
 use super::codec::Codec;
@@ -331,7 +331,7 @@ where
         }
     }
 
-    fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         log::trace!(
             "New http1 connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()
diff --git a/ntex/src/http/h1/upgrade.rs b/ntex/src/http/h1/upgrade.rs
index 55e899cb..72208d56 100644
--- a/ntex/src/http/h1/upgrade.rs
+++ b/ntex/src/http/h1/upgrade.rs
@@ -1,7 +1,8 @@
 use std::{io, marker::PhantomData};
 
 use crate::http::{h1::Codec, request::Request};
-use crate::{io::Io, service::Ctx, service::Service, service::ServiceFactory, util::Ready};
+use crate::service::{Service, ServiceCtx, ServiceFactory};
+use crate::{io::Io, util::Ready};
 
 pub struct UpgradeHandler<F>(PhantomData<F>);
 
@@ -28,7 +29,7 @@ impl<F> Service<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
     fn call<'a>(
         &'a self,
         _: (Request, Io<F>, Codec),
-        _: Ctx<'a, Self>,
+        _: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         unimplemented!()
     }
diff --git a/ntex/src/http/h2/service.rs b/ntex/src/http/h2/service.rs
index d4f78c6d..6ad57df5 100644
--- a/ntex/src/http/h2/service.rs
+++ b/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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{IntoServiceFactory, Service, ServiceCtx, 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<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
+    fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
         log::trace!(
             "New http2 connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()
@@ -233,7 +233,7 @@ impl Service<h2::ControlMessage<H2Error>> for ControlService {
     fn call<'a>(
         &'a self,
         msg: h2::ControlMessage<H2Error>,
-        _: Ctx<'a, Self>,
+        _: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         log::trace!("Control message: {:?}", msg);
         Ready::Ok::<_, ()>(msg.ack())
@@ -280,7 +280,11 @@ where
         Ready<Self::Response, Self::Error>,
     >;
 
-    fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        mut msg: h2::Message,
+        _: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         let (io, pseudo, headers, eof, payload) = match msg.kind().take() {
             h2::MessageKind::Headers {
                 pseudo,
diff --git a/ntex/src/http/service.rs b/ntex/src/http/service.rs
index 19896c21..98103293 100644
--- a/ntex/src/http/service.rs
+++ b/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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
+use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 use crate::time::{Millis, Seconds};
 use crate::util::BoxFuture;
 
@@ -368,7 +368,7 @@ where
         }
     }
 
-    fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         log::trace!(
             "New http connection, peer address {:?}",
             io.query::<types::PeerAddr>().get()
diff --git a/ntex/src/lib.rs b/ntex/src/lib.rs
index 99e3d603..d67806db 100644
--- a/ntex/src/lib.rs
+++ b/ntex/src/lib.rs
@@ -38,8 +38,8 @@ pub mod web;
 pub mod ws;
 
 pub use self::service::{
-    fn_service, into_service, pipeline, pipeline_factory, Container, Ctx, IntoService,
-    IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory,
+    fn_service, into_service, pipeline, pipeline_factory, Container, IntoService,
+    IntoServiceFactory, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory,
 };
 
 pub use ntex_util::{channel, task};
diff --git a/ntex/src/server/service.rs b/ntex/src/server/service.rs
index 501472ad..e9a8d72e 100644
--- a/ntex/src/server/service.rs
+++ b/ntex/src/server/service.rs
@@ -2,7 +2,7 @@ use std::{net::SocketAddr, rc::Rc, task::Context, task::Poll};
 
 use log::error;
 
-use crate::service::{boxed, Ctx, Service, ServiceFactory};
+use crate::service::{boxed, Service, ServiceCtx, ServiceFactory};
 use crate::util::{BoxFuture, Pool, PoolId};
 use crate::{io::Io, time::Millis};
 
@@ -74,7 +74,7 @@ where
     fn call<'a>(
         &'a self,
         (guard, req): (Option<CounterGuard>, ServerMessage),
-        ctx: Ctx<'a, Self>,
+        ctx: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         Box::pin(async move {
             match req {
diff --git a/ntex/src/server/worker.rs b/ntex/src/server/worker.rs
index 0d8241d9..f18ab90b 100644
--- a/ntex/src/server/worker.rs
+++ b/ntex/src/server/worker.rs
@@ -512,7 +512,7 @@ mod tests {
     use super::*;
     use crate::io::Io;
     use crate::server::service::Factory;
-    use crate::service::{Ctx, Service, ServiceFactory};
+    use crate::service::{Service, ServiceCtx, ServiceFactory};
     use crate::util::{lazy, Ready};
 
     #[derive(Clone, Copy, Debug)]
@@ -572,7 +572,7 @@ mod tests {
             }
         }
 
-        fn call<'a>(&'a self, _: Io, _: Ctx<'a, Self>) -> Self::Future<'a> {
+        fn call<'a>(&'a self, _: Io, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
             Ready::Ok(())
         }
     }
diff --git a/ntex/src/web/app.rs b/ntex/src/web/app.rs
index 19fb3492..bc14c4cc 100644
--- a/ntex/src/web/app.rs
+++ b/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::{Ctx, Identity, Middleware, Service, ServiceFactory, Stack};
+use crate::service::{Identity, Middleware, Service, ServiceCtx, ServiceFactory, Stack};
 use crate::util::{BoxFuture, Extensions, Ready};
 
 use super::app_service::{AppFactory, AppService};
@@ -581,7 +581,11 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
     type Future<'f> = Ready<WebRequest<Err>, Err::Container>;
 
     #[inline]
-    fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<Err>,
+        _: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         Ready::Ok(req)
     }
 }
diff --git a/ntex/src/web/app_service.rs b/ntex/src/web/app_service.rs
index bfc9fefd..84895dc9 100644
--- a/ntex/src/web/app_service.rs
+++ b/ntex/src/web/app_service.rs
@@ -5,7 +5,8 @@ use crate::http::{Request, Response};
 use crate::router::{Path, ResourceDef, Router};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
 use crate::service::{
-    fn_service, Ctx, Middleware, PipelineFactory, Service, ServiceCall, ServiceFactory,
+    fn_service, Middleware, PipelineFactory, Service, ServiceCall, ServiceCtx,
+    ServiceFactory,
 };
 use crate::util::{BoxFuture, Either, Extensions};
 
@@ -205,7 +206,7 @@ where
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call<'a>(&'a self, req: Request, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(&'a self, req: Request, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
         let (head, payload) = req.into_parts();
 
         let req = if let Some(mut req) = self.pool.get_request() {
@@ -253,7 +254,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
     fn call<'a>(
         &'a self,
         mut req: WebRequest<Err>,
-        ctx: Ctx<'a, Self>,
+        ctx: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         let res = self.router.recognize_checked(&mut req, |req, guards| {
             if let Some(guards) = guards {
@@ -305,7 +306,11 @@ where
         }
     }
 
-    fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<Err>,
+        ctx: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         AppServiceResponse {
             filter: ctx.call(&self.filter, req),
             routing: &self.routing,
@@ -326,7 +331,7 @@ pin_project_lite::pin_project! {
         filter: ServiceCall<'f, F, WebRequest<Err>>,
         routing: &'f AppRouting<Err>,
         endpoint: Option<BoxAppServiceResponse<'f, Err>>,
-        ctx: Ctx<'f, AppService<F, Err>>,
+        ctx: ServiceCtx<'f, AppService<F, Err>>,
     }
 }
 
diff --git a/ntex/src/web/middleware/compress.rs b/ntex/src/web/middleware/compress.rs
index 9cc2626d..131fe52a 100644
--- a/ntex/src/web/middleware/compress.rs
+++ b/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::{Ctx, Middleware, Service, ServiceCall};
+use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
 use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
 
 #[derive(Debug, Clone)]
@@ -71,7 +71,11 @@ where
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<E>,
+        ctx: ServiceCtx<'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() {
diff --git a/ntex/src/web/middleware/defaultheaders.rs b/ntex/src/web/middleware/defaultheaders.rs
index 4fdd76d5..f5846173 100644
--- a/ntex/src/web/middleware/defaultheaders.rs
+++ b/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::{Ctx, Middleware, Service};
+use crate::service::{Middleware, Service, ServiceCtx};
 use crate::util::BoxFuture;
 use crate::web::{WebRequest, WebResponse};
 
@@ -115,7 +115,11 @@ where
     crate::forward_poll_ready!(service);
     crate::forward_poll_shutdown!(service);
 
-    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<E>,
+        ctx: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         Box::pin(async move {
             let mut res = ctx.call(&self.service, req).await?;
 
diff --git a/ntex/src/web/middleware/logger.rs b/ntex/src/web/middleware/logger.rs
index cefdc82a..4eb2ef2a 100644
--- a/ntex/src/web/middleware/logger.rs
+++ b/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::{Ctx, Middleware, Service, ServiceCall};
+use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
 use crate::util::{Bytes, Either, HashSet};
 use crate::web::{HttpResponse, WebRequest, WebResponse};
 
@@ -142,7 +142,11 @@ where
     crate::forward_poll_shutdown!(service);
 
     #[inline]
-    fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<E>,
+        ctx: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         if self.inner.exclude.contains(req.path()) {
             Either::Right(ctx.call(&self.service, req))
         } else {
diff --git a/ntex/src/web/resource.rs b/ntex/src/web/resource.rs
index eb4248eb..4521e0d3 100644
--- a/ntex/src/web/resource.rs
+++ b/ntex/src/web/resource.rs
@@ -4,7 +4,7 @@ use crate::http::Response;
 use crate::router::{IntoPattern, ResourceDef};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
 use crate::service::{
-    dev::AndThen, pipeline, pipeline_factory, Ctx, Pipeline, PipelineFactory,
+    dev::AndThen, pipeline, pipeline_factory, Pipeline, PipelineFactory, ServiceCtx,
 };
 use crate::service::{
     Identity, IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory, Stack,
@@ -480,7 +480,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
     fn call<'a>(
         &'a self,
         mut req: WebRequest<Err>,
-        ctx: Ctx<'a, Self>,
+        ctx: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         for route in self.routes.iter() {
             if route.check(&mut req) {
diff --git a/ntex/src/web/route.rs b/ntex/src/web/route.rs
index 08e8a38a..8deb1224 100644
--- a/ntex/src/web/route.rs
+++ b/ntex/src/web/route.rs
@@ -1,7 +1,7 @@
 use std::{mem, rc::Rc};
 
 use crate::util::{BoxFuture, Ready};
-use crate::{http::Method, service::Ctx, service::Service, service::ServiceFactory};
+use crate::{http::Method, service::Service, service::ServiceCtx, service::ServiceFactory};
 
 use super::error::ErrorRenderer;
 use super::error_default::DefaultError;
@@ -90,7 +90,11 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for RouteService<Err> {
     type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
     #[inline]
-    fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<Err>,
+        _: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         self.handler.call(req)
     }
 }
diff --git a/ntex/src/web/scope.rs b/ntex/src/web/scope.rs
index f2fa3513..24033702 100644
--- a/ntex/src/web/scope.rs
+++ b/ntex/src/web/scope.rs
@@ -7,7 +7,7 @@ use crate::router::{IntoPattern, ResourceDef, Router};
 use crate::service::boxed::{self, BoxService, BoxServiceFactory};
 use crate::service::{pipeline_factory, IntoServiceFactory, PipelineFactory};
 use crate::service::{
-    Ctx, Identity, Middleware, Service, ServiceCall, ServiceFactory, Stack,
+    Identity, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory, Stack,
 };
 use crate::util::{BoxFuture, Either, Extensions, Ready};
 
@@ -505,7 +505,11 @@ where
         }
     }
 
-    fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
+    fn call<'a>(
+        &'a self,
+        req: WebRequest<Err>,
+        ctx: ServiceCtx<'a, Self>,
+    ) -> Self::Future<'a> {
         ScopeServiceResponse {
             filter: ctx.call(&self.filter, req),
             routing: &self.routing,
@@ -522,7 +526,7 @@ pin_project_lite::pin_project! {
         #[pin]
         filter: ServiceCall<'f, F, WebRequest<Err>>,
         routing: &'f ScopeRouter<Err>,
-        ctx: Ctx<'f, ScopeService<F, Err>>,
+        ctx: ServiceCtx<'f, ScopeService<F, Err>>,
         endpoint: Option<ServiceCall<'f, ScopeRouter<Err>, WebRequest<Err>>>,
     }
 }
@@ -608,7 +612,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
     fn call<'a>(
         &'a self,
         mut req: WebRequest<Err>,
-        ctx: Ctx<'a, Self>,
+        ctx: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         let res = self.router.recognize_checked(&mut req, |req, guards| {
             if let Some(guards) = guards {
diff --git a/ntex/tests/http_ws.rs b/ntex/tests/http_ws.rs
index f51f128f..60019140 100644
--- a/ntex/tests/http_ws.rs
+++ b/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, Ctx, Service};
+use ntex::service::{fn_factory, Service, ServiceCtx};
 use ntex::util::{BoxFuture, ByteString, Bytes, Ready};
 use ntex::ws::{self, handshake, handshake_response};
 
@@ -43,7 +43,7 @@ impl Service<(Request, Io, h1::Codec)> for WsService {
     fn call<'a>(
         &'a self,
         (req, io, codec): (Request, Io, h1::Codec),
-        _: Ctx<'a, Self>,
+        _: ServiceCtx<'a, Self>,
     ) -> Self::Future<'a> {
         let fut = async move {
             let res = handshake(req.head()).unwrap().message_body(());