Migrate to ntex-service 1.2 (#209)

* Migrate to ntex-service 1.2

ntex-service/Cargo.toml

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

ntex-service/src/and_then.rs

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

ntex-service/src/apply.rs

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

ntex-service/src/boxed.rs

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

ntex-service/src/ctx.rs

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

ntex-service/src/fn_service.rs

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

ntex-service/src/fn_shutdown.rs

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

ntex-service/src/lib.rs

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

ntex-service/src/map.rs

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

ntex-service/src/map_err.rs

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

ntex-service/src/middleware.rs

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

ntex-service/src/pipeline.rs

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

ntex-service/src/then.rs

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