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

Migrate to ntex-service 1.2 (#209)

Browse source 
* Migrate to ntex-service 1.2
This commit is contained in:
Nikolay Kim 2023-06-15 12:43:26 +06:00
parent e151b1eff1
commit 7960b550c9
84 changed files with 676 additions and 821 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

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

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

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

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.6.0", features = ["tokio"] }
ntex = { version = "0.7.0", features = ["tokio"] }

22
ntex-connect/Cargo.toml
View file

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

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

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

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

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

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

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

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

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

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

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

6
ntex-glommio/Cargo.toml
View file

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

6
ntex-http/src/value.rs
View file

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

8
ntex-io/Cargo.toml
View file

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

12
ntex-io/src/buf.rs
View file

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

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

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

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

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

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

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

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.6.0-alpha.0", features = ["tokio"] }
ntex = { version = "0.7.0", features = ["tokio"] }
futures = "0.3"
env_logger = "0.10"

2
ntex-router/src/quoter.rs
View file

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

4
ntex-service/Cargo.toml
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

14
ntex-tls/Cargo.toml
View file

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

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

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

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

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

6
ntex-tokio/Cargo.toml
View file

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

4
ntex-util/CHANGES.md
View file

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

6
ntex-util/Cargo.toml
View file

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

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

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

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

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

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

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

1
ntex-util/src/services/mod.rs
View file

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

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

169
ntex-util/src/services/shared.rs
View file

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

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

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

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

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

2
ntex-util/src/time/wheel.rs
View file

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

28
ntex/Cargo.toml
View file

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

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

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

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

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

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

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

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

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

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

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

2
ntex/src/http/client/mod.rs
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7
ntex/src/lib.rs
View file

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

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

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

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

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

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

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

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

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

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

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

2
ntex/src/web/config.rs
View file

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

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

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

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

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

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

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

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

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

2
ntex/src/web/responder.rs
View file

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

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

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

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

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

1
ntex/src/web/service.rs
View file

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

15
ntex/src/web/test.rs
View file

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

3
ntex/src/web/types/payload.rs
View file

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

1
ntex/src/web/types/state.rs
View file

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

2
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, Service, ServiceFactory,
apply_fn, fn_factory_with_config, IntoServiceFactory, ServiceFactory,
};
use crate::web::{HttpRequest, HttpResponse};
use crate::ws::{self, error::HandshakeError, error::WsError, handshake};

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

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

18
ntex/tests/connect.rs
View file

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

8
ntex/tests/http_ws.rs
View file

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