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

refactor Service trait

Browse source
This commit is contained in:
Nikolay Kim 2020-03-30 17:44:22 +06:00
parent a3abae8c16
commit 89cebe5534
58 changed files with 701 additions and 593 deletions
Download patch file Download diff file Expand all files Collapse all files

28
ntex-router/src/router.rs
View file

@ -62,6 +62,34 @@ impl<T, U> Router<T, U> {
} }
} }
pub fn recognize_checked<R, P, F>(
&self,
resource: &mut R,
check: F,
) -> Option<(&T, ResourceId)>
where
F: Fn(&R, Option<&U>) -> bool,
R: Resource<P>,
P: ResourcePath,
{
if let Some(idx) = if self.insensitive {
self.tree.find_checked_insensitive(resource, &|idx, res| {
let item = &self.resources[idx];
check(res, item.2.as_ref())
})
} else {
self.tree.find_checked(resource, &|idx, res| {
let item = &self.resources[idx];
check(res, item.2.as_ref())
})
} {
let item = &self.resources[idx];
Some((&item.1, ResourceId(item.0.id())))
} else {
None
}
}
pub fn recognize_mut_checked<R, P, F>( pub fn recognize_mut_checked<R, P, F>(
&mut self, &mut self,
resource: &mut R, resource: &mut R,

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

@ -4,13 +4,12 @@ use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use super::{Service, ServiceFactory}; use super::{Service, ServiceFactory};
use crate::cell::Cell;
/// Service for the `and_then` combinator, chaining a computation onto the end /// Service for the `and_then` combinator, chaining a computation onto the end
/// of another service which completes successfully. /// of another service which completes successfully.
/// ///
/// This is created by the `ServiceExt::and_then` method. /// This is created by the `ServiceExt::and_then` method.
pub(crate) struct AndThenService<A, B>(Cell<(A, B)>); pub(crate) struct AndThenService<A, B>(Rc<(A, B)>);
impl<A, B> AndThenService<A, B> { impl<A, B> AndThenService<A, B> {
/// Create new `AndThen` combinator /// Create new `AndThen` combinator
@ -19,7 +18,7 @@ impl<A, B> AndThenService<A, B> {
A: Service, A: Service,
B: Service<Request = A::Response, Error = A::Error>, B: Service<Request = A::Response, Error = A::Error>,
{ {
Self(Cell::new((a, b))) Self(Rc::new((a, b)))
} }
} }
@ -39,8 +38,8 @@ where
type Error = A::Error; type Error = A::Error;
type Future = AndThenServiceResponse<A, B>; type Future = AndThenServiceResponse<A, B>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let srv = self.0.get_mut(); let srv = self.0.as_ref();
let not_ready = !srv.0.poll_ready(cx)?.is_ready(); let not_ready = !srv.0.poll_ready(cx)?.is_ready();
if !srv.1.poll_ready(cx)?.is_ready() || not_ready { if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
Poll::Pending Poll::Pending
@ -49,8 +48,8 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let srv = self.0.get_mut(); let srv = self.0.as_ref();
if srv.0.poll_shutdown(cx, is_error).is_ready() if srv.0.poll_shutdown(cx, is_error).is_ready()
&& srv.1.poll_shutdown(cx, is_error).is_ready() && srv.1.poll_shutdown(cx, is_error).is_ready()
@ -62,9 +61,9 @@ where
} }
#[inline] #[inline]
fn call(&mut self, req: A::Request) -> Self::Future { fn call(&self, req: A::Request) -> Self::Future {
AndThenServiceResponse { AndThenServiceResponse {
state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())), state: State::A(self.0.as_ref().0.call(req), Some(self.0.clone())),
} }
} }
} }
@ -85,7 +84,7 @@ where
A: Service, A: Service,
B: Service<Request = A::Response, Error = A::Error>, B: Service<Request = A::Response, Error = A::Error>,
{ {
A(#[pin] A::Future, Option<Cell<(A, B)>>), A(#[pin] A::Future, Option<Rc<(A, B)>>),
B(#[pin] B::Future), B(#[pin] B::Future),
Empty, Empty,
} }
@ -105,9 +104,9 @@ where
match this.state.as_mut().project() { match this.state.as_mut().project() {
State::A(fut, b) => match fut.poll(cx)? { State::A(fut, b) => match fut.poll(cx)? {
Poll::Ready(res) => { Poll::Ready(res) => {
let mut b = b.take().unwrap(); let b = b.take().unwrap();
this.state.set(State::Empty); // drop fut A this.state.set(State::Empty); // drop fut A
let fut = b.get_mut().1.call(res); let fut = b.as_ref().1.call(res);
this.state.set(State::B(fut)); this.state.set(State::B(fut));
self.poll(cx) self.poll(cx)
} }
@ -284,12 +283,12 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<Self::Response, ()>>; type Future = Ready<Result<Self::Response, ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1); self.0.set(self.0.get() + 1);
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: &'static str) -> Self::Future { fn call(&self, req: &'static str) -> Self::Future {
ok(req) ok(req)
} }
} }
@ -303,12 +302,12 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<Self::Response, ()>>; type Future = Ready<Result<Self::Response, ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1); self.0.set(self.0.get() + 1);
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: &'static str) -> Self::Future { fn call(&self, req: &'static str) -> Self::Future {
ok((req, "srv2")) ok((req, "srv2"))
} }
} }
@ -316,7 +315,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_poll_ready() { async fn test_poll_ready() {
let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone())); let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone()));
let res = lazy(|cx| srv.poll_ready(cx)).await; let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(()))); assert_eq!(res, Poll::Ready(Ok(())));
assert_eq!(cnt.get(), 2); assert_eq!(cnt.get(), 2);
@ -325,7 +324,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_call() { async fn test_call() {
let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt)); let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
let res = srv.call("srv1").await; let res = srv.call("srv1").await;
assert!(res.is_ok()); assert!(res.is_ok());
assert_eq!(res.unwrap(), (("srv1", "srv2"))); assert_eq!(res.unwrap(), (("srv1", "srv2")));
@ -339,7 +338,7 @@ mod tests {
pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))))) pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
.and_then(move || ready(Ok(Srv2(cnt.clone())))); .and_then(move || ready(Ok(Srv2(cnt.clone()))));
let mut srv = new_srv.new_service(()).await.unwrap(); let srv = new_srv.new_service(()).await.unwrap();
let res = srv.call("srv1").await; let res = srv.call("srv1").await;
assert!(res.is_ok()); assert!(res.is_ok());
assert_eq!(res.unwrap(), ("srv1", "srv2")); assert_eq!(res.unwrap(), ("srv1", "srv2"));

57
ntex-service/src/and_then_apply_fn.rs
View file

@ -4,7 +4,6 @@ use std::pin::Pin;
use std::rc::Rc; use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use crate::cell::Cell;
use crate::{Service, ServiceFactory}; use crate::{Service, ServiceFactory};
/// `Apply` service combinator /// `Apply` service combinator
@ -12,11 +11,11 @@ pub(crate) struct AndThenApplyFn<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
srv: Cell<(A, B, F)>, srv: Rc<(A, B, F)>,
r: PhantomData<(Fut, Res, Err)>, r: PhantomData<(Fut, Res, Err)>,
} }
@ -24,14 +23,14 @@ impl<A, B, F, Fut, Res, Err> AndThenApplyFn<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
/// Create new `Apply` combinator /// Create new `Apply` combinator
pub(crate) fn new(a: A, b: B, f: F) -> Self { pub(crate) fn new(a: A, b: B, f: F) -> Self {
Self { Self {
srv: Cell::new((a, b, f)), srv: Rc::new((a, b, f)),
r: PhantomData, r: PhantomData,
} }
} }
@ -41,7 +40,7 @@ impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -57,7 +56,7 @@ impl<A, B, F, Fut, Res, Err> Service for AndThenApplyFn<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -66,8 +65,8 @@ where
type Error = Err; type Error = Err;
type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>; type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let inner = self.srv.get_mut(); let inner = self.srv.as_ref();
let not_ready = inner.0.poll_ready(cx)?.is_pending(); let not_ready = inner.0.poll_ready(cx)?.is_pending();
if inner.1.poll_ready(cx)?.is_pending() || not_ready { if inner.1.poll_ready(cx)?.is_pending() || not_ready {
Poll::Pending Poll::Pending
@ -76,8 +75,8 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let srv = self.srv.get_mut(); let srv = self.srv.as_ref();
if srv.0.poll_shutdown(cx, is_error).is_ready() if srv.0.poll_shutdown(cx, is_error).is_ready()
&& srv.1.poll_shutdown(cx, is_error).is_ready() && srv.1.poll_shutdown(cx, is_error).is_ready()
@ -88,8 +87,8 @@ where
} }
} }
fn call(&mut self, req: A::Request) -> Self::Future { fn call(&self, req: A::Request) -> Self::Future {
let fut = self.srv.get_mut().0.call(req); let fut = self.srv.as_ref().0.call(req);
AndThenApplyFnFuture { AndThenApplyFnFuture {
state: State::A(fut, Some(self.srv.clone())), state: State::A(fut, Some(self.srv.clone())),
} }
@ -101,7 +100,7 @@ pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>, Err: From<A::Error>,
Err: From<B::Error>, Err: From<B::Error>,
@ -115,12 +114,12 @@ enum State<A, B, F, Fut, Res, Err>
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>, Err: From<A::Error>,
Err: From<B::Error>, Err: From<B::Error>,
{ {
A(#[pin] A::Future, Option<Cell<(A, B, F)>>), A(#[pin] A::Future, Option<Rc<(A, B, F)>>),
B(#[pin] Fut), B(#[pin] Fut),
Empty, Empty,
} }
@ -129,7 +128,7 @@ impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Res,
where where
A: Service, A: Service,
B: Service, B: Service,
F: FnMut(A::Response, &mut B) -> Fut, F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -143,10 +142,10 @@ where
match this.state.as_mut().project() { match this.state.as_mut().project() {
State::A(fut, b) => match fut.poll(cx)? { State::A(fut, b) => match fut.poll(cx)? {
Poll::Ready(res) => { Poll::Ready(res) => {
let mut b = b.take().unwrap(); let b = b.take().unwrap();
this.state.set(State::Empty); this.state.set(State::Empty);
let b = b.get_mut(); let b = b.as_ref();
let fut = (&mut b.2)(res, &mut b.1); let fut = (&b.2)(res, &b.1);
this.state.set(State::B(fut)); this.state.set(State::B(fut));
self.poll(cx) self.poll(cx)
} }
@ -173,7 +172,7 @@ impl<A, B, F, Fut, Res, Err> AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
where where
A: ServiceFactory, A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>, B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -201,7 +200,7 @@ where
A: ServiceFactory, A: ServiceFactory,
A::Config: Clone, A::Config: Clone,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>, B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -230,7 +229,7 @@ pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
where where
A: ServiceFactory, A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>, B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>, Err: From<A::Error>,
Err: From<B::Error>, Err: From<B::Error>,
@ -249,7 +248,7 @@ impl<A, B, F, Fut, Res, Err> Future
where where
A: ServiceFactory, A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>, B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>, Err: From<A::Error> + From<B::Error>,
{ {
@ -273,7 +272,7 @@ where
if this.a.is_some() && this.b.is_some() { if this.a.is_some() && this.b.is_some() {
Poll::Ready(Ok(AndThenApplyFn { Poll::Ready(Ok(AndThenApplyFn {
srv: Cell::new(( srv: Rc::new((
this.a.take().unwrap(), this.a.take().unwrap(),
this.b.take().unwrap(), this.b.take().unwrap(),
this.f.clone(), this.f.clone(),
@ -302,18 +301,18 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&self, req: Self::Request) -> Self::Future {
ok(req) ok(req)
} }
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_service() { async fn test_service() {
let mut srv = pipeline(|r: &'static str| ok(r)) let srv = pipeline(|r: &'static str| ok(r))
.and_then_apply_fn(Srv, |req: &'static str, s| { .and_then_apply_fn(Srv, |req: &'static str, s| {
s.call(()).map_ok(move |res| (req, res)) s.call(()).map_ok(move |res| (req, res))
}); });
@ -333,7 +332,7 @@ mod tests {
|| ok(Srv), || ok(Srv),
|req: &'static str, s| s.call(()).map_ok(move |res| (req, res)), |req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
); );
let mut srv = new_srv.new_service(()).await.unwrap(); let srv = new_srv.new_service(()).await.unwrap();
let res = lazy(|cx| srv.poll_ready(cx)).await; let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(()))); assert_eq!(res, Poll::Ready(Ok(())));

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

@ -12,7 +12,7 @@ pub fn apply_fn<T, F, R, In, Out, Err, U>(
) -> Apply<T, F, R, In, Out, Err> ) -> Apply<T, F, R, In, Out, Err>
where where
T: Service<Error = Err>, T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R, F: Fn(In, &T) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
U: IntoService<T>, U: IntoService<T>,
{ {
@ -26,7 +26,7 @@ pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
) -> ApplyServiceFactory<T, F, R, In, Out, Err> ) -> ApplyServiceFactory<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
U: IntoServiceFactory<T>, U: IntoServiceFactory<T>,
{ {
@ -46,7 +46,7 @@ where
impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
where where
T: Service<Error = Err>, T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R, F: Fn(In, &T) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
/// Create new `Apply` combinator /// Create new `Apply` combinator
@ -62,7 +62,7 @@ where
impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
where where
T: Service<Error = Err> + Clone, T: Service<Error = Err> + Clone,
F: FnMut(In, &mut T) -> R + Clone, F: Fn(In, &T) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -77,7 +77,7 @@ where
impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
where where
T: Service<Error = Err>, T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R, F: Fn(In, &T) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
type Request = In; type Request = In;
@ -86,18 +86,18 @@ where
type Future = R; type Future = R;
#[inline] #[inline]
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(futures_util::ready!(self.service.poll_ready(cx))) self.service.poll_ready(cx)
} }
#[inline] #[inline]
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
#[inline] #[inline]
fn call(&mut self, req: In) -> Self::Future { fn call(&self, req: In) -> Self::Future {
(self.f)(req, &mut self.service) (self.f)(req, &self.service)
} }
} }
@ -105,7 +105,7 @@ where
pub struct ApplyServiceFactory<T, F, R, In, Out, Err> pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
service: T, service: T,
@ -116,7 +116,7 @@ where
impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
/// Create new `ApplyNewService` new service instance /// Create new `ApplyNewService` new service instance
@ -132,7 +132,7 @@ where
impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err> + Clone, T: ServiceFactory<Error = Err> + Clone,
F: FnMut(In, &mut T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
@ -147,7 +147,7 @@ where
impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R + Clone, F: Fn(In, &T::Service) -> R + Clone,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
type Request = In; type Request = In;
@ -168,7 +168,7 @@ where
pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err> pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
#[pin] #[pin]
@ -180,7 +180,7 @@ where
impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
fn new(fut: T::Future, f: F) -> Self { fn new(fut: T::Future, f: F) -> Self {
@ -195,7 +195,7 @@ where
impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err> impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
where where
T: ServiceFactory<Error = Err>, T: ServiceFactory<Error = Err>,
F: FnMut(In, &mut T::Service) -> R, F: Fn(In, &T::Service) -> R,
R: Future<Output = Result<Out, Err>>, R: Future<Output = Result<Out, Err>>,
{ {
type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>; type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
@ -229,18 +229,18 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: ()) -> Self::Future { fn call(&self, _: ()) -> Self::Future {
ok(()) ok(())
} }
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_call() { async fn test_call() {
let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| { let srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
let fut = srv.call(()); let fut = srv.call(());
async move { async move {
let res = fut.await.unwrap(); let res = fut.await.unwrap();
@ -268,7 +268,7 @@ mod tests {
}, },
)); ));
let mut srv = new_srv.new_service(()).await.unwrap(); let srv = new_srv.new_service(()).await.unwrap();
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));

46
ntex-service/src/apply_cfg.rs
View file

@ -1,9 +1,9 @@
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::pin::Pin; use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use crate::cell::Cell;
use crate::{Service, ServiceFactory}; use crate::{Service, ServiceFactory};
/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory /// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
@ -20,18 +20,18 @@ pub fn apply_cfg<F, C, T, R, S, E>(
Future = R, Future = R,
> + Clone > + Clone
where where
F: FnMut(C, &mut T) -> R, F: Fn(C, &T) -> R,
T: Service, T: Service,
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
{ {
ApplyConfigService { ApplyConfigService {
srv: Cell::new((srv, f)), srv: Rc::new((srv, f)),
_t: PhantomData, _t: PhantomData,
} }
} }
/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory /// Convert `Fn(Config, &Service1) -> Future<Service2>` fn to a service factory
/// ///
/// Service1 get constructed from `T` factory. /// Service1 get constructed from `T` factory.
pub fn apply_cfg_factory<F, C, T, R, S>( pub fn apply_cfg_factory<F, C, T, R, S>(
@ -46,33 +46,33 @@ pub fn apply_cfg_factory<F, C, T, R, S>(
InitError = T::InitError, InitError = T::InitError,
> + Clone > + Clone
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>, T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
S: Service, S: Service,
{ {
ApplyConfigServiceFactory { ApplyConfigServiceFactory {
srv: Cell::new((factory, f)), srv: Rc::new((factory, f)),
_t: PhantomData, _t: PhantomData,
} }
} }
/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\ /// Convert `Fn(Config, &Server) -> Future<Service>` fn to NewService\
struct ApplyConfigService<F, C, T, R, S, E> struct ApplyConfigService<F, C, T, R, S, E>
where where
F: FnMut(C, &mut T) -> R, F: Fn(C, &T) -> R,
T: Service, T: Service,
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
{ {
srv: Cell<(T, F)>, srv: Rc<(T, F)>,
_t: PhantomData<(C, R, S)>, _t: PhantomData<(C, R, S)>,
} }
impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E> impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
where where
F: FnMut(C, &mut T) -> R, F: Fn(C, &T) -> R,
T: Service, T: Service,
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
@ -87,7 +87,7 @@ where
impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E> impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E>
where where
F: FnMut(C, &mut T) -> R, F: Fn(C, &T) -> R,
T: Service, T: Service,
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
@ -102,28 +102,26 @@ where
type Future = R; type Future = R;
fn new_service(&self, cfg: C) -> Self::Future { fn new_service(&self, cfg: C) -> Self::Future {
unsafe { let srv = self.srv.as_ref();
let srv = self.srv.get_mut_unsafe(); (srv.1)(cfg, &srv.0)
(srv.1)(cfg, &mut srv.0)
}
} }
} }
/// Convert `Fn(&Config) -> Future<Service>` fn to NewService /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
struct ApplyConfigServiceFactory<F, C, T, R, S> struct ApplyConfigServiceFactory<F, C, T, R, S>
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
S: Service, S: Service,
{ {
srv: Cell<(T, F)>, srv: Rc<(T, F)>,
_t: PhantomData<(C, R, S)>, _t: PhantomData<(C, R, S)>,
} }
impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S> impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S>
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
S: Service, S: Service,
@ -138,7 +136,7 @@ where
impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S> impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S>
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>, T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
@ -157,7 +155,7 @@ where
ApplyConfigServiceFactoryResponse { ApplyConfigServiceFactoryResponse {
cfg: Some(cfg), cfg: Some(cfg),
store: self.srv.clone(), store: self.srv.clone(),
state: State::A(self.srv.get_ref().0.new_service(())), state: State::A(self.srv.as_ref().0.new_service(())),
} }
} }
} }
@ -165,14 +163,14 @@ where
#[pin_project::pin_project] #[pin_project::pin_project]
struct ApplyConfigServiceFactoryResponse<F, C, T, R, S> struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>, T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
S: Service, S: Service,
{ {
cfg: Option<C>, cfg: Option<C>,
store: Cell<(T, F)>, store: Rc<(T, F)>,
#[pin] #[pin]
state: State<T, R, S>, state: State<T, R, S>,
} }
@ -192,7 +190,7 @@ where
impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S> impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
where where
F: FnMut(C, &mut T::Service) -> R, F: Fn(C, &T::Service) -> R,
T: ServiceFactory<Config = ()>, T: ServiceFactory<Config = ()>,
T::InitError: From<T::Error>, T::InitError: From<T::Error>,
R: Future<Output = Result<S, T::InitError>>, R: Future<Output = Result<S, T::InitError>>,
@ -215,7 +213,7 @@ where
}, },
State::B(srv) => match srv.poll_ready(cx)? { State::B(srv) => match srv.poll_ready(cx)? {
Poll::Ready(_) => { Poll::Ready(_) => {
let fut = (this.store.get_mut().1)(this.cfg.take().unwrap(), srv); let fut = (this.store.as_ref().1)(this.cfg.take().unwrap(), srv);
this.state.set(State::C(fut)); this.state.set(State::C(fut));
self.poll(cx) self.poll(cx)
} }

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

@ -145,17 +145,17 @@ where
type Future = BoxFuture<Res, Err>; type Future = BoxFuture<Res, Err>;
#[inline] #[inline]
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.poll_ready(ctx) self.0.poll_ready(ctx)
} }
#[inline] #[inline]
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.0.poll_shutdown(cx, is_error) self.0.poll_shutdown(cx, is_error)
} }
#[inline] #[inline]
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&self, req: Self::Request) -> Self::Future {
Box::pin(self.0.call(req)) Box::pin(self.0.call(req))
} }
} }

61
ntex-service/src/cell.rs
View file

@ -1,61 +0,0 @@
//! Custom cell impl, internal use only
use std::task::{Context, Poll};
use std::{cell::UnsafeCell, fmt, rc::Rc};
pub(crate) struct Cell<T> {
inner: Rc<UnsafeCell<T>>,
}
impl<T> Clone for Cell<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T: fmt::Debug> fmt::Debug for Cell<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.inner.fmt(f)
}
}
impl<T> Cell<T> {
pub(crate) fn new(inner: T) -> Self {
Self {
inner: Rc::new(UnsafeCell::new(inner)),
}
}
pub(crate) fn get_ref(&self) -> &T {
unsafe { &*self.inner.as_ref().get() }
}
pub(crate) fn get_mut(&mut self) -> &mut T {
unsafe { &mut *self.inner.as_ref().get() }
}
#[allow(clippy::mut_from_ref)]
pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
&mut *self.inner.as_ref().get()
}
}
impl<T: crate::Service> crate::Service for Cell<T> {
type Request = T::Request;
type Response = T::Response;
type Error = T::Error;
type Future = T::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.get_mut().poll_ready(cx)
}
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.get_mut().poll_shutdown(cx, is_error)
}
fn call(&mut self, req: Self::Request) -> Self::Future {
self.get_mut().call(req)
}
}

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

@ -6,17 +6,19 @@ use futures_util::future::{ok, Ready};
use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory}; use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
#[inline]
/// Create `ServiceFactory` for function that can act as a `Service` /// Create `ServiceFactory` for function that can act as a `Service`
pub fn fn_service<F, Fut, Req, Res, Err, Cfg>( pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
f: F, f: F,
) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg> ) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
FnServiceFactory::new(f) FnServiceFactory::new(f)
} }
#[inline]
/// Create `ServiceFactory` for function that can produce services /// Create `ServiceFactory` for function that can produce services
/// ///
/// # Example /// # Example
@ -43,7 +45,7 @@ where
/// }); /// });
/// ///
/// // construct new service /// // construct new service
/// let mut srv = factory.new_service(()).await?; /// let srv = factory.new_service(()).await?;
/// ///
/// // now we can use `div` service /// // now we can use `div` service
/// let result = srv.call((10, 20)).await?; /// let result = srv.call((10, 20)).await?;
@ -64,6 +66,7 @@ where
FnServiceNoConfig::new(f) FnServiceNoConfig::new(f)
} }
#[inline]
/// Create `ServiceFactory` for function that accepts config argument and can produce services /// Create `ServiceFactory` for function that accepts config argument and can produce services
/// ///
/// Any function that has following form `Fn(Config) -> Future<Output = Service>` could /// Any function that has following form `Fn(Config) -> Future<Output = Service>` could
@ -85,7 +88,7 @@ where
/// }); /// });
/// ///
/// // construct new service with config argument /// // construct new service with config argument
/// let mut srv = factory.new_service(10).await?; /// let srv = factory.new_service(10).await?;
/// ///
/// let result = srv.call(10).await?; /// let result = srv.call(10).await?;
/// assert_eq!(result, 100); /// assert_eq!(result, 100);
@ -107,7 +110,7 @@ where
pub struct FnService<F, Fut, Req, Res, Err> pub struct FnService<F, Fut, Req, Res, Err>
where where
F: FnMut(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
f: F, f: F,
@ -116,7 +119,7 @@ where
impl<F, Fut, Req, Res, Err> FnService<F, Fut, Req, Res, Err> impl<F, Fut, Req, Res, Err> FnService<F, Fut, Req, Res, Err>
where where
F: FnMut(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
pub(crate) fn new(f: F) -> Self { pub(crate) fn new(f: F) -> Self {
@ -126,9 +129,10 @@ where
impl<F, Fut, Req, Res, Err> Clone for FnService<F, Fut, Req, Res, Err> impl<F, Fut, Req, Res, Err> Clone for FnService<F, Fut, Req, Res, Err>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self::new(self.f.clone()) Self::new(self.f.clone())
} }
@ -136,7 +140,7 @@ where
impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err> impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err>
where where
F: FnMut(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
type Request = Req; type Request = Req;
@ -144,20 +148,23 @@ where
type Error = Err; type Error = Err;
type Future = Fut; type Future = Fut;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Req) -> Self::Future { #[inline]
fn call(&self, req: Req) -> Self::Future {
(self.f)(req) (self.f)(req)
} }
} }
impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F
where where
F: FnMut(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
#[inline]
fn into_service(self) -> FnService<F, Fut, Req, Res, Err> { fn into_service(self) -> FnService<F, Fut, Req, Res, Err> {
FnService::new(self) FnService::new(self)
} }
@ -165,7 +172,7 @@ where
pub struct FnServiceFactory<F, Fut, Req, Res, Err, Cfg> pub struct FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where where
F: FnMut(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
f: F, f: F,
@ -174,7 +181,7 @@ where
impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg> impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
fn new(f: F) -> Self { fn new(f: F) -> Self {
@ -184,9 +191,10 @@ where
impl<F, Fut, Req, Res, Err, Cfg> Clone for FnServiceFactory<F, Fut, Req, Res, Err, Cfg> impl<F, Fut, Req, Res, Err, Cfg> Clone for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self::new(self.f.clone()) Self::new(self.f.clone())
} }
@ -194,7 +202,7 @@ where
impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()> impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
type Request = Req; type Request = Req;
@ -202,11 +210,13 @@ where
type Error = Err; type Error = Err;
type Future = Fut; type Future = Fut;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { #[inline]
fn call(&self, req: Self::Request) -> Self::Future {
(self.f)(req) (self.f)(req)
} }
} }
@ -214,7 +224,7 @@ where
impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory
for FnServiceFactory<F, Fut, Req, Res, Err, Cfg> for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where where
F: FnMut(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
type Request = Req; type Request = Req;
@ -226,6 +236,7 @@ where
type InitError = (); type InitError = ();
type Future = Ready<Result<Self::Service, Self::InitError>>; type Future = Ready<Result<Self::Service, Self::InitError>>;
#[inline]
fn new_service(&self, _: Cfg) -> Self::Future { fn new_service(&self, _: Cfg) -> Self::Future {
ok(FnService::new(self.f.clone())) ok(FnService::new(self.f.clone()))
} }
@ -237,6 +248,7 @@ where
F: Fn(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
{ {
#[inline]
fn into_factory(self) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg> { fn into_factory(self) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg> {
FnServiceFactory::new(self) FnServiceFactory::new(self)
} }
@ -270,6 +282,7 @@ where
Fut: Future<Output = Result<Srv, Err>>, Fut: Future<Output = Result<Srv, Err>>,
Srv: Service, Srv: Service,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
FnServiceConfig { FnServiceConfig {
f: self.f.clone(), f: self.f.clone(),
@ -293,6 +306,7 @@ where
type InitError = Err; type InitError = Err;
type Future = Fut; type Future = Fut;
#[inline]
fn new_service(&self, cfg: Cfg) -> Self::Future { fn new_service(&self, cfg: Cfg) -> Self::Future {
(self.f)(cfg) (self.f)(cfg)
} }
@ -334,6 +348,7 @@ where
type InitError = E; type InitError = E;
type Future = R; type Future = R;
#[inline]
fn new_service(&self, _: C) -> Self::Future { fn new_service(&self, _: C) -> Self::Future {
(self.f)() (self.f)()
} }
@ -345,6 +360,7 @@ where
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self::new(self.f.clone()) Self::new(self.f.clone())
} }
@ -356,6 +372,7 @@ where
R: Future<Output = Result<S, E>>, R: Future<Output = Result<S, E>>,
S: Service, S: Service,
{ {
#[inline]
fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> { fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> {
FnServiceNoConfig::new(self) FnServiceNoConfig::new(self)
} }
@ -374,7 +391,7 @@ mod tests {
async fn test_fn_service() { async fn test_fn_service() {
let new_srv = fn_service(|()| ok::<_, ()>("srv")); let new_srv = fn_service(|()| ok::<_, ()>("srv"));
let mut srv = new_srv.new_service(()).await.unwrap(); let srv = new_srv.new_service(()).await.unwrap();
let res = srv.call(()).await; let res = srv.call(()).await;
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
assert!(res.is_ok()); assert!(res.is_ok());
@ -383,7 +400,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_fn_service_service() { async fn test_fn_service_service() {
let mut srv = fn_service(|()| ok::<_, ()>("srv")); let srv = fn_service(|()| ok::<_, ()>("srv"));
let res = srv.call(()).await; let res = srv.call(()).await;
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
@ -397,7 +414,7 @@ mod tests {
ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg)))) ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg))))
}); });
let mut srv = new_srv.new_service(1).await.unwrap(); let srv = new_srv.new_service(1).await.unwrap();
let res = srv.call(()).await; let res = srv.call(()).await;
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
assert!(res.is_ok()); assert!(res.is_ok());

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

@ -1,7 +1,6 @@
#![deny(rust_2018_idioms, warnings)] #![deny(rust_2018_idioms, warnings)]
#![allow(clippy::type_complexity)] #![allow(clippy::type_complexity)]
use std::cell::RefCell;
use std::future::Future; use std::future::Future;
use std::rc::Rc; use std::rc::Rc;
use std::sync::Arc; use std::sync::Arc;
@ -12,7 +11,6 @@ mod and_then_apply_fn;
mod apply; mod apply;
mod apply_cfg; mod apply_cfg;
pub mod boxed; pub mod boxed;
mod cell;
mod fn_service; mod fn_service;
mod map; mod map;
mod map_config; mod map_config;
@ -95,10 +93,7 @@ pub trait Service {
/// 1. `.poll_ready()` might be called on different task from actual service call. /// 1. `.poll_ready()` might be called on different task from actual service call.
/// ///
/// 2. In case of chained services, `.poll_ready()` get called for all services at once. /// 2. In case of chained services, `.poll_ready()` get called for all services at once.
fn poll_ready( fn poll_ready(&self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
&mut self,
ctx: &mut task::Context<'_>,
) -> Poll<Result<(), Self::Error>>;
#[inline] #[inline]
#[allow(unused_variables)] #[allow(unused_variables)]
@ -106,11 +101,7 @@ pub trait Service {
/// ///
/// Returns `Ready` when the service is properly shutdowned. This method might be called /// Returns `Ready` when the service is properly shutdowned. This method might be called
/// after it returns `Ready`. /// after it returns `Ready`.
fn poll_shutdown( fn poll_shutdown(&self, ctx: &mut task::Context<'_>, is_error: bool) -> Poll<()> {
&mut self,
ctx: &mut task::Context<'_>,
is_error: bool,
) -> Poll<()> {
Poll::Ready(()) Poll::Ready(())
} }
@ -123,7 +114,7 @@ pub trait Service {
/// ///
/// Calling `call` without calling `poll_ready` is permitted. The /// Calling `call` without calling `poll_ready` is permitted. The
/// implementation must be resilient to this fact. /// implementation must be resilient to this fact.
fn call(&mut self, req: Self::Request) -> Self::Future; fn call(&self, req: Self::Request) -> Self::Future;
#[inline] #[inline]
/// Map this service's output to a different type, returning a new service /// Map this service's output to a different type, returning a new service
@ -199,6 +190,7 @@ pub trait ServiceFactory {
/// Create and return a new service value asynchronously. /// Create and return a new service value asynchronously.
fn new_service(&self, cfg: Self::Config) -> Self::Future; fn new_service(&self, cfg: Self::Config) -> Self::Future;
#[inline]
/// Map this service's output to a different type, returning a new service /// Map this service's output to a different type, returning a new service
/// of the resulting type. /// of the resulting type.
fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R> fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
@ -209,6 +201,7 @@ pub trait ServiceFactory {
crate::map::MapServiceFactory::new(self, f) crate::map::MapServiceFactory::new(self, f)
} }
#[inline]
/// Map this service's error to a different error, returning a new service. /// Map this service's error to a different error, returning a new service.
fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E> fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
where where
@ -218,6 +211,7 @@ pub trait ServiceFactory {
crate::map_err::MapErrServiceFactory::new(self, f) crate::map_err::MapErrServiceFactory::new(self, f)
} }
#[inline]
/// Map this factory's init error to a different error, returning a new service. /// Map this factory's init error to a different error, returning a new service.
fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E> fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
where where
@ -237,11 +231,18 @@ where
type Error = S::Error; type Error = S::Error;
type Future = S::Future; type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
(**self).poll_ready(ctx) fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
(**self).poll_ready(cx)
} }
fn call(&mut self, request: Self::Request) -> S::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
(**self).poll_shutdown(cx, is_error)
}
#[inline]
fn call(&self, request: Self::Request) -> S::Future {
(**self).call(request) (**self).call(request)
} }
} }
@ -255,16 +256,23 @@ where
type Error = S::Error; type Error = S::Error;
type Future = S::Future; type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> { #[inline]
(**self).poll_ready(ctx) fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
(**self).poll_ready(cx)
} }
fn call(&mut self, request: Self::Request) -> S::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
(**self).poll_shutdown(cx, is_error)
}
#[inline]
fn call(&self, request: Self::Request) -> S::Future {
(**self).call(request) (**self).call(request)
} }
} }
impl<S> Service for RefCell<S> impl<S> Service for Rc<S>
where where
S: Service, S: Service,
{ {
@ -273,30 +281,17 @@ where
type Error = S::Error; type Error = S::Error;
type Future = S::Future; type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx) (**self).poll_ready(cx)
} }
fn call(&mut self, request: Self::Request) -> S::Future { #[inline]
self.borrow_mut().call(request) fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
} (**self).poll_shutdown(cx, is_error)
}
impl<S> Service for Rc<RefCell<S>>
where
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx)
} }
fn call(&mut self, request: Self::Request) -> S::Future { fn call(&self, request: Self::Request) -> S::Future {
(&mut (**self).borrow_mut()).call(request) (**self).call(request)
} }
} }

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

@ -34,6 +34,7 @@ where
A: Clone, A: Clone,
F: Clone, F: Clone,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
Map { Map {
service: self.service.clone(), service: self.service.clone(),
@ -54,17 +55,17 @@ where
type Future = MapFuture<A, F, Response>; type Future = MapFuture<A, F, Response>;
#[inline] #[inline]
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
#[inline] #[inline]
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
#[inline] #[inline]
fn call(&mut self, req: A::Request) -> Self::Future { fn call(&self, req: A::Request) -> Self::Future {
MapFuture::new(self.service.call(req), self.f.clone()) MapFuture::new(self.service.call(req), self.f.clone())
} }
} }
@ -135,6 +136,7 @@ where
A: Clone, A: Clone,
F: Clone, F: Clone,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
a: self.a.clone(), a: self.a.clone(),
@ -158,6 +160,7 @@ where
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapServiceFuture<A, F, Res>; type Future = MapServiceFuture<A, F, Res>;
#[inline]
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: A::Config) -> Self::Future {
MapServiceFuture::new(self.a.new_service(cfg), self.f.clone()) MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
} }
@ -217,25 +220,25 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: ()) -> Self::Future { fn call(&self, _: ()) -> Self::Future {
ok(()) ok(())
} }
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_poll_ready() { async fn test_poll_ready() {
let mut srv = Srv.map(|_| "ok"); let srv = Srv.map(|_| "ok");
let res = lazy(|cx| srv.poll_ready(cx)).await; let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(()))); assert_eq!(res, Poll::Ready(Ok(())));
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_call() { async fn test_call() {
let mut srv = Srv.map(|_| "ok"); let srv = Srv.map(|_| "ok");
let res = srv.call(()).await; let res = srv.call(()).await;
assert!(res.is_ok()); assert!(res.is_ok());
assert_eq!(res.unwrap(), "ok"); assert_eq!(res.unwrap(), "ok");
@ -244,7 +247,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_new_service() { async fn test_new_service() {
let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map(|_| "ok"); let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map(|_| "ok");
let mut srv = new_srv.new_service(&()).await.unwrap(); let srv = new_srv.new_service(&()).await.unwrap();
let res = srv.call(()).await; let res = srv.call(()).await;
assert!(res.is_ok()); assert!(res.is_ok());
assert_eq!(res.unwrap(), ("ok")); assert_eq!(res.unwrap(), ("ok"));

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

@ -35,6 +35,7 @@ where
A: Clone, A: Clone,
F: Clone, F: Clone,
{ {
#[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {
MapErr { MapErr {
service: self.service.clone(), service: self.service.clone(),
@ -55,17 +56,17 @@ where
type Future = MapErrFuture<A, F, E>; type Future = MapErrFuture<A, F, E>;
#[inline] #[inline]
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx).map_err(&self.f) self.service.poll_ready(cx).map_err(&self.f)
} }
#[inline] #[inline]
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
#[inline] #[inline]
fn call(&mut self, req: A::Request) -> Self::Future { fn call(&self, req: A::Request) -> Self::Future {
MapErrFuture::new(self.service.call(req), self.f.clone()) MapErrFuture::new(self.service.call(req), self.f.clone())
} }
} }
@ -161,6 +162,7 @@ where
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapErrServiceFuture<A, F, E>; type Future = MapErrServiceFuture<A, F, E>;
#[inline]
fn new_service(&self, cfg: A::Config) -> Self::Future { fn new_service(&self, cfg: A::Config) -> Self::Future {
MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone()) MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
} }
@ -219,25 +221,25 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Err(())) Poll::Ready(Err(()))
} }
fn call(&mut self, _: ()) -> Self::Future { fn call(&self, _: ()) -> Self::Future {
err(()) err(())
} }
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_poll_ready() { async fn test_poll_ready() {
let mut srv = Srv.map_err(|_| "error"); let srv = Srv.map_err(|_| "error");
let res = lazy(|cx| srv.poll_ready(cx)).await; let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Err("error"))); assert_eq!(res, Poll::Ready(Err("error")));
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_call() { async fn test_call() {
let mut srv = Srv.map_err(|_| "error"); let srv = Srv.map_err(|_| "error");
let res = srv.call(()).await; let res = srv.call(()).await;
assert!(res.is_err()); assert!(res.is_err());
assert_eq!(res.err().unwrap(), "error"); assert_eq!(res.err().unwrap(), "error");
@ -246,7 +248,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_new_service() { async fn test_new_service() {
let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map_err(|_| "error"); let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map_err(|_| "error");
let mut srv = new_srv.new_service(&()).await.unwrap(); let srv = new_srv.new_service(&()).await.unwrap();
let res = srv.call(()).await; let res = srv.call(()).await;
assert!(res.is_err()); assert!(res.is_err());
assert_eq!(res.err().unwrap(), "error"); assert_eq!(res.err().unwrap(), "error");

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

@ -75,7 +75,7 @@ impl<T: Service> Pipeline<T> {
Self: Sized, Self: Sized,
I: IntoService<U>, I: IntoService<U>,
U: Service, U: Service,
F: FnMut(T::Response, &mut U) -> Fut, F: Fn(T::Response, &U) -> Fut,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<T::Error> + From<U::Error>, Err: From<T::Error> + From<U::Error>,
{ {
@ -161,17 +161,17 @@ impl<T: Service> Service for Pipeline<T> {
type Future = T::Future; type Future = T::Future;
#[inline] #[inline]
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), T::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), T::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
#[inline] #[inline]
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
#[inline] #[inline]
fn call(&mut self, req: T::Request) -> Self::Future { fn call(&self, req: T::Request) -> Self::Future {
self.service.call(req) self.service.call(req)
} }
} }
@ -240,7 +240,7 @@ impl<T: ServiceFactory> PipelineFactory<T> {
T::Config: Clone, T::Config: Clone,
I: IntoServiceFactory<U>, I: IntoServiceFactory<U>,
U: ServiceFactory<Config = T::Config, InitError = T::InitError>, U: ServiceFactory<Config = T::Config, InitError = T::InitError>,
F: FnMut(T::Response, &mut U::Service) -> Fut + Clone, F: Fn(T::Response, &U::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>, Fut: Future<Output = Result<Res, Err>>,
Err: From<T::Error> + From<U::Error>, Err: From<T::Error> + From<U::Error>,
{ {

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

@ -4,13 +4,12 @@ use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use super::{Service, ServiceFactory}; use super::{Service, ServiceFactory};
use crate::cell::Cell;
/// Service for the `then` combinator, chaining a computation onto the end of /// Service for the `then` combinator, chaining a computation onto the end of
/// another service. /// another service.
/// ///
/// This is created by the `Pipeline::then` method. /// This is created by the `Pipeline::then` method.
pub(crate) struct ThenService<A, B>(Cell<(A, B)>); pub(crate) struct ThenService<A, B>(Rc<(A, B)>);
impl<A, B> ThenService<A, B> { impl<A, B> ThenService<A, B> {
/// Create new `.then()` combinator /// Create new `.then()` combinator
@ -19,7 +18,7 @@ impl<A, B> ThenService<A, B> {
A: Service, A: Service,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>, B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
{ {
Self(Cell::new((a, b))) Self(Rc::new((a, b)))
} }
} }
@ -39,8 +38,8 @@ where
type Error = B::Error; type Error = B::Error;
type Future = ThenServiceResponse<A, B>; type Future = ThenServiceResponse<A, B>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let srv = self.0.get_mut(); let srv = self.0.as_ref();
let not_ready = !srv.0.poll_ready(cx)?.is_ready(); let not_ready = !srv.0.poll_ready(cx)?.is_ready();
if !srv.1.poll_ready(cx)?.is_ready() || not_ready { if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
Poll::Pending Poll::Pending
@ -49,8 +48,8 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let srv = self.0.get_mut(); let srv = self.0.as_ref();
if srv.0.poll_shutdown(cx, is_error).is_ready() if srv.0.poll_shutdown(cx, is_error).is_ready()
&& srv.1.poll_shutdown(cx, is_error).is_ready() && srv.1.poll_shutdown(cx, is_error).is_ready()
@ -61,9 +60,9 @@ where
} }
} }
fn call(&mut self, req: A::Request) -> Self::Future { fn call(&self, req: A::Request) -> Self::Future {
ThenServiceResponse { ThenServiceResponse {
state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())), state: State::A(self.0.as_ref().0.call(req), Some(self.0.clone())),
} }
} }
} }
@ -84,7 +83,7 @@ where
A: Service, A: Service,
B: Service<Request = Result<A::Response, A::Error>>, B: Service<Request = Result<A::Response, A::Error>>,
{ {
A(#[pin] A::Future, Option<Cell<(A, B)>>), A(#[pin] A::Future, Option<Rc<(A, B)>>),
B(#[pin] B::Future), B(#[pin] B::Future),
Empty, Empty,
} }
@ -104,9 +103,9 @@ where
match this.state.as_mut().project() { match this.state.as_mut().project() {
State::A(fut, b) => match fut.poll(cx) { State::A(fut, b) => match fut.poll(cx) {
Poll::Ready(res) => { Poll::Ready(res) => {
let mut b = b.take().unwrap(); let b = b.take().unwrap();
this.state.set(State::Empty); // drop fut A this.state.set(State::Empty); // drop fut A
let fut = b.get_mut().1.call(res); let fut = b.as_ref().1.call(res);
this.state.set(State::B(fut)); this.state.set(State::B(fut));
self.poll(cx) self.poll(cx)
} }
@ -272,12 +271,12 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1); self.0.set(self.0.get() + 1);
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Result<&'static str, &'static str>) -> Self::Future { fn call(&self, req: Result<&'static str, &'static str>) -> Self::Future {
match req { match req {
Ok(msg) => ok(msg), Ok(msg) => ok(msg),
Err(_) => err(()), Err(_) => err(()),
@ -293,12 +292,12 @@ mod tests {
type Error = (); type Error = ();
type Future = Ready<Result<Self::Response, ()>>; type Future = Ready<Result<Self::Response, ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.set(self.0.get() + 1); self.0.set(self.0.get() + 1);
Poll::Ready(Err(())) Poll::Ready(Err(()))
} }
fn call(&mut self, req: Result<&'static str, ()>) -> Self::Future { fn call(&self, req: Result<&'static str, ()>) -> Self::Future {
match req { match req {
Ok(msg) => ok((msg, "ok")), Ok(msg) => ok((msg, "ok")),
Err(()) => ok(("srv2", "err")), Err(()) => ok(("srv2", "err")),
@ -309,7 +308,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_poll_ready() { async fn test_poll_ready() {
let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); let srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone()));
let res = lazy(|cx| srv.poll_ready(cx)).await; let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Err(()))); assert_eq!(res, Poll::Ready(Err(())));
assert_eq!(cnt.get(), 2); assert_eq!(cnt.get(), 2);
@ -318,7 +317,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_call() { async fn test_call() {
let cnt = Rc::new(Cell::new(0)); let cnt = Rc::new(Cell::new(0));
let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt)); let srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt));
let res = srv.call(Ok("srv1")).await; let res = srv.call(Ok("srv1")).await;
assert!(res.is_ok()); assert!(res.is_ok());
@ -335,7 +334,7 @@ mod tests {
let cnt2 = cnt.clone(); let cnt2 = cnt.clone();
let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))); let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone())));
let factory = pipeline_factory(blank).then(move || ready(Ok(Srv2(cnt.clone())))); let factory = pipeline_factory(blank).then(move || ready(Ok(Srv2(cnt.clone()))));
let mut srv = factory.new_service(&()).await.unwrap(); let srv = factory.new_service(&()).await.unwrap();
let res = srv.call(Ok("srv1")).await; let res = srv.call(Ok("srv1")).await;
assert!(res.is_ok()); assert!(res.is_ok());
assert_eq!(res.unwrap(), (("srv1", "ok"))); assert_eq!(res.unwrap(), (("srv1", "ok")));

2
ntex/Cargo.toml
View file

@ -47,7 +47,7 @@ actix-threadpool = "0.3.1"
base64 = "0.11" base64 = "0.11"
bitflags = "1.2" bitflags = "1.2"
bytes = "0.5.3" bytes = "0.5.3"
bytestring = "0.1.4" bytestring = "0.1.5"
derive_more = "0.99.2" derive_more = "0.99.2"
either = "1.5.3" either = "1.5.3"
encoding_rs = "0.8" encoding_rs = "0.8"

21
ntex/src/channel/condition.rs
View file

@ -57,6 +57,27 @@ pub struct Waiter {
inner: Cell<Inner>, inner: Cell<Inner>,
} }
impl Waiter {
pub fn poll_waiter(&self, cx: &mut Context<'_>) -> Poll<()> {
let inner = unsafe {
self.inner
.get_mut_unsafe()
.data
.get_unchecked_mut(self.token)
};
if inner.is_none() {
let waker = LocalWaker::default();
waker.register(cx.waker());
*inner = Some(waker);
Poll::Pending
} else if inner.as_mut().unwrap().register(cx.waker()) {
Poll::Pending
} else {
Poll::Ready(())
}
}
}
impl Clone for Waiter { impl Clone for Waiter {
fn clone(&self) -> Self { fn clone(&self) -> Self {
let token = unsafe { self.inner.get_mut_unsafe() }.data.insert(None); let token = unsafe { self.inner.get_mut_unsafe() }.data.insert(None);

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

@ -126,8 +126,8 @@ struct PoolInner<T> {
} }
impl<T> Pool<T> { impl<T> Pool<T> {
pub fn channel(&mut self) -> (PSender<T>, PReceiver<T>) { pub fn channel(&self) -> (PSender<T>, PReceiver<T>) {
let token = self.0.get_mut().insert(PoolInner { let token = unsafe { self.0.get_mut_unsafe() }.insert(PoolInner {
flags: Flags::all(), flags: Flags::all(),
value: None, value: None,
waker: LocalWaker::default(), waker: LocalWaker::default(),

5
ntex/src/connect/openssl.rs
View file

@ -63,11 +63,12 @@ impl<T: Address + 'static> Service for OpensslConnector<T> {
type Error = ConnectError; type Error = ConnectError;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Connect<T>) -> Self::Future { fn call(&self, req: Connect<T>) -> Self::Future {
let host = req.host().to_string(); let host = req.host().to_string();
let conn = self.connector.call(req); let conn = self.connector.call(req);
let openssl = self.openssl.clone(); let openssl = self.openssl.clone();

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

@ -86,11 +86,13 @@ impl<T: Address> Service for Resolver<T> {
type Error = ConnectError; type Error = ConnectError;
type Future = Either<ResolverFuture<T>, Ready<Result<Connect<T>, Self::Error>>>; type Future = Either<ResolverFuture<T>, Ready<Result<Connect<T>, Self::Error>>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Connect<T>) -> Self::Future { #[inline]
fn call(&self, req: Connect<T>) -> Self::Future {
self.lookup(req) self.lookup(req)
} }
} }

5
ntex/src/connect/rustls.rs
View file

@ -68,11 +68,12 @@ impl<T: Address + 'static> Service for RustlsConnector<T> {
type Error = ConnectError; type Error = ConnectError;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Connect<T>) -> Self::Future { fn call(&self, req: Connect<T>) -> Self::Future {
let host = req.host().to_string(); let host = req.host().to_string();
let conn = self.connector.call(req); let conn = self.connector.call(req);
let config = self.config.clone(); let config = self.config.clone();

7
ntex/src/connect/service.rs
View file

@ -54,6 +54,7 @@ impl<T: Address> ServiceFactory for Connector<T> {
type InitError = (); type InitError = ();
type Future = Ready<Result<Self::Service, Self::InitError>>; type Future = Ready<Result<Self::Service, Self::InitError>>;
#[inline]
fn new_service(&self, _: ()) -> Self::Future { fn new_service(&self, _: ()) -> Self::Future {
ok(self.clone()) ok(self.clone())
} }
@ -65,11 +66,13 @@ impl<T: Address> Service for Connector<T> {
type Error = ConnectError; type Error = ConnectError;
type Future = ConnectServiceResponse<T>; type Future = ConnectServiceResponse<T>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Connect<T>) -> Self::Future { #[inline]
fn call(&self, req: Connect<T>) -> Self::Future {
ConnectServiceResponse { ConnectServiceResponse {
state: ConnectState::Resolve(self.resolver.lookup(req)), state: ConnectState::Resolve(self.resolver.lookup(req)),
} }

9
ntex/src/framed/service.rs
View file

@ -270,15 +270,18 @@ where
type Error = ServiceError<C::Error, Codec>; type Error = ServiceError<C::Error, Codec>;
type Future = FramedServiceImplResponse<St, Io, Codec, Out, C, T>; type Future = FramedServiceImplResponse<St, Io, Codec, Out, C, T>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.connect.poll_ready(cx).map_err(|e| e.into()) self.connect.poll_ready(cx).map_err(|e| e.into())
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.connect.poll_shutdown(cx, is_error) self.connect.poll_shutdown(cx, is_error)
} }
fn call(&mut self, req: Io) -> Self::Future { #[inline]
fn call(&self, req: Io) -> Self::Future {
log::trace!("Start connection handshake"); log::trace!("Start connection handshake");
FramedServiceImplResponse { FramedServiceImplResponse {
inner: FramedServiceImplResponseInner::Connect( inner: FramedServiceImplResponseInner::Connect(

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

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::rc::Rc; use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::time::Duration; use std::time::Duration;
@ -262,7 +261,7 @@ impl Connector {
None None
}; };
Rc::new(RefCell::new(InnerConnector { Rc::new(InnerConnector {
tcp_pool: ConnectionPool::new( tcp_pool: ConnectionPool::new(
tcp_service, tcp_service,
self.conn_lifetime, self.conn_lifetime,
@ -271,7 +270,7 @@ impl Connector {
self.limit, self.limit,
), ),
ssl_pool, ssl_pool,
})) })
} }
} }
@ -314,14 +313,40 @@ where
type Future = type Future =
Either<<Pool<T> as Service>::Future, Ready<Result<Self::Response, Self::Error>>>; Either<<Pool<T> as Service>::Future, Ready<Result<Self::Response, Self::Error>>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
self.tcp_pool.poll_ready(cx) fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let ready = self.tcp_pool.poll_ready(cx)?.is_ready();
let ready = if let Some(ref ssl_pool) = self.ssl_pool {
ssl_pool.poll_ready(cx)?.is_ready() && ready
} else {
ready
};
if ready {
Poll::Ready(Ok(()))
} else {
Poll::Pending
}
} }
fn call(&mut self, req: Connect) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let ready = self.tcp_pool.poll_shutdown(cx, is_error).is_ready();
let ready = if let Some(ref ssl_pool) = self.ssl_pool {
ssl_pool.poll_shutdown(cx, is_error).is_ready() && ready
} else {
ready
};
if ready {
Poll::Ready(())
} else {
Poll::Pending
}
}
fn call(&self, req: Connect) -> Self::Future {
match req.uri.scheme_str() { match req.uri.scheme_str() {
Some("https") | Some("wss") => { Some("https") | Some("wss") => {
if let Some(ref mut conn) = self.ssl_pool { if let Some(ref conn) = self.ssl_pool {
Either::Left(conn.call(req)) Either::Left(conn.call(req))
} else { } else {
Either::Right(err(ConnectError::SslIsNotSupported)) Either::Right(err(ConnectError::SslIsNotSupported))

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

@ -37,7 +37,7 @@ impl From<Authority> for Key {
} }
/// Connections pool /// Connections pool
pub(super) struct ConnectionPool<T, Io: 'static>(Rc<RefCell<T>>, Rc<RefCell<Inner<Io>>>); pub(super) struct ConnectionPool<T, Io: 'static>(Rc<T>, Rc<RefCell<Inner<Io>>>);
impl<T, Io> ConnectionPool<T, Io> impl<T, Io> ConnectionPool<T, Io>
where where
@ -52,7 +52,7 @@ where
limit: usize, limit: usize,
) -> Self { ) -> Self {
ConnectionPool( ConnectionPool(
Rc::new(RefCell::new(connector)), Rc::new(connector),
Rc::new(RefCell::new(Inner { Rc::new(RefCell::new(Inner {
conn_lifetime, conn_lifetime,
conn_keep_alive, conn_keep_alive,
@ -88,18 +88,25 @@ where
type Error = ConnectError; type Error = ConnectError;
type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>; type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.poll_ready(cx) self.0.poll_ready(cx)
} }
fn call(&mut self, req: Connect) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.0.poll_shutdown(cx, is_error)
}
#[inline]
fn call(&self, req: Connect) -> Self::Future {
// start support future // start support future
crate::rt::spawn(ConnectorPoolSupport { crate::rt::spawn(ConnectorPoolSupport {
connector: self.0.clone(), connector: self.0.clone(),
inner: self.1.clone(), inner: self.1.clone(),
}); });
let mut connector = self.0.clone(); let connector = self.0.clone();
let inner = self.1.clone(); let inner = self.1.clone();
let fut = async move { let fut = async move {
@ -619,7 +626,7 @@ where
impl<T> Drop for Acquired<T> { impl<T> Drop for Acquired<T> {
fn drop(&mut self) { fn drop(&mut self) {
if let Some(inner) = self.1.take() { if let Some(inner) = self.1.take() {
inner.as_ref().borrow_mut().release(); inner.borrow_mut().release();
} }
} }
} }

40
ntex/src/http/cloneable.rs
View file

@ -1,40 +0,0 @@
use std::cell::RefCell;
use std::rc::Rc;
use std::task::{Context, Poll};
use crate::service::Service;
#[doc(hidden)]
/// Service that allows to turn non-clone service to a service with `Clone` impl
///
/// # Panics
/// CloneableService might panic with some creative use of thread local storage.
/// See https://github.com/actix/actix-web/issues/1295 for example
pub(crate) struct CloneableService<T: Service>(Rc<RefCell<T>>);
impl<T: Service> CloneableService<T> {
pub(crate) fn new(service: T) -> Self {
Self(Rc::new(RefCell::new(service)))
}
}
impl<T: Service> Clone for CloneableService<T> {
fn clone(&self) -> Self {
Self(self.0.clone())
}
}
impl<T: Service> Service for CloneableService<T> {
type Request = T::Request;
type Response = T::Response;
type Error = T::Error;
type Future = T::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.borrow_mut().poll_ready(cx)
}
fn call(&mut self, req: T::Request) -> Self::Future {
self.0.borrow_mut().call(req)
}
}

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

@ -1,6 +1,7 @@
use std::collections::VecDeque; use std::collections::VecDeque;
use std::future::Future; use std::future::Future;
use std::pin::Pin; use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{fmt, io, net}; use std::{fmt, io, net};
@ -10,7 +11,6 @@ use log::{error, trace};
use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts}; use crate::codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts};
use crate::http::body::{Body, BodySize, MessageBody, ResponseBody}; use crate::http::body::{Body, BodySize, MessageBody, ResponseBody};
use crate::http::cloneable::CloneableService;
use crate::http::config::ServiceConfig; use crate::http::config::ServiceConfig;
use crate::http::error::{DispatchError, ResponseError}; use crate::http::error::{DispatchError, ResponseError};
use crate::http::error::{ParseError, PayloadError}; use crate::http::error::{ParseError, PayloadError};
@ -79,9 +79,9 @@ where
U: Service<Request = (Request, Framed<T, Codec>), Response = ()>, U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
U::Error: fmt::Display, U::Error: fmt::Display,
{ {
service: CloneableService<S>, service: Rc<S>,
expect: CloneableService<X>, expect: Rc<X>,
upgrade: Option<CloneableService<U>>, upgrade: Option<Rc<U>>,
on_connect: Option<Box<dyn DataFactory>>, on_connect: Option<Box<dyn DataFactory>>,
flags: Flags, flags: Flags,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
@ -179,9 +179,9 @@ where
pub(crate) fn new( pub(crate) fn new(
stream: T, stream: T,
config: ServiceConfig, config: ServiceConfig,
service: CloneableService<S>, service: Rc<S>,
expect: CloneableService<X>, expect: Rc<X>,
upgrade: Option<CloneableService<U>>, upgrade: Option<Rc<U>>,
on_connect: Option<Box<dyn DataFactory>>, on_connect: Option<Box<dyn DataFactory>>,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
) -> Self { ) -> Self {
@ -206,9 +206,9 @@ where
config: ServiceConfig, config: ServiceConfig,
read_buf: BytesMut, read_buf: BytesMut,
timeout: Option<Delay>, timeout: Option<Delay>,
service: CloneableService<S>, service: Rc<S>,
expect: CloneableService<X>, expect: Rc<X>,
upgrade: Option<CloneableService<U>>, upgrade: Option<Rc<U>>,
on_connect: Option<Box<dyn DataFactory>>, on_connect: Option<Box<dyn DataFactory>>,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
) -> Self { ) -> Self {
@ -921,10 +921,10 @@ mod tests {
let mut h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new( let mut h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
buf, buf,
ServiceConfig::default(), ServiceConfig::default(),
CloneableService::new( Rc::new(
(|_| ok::<_, io::Error>(Response::Ok().finish())).into_service(), (|_| ok::<_, io::Error>(Response::Ok().finish())).into_service(),
), ),
CloneableService::new(ExpectHandler), Rc::new(ExpectHandler),
None, None,
None, None,
None, None,

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

@ -17,6 +17,7 @@ impl ServiceFactory for ExpectHandler {
type InitError = io::Error; type InitError = io::Error;
type Future = Ready<Result<Self::Service, Self::InitError>>; type Future = Ready<Result<Self::Service, Self::InitError>>;
#[inline]
fn new_service(&self, _: ()) -> Self::Future { fn new_service(&self, _: ()) -> Self::Future {
ok(ExpectHandler) ok(ExpectHandler)
} }
@ -28,11 +29,13 @@ impl Service for ExpectHandler {
type Error = io::Error; type Error = io::Error;
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Request) -> Self::Future { #[inline]
fn call(&self, req: Request) -> Self::Future {
ok(req) ok(req)
} }
} }

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

@ -10,7 +10,6 @@ use futures::ready;
use crate::codec::{AsyncRead, AsyncWrite, Framed}; use crate::codec::{AsyncRead, AsyncWrite, Framed};
use crate::http::body::MessageBody; use crate::http::body::MessageBody;
use crate::http::cloneable::CloneableService;
use crate::http::config::ServiceConfig; use crate::http::config::ServiceConfig;
use crate::http::error::{DispatchError, ParseError, ResponseError}; use crate::http::error::{DispatchError, ParseError, ResponseError};
use crate::http::helpers::DataFactory; use crate::http::helpers::DataFactory;
@ -365,9 +364,9 @@ where
/// `Service` implementation for HTTP1 transport /// `Service` implementation for HTTP1 transport
pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> { pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
srv: CloneableService<S>, srv: Rc<S>,
expect: CloneableService<X>, expect: Rc<X>,
upgrade: Option<CloneableService<U>>, upgrade: Option<Rc<U>>,
on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
@ -392,9 +391,9 @@ where
on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
) -> H1ServiceHandler<T, S, B, X, U> { ) -> H1ServiceHandler<T, S, B, X, U> {
H1ServiceHandler { H1ServiceHandler {
srv: CloneableService::new(srv), srv: Rc::new(srv),
expect: CloneableService::new(expect), expect: Rc::new(expect),
upgrade: upgrade.map(CloneableService::new), upgrade: upgrade.map(Rc::new),
cfg, cfg,
on_connect, on_connect,
_t: PhantomData, _t: PhantomData,
@ -419,7 +418,7 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = Dispatcher<T, S, B, X, U>; type Future = Dispatcher<T, S, B, X, U>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let ready = self let ready = self
.expect .expect
.poll_ready(cx) .poll_ready(cx)
@ -439,7 +438,7 @@ where
.is_ready() .is_ready()
&& ready; && ready;
let ready = if let Some(ref mut upg) = self.upgrade { let ready = if let Some(ref upg) = self.upgrade {
upg.poll_ready(cx) upg.poll_ready(cx)
.map_err(|e| { .map_err(|e| {
log::error!("Http service readiness error: {:?}", e); log::error!("Http service readiness error: {:?}", e);
@ -458,7 +457,23 @@ where
} }
} }
fn call(&mut self, (io, addr): Self::Request) -> Self::Future { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let ready = self.expect.poll_shutdown(cx, is_error).is_ready();
let ready = self.srv.poll_shutdown(cx, is_error).is_ready() && ready;
let ready = if let Some(ref upg) = self.upgrade {
upg.poll_shutdown(cx, is_error).is_ready() && ready
} else {
ready
};
if ready {
Poll::Ready(())
} else {
Poll::Pending
}
}
fn call(&self, (io, addr): Self::Request) -> Self::Future {
let on_connect = if let Some(ref on_connect) = self.on_connect { let on_connect = if let Some(ref on_connect) = self.on_connect {
Some(on_connect(&io)) Some(on_connect(&io))
} else { } else {
@ -533,11 +548,13 @@ where
type Error = ParseError; type Error = ParseError;
type Future = OneRequestServiceResponse<T>; type Future = OneRequestServiceResponse<T>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { #[inline]
fn call(&self, req: Self::Request) -> Self::Future {
OneRequestServiceResponse { OneRequestServiceResponse {
framed: Some(Framed::new(req, Codec::new(self.config.clone()))), framed: Some(Framed::new(req, Codec::new(self.config.clone()))),
} }

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

@ -20,6 +20,7 @@ impl<T> ServiceFactory for UpgradeHandler<T> {
type InitError = io::Error; type InitError = io::Error;
type Future = Ready<Result<Self::Service, Self::InitError>>; type Future = Ready<Result<Self::Service, Self::InitError>>;
#[inline]
fn new_service(&self, _: ()) -> Self::Future { fn new_service(&self, _: ()) -> Self::Future {
unimplemented!() unimplemented!()
} }
@ -31,11 +32,13 @@ impl<T> Service for UpgradeHandler<T> {
type Error = io::Error; type Error = io::Error;
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: Self::Request) -> Self::Future { #[inline]
fn call(&self, _: Self::Request) -> Self::Future {
unimplemented!() unimplemented!()
} }
} }

7
ntex/src/http/h2/dispatcher.rs
View file

@ -3,6 +3,7 @@ use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::net; use std::net;
use std::pin::Pin; use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};
@ -13,7 +14,6 @@ use log::{error, trace};
use crate::codec::{AsyncRead, AsyncWrite}; use crate::codec::{AsyncRead, AsyncWrite};
use crate::http::body::{BodySize, MessageBody, ResponseBody}; use crate::http::body::{BodySize, MessageBody, ResponseBody};
use crate::http::cloneable::CloneableService;
use crate::http::config::ServiceConfig; use crate::http::config::ServiceConfig;
use crate::http::error::{DispatchError, ResponseError}; use crate::http::error::{DispatchError, ResponseError};
use crate::http::helpers::DataFactory; use crate::http::helpers::DataFactory;
@ -32,7 +32,7 @@ pub struct Dispatcher<T, S: Service<Request = Request>, B: MessageBody>
where where
T: AsyncRead + AsyncWrite + Unpin, T: AsyncRead + AsyncWrite + Unpin,
{ {
service: CloneableService<S>, service: Rc<S>,
connection: Connection<T, Bytes>, connection: Connection<T, Bytes>,
on_connect: Option<Box<dyn DataFactory>>, on_connect: Option<Box<dyn DataFactory>>,
config: ServiceConfig, config: ServiceConfig,
@ -47,12 +47,11 @@ where
T: AsyncRead + AsyncWrite + Unpin, T: AsyncRead + AsyncWrite + Unpin,
S: Service<Request = Request>, S: Service<Request = Request>,
S::Error: ResponseError, S::Error: ResponseError,
// S::Future: 'static,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody, B: MessageBody,
{ {
pub(crate) fn new( pub(crate) fn new(
service: CloneableService<S>, service: Rc<S>,
connection: Connection<T, Bytes>, connection: Connection<T, Bytes>,
on_connect: Option<Box<dyn DataFactory>>, on_connect: Option<Box<dyn DataFactory>>,
config: ServiceConfig, config: ServiceConfig,

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

@ -1,8 +1,9 @@
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::net;
use std::pin::Pin; use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{net, rc};
use bytes::Bytes; use bytes::Bytes;
use futures::future::ok; use futures::future::ok;
@ -12,7 +13,6 @@ use log::error;
use crate::codec::{AsyncRead, AsyncWrite}; use crate::codec::{AsyncRead, AsyncWrite};
use crate::http::body::MessageBody; use crate::http::body::MessageBody;
use crate::http::cloneable::CloneableService;
use crate::http::config::ServiceConfig; use crate::http::config::ServiceConfig;
use crate::http::error::{DispatchError, ResponseError}; use crate::http::error::{DispatchError, ResponseError};
use crate::http::helpers::DataFactory; use crate::http::helpers::DataFactory;
@ -30,7 +30,7 @@ use super::dispatcher::Dispatcher;
pub struct H2Service<T, S, B> { pub struct H2Service<T, S, B> {
srv: S, srv: S,
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
} }
@ -58,7 +58,7 @@ where
/// Set on connect callback. /// Set on connect callback.
pub(crate) fn on_connect( pub(crate) fn on_connect(
mut self, mut self,
f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
) -> Self { ) -> Self {
self.on_connect = f; self.on_connect = f;
self self
@ -214,7 +214,7 @@ pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
#[pin] #[pin]
fut: S::Future, fut: S::Future,
cfg: Option<ServiceConfig>, cfg: Option<ServiceConfig>,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
} }
@ -245,9 +245,9 @@ where
/// `Service` implementation for http/2 transport /// `Service` implementation for http/2 transport
pub struct H2ServiceHandler<T, S: Service, B> { pub struct H2ServiceHandler<T, S: Service, B> {
srv: CloneableService<S>, srv: Rc<S>,
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
} }
@ -261,13 +261,13 @@ where
{ {
fn new( fn new(
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
srv: S, srv: S,
) -> H2ServiceHandler<T, S, B> { ) -> H2ServiceHandler<T, S, B> {
H2ServiceHandler { H2ServiceHandler {
cfg, cfg,
on_connect, on_connect,
srv: CloneableService::new(srv), srv: Rc::new(srv),
_t: PhantomData, _t: PhantomData,
} }
} }
@ -287,14 +287,20 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = H2ServiceHandlerResponse<T, S, B>; type Future = H2ServiceHandlerResponse<T, S, B>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.srv.poll_ready(cx).map_err(|e| { self.srv.poll_ready(cx).map_err(|e| {
error!("Service readiness error: {:?}", e); error!("Service readiness error: {:?}", e);
DispatchError::Service(Box::new(e)) DispatchError::Service(Box::new(e))
}) })
} }
fn call(&mut self, (io, addr): Self::Request) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.srv.poll_shutdown(cx, is_error)
}
fn call(&self, (io, addr): Self::Request) -> Self::Future {
let on_connect = if let Some(ref on_connect) = self.on_connect { let on_connect = if let Some(ref on_connect) = self.on_connect {
Some(on_connect(&io)) Some(on_connect(&io))
} else { } else {
@ -320,7 +326,7 @@ where
{ {
Incoming(Dispatcher<T, S, B>), Incoming(Dispatcher<T, S, B>),
Handshake( Handshake(
Option<CloneableService<S>>, Option<Rc<S>>,
Option<ServiceConfig>, Option<ServiceConfig>,
Option<net::SocketAddr>, Option<net::SocketAddr>,
Option<Box<dyn DataFactory>>, Option<Box<dyn DataFactory>>,

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

@ -2,7 +2,6 @@
pub mod body; pub mod body;
mod builder; mod builder;
pub mod client; pub mod client;
mod cloneable;
mod config; mod config;
#[cfg(feature = "compress")] #[cfg(feature = "compress")]
pub mod encoding; pub mod encoding;

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

@ -1,7 +1,8 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::pin::Pin; use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{fmt, net, rc}; use std::{fmt, net};
use bytes::Bytes; use bytes::Bytes;
use futures::future::ok; use futures::future::ok;
@ -15,7 +16,6 @@ use crate::service::{pipeline_factory, IntoServiceFactory, Service, ServiceFacto
use super::body::MessageBody; use super::body::MessageBody;
use super::builder::HttpServiceBuilder; use super::builder::HttpServiceBuilder;
use super::cloneable::CloneableService;
use super::config::{KeepAlive, ServiceConfig}; use super::config::{KeepAlive, ServiceConfig};
use super::error::{DispatchError, ResponseError}; use super::error::{DispatchError, ResponseError};
use super::helpers::DataFactory; use super::helpers::DataFactory;
@ -29,7 +29,7 @@ pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>
cfg: ServiceConfig, cfg: ServiceConfig,
expect: X, expect: X,
upgrade: Option<U>, upgrade: Option<U>,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
} }
@ -146,7 +146,7 @@ where
/// Set on connect callback. /// Set on connect callback.
pub(crate) fn on_connect( pub(crate) fn on_connect(
mut self, mut self,
f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
) -> Self { ) -> Self {
self.on_connect = f; self.on_connect = f;
self self
@ -379,7 +379,7 @@ pub struct HttpServiceResponse<
fut_upg: Option<U::Future>, fut_upg: Option<U::Future>,
expect: Option<X::Service>, expect: Option<X::Service>,
upgrade: Option<U::Service>, upgrade: Option<U::Service>,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, B)>,
} }
@ -445,11 +445,11 @@ where
/// `Service` implementation for http transport /// `Service` implementation for http transport
pub struct HttpServiceHandler<T, S: Service, B, X: Service, U: Service> { pub struct HttpServiceHandler<T, S: Service, B, X: Service, U: Service> {
srv: CloneableService<S>, srv: Rc<S>,
expect: CloneableService<X>, expect: Rc<X>,
upgrade: Option<CloneableService<U>>, upgrade: Option<Rc<U>>,
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
_t: PhantomData<(T, B, X)>, _t: PhantomData<(T, B, X)>,
} }
@ -470,14 +470,14 @@ where
srv: S, srv: S,
expect: X, expect: X,
upgrade: Option<U>, upgrade: Option<U>,
on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>, on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
) -> HttpServiceHandler<T, S, B, X, U> { ) -> HttpServiceHandler<T, S, B, X, U> {
HttpServiceHandler { HttpServiceHandler {
cfg, cfg,
on_connect, on_connect,
srv: CloneableService::new(srv), srv: Rc::new(srv),
expect: CloneableService::new(expect), expect: Rc::new(expect),
upgrade: upgrade.map(CloneableService::new), upgrade: upgrade.map(Rc::new),
_t: PhantomData, _t: PhantomData,
} }
} }
@ -501,7 +501,7 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = HttpServiceHandlerResponse<T, S, B, X, U>; type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let ready = self let ready = self
.expect .expect
.poll_ready(cx) .poll_ready(cx)
@ -521,7 +521,7 @@ where
.is_ready() .is_ready()
&& ready; && ready;
let ready = if let Some(ref mut upg) = self.upgrade { let ready = if let Some(ref upg) = self.upgrade {
upg.poll_ready(cx) upg.poll_ready(cx)
.map_err(|e| { .map_err(|e| {
log::error!("Http service readiness error: {:?}", e); log::error!("Http service readiness error: {:?}", e);
@ -540,7 +540,23 @@ where
} }
} }
fn call(&mut self, (io, proto, peer_addr): Self::Request) -> Self::Future { fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
let ready = self.expect.poll_shutdown(cx, is_error).is_ready();
let ready = self.srv.poll_shutdown(cx, is_error).is_ready() && ready;
let ready = if let Some(ref upg) = self.upgrade {
upg.poll_shutdown(cx, is_error).is_ready() && ready
} else {
ready
};
if ready {
Poll::Ready(())
} else {
Poll::Pending
}
}
fn call(&self, (io, proto, peer_addr): Self::Request) -> Self::Future {
let on_connect = if let Some(ref on_connect) = self.on_connect { let on_connect = if let Some(ref on_connect) = self.on_connect {
Some(on_connect(&io)) Some(on_connect(&io))
} else { } else {
@ -591,7 +607,7 @@ where
Option<( Option<(
Handshake<T, Bytes>, Handshake<T, Bytes>,
ServiceConfig, ServiceConfig,
CloneableService<S>, Rc<S>,
Option<Box<dyn DataFactory>>, Option<Box<dyn DataFactory>>,
Option<net::SocketAddr>, Option<net::SocketAddr>,
)>, )>,

6
ntex/src/server/openssl.rs
View file

@ -73,7 +73,8 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Service for AcceptorService<T>
type Error = HandshakeError<T>; type Error = HandshakeError<T>;
type Future = AcceptorServiceResponse<T>; type Future = AcceptorServiceResponse<T>;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
if self.conns.available(ctx) { if self.conns.available(ctx) {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} else { } else {
@ -81,7 +82,8 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Service for AcceptorService<T>
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { #[inline]
fn call(&self, req: Self::Request) -> Self::Future {
let acc = self.acceptor.clone(); let acc = self.acceptor.clone();
AcceptorServiceResponse { AcceptorServiceResponse {
_guard: self.conns.get(), _guard: self.conns.get(),

6
ntex/src/server/rustls.rs
View file

@ -79,7 +79,8 @@ impl<T: AsyncRead + AsyncWrite + Unpin> Service for AcceptorService<T> {
type Error = io::Error; type Error = io::Error;
type Future = AcceptorServiceFut<T>; type Future = AcceptorServiceFut<T>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
if self.conns.available(cx) { if self.conns.available(cx) {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} else { } else {
@ -87,7 +88,8 @@ impl<T: AsyncRead + AsyncWrite + Unpin> Service for AcceptorService<T> {
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { #[inline]
fn call(&self, req: Self::Request) -> Self::Future {
AcceptorServiceFut { AcceptorServiceFut {
_guard: self.conns.get(), _guard: self.conns.get(),
fut: self.acceptor.accept(req), fut: self.acceptor.accept(req),

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

@ -71,14 +71,17 @@ where
type Error = (); type Error = ();
type Future = Ready<Result<(), ()>>; type Future = Ready<Result<(), ()>>;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(ctx).map_err(|_| ()) self.service.poll_ready(ctx).map_err(|_| ())
} }
fn call( #[inline]
&mut self, fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
(guard, req): (Option<CounterGuard>, ServerMessage), self.service.poll_shutdown(cx, is_error)
) -> Self::Future { }
fn call(&self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
match req { match req {
ServerMessage::Connect(stream) => { ServerMessage::Connect(stream) => {
let stream = FromStream::from_stdstream(stream).map_err(|e| { let stream = FromStream::from_stdstream(stream).map_err(|e| {
@ -189,6 +192,7 @@ where
{ {
type Factory = T; type Factory = T;
#[inline]
fn create(&self) -> T { fn create(&self) -> T {
(self)() (self)()
} }

9
ntex/src/util/either.rs
View file

@ -52,7 +52,8 @@ where
type Error = A::Error; type Error = A::Error;
type Future = future::Either<A::Future, B::Future>; type Future = future::Either<A::Future, B::Future>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let left = self.left.poll_ready(cx)?; let left = self.left.poll_ready(cx)?;
let right = self.right.poll_ready(cx)?; let right = self.right.poll_ready(cx)?;
@ -63,7 +64,8 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
if self.left.poll_shutdown(cx, is_error).is_ready() if self.left.poll_shutdown(cx, is_error).is_ready()
&& self.right.poll_shutdown(cx, is_error).is_ready() && self.right.poll_shutdown(cx, is_error).is_ready()
{ {
@ -73,7 +75,8 @@ where
} }
} }
fn call(&mut self, req: either::Either<A::Request, B::Request>) -> Self::Future { #[inline]
fn call(&self, req: either::Either<A::Request, B::Request>) -> Self::Future {
match req { match req {
either::Either::Left(req) => future::Either::Left(self.left.call(req)), either::Either::Left(req) => future::Either::Left(self.left.call(req)),
either::Either::Right(req) => future::Either::Right(self.right.call(req)), either::Either::Right(req) => future::Either::Right(self.right.call(req)),

17
ntex/src/util/inflight.rs
View file

@ -73,7 +73,8 @@ where
type Error = T::Error; type Error = T::Error;
type Future = InFlightServiceResponse<T>; type Future = InFlightServiceResponse<T>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
if let Poll::Pending = self.service.poll_ready(cx)? { if let Poll::Pending = self.service.poll_ready(cx)? {
Poll::Pending Poll::Pending
} else if !self.count.available(cx) { } else if !self.count.available(cx) {
@ -84,11 +85,13 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
fn call(&mut self, req: T::Request) -> Self::Future { #[inline]
fn call(&self, req: T::Request) -> Self::Future {
InFlightServiceResponse { InFlightServiceResponse {
fut: self.service.call(req), fut: self.service.call(req),
_guard: self.count.get(), _guard: self.count.get(),
@ -129,11 +132,11 @@ mod tests {
type Error = (); type Error = ();
type Future = LocalBoxFuture<'static, Result<(), ()>>; type Future = LocalBoxFuture<'static, Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: ()) -> Self::Future { fn call(&self, _: ()) -> Self::Future {
crate::rt::time::delay_for(self.0) crate::rt::time::delay_for(self.0)
.then(|_| ok::<_, ()>(())) .then(|_| ok::<_, ()>(()))
.boxed_local() .boxed_local()
@ -144,7 +147,7 @@ mod tests {
async fn test_transform() { async fn test_transform() {
let wait_time = Duration::from_millis(50); let wait_time = Duration::from_millis(50);
let mut srv = InFlightService::new(1, SleepService(wait_time)); let srv = InFlightService::new(1, SleepService(wait_time));
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
let res = srv.call(()); let res = srv.call(());
@ -160,7 +163,7 @@ mod tests {
let srv = apply(InFlight::new(1), fn_factory(|| ok(SleepService(wait_time)))); let srv = apply(InFlight::new(1), fn_factory(|| ok(SleepService(wait_time))));
let mut srv = srv.new_service(&()).await.unwrap(); let srv = srv.new_service(&()).await.unwrap();
assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
let res = srv.call(()); let res = srv.call(());

30
ntex/src/util/keepalive.rs
View file

@ -1,3 +1,4 @@
use std::cell::RefCell;
use std::convert::Infallible; use std::convert::Infallible;
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
@ -72,9 +73,13 @@ pub struct KeepAliveService<R, E, F> {
f: F, f: F,
ka: Duration, ka: Duration,
time: LowResTimeService, time: LowResTimeService,
inner: RefCell<Inner>,
_t: PhantomData<(R, E)>,
}
struct Inner {
delay: Delay, delay: Delay,
expire: Instant, expire: Instant,
_t: PhantomData<(R, E)>,
} }
impl<R, E, F> KeepAliveService<R, E, F> impl<R, E, F> KeepAliveService<R, E, F>
@ -87,8 +92,10 @@ where
f, f,
ka, ka,
time, time,
expire, inner: RefCell::new(Inner {
delay: delay_until(expire), expire,
delay: delay_until(expire),
}),
_t: PhantomData, _t: PhantomData,
} }
} }
@ -103,15 +110,18 @@ where
type Error = E; type Error = E;
type Future = Ready<Result<R, E>>; type Future = Ready<Result<R, E>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
match Pin::new(&mut self.delay).poll(cx) { let mut inner = self.inner.borrow_mut();
match Pin::new(&mut inner.delay).poll(cx) {
Poll::Ready(_) => { Poll::Ready(_) => {
let now = Instant::from_std(self.time.now()); let now = Instant::from_std(self.time.now());
if self.expire <= now { if inner.expire <= now {
Poll::Ready(Err((self.f)())) Poll::Ready(Err((self.f)()))
} else { } else {
self.delay.reset(self.expire); let expire = inner.expire;
let _ = Pin::new(&mut self.delay).poll(cx); inner.delay.reset(expire);
let _ = Pin::new(&mut inner.delay).poll(cx);
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
} }
@ -119,8 +129,8 @@ where
} }
} }
fn call(&mut self, req: R) -> Self::Future { fn call(&self, req: R) -> Self::Future {
self.expire = Instant::from_std(self.time.now() + self.ka); self.inner.borrow_mut().expire = Instant::from_std(self.time.now() + self.ka);
ok(req) ok(req)
} }
} }

53
ntex/src/util/order.rs
View file

@ -1,3 +1,4 @@
use std::cell::RefCell;
use std::collections::VecDeque; use std::collections::VecDeque;
use std::convert::Infallible; use std::convert::Infallible;
use std::fmt; use std::fmt;
@ -58,7 +59,7 @@ pub struct InOrder<S> {
impl<S> InOrder<S> impl<S> InOrder<S>
where where
S: Service, S: Service + 'static,
S::Response: 'static, S::Response: 'static,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
@ -74,7 +75,7 @@ where
impl<S> Default for InOrder<S> impl<S> Default for InOrder<S>
where where
S: Service, S: Service + 'static,
S::Response: 'static, S::Response: 'static,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
@ -86,7 +87,7 @@ where
impl<S> Transform<S> for InOrder<S> impl<S> Transform<S> for InOrder<S>
where where
S: Service, S: Service + 'static,
S::Response: 'static, S::Response: 'static,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
@ -105,7 +106,11 @@ where
pub struct InOrderService<S: Service> { pub struct InOrderService<S: Service> {
service: S, service: S,
waker: Rc<LocalWaker>, inner: Rc<RefCell<Inner<S>>>,
}
struct Inner<S: Service> {
waker: LocalWaker,
acks: VecDeque<Record<S::Response, S::Error>>, acks: VecDeque<Record<S::Response, S::Error>>,
} }
@ -122,15 +127,17 @@ where
{ {
Self { Self {
service: service.into_service(), service: service.into_service(),
acks: VecDeque::new(), inner: Rc::new(RefCell::new(Inner {
waker: Rc::new(LocalWaker::new()), acks: VecDeque::new(),
waker: LocalWaker::new(),
})),
} }
} }
} }
impl<S> Service for InOrderService<S> impl<S> Service for InOrderService<S>
where where
S: Service, S: Service + 'static,
S::Response: 'static, S::Response: 'static,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
@ -140,16 +147,18 @@ where
type Error = InOrderError<S::Error>; type Error = InOrderError<S::Error>;
type Future = InOrderServiceResponse<S>; type Future = InOrderServiceResponse<S>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let mut inner = self.inner.borrow_mut();
// poll_ready could be called from different task // poll_ready could be called from different task
self.waker.register(cx.waker()); inner.waker.register(cx.waker());
// check acks // check acks
while !self.acks.is_empty() { while !inner.acks.is_empty() {
let rec = self.acks.front_mut().unwrap(); let rec = inner.acks.front_mut().unwrap();
match Pin::new(&mut rec.rx).poll(cx) { match Pin::new(&mut rec.rx).poll(cx) {
Poll::Ready(Ok(res)) => { Poll::Ready(Ok(res)) => {
let rec = self.acks.pop_front().unwrap(); let rec = inner.acks.pop_front().unwrap();
let _ = rec.tx.send(res); let _ = rec.tx.send(res);
} }
Poll::Pending => break, Poll::Pending => break,
@ -169,20 +178,24 @@ where
} }
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
fn call(&mut self, request: S::Request) -> Self::Future { fn call(&self, request: S::Request) -> Self::Future {
let inner = self.inner.clone();
let mut inner_b = inner.borrow_mut();
let (tx1, rx1) = oneshot::channel(); let (tx1, rx1) = oneshot::channel();
let (tx2, rx2) = oneshot::channel(); let (tx2, rx2) = oneshot::channel();
self.acks.push_back(Record { rx: rx1, tx: tx2 }); inner_b.acks.push_back(Record { rx: rx1, tx: tx2 });
let waker = self.waker.clone();
let fut = self.service.call(request); let fut = self.service.call(request);
drop(inner_b);
crate::rt::spawn(async move { crate::rt::spawn(async move {
let res = fut.await; let res = fut.await;
waker.wake(); inner.borrow().waker.wake();
let _ = tx1.send(res); let _ = tx1.send(res);
}); });
@ -227,11 +240,11 @@ mod tests {
type Error = (); type Error = ();
type Future = LocalBoxFuture<'static, Result<usize, ()>>; type Future = LocalBoxFuture<'static, Result<usize, ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: oneshot::Receiver<usize>) -> Self::Future { fn call(&self, req: oneshot::Receiver<usize>) -> Self::Future {
req.map(|res| res.map_err(|_| ())).boxed_local() req.map(|res| res.map_err(|_| ())).boxed_local()
} }
} }
@ -249,7 +262,7 @@ mod tests {
let rx3 = rx3; let rx3 = rx3;
let tx_stop = tx_stop; let tx_stop = tx_stop;
let _ = crate::rt::System::new("test").block_on(async { let _ = crate::rt::System::new("test").block_on(async {
let mut srv = InOrderService::new(Srv); let srv = InOrderService::new(Srv);
let _ = lazy(|cx| srv.poll_ready(cx)).await; let _ = lazy(|cx| srv.poll_ready(cx)).await;
let res1 = srv.call(rx1); let res1 = srv.call(rx1);

7
ntex/src/util/time.rs
View file

@ -51,6 +51,7 @@ impl ServiceFactory for LowResTime {
type Service = LowResTimeService; type Service = LowResTimeService;
type Future = Ready<Result<Self::Service, Self::InitError>>; type Future = Ready<Result<Self::Service, Self::InitError>>;
#[inline]
fn new_service(&self, _: ()) -> Self::Future { fn new_service(&self, _: ()) -> Self::Future {
ok(self.timer()) ok(self.timer())
} }
@ -94,11 +95,13 @@ impl Service for LowResTimeService {
type Error = Infallible; type Error = Infallible;
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: ()) -> Self::Future { #[inline]
fn call(&self, _: ()) -> Self::Future {
ok(self.now()) ok(self.now())
} }
} }

18
ntex/src/util/timeout.rs
View file

@ -136,15 +136,17 @@ where
type Error = TimeoutError<S::Error>; type Error = TimeoutError<S::Error>;
type Future = Either<TimeoutServiceResponse<S>, TimeoutServiceResponse2<S>>; type Future = Either<TimeoutServiceResponse<S>, TimeoutServiceResponse2<S>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx).map_err(TimeoutError::Service) self.service.poll_ready(cx).map_err(TimeoutError::Service)
} }
fn poll_shutdown(&mut self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error) self.service.poll_shutdown(cx, is_error)
} }
fn call(&mut self, request: S::Request) -> Self::Future { fn call(&self, request: S::Request) -> Self::Future {
if self.timeout == ZERO { if self.timeout == ZERO {
Either::Right(TimeoutServiceResponse2 { Either::Right(TimeoutServiceResponse2 {
fut: self.service.call(request), fut: self.service.call(request),
@ -231,11 +233,11 @@ mod tests {
type Error = (); type Error = ();
type Future = LocalBoxFuture<'static, Result<(), ()>>; type Future = LocalBoxFuture<'static, Result<(), ()>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, _: ()) -> Self::Future { fn call(&self, _: ()) -> Self::Future {
crate::rt::time::delay_for(self.0) crate::rt::time::delay_for(self.0)
.then(|_| ok::<_, ()>(())) .then(|_| ok::<_, ()>(()))
.boxed_local() .boxed_local()
@ -247,7 +249,7 @@ mod tests {
let resolution = Duration::from_millis(100); let resolution = Duration::from_millis(100);
let wait_time = Duration::from_millis(50); let wait_time = Duration::from_millis(50);
let mut timeout = TimeoutService::new(resolution, SleepService(wait_time)); let timeout = TimeoutService::new(resolution, SleepService(wait_time));
assert_eq!(timeout.call(()).await, Ok(())); assert_eq!(timeout.call(()).await, Ok(()));
} }
@ -256,7 +258,7 @@ mod tests {
let resolution = Duration::from_millis(100); let resolution = Duration::from_millis(100);
let wait_time = Duration::from_millis(500); let wait_time = Duration::from_millis(500);
let mut timeout = TimeoutService::new(resolution, SleepService(wait_time)); let timeout = TimeoutService::new(resolution, SleepService(wait_time));
assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout)); assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout));
} }
@ -269,7 +271,7 @@ mod tests {
Timeout::new(resolution), Timeout::new(resolution),
fn_factory(|| ok::<_, ()>(SleepService(wait_time))), fn_factory(|| ok::<_, ()>(SleepService(wait_time))),
); );
let mut srv = timeout.new_service(&()).await.unwrap(); let srv = timeout.new_service(&()).await.unwrap();
assert_eq!(srv.call(()).await, Err(TimeoutError::Timeout)); assert_eq!(srv.call(()).await, Err(TimeoutError::Timeout));
} }

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

@ -459,7 +459,7 @@ where
> >
where where
B1: MessageBody, B1: MessageBody,
F: FnMut(WebRequest<Err>, &mut T::Service) -> R + Clone, F: Fn(WebRequest<Err>, &T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse<B1>, Err::Container>>, R: Future<Output = Result<WebResponse<B1>, Err::Container>>,
{ {
App { App {
@ -529,7 +529,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_default_resource() { async fn test_default_resource() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::resource("/test").to(|| async { HttpResponse::Ok() })), .service(web::resource("/test").to(|| async { HttpResponse::Ok() })),
) )
@ -542,7 +542,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::resource("/test").to(|| async { HttpResponse::Ok() })) .service(web::resource("/test").to(|| async { HttpResponse::Ok() }))
.service( .service(
@ -575,7 +575,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_data_factory() { async fn test_data_factory() {
let mut srv = init_service( let srv = init_service(
App::new().data_factory(|| ok::<_, ()>(10usize)).service( App::new().data_factory(|| ok::<_, ()>(10usize)).service(
web::resource("/") web::resource("/")
.to(|_: web::Data<usize>| async { HttpResponse::Ok() }), .to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
@ -586,12 +586,9 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service( let srv = init_service(App::new().data_factory(|| ok::<_, ()>(10u32)).service(
App::new().data_factory(|| ok::<_, ()>(10u32)).service( web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
web::resource("/") ))
.to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
),
)
.await; .await;
let req = TestRequest::default().to_request(); let req = TestRequest::default().to_request();
let res = srv.call(req).await.unwrap(); let res = srv.call(req).await.unwrap();
@ -600,7 +597,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_extension() { async fn test_extension() {
let mut srv = init_service(App::new().app_data(10usize).service( let srv = init_service(App::new().app_data(10usize).service(
web::resource("/").to(|req: HttpRequest| async move { web::resource("/").to(|req: HttpRequest| async move {
assert_eq!(*req.app_data::<usize>().unwrap(), 10); assert_eq!(*req.app_data::<usize>().unwrap(), 10);
HttpResponse::Ok() HttpResponse::Ok()
@ -614,7 +611,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_wrap() { async fn test_wrap() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap( .wrap(
DefaultHeaders::new() DefaultHeaders::new()
@ -624,7 +621,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -634,7 +631,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_router_wrap() { async fn test_router_wrap() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.route("/test", web::get().to(|| async { HttpResponse::Ok() })) .route("/test", web::get().to(|| async { HttpResponse::Ok() }))
.wrap( .wrap(
@ -644,7 +641,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -654,7 +651,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_wrap_fn() { async fn test_wrap_fn() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
let fut = srv.call(req); let fut = srv.call(req);
@ -671,7 +668,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -681,7 +678,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_router_wrap_fn() { async fn test_router_wrap_fn() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.route("/test", web::get().to(|| async { HttpResponse::Ok() })) .route("/test", web::get().to(|| async { HttpResponse::Ok() }))
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
@ -698,7 +695,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -708,24 +705,24 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_case_insensitive_router() { async fn test_case_insensitive_router() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.case_insensitive_routing() .case_insensitive_routing()
.route("/test", web::get().to(|| async { HttpResponse::Ok() })), .route("/test", web::get().to(|| async { HttpResponse::Ok() })),
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/Test").to_request(); let req = TestRequest::with_uri("/Test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_external_resource() { async fn test_external_resource() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.external_resource("youtube", "https://youtube.com/watch/{video_id}") .external_resource("youtube", "https://youtube.com/watch/{video_id}")
.route( .route(
@ -740,7 +737,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;
assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345")); assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));

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

@ -246,11 +246,17 @@ where
type Error = T::Error; type Error = T::Error;
type Future = T::Future; type Future = T::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: Request) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error)
}
fn call(&self, req: Request) -> Self::Future {
let (head, payload) = req.into_parts(); let (head, payload) = req.into_parts();
let req = if let Some(mut req) = self.pool.get_request() { let req = if let Some(mut req) = self.pool.get_request() {
@ -419,7 +425,8 @@ impl<Err: ErrorRenderer> Service for AppRouting<Err> {
type Error = Err::Container; type Error = Err::Container;
type Future = BoxResponse<Err>; type Future = BoxResponse<Err>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
if self.ready.is_none() { if self.ready.is_none() {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} else { } else {
@ -427,8 +434,8 @@ impl<Err: ErrorRenderer> Service for AppRouting<Err> {
} }
} }
fn call(&mut self, mut req: WebRequest<Err>) -> Self::Future { fn call(&self, mut req: WebRequest<Err>) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards { if let Some(guards) = guards {
for f in guards { for f in guards {
if !f.check(req.head()) { if !f.check(req.head()) {
@ -441,7 +448,7 @@ impl<Err: ErrorRenderer> Service for AppRouting<Err> {
if let Some((srv, _info)) = res { if let Some((srv, _info)) = res {
srv.call(req) srv.call(req)
} else if let Some(ref mut default) = self.default { } else if let Some(ref default) = self.default {
default.call(req) default.call(req)
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;
@ -497,7 +504,7 @@ mod tests {
let data = Arc::new(AtomicBool::new(false)); let data = Arc::new(AtomicBool::new(false));
{ {
let mut app = let app =
init_service(App::new().data(DropData(data.clone())).service( init_service(App::new().data(DropData(data.clone())).service(
web::resource("/test").to(|| async { HttpResponse::Ok() }), web::resource("/test").to(|| async { HttpResponse::Ok() }),
)) ))

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

@ -255,7 +255,7 @@ mod tests {
cfg.data(10usize); cfg.data(10usize);
}; };
let mut srv = init_service(App::new().configure(cfg).service( let srv = init_service(App::new().configure(cfg).service(
web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }), web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
)) ))
.await; .await;

14
ntex/src/web/data.rs
View file

@ -142,7 +142,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_data_extractor() { async fn test_data_extractor() {
let mut srv = init_service(App::new().data("TEST".to_string()).service( let srv = init_service(App::new().data("TEST".to_string()).service(
web::resource("/").to(|data: web::Data<String>| async move { web::resource("/").to(|data: web::Data<String>| async move {
assert_eq!(data.to_lowercase(), "test"); assert_eq!(data.to_lowercase(), "test");
HttpResponse::Ok() HttpResponse::Ok()
@ -154,7 +154,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().data(10u32).service( let srv = init_service(App::new().data(10u32).service(
web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }), web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
)) ))
.await; .await;
@ -165,7 +165,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_app_data_extractor() { async fn test_app_data_extractor() {
let mut srv = init_service(App::new().app_data(Data::new(10usize)).service( let srv = init_service(App::new().app_data(Data::new(10usize)).service(
web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }), web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
)) ))
.await; .await;
@ -174,7 +174,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().app_data(Data::new(10u32)).service( let srv = init_service(App::new().app_data(Data::new(10u32)).service(
web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }), web::resource("/").to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
)) ))
.await; .await;
@ -185,7 +185,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_route_data_extractor() { async fn test_route_data_extractor() {
let mut srv = let srv =
init_service(App::new().service(web::resource("/").data(10usize).route( init_service(App::new().service(web::resource("/").data(10usize).route(
web::get().to(|data: web::Data<usize>| async move { web::get().to(|data: web::Data<usize>| async move {
let _ = data.clone(); let _ = data.clone();
@ -199,7 +199,7 @@ mod tests {
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
// different type // different type
let mut srv = let srv =
init_service(App::new().service(web::resource("/").data(10u32).route( init_service(App::new().service(web::resource("/").data(10u32).route(
web::get().to(|_: web::Data<usize>| async { HttpResponse::Ok() }), web::get().to(|_: web::Data<usize>| async { HttpResponse::Ok() }),
))) )))
@ -211,7 +211,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_override_data() { async fn test_override_data() {
let mut srv = init_service(App::new().data(1usize).service( let srv = init_service(App::new().data(1usize).service(
web::resource("/").data(10usize).route(web::get().to( web::resource("/").data(10usize).route(web::get().to(
|data: web::Data<usize>| async move { |data: web::Data<usize>| async move {
assert_eq!(**data, 10); assert_eq!(**data, 10);

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

@ -36,7 +36,7 @@ where
pub(super) trait HandlerFn<Err: ErrorRenderer> { pub(super) trait HandlerFn<Err: ErrorRenderer> {
fn call( fn call(
&mut self, &self,
_: WebRequest<Err>, _: WebRequest<Err>,
) -> LocalBoxFuture<'static, Result<WebResponse, Err::Container>>; ) -> LocalBoxFuture<'static, Result<WebResponse, Err::Container>>;
@ -86,7 +86,7 @@ where
Err: ErrorRenderer, Err: ErrorRenderer,
{ {
fn call( fn call(
&mut self, &self,
req: WebRequest<Err>, req: WebRequest<Err>,
) -> LocalBoxFuture<'static, Result<WebResponse, Err::Container>> { ) -> LocalBoxFuture<'static, Result<WebResponse, Err::Container>> {
let (req, mut payload) = req.into_parts(); let (req, mut payload) = req.into_parts();

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

@ -97,11 +97,17 @@ where
type Error = S::Error; type Error = S::Error;
type Future = CompressResponse<S, B, E>; type Future = CompressResponse<S, B, E>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: WebRequest<E>) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error)
}
fn call(&self, req: WebRequest<E>) -> Self::Future {
// negotiate content-encoding // negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) { let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() { if let Ok(enc) = val.to_str() {

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

@ -129,11 +129,17 @@ where
type Error = S::Error; type Error = S::Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: WebRequest<E>) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error)
}
fn call(&self, req: WebRequest<E>) -> Self::Future {
let inner = self.inner.clone(); let inner = self.inner.clone();
let fut = self.service.call(req); let fut = self.service.call(req);
@ -172,7 +178,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_default_headers() { async fn test_default_headers() {
let mut mw = DefaultHeaders::<DefaultError>::new() let mw = DefaultHeaders::<DefaultError>::new()
.header(CONTENT_TYPE, "0001") .header(CONTENT_TYPE, "0001")
.new_transform(ok_service()) .new_transform(ok_service())
.await .await
@ -189,7 +195,7 @@ mod tests {
HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish(), HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish(),
)) ))
}; };
let mut mw = DefaultHeaders::<DefaultError>::new() let mw = DefaultHeaders::<DefaultError>::new()
.header(CONTENT_TYPE, "0001") .header(CONTENT_TYPE, "0001")
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
@ -203,7 +209,7 @@ mod tests {
let srv = |req: WebRequest<DefaultError>| { let srv = |req: WebRequest<DefaultError>| {
ok::<_, Error>(req.into_response(HttpResponse::Ok().finish())) ok::<_, Error>(req.into_response(HttpResponse::Ok().finish()))
}; };
let mut mw = DefaultHeaders::<DefaultError>::new() let mw = DefaultHeaders::<DefaultError>::new()
.content_type() .content_type()
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await

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

@ -164,11 +164,18 @@ where
type Error = S::Error; type Error = S::Error;
type Future = LoggerResponse<S, B, E>; type Future = LoggerResponse<S, B, E>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: WebRequest<E>) -> Self::Future { #[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error)
}
#[inline]
fn call(&self, req: WebRequest<E>) -> Self::Future {
if self.inner.exclude.contains(req.path()) { if self.inner.exclude.contains(req.path()) {
LoggerResponse { LoggerResponse {
fut: self.service.call(req), fut: self.service.call(req),
@ -503,7 +510,7 @@ mod tests {
}; };
let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test"); let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");
let mut srv = Transform::new_transform(&logger, srv.into_service()) let srv = Transform::new_transform(&logger, srv.into_service())
.await .await
.unwrap(); .unwrap();

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

@ -331,7 +331,7 @@ where
>, >,
> >
where where
F: FnMut(WebRequest<Err>, &mut T::Service) -> R + Clone, F: Fn(WebRequest<Err>, &T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse, Err::Container>>, R: Future<Output = Result<WebResponse, Err::Container>>,
{ {
Resource { Resource {
@ -504,12 +504,13 @@ impl<Err: ErrorRenderer> Service for ResourceService<Err> {
LocalBoxFuture<'static, Result<WebResponse, Err::Container>>, LocalBoxFuture<'static, Result<WebResponse, Err::Container>>,
>; >;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, mut req: WebRequest<Err>) -> Self::Future { fn call(&self, mut req: WebRequest<Err>) -> Self::Future {
for route in self.routes.iter_mut() { for route in self.routes.iter() {
if route.check(&mut req) { if route.check(&mut req) {
if let Some(ref data) = self.data { if let Some(ref data) = self.data {
req.set_data_container(data.clone()); req.set_data_container(data.clone());
@ -517,7 +518,7 @@ impl<Err: ErrorRenderer> Service for ResourceService<Err> {
return Either::Right(route.call(req)); return Either::Right(route.call(req));
} }
} }
if let Some(ref mut default) = self.default { if let Some(ref default) = self.default {
Either::Right(default.call(req)) Either::Right(default.call(req))
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;

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

@ -487,7 +487,7 @@ pub(crate) mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_option_responder() { async fn test_option_responder() {
let mut srv = init_service( let srv = init_service(
web::App::new() web::App::new()
.service( .service(
web::resource("/none").to(|| async { Option::<&'static str>::None }), web::resource("/none").to(|| async { Option::<&'static str>::None }),

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

@ -82,11 +82,13 @@ impl<Err: ErrorRenderer> Service for RouteService<Err> {
type Error = Err::Container; type Error = Err::Container;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: WebRequest<Err>) -> Self::Future { #[inline]
fn call(&self, req: WebRequest<Err>) -> Self::Future {
self.handler.call(req) self.handler.call(req)
} }
} }

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

@ -394,7 +394,7 @@ where
>, >,
> >
where where
F: FnMut(WebRequest<Err>, &mut T::Service) -> R + Clone, F: Fn(WebRequest<Err>, &T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse, Err::Container>>, R: Future<Output = Result<WebResponse, Err::Container>>,
{ {
Scope { Scope {
@ -619,12 +619,13 @@ impl<Err: ErrorRenderer> Service for ScopeService<Err> {
type Error = Err::Container; type Error = Err::Container;
type Future = Either<BoxedResponse<Err>, Ready<Result<Self::Response, Self::Error>>>; type Future = Either<BoxedResponse<Err>, Ready<Result<Self::Response, Self::Error>>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { #[inline]
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, mut req: WebRequest<Err>) -> Self::Future { fn call(&self, mut req: WebRequest<Err>) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_checked(&mut req, |req, guards| {
if let Some(guards) = guards { if let Some(guards) = guards {
for f in guards { for f in guards {
if !f.check(req.head()) { if !f.check(req.head()) {
@ -640,7 +641,7 @@ impl<Err: ErrorRenderer> Service for ScopeService<Err> {
req.set_data_container(data.clone()); req.set_data_container(data.clone());
} }
Either::Left(srv.call(req)) Either::Left(srv.call(req))
} else if let Some(ref mut default) = self.default { } else if let Some(ref default) = self.default {
Either::Left(default.call(req)) Either::Left(default.call(req))
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;
@ -691,7 +692,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope() { async fn test_scope() {
let mut srv = let srv =
init_service(App::new().service( init_service(App::new().service(
web::scope("/app").service( web::scope("/app").service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }), web::resource("/path1").to(|| async { HttpResponse::Ok() }),
@ -706,7 +707,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_root() { async fn test_scope_root() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.service(web::resource("").to(|| async { HttpResponse::Ok() })) .service(web::resource("").to(|| async { HttpResponse::Ok() }))
@ -728,7 +729,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_root2() { async fn test_scope_root2() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app/") web::scope("/app/")
.service(web::resource("").to(|| async { HttpResponse::Ok() })), .service(web::resource("").to(|| async { HttpResponse::Ok() })),
@ -747,7 +748,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_root3() { async fn test_scope_root3() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app/") web::scope("/app/")
.service(web::resource("/").to(|| async { HttpResponse::Ok() })), .service(web::resource("/").to(|| async { HttpResponse::Ok() })),
@ -766,7 +767,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_route() { async fn test_scope_route() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.route("/path1", web::get().to(|| async { HttpResponse::Ok() })) .route("/path1", web::get().to(|| async { HttpResponse::Ok() }))
@ -794,7 +795,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_route_without_leading_slash() { async fn test_scope_route_without_leading_slash() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app").service( web::scope("app").service(
web::resource("path1") web::resource("path1")
@ -824,7 +825,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_guard() { async fn test_scope_guard() {
let mut srv = let srv =
init_service(App::new().service( init_service(App::new().service(
web::scope("/app").guard(guard::Get()).service( web::scope("/app").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }), web::resource("/path1").to(|| async { HttpResponse::Ok() }),
@ -847,14 +848,13 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_variable_segment() { async fn test_scope_variable_segment() {
let mut srv = let srv = init_service(App::new().service(web::scope("/ab-{project}").service(
init_service(App::new().service(web::scope("/ab-{project}").service( web::resource("/path1").to(|r: HttpRequest| async move {
web::resource("/path1").to(|r: HttpRequest| async move { HttpResponse::Ok()
HttpResponse::Ok() .body(format!("project: {}", &r.match_info()["project"]))
.body(format!("project: {}", &r.match_info()["project"])) }),
}), )))
))) .await;
.await;
let req = TestRequest::with_uri("/ab-project1/path1").to_request(); let req = TestRequest::with_uri("/ab-project1/path1").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -875,7 +875,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested_scope() { async fn test_nested_scope() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").service( web::scope("/t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }), web::resource("/path1").to(|| async { HttpResponse::Created() }),
), ),
@ -889,7 +889,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested_scope_no_slash() { async fn test_nested_scope_no_slash() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("t1").service( web::scope("t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }), web::resource("/path1").to(|| async { HttpResponse::Created() }),
), ),
@ -903,7 +903,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested_scope_root() { async fn test_nested_scope_root() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app").service( web::scope("/app").service(
web::scope("/t1") web::scope("/t1")
@ -927,7 +927,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested_scope_filter() { async fn test_nested_scope_filter() {
let mut srv = let srv =
init_service(App::new().service(web::scope("/app").service( init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").guard(guard::Get()).service( web::scope("/t1").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }), web::resource("/path1").to(|| async { HttpResponse::Ok() }),
@ -950,7 +950,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested_scope_with_variable_segment() { async fn test_nested_scope_with_variable_segment() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/{project_id}").service(web::resource("/path1").to( web::scope("/{project_id}").service(web::resource("/path1").to(
|r: HttpRequest| async move { |r: HttpRequest| async move {
HttpResponse::Created() HttpResponse::Created()
@ -975,7 +975,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_nested2_scope_with_variable_segment() { async fn test_nested2_scope_with_variable_segment() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/{project}").service(web::scope("/{id}").service( web::scope("/{project}").service(web::scope("/{id}").service(
web::resource("/path1").to(|r: HttpRequest| async move { web::resource("/path1").to(|r: HttpRequest| async move {
HttpResponse::Created().body(format!( HttpResponse::Created().body(format!(
@ -1007,7 +1007,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_default_resource() { async fn test_default_resource() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.service(web::resource("/path1").to(|| async { HttpResponse::Ok() })) .service(web::resource("/path1").to(|| async { HttpResponse::Ok() }))
@ -1029,7 +1029,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_default_resource_propagation() { async fn test_default_resource_propagation() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::scope("/app1").default_service( .service(web::scope("/app1").default_service(
web::resource("").to(|| async { HttpResponse::BadRequest() }), web::resource("").to(|| async { HttpResponse::BadRequest() }),
@ -1056,7 +1056,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_middleware() { async fn test_middleware() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.wrap( .wrap(
@ -1072,7 +1072,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(), resp.headers().get(CONTENT_TYPE).unwrap(),
@ -1082,7 +1082,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_middleware_fn() { async fn test_middleware_fn() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
@ -1100,7 +1100,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(), resp.headers().get(CONTENT_TYPE).unwrap(),
@ -1110,7 +1110,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_override_data() { async fn test_override_data() {
let mut srv = init_service(App::new().data(1usize).service( let srv = init_service(App::new().data(1usize).service(
web::scope("app").data(10usize).route( web::scope("app").data(10usize).route(
"/t", "/t",
web::get().to(|data: web::Data<usize>| { web::get().to(|data: web::Data<usize>| {
@ -1123,13 +1123,13 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/t").to_request(); let req = TestRequest::with_uri("/app/t").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_override_app_data() { async fn test_override_app_data() {
let mut srv = init_service(App::new().app_data(web::Data::new(1usize)).service( let srv = init_service(App::new().app_data(web::Data::new(1usize)).service(
web::scope("app").app_data(web::Data::new(10usize)).route( web::scope("app").app_data(web::Data::new(10usize)).route(
"/t", "/t",
web::get().to(|data: web::Data<usize>| { web::get().to(|data: web::Data<usize>| {
@ -1142,17 +1142,16 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/t").to_request(); let req = TestRequest::with_uri("/app/t").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_config() { async fn test_scope_config() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.route("/path1", web::get().to(|| async { HttpResponse::Ok() }));
s.route("/path1", web::get().to(|| async { HttpResponse::Ok() })); })))
}))) .await;
.await;
let req = TestRequest::with_uri("/app/path1").to_request(); let req = TestRequest::with_uri("/app/path1").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1161,13 +1160,12 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_scope_config_2() { async fn test_scope_config_2() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.service(web::scope("/v1").configure(|s| {
s.service(web::scope("/v1").configure(|s| { s.route("/", web::get().to(|| async { HttpResponse::Ok() }));
s.route("/", web::get().to(|| async { HttpResponse::Ok() })); }));
})); })))
}))) .await;
.await;
let req = TestRequest::with_uri("/app/v1/").to_request(); let req = TestRequest::with_uri("/app/v1/").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1176,25 +1174,21 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_url_for_external() { async fn test_url_for_external() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.service(web::scope("/v1").configure(|s| {
s.service(web::scope("/v1").configure(|s| { s.external_resource("youtube", "https://youtube.com/watch/{video_id}");
s.external_resource( s.route(
"youtube", "/",
"https://youtube.com/watch/{video_id}", web::get().to(|req: HttpRequest| async move {
); HttpResponse::Ok().body(format!(
s.route( "{}",
"/", req.url_for("youtube", &["xxxxxx"]).unwrap().as_str()
web::get().to(|req: HttpRequest| async move { ))
HttpResponse::Ok().body(format!( }),
"{}", );
req.url_for("youtube", &["xxxxxx"]).unwrap().as_str() }));
)) })))
}), .await;
);
}));
})))
.await;
let req = TestRequest::with_uri("/app/v1/").to_request(); let req = TestRequest::with_uri("/app/v1/").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1205,7 +1199,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_url_for_nested() { async fn test_url_for_nested() {
let mut srv = init_service(App::new().service(web::scope("/a").service( let srv = init_service(App::new().service(web::scope("/a").service(
web::scope("/b").service(web::resource("/c/{stuff}").name("c").route( web::scope("/b").service(web::resource("/c/{stuff}").name("c").route(
web::get().to(|req: HttpRequest| async move { web::get().to(|req: HttpRequest| async move {
HttpResponse::Ok() HttpResponse::Ok()
@ -1216,7 +1210,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/a/b/c/test").to_request(); let req = TestRequest::with_uri("/a/b/c/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;
assert_eq!( assert_eq!(

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

@ -602,7 +602,7 @@ mod tests {
#[ntex_rt::test] #[ntex_rt::test]
async fn test_service() { async fn test_service() {
let mut srv = init_service(App::new().service( let srv = init_service(App::new().service(
web::service("/test").name("test").finish( web::service("/test").name("test").finish(
|req: WebRequest<DefaultError>| { |req: WebRequest<DefaultError>| {
ok(req.into_response(HttpResponse::Ok().finish())) ok(req.into_response(HttpResponse::Ok().finish()))
@ -614,7 +614,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().service( let srv = init_service(App::new().service(
web::service("/test").guard(guard::Get()).finish( web::service("/test").guard(guard::Get()).finish(
|req: WebRequest<DefaultError>| { |req: WebRequest<DefaultError>| {
ok(req.into_response(HttpResponse::Ok().finish())) ok(req.into_response(HttpResponse::Ok().finish()))

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

@ -125,7 +125,7 @@ where
/// assert_eq!(resp.status(), StatusCode::OK); /// assert_eq!(resp.status(), StatusCode::OK);
/// } /// }
/// ``` /// ```
pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response pub async fn call_service<S, R, B, E>(app: &S, req: R) -> S::Response
where where
S: Service<Request = R, Response = WebResponse<B>, Error = E>, S: Service<Request = R, Response = WebResponse<B>, Error = E>,
E: std::fmt::Debug, E: std::fmt::Debug,
@ -159,7 +159,7 @@ where
/// assert_eq!(result, Bytes::from_static(b"welcome!")); /// assert_eq!(result, Bytes::from_static(b"welcome!"));
/// } /// }
/// ``` /// ```
pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes pub async fn read_response<S, B>(app: &S, req: Request) -> Bytes
where where
S: Service<Request = Request, Response = WebResponse<B>>, S: Service<Request = Request, Response = WebResponse<B>>,
B: MessageBody, B: MessageBody,
@ -262,7 +262,7 @@ where
/// let result: Person = test::read_response_json(&mut app, req).await; /// let result: Person = test::read_response_json(&mut app, req).await;
/// } /// }
/// ``` /// ```
pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T pub async fn read_response_json<S, B, T>(app: &S, req: Request) -> T
where where
S: Service<Request = Request, Response = WebResponse<B>>, S: Service<Request = Request, Response = WebResponse<B>>,
B: MessageBody, B: MessageBody,
@ -1129,7 +1129,7 @@ mod tests {
} }
} }
let mut app = init_service( let app = init_service(
App::new().service( App::new().service(
web::resource("/index.html") web::resource("/index.html")
.to(crate::web::dev::__assert_handler(async_with_block)), .to(crate::web::dev::__assert_handler(async_with_block)),
@ -1149,7 +1149,7 @@ mod tests {
HttpResponse::Ok() HttpResponse::Ok()
} }
let mut app = init_service(App::new().data(10usize).service( let app = init_service(App::new().data(10usize).service(
web::resource("/index.html").to(crate::web::dev::__assert_handler1(handler)), web::resource("/index.html").to(crate::web::dev::__assert_handler1(handler)),
)) ))
.await; .await;

14
ntex/tests/connect.rs
View file

@ -21,7 +21,7 @@ async fn test_string() {
}) })
}); });
let mut conn = ntex::connect::Connector::default(); let conn = ntex::connect::Connector::default();
let addr = format!("localhost:{}", srv.addr().port()); let addr = format!("localhost:{}", srv.addr().port());
let con = conn.call(addr.into()).await.unwrap(); let con = conn.call(addr.into()).await.unwrap();
assert_eq!(con.peer_addr().unwrap(), srv.addr()); assert_eq!(con.peer_addr().unwrap(), srv.addr());
@ -38,7 +38,7 @@ async fn test_rustls_string() {
}) })
}); });
let mut conn = ntex::connect::Connector::default(); let conn = ntex::connect::Connector::default();
let addr = format!("localhost:{}", srv.addr().port()); let addr = format!("localhost:{}", srv.addr().port());
let con = conn.call(addr.into()).await.unwrap(); let con = conn.call(addr.into()).await.unwrap();
assert_eq!(con.peer_addr().unwrap(), srv.addr()); assert_eq!(con.peer_addr().unwrap(), srv.addr());
@ -55,13 +55,13 @@ async fn test_static_str() {
}); });
let resolver = ntex::connect::default_resolver(); let resolver = ntex::connect::default_resolver();
let mut conn = ntex::connect::Connector::new(resolver.clone()); let conn = ntex::connect::Connector::new(resolver.clone());
let con = conn.call(Connect::with("10", srv.addr())).await.unwrap(); let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
assert_eq!(con.peer_addr().unwrap(), srv.addr()); assert_eq!(con.peer_addr().unwrap(), srv.addr());
let connect = Connect::new("127.0.0.1".to_owned()); let connect = Connect::new("127.0.0.1".to_owned());
let mut conn = ntex::connect::Connector::new(resolver); let conn = ntex::connect::Connector::new(resolver);
let con = conn.call(connect).await; let con = conn.call(connect).await;
assert!(con.is_err()); assert!(con.is_err());
} }
@ -83,7 +83,7 @@ async fn test_new_service() {
let factory = ntex::connect::Connector::new(resolver); let factory = ntex::connect::Connector::new(resolver);
let mut conn = factory.new_service(()).await.unwrap(); let conn = factory.new_service(()).await.unwrap();
let con = conn.call(Connect::with("10", srv.addr())).await.unwrap(); let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
assert_eq!(con.peer_addr().unwrap(), srv.addr()); assert_eq!(con.peer_addr().unwrap(), srv.addr());
} }
@ -101,7 +101,7 @@ async fn test_uri() {
}) })
}); });
let mut conn = ntex::connect::Connector::default(); let conn = ntex::connect::Connector::default();
let addr = let addr =
ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port())) ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port()))
.unwrap(); .unwrap();
@ -122,7 +122,7 @@ async fn test_rustls_uri() {
}) })
}); });
let mut conn = ntex::connect::Connector::default(); let conn = ntex::connect::Connector::default();
let addr = let addr =
ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port())) ntex::http::Uri::try_from(format!("https://localhost:{}", srv.addr().port()))
.unwrap(); .unwrap();

9
ntex/tests/framed_server.rs
View file

@ -1,4 +1,4 @@
use std::cell::Cell; use std::cell::{Cell, RefCell};
use std::rc::Rc; use std::rc::Rc;
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};
@ -26,18 +26,19 @@ async fn test_basic() {
}); });
let item = client_item.clone(); let item = client_item.clone();
let mut client = Builder::new(fn_service(move |conn: Connect<_, _>| async move { let client = Builder::new(fn_service(move |conn: Connect<_, _>| async move {
let (tx, rx) = mpsc::channel(); let (tx, rx) = mpsc::channel();
let _ = tx.send(Bytes::from_static(b"Hello")); let _ = tx.send(Bytes::from_static(b"Hello"));
Ok(conn.codec(BytesCodec).out(rx).state(State(Some(tx)))) Ok(conn.codec(BytesCodec).out(rx).state(State(Some(tx))))
})) }))
.build(fn_factory_with_config(move |mut cfg: State| { .build(fn_factory_with_config(move |cfg: State| {
let item = item.clone(); let item = item.clone();
let cfg = RefCell::new(cfg);
ok((move |t: BytesMut| { ok((move |t: BytesMut| {
assert_eq!(t.freeze(), Bytes::from_static(b"Hello")); assert_eq!(t.freeze(), Bytes::from_static(b"Hello"));
item.set(true); item.set(true);
// drop Sender, which will close connection // drop Sender, which will close connection
cfg.0.take(); cfg.borrow_mut().0.take();
ok::<_, ()>(None) ok::<_, ()>(None)
}) })
.into_service()) .into_service())

6
ntex/tests/http_ws.rs
View file

@ -22,7 +22,7 @@ impl<T> WsService<T> {
WsService(Arc::new(Mutex::new((PhantomData, Cell::new(false))))) WsService(Arc::new(Mutex::new((PhantomData, Cell::new(false)))))
} }
fn set_polled(&mut self) { fn set_polled(&self) {
*self.0.lock().unwrap().1.get_mut() = true; *self.0.lock().unwrap().1.get_mut() = true;
} }
@ -46,12 +46,12 @@ where
type Error = io::Error; type Error = io::Error;
type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>; type Future = Pin<Box<dyn Future<Output = Result<(), io::Error>>>>;
fn poll_ready(&mut self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.set_polled(); self.set_polled();
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, (req, mut framed): Self::Request) -> Self::Future { fn call(&self, (req, mut framed): Self::Request) -> Self::Future {
let fut = async move { let fut = async move {
let res = handshake(req.head()).unwrap().message_body(()); let res = handshake(req.head()).unwrap().message_body(());