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

Rename Ctx to ServiceCtx

Browse source
This commit is contained in:
Nikolay Kim 2023-06-19 18:38:23 +06:00
parent 4714064872
commit 108e2ac20a
54 changed files with 217 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

10
ntex-connect/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-connect"
version = "0.3.0-beta.0"
version = "0.3.0-beta.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntexwork connect utils for ntex framework"
keywords = ["network", "framework", "async", "futures"]
@ -34,13 +34,13 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
async-std = ["ntex-rt/async-std", "ntex-async-std"]
[dependencies]
ntex-service = "1.2.0-beta.0"
ntex-service = "1.2.0-beta.1"
ntex-bytes = "0.1.19"
ntex-http = "0.1.8"
ntex-io = "0.3.0-beta.0"
ntex-io = "0.3.0-beta.1"
ntex-rt = "0.4.7"
ntex-tls = "0.3.0-beta.0"
ntex-util = "0.3.0-beta.0"
ntex-tls = "0.3.0-beta.1"
ntex-util = "0.3.0-beta.1"
log = "0.4"
thiserror = "1.0"

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

@ -5,7 +5,7 @@ pub use tls_openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslM
use ntex_bytes::PoolId;
use ntex_io::{FilterFactory, Io, Layer};
use ntex_service::{Container, Ctx, Service, ServiceFactory};
use ntex_service::{Container, Service, ServiceCtx, ServiceFactory};
use ntex_tls::openssl::SslConnector as IoSslConnector;
use ntex_util::future::{BoxFuture, Ready};
@ -107,7 +107,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
#[inline]
fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(self.connect(req))
}
}

4
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::{Ctx, Service, ServiceFactory};
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use ntex_util::future::{BoxFuture, Either, Ready};
use crate::{Address, Connect, ConnectError};
@ -115,7 +115,7 @@ impl<T: Address> Service<Connect<T>> for Resolver<T> {
type Future<'f> = BoxFuture<'f, Result<Connect<T>, Self::Error>>;
#[inline]
fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'_> {
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
Box::pin(self.lookup(req))
}
}

4
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::{Container, Ctx, Service, ServiceFactory};
use ntex_service::{Container, Service, ServiceCtx, ServiceFactory};
use ntex_tls::rustls::TlsConnector;
use ntex_util::future::{BoxFuture, Ready};
@ -110,7 +110,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
type Error = ConnectError;
type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(self.connect(req))
}
}

4
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::{Ctx, Service, ServiceFactory};
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use ntex_util::future::{BoxFuture, Either, Ready};
use crate::{net::tcp_connect_in, Address, Connect, ConnectError, Resolver};
@ -80,7 +80,7 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
type Future<'f> = ConnectServiceResponse<'f, T>;
#[inline]
fn call<'a>(&'a self, req: Connect<T>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Connect<T>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ConnectServiceResponse::new(Box::pin(self.resolver.lookup(req)))
}
}

6
ntex-io/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-io"
version = "0.3.0-beta.0"
version = "0.3.0-beta.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Utilities for encoding and decoding frames"
keywords = ["network", "framework", "async", "futures"]
@ -18,8 +18,8 @@ path = "src/lib.rs"
[dependencies]
ntex-codec = "0.6.2"
ntex-bytes = "0.1.19"
ntex-util = "0.3.0-beta.0"
ntex-service = "1.2.0-beta.0"
ntex-util = "0.3.0-beta.1"
ntex-service = "1.2.0-beta.1"
bitflags = "1.3"
log = "0.4"

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

@ -426,7 +426,7 @@ mod tests {
use ntex_bytes::{Bytes, PoolId, PoolRef};
use ntex_codec::BytesCodec;
use ntex_service::Ctx;
use ntex_service::ServiceCtx;
use ntex_util::{future::Ready, time::sleep, time::Millis, time::Seconds};
use super::*;
@ -625,7 +625,7 @@ mod tests {
fn call<'a>(
&'a self,
_: DispatchItem<BytesCodec>,
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(None)
}

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

@ -1,6 +1,6 @@
use std::marker::PhantomData;
use ntex_service::{fn_service, pipeline_factory, Ctx, Service, ServiceFactory};
use ntex_service::{fn_service, pipeline_factory, Service, ServiceCtx, ServiceFactory};
use ntex_util::future::Ready;
use crate::{Filter, FilterFactory, Io, IoBoxed, Layer};
@ -75,7 +75,7 @@ where
type Future<'f> = T::Future where T: 'f, F: 'f;
#[inline]
fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.filter.clone().create(req)
}
}

4
ntex-service/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [1.2.0-beta.1] - 2023-06-19
* Rename Ctx to ServiceCtx
## [1.2.0-beta.0] - 2023-06-16
* Enforce service readiness during call

2
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "1.2.0-beta.0"
version = "1.2.0-beta.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex service"
keywords = ["network", "framework", "async", "futures"]

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

@ -1,6 +1,6 @@
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use super::{Ctx, Service, ServiceCall, ServiceFactory};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
/// Service for the `and_then` combinator, chaining a computation onto the end
/// of another service which completes successfully.
@ -59,7 +59,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
AndThenServiceResponse {
slf: self,
state: State::A {
@ -93,7 +93,7 @@ pin_project_lite::pin_project! {
B: Service<A::Response, Error = A::Error>,
B: 'f,
{
A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<Ctx<'f, AndThen<A, B>>> },
A { #[pin] fut: ServiceCall<'f, A, Req>, ctx: Option<ServiceCtx<'f, AndThen<A, B>>> },
B { #[pin] fut: ServiceCall<'f, B, A::Response> },
Empty,
}
@ -234,7 +234,9 @@ where
mod tests {
use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
use crate::{fn_factory, pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
use crate::{
fn_factory, pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory,
};
use ntex_util::future::{lazy, Ready};
#[derive(Clone)]
@ -250,7 +252,11 @@ mod tests {
Poll::Ready(Ok(()))
}
fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: &'static str,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(req)
}
}
@ -268,7 +274,11 @@ mod tests {
Poll::Ready(Ok(()))
}
fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: &'static str,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok((req, "srv2"))
}
}

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

@ -1,7 +1,7 @@
#![allow(clippy::type_complexity)]
use std::{future::Future, marker, pin::Pin, rc::Rc, task, task::Poll};
use super::ctx::{Ctx, ServiceCall, Waiters};
use super::ctx::{ServiceCall, ServiceCtx, Waiters};
use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
/// Apply transform function to a service.
@ -83,7 +83,7 @@ impl<S> ApplyService<S> {
where
S: Service<R>,
{
Ctx::<S>::new(&self.waiters).call(&self.svc, req)
ServiceCtx::<S>::new(&self.waiters).call(&self.svc, req)
}
}
@ -101,7 +101,7 @@ where
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: In, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: In, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
let svc = ApplyService {
svc: self.service.clone(),
waiters: ctx.waiters().clone(),
@ -221,7 +221,7 @@ mod tests {
use std::task::Poll;
use super::*;
use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
#[derive(Clone)]
struct Srv;
@ -231,7 +231,7 @@ mod tests {
type Error = ();
type Future<'f> = Ready<(), ()>;
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
}
}

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

@ -1,6 +1,6 @@
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use crate::ctx::{Ctx, Waiters};
use crate::ctx::{ServiceCtx, Waiters};
pub type BoxFuture<'a, I, E> = Pin<Box<dyn Future<Output = Result<I, E>> + 'a>>;
@ -71,7 +71,7 @@ where
req: Req,
waiters: &'a Waiters,
) -> BoxFuture<'a, Self::Response, Self::Error> {
Box::pin(Ctx::<'a, S>::new(waiters).call_nowait(self, req))
Box::pin(ServiceCtx::<'a, S>::new(waiters).call_nowait(self, req))
}
}
@ -131,7 +131,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.0.call(req, ctx.waiters())
}
}

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

@ -12,7 +12,7 @@ pub struct Container<S> {
waiters: Waiters,
}
pub struct Ctx<'a, S: ?Sized> {
pub struct ServiceCtx<'a, S: ?Sized> {
waiters: &'a Waiters,
_t: marker::PhantomData<Rc<S>>,
}
@ -103,7 +103,7 @@ impl<S> Container<S> {
where
S: Service<R>,
{
let ctx = Ctx::<'a, S> {
let ctx = ServiceCtx::<'a, S> {
waiters: &self.waiters,
_t: marker::PhantomData,
};
@ -151,7 +151,7 @@ impl<S> ops::Deref for Container<S> {
}
}
impl<'a, S: ?Sized> Ctx<'a, S> {
impl<'a, S: ?Sized> ServiceCtx<'a, S> {
pub(crate) fn new(waiters: &'a Waiters) -> Self {
Self {
waiters,
@ -171,7 +171,7 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
{
svc.call(
req,
Ctx {
ServiceCtx {
waiters: self.waiters,
_t: marker::PhantomData,
},
@ -195,9 +195,9 @@ impl<'a, S: ?Sized> Ctx<'a, S> {
}
}
impl<'a, S: ?Sized> Copy for Ctx<'a, S> {}
impl<'a, S: ?Sized> Copy for ServiceCtx<'a, S> {}
impl<'a, S: ?Sized> Clone for Ctx<'a, S> {
impl<'a, S: ?Sized> Clone for ServiceCtx<'a, S> {
#[inline]
fn clone(&self) -> Self {
Self {
@ -256,7 +256,7 @@ where
let fut = svc.call(
req.take().unwrap(),
Ctx {
ServiceCtx {
waiters,
_t: marker::PhantomData,
},
@ -327,7 +327,11 @@ mod tests {
self.1.poll_ready(cx).map(|_| Ok(()))
}
fn call<'a>(&'a self, req: &'static str, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: &'static str,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(req)
}
}

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

@ -1,6 +1,6 @@
use std::{future::ready, future::Future, future::Ready, marker::PhantomData};
use crate::{Ctx, IntoService, IntoServiceFactory, Service, ServiceFactory};
use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
#[inline]
/// Create `ServiceFactory` for function that can act as a `Service`
@ -128,7 +128,7 @@ where
type Future<'f> = Fut where Self: 'f, Req: 'f;
#[inline]
fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
(self.f)(req)
}
}
@ -190,7 +190,7 @@ where
type Future<'f> = Fut where Self: 'f;
#[inline]
fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
(self.f)(req)
}
}

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

@ -3,7 +3,7 @@ use std::future::{ready, Ready};
use std::marker::PhantomData;
use std::task::{Context, Poll};
use crate::{Ctx, Service};
use crate::{Service, ServiceCtx};
#[inline]
/// Create `FnShutdown` for function that can act as a `on_shutdown` callback.
@ -60,7 +60,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: Req, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ready(Ok(req))
}
}

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

@ -22,7 +22,7 @@ mod pipeline;
mod then;
pub use self::apply::{apply_fn, apply_fn_factory};
pub use self::ctx::{Container, ContainerFactory, Ctx, ServiceCall};
pub use self::ctx::{Container, ContainerFactory, ServiceCall, ServiceCtx};
pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
pub use self::fn_shutdown::fn_shutdown;
pub use self::map_config::{map_config, unit_config};
@ -59,7 +59,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
/// # use std::future::Future;
/// # use std::pin::Pin;
/// #
/// # use ntex_service::{Ctx, Service};
/// # use ntex_service::{Service, ServiceCtx};
///
/// struct MyService;
///
@ -68,7 +68,7 @@ pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
/// type Error = Infallible;
/// type Future<'f> = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
///
/// fn call<'a>(&'a self, req: u8, _: Ctx<'a, Self>) -> Self::Future<'a> {
/// fn call<'a>(&'a self, req: u8, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
/// Box::pin(std::future::ready(Ok(req as u64)))
/// }
/// }
@ -103,7 +103,7 @@ pub trait Service<Req> {
/// should take care to not call `poll_ready`. Caller of the service verifies readiness,
/// Only way to make a `call` is to use `ctx` argument, it enforces readiness before calling
/// service.
fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a>;
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>;
#[inline]
/// Returns `Ready` when the service is able to process requests.
@ -261,7 +261,7 @@ where
}
#[inline]
fn call<'s>(&'s self, request: Req, ctx: Ctx<'s, Self>) -> S::Future<'s> {
fn call<'s>(&'s self, request: Req, ctx: ServiceCtx<'s, Self>) -> S::Future<'s> {
ctx.call_nowait(&**self, request)
}
}
@ -285,7 +285,7 @@ where
}
#[inline]
fn call<'a>(&'a self, request: Req, ctx: Ctx<'a, Self>) -> S::Future<'a> {
fn call<'a>(&'a self, request: Req, ctx: ServiceCtx<'a, Self>) -> S::Future<'a> {
ctx.call_nowait(&**self, request)
}
}

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

@ -1,6 +1,6 @@
use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use super::{Ctx, Service, ServiceCall, ServiceFactory};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
/// Service for the `map` combinator, changing the type of a service's response.
///
@ -54,7 +54,7 @@ where
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
MapFuture {
fut: ctx.call(&self.service, req),
slf: self,
@ -192,7 +192,7 @@ mod tests {
use ntex_util::future::{lazy, Ready};
use super::*;
use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
#[derive(Clone)]
struct Srv;
@ -206,7 +206,7 @@ mod tests {
Poll::Ready(Ok(()))
}
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
}
}

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

@ -1,6 +1,6 @@
use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
use super::{Ctx, Service, ServiceCall, ServiceFactory};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
/// Service for the `map_err` combinator, changing the type of a service's
/// error.
@ -57,7 +57,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
MapErrFuture {
slf: self,
fut: ctx.call(&self.service, req),
@ -196,7 +196,7 @@ mod tests {
use ntex_util::future::{lazy, Ready};
use super::*;
use crate::{fn_factory, Container, Ctx, Service, ServiceFactory};
use crate::{fn_factory, Container, Service, ServiceCtx, ServiceFactory};
#[derive(Clone)]
struct Srv(bool);
@ -214,7 +214,7 @@ mod tests {
}
}
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Err(())
}
}

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

@ -214,7 +214,7 @@ mod tests {
use std::marker;
use super::*;
use crate::{fn_service, Container, Ctx, Service, ServiceCall, ServiceFactory};
use crate::{fn_service, Container, Service, ServiceCall, ServiceCtx, ServiceFactory};
#[derive(Clone)]
struct Tr<R>(marker::PhantomData<R>);
@ -239,7 +239,7 @@ mod tests {
self.0.poll_ready(cx)
}
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ctx.call(&self.0, req)
}
}

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

@ -1,7 +1,7 @@
use std::marker::PhantomData;
use crate::and_then::{AndThen, AndThenFactory};
use crate::ctx::{Container, Ctx, ServiceCall};
use crate::ctx::{Container, ServiceCall, ServiceCtx};
use crate::map::{Map, MapFactory};
use crate::map_err::{MapErr, MapErrFactory};
use crate::map_init_err::MapInitErr;
@ -144,7 +144,7 @@ impl<Req, Svc: Service<Req>> Service<Req> for Pipeline<Req, Svc> {
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: Req, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Req, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ctx.call(&self.service, req)
}
}

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

@ -1,6 +1,6 @@
use std::{future::Future, pin::Pin, task::Context, task::Poll};
use super::{Ctx, Service, ServiceCall, ServiceFactory};
use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
/// Service for the `then` combinator, chaining a computation onto the end of
/// another service.
@ -60,7 +60,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
ThenServiceResponse {
slf: self,
state: State::A {
@ -95,7 +95,7 @@ pin_project_lite::pin_project! {
B: 'f,
R: 'f,
{
A { #[pin] fut: ServiceCall<'f, A, R>, ctx: Ctx<'f, Then<A, B>> },
A { #[pin] fut: ServiceCall<'f, A, R>, ctx: ServiceCtx<'f, Then<A, B>> },
B { #[pin] fut: ServiceCall<'f, B, Result<A::Response, A::Error>> },
Empty,
}
@ -248,7 +248,7 @@ mod tests {
use ntex_util::future::{lazy, Ready};
use std::{cell::Cell, rc::Rc, task::Context, task::Poll};
use crate::{pipeline, pipeline_factory, Ctx, Service, ServiceFactory};
use crate::{pipeline, pipeline_factory, Service, ServiceCtx, ServiceFactory};
#[derive(Clone)]
struct Srv1(Rc<Cell<usize>>);
@ -266,7 +266,7 @@ mod tests {
fn call<'a>(
&'a self,
req: Result<&'static str, &'static str>,
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
match req {
Ok(msg) => Ready::Ok(msg),
@ -291,7 +291,7 @@ mod tests {
fn call<'a>(
&'a self,
req: Result<&'static str, ()>,
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
match req {
Ok(msg) => Ready::Ok((msg, "ok")),

10
ntex-tls/Cargo.toml
View file

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

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::{Ctx, Service, ServiceFactory};
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use ntex_util::{future::Ready, time::Millis};
use tls_openssl::ssl::SslAcceptor;
@ -95,7 +95,7 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
}
#[inline]
fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
AcceptorServiceResponse {
_guard: self.conns.get(),
fut: self.acceptor.clone().create(req),

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::{Ctx, Service, ServiceFactory};
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use ntex_util::{future::Ready, time::Millis};
use super::{TlsAcceptor, TlsFilter};
@ -93,7 +93,7 @@ impl<F: Filter> Service<Io<F>> for AcceptorService<F> {
}
#[inline]
fn call<'a>(&'a self, req: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
AcceptorServiceFut {
_guard: self.conns.get(),
fut: self.acceptor.clone().create(req),

4
ntex-util/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-util"
version = "0.3.0-beta.0"
version = "0.3.0-beta.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Utilities for ntex framework"
keywords = ["network", "framework", "async", "futures"]
@ -17,7 +17,7 @@ path = "src/lib.rs"
[dependencies]
ntex-rt = "0.4.7"
ntex-service = "1.2.0-beta.0"
ntex-service = "1.2.0-beta.1"
bitflags = "1.3"
fxhash = "0.2.1"
log = "0.4"

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

@ -3,7 +3,7 @@ use std::cell::{Cell, RefCell};
use std::task::{ready, Context, Poll};
use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin};
use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use crate::{channel::oneshot, future::Either, task::LocalWaker};
@ -138,7 +138,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
if self.ready.get() {
self.ready.set(false);
Either::Left(ctx.call(&self.service, req))
@ -220,7 +220,7 @@ mod tests {
}
}
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.0.ready.set(false);
self.0.count.set(self.0.count.get() + 1);
Ready::Ok(())

8
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::{Ctx, IntoService, Middleware, Service, ServiceCall};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use super::counter::{Counter, CounterGuard};
@ -76,7 +76,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
InFlightServiceResponse {
fut: ctx.call(&self.service, req),
_guard: self.count.get(),
@ -109,7 +109,7 @@ impl<'f, T: Service<R>, R> Future for InFlightServiceResponse<'f, T, R> {
#[cfg(test)]
mod tests {
use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
use ntex_service::{apply, fn_factory, Container, Service, ServiceCtx, ServiceFactory};
use std::{cell::RefCell, task::Poll, time::Duration};
use super::*;
@ -122,7 +122,7 @@ mod tests {
type Error = ();
type Future<'f> = BoxFuture<'f, Result<(), ()>>;
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(async move {
let _ = self.0.recv().await;
Ok::<_, ()>(())

4
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::{Ctx, Service, ServiceFactory};
use ntex_service::{Service, ServiceCtx, ServiceFactory};
use crate::future::Ready;
use crate::time::{now, sleep, Millis, Sleep};
@ -113,7 +113,7 @@ where
}
}
fn call<'a>(&'a self, req: R, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.expire.set(now());
Ready::Ok(req)
}

8
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::{Ctx, IntoService, Middleware, Service, ServiceCall};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use crate::task::LocalWaker;
@ -63,7 +63,7 @@ where
}
#[inline]
fn call<'a>(&'a self, req: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
self.ready.set(false);
OneRequestServiceResponse {
@ -101,7 +101,7 @@ impl<'f, T: Service<R>, R> Future for OneRequestServiceResponse<'f, T, R> {
#[cfg(test)]
mod tests {
use ntex_service::{apply, fn_factory, Container, Ctx, Service, ServiceFactory};
use ntex_service::{apply, fn_factory, Container, Service, ServiceCtx, ServiceFactory};
use std::{cell::RefCell, task::Poll, time::Duration};
use super::*;
@ -114,7 +114,7 @@ mod tests {
type Error = ();
type Future<'f> = BoxFuture<'f, Result<(), ()>>;
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Box::pin(async move {
let _ = self.0.recv().await;
Ok::<_, ()>(())

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

@ -4,7 +4,7 @@
//! will be aborted.
use std::{fmt, future::Future, marker, pin::Pin, task::Context, task::Poll};
use ntex_service::{Ctx, IntoService, Middleware, Service, ServiceCall};
use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
use crate::future::Either;
use crate::time::{sleep, Millis, Sleep};
@ -125,7 +125,7 @@ where
type Error = TimeoutError<S::Error>;
type Future<'f> = Either<TimeoutServiceResponse<'f, S, R>, TimeoutServiceResponse2<'f, S, R>> where Self: 'f, R: 'f;
fn call<'a>(&'a self, request: R, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, request: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
if self.timeout.is_zero() {
Either::Right(TimeoutServiceResponse2 {
fut: ctx.call(&self.service, request),
@ -236,7 +236,7 @@ mod tests {
type Error = SrvError;
type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
let fut = crate::time::sleep(self.0);
Box::pin(async move {
fut.await;

8
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::{Ctx, IntoServiceFactory, Service, ServiceCall, ServiceFactory};
use ntex_service::{IntoServiceFactory, Service, ServiceCall, ServiceCtx, ServiceFactory};
/// Construct `Variant` service factory.
///
@ -128,7 +128,7 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
}
}
fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: Ctx<'a, Self>) -> Self::Future<'a>
fn call<'a>(&'a self, req: $enum_type<V1R, $($R,)+>, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a>
{
match req {
$enum_type::V1(req) => $mod_name::ServiceResponse::V1 { fut: ctx.call(&self.V1, req) },
@ -321,7 +321,7 @@ mod tests {
Poll::Ready(())
}
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::<_, ()>::Ok(1)
}
}
@ -342,7 +342,7 @@ mod tests {
Poll::Ready(())
}
fn call<'a>(&'a self, _: (), _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::<_, ()>::Ok(2)
}
}

4
ntex/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.7.0-beta.1] - 2023-06-19
* Rename Ctx to ServiceCtx
## [0.7.0-beta.0] - 2023-06-16
* Migrate to ntex-service 1.2

14
ntex/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex"
version = "0.7.0-beta.0"
version = "0.7.0-beta.1"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Framework for composable network services"
readme = "README.md"
@ -49,17 +49,17 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
[dependencies]
ntex-codec = "0.6.2"
ntex-connect = "0.3.0-beta.0"
ntex-connect = "0.3.0-beta.1"
ntex-http = "0.1.9"
ntex-router = "0.5.1"
ntex-service = "1.2.0-beta.0"
ntex-service = "1.2.0-beta.1"
ntex-macros = "0.1.3"
ntex-util = "0.3.0-beta.0"
ntex-util = "0.3.0-beta.1"
ntex-bytes = "0.1.19"
ntex-h2 = "0.3.0-beta.0"
ntex-h2 = "0.3.0-beta.1"
ntex-rt = "0.4.9"
ntex-io = "0.3.0-beta.0"
ntex-tls = "0.3.0-beta.0"
ntex-io = "0.3.0-beta.1"
ntex-tls = "0.3.0-beta.1"
ntex-tokio = { version = "0.3.0-beta.0", optional = true }
ntex-glommio = { version = "0.3.0-beta.0", optional = true }
ntex-async-std = { version = "0.3.0-beta.0", optional = true }

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

@ -3,7 +3,7 @@ use std::{task::Context, task::Poll, time::Duration};
use ntex_h2::{self as h2};
use crate::connect::{Connect as TcpConnect, Connector as TcpConnector};
use crate::service::{apply_fn, boxed, Ctx, Service, ServiceCall};
use crate::service::{apply_fn, boxed, Service, ServiceCall, ServiceCtx};
use crate::time::{Millis, Seconds};
use crate::util::{timeout::TimeoutError, timeout::TimeoutService, Either, Ready};
use crate::{http::Uri, io::IoBoxed};
@ -315,7 +315,7 @@ where
}
}
fn call<'a>(&'a self, req: Connect, ctx: Ctx<'a, Self>) -> Self::Future<'_> {
fn call<'a>(&'a self, req: Connect, ctx: ServiceCtx<'a, Self>) -> Self::Future<'_> {
match req.uri.scheme_str() {
Some("https") | Some("wss") => {
if let Some(ref conn) = self.ssl_pool {

8
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::Ctx, service::Service};
use crate::{channel::oneshot, Service, ServiceCtx};
use super::error::SendRequestError;
@ -226,7 +226,11 @@ impl Service<h2::Message> for H2PublishService {
type Error = &'static str;
type Future<'f> = Ready<Self::Response, Self::Error>;
fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
mut msg: h2::Message,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
match msg.kind().take() {
h2::MessageKind::Headers {
pseudo,

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

@ -6,7 +6,7 @@ use ntex_h2::{self as h2};
use crate::http::uri::{Authority, Scheme, Uri};
use crate::io::{types::HttpProtocol, IoBoxed};
use crate::service::{Container, Ctx, Service, ServiceCall};
use crate::service::{Container, Service, ServiceCall, ServiceCtx};
use crate::time::{now, Millis};
use crate::util::{ready, BoxFuture, ByteString, HashMap, HashSet};
use crate::{channel::pool, rt::spawn, task::LocalWaker};
@ -121,7 +121,7 @@ where
crate::forward_poll_ready!(connector);
crate::forward_poll_shutdown!(connector);
fn call<'a>(&'a self, req: Connect, _: Ctx<'a, Self>) -> Self::Future<'_> {
fn call<'a>(&'a self, req: Connect, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
trace!("Get connection for {:?}", req.uri);
let inner = self.inner.clone();
let waiters = self.waiters.clone();

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

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

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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::{time::Millis, util::BoxFuture};
use super::codec::Codec;
@ -331,7 +331,7 @@ where
}
}
fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
log::trace!(
"New http1 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()

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

@ -1,7 +1,8 @@
use std::{io, marker::PhantomData};
use crate::http::{h1::Codec, request::Request};
use crate::{io::Io, service::Ctx, service::Service, service::ServiceFactory, util::Ready};
use crate::service::{Service, ServiceCtx, ServiceFactory};
use crate::{io::Io, util::Ready};
pub struct UpgradeHandler<F>(PhantomData<F>);
@ -28,7 +29,7 @@ impl<F> Service<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
fn call<'a>(
&'a self,
_: (Request, Io<F>, Codec),
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
unimplemented!()
}

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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::util::{poll_fn, BoxFuture, Bytes, BytesMut, Either, HashMap, Ready};
use super::payload::{Payload, PayloadSender};
@ -181,7 +181,7 @@ where
self.config.service.poll_shutdown(cx)
}
fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'_> {
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'_> {
log::trace!(
"New http2 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
@ -233,7 +233,7 @@ impl Service<h2::ControlMessage<H2Error>> for ControlService {
fn call<'a>(
&'a self,
msg: h2::ControlMessage<H2Error>,
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
log::trace!("Control message: {:?}", msg);
Ready::Ok::<_, ()>(msg.ack())
@ -280,7 +280,11 @@ where
Ready<Self::Response, Self::Error>,
>;
fn call<'a>(&'a self, mut msg: h2::Message, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
mut msg: h2::Message,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
let (io, pseudo, headers, eof, payload) = match msg.kind().take() {
h2::MessageKind::Headers {
pseudo,

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::{Ctx, IntoServiceFactory, Service, ServiceFactory};
use crate::service::{IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
use crate::time::{Millis, Seconds};
use crate::util::BoxFuture;
@ -368,7 +368,7 @@ where
}
}
fn call<'a>(&'a self, io: Io<F>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, io: Io<F>, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
log::trace!(
"New http connection, peer address {:?}",
io.query::<types::PeerAddr>().get()

4
ntex/src/lib.rs
View file

@ -38,8 +38,8 @@ pub mod web;
pub mod ws;
pub use self::service::{
fn_service, into_service, pipeline, pipeline_factory, Container, Ctx, IntoService,
IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory,
fn_service, into_service, pipeline, pipeline_factory, Container, IntoService,
IntoServiceFactory, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory,
};
pub use ntex_util::{channel, task};

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

@ -2,7 +2,7 @@ use std::{net::SocketAddr, rc::Rc, task::Context, task::Poll};
use log::error;
use crate::service::{boxed, Ctx, Service, ServiceFactory};
use crate::service::{boxed, Service, ServiceCtx, ServiceFactory};
use crate::util::{BoxFuture, Pool, PoolId};
use crate::{io::Io, time::Millis};
@ -74,7 +74,7 @@ where
fn call<'a>(
&'a self,
(guard, req): (Option<CounterGuard>, ServerMessage),
ctx: Ctx<'a, Self>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Box::pin(async move {
match req {

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

@ -512,7 +512,7 @@ mod tests {
use super::*;
use crate::io::Io;
use crate::server::service::Factory;
use crate::service::{Ctx, Service, ServiceFactory};
use crate::service::{Service, ServiceCtx, ServiceFactory};
use crate::util::{lazy, Ready};
#[derive(Clone, Copy, Debug)]
@ -572,7 +572,7 @@ mod tests {
}
}
fn call<'a>(&'a self, _: Io, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, _: Io, _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
Ready::Ok(())
}
}

8
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::{Ctx, Identity, Middleware, Service, ServiceFactory, Stack};
use crate::service::{Identity, Middleware, Service, ServiceCtx, ServiceFactory, Stack};
use crate::util::{BoxFuture, Extensions, Ready};
use super::app_service::{AppFactory, AppService};
@ -581,7 +581,11 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
type Future<'f> = Ready<WebRequest<Err>, Err::Container>;
#[inline]
fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<Err>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Ready::Ok(req)
}
}

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

@ -5,7 +5,8 @@ use crate::http::{Request, Response};
use crate::router::{Path, ResourceDef, Router};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{
fn_service, Ctx, Middleware, PipelineFactory, Service, ServiceCall, ServiceFactory,
fn_service, Middleware, PipelineFactory, Service, ServiceCall, ServiceCtx,
ServiceFactory,
};
use crate::util::{BoxFuture, Either, Extensions};
@ -205,7 +206,7 @@ where
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(&'a self, req: Request, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(&'a self, req: Request, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
let (head, payload) = req.into_parts();
let req = if let Some(mut req) = self.pool.get_request() {
@ -253,7 +254,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
fn call<'a>(
&'a self,
mut req: WebRequest<Err>,
ctx: Ctx<'a, Self>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards {
@ -305,7 +306,11 @@ where
}
}
fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
AppServiceResponse {
filter: ctx.call(&self.filter, req),
routing: &self.routing,
@ -326,7 +331,7 @@ pin_project_lite::pin_project! {
filter: ServiceCall<'f, F, WebRequest<Err>>,
routing: &'f AppRouting<Err>,
endpoint: Option<BoxAppServiceResponse<'f, Err>>,
ctx: Ctx<'f, AppService<F, Err>>,
ctx: ServiceCtx<'f, AppService<F, Err>>,
}
}

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::{Ctx, Middleware, Service, ServiceCall};
use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
#[derive(Debug, Clone)]
@ -71,7 +71,11 @@ where
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
// negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() {

8
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::{Ctx, Middleware, Service};
use crate::service::{Middleware, Service, ServiceCtx};
use crate::util::BoxFuture;
use crate::web::{WebRequest, WebResponse};
@ -115,7 +115,11 @@ where
crate::forward_poll_ready!(service);
crate::forward_poll_shutdown!(service);
fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
Box::pin(async move {
let mut res = ctx.call(&self.service, req).await?;

8
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::{Ctx, Middleware, Service, ServiceCall};
use crate::service::{Middleware, Service, ServiceCall, ServiceCtx};
use crate::util::{Bytes, Either, HashSet};
use crate::web::{HttpResponse, WebRequest, WebResponse};
@ -142,7 +142,11 @@ where
crate::forward_poll_shutdown!(service);
#[inline]
fn call<'a>(&'a self, req: WebRequest<E>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<E>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
if self.inner.exclude.contains(req.path()) {
Either::Right(ctx.call(&self.service, req))
} else {

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

@ -4,7 +4,7 @@ use crate::http::Response;
use crate::router::{IntoPattern, ResourceDef};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{
dev::AndThen, pipeline, pipeline_factory, Ctx, Pipeline, PipelineFactory,
dev::AndThen, pipeline, pipeline_factory, Pipeline, PipelineFactory, ServiceCtx,
};
use crate::service::{
Identity, IntoServiceFactory, Middleware, Service, ServiceCall, ServiceFactory, Stack,
@ -480,7 +480,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
fn call<'a>(
&'a self,
mut req: WebRequest<Err>,
ctx: Ctx<'a, Self>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
for route in self.routes.iter() {
if route.check(&mut req) {

8
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::Ctx, service::Service, service::ServiceFactory};
use crate::{http::Method, service::Service, service::ServiceCtx, service::ServiceFactory};
use super::error::ErrorRenderer;
use super::error_default::DefaultError;
@ -90,7 +90,11 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for RouteService<Err> {
type Future<'f> = BoxFuture<'f, Result<Self::Response, Self::Error>>;
#[inline]
fn call<'a>(&'a self, req: WebRequest<Err>, _: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<Err>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
self.handler.call(req)
}
}

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

@ -7,7 +7,7 @@ use crate::router::{IntoPattern, ResourceDef, Router};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{pipeline_factory, IntoServiceFactory, PipelineFactory};
use crate::service::{
Ctx, Identity, Middleware, Service, ServiceCall, ServiceFactory, Stack,
Identity, Middleware, Service, ServiceCall, ServiceCtx, ServiceFactory, Stack,
};
use crate::util::{BoxFuture, Either, Extensions, Ready};
@ -505,7 +505,11 @@ where
}
}
fn call<'a>(&'a self, req: WebRequest<Err>, ctx: Ctx<'a, Self>) -> Self::Future<'a> {
fn call<'a>(
&'a self,
req: WebRequest<Err>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
ScopeServiceResponse {
filter: ctx.call(&self.filter, req),
routing: &self.routing,
@ -522,7 +526,7 @@ pin_project_lite::pin_project! {
#[pin]
filter: ServiceCall<'f, F, WebRequest<Err>>,
routing: &'f ScopeRouter<Err>,
ctx: Ctx<'f, ScopeService<F, Err>>,
ctx: ServiceCtx<'f, ScopeService<F, Err>>,
endpoint: Option<ServiceCall<'f, ScopeRouter<Err>, WebRequest<Err>>>,
}
}
@ -608,7 +612,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
fn call<'a>(
&'a self,
mut req: WebRequest<Err>,
ctx: Ctx<'a, Self>,
ctx: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards {

4
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, Ctx, Service};
use ntex::service::{fn_factory, Service, ServiceCtx};
use ntex::util::{BoxFuture, ByteString, Bytes, Ready};
use ntex::ws::{self, handshake, handshake_response};
@ -43,7 +43,7 @@ impl Service<(Request, Io, h1::Codec)> for WsService {
fn call<'a>(
&'a self,
(req, io, codec): (Request, Io, h1::Codec),
_: Ctx<'a, Self>,
_: ServiceCtx<'a, Self>,
) -> Self::Future<'a> {
let fut = async move {
let res = handshake(req.head()).unwrap().message_body(());