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

Merge pull request from ntex-rs/async-fn-in-trait

Browse source 
Use  "async fn in trait" for Service definition
This commit is contained in:
Nikolay Kim 2024-01-07 20:43:45 +06:00 • committed by GitHub
commit 566339ee70
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
95 changed files with 1164 additions and 2722 deletions

2
.github/workflows/linux.yml vendored
View file

@ -8,7 +8,7 @@ jobs:
fail-fast: false
matrix:
version:
- 1.67.0 # MSRV
- 1.75.0 # MSRV
- stable
- nightly

2
Cargo.toml
View file

@ -35,3 +35,5 @@ ntex-util = { path = "ntex-util" }
ntex-glommio = { path = "ntex-glommio" }
ntex-tokio = { path = "ntex-tokio" }
ntex-async-std = { path = "ntex-async-std" }
ntex-h2 = { git = "https://github.com/ntex-rs/ntex-h2.git", branch = "async-fn-in-trait" }

4
ntex-async-std/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.4.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.3.2] - 2023-11-22
* Replace async-oneshot with oneshot

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-b.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.0-b.0"
ntex-util = "1.0.0-b.0"
log = "0.4"
pin-project-lite = "0.2"
async-std = { version = "1", features = ["unstable"] }

2
ntex-bytes/Cargo.toml
View file

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

4
ntex-connect/CHANGES.md
View file

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

21
ntex-connect/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-connect"
version = "0.3.4"
version = "1.0.0-b.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.0-b.0"
ntex-io = "1.0.0-b.0"
ntex-tls = "1.0.0-b.0"
ntex-util = "1.0.0-b.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.0-b.0", optional = true }
ntex-glommio = { version = "0.4.0-b.0", optional = true }
ntex-async-std = { version = "0.4.0-b.0", optional = true }
# openssl
tls-openssl = { version="0.10", package = "openssl", optional = true }
@ -58,4 +59,4 @@ webpki-roots = { version = "0.25", optional = true }
[dev-dependencies]
rand = "0.8"
env_logger = "0.10"
ntex = { version = "0.7.0", features = ["tokio"] }
ntex = { version = "1.0.0-b.0", features = ["tokio"] }

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()

4
ntex-glommio/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.4.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.3.1] - 2023-11-22
* Replace async-oneshot with oneshot

6
ntex-glommio/Cargo.toml
View file

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

4
ntex-io/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [1.0.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.3.17] - 2023-12-25
* Fix filter leak during Io drop

8
ntex-io/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-io"
version = "0.3.17"
version = "1.0.0-b.0"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Utilities for encoding and decoding frames"
keywords = ["network", "framework", "async", "futures"]
@ -18,8 +18,8 @@ path = "src/lib.rs"
[dependencies]
ntex-codec = "0.6.2"
ntex-bytes = "0.1.21"
ntex-util = "0.3.4"
ntex-service = "1.2.7"
ntex-util = "1.0.0-b.0"
ntex-service = "2.0.0-b.0"
bitflags = "2.4"
log = "0.4"
@ -29,4 +29,4 @@ pin-project-lite = "0.2"
rand = "0.8"
env_logger = "0.10"
ntex = { version = "0.7", features = ["tokio"] }
ntex = { version = "1.0.0-b.0", features = ["tokio"] }

78
ntex-io/src/dispatcher.rs
View file

@ -1,5 +1,5 @@
//! Framed transport dispatcher
use std::{cell::Cell, future, pin::Pin, rc::Rc, task::Context, task::Poll, time};
use std::{cell::Cell, future, pin::Pin, rc::Rc, task::Context, task::Poll};
use ntex_bytes::Pool;
use ntex_codec::{Decoder, Encoder};
@ -38,17 +38,9 @@ impl Default for DispatcherConfig {
}
impl DispatcherConfig {
#[doc(hidden)]
#[deprecated(since = "0.3.12")]
#[inline]
/// Get keep-alive timeout
pub fn keepalive_timeout(&self) -> time::Duration {
self.0.keepalive_timeout.get().into()
}
#[inline]
/// Get keep-alive timeout
pub fn keepalive_timeout_secs(&self) -> Seconds {
pub fn keepalive_timeout(&self) -> Seconds {
self.0.keepalive_timeout.get()
}
@ -58,25 +50,9 @@ impl DispatcherConfig {
self.0.disconnect_timeout.get()
}
#[doc(hidden)]
#[deprecated(since = "0.3.12")]
#[inline]
/// Get frame read rate
pub fn frame_read_rate(&self) -> Option<(time::Duration, time::Duration, u16)> {
if self.0.frame_read_enabled.get() {
Some((
self.0.frame_read_timeout.get().into(),
self.0.frame_read_max_timeout.get().into(),
self.0.frame_read_rate.get(),
))
} else {
None
}
}
#[inline]
/// Get frame read rate
pub fn frame_read_rate_params(&self) -> Option<(Seconds, Seconds, u16)> {
pub fn frame_read_rate(&self) -> Option<(Seconds, Seconds, u16)> {
if self.0.frame_read_enabled.get() {
Some((
self.0.frame_read_timeout.get(),
@ -219,7 +195,7 @@ where
U: Decoder + Encoder,
{
/// Construct new `Dispatcher` instance.
pub fn with_config<Io, F>(
pub fn new<Io, F>(
io: Io,
codec: U,
service: F,
@ -232,7 +208,7 @@ where
let io = IoBoxed::from(io);
io.set_disconnect_timeout(cfg.disconnect_timeout());
let flags = if cfg.keepalive_timeout_secs().is_zero() {
let flags = if cfg.keepalive_timeout().is_zero() {
Flags::empty()
} else {
Flags::KA_ENABLED
@ -261,17 +237,6 @@ where
},
}
}
#[doc(hidden)]
#[deprecated(since = "0.3.6", note = "Use Dispatcher::with_config() method")]
/// Construct new `Dispatcher` instance.
pub fn new<Io, F>(io: Io, codec: U, service: F) -> Dispatcher<S, U>
where
IoBoxed: From<Io>,
F: IntoService<S, DispatchItem<U>>,
{
Self::with_config(io, codec, service, &DispatcherConfig::default())
}
}
impl<S, U> DispatcherShared<S, U>
@ -560,14 +525,12 @@ where
log::debug!(
"{}: Start keep-alive timer {:?}",
self.shared.io.tag(),
self.cfg.keepalive_timeout_secs()
self.cfg.keepalive_timeout()
);
self.flags.insert(Flags::KA_TIMEOUT);
self.shared
.io
.start_timer_secs(self.cfg.keepalive_timeout_secs());
self.shared.io.start_timer(self.cfg.keepalive_timeout());
}
} else if let Some((timeout, max, _)) = self.cfg.frame_read_rate_params() {
} else if let Some((timeout, max, _)) = self.cfg.frame_read_rate() {
// we got new data but not enough to parse single frame
// start read timer
self.flags.insert(Flags::READ_TIMEOUT);
@ -575,14 +538,14 @@ where
self.read_remains = decoded.remains as u32;
self.read_remains_prev = 0;
self.read_max_timeout = max;
self.shared.io.start_timer_secs(timeout);
self.shared.io.start_timer(timeout);
}
}
fn handle_timeout(&mut self) -> Result<(), DispatchItem<U>> {
// check read timer
if self.flags.contains(Flags::READ_TIMEOUT) {
if let Some((timeout, max, rate)) = self.cfg.frame_read_rate_params() {
if let Some((timeout, max, rate)) = self.cfg.frame_read_rate() {
let total = (self.read_remains - self.read_remains_prev)
.try_into()
.unwrap_or(u16::MAX);
@ -603,7 +566,7 @@ where
self.shared.io.tag(),
total
);
self.shared.io.start_timer_secs(timeout);
self.shared.io.start_timer(timeout);
return Ok(());
}
log::trace!(
@ -627,12 +590,12 @@ where
mod tests {
use rand::Rng;
use std::sync::{atomic::AtomicBool, atomic::Ordering::Relaxed, Arc, Mutex};
use std::{cell::RefCell, io, time::Duration};
use std::{cell::RefCell, io};
use ntex_bytes::{Bytes, BytesMut, PoolId, PoolRef};
use ntex_codec::BytesCodec;
use ntex_service::ServiceCtx;
use ntex_util::{future::Ready, time::sleep, time::Millis, time::Seconds};
use ntex_util::{time::sleep, time::Millis, time::Seconds};
use super::*;
use crate::{io::Flags, testing::IoTest, Io, IoRef, IoStream};
@ -713,14 +676,14 @@ mod tests {
state.set_disconnect_timeout(cfg.disconnect_timeout());
state.set_tag("DBG");
let flags = if cfg.keepalive_timeout_secs().is_zero() {
let flags = if cfg.keepalive_timeout().is_zero() {
super::Flags::empty()
} else {
super::Flags::KA_ENABLED
};
let inner = State(state.get_ref());
state.start_timer(Duration::from_millis(500));
state.start_timer(Seconds::ONE);
let shared = Rc::new(DispatcherShared {
codec,
@ -870,19 +833,18 @@ mod tests {
impl Service<DispatchItem<BytesCodec>> for Srv {
type Response = Option<Response<BytesCodec>>;
type Error = ();
type Future<'f> = Ready<Option<Response<BytesCodec>>, ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), ()>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Err(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
_: DispatchItem<BytesCodec>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(None)
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
Ok(None)
}
}

5
ntex-io/src/io.rs
View file

@ -1,10 +1,11 @@
use std::cell::Cell;
use std::future::{poll_fn, Future};
use std::task::{Context, Poll};
use std::{fmt, future::Future, hash, io, marker, mem, ops, pin::Pin, ptr, rc::Rc};
use std::{fmt, hash, io, marker, mem, ops, pin::Pin, ptr, rc::Rc};
use ntex_bytes::{PoolId, PoolRef};
use ntex_codec::{Decoder, Encoder};
use ntex_util::{future::poll_fn, future::Either, task::LocalWaker, time::Seconds};
use ntex_util::{future::Either, task::LocalWaker, time::Seconds};
use crate::buf::Stack;
use crate::filter::{Base, Filter, Layer, NullFilter};

38
ntex-io/src/ioref.rs
View file

@ -1,4 +1,4 @@
use std::{any, fmt, hash, io, time};
use std::{any, fmt, hash, io};
use ntex_bytes::{BytesVec, PoolRef};
use ntex_codec::{Decoder, Encoder};
@ -225,23 +225,9 @@ impl IoRef {
self.0.timeout.get()
}
#[doc(hidden)]
#[deprecated(since = "0.3.12")]
#[inline]
/// current timer deadline
pub fn timer_deadline(&self) -> time::Instant {
self.0.timeout.get().instant()
}
#[inline]
/// Start timer
pub fn start_timer(&self, timeout: time::Duration) {
self.start_timer_secs(Seconds(timeout.as_secs() as u16));
}
#[inline]
/// Start timer
pub fn start_timer_secs(&self, timeout: Seconds) -> timer::TimerHandle {
pub fn start_timer(&self, timeout: Seconds) -> timer::TimerHandle {
let cur_hnd = self.0.timeout.get();
if !timeout.is_zero() {
@ -278,22 +264,6 @@ impl IoRef {
}
}
#[doc(hidden)]
#[deprecated(since = "0.3.6")]
#[inline]
/// Start keep-alive timer
pub fn start_keepalive_timer(&self, timeout: time::Duration) {
self.start_timer(timeout);
}
#[doc(hidden)]
#[deprecated(since = "0.3.6")]
#[inline]
/// Stop keep-alive timer
pub fn stop_keepalive_timer(&self) {
self.stop_timer()
}
#[inline]
/// Get tag
pub fn tag(&self) -> &'static str {
@ -340,11 +310,11 @@ impl fmt::Debug for IoRef {
#[cfg(test)]
mod tests {
use std::cell::{Cell, RefCell};
use std::{future::Future, pin::Pin, rc::Rc, task::Poll};
use std::{future::poll_fn, future::Future, pin::Pin, rc::Rc, task::Poll};
use ntex_bytes::Bytes;
use ntex_codec::BytesCodec;
use ntex_util::future::{lazy, poll_fn};
use ntex_util::future::lazy;
use ntex_util::time::{sleep, Millis};
use super::*;

4
ntex-io/src/testing.rs
View file

@ -1,10 +1,10 @@
//! utilities and helpers for testing
use std::future::{poll_fn, Future};
use std::sync::{Arc, Mutex};
use std::task::{ready, Context, Poll, Waker};
use std::{any, cell::RefCell, cmp, fmt, future::Future, io, mem, net, pin::Pin, rc::Rc};
use std::{any, cell::RefCell, cmp, fmt, io, mem, net, pin::Pin, rc::Rc};
use ntex_bytes::{Buf, BufMut, Bytes, BytesVec};
use ntex_util::future::poll_fn;
use ntex_util::time::{sleep, Millis, Sleep};
use crate::{types, Handle, IoStream, ReadContext, ReadStatus, WriteContext, WriteStatus};

19
ntex-io/src/utils.rs
View file

@ -66,11 +66,9 @@ where
type Error = T::Error;
type Service = FilterService<T, F>;
type InitError = ();
type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f;
#[inline]
fn create(&self, _: ()) -> Self::Future<'_> {
Ready::Ok(FilterService {
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
Ok(FilterService {
filter: self.filter.clone(),
_t: PhantomData,
})
@ -96,11 +94,14 @@ where
{
type Response = Io<Layer<T::Filter, F>>;
type Error = T::Error;
type Future<'f> = T::Future where T: 'f, F: 'f;
#[inline]
fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.filter.clone().create(req)
async fn call(
&self,
req: Io<F>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.filter.clone().create(req).await
}
}
@ -204,11 +205,11 @@ mod tests {
assert!(NullFilter.query(std::any::TypeId::of::<()>()).is_none());
assert!(NullFilter.shutdown(&ioref, &stack, 0).unwrap().is_ready());
assert_eq!(
ntex_util::future::poll_fn(|cx| NullFilter.poll_read_ready(cx)).await,
std::future::poll_fn(|cx| NullFilter.poll_read_ready(cx)).await,
crate::ReadStatus::Terminate
);
assert_eq!(
ntex_util::future::poll_fn(|cx| NullFilter.poll_write_ready(cx)).await,
std::future::poll_fn(|cx| NullFilter.poll_write_ready(cx)).await,
crate::WriteStatus::Terminate
);
assert!(NullFilter.process_write_buf(&ioref, &stack, 0).is_ok());

2
ntex-macros/Cargo.toml
View file

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

4
ntex-service/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [2.0.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [1.2.7] - 2023-09-19
* Use From<T::Error> for apply_fn util

6
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "1.2.7"
version = "2.0.0-b.0"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex service"
keywords = ["network", "framework", "async", "futures"]
@ -20,5 +20,5 @@ pin-project-lite = "0.2.6"
slab = "0.4"
[dev-dependencies]
ntex = { version = "0.7.0", features = ["tokio"] }
ntex-util = "0.3.0"
ntex = { version = "1.0.0-b.0", features = ["tokio"] }
ntex-util = "1.0.0-b.0"

165
ntex-service/src/and_then.rs
View file

@ -1,6 +1,6 @@
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use std::{task::Context, task::Poll};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
use super::{Service, ServiceCtx, ServiceFactory};
#[derive(Clone, Debug)]
/// Service for the `and_then` combinator, chaining a computation onto the end
@ -26,7 +26,6 @@ where
{
type Response = B::Response;
type Error = A::Error;
type Future<'f> = AndThenServiceResponse<'f, A, B, Req> where Self: 'f, Req: 'f;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let not_ready = !self.svc1.poll_ready(cx)?.is_ready();
@ -47,73 +46,13 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
AndThenServiceResponse {
slf: self,
state: State::A {
fut: ctx.call(&self.svc1, req),
ctx: Some(ctx),
},
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct AndThenServiceResponse<'f, A, B, Req>
where
A: Service<Req>,
B: Service<A::Response, Error = A::Error>,
{
slf: &'f AndThen<A, B>,
#[pin]
state: State<'f, A, B, Req>,
}
}
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<'f, A, B, Req>
where
A: Service<Req>,
A: 'f,
Req: 'f,
B: Service<A::Response, Error = A::Error>,
B: 'f,
{
A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<ServiceCtx<'f, AndThen<A, B>>> },
B { #[pin] fut: ServiceCall<'f, B, A::Response> },
Empty,
}
}
impl<'f, A, B, Req> Future for AndThenServiceResponse<'f, A, B, Req>
where
A: Service<Req>,
B: Service<A::Response, Error = A::Error>,
{
type Output = Result<B::Response, A::Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A { fut, ctx } => match fut.poll(cx)? {
Poll::Ready(res) => {
let fut = ctx.take().unwrap().call(&this.slf.svc2, res);
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
StateProject::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
async fn call(
&self,
req: Req,
ctx: ServiceCtx<'_, Self>,
) -> Result<B::Response, A::Error> {
let res = ctx.call(&self.svc1, req).await?;
ctx.call(&self.svc2, res).await
}
}
@ -142,67 +81,13 @@ where
type Service = AndThen<A::Service, B::Service>;
type InitError = A::InitError;
type Future<'f> = AndThenFactoryResponse<'f, A, B, Req, Cfg> where Self: 'f, Cfg: 'f;
#[inline]
fn create(&self, cfg: Cfg) -> Self::Future<'_> {
AndThenFactoryResponse {
fut1: self.svc1.create(cfg.clone()),
fut2: self.svc2.create(cfg),
svc1: None,
svc2: None,
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct AndThenFactoryResponse<'f, A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
A: 'f,
B: ServiceFactory<A::Response, Cfg>,
B: 'f,
Cfg: 'f
{
#[pin]
fut1: A::Future<'f>,
#[pin]
fut2: B::Future<'f>,
svc1: Option<A::Service>,
svc2: Option<B::Service>,
}
}
impl<'f, A, B, Req, Cfg> Future for AndThenFactoryResponse<'f, A, B, Req, Cfg>
where
A: ServiceFactory<Req, Cfg>,
B: ServiceFactory<A::Response, Cfg, Error = A::Error, InitError = A::InitError>,
{
type Output = Result<AndThen<A::Service, B::Service>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if this.svc1.is_none() {
if let Poll::Ready(service) = this.fut1.poll(cx)? {
*this.svc1 = Some(service);
}
}
if this.svc2.is_none() {
if let Poll::Ready(service) = this.fut2.poll(cx)? {
*this.svc2 = Some(service);
}
}
if this.svc1.is_some() && this.svc2.is_some() {
Poll::Ready(Ok(AndThen::new(
this.svc1.take().unwrap(),
this.svc2.take().unwrap(),
)))
} else {
Poll::Pending
}
async fn create(&self, cfg: Cfg) -> Result<Self::Service, Self::InitError> {
Ok(AndThen {
svc1: self.svc1.create(cfg.clone()).await?,
svc2: self.svc2.create(cfg).await?,
})
}
}
@ -219,19 +104,18 @@ mod tests {
impl Service<&'static str> for Srv1 {
type Response = &'static str;
type Error = ();
type Future<'f> = Ready<Self::Response, ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: &'static str,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(req)
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, ()> {
Ok(req)
}
}
@ -241,19 +125,18 @@ mod tests {
impl Service<&'static str> for Srv2 {
type Response = (&'static str, &'static str);
type Error = ();
type Future<'f> = Ready<Self::Response, ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: &'static str,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok((req, "srv2"))
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, ()> {
Ok((req, "srv2"))
}
}

72
ntex-service/src/apply.rs
View file

@ -1,5 +1,5 @@
#![allow(clippy::type_complexity)]
use std::{fmt, future::Future, marker, pin::Pin, task, task::Poll};
use std::{fmt, future::Future, marker};
use super::ctx::ServiceCtx;
use super::{IntoService, IntoServiceFactory, Pipeline, Service, ServiceFactory};
@ -97,14 +97,17 @@ where
{
type Response = Out;
type Error = Err;
type Future<'f> = R where Self: 'f, In: 'f, R: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: In, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
(self.f)(req, self.service.clone())
async fn call(
&self,
req: In,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
(self.f)(req, self.service.clone()).await
}
}
@ -183,58 +186,14 @@ where
type Service = Apply<T::Service, Req, F, R, In, Out, Err>;
type InitError = T::InitError;
type Future<'f> = ApplyFactoryResponse<'f, T, Req, Cfg, F, R, In, Out, Err> where Self: 'f, Cfg: 'f;
#[inline]
fn create(&self, cfg: Cfg) -> Self::Future<'_> {
ApplyFactoryResponse {
fut: self.service.create(cfg),
f: Some(self.f.clone()),
_t: marker::PhantomData,
}
}
}
pin_project_lite::pin_project! {
pub struct ApplyFactoryResponse<'f, T, Req, Cfg, F, R, In, Out, Err>
where
T: ServiceFactory<Req, Cfg>,
T: 'f,
F: Fn(In, Pipeline<T::Service>) -> R,
T::Service: 'f,
R: Future<Output = Result<Out, Err>>,
Cfg: 'f,
Err: From<T::Error>,
{
#[pin]
fut: T::Future<'f>,
f: Option<F>,
_t: marker::PhantomData<(In, Out)>,
}
}
impl<'f, T, Req, Cfg, F, R, In, Out, Err> Future
for ApplyFactoryResponse<'f, T, Req, Cfg, F, R, In, Out, Err>
where
T: ServiceFactory<Req, Cfg>,
F: Fn(In, Pipeline<T::Service>) -> R,
R: Future<Output = Result<Out, Err>>,
Err: From<T::Error>,
{
type Output = Result<Apply<T::Service, Req, F, R, In, Out, Err>, T::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if let Poll::Ready(svc) = this.fut.poll(cx)? {
Poll::Ready(Ok(Apply {
service: svc.into(),
f: this.f.take().unwrap(),
r: marker::PhantomData,
}))
} else {
Poll::Pending
}
async fn create(&self, cfg: Cfg) -> Result<Self::Service, Self::InitError> {
self.service.create(cfg).await.map(|svc| Apply {
service: svc.into(),
f: self.f.clone(),
r: marker::PhantomData,
})
}
}
@ -252,10 +211,9 @@ mod tests {
impl Service<()> for Srv {
type Response = ();
type Error = ();
type Future<'f> = Ready<(), ()>;
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
Ok(())
}
}

16
ntex-service/src/boxed.rs
View file

@ -87,7 +87,11 @@ where
idx: usize,
waiters: &'a WaitersRef,
) -> BoxFuture<'a, Self::Response, Self::Error> {
Box::pin(ServiceCtx::<'a, S>::from_ref(idx, waiters).call_nowait(self, req))
Box::pin(async move {
ServiceCtx::<'a, S>::from_ref(idx, waiters)
.call_nowait(self, req)
.await
})
}
}
@ -134,7 +138,6 @@ where
{
type Response = Res;
type Error = Err;
type Future<'f> = BoxFuture<'f, Res, Err> where Self: 'f, Req: 'f;
#[inline]
fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -147,9 +150,9 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(&self, req: Req, ctx: ServiceCtx<'_, Self>) -> Result<Res, Err> {
let (idx, waiters) = ctx.inner();
self.0.call(req, idx, waiters)
self.0.call(req, idx, waiters).await
}
}
@ -163,10 +166,9 @@ where
type Service = BoxService<Req, Res, Err>;
type InitError = InitErr;
type Future<'f> = BoxFuture<'f, Self::Service, InitErr> where Self: 'f, C: 'f;
#[inline]
fn create(&self, cfg: C) -> Self::Future<'_> {
self.0.create(cfg)
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.0.create(cfg).await
}
}

21
ntex-service/src/chain.rs
View file

@ -3,12 +3,11 @@ use std::{fmt, future::Future, marker::PhantomData};
use crate::and_then::{AndThen, AndThenFactory};
use crate::apply::{Apply, ApplyFactory};
use crate::ctx::{ServiceCall, ServiceCtx};
use crate::ctx::ServiceCtx;
use crate::map::{Map, MapFactory};
use crate::map_err::{MapErr, MapErrFactory};
use crate::map_init_err::MapInitErr;
use crate::middleware::{ApplyMiddleware, Middleware};
use crate::pipeline::CreatePipeline;
use crate::then::{Then, ThenFactory};
use crate::{IntoService, IntoServiceFactory, Pipeline, Service, ServiceFactory};
@ -171,14 +170,17 @@ where
impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req> {
type Response = Svc::Response;
type Error = Svc::Error;
type Future<'f> = ServiceCall<'f, Svc, Req> where Self: 'f, Req: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ctx.call(&self.service, req)
async fn call(
&self,
req: Req,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call(&self.service, req).await
}
}
@ -308,11 +310,11 @@ impl<T: ServiceFactory<Req, C>, Req, C> ServiceChainFactory<T, Req, C> {
}
/// Create and return a new service value asynchronously and wrap into a container
pub fn pipeline(&self, cfg: C) -> CreatePipeline<'_, T, Req, C>
pub async fn pipeline(&self, cfg: C) -> Result<Pipeline<T::Service>, T::InitError>
where
Self: Sized,
{
CreatePipeline::new(self.factory.create(cfg))
Ok(Pipeline::new(self.factory.create(cfg).await?))
}
}
@ -344,10 +346,9 @@ impl<T: ServiceFactory<R, C>, R, C> ServiceFactory<R, C> for ServiceChainFactory
type Error = T::Error;
type Service = T::Service;
type InitError = T::InitError;
type Future<'f> = T::Future<'f> where Self: 'f;
#[inline]
fn create(&self, cfg: C) -> Self::Future<'_> {
self.factory.create(cfg)
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.factory.create(cfg).await
}
}

297
ntex-service/src/ctx.rs
View file

@ -1,6 +1,6 @@
use std::{cell::UnsafeCell, fmt, future::Future, marker, pin::Pin, rc::Rc, task};
use std::{cell::UnsafeCell, fmt, future::poll_fn, marker, rc::Rc, task, task::Poll};
use crate::{Pipeline, Service};
use crate::Service;
pub struct ServiceCtx<'a, S: ?Sized> {
idx: usize,
@ -112,27 +112,51 @@ impl<'a, S> ServiceCtx<'a, S> {
(self.idx, self.waiters)
}
/// Returns when the service is able to process requests.
pub async fn ready<T, R>(&self, svc: &'a T) -> Result<(), T::Error>
where
T: Service<R>,
{
// check readiness and notify waiters
poll_fn(move |cx| match svc.poll_ready(cx)? {
Poll::Ready(()) => {
self.waiters.notify();
Poll::Ready(Ok(()))
}
Poll::Pending => {
self.waiters.register(self.idx, cx);
Poll::Pending
}
})
.await
}
#[inline]
/// Wait for service readiness and then call service
pub fn call<T, R>(&self, svc: &'a T, req: R) -> ServiceCall<'a, T, R>
pub async fn call<T, R>(&self, svc: &'a T, req: R) -> Result<T::Response, T::Error>
where
T: Service<R>,
R: 'a,
{
ServiceCall {
state: ServiceCallState::Ready {
svc,
req: Some(req),
self.ready(svc).await?;
svc.call(
req,
ServiceCtx {
idx: self.idx,
waiters: self.waiters,
_t: marker::PhantomData,
},
}
)
.await
}
#[doc(hidden)]
#[inline]
/// Call service, do not check service readiness
pub fn call_nowait<T, R>(&self, svc: &'a T, req: R) -> T::Future<'a>
pub async fn call_nowait<T, R>(
&self,
svc: &'a T,
req: R,
) -> Result<T::Response, T::Error>
where
T: Service<R>,
R: 'a,
@ -145,6 +169,7 @@ impl<'a, S> ServiceCtx<'a, S> {
_t: marker::PhantomData,
},
)
.await
}
}
@ -166,201 +191,12 @@ impl<'a, S> fmt::Debug for ServiceCtx<'a, S> {
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct ServiceCall<'a, S, Req>
where
S: Service<Req>,
Req: 'a,
{
#[pin]
state: ServiceCallState<'a, S, Req>,
}
}
pin_project_lite::pin_project! {
#[project = ServiceCallStateProject]
enum ServiceCallState<'a, S, Req>
where
S: Service<Req>,
Req: 'a,
{
Ready { req: Option<Req>,
svc: &'a S,
idx: usize,
waiters: &'a WaitersRef,
},
ReadyPl { req: Option<Req>,
svc: &'a Pipeline<S>,
pl: Pipeline<S>,
},
Call { #[pin] fut: S::Future<'a> },
Empty,
}
}
impl<'a, S, Req> ServiceCall<'a, S, Req>
where
S: Service<Req>,
Req: 'a,
{
pub(crate) fn call_pipeline(req: Req, svc: &'a Pipeline<S>) -> Self {
ServiceCall {
state: ServiceCallState::ReadyPl {
req: Some(req),
pl: svc.clone(),
svc,
},
}
}
pub fn advance_to_call(self) -> ServiceCallToCall<'a, S, Req> {
match self.state {
ServiceCallState::Ready { .. } | ServiceCallState::ReadyPl { .. } => {}
ServiceCallState::Call { .. } | ServiceCallState::Empty => {
panic!(
"`ServiceCall::advance_to_call` must be called before `ServiceCall::poll`"
)
}
}
ServiceCallToCall { state: self.state }
}
}
impl<'a, S, Req> Future for ServiceCall<'a, S, Req>
where
S: Service<Req>,
{
type Output = Result<S::Response, S::Error>;
fn poll(
mut self: Pin<&mut Self>,
cx: &mut task::Context<'_>,
) -> task::Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
ServiceCallStateProject::Ready {
req,
svc,
idx,
waiters,
} => match svc.poll_ready(cx)? {
task::Poll::Ready(()) => {
waiters.notify();
let fut = svc.call(
req.take().unwrap(),
ServiceCtx {
waiters,
idx: *idx,
_t: marker::PhantomData,
},
);
this.state.set(ServiceCallState::Call { fut });
self.poll(cx)
}
task::Poll::Pending => {
waiters.register(*idx, cx);
task::Poll::Pending
}
},
ServiceCallStateProject::ReadyPl { req, svc, pl } => {
task::ready!(pl.poll_ready(cx))?;
let ctx = ServiceCtx::new(&svc.waiters);
let svc_call = svc.get_ref().call(req.take().unwrap(), ctx);
// SAFETY: `svc_call` has same lifetime same as lifetime of `pl.svc`
// Pipeline::svc is heap allocated(Rc<S>), we keep it alive until
// `svc_call` get resolved to result
let fut = unsafe { std::mem::transmute(svc_call) };
this.state.set(ServiceCallState::Call { fut });
self.poll(cx)
}
ServiceCallStateProject::Call { fut, .. } => fut.poll(cx).map(|r| {
this.state.set(ServiceCallState::Empty);
r
}),
ServiceCallStateProject::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct ServiceCallToCall<'a, S, Req>
where
S: Service<Req>,
Req: 'a,
{
#[pin]
state: ServiceCallState<'a, S, Req>,
}
}
impl<'a, S, Req> Future for ServiceCallToCall<'a, S, Req>
where
S: Service<Req>,
{
type Output = Result<S::Future<'a>, S::Error>;
fn poll(
mut self: Pin<&mut Self>,
cx: &mut task::Context<'_>,
) -> task::Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
ServiceCallStateProject::Ready {
req,
svc,
idx,
waiters,
} => match svc.poll_ready(cx)? {
task::Poll::Ready(()) => {
waiters.notify();
let fut = svc.call(
req.take().unwrap(),
ServiceCtx {
waiters,
idx: *idx,
_t: marker::PhantomData,
},
);
this.state.set(ServiceCallState::Empty);
task::Poll::Ready(Ok(fut))
}
task::Poll::Pending => {
waiters.register(*idx, cx);
task::Poll::Pending
}
},
ServiceCallStateProject::ReadyPl { req, svc, pl } => {
task::ready!(pl.poll_ready(cx))?;
let ctx = ServiceCtx::new(&svc.waiters);
task::Poll::Ready(Ok(svc.get_ref().call(req.take().unwrap(), ctx)))
}
ServiceCallStateProject::Call { .. } => {
unreachable!("`ServiceCallToCall` can only be constructed in `Ready` state")
}
ServiceCallStateProject::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}
#[cfg(test)]
mod tests {
use ntex_util::future::{lazy, poll_fn, Ready};
use ntex_util::future::lazy;
use ntex_util::{channel::condition, time};
use std::{cell::Cell, cell::RefCell, rc::Rc, task::Context, task::Poll};
use std::task::{Context, Poll};
use std::{cell::Cell, cell::RefCell, future::poll_fn, rc::Rc};
use super::*;
use crate::Pipeline;
@ -370,20 +206,19 @@ mod tests {
impl Service<&'static str> for Srv {
type Response = &'static str;
type Error = ();
type Future<'f> = Ready<Self::Response, ()>;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
self.1.poll_ready(cx).map(|_| Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: &'static str,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let _ = ctx.clone();
Ready::Ok(req)
Ok(req)
}
}
@ -451,32 +286,32 @@ mod tests {
assert_eq!(&*data.borrow(), &["srv2", "srv1"]);
}
#[ntex::test]
async fn test_advance_to_call() {
let cnt = Rc::new(Cell::new(0));
let con = condition::Condition::new();
let srv = Pipeline::from(Srv(cnt.clone(), con.wait()));
// #[ntex::test]
// async fn test_advance_to_call() {
// let cnt = Rc::new(Cell::new(0));
// let con = condition::Condition::new();
// let srv = Pipeline::from(Srv(cnt.clone(), con.wait()));
let mut fut = srv.call("test").advance_to_call();
let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
con.notify();
// let mut fut = srv.call("test").advance_to_call();
// let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
// con.notify();
let res = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
assert!(res.is_ready());
}
// let res = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
// assert!(res.is_ready());
// }
#[ntex::test]
#[should_panic]
async fn test_advance_to_call_panic() {
let cnt = Rc::new(Cell::new(0));
let con = condition::Condition::new();
let srv = Pipeline::from(Srv(cnt.clone(), con.wait()));
// #[ntex::test]
// #[should_panic]
// async fn test_advance_to_call_panic() {
// let cnt = Rc::new(Cell::new(0));
// let con = condition::Condition::new();
// let srv = Pipeline::from(Srv(cnt.clone(), con.wait()));
let mut fut = srv.call("test");
let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
con.notify();
// let mut fut = srv.call("test");
// let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
// con.notify();
let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
let _f = fut.advance_to_call();
}
// let _ = lazy(|cx| Pin::new(&mut fut).poll(cx)).await;
// let _f = fut.advance_to_call();
// }
}

29
ntex-service/src/fn_service.rs
View file

@ -1,4 +1,4 @@
use std::{fmt, future::ready, future::Future, future::Ready, marker::PhantomData};
use std::{fmt, future::Future, marker::PhantomData};
use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
@ -133,11 +133,10 @@ where
{
type Response = Res;
type Error = Err;
type Future<'f> = Fut where Self: 'f, Req: 'f;
#[inline]
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
(self.f)(req)
async fn call(&self, req: Req, _: ServiceCtx<'_, Self>) -> Result<Res, Err> {
(self.f)(req).await
}
}
@ -207,11 +206,10 @@ where
{
type Response = Res;
type Error = Err;
type Future<'f> = Fut where Self: 'f;
#[inline]
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
(self.f)(req)
async fn call(&self, req: Req, _: ServiceCtx<'_, Self>) -> Result<Res, Err> {
(self.f)(req).await
}
}
@ -226,14 +224,13 @@ where
type Service = FnService<F, Req>;
type InitError = ();
type Future<'f> = Ready<Result<Self::Service, Self::InitError>> where Self: 'f;
#[inline]
fn create(&self, _: Cfg) -> Self::Future<'_> {
ready(Ok(FnService {
async fn create(&self, _: Cfg) -> Result<Self::Service, Self::InitError> {
Ok(FnService {
f: self.f.clone(),
_t: PhantomData,
}))
})
}
}
@ -300,11 +297,10 @@ where
type Service = Srv;
type InitError = Err;
type Future<'f> = Fut where Self: 'f, Fut: 'f;
#[inline]
fn create(&self, cfg: Cfg) -> Self::Future<'_> {
(self.f)(cfg)
async fn create(&self, cfg: Cfg) -> Result<Self::Service, Self::InitError> {
(self.f)(cfg).await
}
}
@ -341,11 +337,10 @@ where
type Error = S::Error;
type Service = S;
type InitError = E;
type Future<'f> = R where Self: 'f, R: 'f;
#[inline]
fn create(&self, _: C) -> Self::Future<'_> {
(self.f)()
async fn create(&self, _: C) -> Result<S, E> {
(self.f)().await
}
}

8
ntex-service/src/fn_shutdown.rs
View file

@ -1,5 +1,4 @@
use std::task::{Context, Poll};
use std::{cell::Cell, fmt, future::ready, future::Ready, marker::PhantomData};
use std::{cell::Cell, fmt, marker::PhantomData, task::Context, task::Poll};
use crate::{Service, ServiceCtx};
@ -55,7 +54,6 @@ where
{
type Response = Req;
type Error = Err;
type Future<'f> = Ready<Result<Req, Err>> where Self: 'f, Req: 'f;
#[inline]
fn poll_shutdown(&self, _: &mut Context<'_>) -> Poll<()> {
@ -66,8 +64,8 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ready(Ok(req))
async fn call(&self, req: Req, _: ServiceCtx<'_, Self>) -> Result<Req, Err> {
Ok(req)
}
}

95
ntex-service/src/lib.rs
View file

@ -6,9 +6,7 @@
missing_debug_implementations
)]
use std::future::Future;
use std::rc::Rc;
use std::task::{self, Context, Poll};
use std::{future::Future, rc::Rc, task, task::Context, task::Poll};
mod and_then;
mod apply;
@ -28,7 +26,7 @@ mod then;
pub use self::apply::{apply_fn, apply_fn_factory};
pub use self::chain::{chain, chain_factory};
pub use self::ctx::{ServiceCall, ServiceCallToCall, ServiceCtx};
pub use self::ctx::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};
@ -62,8 +60,6 @@ pub use self::pipeline::{Pipeline, PipelineCall};
///
/// ```rust
/// # use std::convert::Infallible;
/// # use std::future::Future;
/// # use std::pin::Pin;
/// #
/// # use ntex_service::{Service, ServiceCtx};
///
@ -72,10 +68,9 @@ pub use self::pipeline::{Pipeline, PipelineCall};
/// impl Service<u8> for MyService {
/// type Response = u64;
/// type Error = Infallible;
/// type Future<'f> = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
///
/// fn call<'a>(&'a self, req: u8, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
/// Box::pin(std::future::ready(Ok(req as u64)))
/// async fn call(&self, req: u8, _: ServiceCtx<'_, Self>) -> Result<Self::Response, Self::Error> {
/// Ok(req as u64)
/// }
/// }
/// ```
@ -97,19 +92,17 @@ pub trait Service<Req> {
/// Errors produced by the service when polling readiness or executing call.
type Error;
/// The future response value.
type Future<'f>: Future<Output = Result<Self::Response, Self::Error>>
where
Req: 'f,
Self: 'f;
/// Process the request and return the response asynchronously.
///
/// This function is expected to be callable off-task. As such, implementations of `call`
/// 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: ServiceCtx<'a, Self>) -> Self::Future<'a>;
fn call(
&self,
req: Req,
ctx: ServiceCtx<'_, Self>,
) -> impl Future<Output = Result<Self::Response, Self::Error>>;
#[inline]
/// Returns `Ready` when the service is able to process requests.
@ -170,15 +163,6 @@ pub trait Service<Req> {
{
chain(dev::MapErr::new(self, f))
}
#[inline]
/// Convert `Self` to a `ServiceChain`
fn chain(self) -> dev::ServiceChain<Self, Req>
where
Self: Sized,
{
chain(self)
}
}
/// Factory for creating `Service`s.
@ -205,21 +189,19 @@ pub trait ServiceFactory<Req, Cfg = ()> {
/// Errors potentially raised while building a service.
type InitError;
/// The future of the `ServiceFactory` instance.
type Future<'f>: Future<Output = Result<Self::Service, Self::InitError>>
where
Cfg: 'f,
Self: 'f;
/// Create and return a new service value asynchronously.
fn create(&self, cfg: Cfg) -> Self::Future<'_>;
fn create(
&self,
cfg: Cfg,
) -> impl Future<Output = Result<Self::Service, Self::InitError>>;
#[allow(async_fn_in_trait)]
/// Create and return a new service value asynchronously and wrap into a container
fn pipeline(&self, cfg: Cfg) -> dev::CreatePipeline<'_, Self, Req, Cfg>
async fn pipeline(&self, cfg: Cfg) -> Result<Pipeline<Self::Service>, Self::InitError>
where
Self: Sized,
{
dev::CreatePipeline::new(self.create(cfg))
Ok(Pipeline::new(self.create(cfg).await?))
}
#[inline]
@ -269,7 +251,6 @@ where
{
type Response = S::Response;
type Error = S::Error;
type Future<'f> = S::Future<'f> where 'a: 'f, Req: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
@ -282,8 +263,12 @@ where
}
#[inline]
fn call<'s>(&'s self, request: Req, ctx: ServiceCtx<'s, Self>) -> S::Future<'s> {
ctx.call_nowait(&**self, request)
async fn call(
&self,
request: Req,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call_nowait(&**self, request).await
}
}
@ -293,7 +278,6 @@ where
{
type Response = S::Response;
type Error = S::Error;
type Future<'f> = S::Future<'f> where S: 'f, Req: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
@ -306,8 +290,12 @@ where
}
#[inline]
fn call<'a>(&'a self, request: Req, ctx: ServiceCtx<'a, Self>) -> S::Future<'a> {
ctx.call_nowait(&**self, request)
async fn call(
&self,
request: Req,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call_nowait(&**self, request).await
}
}
@ -319,10 +307,9 @@ where
type Error = S::Error;
type Service = S::Service;
type InitError = S::InitError;
type Future<'f> = S::Future<'f> where S: 'f, Cfg: 'f;
fn create(&self, cfg: Cfg) -> S::Future<'_> {
self.as_ref().create(cfg)
async fn create(&self, cfg: Cfg) -> Result<Self::Service, Self::InitError> {
self.as_ref().create(cfg).await
}
}
@ -333,15 +320,6 @@ where
{
/// Convert to a `Service`
fn into_service(self) -> Svc;
#[inline]
/// Convert `Self` to a `ServiceChain`
fn into_chain(self) -> dev::ServiceChain<Svc, Req>
where
Self: Sized,
{
chain(self)
}
}
/// Trait for types that can be converted to a `ServiceFactory`
@ -351,15 +329,6 @@ where
{
/// Convert `Self` to a `ServiceFactory`
fn into_factory(self) -> T;
#[inline]
/// Convert `Self` to a `ServiceChainFactory`
fn chain(self) -> dev::ServiceChainFactory<T, Req, Cfg>
where
Self: Sized,
{
chain_factory(self)
}
}
impl<Svc, Req> IntoService<Svc, Req> for Svc
@ -404,9 +373,5 @@ pub mod dev {
pub use crate::map_err::{MapErr, MapErrFactory};
pub use crate::map_init_err::MapInitErr;
pub use crate::middleware::ApplyMiddleware;
pub use crate::pipeline::CreatePipeline;
pub use crate::then::{Then, ThenFactory};
#[doc(hidden)]
pub type ApplyService<T> = crate::Pipeline<T>;
}

104
ntex-service/src/map.rs
View file

@ -1,6 +1,6 @@
use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker::PhantomData};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
use super::{Service, ServiceCtx, ServiceFactory};
/// Service for the `map` combinator, changing the type of a service's response.
///
@ -60,51 +60,17 @@ where
{
type Response = Res;
type Error = A::Error;
type Future<'f> = MapFuture<'f, A, F, Req, Res> where Self: 'f, Req: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
MapFuture {
fut: ctx.call(&self.service, req),
slf: self,
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct MapFuture<'f, A, F, Req, Res>
where
A: Service<Req>,
A: 'f,
Req: 'f,
F: Fn(A::Response) -> Res,
{
slf: &'f Map<A, F, Req, Res>,
#[pin]
fut: ServiceCall<'f, A, Req>,
}
}
impl<'f, A, F, Req, Res> Future for MapFuture<'f, A, F, Req, Res>
where
A: Service<Req> + 'f,
Req: 'f,
F: Fn(A::Response) -> Res,
{
type Output = Result<Res, A::Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project();
match this.fut.poll(cx) {
Poll::Ready(Ok(resp)) => Poll::Ready(Ok((self.project().slf.f)(resp))),
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
}
async fn call(
&self,
req: Req,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call(&self.service, req).await.map(|r| (self.f)(r))
}
}
@ -167,55 +133,22 @@ where
type Service = Map<A::Service, F, Req, Res>;
type InitError = A::InitError;
type Future<'f> = MapFactoryFuture<'f, A, F, Req, Res, Cfg> where Self: 'f, Cfg: 'f;
#[inline]
fn create(&self, cfg: Cfg) -> Self::Future<'_> {
MapFactoryFuture {
fut: self.a.create(cfg),
f: Some(self.f.clone()),
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct MapFactoryFuture<'f, A, F, Req, Res, Cfg>
where
A: ServiceFactory<Req, Cfg>,
A: 'f,
F: Fn(A::Response) -> Res,
Cfg: 'f,
{
#[pin]
fut: A::Future<'f>,
f: Option<F>,
}
}
impl<'f, A, F, Req, Res, Cfg> Future for MapFactoryFuture<'f, A, F, Req, Res, Cfg>
where
A: ServiceFactory<Req, Cfg>,
F: Fn(A::Response) -> Res,
{
type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if let Poll::Ready(svc) = this.fut.poll(cx)? {
Poll::Ready(Ok(Map::new(svc, this.f.take().unwrap())))
} else {
Poll::Pending
}
async fn create(&self, cfg: Cfg) -> Result<Self::Service, Self::InitError> {
Ok(Map {
service: self.a.create(cfg).await?,
f: self.f.clone(),
_t: PhantomData,
})
}
}
#[cfg(test)]
mod tests {
use ntex_util::future::{lazy, Ready};
use ntex_util::future::lazy;
use std::task::{Context, Poll};
use super::*;
use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
#[derive(Debug, Clone)]
@ -224,14 +157,13 @@ mod tests {
impl Service<()> for Srv {
type Response = ();
type Error = ();
type Future<'f> = Ready<(), ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
Ok(())
}
}

64
ntex-service/src/map_config.rs
View file

@ -1,4 +1,4 @@
use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker::PhantomData};
use super::{IntoServiceFactory, ServiceFactory};
@ -78,11 +78,9 @@ where
type Service = A::Service;
type InitError = A::InitError;
type Future<'f> = A::Future<'f> where Self: 'f;
fn create(&self, cfg: C) -> Self::Future<'_> {
let cfg = (self.f)(cfg);
self.a.create(cfg)
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.a.create((self.f)(cfg)).await
}
}
@ -108,37 +106,9 @@ where
type Service = A::Service;
type InitError = A::InitError;
type Future<'f> = UnitConfigFuture<'f, A, R, C> where Self: 'f, C: 'f;
fn create(&self, _: C) -> Self::Future<'_> {
UnitConfigFuture {
fut: self.factory.create(()),
_t: PhantomData,
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct UnitConfigFuture<'f, A, R, C>
where A: ServiceFactory<R>,
A: 'f,
C: 'f,
{
#[pin]
fut: A::Future<'f>,
_t: PhantomData<C>,
}
}
impl<'f, A, R, C> Future for UnitConfigFuture<'f, A, R, C>
where
A: ServiceFactory<R>,
{
type Output = Result<A::Service, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
self.project().fut.poll(cx)
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
self.factory.create(()).await
}
}
@ -175,28 +145,4 @@ mod tests {
.create(&10)
.await;
}
// #[ntex::test]
// async fn test_map_config_service() {
// let item = Rc::new(Cell::new(10usize));
// let item2 = item.clone();
// let srv = map_config_service(
// fn_factory_with_config(move |next: usize| {
// let item = item2.clone();
// async move {
// item.set(next);
// Ok::<_, ()>(fn_service(|id: usize| Ready::<_, ()>::Ok(id * 2)))
// }
// }),
// fn_service(move |item: usize| Ready::<_, ()>::Ok(item + 1)),
// )
// .clone()
// .create(10)
// .await
// .unwrap();
// assert_eq!(srv.call(10usize).await.unwrap(), 20);
// assert_eq!(item.get(), 11);
// }
}

91
ntex-service/src/map_err.rs
View file

@ -1,6 +1,6 @@
use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker::PhantomData, task::Context, task::Poll};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
use super::{Service, ServiceCtx, ServiceFactory};
/// Service for the `map_err` combinator, changing the type of a service's
/// error.
@ -61,7 +61,6 @@ where
{
type Response = A::Response;
type Error = E;
type Future<'f> = MapErrFuture<'f, A, R, F, E> where A: 'f, R: 'f, F: 'f, E: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -69,44 +68,17 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
MapErrFuture {
slf: self,
fut: ctx.call(&self.service, req),
}
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call(&self.service, req).await.map_err(|e| (self.f)(e))
}
crate::forward_poll_shutdown!(service);
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct MapErrFuture<'f, A, R, F, E>
where
A: Service<R>,
A: 'f,
R: 'f,
F: Fn(A::Error) -> E,
{
slf: &'f MapErr<A, F, E>,
#[pin]
fut: ServiceCall<'f, A, R>,
}
}
impl<'f, A, R, F, E> Future for MapErrFuture<'f, A, R, F, E>
where
A: Service<R> + 'f,
F: Fn(A::Error) -> E,
{
type Output = Result<A::Response, E>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project();
this.fut.poll(cx).map_err(|e| (self.project().slf.f)(e))
}
}
/// Factory for the `map_err` combinator, changing the type of a new
/// service's error.
///
@ -173,46 +145,14 @@ where
type Service = MapErr<A::Service, F, E>;
type InitError = A::InitError;
type Future<'f> = MapErrFactoryFuture<'f, A, R, C, F, E> where Self: 'f, C: 'f;
#[inline]
fn create(&self, cfg: C) -> Self::Future<'_> {
MapErrFactoryFuture {
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.a.create(cfg).await.map(|service| MapErr {
service,
f: self.f.clone(),
fut: self.a.create(cfg),
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct MapErrFactoryFuture<'f, A, R, C, F, E>
where
A: ServiceFactory<R, C>,
A: 'f,
F: Fn(A::Error) -> E,
C: 'f,
{
f: F,
#[pin]
fut: A::Future<'f>,
}
}
impl<'f, A, R, C, F, E> Future for MapErrFactoryFuture<'f, A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::Error) -> E + Clone,
{
type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if let Poll::Ready(svc) = this.fut.poll(cx)? {
Poll::Ready(Ok(MapErr::new(svc, this.f.clone())))
} else {
Poll::Pending
}
_t: PhantomData,
})
}
}
@ -229,7 +169,6 @@ mod tests {
impl Service<()> for Srv {
type Response = ();
type Error = ();
type Future<'f> = Ready<(), ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
if self.0 {
@ -239,8 +178,8 @@ mod tests {
}
}
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Err(())
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
Err(())
}
}

38
ntex-service/src/map_init_err.rs
View file

@ -1,4 +1,4 @@
use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker::PhantomData};
use super::ServiceFactory;
@ -60,42 +60,10 @@ where
type Service = A::Service;
type InitError = E;
type Future<'f> = MapInitErrFuture<'f, A, R, C, F, E> where Self: 'f, C: 'f;
#[inline]
fn create(&self, cfg: C) -> Self::Future<'_> {
MapInitErrFuture {
f: self.f.clone(),
fut: self.a.create(cfg),
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct MapInitErrFuture<'f, A, R, C, F, E>
where
A: ServiceFactory<R, C>,
A: 'f,
F: Fn(A::InitError) -> E,
C: 'f,
{
f: F,
#[pin]
fut: A::Future<'f>,
}
}
impl<'f, A, R, C, F, E> Future for MapInitErrFuture<'f, A, R, C, F, E>
where
A: ServiceFactory<R, C>,
F: Fn(A::InitError) -> E,
{
type Output = Result<A::Service, E>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project();
this.fut.poll(cx).map_err(|e| (self.project().f)(e))
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.a.create(cfg).await.map_err(|e| (self.f)(e))
}
}

71
ntex-service/src/middleware.rs
View file

@ -1,4 +1,4 @@
use std::{fmt, future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
use std::{fmt, marker::PhantomData, rc::Rc};
use crate::{IntoServiceFactory, Service, ServiceFactory};
@ -98,18 +98,18 @@ where
}
/// `Apply` middleware to a service factory.
pub struct ApplyMiddleware<T, S, C>(Rc<(T, S)>, marker::PhantomData<C>);
pub struct ApplyMiddleware<T, S, C>(Rc<(T, S)>, PhantomData<C>);
impl<T, S, C> ApplyMiddleware<T, S, C> {
/// Create new `ApplyMiddleware` service factory instance
pub(crate) fn new(mw: T, svc: S) -> Self {
Self(Rc::new((mw, svc)), marker::PhantomData)
Self(Rc::new((mw, svc)), PhantomData)
}
}
impl<T, S, C> Clone for ApplyMiddleware<T, S, C> {
fn clone(&self) -> Self {
Self(self.0.clone(), marker::PhantomData)
Self(self.0.clone(), PhantomData)
}
}
@ -137,46 +137,10 @@ where
type Service = T::Service;
type InitError = S::InitError;
type Future<'f> = ApplyMiddlewareFuture<'f, T, S, R, C> where Self: 'f, C: 'f;
#[inline]
fn create(&self, cfg: C) -> Self::Future<'_> {
ApplyMiddlewareFuture {
slf: self.0.clone(),
fut: self.0 .1.create(cfg),
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct ApplyMiddlewareFuture<'f, T, S, R, C>
where
S: ServiceFactory<R, C>,
S: 'f,
T: Middleware<S::Service>,
C: 'f,
{
slf: Rc<(T, S)>,
#[pin]
fut: S::Future<'f>,
}
}
impl<'f, T, S, R, C> Future for ApplyMiddlewareFuture<'f, T, S, R, C>
where
S: ServiceFactory<R, C>,
T: Middleware<S::Service>,
{
type Output = Result<T::Service, S::InitError>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project();
match this.fut.poll(cx)? {
Poll::Ready(srv) => Poll::Ready(Ok(this.slf.0.create(srv))),
Poll::Pending => Poll::Pending,
}
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
Ok(self.0 .0.create(self.0 .1.create(cfg).await?))
}
}
@ -224,43 +188,46 @@ where
#[allow(clippy::redundant_clone)]
mod tests {
use ntex_util::future::{lazy, Ready};
use std::marker;
use std::task::{Context, Poll};
use super::*;
use crate::{fn_service, Pipeline, Service, ServiceCall, ServiceCtx, ServiceFactory};
use crate::{fn_service, Pipeline, Service, ServiceCtx, ServiceFactory};
#[derive(Debug, Clone)]
struct Tr<R>(marker::PhantomData<R>);
struct Tr<R>(PhantomData<R>);
impl<S, R> Middleware<S> for Tr<R> {
type Service = Srv<S, R>;
fn create(&self, service: S) -> Self::Service {
Srv(service, marker::PhantomData)
Srv(service, PhantomData)
}
}
#[derive(Debug, Clone)]
struct Srv<S, R>(S, marker::PhantomData<R>);
struct Srv<S, R>(S, PhantomData<R>);
impl<S: Service<R>, R> Service<R> for Srv<S, R> {
type Response = S::Response;
type Error = S::Error;
type Future<'f> = ServiceCall<'f, S, R> where Self: 'f, R: 'f;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.poll_ready(cx)
}
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ctx.call(&self.0, req)
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<S::Response, S::Error> {
ctx.call(&self.0, req).await
}
}
#[ntex::test]
async fn middleware() {
let factory = apply(
Rc::new(Tr(marker::PhantomData).clone()),
Rc::new(Tr(PhantomData).clone()),
fn_service(|i: usize| Ready::<_, ()>::Ok(i * 2)),
)
.clone();
@ -279,7 +246,7 @@ mod tests {
let factory =
crate::chain_factory(fn_service(|i: usize| Ready::<_, ()>::Ok(i * 2)))
.apply(Rc::new(Tr(marker::PhantomData).clone()))
.apply(Rc::new(Tr(PhantomData).clone()))
.clone();
let srv = Pipeline::new(factory.create(&()).await.unwrap().clone());

82
ntex-service/src/pipeline.rs
View file

@ -1,6 +1,7 @@
use std::{cell::Cell, future, pin::Pin, rc::Rc, task, task::Context, task::Poll};
use std::future::{poll_fn, Future};
use std::{cell::Cell, pin::Pin, rc::Rc, task, task::Context, task::Poll};
use crate::{ctx::ServiceCall, ctx::Waiters, Service, ServiceCtx, ServiceFactory};
use crate::{ctx::Waiters, Service, ServiceCtx};
#[derive(Debug)]
/// Container for a service.
@ -29,6 +30,15 @@ impl<S> Pipeline<S> {
self.svc.as_ref()
}
#[inline]
/// Returns when the service is able to process requests.
pub async fn ready<R>(&self) -> Result<(), S::Error>
where
S: Service<R>,
{
poll_fn(move |cx| self.poll_ready(cx)).await
}
#[inline]
/// Returns `Ready` when the service is able to process requests.
pub fn poll_ready<R>(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>>
@ -55,26 +65,21 @@ impl<S> Pipeline<S> {
self.svc.poll_shutdown(cx)
}
#[deprecated(since = "1.2.3", note = "Use Pipeline::call() instead")]
#[doc(hidden)]
#[inline]
/// Wait for service readiness and then create future object
/// that resolves to service result.
pub fn service_call<R>(&self, req: R) -> ServiceCall<'_, S, R>
pub async fn call<R>(&self, req: R) -> Result<S::Response, S::Error>
where
S: Service<R>,
{
ServiceCall::call_pipeline(req, self)
}
// check service readiness
self.ready().await?;
#[inline]
/// Wait for service readiness and then create future object
/// that resolves to service result.
pub fn call<R>(&self, req: R) -> ServiceCall<'_, S, R>
where
S: Service<R>,
{
ServiceCall::call_pipeline(req, self)
// call service
self.svc
.as_ref()
.call(req, ServiceCtx::new(&self.waiters))
.await
}
#[inline]
@ -130,6 +135,8 @@ impl<S> Clone for Pipeline<S> {
}
}
type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct PipelineCall<S, R>
@ -153,7 +160,7 @@ pin_project_lite::pin_project! {
Req: 'static,
{
Ready { req: Option<Req> },
Call { #[pin] fut: S::Future<'static> },
Call { #[pin] fut: BoxFuture<'static, Result<S::Response, S::Error>> },
Empty,
}
}
@ -163,9 +170,10 @@ where
S: Service<R> + 'static,
R: 'static,
{
fn new_call(pl: &Pipeline<S>, req: R) -> Self {
fn new_call<'a>(pl: &'a Pipeline<S>, req: R) -> Self {
let ctx = ServiceCtx::new(&pl.waiters);
let svc_call = pl.get_ref().call(req, ctx);
let svc_call: BoxFuture<'a, Result<S::Response, S::Error>> =
Box::pin(pl.get_ref().call(req, ctx));
// SAFETY: `svc_call` has same lifetime same as lifetime of `pl.svc`
// Pipeline::svc is heap allocated(Rc<S>), we keep it alive until
@ -176,7 +184,7 @@ where
}
}
impl<S, R> future::Future for PipelineCall<S, R>
impl<S, R> Future for PipelineCall<S, R>
where
S: Service<R>,
{
@ -204,39 +212,3 @@ where
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct CreatePipeline<'f, F, R, C>
where F: ServiceFactory<R, C>,
F: ?Sized,
F: 'f,
C: 'f,
{
#[pin]
fut: F::Future<'f>,
}
}
impl<'f, F, R, C> CreatePipeline<'f, F, R, C>
where
F: ServiceFactory<R, C> + 'f,
{
pub(crate) fn new(fut: F::Future<'f>) -> Self {
Self { fut }
}
}
impl<'f, F, R, C> future::Future for CreatePipeline<'f, F, R, C>
where
F: ServiceFactory<R, C> + 'f,
{
type Output = Result<Pipeline<F::Service>, F::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Poll::Ready(Ok(Pipeline::new(std::task::ready!(self
.project()
.fut
.poll(cx))?)))
}
}

176
ntex-service/src/then.rs
View file

@ -1,6 +1,6 @@
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use std::{task::Context, task::Poll};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
use super::{Service, ServiceCtx, ServiceFactory};
#[derive(Debug, Clone)]
/// Service for the `then` combinator, chaining a computation onto the end of
@ -26,7 +26,6 @@ where
{
type Response = B::Response;
type Error = B::Error;
type Future<'f> = ThenServiceResponse<'f, A, B, R> where Self: 'f, R: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -48,74 +47,12 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ThenServiceResponse {
slf: self,
state: State::A {
fut: ctx.call(&self.svc1, req),
ctx,
},
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct ThenServiceResponse<'f, A, B, R>
where
A: Service<R>,
B: Service<Result<A::Response, A::Error>>,
{
slf: &'f Then<A, B>,
#[pin]
state: State<'f, A, B, R>,
}
}
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<'f, A, B, R>
where
A: Service<R>,
A: 'f,
A::Response: 'f,
B: Service<Result<A::Response, A::Error>>,
B: 'f,
R: 'f,
{
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,
}
}
impl<'a, A, B, R> Future for ThenServiceResponse<'a, A, B, R>
where
A: Service<R>,
B: Service<Result<A::Response, A::Error>>,
{
type Output = Result<B::Response, B::Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A { fut, ctx } => match fut.poll(cx) {
Poll::Ready(res) => {
let fut = ctx.call(&this.slf.svc2, res);
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
StateProject::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
ctx.call(&self.svc2, ctx.call(&self.svc1, req).await).await
}
}
@ -149,73 +86,12 @@ where
type Service = Then<A::Service, B::Service>;
type InitError = A::InitError;
type Future<'f> = ThenFactoryResponse<'f, A, B, R, C> where Self: 'f, C: 'f;
fn create(&self, cfg: C) -> Self::Future<'_> {
ThenFactoryResponse {
fut_a: self.svc1.create(cfg.clone()),
fut_b: self.svc2.create(cfg),
a: None,
b: None,
}
}
}
pin_project_lite::pin_project! {
#[must_use = "futures do nothing unless polled"]
pub struct ThenFactoryResponse<'f, A, B, R, C>
where
A: ServiceFactory<R, C>,
B: ServiceFactory<Result<A::Response, A::Error>, C,
Error = A::Error,
InitError = A::InitError,
>,
A: 'f,
B: 'f,
C: 'f,
{
#[pin]
fut_b: B::Future<'f>,
#[pin]
fut_a: A::Future<'f>,
a: Option<A::Service>,
b: Option<B::Service>,
}
}
impl<'f, A, B, R, C> Future for ThenFactoryResponse<'f, A, B, R, C>
where
A: ServiceFactory<R, C>,
B: ServiceFactory<
Result<A::Response, A::Error>,
C,
Error = A::Error,
InitError = A::InitError,
>,
{
type Output = Result<Then<A::Service, B::Service>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if this.a.is_none() {
if let Poll::Ready(service) = this.fut_a.poll(cx)? {
*this.a = Some(service);
}
}
if this.b.is_none() {
if let Poll::Ready(service) = this.fut_b.poll(cx)? {
*this.b = Some(service);
}
}
if this.a.is_some() && this.b.is_some() {
Poll::Ready(Ok(Then::new(
this.a.take().unwrap(),
this.b.take().unwrap(),
)))
} else {
Poll::Pending
}
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
Ok(Then {
svc1: self.svc1.create(cfg.clone()).await?,
svc2: self.svc2.create(cfg).await?,
})
}
}
@ -232,21 +108,20 @@ mod tests {
impl Service<Result<&'static str, &'static str>> for Srv1 {
type Response = &'static str;
type Error = ();
type Future<'f> = Ready<Self::Response, Self::Error>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: Result<&'static str, &'static str>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
_: ServiceCtx<'_, Self>,
) -> Result<&'static str, ()> {
match req {
Ok(msg) => Ready::Ok(msg),
Err(_) => Ready::Err(()),
Ok(msg) => Ok(msg),
Err(_) => Err(()),
}
}
}
@ -257,21 +132,20 @@ mod tests {
impl Service<Result<&'static str, ()>> for Srv2 {
type Response = (&'static str, &'static str);
type Error = ();
type Future<'f> = Ready<Self::Response, ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1);
Poll::Ready(Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: Result<&'static str, ()>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, ()> {
match req {
Ok(msg) => Ready::Ok((msg, "ok")),
Err(()) => Ready::Ok(("srv2", "err")),
Ok(msg) => Ok((msg, "ok")),
Err(()) => Ok(("srv2", "err")),
}
}
}

4
ntex-tls/CHANGES.md
View file

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

10
ntex-tls/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-tls"
version = "0.3.3"
version = "1.0.0-b.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.0-b.0"
ntex-util = "1.0.0-b.0"
ntex-service = "2.0.0-b.0"
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", features = ["openssl", "rustls", "tokio"] }
ntex = { version = "1.0.0-b.0", features = ["openssl", "rustls", "tokio"] }
env_logger = "0.10"
rustls-pemfile = "1.0"
webpki-roots = "0.25"

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

4
ntex-tokio/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.4.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.3.1] - 2023-11-12
* Optimize io read task

6
ntex-tokio/Cargo.toml
View file

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

4
ntex-util/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [1.0.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.3.4] - 2023-11-06
* Add UnwindSafe trait on mpsc::Receiver<T> #239

8
ntex-util/Cargo.toml
View file

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

4
ntex-util/src/channel/condition.rs
View file

@ -1,8 +1,8 @@
use slab::Slab;
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use std::{future::poll_fn, future::Future, pin::Pin, task::Context, task::Poll};
use super::cell::Cell;
use crate::{future::poll_fn, task::LocalWaker};
use crate::task::LocalWaker;
/// Condition allows to notify multiple waiters at the same time
#[derive(Clone, Debug)]

8
ntex-util/src/channel/mpsc.rs
View file

@ -1,13 +1,13 @@
//! A multi-producer, single-consumer, futures-aware, FIFO queue.
use std::{
collections::VecDeque, fmt, panic::UnwindSafe, pin::Pin, task::Context, task::Poll,
};
use std::collections::VecDeque;
use std::future::poll_fn;
use std::{fmt, panic::UnwindSafe, pin::Pin, task::Context, task::Poll};
use futures_core::{FusedStream, Stream};
use futures_sink::Sink;
use super::cell::{Cell, WeakCell};
use crate::{future::poll_fn, task::LocalWaker};
use crate::task::LocalWaker;
/// Creates a unbounded in-memory channel with buffered storage.
pub fn channel<T>() -> (Sender<T>, Receiver<T>) {

4
ntex-util/src/channel/oneshot.rs
View file

@ -1,8 +1,8 @@
//! A one-shot, futures-aware channel.
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use std::{future::poll_fn, future::Future, pin::Pin, task::Context, task::Poll};
use super::{cell::Cell, Canceled};
use crate::{future::poll_fn, task::LocalWaker};
use crate::task::LocalWaker;
/// Creates a new futures-aware, one-shot channel.
pub fn channel<T>() -> (Sender<T>, Receiver<T>) {

31
ntex-util/src/future/mod.rs
View file

@ -1,5 +1,5 @@
//! Utilities for futures
use std::{future::Future, mem, pin::Pin, task::Context, task::Poll};
use std::{future::poll_fn, future::Future, mem, pin::Pin, task::Context, task::Poll};
pub use futures_core::{Stream, TryFuture};
pub use futures_sink::Sink;
@ -20,35 +20,6 @@ pub use self::select::select;
/// you can't statically type your result or need to add some indirection.
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
/// Creates a new future wrapping around a function returning [`Poll`].
///
/// Polling the returned future delegates to the wrapped function.
pub fn poll_fn<T, F>(f: F) -> impl Future<Output = T>
where
F: FnMut(&mut Context<'_>) -> Poll<T>,
{
PollFn { f }
}
/// Future for the [`poll_fn`] function.
#[must_use = "futures do nothing unless you `.await` or poll them"]
struct PollFn<F> {
f: F,
}
impl<F> Unpin for PollFn<F> {}
impl<T, F> Future for PollFn<F>
where
F: FnMut(&mut Context<'_>) -> Poll<T>,
{
type Output = T;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
(self.f)(cx)
}
}
/// Creates a future that resolves to the next item in the stream.
pub async fn stream_recv<S>(stream: &mut S) -> Option<S::Item>
where

159
ntex-util/src/services/buffer.rs
View file

@ -1,11 +1,11 @@
//! Service that buffers incomming requests.
use std::cell::{Cell, RefCell};
use std::task::{ready, Context, Poll};
use std::{collections::VecDeque, fmt, future::Future, marker::PhantomData, pin::Pin};
use std::{collections::VecDeque, fmt, marker::PhantomData};
use ntex_service::{IntoService, Middleware, Service, ServiceCallToCall, ServiceCtx};
use ntex_service::{IntoService, Middleware, Service, ServiceCtx};
use crate::channel::{oneshot, Canceled};
use crate::channel::oneshot;
/// Buffer - service factory for service that can buffer incoming request.
///
@ -79,6 +79,31 @@ where
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BufferServiceError<E> {
Service(E),
RequestCanceled,
}
impl<E> From<E> for BufferServiceError<E> {
fn from(err: E) -> Self {
BufferServiceError::Service(err)
}
}
impl<E: std::fmt::Display> std::fmt::Display for BufferServiceError<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
BufferServiceError::Service(e) => std::fmt::Display::fmt(e, f),
BufferServiceError::RequestCanceled => {
f.write_str("buffer service request canceled")
}
}
}
}
impl<E: std::fmt::Display + std::fmt::Debug> std::error::Error for BufferServiceError<E> {}
/// Buffer service - service that can buffer incoming requests.
///
/// Default number of buffered requests is 16
@ -158,7 +183,6 @@ where
{
type Response = S::Response;
type Error = BufferServiceError<S::Error>;
type Future<'f> = BufferServiceResponse<'f, R, S> where Self: 'f, R: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -196,30 +220,6 @@ where
Poll::Ready(Ok(()))
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
if self.ready.get() {
self.ready.set(false);
BufferServiceResponse {
slf: self,
state: ResponseState::Running {
fut: ctx.call_nowait(&self.service, req),
},
}
} else {
let (tx, rx) = oneshot::channel();
self.buf.borrow_mut().push_back(tx);
BufferServiceResponse {
slf: self,
state: ResponseState::WaitingForRelease {
rx,
call: Some(ctx.call(&self.service, req).advance_to_call()),
},
}
}
}
fn poll_shutdown(&self, cx: &mut std::task::Context<'_>) -> Poll<()> {
let mut buffer = self.buf.borrow_mut();
if self.cancel_on_shutdown {
@ -257,97 +257,41 @@ where
self.service.poll_shutdown(cx)
}
}
pin_project_lite::pin_project! {
#[doc(hidden)]
#[must_use = "futures do nothing unless polled"]
pub struct BufferServiceResponse<'f, R, S: Service<R>>
{
#[pin]
state: ResponseState<'f, R, S>,
slf: &'f BufferService<R, S>,
}
}
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
if self.ready.get() {
self.ready.set(false);
Ok(ctx.call_nowait(&self.service, req).await?)
} else {
let (tx, rx) = oneshot::channel();
self.buf.borrow_mut().push_back(tx);
pin_project_lite::pin_project! {
#[project = ResponseStateProject]
enum ResponseState<'f, R, S: Service<R>>
{
WaitingForRelease { rx: oneshot::Receiver<oneshot::Sender<()>>, call: Option<ServiceCallToCall<'f, S, R>> },
WaitingForReady { tx: oneshot::Sender<()>, #[pin] call: ServiceCallToCall<'f, S, R> },
Running { #[pin] fut: S::Future<'f> },
}
}
// release
let _task_guard = rx.recv().await.map_err(|_| {
log::trace!("Buffered service request canceled");
BufferServiceError::RequestCanceled
})?;
impl<'f, R, S> Future for BufferServiceResponse<'f, R, S>
where
S: Service<R>,
{
type Output = Result<S::Response, BufferServiceError<S::Error>>;
// check service readiness
ctx.ready(&self.service).await?;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
ResponseStateProject::WaitingForRelease { rx, call } => {
match ready!(rx.poll_recv(cx)) {
Ok(tx) => {
let call = call.take().expect("always set in this state");
this.state.set(ResponseState::WaitingForReady { tx, call });
self.poll(cx)
}
Err(Canceled) => {
log::trace!("Buffered service request canceled");
Poll::Ready(Err(BufferServiceError::RequestCanceled))
}
}
}
ResponseStateProject::WaitingForReady { call, .. } => {
let fut = match ready!(call.poll(cx)) {
Ok(fut) => fut,
Err(err) => return Poll::Ready(Err(err.into())),
};
this.state.set(ResponseState::Running { fut });
self.poll(cx)
}
ResponseStateProject::Running { fut } => fut.poll(cx).map_err(|e| e.into()),
// call service
Ok(ctx.call_nowait(&self.service, req).await?)
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BufferServiceError<E> {
Service(E),
RequestCanceled,
}
impl<E> From<E> for BufferServiceError<E> {
fn from(err: E) -> Self {
BufferServiceError::Service(err)
}
}
impl<E: std::fmt::Display> std::fmt::Display for BufferServiceError<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
BufferServiceError::Service(e) => std::fmt::Display::fmt(e, f),
BufferServiceError::RequestCanceled => {
f.write_str("buffer service request canceled")
}
}
}
}
impl<E: std::fmt::Display + std::fmt::Debug> std::error::Error for BufferServiceError<E> {}
#[cfg(test)]
mod tests {
use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceFactory};
use std::{rc::Rc, task::Context, task::Poll, time::Duration};
use super::*;
use crate::future::{lazy, Ready};
use crate::future::lazy;
use crate::task::LocalWaker;
#[derive(Clone)]
@ -362,7 +306,6 @@ mod tests {
impl Service<()> for TestService {
type Response = ();
type Error = ();
type Future<'f> = Ready<(), ()> where Self: 'f;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.waker.register(cx.waker());
@ -373,10 +316,10 @@ mod tests {
}
}
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
self.0.ready.set(false);
self.0.count.set(self.0.count.get() + 1);
Ready::Ok(())
Ok(())
}
}

51
ntex-util/src/services/inflight.rs
View file

@ -1,9 +1,9 @@
//! Service that limits number of in-flight async requests.
use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{task::Context, task::Poll};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use ntex_service::{IntoService, Middleware, Service, ServiceCtx};
use super::counter::{Counter, CounterGuard};
use super::counter::Counter;
/// InFlight - service factory for service that can limit number of in-flight
/// async requests.
@ -62,7 +62,6 @@ where
{
type Response = T::Response;
type Error = T::Error;
type Future<'f> = InFlightServiceResponse<'f, T, R> where Self: 'f, R: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -77,57 +76,35 @@ where
}
#[inline]
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(),
_t: PhantomData,
}
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let _guard = self.count.get();
ctx.call(&self.service, req).await
}
ntex_service::forward_poll_shutdown!(service);
}
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct InFlightServiceResponse<'f, T: Service<R>, R>
where T: 'f, R: 'f
{
#[pin]
fut: ServiceCall<'f, T, R>,
_guard: CounterGuard,
_t: PhantomData<R>
}
}
impl<'f, T: Service<R>, R> Future for InFlightServiceResponse<'f, T, R> {
type Output = Result<T::Response, T::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
self.project().fut.poll(cx)
}
}
#[cfg(test)]
mod tests {
use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
use std::{cell::RefCell, task::Poll, time::Duration};
use super::*;
use crate::{channel::oneshot, future::lazy, future::BoxFuture};
use crate::{channel::oneshot, future::lazy};
struct SleepService(oneshot::Receiver<()>);
impl Service<()> for SleepService {
type Response = ();
type Error = ();
type Future<'f> = BoxFuture<'f, Result<(), ()>>;
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(async move {
let _ = self.0.recv().await;
Ok::<_, ()>(())
})
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
let _ = self.0.recv().await;
Ok(())
}
}

14
ntex-util/src/services/keepalive.rs
View file

@ -3,7 +3,6 @@ use std::{cell::Cell, convert::Infallible, fmt, marker, time::Duration, time::In
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use crate::future::Ready;
use crate::time::{now, sleep, Millis, Sleep};
/// KeepAlive service factory
@ -60,13 +59,13 @@ where
{
type Response = R;
type Error = E;
type InitError = Infallible;
type Service = KeepAliveService<R, E, F>;
type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f, C: 'f;
type InitError = Infallible;
#[inline]
fn create(&self, _: C) -> Self::Future<'_> {
Ready::Ok(KeepAliveService::new(self.ka, self.f.clone()))
async fn create(&self, _: C) -> Result<Self::Service, Self::InitError> {
Ok(KeepAliveService::new(self.ka, self.f.clone()))
}
}
@ -111,7 +110,6 @@ where
{
type Response = R;
type Error = E;
type Future<'f> = Ready<R, E> where Self: 'f, R: 'f;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
match self.sleep.poll_elapsed(cx) {
@ -132,9 +130,9 @@ where
}
}
fn call<'a>(&'a self, req: R, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(&self, req: R, _: ServiceCtx<'_, Self>) -> Result<R, E> {
self.expire.set(now());
Ready::Ok(req)
Ok(req)
}
}

54
ntex-util/src/services/onerequest.rs
View file

@ -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 std::{cell::Cell, task::Context, task::Poll};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use ntex_service::{IntoService, Middleware, Service, ServiceCtx};
use crate::task::LocalWaker;
@ -49,7 +49,6 @@ where
{
type Response = T::Response;
type Error = T::Error;
type Future<'f> = OneRequestServiceResponse<'f, T, R> where Self: 'f, R: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -64,62 +63,39 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(
&self,
req: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.ready.set(false);
OneRequestServiceResponse {
fut: ctx.call(&self.service, req),
service: self,
}
let result = ctx.call(&self.service, req).await;
self.ready.set(true);
self.waker.wake();
result
}
ntex_service::forward_poll_shutdown!(service);
}
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct OneRequestServiceResponse<'f, T: Service<R>, R>
where T: 'f, R: 'f
{
#[pin]
fut: ServiceCall<'f, T, R>,
service: &'f OneRequestService<T>,
}
}
impl<'f, T: Service<R>, R> Future for OneRequestServiceResponse<'f, T, R> {
type Output = Result<T::Response, T::Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let result = self.as_mut().project().fut.poll(cx);
if result.is_ready() {
self.service.ready.set(true);
self.service.waker.wake();
}
result
}
}
#[cfg(test)]
mod tests {
use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
use std::{cell::RefCell, task::Poll, time::Duration};
use super::*;
use crate::{channel::oneshot, future::lazy, future::BoxFuture};
use crate::{channel::oneshot, future::lazy};
struct SleepService(oneshot::Receiver<()>);
impl Service<()> for SleepService {
type Response = ();
type Error = ();
type Future<'f> = BoxFuture<'f, Result<(), ()>>;
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(async move {
let _ = self.0.recv().await;
Ok::<_, ()>(())
})
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), ()> {
let _ = self.0.recv().await;
Ok::<_, ()>(())
}
}

109
ntex-util/src/services/timeout.rs
View file

@ -2,12 +2,12 @@
//!
//! If the response does not complete within the specified timeout, the response
//! will be aborted.
use std::{fmt, future::Future, marker, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use ntex_service::{IntoService, Middleware, Service, ServiceCtx};
use crate::future::Either;
use crate::time::{sleep, Millis, Sleep};
use crate::future::{select, Either};
use crate::time::{sleep, Millis};
/// Applies a timeout to requests.
///
@ -123,20 +123,21 @@ where
{
type Response = S::Response;
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: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(
&self,
request: R,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
if self.timeout.is_zero() {
Either::Right(TimeoutServiceResponse2 {
fut: ctx.call(&self.service, request),
_t: marker::PhantomData,
})
ctx.call(&self.service, request)
.await
.map_err(TimeoutError::Service)
} else {
Either::Left(TimeoutServiceResponse {
fut: ctx.call(&self.service, request),
sleep: sleep(self.timeout),
_t: marker::PhantomData,
})
match select(sleep(self.timeout), ctx.call(&self.service, request)).await {
Either::Left(_) => Err(TimeoutError::Timeout),
Either::Right(res) => res.map_err(TimeoutError::Service),
}
}
}
@ -144,72 +145,6 @@ where
ntex_service::forward_poll_shutdown!(service);
}
pin_project_lite::pin_project! {
/// `TimeoutService` response future
#[doc(hidden)]
#[must_use = "futures do nothing unless polled"]
pub struct TimeoutServiceResponse<'f, T: Service<R>, R>
where T: 'f, R: 'f,
{
#[pin]
fut: ServiceCall<'f, T, R>,
sleep: Sleep,
_t: marker::PhantomData<R>
}
}
impl<'f, T, R> Future for TimeoutServiceResponse<'f, T, R>
where
T: Service<R>,
{
type Output = Result<T::Response, TimeoutError<T::Error>>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
// First, try polling the future
match this.fut.poll(cx) {
Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)),
Poll::Ready(Err(e)) => return Poll::Ready(Err(TimeoutError::Service(e))),
Poll::Pending => {}
}
// Now check the sleep
match this.sleep.poll_elapsed(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(_) => Poll::Ready(Err(TimeoutError::Timeout)),
}
}
}
pin_project_lite::pin_project! {
/// `TimeoutService` response future
#[doc(hidden)]
#[must_use = "futures do nothing unless polled"]
pub struct TimeoutServiceResponse2<'f, T: Service<R>, R>
where T: 'f, R: 'f,
{
#[pin]
fut: ServiceCall<'f, T, R>,
_t: marker::PhantomData<R>,
}
}
impl<'f, T, R> Future for TimeoutServiceResponse2<'f, T, R>
where
T: Service<R>,
{
type Output = Result<T::Response, TimeoutError<T::Error>>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
match self.project().fut.poll(cx) {
Poll::Ready(Ok(v)) => Poll::Ready(Ok(v)),
Poll::Ready(Err(e)) => Poll::Ready(Err(TimeoutError::Service(e))),
Poll::Pending => Poll::Pending,
}
}
}
#[cfg(test)]
mod tests {
use std::{fmt, time::Duration};
@ -217,7 +152,7 @@ mod tests {
use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceFactory};
use super::*;
use crate::future::{lazy, BoxFuture};
use crate::future::lazy;
#[derive(Clone, Debug, PartialEq)]
struct SleepService(Duration);
@ -234,14 +169,10 @@ mod tests {
impl Service<()> for SleepService {
type Response = ();
type Error = SrvError;
type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
let fut = crate::time::sleep(self.0);
Box::pin(async move {
fut.await;
Ok::<_, SrvError>(())
})
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<(), SrvError> {
crate::time::sleep(self.0).await;
Ok::<_, SrvError>(())
}
}

132
ntex-util/src/services/variant.rs
View file

@ -1,7 +1,7 @@
//! Contains `Variant` service and related types and functions.
use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use std::{fmt, marker::PhantomData, task::Context, task::Poll};
use ntex_service::{IntoServiceFactory, Service, ServiceCall, ServiceCtx, ServiceFactory};
use ntex_service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
/// Construct `Variant` service factory.
///
@ -123,8 +123,6 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
{
type Response = V1::Response;
type Error = V1::Error;
type Future<'f> = $mod_name::ServiceResponse<
ServiceCall<'f, V1, V1R>, $(ServiceCall<'f, $T, $R>),+> where Self: 'f, V1: 'f;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let mut ready = self.V1.poll_ready(cx)?.is_ready();
@ -148,11 +146,11 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
}
}
fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>
async fn call(&self, req: $enum_type<V1R, $($R,)+>, ctx: ServiceCtx<'_, Self>) -> Result<Self::Response, Self::Error>
{
match req {
$enum_type::V1(req) => $mod_name::ServiceResponse::V1 { fut: ctx.call(&self.V1, req) },
$($enum_type::$T(req) => $mod_name::ServiceResponse::$T { fut: ctx.call(&self.$T, req) },)+
$enum_type::V1(req) => ctx.call(&self.V1, req).await,
$($enum_type::$T(req) => ctx.call(&self.$T, req).await,)+
}
}
}
@ -191,111 +189,17 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
{
type Response = V1::Response;
type Error = V1::Error;
type InitError = V1::InitError;
type Service = $srv_type<V1::Service, $($T::Service,)+ V1R, $($R,)+>;
type Future<'f> = $mod_name::ServiceFactoryResponse<'f, V1, V1C, $($T,)+ V1R, $($R,)+> where Self: 'f, V1C: 'f;
type InitError = V1::InitError;
fn create(&self, cfg: V1C) -> Self::Future<'_> {
$mod_name::ServiceFactoryResponse {
V1: None,
items: Default::default(),
$($T: self.$T.create(cfg.clone()),)+
V1_fut: self.V1.create(cfg),
}
async fn create(&self, cfg: V1C) -> Result<Self::Service, Self::InitError> {
Ok($srv_type {
V1: self.V1.create(cfg.clone()).await?,
$($T: self.$T.create(cfg.clone()).await?,)+
_t: PhantomData
})
}
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub mod $mod_name {
use super::*;
pin_project_lite::pin_project! {
#[project = ServiceResponseProject]
pub enum ServiceResponse<V1: Future, $($T: Future),+>
{
V1{ #[pin] fut: V1 },
$($T{ #[pin] fut: $T },)+
}
}
impl<V1, $($T),+> Future for ServiceResponse<V1, $($T),+>
where
V1: Future,
$($T: Future<Output = V1::Output>),+
{
type Output = V1::Output;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
match self.project() {
ServiceResponseProject::V1{fut} => fut.poll(cx),
$(ServiceResponseProject::$T{fut} => fut.poll(cx),)+
}
}
}
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct ServiceFactoryResponse<'f, V1: ServiceFactory<V1R, V1C>, V1C, $($T: ServiceFactory<$R, V1C>,)+ V1R, $($R,)+>
where
V1C: 'f,
V1: 'f,
$($T: 'f,)+
{
pub(super) V1: Option<V1::Service>,
pub(super) items: ($(Option<$T::Service>,)+),
#[pin] pub(super) V1_fut: V1::Future<'f>,
$(#[pin] pub(super) $T: $T::Future<'f>),+
}
}
impl<'f, V1, V1C, $($T,)+ V1R, $($R,)+> Future for ServiceFactoryResponse<'f, V1, V1C, $($T,)+ V1R, $($R,)+>
where
V1: ServiceFactory<V1R, V1C> + 'f,
$($T: ServiceFactory<$R, V1C, Response = V1::Response, Error = V1::Error, InitError = V1::InitError,> + 'f),+
{
type Output = Result<$srv_type<V1::Service, $($T::Service,)+ V1R, $($R),+>, V1::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
let mut ready = true;
if this.V1.is_none() {
match this.V1_fut.poll(cx) {
Poll::Ready(Ok(item)) => {
*this.V1 = Some(item);
}
Poll::Pending => ready = false,
Poll::Ready(Err(e)) => return Poll::Ready(Err(e.into())),
}
}
$(
if this.items.$n.is_none() {
match this.$T.poll(cx) {
Poll::Ready(Ok(item)) => {
this.items.$n = Some(item);
}
Poll::Pending => ready = false,
Poll::Ready(Err(e)) => return Poll::Ready(Err(e.into())),
}
}
)+
if ready {
Poll::Ready(Ok($srv_type {
V1: this.V1.take().unwrap(),
$($T: this.items.$n.take().unwrap(),)+
_t: PhantomData
}))
} else {
Poll::Pending
}
}
}
}
});
#[rustfmt::skip]
@ -332,7 +236,7 @@ mod tests {
use std::task::{Context, Poll};
use super::*;
use crate::future::{lazy, Ready};
use crate::future::lazy;
#[derive(Clone)]
struct Srv1;
@ -340,7 +244,6 @@ mod tests {
impl Service<()> for Srv1 {
type Response = usize;
type Error = ();
type Future<'f> = Ready<usize, ()> where Self: 'f;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
@ -350,8 +253,8 @@ mod tests {
Poll::Ready(())
}
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::<_, ()>::Ok(1)
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<usize, ()> {
Ok(1)
}
}
@ -361,7 +264,6 @@ mod tests {
impl Service<()> for Srv2 {
type Response = usize;
type Error = ();
type Future<'f> = Ready<usize, ()> where Self: 'f;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
@ -371,8 +273,8 @@ mod tests {
Poll::Ready(())
}
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::<_, ()>::Ok(2)
async fn call(&self, _: (), _: ServiceCtx<'_, Self>) -> Result<usize, ()> {
Ok(2)
}
}

4
ntex-util/src/time/mod.rs
View file

@ -1,5 +1,5 @@
//! Utilities for tracking time.
use std::{cmp, future::Future, pin::Pin, task, task::Poll};
use std::{cmp, future::poll_fn, future::Future, pin::Pin, task, task::Poll};
mod types;
mod wheel;
@ -312,7 +312,7 @@ impl Interval {
#[inline]
pub async fn tick(&self) {
crate::future::poll_fn(|cx| self.poll_tick(cx)).await;
poll_fn(|cx| self.poll_tick(cx)).await;
}
#[inline]

4
ntex/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [1.0.0-b.0] - 2024-01-07
* Use "async fn" in trait for Service definition
## [0.7.17] - 2024-01-05
* Allow to set default response payload limit and timeout

20
ntex/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex"
version = "0.7.17"
version = "1.0.0-b.0"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Framework for composable network services"
readme = "README.md"
@ -49,20 +49,20 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
[dependencies]
ntex-codec = "0.6.2"
ntex-connect = "0.3.4"
ntex-connect = "1.0.0-b.0"
ntex-http = "0.1.11"
ntex-router = "0.5.2"
ntex-service = "1.2.7"
ntex-service = "2.0.0-b.0"
ntex-macros = "0.1.3"
ntex-util = "0.3.4"
ntex-util = "1.0.0-b.0"
ntex-bytes = "0.1.21"
ntex-h2 = "0.4.4"
ntex-h2 = "0.5.0-b.0"
ntex-rt = "0.4.11"
ntex-io = "0.3.17"
ntex-tls = "0.3.3"
ntex-tokio = { version = "0.3.1", optional = true }
ntex-glommio = { version = "0.3.1", optional = true }
ntex-async-std = { version = "0.3.2", optional = true }
ntex-io = "1.0.0-b.0"
ntex-tls = "1.0.0-b.0"
ntex-tokio = { version = "0.4.0-b.0", optional = true }
ntex-glommio = { version = "0.4.0-b.0", optional = true }
ntex-async-std = { version = "0.4.0-b.0", optional = true }
async-channel = "2.1"
base64 = "0.21"

4
ntex/src/http/body.rs
View file

@ -543,10 +543,10 @@ where
#[cfg(test)]
mod tests {
use futures_util::stream;
use std::io;
use std::{future::poll_fn, io};
use super::*;
use crate::util::{poll_fn, Ready};
use crate::util::Ready;
impl Body {
pub(crate) fn get_ref(&self) -> &[u8] {

37
ntex/src/http/client/connector.rs
View file

@ -3,9 +3,9 @@ use std::{fmt, task::Context, task::Poll, time::Duration};
use ntex_h2::{self as h2};
use crate::connect::{Connect as TcpConnect, Connector as TcpConnector};
use crate::service::{apply_fn, boxed, Service, ServiceCall, ServiceCtx};
use crate::service::{apply_fn, boxed, Service, ServiceCtx};
use crate::time::{Millis, Seconds};
use crate::util::{timeout::TimeoutError, timeout::TimeoutService, Either, Ready};
use crate::util::{timeout::TimeoutError, timeout::TimeoutService};
use crate::{http::Uri, io::IoBoxed};
use super::{connection::Connection, error::ConnectError, pool::ConnectionPool, Connect};
@ -54,7 +54,6 @@ impl Connector {
let conn = Connector {
connector: boxed::service(
TcpConnector::new()
.chain()
.map(IoBoxed::from)
.map_err(ConnectError::from),
),
@ -192,12 +191,8 @@ impl Connector {
T: Service<TcpConnect<Uri>, Error = crate::connect::ConnectError> + 'static,
IoBoxed: From<T::Response>,
{
self.connector = boxed::service(
connector
.chain()
.map(IoBoxed::from)
.map_err(ConnectError::from),
);
self.connector =
boxed::service(connector.map(IoBoxed::from).map_err(ConnectError::from));
self
}
@ -208,10 +203,7 @@ impl Connector {
IoBoxed: From<T::Response>,
{
self.ssl_connector = Some(boxed::service(
connector
.chain()
.map(IoBoxed::from)
.map_err(ConnectError::from),
connector.map(IoBoxed::from).map_err(ConnectError::from),
));
self
}
@ -265,7 +257,6 @@ fn connector(
async move { srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr)).await },
)
})
.chain()
.map(move |io: IoBoxed| {
io.set_disconnect_timeout(disconnect_timeout);
io
@ -290,12 +281,7 @@ where
{
type Response = <ConnectionPool<T> as Service<Connect>>::Response;
type Error = ConnectError;
type Future<'f> = Either<
ServiceCall<'f, ConnectionPool<T>, Connect>,
Ready<Self::Response, Self::Error>,
>;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let ready = self.tcp_pool.poll_ready(cx)?.is_ready();
let ready = if let Some(ref ssl_pool) = self.ssl_pool {
@ -310,7 +296,6 @@ where
}
}
#[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
let tcp_ready = self.tcp_pool.poll_shutdown(cx).is_ready();
let ssl_ready = self
@ -325,16 +310,20 @@ where
}
}
fn call<'a>(&'a self, req: Connect, ctx: ServiceCtx<'a, Self>) -> Self::Future<'_> {
async fn call(
&self,
req: Connect,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
match req.uri.scheme_str() {
Some("https") | Some("wss") => {
if let Some(ref conn) = self.ssl_pool {
Either::Left(ctx.call(conn, req))
ctx.call(conn, req).await
} else {
Either::Right(Ready::Err(ConnectError::SslIsNotSupported))
Err(ConnectError::SslIsNotSupported)
}
}
_ => Either::Left(ctx.call(&self.tcp_pool, req)),
_ => ctx.call(&self.tcp_pool, req).await,
}
}
}

6
ntex/src/http/client/h1proto.rs
View file

@ -1,4 +1,6 @@
use std::{io, io::Write, pin::Pin, task::Context, task::Poll, time::Instant};
use std::{
future::poll_fn, io, io::Write, pin::Pin, task::Context, task::Poll, time::Instant,
};
use crate::http::body::{BodySize, MessageBody};
use crate::http::error::PayloadError;
@ -8,7 +10,7 @@ use crate::http::message::{RequestHeadType, ResponseHead};
use crate::http::payload::{Payload, PayloadStream};
use crate::io::{IoBoxed, RecvError};
use crate::time::{timeout_checked, Millis};
use crate::util::{poll_fn, ready, BufMut, Bytes, BytesMut, Stream};
use crate::util::{ready, BufMut, Bytes, BytesMut, Stream};
use super::connection::{Connection, ConnectionType};
use super::error::{ConnectError, SendRequestError};

4
ntex/src/http/client/h2proto.rs
View file

@ -1,4 +1,4 @@
use std::io;
use std::{future::poll_fn, io};
use ntex_h2::client::{RecvStream, SimpleClient};
use ntex_h2::{self as h2, frame};
@ -8,7 +8,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::time::{timeout_checked, Millis};
use crate::util::{poll_fn, ByteString, Bytes};
use crate::util::{ByteString, Bytes};
use super::error::{ConnectError, SendRequestError};

103
ntex/src/http/client/pool.rs
View file

@ -8,7 +8,7 @@ use crate::http::uri::{Authority, Scheme, Uri};
use crate::io::{types::HttpProtocol, IoBoxed};
use crate::service::{Pipeline, PipelineCall, Service, ServiceCtx};
use crate::time::{now, Seconds};
use crate::util::{ready, BoxFuture, ByteString, HashMap, HashSet};
use crate::util::{ready, ByteString, HashMap, HashSet};
use crate::{channel::pool, rt::spawn, task::LocalWaker};
use super::connection::{Connection, ConnectionType};
@ -116,61 +116,62 @@ where
{
type Response = Connection;
type Error = ConnectError;
type Future<'f> = BoxFuture<'f, Result<Connection, ConnectError>>;
crate::forward_poll_ready!(connector);
crate::forward_poll_shutdown!(connector);
fn call<'a>(&'a self, req: Connect, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
async fn call(
&self,
req: Connect,
_: ServiceCtx<'_, Self>,
) -> Result<Connection, ConnectError> {
trace!("Get connection for {:?}", req.uri);
let inner = self.inner.clone();
let waiters = self.waiters.clone();
Box::pin(async move {
let key = if let Some(authority) = req.uri.authority() {
authority.clone().into()
} else {
return Err(ConnectError::Unresolved);
};
let key = if let Some(authority) = req.uri.authority() {
authority.clone().into()
} else {
return Err(ConnectError::Unresolved);
};
// acquire connection
let result = inner.borrow_mut().acquire(&key);
match result {
// use existing connection
Acquire::Acquired(io, created) => {
trace!("Use existing {:?} connection for {:?}", io, req.uri);
Ok(Connection::new(
io,
created,
Some(Acquired::new(key, inner)),
))
}
// open new tcp connection
Acquire::Available => {
trace!("Connecting to {:?}", req.uri);
let uri = req.uri.clone();
let (tx, rx) = waiters.borrow_mut().pool.channel();
OpenConnection::spawn(key, tx, uri, inner, &self.connector, req);
// acquire connection
let result = inner.borrow_mut().acquire(&key);
match result {
// use existing connection
Acquire::Acquired(io, created) => {
trace!("Use existing {:?} connection for {:?}", io, req.uri);
Ok(Connection::new(
io,
created,
Some(Acquired::new(key, inner)),
))
}
// open new tcp connection
Acquire::Available => {
trace!("Connecting to {:?}", req.uri);
let uri = req.uri.clone();
let (tx, rx) = waiters.borrow_mut().pool.channel();
OpenConnection::spawn(key, tx, uri, inner, &self.connector, req);
match rx.await {
Err(_) => Err(ConnectError::Disconnected(None)),
Ok(res) => res,
}
}
// pool is full, wait
Acquire::NotAvailable => {
trace!(
"Pool is full, waiting for available connections for {:?}",
req.uri
);
let rx = waiters.borrow_mut().wait_for(req);
match rx.await {
Err(_) => Err(ConnectError::Disconnected(None)),
Ok(res) => res,
}
match rx.await {
Err(_) => Err(ConnectError::Disconnected(None)),
Ok(res) => res,
}
}
})
// pool is full, wait
Acquire::NotAvailable => {
trace!(
"Pool is full, waiting for available connections for {:?}",
req.uri
);
let rx = waiters.borrow_mut().wait_for(req);
match rx.await {
Err(_) => Err(ConnectError::Disconnected(None)),
Ok(res) => res,
}
}
}
}
}
@ -659,8 +660,8 @@ mod tests {
assert!(pool.get_ref().inner.borrow().connecting.is_empty());
// pool is full, waiting
let mut fut = pool.call(req.clone());
assert!(lazy(|cx| Pin::new(&mut fut).poll(cx)).await.is_pending());
let mut fut = std::pin::pin!(pool.call(req.clone()));
assert!(lazy(|cx| fut.as_mut().poll(cx)).await.is_pending());
assert_eq!(pool.get_ref().waiters.borrow().waiters.len(), 1);
// release connection and push it to next waiter
@ -676,8 +677,8 @@ mod tests {
assert_eq!(store.borrow().len(), 2);
assert_eq!(pool.get_ref().inner.borrow().acquired, 1);
assert!(pool.get_ref().inner.borrow().connecting.is_empty());
let mut fut = pool.call(req.clone());
assert!(lazy(|cx| Pin::new(&mut fut).poll(cx)).await.is_pending());
let mut fut = std::pin::pin!(pool.call(req.clone()));
assert!(lazy(|cx| fut.as_mut().poll(cx)).await.is_pending());
assert_eq!(pool.get_ref().waiters.borrow().waiters.len(), 1);
// release and close
@ -692,7 +693,7 @@ mod tests {
assert_eq!(pool.get_ref().inner.borrow().acquired, 1);
// drop waiter, no interest in connection
let mut fut = pool.call(req.clone());
let mut fut = Box::pin(pool.call(req.clone()));
assert!(lazy(|cx| Pin::new(&mut fut).poll(cx)).await.is_pending());
drop(fut);
sleep(Millis(50)).await;
@ -704,8 +705,8 @@ mod tests {
uri: Uri::try_from("http://localhost2/test").unwrap(),
addr: None,
};
let mut fut = pool.call(req.clone());
assert!(lazy(|cx| Pin::new(&mut fut).poll(cx)).await.is_pending());
let mut fut = std::pin::pin!(pool.call(req.clone()));
assert!(lazy(|cx| fut.as_mut().poll(cx)).await.is_pending());
assert_eq!(pool.get_ref().waiters.borrow().waiters.len(), 1);
conn.release(false);
assert_eq!(pool.get_ref().inner.borrow().acquired, 0);

18
ntex/src/http/h1/dispatcher.rs
View file

@ -117,7 +117,7 @@ where
// slow-request timer
let (flags, max_timeout) = if let Some(cfg) = config.headers_read_rate() {
io.start_timer_secs(cfg.timeout);
io.start_timer(cfg.timeout);
(Flags::READ_HDRS_TIMEOUT, cfg.max_timeout)
} else {
(Flags::empty(), Seconds::ZERO)
@ -888,7 +888,7 @@ where
self.io.tag(),
total
);
self.io.start_timer_secs(cfg.timeout);
self.io.start_timer(cfg.timeout);
return Ok(());
}
}
@ -935,7 +935,7 @@ where
);
self.flags.insert(Flags::READ_KA_TIMEOUT);
if self.config.keep_alive_enabled() {
self.io.start_timer_secs(self.config.keep_alive);
self.io.start_timer(self.config.keep_alive);
}
}
} else {
@ -957,7 +957,7 @@ where
self.read_consumed = 0;
self.read_remains = decoded.remains as u32;
self.read_max_timeout = cfg.max_timeout;
self.io.start_timer_secs(cfg.timeout);
self.io.start_timer(cfg.timeout);
}
None
}
@ -973,7 +973,7 @@ where
self.read_remains = decoded.remains as u32;
self.read_consumed = decoded.consumed as u32;
self.read_max_timeout = cfg.max_timeout;
self.io.start_timer_secs(cfg.timeout);
self.io.start_timer(cfg.timeout);
}
}
}
@ -981,7 +981,7 @@ where
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::{cell::Cell, io, sync::Arc};
use std::{cell::Cell, future::poll_fn, io, sync::Arc};
use ntex_h2::Config;
use rand::Rng;
@ -992,7 +992,7 @@ mod tests {
use crate::http::{body, Request, ResponseHead, StatusCode};
use crate::io::{self as nio, Base};
use crate::service::{boxed, fn_service, IntoService};
use crate::util::{lazy, poll_fn, stream_recv, Bytes, BytesMut};
use crate::util::{lazy, stream_recv, Bytes, BytesMut};
use crate::{codec::Decoder, testing::Io, time::sleep, time::Millis, time::Seconds};
const BUFFER_SIZE: usize = 32_768;
@ -1274,9 +1274,7 @@ mod tests {
assert!(lazy(|cx| Pin::new(&mut h1).poll(cx)).await.is_pending());
sleep(Millis(50)).await;
crate::util::poll_fn(|cx| Pin::new(&mut h1).poll(cx))
.await
.unwrap();
poll_fn(|cx| Pin::new(&mut h1).poll(cx)).await.unwrap();
assert!(h1.inner.io.is_closed());
let mut buf = BytesMut::from(&client.read().await.unwrap()[..]);

18
ntex/src/http/h1/expect.rs
View file

@ -1,7 +1,7 @@
use std::io;
use crate::http::request::Request;
use crate::service::{Service, ServiceCtx, ServiceFactory};
use crate::{http::request::Request, util::Ready};
#[derive(Copy, Clone, Debug)]
pub struct ExpectHandler;
@ -11,21 +11,21 @@ impl ServiceFactory<Request> for ExpectHandler {
type Error = io::Error;
type Service = ExpectHandler;
type InitError = io::Error;
type Future<'f> = Ready<Self::Service, Self::InitError>;
#[inline]
fn create(&self, _: ()) -> Self::Future<'_> {
Ready::Ok(ExpectHandler)
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
Ok(ExpectHandler)
}
}
impl Service<Request> for ExpectHandler {
type Response = Request;
type Error = io::Error;
type Future<'f> = Ready<Self::Response, Self::Error>;
#[inline]
fn call<'a>(&'a self, req: Request, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
Ready::Ok(req)
async fn call(
&self,
req: Request,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
Ok(req)
}
}

3
ntex/src/http/h1/payload.rs
View file

@ -205,8 +205,9 @@ impl Inner {
#[cfg(test)]
mod tests {
use std::future::poll_fn;
use super::*;
use crate::util::poll_fn;
#[crate::rt_test]
async fn test_unread_data() {

57
ntex/src/http/h1/service.rs
View file

@ -6,7 +6,6 @@ use crate::http::error::{DispatchError, ResponseError};
use crate::http::{request::Request, response::Response};
use crate::io::{types, Filter, Io};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::util::BoxFuture;
use super::codec::Codec;
use super::dispatcher::Dispatcher;
@ -82,10 +81,9 @@ mod openssl {
> {
Acceptor::new(acceptor)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(SslError::Ssl)
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -128,10 +126,9 @@ mod rustls {
> {
Acceptor::from(config)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(|e| SslError::Ssl(Box::new(e)))
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -205,39 +202,36 @@ where
type Error = DispatchError;
type InitError = ();
type Service = H1ServiceHandler<F, S::Service, B, X::Service, U::Service>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let fut = self.srv.create(());
let fut_ex = self.expect.create(());
let fut_upg = self.upgrade.as_ref().map(|f| f.create(()));
let on_request = self.on_request.borrow_mut().take();
let cfg = self.cfg.clone();
Box::pin(async move {
let service = fut
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let expect = fut_ex
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let upgrade = if let Some(fut) = fut_upg {
Some(
fut.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?,
)
} else {
None
};
let service = fut
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let expect = fut_ex
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let upgrade = if let Some(fut) = fut_upg {
Some(
fut.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?,
)
} else {
None
};
let config = Rc::new(DispatcherConfig::new(
cfg, service, expect, upgrade, on_request,
));
let config = Rc::new(DispatcherConfig::new(
cfg, service, expect, upgrade, on_request,
));
Ok(H1ServiceHandler {
config,
_t: marker::PhantomData,
})
Ok(H1ServiceHandler {
config,
_t: marker::PhantomData,
})
}
}
@ -262,7 +256,6 @@ where
{
type Response = ();
type Error = DispatchError;
type Future<'f> = Dispatcher<F, S, B, X, U>;
fn poll_ready(
&self,
@ -324,12 +317,12 @@ where
}
}
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
async fn call(&self, io: Io<F>, _: ServiceCtx<'_, Self>) -> Result<(), DispatchError> {
log::trace!(
"New http1 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
);
Dispatcher::new(io, self.config.clone())
Dispatcher::new(io, self.config.clone()).await
}
}

16
ntex/src/http/h1/upgrade.rs
View file

@ -1,8 +1,8 @@
use std::{io, marker::PhantomData};
use crate::http::{h1::Codec, request::Request};
use crate::io::Io;
use crate::service::{Service, ServiceCtx, ServiceFactory};
use crate::{io::Io, util::Ready};
pub struct UpgradeHandler<F>(PhantomData<F>);
@ -12,10 +12,8 @@ impl<F> ServiceFactory<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
type Service = UpgradeHandler<F>;
type InitError = io::Error;
type Future<'f> = Ready<Self::Service, Self::InitError> where Self: 'f;
#[inline]
fn create(&self, _: ()) -> Self::Future<'_> {
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
unimplemented!()
}
}
@ -23,14 +21,12 @@ impl<F> ServiceFactory<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
impl<F> Service<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
type Response = ();
type Error = io::Error;
type Future<'f> = Ready<Self::Response, Self::Error> where F: 'f;
#[inline]
fn call<'a>(
&'a self,
async fn call(
&self,
_: (Request, Io<F>, Codec),
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
unimplemented!()
}
}

5
ntex/src/http/h2/payload.rs
View file

@ -1,10 +1,11 @@
//! Payload stream
use std::collections::VecDeque;
use std::task::{Context, Poll};
use std::{cell::RefCell, collections::VecDeque, pin::Pin, rc::Rc, rc::Weak};
use std::{cell::RefCell, future::poll_fn, pin::Pin, rc::Rc, rc::Weak};
use ntex_h2::{self as h2};
use crate::util::{poll_fn, Bytes, Stream};
use crate::util::{Bytes, Stream};
use crate::{http::error::PayloadError, task::LocalWaker};
/// Buffered stream of byte chunks

200
ntex/src/http/h2/service.rs
View file

@ -1,5 +1,5 @@
use std::{cell::RefCell, io, task::Context, task::Poll};
use std::{marker::PhantomData, mem, rc::Rc};
use std::{future::poll_fn, marker::PhantomData, mem, rc::Rc};
use ntex_h2::{self as h2, frame::StreamId, server};
@ -11,7 +11,7 @@ use crate::http::message::{CurrentIo, ResponseHead};
use crate::http::{DateService, Method, Request, Response, StatusCode, Uri, Version};
use crate::io::{types, Filter, Io, IoBoxed, IoRef};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::util::{poll_fn, BoxFuture, Bytes, BytesMut, Either, HashMap, Ready};
use crate::util::{Bytes, BytesMut, HashMap};
use super::payload::{Payload, PayloadSender};
@ -71,10 +71,9 @@ mod openssl {
> {
Acceptor::new(acceptor)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(SslError::Ssl)
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -110,10 +109,9 @@ mod rustls {
Acceptor::from(config)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(|e| SslError::Ssl(Box::new(e)))
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -130,20 +128,20 @@ where
type Error = DispatchError;
type InitError = S::InitError;
type Service = H2ServiceHandler<F, S::Service, B>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
let fut = self.srv.create(());
let cfg = self.cfg.clone();
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let service = self.srv.create(()).await?;
let config = Rc::new(DispatcherConfig::new(
self.cfg.clone(),
service,
(),
None,
None,
));
Box::pin(async move {
let service = fut.await?;
let config = Rc::new(DispatcherConfig::new(cfg, service, (), None, None));
Ok(H2ServiceHandler {
config,
_t: PhantomData,
})
Ok(H2ServiceHandler {
config,
_t: PhantomData,
})
}
}
@ -164,9 +162,7 @@ where
{
type Response = ();
type Error = DispatchError;
type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.config.service.poll_ready(cx).map_err(|e| {
log::error!("Service readiness error: {:?}", e);
@ -174,18 +170,21 @@ where
})
}
#[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
self.config.service.poll_shutdown(cx)
}
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
async fn call(
&self,
io: Io<F>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
log::trace!(
"New http2 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
);
Box::pin(handle(io.into(), self.config.clone()))
handle(io.into(), self.config.clone()).await
}
}
@ -226,15 +225,14 @@ impl ControlService {
impl Service<h2::ControlMessage<H2Error>> for ControlService {
type Response = h2::ControlResult;
type Error = ();
type Future<'f> = Ready<Self::Response, Self::Error>;
fn call<'a>(
&'a self,
async fn call(
&self,
msg: h2::ControlMessage<H2Error>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
log::trace!("Control message: {:?}", msg);
Ready::Ok::<_, ()>(msg.ack())
Ok::<_, ()>(msg.ack())
}
}
@ -273,12 +271,12 @@ where
{
type Response = ();
type Error = H2Error;
type Future<'f> = Either<
BoxFuture<'f, Result<Self::Response, Self::Error>>,
Ready<Self::Response, Self::Error>,
>;
fn call<'a>(&'a self, msg: h2::Message, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(
&self,
msg: h2::Message,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let h2::Message { stream, kind } = msg;
let (io, pseudo, headers, eof, payload) = match kind {
h2::MessageKind::Headers {
@ -303,7 +301,7 @@ where
} else {
log::error!("Payload stream does not exists for {:?}", stream.id());
};
return Either::Right(Ready::Ok(()));
return Ok(());
}
h2::MessageKind::Eof(item) => {
log::debug!("Got payload eof for {:?}: {:?}", stream.id(), item);
@ -318,95 +316,93 @@ where
h2::StreamEof::Error(err) => sender.set_error(err.into()),
}
}
return Either::Right(Ready::Ok(()));
return Ok(());
}
h2::MessageKind::Disconnect(err) => {
log::debug!("Connection is disconnected {:?}", err);
if let Some(mut sender) = self.streams.borrow_mut().remove(&stream.id()) {
sender.set_error(io::Error::new(io::ErrorKind::Other, err).into());
}
return Either::Right(Ready::Ok(()));
return Ok(());
}
};
let cfg = self.config.clone();
Either::Left(Box::pin(async move {
log::trace!(
"{:?} got request (eof: {}): {:#?}\nheaders: {:#?}",
stream.id(),
eof,
pseudo,
headers
);
let mut req = if let Some(pl) = payload {
Request::with_payload(crate::http::Payload::H2(pl))
} else {
Request::new()
};
log::trace!(
"{:?} got request (eof: {}): {:#?}\nheaders: {:#?}",
stream.id(),
eof,
pseudo,
headers
);
let mut req = if let Some(pl) = payload {
Request::with_payload(crate::http::Payload::H2(pl))
} else {
Request::new()
};
let path = pseudo.path.ok_or(H2Error::MissingPseudo("Path"))?;
let method = pseudo.method.ok_or(H2Error::MissingPseudo("Method"))?;
let path = pseudo.path.ok_or(H2Error::MissingPseudo("Path"))?;
let method = pseudo.method.ok_or(H2Error::MissingPseudo("Method"))?;
let head = req.head_mut();
head.uri = if let Some(ref authority) = pseudo.authority {
let scheme = pseudo.scheme.ok_or(H2Error::MissingPseudo("Scheme"))?;
Uri::try_from(format!("{}://{}{}", scheme, authority, path))?
} else {
Uri::try_from(path.as_str())?
};
let is_head_req = method == Method::HEAD;
head.version = Version::HTTP_2;
head.method = method;
head.headers = headers;
head.io = CurrentIo::Ref(io);
let head = req.head_mut();
head.uri = if let Some(ref authority) = pseudo.authority {
let scheme = pseudo.scheme.ok_or(H2Error::MissingPseudo("Scheme"))?;
Uri::try_from(format!("{}://{}{}", scheme, authority, path))?
} else {
Uri::try_from(path.as_str())?
};
let is_head_req = method == Method::HEAD;
head.version = Version::HTTP_2;
head.method = method;
head.headers = headers;
head.io = CurrentIo::Ref(io);
let (mut res, mut body) = match cfg.service.call(req).await {
Ok(res) => res.into().into_parts(),
Err(err) => {
let (res, body) = Response::from(&err).into_parts();
(res, body.into_body())
}
};
let (mut res, mut body) = match cfg.service.call(req).await {
Ok(res) => res.into().into_parts(),
Err(err) => {
let (res, body) = Response::from(&err).into_parts();
(res, body.into_body())
}
};
let head = res.head_mut();
let mut size = body.size();
prepare_response(&cfg.timer, head, &mut size);
let head = res.head_mut();
let mut size = body.size();
prepare_response(&cfg.timer, head, &mut size);
log::debug!("Received service response: {:?} payload: {:?}", head, size);
log::debug!("Received service response: {:?} payload: {:?}", head, size);
let hdrs = mem::replace(&mut head.headers, HeaderMap::new());
if size.is_eof() || is_head_req {
stream.send_response(head.status, hdrs, true)?;
} else {
stream.send_response(head.status, hdrs, false)?;
let hdrs = mem::replace(&mut head.headers, HeaderMap::new());
if size.is_eof() || is_head_req {
stream.send_response(head.status, hdrs, true)?;
} else {
stream.send_response(head.status, hdrs, false)?;
loop {
match poll_fn(|cx| body.poll_next_chunk(cx)).await {
None => {
log::debug!("{:?} closing payload stream", stream.id());
stream.send_payload(Bytes::new(), true).await?;
break;
}
Some(Ok(chunk)) => {
log::debug!(
"{:?} sending data chunk {:?} bytes",
stream.id(),
chunk.len()
);
if !chunk.is_empty() {
stream.send_payload(chunk, false).await?;
}
}
Some(Err(e)) => {
error!("Response payload stream error: {:?}", e);
return Err(e.into());
loop {
match poll_fn(|cx| body.poll_next_chunk(cx)).await {
None => {
log::debug!("{:?} closing payload stream", stream.id());
stream.send_payload(Bytes::new(), true).await?;
break;
}
Some(Ok(chunk)) => {
log::debug!(
"{:?} sending data chunk {:?} bytes",
stream.id(),
chunk.len()
);
if !chunk.is_empty() {
stream.send_payload(chunk, false).await?;
}
}
Some(Err(e)) => {
error!("Response payload stream error: {:?}", e);
return Err(e.into());
}
}
}
Ok(())
}))
}
Ok(())
}
}

4
ntex/src/http/payload.rs
View file

@ -1,7 +1,7 @@
use std::{fmt, mem, pin::Pin, task::Context, task::Poll};
use std::{fmt, future::poll_fn, mem, pin::Pin, task::Context, task::Poll};
use super::{error::PayloadError, h1, h2};
use crate::util::{poll_fn, Bytes, Stream};
use crate::util::{Bytes, Stream};
/// Type represent boxed payload
pub type PayloadStream = Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>>>>;

142
ntex/src/http/service.rs
View file

@ -1,9 +1,7 @@
use std::task::{Context, Poll};
use std::{cell, error, fmt, future, marker, pin::Pin, rc::Rc};
use std::{cell, error, fmt, marker, rc::Rc, task::Context, task::Poll};
use crate::io::{types, Filter, Io};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::util::BoxFuture;
use super::body::MessageBody;
use super::builder::HttpServiceBuilder;
@ -175,10 +173,9 @@ mod openssl {
> {
Acceptor::new(acceptor)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(SslError::Ssl)
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -222,10 +219,9 @@ mod rustls {
Acceptor::from(config)
.timeout(self.cfg.ssl_handshake_timeout)
.chain()
.map_err(|e| SslError::Ssl(Box::new(e)))
.map_init_err(|_| panic!())
.and_then(self.chain().map_err(SslError::Service))
.and_then(self.map_err(SslError::Service))
}
}
}
@ -249,39 +245,36 @@ where
type Error = DispatchError;
type InitError = ();
type Service = HttpServiceHandler<F, S::Service, B, X::Service, U::Service>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let fut = self.srv.create(());
let fut_ex = self.expect.create(());
let fut_upg = self.upgrade.as_ref().map(|f| f.create(()));
let on_request = self.on_request.borrow_mut().take();
let cfg = self.cfg.clone();
Box::pin(async move {
let service = fut
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let service = fut
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let expect = fut_ex
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let expect = fut_ex
.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?;
let upgrade = if let Some(fut) = fut_upg {
Some(
fut.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?,
)
} else {
None
};
let upgrade = if let Some(fut) = fut_upg {
Some(
fut.await
.map_err(|e| log::error!("Init http service error: {:?}", e))?,
)
} else {
None
};
let config = DispatcherConfig::new(cfg, service, expect, upgrade, on_request);
let config = DispatcherConfig::new(cfg, service, expect, upgrade, on_request);
Ok(HttpServiceHandler {
config: Rc::new(config),
_t: marker::PhantomData,
})
Ok(HttpServiceHandler {
config: Rc::new(config),
_t: marker::PhantomData,
})
}
}
@ -306,7 +299,6 @@ where
{
type Response = ();
type Error = DispatchError;
type Future<'f> = HttpServiceHandlerResponse<F, S, B, X, U>;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let cfg = self.config.as_ref();
@ -365,96 +357,20 @@ where
}
}
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(
&self,
io: Io<F>,
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
log::trace!(
"New http connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
);
if io.query::<types::HttpProtocol>().get() == Some(types::HttpProtocol::Http2) {
HttpServiceHandlerResponse {
state: ResponseState::H2 {
fut: Box::pin(h2::handle(io.into(), self.config.clone())),
},
}
h2::handle(io.into(), self.config.clone()).await
} else {
HttpServiceHandlerResponse {
state: ResponseState::H1 {
fut: h1::Dispatcher::new(io, self.config.clone()),
},
}
}
}
}
pin_project_lite::pin_project! {
pub struct HttpServiceHandlerResponse<F, S, B, X, U>
where
F: Filter,
S: Service<Request>,
S: 'static,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request, Response = Request>,
X: 'static,
X::Error: ResponseError,
X::Error: 'static,
U: Service<(Request, Io<F>, h1::Codec), Response = ()>,
U: 'static,
U::Error: fmt::Display,
U::Error: error::Error,
U: 'static,
{
#[pin]
state: ResponseState<F, S, B, X, U>,
}
}
pin_project_lite::pin_project! {
#[project = StateProject]
enum ResponseState<F, S, B, X, U>
where
F: Filter,
S: Service<Request>,
S: 'static,
S::Error: ResponseError,
B: MessageBody,
X: Service<Request, Response = Request>,
X: 'static,
X::Error: ResponseError,
X::Error: 'static,
U: Service<(Request, Io<F>, h1::Codec), Response = ()>,
U: 'static,
U::Error: fmt::Display,
U::Error: error::Error,
U: 'static,
{
H1 { #[pin] fut: h1::Dispatcher<F, S, B, X, U> },
H2 { fut: BoxFuture<'static, Result<(), DispatchError>> },
}
}
impl<F, S, B, X, U> future::Future for HttpServiceHandlerResponse<F, S, B, X, U>
where
F: Filter,
S: Service<Request> + 'static,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request, Response = Request> + 'static,
X::Error: ResponseError,
U: Service<(Request, Io<F>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
{
type Output = Result<(), DispatchError>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project();
match this.state.project() {
StateProject::H1 { fut } => fut.poll(cx),
StateProject::H2 { ref mut fut } => Pin::new(fut).poll(cx),
h1::Dispatcher::new(io, self.config.clone()).await
}
}
}

2
ntex/src/lib.rs
View file

@ -39,7 +39,7 @@ pub mod ws;
pub use self::service::{
chain, chain_factory, fn_service, into_service, IntoService, IntoServiceFactory,
Middleware, Pipeline, Service, ServiceCall, ServiceCtx, ServiceFactory,
Middleware, Pipeline, Service, ServiceCtx, ServiceFactory,
};
pub use ntex_util::{channel, task};

2
ntex/src/server/builder.rs
View file

@ -323,7 +323,7 @@ impl ServerBuilder {
pub fn set_tag<N: AsRef<str>>(mut self, name: N, tag: &'static str) -> Self {
let mut token = None;
for sock in &self.sockets {
if &sock.1 == name.as_ref() {
if sock.1 == name.as_ref() {
token = Some(sock.0);
break;
}

19
ntex/src/server/config.rs
View file

@ -397,20 +397,17 @@ where
type Error = ();
type InitError = ();
type Service = BoxedServerService;
type Future<'f> = BoxFuture<'f, Result<BoxedServerService, ()>> where Self: 'f;
fn create(&self, _: ()) -> Self::Future<'_> {
async fn create(&self, _: ()) -> Result<BoxedServerService, ()> {
let tag = self.tag;
let pool = self.pool;
let fut = self.inner.create(());
Box::pin(async move {
match fut.await {
Ok(s) => Ok(boxed::service(StreamService::new(s, tag, pool))),
Err(e) => {
error!("Cannot construct service: {:?}", e);
Err(())
}
match self.inner.create(()).await {
Ok(s) => Ok(boxed::service(StreamService::new(s, tag, pool))),
Err(e) => {
error!("Cannot construct service: {:?}", e);
Err(())
}
})
}
}
}

43
ntex/src/server/service.rs
View file

@ -62,7 +62,6 @@ where
{
type Response = ();
type Error = ();
type Future<'f> = BoxFuture<'f, Result<(), ()>> where T: 'f;
crate::forward_poll_shutdown!(service);
@ -77,32 +76,30 @@ where
}
}
fn call<'a>(
&'a self,
async fn call(
&self,
(guard, req): (Option<CounterGuard>, ServerMessage),
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Box::pin(async move {
match req {
ServerMessage::Connect(stream) => {
let stream = stream.try_into().map_err(|e| {
error!("Cannot convert to an async io stream: {}", e);
});
ctx: ServiceCtx<'_, Self>,
) -> Result<(), ()> {
match req {
ServerMessage::Connect(stream) => {
let stream = stream.try_into().map_err(|e| {
error!("Cannot convert to an async io stream: {}", e);
});
if let Ok(stream) = stream {
let stream: Io<_> = stream;
stream.set_tag(self.tag);
stream.set_memory_pool(self.pool_ref);
let _ = ctx.call(self.service.as_ref(), stream).await;
drop(guard);
Ok(())
} else {
Err(())
}
if let Ok(stream) = stream {
let stream: Io<_> = stream;
stream.set_tag(self.tag);
stream.set_memory_pool(self.pool_ref);
let _ = ctx.call(self.service.as_ref(), stream).await;
drop(guard);
Ok(())
} else {
Err(())
}
_ => Ok(()),
}
})
_ => Ok(()),
}
}
}

12
ntex/src/server/worker.rs
View file

@ -515,7 +515,7 @@ mod tests {
use crate::io::Io;
use crate::server::service::Factory;
use crate::service::{Service, ServiceCtx, ServiceFactory};
use crate::util::{lazy, Ready};
use crate::util::lazy;
#[derive(Clone, Copy, Debug)]
enum St {
@ -535,12 +535,11 @@ mod tests {
type Error = ();
type Service = Srv;
type InitError = ();
type Future<'f> = Ready<Srv, ()>;
fn create(&self, _: ()) -> Self::Future<'_> {
async fn create(&self, _: ()) -> Result<Srv, ()> {
let mut cnt = self.counter.lock().unwrap();
*cnt += 1;
Ready::Ok(Srv {
Ok(Srv {
st: self.st.clone(),
})
}
@ -553,7 +552,6 @@ mod tests {
impl Service<Io> for Srv {
type Response = ();
type Error = ();
type Future<'f> = Ready<(), ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let st: St = { *self.st.lock().unwrap() };
@ -574,8 +572,8 @@ mod tests {
}
}
fn call<'a>(&'a self, _: Io, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
async fn call(&self, _: Io, _: ServiceCtx<'_, Self>) -> Result<(), ()> {
Ok(())
}
}

26
ntex/src/web/app.rs
View file

@ -7,7 +7,7 @@ use crate::service::{
chain_factory, dev::ServiceChainFactory, map_config, IntoServiceFactory,
};
use crate::service::{Identity, Middleware, Service, ServiceCtx, ServiceFactory, Stack};
use crate::util::{BoxFuture, Extensions, Ready};
use crate::util::{BoxFuture, Extensions};
use super::app_service::{AppFactory, AppService};
use super::config::{AppConfig, ServiceConfig};
@ -269,9 +269,9 @@ where
U::InitError: fmt::Debug,
{
// create and configure default resource
self.default = Some(Rc::new(boxed::factory(f.chain().map_init_err(|e| {
log::error!("Cannot construct default service: {:?}", e)
}))));
self.default = Some(Rc::new(boxed::factory(chain_factory(f).map_init_err(
|e| log::error!("Cannot construct default service: {:?}", e),
))));
self
}
@ -569,26 +569,22 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Filter<Err> {
type Error = Err::Container;
type InitError = ();
type Service = Filter<Err>;
type Future<'f> = Ready<Filter<Err>, ()>;
#[inline]
fn create(&self, _: ()) -> Self::Future<'_> {
Ready::Ok(Filter(PhantomData))
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
Ok(Filter(PhantomData))
}
}
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
type Response = WebRequest<Err>;
type Error = Err::Container;
type Future<'f> = Ready<WebRequest<Err>, Err::Container>;
#[inline]
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<Err>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(req)
_: ServiceCtx<'_, Self>,
) -> Result<WebRequest<Err>, Err::Container> {
Ok(req)
}
}

210
ntex/src/web/app_service.rs
View file

@ -1,14 +1,11 @@
use std::task::{Context, Poll};
use std::{cell::RefCell, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
use std::{cell::RefCell, marker::PhantomData, rc::Rc, task::Context, task::Poll};
use crate::http::{Request, Response};
use crate::router::{Path, ResourceDef, Router};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::dev::ServiceChainFactory;
use crate::service::{
fn_service, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory,
};
use crate::util::{BoxFuture, Either, Extensions};
use crate::service::{fn_service, Middleware, Service, ServiceCtx, ServiceFactory};
use crate::util::{BoxFuture, Extensions};
use super::config::AppConfig;
use super::error::ErrorRenderer;
@ -24,8 +21,6 @@ type HttpService<Err: ErrorRenderer> =
BoxService<WebRequest<Err>, WebResponse, Err::Container>;
type HttpNewService<Err: ErrorRenderer> =
BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
type BoxResponse<'a, Err: ErrorRenderer> =
ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
type FnStateFactory = Box<dyn Fn(Extensions) -> BoxFuture<'static, Result<Extensions, ()>>>;
/// Service factory to convert `Request` to a `WebRequest<S>`.
@ -66,10 +61,9 @@ where
type Error = Err::Container;
type InitError = ();
type Service = AppFactoryService<T::Service, Err>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>> where Self: 'f;
fn create(&self, _: ()) -> Self::Future<'_> {
ServiceFactory::create(self, AppConfig::default())
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
ServiceFactory::create(self, AppConfig::default()).await
}
}
@ -89,9 +83,8 @@ where
type Error = Err::Container;
type InitError = ();
type Service = AppFactoryService<T::Service, Err>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>> where Self: 'f;
fn create(&self, config: AppConfig) -> Self::Future<'_> {
async fn create(&self, config: AppConfig) -> Result<Self::Service, Self::InitError> {
let services = std::mem::take(&mut *self.services.borrow_mut());
// update resource default service
@ -114,65 +107,63 @@ where
router.case_insensitive();
}
Box::pin(async move {
// app state factories
for fut in state_factories.iter() {
extensions = fut(extensions).await?;
}
let state = AppState::new(extensions, None, config.clone());
// app state factories
for fut in state_factories.iter() {
extensions = fut(extensions).await?;
}
let state = AppState::new(extensions, None, config.clone());
// App config
let mut config = WebServiceConfig::new(state.clone(), default.clone());
// App config
let mut config = WebServiceConfig::new(state.clone(), default.clone());
// register services
services
.into_iter()
.for_each(|mut srv| srv.register(&mut config));
let services = config.into_services();
// register services
services
.into_iter()
.for_each(|mut srv| srv.register(&mut config));
let services = config.into_services();
// resource map
let mut rmap = ResourceMap::new(ResourceDef::new(""));
for mut rdef in external {
rmap.add(&mut rdef, None);
}
// resource map
let mut rmap = ResourceMap::new(ResourceDef::new(""));
for mut rdef in external {
rmap.add(&mut rdef, None);
}
// complete pipeline creation
let services: Vec<_> = services
.into_iter()
.map(|(mut rdef, srv, guards, nested)| {
rmap.add(&mut rdef, nested);
(rdef, srv, RefCell::new(guards))
})
.collect();
// complete ResourceMap tree creation
let rmap = Rc::new(rmap);
rmap.finish(rmap.clone());
// create http services
for (path, factory, guards) in &mut services.iter() {
let service = factory.create(()).await?;
router.rdef(path.clone(), service).2 = guards.borrow_mut().take();
}
let routing = AppRouting {
router: router.finish(),
default: Some(default.create(()).await?),
};
// main service
let service = AppService {
routing,
filter: filter_fut.await?,
};
Ok(AppFactoryService {
rmap,
state,
service: middleware.create(service),
pool: HttpRequestPool::create(),
_t: PhantomData,
// complete pipeline creation
let services: Vec<_> = services
.into_iter()
.map(|(mut rdef, srv, guards, nested)| {
rmap.add(&mut rdef, nested);
(rdef, srv, RefCell::new(guards))
})
.collect();
// complete ResourceMap tree creation
let rmap = Rc::new(rmap);
rmap.finish(rmap.clone());
// create http services
for (path, factory, guards) in &mut services.iter() {
let service = factory.create(()).await?;
router.rdef(path.clone(), service).2 = guards.borrow_mut().take();
}
let routing = AppRouting {
router: router.finish(),
default: Some(default.create(()).await?),
};
// main service
let service = AppService {
routing,
filter: filter_fut.await?,
};
Ok(AppFactoryService {
rmap,
state,
service: middleware.create(service),
pool: HttpRequestPool::create(),
_t: PhantomData,
})
}
}
@ -197,12 +188,15 @@ where
{
type Response = WebResponse;
type Error = T::Error;
type Future<'f> = ServiceCall<'f, T, WebRequest<Err>> where T: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(&'a self, req: Request, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
async fn call(
&self,
req: Request,
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let (head, payload) = req.into_parts();
let req = if let Some(mut req) = self.pool.get_request() {
@ -222,7 +216,7 @@ where
self.pool,
)
};
ctx.call(&self.service, WebRequest::new(req))
ctx.call(&self.service, WebRequest::new(req)).await
}
}
@ -244,14 +238,12 @@ struct AppRouting<Err: ErrorRenderer> {
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> =
Either<BoxResponse<'f, Err>, BoxFuture<'f, Result<WebResponse, Err::Container>>>;
fn call<'a>(
&'a self,
async fn call(
&self,
mut req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<WebResponse, Err::Container> {
let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards {
for f in guards {
@ -264,14 +256,12 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
});
if let Some((srv, _info)) = res {
Either::Left(ctx.call(srv, req))
ctx.call(srv, req).await
} else if let Some(ref default) = self.default {
Either::Left(ctx.call(default, req))
ctx.call(default, req).await
} else {
let req = req.into_parts().0;
Either::Right(Box::pin(async {
Ok(WebResponse::new(Response::NotFound().finish(), req))
}))
Ok(WebResponse::new(Response::NotFound().finish(), req))
}
}
}
@ -289,7 +279,6 @@ where
{
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> = AppServiceResponse<'f, F, Err> where F: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -302,58 +291,13 @@ where
}
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
AppServiceResponse {
filter: ctx.call(&self.filter, req),
routing: &self.routing,
endpoint: None,
ctx,
}
}
}
type BoxAppServiceResponse<'a, Err: ErrorRenderer> =
ServiceCall<'a, AppRouting<Err>, WebRequest<Err>>;
pin_project_lite::pin_project! {
pub struct AppServiceResponse<'f, F: Service<WebRequest<Err>>, Err: ErrorRenderer>
where F: 'f
{
#[pin]
filter: ServiceCall<'f, F, WebRequest<Err>>,
routing: &'f AppRouting<Err>,
endpoint: Option<BoxAppServiceResponse<'f, Err>>,
ctx: ServiceCtx<'f, AppService<F, Err>>,
}
}
impl<'f, F, Err> Future for AppServiceResponse<'f, F, Err>
where
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Output = Result<WebResponse, Err::Container>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
loop {
if let Some(fut) = this.endpoint.as_mut() {
return Pin::new(fut).poll(cx);
} else {
let res = if let Poll::Ready(res) = this.filter.poll(cx) {
res?
} else {
return Poll::Pending;
};
*this.endpoint = Some(this.ctx.call(this.routing, res));
this = self.as_mut().project();
}
}
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let req = ctx.call(&self.filter, req).await?;
ctx.call(&self.routing, req).await
}
}

4
ntex/src/web/error.rs
View file

@ -84,10 +84,6 @@ pub enum StateExtractorError {
NotConfigured,
}
#[deprecated]
#[doc(hidden)]
pub type DataExtractorError = StateExtractorError;
/// Errors which can occur when attempting to generate resource uri.
#[derive(Error, Debug, Copy, Clone, PartialEq, Eq)]
pub enum UrlGenerationError {

63
ntex/src/web/middleware/compress.rs
View file

@ -1,10 +1,9 @@
//! `Middleware` for compressing response body.
use std::task::{Context, Poll};
use std::{cmp, future::Future, marker, pin::Pin, str::FromStr};
use std::{cmp, str::FromStr};
use crate::http::encoding::Encoder;
use crate::http::header::{ContentEncoding, ACCEPT_ENCODING};
use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
use crate::service::{Middleware, Service, ServiceCtx};
use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
#[derive(Debug, Clone)]
@ -67,16 +66,15 @@ where
{
type Response = WebResponse;
type Error = S::Error;
type Future<'f> = CompressResponse<'f, S, E> where S: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<WebResponse, S::Error> {
// negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() {
@ -88,50 +86,15 @@ where
ContentEncoding::Identity
};
CompressResponse {
encoding,
fut: ctx.call(&self.service, req),
_t: marker::PhantomData,
}
}
}
let resp = ctx.call(&self.service, req).await?;
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct CompressResponse<'f, S: Service<WebRequest<E>>, E>
where S: 'f, E: 'f
{
#[pin]
fut: ServiceCall<'f, S, WebRequest<E>>,
encoding: ContentEncoding,
_t: marker::PhantomData<E>,
}
}
let enc = if let Some(enc) = resp.response().get_encoding() {
enc
} else {
encoding
};
impl<'f, S, E> Future for CompressResponse<'f, S, E>
where
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Output = Result<WebResponse, S::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
match this.fut.poll(cx)? {
Poll::Ready(resp) => {
let enc = if let Some(enc) = resp.response().get_encoding() {
enc
} else {
*this.encoding
};
Poll::Ready(Ok(
resp.map_body(move |head, body| Encoder::response(enc, head, body))
))
}
Poll::Pending => Poll::Pending,
}
Ok(resp.map_body(move |head, body| Encoder::response(enc, head, body)))
}
}

41
ntex/src/web/middleware/defaultheaders.rs
View file

@ -4,7 +4,6 @@ use std::rc::Rc;
use crate::http::error::HttpError;
use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
use crate::service::{Middleware, Service, ServiceCtx};
use crate::util::BoxFuture;
use crate::web::{WebRequest, WebResponse};
/// `Middleware` for setting default response headers.
@ -111,35 +110,31 @@ where
{
type Response = WebResponse;
type Error = S::Error;
type Future<'f> =
BoxFuture<'f, Result<Self::Response, Self::Error>> where S: 'f, E: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Box::pin(async move {
let mut res = ctx.call(&self.service, req).await?;
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let mut res = ctx.call(&self.service, req).await?;
// set response headers
for (key, value) in self.inner.headers.iter() {
if !res.headers().contains_key(key) {
res.headers_mut().insert(key.clone(), value.clone());
}
// set response headers
for (key, value) in self.inner.headers.iter() {
if !res.headers().contains_key(key) {
res.headers_mut().insert(key.clone(), value.clone());
}
// default content-type
if self.inner.ct && !res.headers().contains_key(&CONTENT_TYPE) {
res.headers_mut().insert(
CONTENT_TYPE,
HeaderValue::from_static("application/octet-stream"),
);
}
Ok(res)
})
}
// default content-type
if self.inner.ct && !res.headers().contains_key(&CONTENT_TYPE) {
res.headers_mut().insert(
CONTENT_TYPE,
HeaderValue::from_static("application/octet-stream"),
);
}
Ok(res)
}
}

74
ntex/src/web/middleware/logger.rs
View file

@ -1,14 +1,13 @@
//! Request logging middleware
use std::task::{ready, Context, Poll};
use std::{env, error::Error, future::Future};
use std::{fmt, fmt::Display, marker::PhantomData, pin::Pin, rc::Rc, time};
use std::task::{Context, Poll};
use std::{env, error::Error, fmt, fmt::Display, rc::Rc, time};
use regex::Regex;
use crate::http::body::{Body, BodySize, MessageBody, ResponseBody};
use crate::http::header::HeaderName;
use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
use crate::util::{Bytes, Either, HashSet};
use crate::service::{Middleware, Service, ServiceCtx};
use crate::util::{Bytes, HashSet};
use crate::web::{HttpResponse, WebRequest, WebResponse};
/// `Middleware` for logging request and response info to the terminal.
@ -139,19 +138,17 @@ where
{
type Response = WebResponse;
type Error = S::Error;
type Future<'f> = Either<LoggerResponse<'f, S, E>, ServiceCall<'f, S, WebRequest<E>>> where S: 'f, E: 'f;
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
if self.inner.exclude.contains(req.path()) {
Either::Right(ctx.call(&self.service, req))
ctx.call(&self.service, req).await
} else {
let time = time::SystemTime::now();
let mut format = self.inner.format.clone();
@ -159,56 +156,21 @@ where
for unit in &mut format.0 {
unit.render_request(time, &req);
}
Either::Left(LoggerResponse {
time,
format: Some(format),
fut: ctx.call(&self.service, req),
_t: PhantomData,
})
}
}
}
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct LoggerResponse<'f, S: Service<WebRequest<E>>, E>
where S: 'f, E: 'f
{
#[pin]
fut: ServiceCall<'f, S, WebRequest<E>>,
time: time::SystemTime,
format: Option<Format>,
_t: PhantomData<E>
}
}
impl<'f, S, E> Future for LoggerResponse<'f, S, E>
where
S: Service<WebRequest<E>, Response = WebResponse>,
{
type Output = Result<WebResponse, S::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
let res = ready!(this.fut.poll(cx)?);
if let Some(ref mut format) = this.format {
let res = ctx.call(&self.service, req).await?;
for unit in &mut format.0 {
unit.render_response(res.response());
}
}
let time = *this.time;
let format = this.format.take();
Poll::Ready(Ok(res.map_body(move |_, body| {
ResponseBody::Other(Body::from_message(StreamLog {
body,
time,
format,
size: 0,
Ok(res.map_body(move |_, body| {
ResponseBody::Other(Body::from_message(StreamLog {
body,
time,
format: Some(format),
size: 0,
}))
}))
})))
}
}
}

67
ntex/src/web/resource.rs
View file

@ -4,11 +4,11 @@ use crate::http::Response;
use crate::router::{IntoPattern, ResourceDef};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::dev::{AndThen, ServiceChain, ServiceChainFactory};
use crate::service::{chain_factory, ServiceCtx};
use crate::service::{chain, chain_factory, ServiceCtx};
use crate::service::{
Identity, IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory, Stack,
Identity, IntoServiceFactory, Middleware, Service, ServiceFactory, Stack,
};
use crate::util::{BoxFuture, Either, Extensions, Ready};
use crate::util::Extensions;
use super::dev::{insert_slash, WebServiceConfig, WebServiceFactory};
use super::extract::FromRequest;
@ -24,8 +24,6 @@ type HttpNewService<Err: ErrorRenderer> =
BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
type ResourcePipeline<F, Err> =
ServiceChain<AndThen<F, ResourceRouter<Err>>, WebRequest<Err>>;
type BoxResponse<'a, Err: ErrorRenderer> =
ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
/// *Resource* is an entry in resources table which corresponds to requested URL.
///
@ -302,7 +300,7 @@ where
{
// create and configure default resource
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
f.chain()
chain_factory(f.into_factory())
.map_init_err(|e| log::error!("Cannot construct default service: {:?}", e)),
)))));
@ -420,14 +418,11 @@ where
type Error = Err::Container;
type Service = M::Service;
type InitError = ();
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
Box::pin(async move {
let filter = self.filter.create(()).await?;
let routing = self.routing.create(()).await?;
Ok(self.middleware.create(filter.chain().and_then(routing)))
})
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let filter = self.filter.create(()).await?;
let routing = self.routing.create(()).await?;
Ok(self.middleware.create(chain(filter).and_then(routing)))
}
}
@ -442,27 +437,21 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ResourceRouterFacto
type Error = Err::Container;
type InitError = ();
type Service = ResourceRouter<Err>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
Box::pin(async move {
let default = if let Some(ref default) = self.default {
Some(default.create(()).await?)
} else {
None
};
Ok(ResourceRouter {
default,
state: self.state.clone(),
routes: self.routes.iter().map(|route| route.service()).collect(),
})
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
let default = if let Some(ref default) = self.default {
Some(default.create(()).await?)
} else {
None
};
Ok(ResourceRouter {
default,
state: self.state.clone(),
routes: self.routes.iter().map(|route| route.service()).collect(),
})
}
}
type BoxResourceRouterResponse<'a, Err: ErrorRenderer> =
ServiceCall<'a, RouteService<Err>, WebRequest<Err>>;
pub struct ResourceRouter<Err: ErrorRenderer> {
state: Option<AppState>,
routes: Vec<RouteService<Err>>,
@ -472,31 +461,27 @@ pub struct ResourceRouter<Err: ErrorRenderer> {
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> = Either<
BoxResourceRouterResponse<'f, Err>,
Either<Ready<WebResponse, Err::Container>, BoxResponse<'f, Err>>,
>;
fn call<'a>(
&'a self,
async fn call(
&self,
mut req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
for route in self.routes.iter() {
if route.check(&mut req) {
if let Some(ref state) = self.state {
req.set_state_container(state.clone());
}
return Either::Left(ctx.call(route, req));
return ctx.call(route, req).await;
}
}
if let Some(ref default) = self.default {
Either::Right(Either::Right(ctx.call(default, req)))
ctx.call(default, req).await
} else {
Either::Right(Either::Left(Ready::Ok(WebResponse::new(
Ok(WebResponse::new(
Response::MethodNotAllowed().finish(),
req.into_parts().0,
))))
))
}
}
}

18
ntex/src/web/route.rs
View file

@ -1,6 +1,5 @@
use std::{fmt, mem, rc::Rc};
use crate::util::{BoxFuture, Ready};
use crate::{http::Method, service::Service, service::ServiceCtx, service::ServiceFactory};
use super::error::ErrorRenderer;
@ -66,10 +65,9 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err> {
type Error = Err::Container;
type InitError = ();
type Service = RouteService<Err>;
type Future<'f> = Ready<RouteService<Err>, ()>;
fn create(&self, _: ()) -> Self::Future<'_> {
Ok(self.service()).into()
async fn create(&self, _: ()) -> Result<RouteService<Err>, ()> {
Ok(self.service())
}
}
@ -102,15 +100,13 @@ impl<Err: ErrorRenderer> fmt::Debug for RouteService<Err> {
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for RouteService<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
#[inline]
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<Err>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
self.handler.call(req)
_: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
self.handler.call(req).await
}
}

141
ntex/src/web/scope.rs
View file

@ -1,15 +1,11 @@
use std::{
cell::RefCell, fmt, future::Future, pin::Pin, rc::Rc, task::Context, task::Poll,
};
use std::{cell::RefCell, fmt, rc::Rc, task::Context, task::Poll};
use crate::http::Response;
use crate::router::{IntoPattern, ResourceDef, Router};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{chain_factory, dev::ServiceChainFactory, IntoServiceFactory};
use crate::service::{
Identity, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory, Stack,
};
use crate::util::{BoxFuture, Either, Extensions, Ready};
use crate::service::{Identity, Middleware, Service, ServiceCtx, ServiceFactory, Stack};
use crate::util::Extensions;
use super::app::Filter;
use super::config::ServiceConfig;
@ -28,8 +24,6 @@ type HttpService<Err: ErrorRenderer> =
BoxService<WebRequest<Err>, WebResponse, Err::Container>;
type HttpNewService<Err: ErrorRenderer> =
BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
type BoxResponse<'a, Err: ErrorRenderer> =
ServiceCall<'a, HttpService<Err>, WebRequest<Err>>;
/// Resources scope.
///
@ -288,7 +282,7 @@ where
{
// create and configure default resource
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
f.chain()
chain_factory(f.into_factory())
.map_init_err(|e| log::error!("Cannot construct default service: {:?}", e)),
)))));
@ -468,15 +462,12 @@ where
type Error = Err::Container;
type Service = M::Service;
type InitError = ();
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
Box::pin(async move {
Ok(self.middleware.create(ScopeService {
filter: self.filter.create(()).await?,
routing: self.routing.create(()).await?,
}))
})
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
Ok(self.middleware.create(ScopeService {
filter: self.filter.create(()).await?,
routing: self.routing.create(()).await?,
}))
}
}
@ -492,7 +483,6 @@ where
{
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> = ScopeServiceResponse<'f, F, Err> where F: 'f;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -505,55 +495,13 @@ where
}
}
fn call<'a>(
&'a self,
async fn call(
&self,
req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ScopeServiceResponse {
filter: ctx.call(&self.filter, req),
routing: &self.routing,
endpoint: None,
ctx,
}
}
}
pin_project_lite::pin_project! {
pub struct ScopeServiceResponse<'f, F: Service<WebRequest<Err>>, Err: ErrorRenderer>
where F: 'f
{
#[pin]
filter: ServiceCall<'f, F, WebRequest<Err>>,
routing: &'f ScopeRouter<Err>,
ctx: ServiceCtx<'f, ScopeService<F, Err>>,
endpoint: Option<ServiceCall<'f, ScopeRouter<Err>, WebRequest<Err>>>,
}
}
impl<'f, F, Err> Future for ScopeServiceResponse<'f, F, Err>
where
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Output = Result<WebResponse, Err::Container>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
loop {
if let Some(fut) = this.endpoint.as_mut() {
return Pin::new(fut).poll(cx);
}
let res = if let Poll::Ready(res) = this.filter.poll(cx) {
res?
} else {
return Poll::Pending;
};
*this.endpoint = Some(this.ctx.call(this.routing, res));
this = self.as_mut().project();
}
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let req = ctx.call(&self.filter, req).await?;
ctx.call(&self.routing, req).await
}
}
@ -569,31 +517,28 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ScopeRouterFactory<
type Error = Err::Container;
type InitError = ();
type Service = ScopeRouter<Err>;
type Future<'f> = BoxFuture<'f, Result<Self::Service, Self::InitError>>;
fn create(&self, _: ()) -> Self::Future<'_> {
Box::pin(async move {
// create http services
let mut router = Router::build();
if self.case_insensitive {
router.case_insensitive();
}
for (path, factory, guards) in &mut self.services.iter() {
let service = factory.create(()).await?;
router.rdef(path.clone(), service).2 = guards.borrow_mut().take();
}
async fn create(&self, _: ()) -> Result<Self::Service, Self::InitError> {
// create http services
let mut router = Router::build();
if self.case_insensitive {
router.case_insensitive();
}
for (path, factory, guards) in &mut self.services.iter() {
let service = factory.create(()).await?;
router.rdef(path.clone(), service).2 = guards.borrow_mut().take();
}
let default = if let Some(ref default) = self.default {
Some(default.create(()).await?)
} else {
None
};
let default = if let Some(ref default) = self.default {
Some(default.create(()).await?)
} else {
None
};
Ok(ScopeRouter {
default,
router: router.finish(),
state: self.state.clone(),
})
Ok(ScopeRouter {
default,
router: router.finish(),
state: self.state.clone(),
})
}
}
@ -607,13 +552,12 @@ struct ScopeRouter<Err: ErrorRenderer> {
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future<'f> = Either<BoxResponse<'f, Err>, Ready<Self::Response, Self::Error>>;
fn call<'a>(
&'a self,
async fn call(
&self,
mut req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ctx: ServiceCtx<'_, Self>,
) -> Result<Self::Response, Self::Error> {
let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards {
for f in guards {
@ -629,15 +573,12 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
if let Some(ref state) = self.state {
req.set_state_container(state.clone());
}
Either::Left(ctx.call(srv, req))
ctx.call(srv, req).await
} else if let Some(ref default) = self.default {
Either::Left(ctx.call(default, req))
ctx.call(default, req).await
} else {
let req = req.into_parts().0;
Either::Right(Ready::Ok(WebResponse::new(
Response::NotFound().finish(),
req,
)))
Ok(WebResponse::new(Response::NotFound().finish(), req))
}
}
}

4
ntex/src/web/types/mod.rs
View file

@ -13,7 +13,3 @@ pub use self::path::Path;
pub use self::payload::{Payload, PayloadConfig};
pub use self::query::Query;
pub use self::state::State;
#[deprecated]
#[doc(hidden)]
pub type Data<T> = State<T>;

6
ntex/src/web/ws.rs
View file

@ -5,7 +5,7 @@ pub use crate::ws::{CloseCode, CloseReason, Frame, Message, WsSink};
use crate::http::{body::BodySize, h1, StatusCode};
use crate::service::{
apply_fn, fn_factory_with_config, IntoServiceFactory, ServiceFactory,
apply_fn, chain_factory, fn_factory_with_config, IntoServiceFactory, ServiceFactory,
};
use crate::web::{HttpRequest, HttpResponse};
use crate::ws::{self, error::HandshakeError, error::WsError, handshake};
@ -19,7 +19,7 @@ where
F: IntoServiceFactory<T, Frame, WsSink>,
Err: From<T::InitError> + From<HandshakeError>,
{
let inner_factory = Rc::new(factory.chain().map_err(WsError::Service));
let inner_factory = Rc::new(chain_factory(factory).map_err(WsError::Service));
let factory = fn_factory_with_config(move |sink: WsSink| {
let factory = inner_factory.clone();
@ -105,7 +105,7 @@ where
// start websockets service dispatcher
rt::spawn(async move {
let res = crate::io::Dispatcher::with_config(io, codec, srv, &cfg).await;
let res = crate::io::Dispatcher::new(io, codec, srv, &cfg).await;
log::trace!("Ws handler is terminated: {:?}", res);
});

4
ntex/src/ws/client.rs
View file

@ -757,7 +757,7 @@ impl WsConnection<Sealed> {
U: IntoService<T, ws::Frame>,
{
let service = apply_fn(
service.into_chain().map_err(WsError::Service),
service.into_service().map_err(WsError::Service),
|req, svc| async move {
match req {
DispatchItem::<ws::Codec>::Item(item) => svc.call(item).await,
@ -773,7 +773,7 @@ impl WsConnection<Sealed> {
},
);
Dispatcher::with_config(self.io, self.codec, service, &self.config).await
Dispatcher::new(self.io, self.codec, service, &self.config).await
}
}

35
ntex/tests/http_ws.rs
View file

@ -5,8 +5,8 @@ use ntex::http::test::server as test_server;
use ntex::http::{body, h1, test, HttpService, Request, Response, StatusCode};
use ntex::io::{DispatchItem, Dispatcher, Io};
use ntex::service::{fn_factory, Service, ServiceCtx};
use ntex::time::{sleep, Millis, Seconds};
use ntex::util::{BoxFuture, ByteString, Bytes, Ready};
use ntex::time::Seconds;
use ntex::util::{ByteString, Bytes, Ready};
use ntex::ws::{self, handshake, handshake_response};
struct WsService(Arc<Mutex<Cell<bool>>>);
@ -34,39 +34,28 @@ impl Clone for WsService {
impl Service<(Request, Io, h1::Codec)> for WsService {
type Response = ();
type Error = io::Error;
type Future<'f> = BoxFuture<'f, Result<(), io::Error>>;
fn poll_ready(&self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.set_polled();
Poll::Ready(Ok(()))
}
fn call<'a>(
&'a self,
async fn call(
&self,
(req, io, codec): (Request, Io, h1::Codec),
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
let fut = async move {
let res = handshake(req.head()).unwrap().message_body(());
_: ServiceCtx<'_, Self>,
) -> Result<(), io::Error> {
let res = handshake(req.head()).unwrap().message_body(());
io.encode((res, body::BodySize::None).into(), &codec)
.unwrap();
io.encode((res, body::BodySize::None).into(), &codec)
.unwrap();
let cfg = ntex_io::DispatcherConfig::default();
cfg.set_keepalive_timeout(Seconds(0));
let cfg = ntex_io::DispatcherConfig::default();
cfg.set_keepalive_timeout(Seconds(0));
Dispatcher::with_config(
io.seal(),
ws::Codec::new(),
service,
//&Default::default(),
&cfg,
)
Dispatcher::new(io.seal(), ws::Codec::new(), service, &cfg)
.await
.map_err(|_| panic!())
};
Box::pin(fut)
}
}

12
ntex/tests/http_ws_client.rs
View file

@ -40,7 +40,7 @@ async fn test_simple() {
.unwrap();
// start websocket service
Dispatcher::with_config(
Dispatcher::new(
io.seal(),
ws::Codec::default(),
ws_service,
@ -96,7 +96,7 @@ async fn test_transport() {
.unwrap();
// start websocket service
Dispatcher::with_config(
Dispatcher::new(
io.seal(),
ws::Codec::default(),
ws_service,
@ -133,13 +133,7 @@ async fn test_keepalive_timeout() {
// start websocket service
let cfg = DispatcherConfig::default();
cfg.set_keepalive_timeout(Seconds::ZERO);
Dispatcher::with_config(
io.seal(),
ws::Codec::default(),
ws_service,
&cfg,
)
.await
Dispatcher::new(io.seal(), ws::Codec::default(), ws_service, &cfg).await
}
})
.finish(|_| Ready::Ok::<_, io::Error>(Response::NotFound()))