Migrate ntex-connect to async fn in trait

ntex-async-std/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-async-std"
-version = "0.3.2"
+version = "0.4.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.21"
-ntex-io = "0.3.6"
+ntex-io = "1.0"
-ntex-util = "0.3.4"
+ntex-util = "1.0"
 log = "0.4"
 pin-project-lite = "0.2"
 async-std = { version = "1", features = ["unstable"] }

ntex-connect/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.0.0] - 2024-01-0x
+
+* Use "async fn" in trait for Service definition
+
 ## [0.3.4] - 2023-12-14
 
 * Better io tag handling

ntex-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-connect"
-version = "0.3.4"
+version = "1.0.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork connect utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -34,19 +34,20 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
 async-std = ["ntex-rt/async-std", "ntex-async-std"]
 
 [dependencies]
-ntex-service = "1.2.7"
+ntex-service = "2.0"
+ntex-io = "1.0"
+ntex-tls = "1.0"
+ntex-util = "1.0"
 ntex-bytes = "0.1.21"
-ntex-http = "0.1.11"
+ntex-http = "0.1"
-ntex-io = "0.3.16"
 ntex-rt = "0.4.7"
-ntex-tls = "0.3.3"
+
-ntex-util = "0.3.4"
 log = "0.4"
 thiserror = "1.0"
 
-ntex-tokio = { version = "0.3.0", optional = true }
+ntex-tokio = { version = "0.4", optional = true }
-ntex-glommio = { version = "0.3.0", optional = true }
+ntex-glommio = { version = "0.4", optional = true }
-ntex-async-std = { version = "0.3.0", optional = true }
+ntex-async-std = { version = "0.4", optional = true }
 
 # openssl
 tls-openssl = { version="0.10", package = "openssl", optional = true }

ntex-connect/src/lib.rs

@@ -1,9 +1,6 @@
 //! Tcp connector service
 #![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
 
-#[macro_use]
-extern crate log;
-
 mod error;
 mod message;
 mod resolve;
@@ -29,8 +26,7 @@ where
     T: Address,
     Connect<T>: From<U>,
 {
-    service::ConnectServiceResponse::new(Box::pin(Resolver::new().lookup(message.into())))
+    Connector::new().connect(message).await
-        .await
 }
 
 #[allow(unused_imports)]

ntex-connect/src/openssl.rs

@@ -7,7 +7,6 @@ use ntex_bytes::PoolId;
 use ntex_io::{FilterFactory, Io, Layer};
 use ntex_service::{Pipeline, Service, ServiceCtx, ServiceFactory};
 use ntex_tls::openssl::SslConnector as IoSslConnector;
-use ntex_util::future::{BoxFuture, Ready};
 
 use super::{Address, Connect, ConnectError, Connector as BaseConnector};
 
@@ -56,7 +55,7 @@ impl<T: Address> Connector<T> {
         let openssl = self.openssl.clone();
 
         let io = conn.await?;
-        trace!("{}: SSL Handshake start for: {:?}", io.tag(), host);
+        log::trace!("{}: SSL Handshake start for: {:?}", io.tag(), host);
 
         match openssl.configure() {
             Err(e) => Err(io::Error::new(io::ErrorKind::Other, e).into()),
@@ -67,11 +66,11 @@ impl<T: Address> Connector<T> {
                 let tag = io.tag();
                 match IoSslConnector::new(ssl).create(io).await {
                     Ok(io) => {
-                        trace!("{}: SSL Handshake success: {:?}", tag, host);
+                        log::trace!("{}: SSL Handshake success: {:?}", tag, host);
                         Ok(io)
                     }
                     Err(e) => {
-                        trace!("{}: SSL Handshake error: {:?}", tag, e);
+                        log::trace!("{}: SSL Handshake error: {:?}", tag, e);
                         Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)).into())
                     }
                 }
@@ -103,22 +102,22 @@ impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Error = ConnectError;
     type Service = Connector<T>;
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
+        Ok(self.clone())
-        Ready::Ok(self.clone())
     }
 }
 
 impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Response = Io<Layer<SslFilter>>;
     type Error = ConnectError;
-    type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
-    #[inline]
+    async fn call(
-    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+        &self,
-        Box::pin(self.connect(req))
+        req: Connect<T>,
+        _: ServiceCtx<'_, Self>,
+    ) -> Result<Self::Response, Self::Error> {
+        self.connect(req).await
     }
 }
 

ntex-connect/src/resolve.rs

@@ -2,7 +2,7 @@ use std::{fmt, io, marker, net};
 
 use ntex_rt::spawn_blocking;
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::future::{BoxFuture, Either, Ready};
+use ntex_util::future::Either;
 
 use crate::{Address, Connect, ConnectError};
 
@@ -26,7 +26,7 @@ impl<T: Address> Resolver<T> {
             req.addr = Some(Either::Left(net::SocketAddr::new(ip, req.port())));
             Ok(req)
         } else {
-            trace!("DNS resolver: resolving host {:?}", req.host());
+            log::trace!("DNS resolver: resolving host {:?}", req.host());
 
             let host = if req.host().contains(':') {
                 req.host().to_string()
@@ -43,7 +43,7 @@ impl<T: Address> Resolver<T> {
                         ip
                     }));
 
-                    trace!(
+                    log::trace!(
                         "DNS resolver: host {:?} resolved to {:?}",
                         req.host(),
                         req.addrs()
@@ -56,7 +56,7 @@ impl<T: Address> Resolver<T> {
                     }
                 }
                 Ok(Err(e)) => {
-                    trace!(
+                    log::trace!(
                         "DNS resolver: failed to resolve host {:?} err: {}",
                         req.host(),
                         e
@@ -64,7 +64,7 @@ impl<T: Address> Resolver<T> {
                     Err(ConnectError::Resolver(e))
                 }
                 Err(e) => {
-                    trace!(
+                    log::trace!(
                         "DNS resolver: failed to resolve host {:?} err: {}",
                         req.host(),
                         e
@@ -102,22 +102,22 @@ impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Resolver<T> {
     type Error = ConnectError;
     type Service = Resolver<T>;
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError>;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
+        Ok(self.clone())
-        Ready::Ok(self.clone())
     }
 }
 
 impl<T: Address> Service<Connect<T>> for Resolver<T> {
     type Response = Connect<T>;
     type Error = ConnectError;
-    type Future<'f> = BoxFuture<'f, Result<Connect<T>, Self::Error>>;
 
-    #[inline]
+    async fn call(
-    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
+        &self,
-        Box::pin(self.lookup(req))
+        req: Connect<T>,
+        _: ServiceCtx<'_, Self>,
+    ) -> Result<Connect<T>, Self::Error> {
+        self.lookup(req).await
     }
 }
 

ntex-connect/src/rustls.rs

@@ -7,7 +7,6 @@ use ntex_bytes::PoolId;
 use ntex_io::{FilterFactory, Io, Layer};
 use ntex_service::{Pipeline, Service, ServiceCtx, ServiceFactory};
 use ntex_tls::rustls::TlsConnector;
-use ntex_util::future::{BoxFuture, Ready};
 
 use super::{Address, Connect, ConnectError, Connector as BaseConnector};
 
@@ -64,7 +63,7 @@ impl<T: Address + 'static> Connector<T> {
         let connector = self.inner.clone();
 
         let io = conn.await?;
-        trace!("{}: SSL Handshake start for: {:?}", io.tag(), host);
+        log::trace!("{}: SSL Handshake start for: {:?}", io.tag(), host);
 
         let tag = io.tag();
         let host = ServerName::try_from(host.as_str())
@@ -73,11 +72,11 @@ impl<T: Address + 'static> Connector<T> {
 
         match connector.create(io).await {
             Ok(io) => {
-                trace!("{}: TLS Handshake success: {:?}", tag, &host);
+                log::trace!("{}: TLS Handshake success: {:?}", tag, &host);
                 Ok(io)
             }
             Err(e) => {
-                trace!("{}: TLS Handshake error: {:?}", tag, e);
+                log::trace!("{}: TLS Handshake error: {:?}", tag, e);
                 Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)).into())
             }
         }
@@ -106,21 +105,22 @@ impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Error = ConnectError;
     type Service = Connector<T>;
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError> where C: 'f;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
+        Ok(self.clone())
-        Ready::Ok(self.clone())
     }
 }
 
 impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Response = Io<Layer<TlsFilter>>;
     type Error = ConnectError;
-    type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
 
-    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+    async fn call(
-        Box::pin(self.connect(req))
+        &self,
+        req: Connect<T>,
+        _: ServiceCtx<'_, Self>,
+    ) -> Result<Self::Response, Self::Error> {
+        self.connect(req).await
     }
 }
 

ntex-connect/src/service.rs

@@ -4,7 +4,7 @@ use std::{collections::VecDeque, fmt, future::Future, io, net::SocketAddr, pin::
 use ntex_bytes::{PoolId, PoolRef};
 use ntex_io::{types, Io};
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::future::{BoxFuture, Either, Ready};
+use ntex_util::future::{BoxFuture, Either};
 
 use crate::{net::tcp_connect_in, Address, Connect, ConnectError, Resolver};
 
@@ -16,12 +16,12 @@ pub struct Connector<T> {
 }
 
 impl<T> Connector<T> {
-    /// Construct new connect service with custom dns resolver
+    /// Construct new connect service with default dns resolver
     pub fn new() -> Self {
         Connector {
             resolver: Resolver::new(),
             pool: PoolId::P0.pool_ref(),
-            tag: "",
+            tag: "TCP-CLIENT",
         }
     }
 
@@ -49,12 +49,27 @@ impl<T: Address> Connector<T> {
     where
         Connect<T>: From<U>,
     {
-        ConnectServiceResponse {
+        // resolve first
-            state: ConnectState::Resolve(Box::pin(self.resolver.lookup(message.into()))),
+        let address = self.resolver.lookup(message.into()).await?;
-            tag: self.tag,
+
-            pool: self.pool,
+        let port = address.port();
+        let Connect { req, addr, .. } = address;
+
+        if let Some(addr) = addr {
+            TcpConnectorResponse::new(req, port, addr, self.tag, self.pool).await
+        } else if let Some(addr) = req.addr() {
+            TcpConnectorResponse::new(
+                req,
+                addr.port(),
+                Either::Left(addr),
+                self.tag,
+                self.pool,
+            )
+            .await
+        } else {
+            log::error!("{}: TCP connector: got unresolved address", self.tag);
+            Err(ConnectError::Unresolved)
         }
-        .await
     }
 }
 
@@ -89,93 +104,22 @@ impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Error = ConnectError;
     type Service = Connector<T>;
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
+        Ok(self.clone())
-        Ready::Ok(self.clone())
     }
 }
 
 impl<T: Address> Service<Connect<T>> for Connector<T> {
     type Response = Io;
     type Error = ConnectError;
-    type Future<'f> = ConnectServiceResponse<'f, T>;
 
-    #[inline]
+    async fn call(
-    fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+        &self,
-        ConnectServiceResponse {
+        req: Connect<T>,
-            state: ConnectState::Resolve(Box::pin(self.resolver.lookup(req))),
+        _: ServiceCtx<'_, Self>,
-            pool: PoolId::P0.pool_ref(),
+    ) -> Result<Self::Response, Self::Error> {
-            tag: self.tag,
+        self.connect(req).await
-        }
-    }
-}
-
-enum ConnectState<'f, T: Address> {
-    Resolve(BoxFuture<'f, Result<Connect<T>, ConnectError>>),
-    Connect(TcpConnectorResponse<T>),
-}
-
-#[doc(hidden)]
-pub struct ConnectServiceResponse<'f, T: Address> {
-    state: ConnectState<'f, T>,
-    pool: PoolRef,
-    tag: &'static str,
-}
-
-impl<'f, T: Address> ConnectServiceResponse<'f, T> {
-    pub(super) fn new(fut: BoxFuture<'f, Result<Connect<T>, ConnectError>>) -> Self {
-        Self {
-            state: ConnectState::Resolve(fut),
-            pool: PoolId::P0.pool_ref(),
-            tag: "",
-        }
-    }
-}
-
-impl<'f, T: Address> fmt::Debug for ConnectServiceResponse<'f, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ConnectServiceResponse")
-            .field("tag", &self.tag)
-            .field("pool", &self.pool)
-            .finish()
-    }
-}
-
-impl<'f, T: Address> Future for ConnectServiceResponse<'f, T> {
-    type Output = Result<Io, ConnectError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.state {
-            ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx)? {
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(address) => {
-                    let port = address.port();
-                    let Connect { req, addr, .. } = address;
-
-                    if let Some(addr) = addr {
-                        self.state = ConnectState::Connect(TcpConnectorResponse::new(
-                            req, port, addr, self.tag, self.pool,
-                        ));
-                        self.poll(cx)
-                    } else if let Some(addr) = req.addr() {
-                        self.state = ConnectState::Connect(TcpConnectorResponse::new(
-                            req,
-                            addr.port(),
-                            Either::Left(addr),
-                            self.tag,
-                            self.pool,
-                        ));
-                        self.poll(cx)
-                    } else {
-                        error!("{}: TCP connector: got unresolved address", self.tag);
-                        Poll::Ready(Err(ConnectError::Unresolved))
-                    }
-                }
-            },
-            ConnectState::Connect(ref mut fut) => Pin::new(fut).poll(cx),
-        }
     }
 }
 
@@ -198,8 +142,8 @@ impl<T: Address> TcpConnectorResponse<T> {
         tag: &'static str,
         pool: PoolRef,
     ) -> TcpConnectorResponse<T> {
-        trace!(
+        log::trace!(
-            "{}TCP connector - connecting to {:?} addr:{:?} port:{}",
+            "{}: TCP connector - connecting to {:?} addr:{:?} port:{}",
             tag,
             req.host(),
             addr,
@@ -227,8 +171,8 @@ impl<T: Address> TcpConnectorResponse<T> {
     }
 
     fn can_continue(&self, err: &io::Error) -> bool {
-        trace!(
+        log::trace!(
-            "{}TCP connector - failed to connect to {:?} port: {} err: {:?}",
+            "{}: TCP connector - failed to connect to {:?} port: {} err: {:?}",
             self.tag,
             self.req.as_ref().unwrap().host(),
             self.port,
@@ -250,8 +194,8 @@ impl<T: Address> Future for TcpConnectorResponse<T> {
                 match new.as_mut().poll(cx) {
                     Poll::Ready(Ok(sock)) => {
                         let req = this.req.take().unwrap();
-                        trace!(
+                        log::trace!(
-                            "{}TCP connector - successfully connected to connecting to {:?} - {:?}",
+                            "{}: TCP connector - successfully connected to connecting to {:?} - {:?}",
                             this.tag,
                             req.host(),
                             sock.query::<types::PeerAddr>().get()

ntex-glommio/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-glommio"
-version = "0.3.1"
+version = "0.4.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.21"
-ntex-io = "0.3.9"
+ntex-io = "1.0"
-ntex-util = "0.3.4"
+ntex-util = "1.0"
 futures-lite = "1.12"
 log = "0.4"
 oneshot = { version = "0.1", default-features = false, features = ["async"] }

ntex-io/Cargo.toml

@@ -18,8 +18,8 @@ path = "src/lib.rs"
 [dependencies]
 ntex-codec = "0.6.2"
 ntex-bytes = "0.1.21"
-ntex-util = "1.0.0"
+ntex-util = "1.0"
-ntex-service = "2.0.0"
+ntex-service = "2.0"
 
 bitflags = "2.4"
 log = "0.4"

ntex-tls/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.0.0] - 2024-01-0x
+
+* Use "async fn" in trait for Service definition
+
 ## [0.3.3] - 2023-11-12
 
 * Attempt to fix #190

ntex-tls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "0.3.3"
+version = "1.0.0"
 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.21"
-ntex-io = "0.3.7"
+ntex-io = "1.0"
-ntex-util = "0.3.4"
+ntex-util = "1.0"
-ntex-service = "1.2.7"
+ntex-service = "2.0"
 log = "0.4"
 pin-project-lite = "0.2"
 

ntex-tls/src/openssl/accept.rs

@@ -1,12 +1,12 @@
 use std::task::{Context, Poll};
-use std::{error::Error, future::Future, marker::PhantomData, pin::Pin};
+use std::{error::Error, marker::PhantomData};
 
 use ntex_io::{Filter, FilterFactory, Io, Layer};
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::{future::Ready, time::Millis};
+use ntex_util::time::Millis;
 use tls_openssl::ssl::SslAcceptor;
 
-use crate::counter::{Counter, CounterGuard};
+use crate::counter::Counter;
 use crate::MAX_SSL_ACCEPT_COUNTER;
 
 use super::{SslAcceptor as IoSslAcceptor, SslFilter};
@@ -58,12 +58,10 @@ impl<F: Filter, C: 'static> ServiceFactory<Io<F>, C> for Acceptor<F> {
     type Error = Box<dyn Error>;
     type Service = AcceptorService<F>;
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError>;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
         MAX_SSL_ACCEPT_COUNTER.with(|conns| {
-            Ready::Ok(AcceptorService {
+            Ok(AcceptorService {
                 acceptor: self.acceptor.clone(),
                 conns: conns.clone(),
                 _t: PhantomData,
@@ -85,9 +83,7 @@ pub struct AcceptorService<F> {
 impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
     type Response = Io<Layer<SslFilter, F>>;
     type Error = Box<dyn Error>;
-    type Future<'f> = AcceptorServiceResponse<F>;
 
-    #[inline]
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(cx) {
             Poll::Ready(Ok(()))
@@ -96,30 +92,12 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
         }
     }
 
-    #[inline]
+    async fn call(
-    fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+        &self,
-        AcceptorServiceResponse {
+        req: Io<F>,
-            _guard: self.conns.get(),
+        _: ServiceCtx<'_, Self>,
-            fut: self.acceptor.clone().create(req),
+    ) -> Result<Self::Response, Self::Error> {
-        }
+        let _guard = self.conns.get();
-    }
+        self.acceptor.clone().create(req).await
-}
-
-pin_project_lite::pin_project! {
-    pub struct AcceptorServiceResponse<F>
-    where
-        F: Filter,
-    {
-        #[pin]
-        fut: <IoSslAcceptor as FilterFactory<F>>::Future,
-        _guard: CounterGuard,
-    }
-}
-
-impl<F: Filter> Future for AcceptorServiceResponse<F> {
-    type Output = Result<Io<Layer<SslFilter, F>>, Box<dyn Error>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().fut.poll(cx)
     }
 }

ntex-tls/src/rustls/accept.rs

@@ -1,14 +1,14 @@
 use std::task::{Context, Poll};
-use std::{future::Future, io, marker::PhantomData, pin::Pin, sync::Arc};
+use std::{io, marker::PhantomData, sync::Arc};
 
 use tls_rust::ServerConfig;
 
 use ntex_io::{Filter, FilterFactory, Io, Layer};
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
-use ntex_util::{future::Ready, time::Millis};
+use ntex_util::time::Millis;
 
 use super::{TlsAcceptor, TlsFilter};
-use crate::{counter::Counter, counter::CounterGuard, MAX_SSL_ACCEPT_COUNTER};
+use crate::{counter::Counter, MAX_SSL_ACCEPT_COUNTER};
 
 #[derive(Debug)]
 /// Support `SSL` connections via rustls package
@@ -56,14 +56,11 @@ impl<F: Filter, C: 'static> ServiceFactory<Io<F>, C> for Acceptor<F> {
     type Response = Io<Layer<TlsFilter, F>>;
     type Error = io::Error;
     type Service = AcceptorService<F>;
-
     type InitError = ();
-    type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f, C: 'f;
 
-    #[inline]
+    async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
-    fn create(&self, _: C) -> Self::Future<'_> {
         MAX_SSL_ACCEPT_COUNTER.with(|conns| {
-            Ready::Ok(AcceptorService {
+            Ok(AcceptorService {
                 acceptor: self.inner.clone(),
                 conns: conns.clone(),
                 io: PhantomData,
@@ -83,9 +80,7 @@ pub struct AcceptorService<F> {
 impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
     type Response = Io<Layer<TlsFilter, F>>;
     type Error = io::Error;
-    type Future<'f> = AcceptorServiceFut<F>;
 
-    #[inline]
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(cx) {
             Poll::Ready(Ok(()))
@@ -94,30 +89,12 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
         }
     }
 
-    #[inline]
+    async fn call(
-    fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+        &self,
-        AcceptorServiceFut {
+        req: Io<F>,
-            _guard: self.conns.get(),
+        _: ServiceCtx<'_, Self>,
-            fut: self.acceptor.clone().create(req),
+    ) -> Result<Self::Response, Self::Error> {
-        }
+        let _guard = self.conns.get();
-    }
+        self.acceptor.clone().create(req).await
-}
-
-pin_project_lite::pin_project! {
-    pub struct AcceptorServiceFut<F>
-    where
-        F: Filter,
-    {
-        #[pin]
-        fut: <TlsAcceptor as FilterFactory<F>>::Future,
-        _guard: CounterGuard,
-    }
-}
-
-impl<F: Filter> Future for AcceptorServiceFut<F> {
-    type Output = Result<Io<Layer<TlsFilter, F>>, io::Error>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().fut.poll(cx)
     }
 }

ntex-tls/src/rustls/client.rs

@@ -1,10 +1,10 @@
 //! An implementation of SSL streams for ntex backed by OpenSSL
 use std::io::{self, Read as IoRead, Write as IoWrite};
-use std::{any, cell::RefCell, sync::Arc, task::Poll};
+use std::{any, cell::RefCell, future::poll_fn, sync::Arc, task::Poll};
 
 use ntex_bytes::BufMut;
 use ntex_io::{types, Filter, FilterLayer, Io, Layer, ReadBuf, WriteBuf};
-use ntex_util::{future::poll_fn, ready};
+use ntex_util::ready;
 use tls_rust::{ClientConfig, ClientConnection, ServerName};
 
 use crate::rustls::{TlsFilter, Wrapper};

ntex-tls/src/rustls/server.rs

@@ -1,10 +1,10 @@
 //! An implementation of SSL streams for ntex backed by OpenSSL
 use std::io::{self, Read as IoRead, Write as IoWrite};
-use std::{any, cell::RefCell, sync::Arc, task::Poll};
+use std::{any, cell::RefCell, future::poll_fn, sync::Arc, task::Poll};
 
 use ntex_bytes::BufMut;
 use ntex_io::{types, Filter, FilterLayer, Io, Layer, ReadBuf, WriteBuf};
-use ntex_util::{future::poll_fn, ready, time, time::Millis};
+use ntex_util::{ready, time, time::Millis};
 use tls_rust::{ServerConfig, ServerConnection};
 
 use crate::rustls::{TlsFilter, Wrapper};

ntex-tokio/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tokio"
-version = "0.3.1"
+version = "0.4.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.21"
-ntex-io = "0.3.6"
+ntex-io = "1.0"
-ntex-util = "0.3.4"
+ntex-util = "1.0"
 log = "0.4"
 pin-project-lite = "0.2"
 tokio = { version = "1", default-features = false, features = ["rt", "net", "sync", "signal"] }