mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-04 05:17:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

Migrate ntex-connect to async fn in trait

Browse source
This commit is contained in:
Nikolay Kim 2024-01-07 05:03:02 +06:00
parent 60620d4587
commit 2e12cc6edf
17 changed files with 134 additions and 231 deletions
Download patch file Download diff file Expand all files Collapse all files

6
ntex-async-std/Cargo.toml
View file

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

4
ntex-connect/CHANGES.md
View file

@ -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

19
ntex-connect/Cargo.toml
View file

@ -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-io = "0.3.16"
ntex-http = "0.1"
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-glommio = { version = "0.3.0", optional = true }
ntex-async-std = { version = "0.3.0", optional = true }
ntex-tokio = { version = "0.4", optional = true }
ntex-glommio = { version = "0.4", optional = true }
ntex-async-std = { version = "0.4", optional = true }
# openssl
tls-openssl = { version="0.10", package = "openssl", optional = true }

6
ntex-connect/src/lib.rs
View file

@ -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())))
.await
Connector::new().connect(message).await
}
#[allow(unused_imports)]

23
ntex-connect/src/openssl.rs
View file

@ -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]
fn create(&self, _: C) -> Self::Future<'_> {
Ready::Ok(self.clone())
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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]
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(self.connect(req))
async fn call(
&self,
req: Connect<T>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.connect(req).await
}
}

26
ntex-connect/src/resolve.rs
View file

@ -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]
fn create(&self, _: C) -> Self::Future<'_> {
Ready::Ok(self.clone())
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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]
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
Box::pin(self.lookup(req))
async fn call(
&self,
req: Connect<T>,
_: ServiceCtx<'_, Self>,
) -> Result<Connect<T>, Self::Error> {
self.lookup(req).await
}
}

22
ntex-connect/src/rustls.rs
View file

@ -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]
fn create(&self, _: C) -> Self::Future<'_> {
Ready::Ok(self.clone())
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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> {
Box::pin(self.connect(req))
async fn call(
&self,
req: Connect<T>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.connect(req).await
}
}

130
ntex-connect/src/service.rs
View file

@ -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 {
state: ConnectState::Resolve(Box::pin(self.resolver.lookup(message.into()))),
tag: self.tag,
pool: self.pool,
// resolve first
let address = self.resolver.lookup(message.into()).await?;
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]
fn create(&self, _: C) -> Self::Future<'_> {
Ready::Ok(self.clone())
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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]
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ConnectServiceResponse {
state: ConnectState::Resolve(Box::pin(self.resolver.lookup(req))),
pool: PoolId::P0.pool_ref(),
tag: self.tag,
}
}
}
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),
}
async fn call(
&self,
req: Connect<T>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.connect(req).await
}
}
@ -198,8 +142,8 @@ impl<T: Address> TcpConnectorResponse<T> {
tag: &'static str,
pool: PoolRef,
) -> TcpConnectorResponse<T> {
trace!(
"{}TCP connector - connecting to {:?} addr:{:?} port:{}",
log::trace!(
"{}: 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!(
"{}TCP connector - failed to connect to {:?} port: {} err: {:?}",
log::trace!(
"{}: 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!(
"{}TCP connector - successfully connected to connecting to {:?} - {:?}",
log::trace!(
"{}: TCP connector - successfully connected to connecting to {:?} - {:?}",
this.tag,
req.host(),
sock.query::<types::PeerAddr>().get()

6
ntex-glommio/Cargo.toml
View file

@ -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-util = "0.3.4"
ntex-io = "1.0"
ntex-util = "1.0"
futures-lite = "1.12"
log = "0.4"
oneshot = { version = "0.1", default-features = false, features = ["async"] }

4
ntex-io/Cargo.toml
View file

@ -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-service = "2.0.0"
ntex-util = "1.0"
ntex-service = "2.0"
bitflags = "2.4"
log = "0.4"

4
ntex-tls/CHANGES.md
View file

@ -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

8
ntex-tls/Cargo.toml
View file

@ -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-util = "0.3.4"
ntex-service = "1.2.7"
ntex-io = "1.0"
ntex-util = "1.0"
ntex-service = "2.0"
log = "0.4"
pin-project-lite = "0.2"

46
ntex-tls/src/openssl/accept.rs
View file

@ -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]
fn create(&self, _: C) -> Self::Future<'_> {
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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]
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),
}
}
}
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)
async fn call(
&self,
req: Io<F>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let _guard = self.conns.get();
self.acceptor.clone().create(req).await
}
}

47
ntex-tls/src/rustls/accept.rs
View file

@ -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]
fn create(&self, _: C) -> Self::Future<'_> {
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
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]
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),
}
}
}
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)
async fn call(
&self,
req: Io<F>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let _guard = self.conns.get();
self.acceptor.clone().create(req).await
}
}

4
ntex-tls/src/rustls/client.rs
View file

@ -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};

4
ntex-tls/src/rustls/server.rs
View file

@ -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};

6
ntex-tokio/Cargo.toml
View file

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