Use GAT (#153)

* Rename Transform to Middleware

* Drop FnService's shutdown helper

* refactor Service trait to use GAT

* Migrate ntex to new service

* move Stack to service

* use BoxFuture

* simplify poll_shitdown method

ntex-util/src/services/timeout.rs

@@ -6,7 +6,7 @@ use std::{
     fmt, future::Future, marker, marker::PhantomData, pin::Pin, task::Context, task::Poll,
 };
 
-use ntex_service::{IntoService, Service, Transform};
+use ntex_service::{IntoService, Middleware, Service};
 
 use crate::future::Either;
 use crate::time::{sleep, Millis, Sleep};
@@ -87,10 +87,10 @@ impl Clone for Timeout {
     }
 }
 
-impl<S> Transform<S> for Timeout {
+impl<S> Middleware<S> for Timeout {
     type Service = TimeoutService<S>;
 
-    fn new_transform(&self, service: S) -> Self::Service {
+    fn create(&self, service: S) -> Self::Service {
         TimeoutService {
             service,
             timeout: self.timeout,
@@ -125,19 +125,9 @@ where
 {
     type Response = S::Response;
     type Error = TimeoutError<S::Error>;
-    type Future = Either<TimeoutServiceResponse<S, R>, TimeoutServiceResponse2<S, R>>;
+    type Future<'f> = Either<TimeoutServiceResponse<'f, S, R>, TimeoutServiceResponse2<'f, S, R>> where Self: 'f, R: 'f;
 
-    #[inline]
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx).map_err(TimeoutError::Service)
-    }
-
-    #[inline]
-    fn poll_shutdown(&self, cx: &mut Context<'_>, is_error: bool) -> Poll<()> {
-        self.service.poll_shutdown(cx, is_error)
-    }
-
-    fn call(&self, request: R) -> Self::Future {
+    fn call(&self, request: R) -> Self::Future<'_> {
         if self.timeout.is_zero() {
             Either::Right(TimeoutServiceResponse2 {
                 fut: self.service.call(request),
@@ -151,21 +141,26 @@ where
             })
         }
     }
+
+    ntex_service::forward_poll_ready!(service, TimeoutError::Service);
+    ntex_service::forward_poll_shutdown!(service);
 }
 
 pin_project_lite::pin_project! {
     /// `TimeoutService` response future
     #[doc(hidden)]
     #[derive(Debug)]
-    pub struct TimeoutServiceResponse<T: Service<R>, R> {
+    pub struct TimeoutServiceResponse<'f, T: Service<R>, R>
+    where T: 'f, R: 'f,
+    {
         #[pin]
-        fut: T::Future,
+        fut: T::Future<'f>,
         sleep: Sleep,
         _t: PhantomData<R>
     }
 }
 
-impl<T, R> Future for TimeoutServiceResponse<T, R>
+impl<'f, T, R> Future for TimeoutServiceResponse<'f, T, R>
 where
     T: Service<R>,
 {
@@ -193,14 +188,16 @@ pin_project_lite::pin_project! {
     /// `TimeoutService` response future
     #[doc(hidden)]
     #[derive(Debug)]
-    pub struct TimeoutServiceResponse2<T: Service<R>, R> {
+    pub struct TimeoutServiceResponse2<'f, T: Service<R>, R>
+    where T: 'f, R: 'f,
+    {
         #[pin]
-        fut: T::Future,
+        fut: T::Future<'f>,
         _t: PhantomData<R>,
     }
 }
 
-impl<T, R> Future for TimeoutServiceResponse2<T, R>
+impl<'f, T, R> Future for TimeoutServiceResponse2<'f, T, R>
 where
     T: Service<R>,
 {
@@ -217,12 +214,12 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::{fmt, task::Context, task::Poll, time::Duration};
+    use std::{fmt, time::Duration};
 
     use ntex_service::{apply, fn_factory, Service, ServiceFactory};
 
     use super::*;
-    use crate::future::lazy;
+    use crate::future::{lazy, BoxFuture};
 
     #[derive(Clone, Debug, PartialEq)]
     struct SleepService(Duration);
@@ -239,21 +236,9 @@ mod tests {
     impl Service<()> for SleepService {
         type Response = ();
         type Error = SrvError;
-        type Future = Pin<Box<dyn Future<Output = Result<(), SrvError>>>>;
+        type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
 
-        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn poll_shutdown(&self, _: &mut Context<'_>, is_error: bool) -> Poll<()> {
-            if is_error {
-                Poll::Ready(())
-            } else {
-                Poll::Pending
-            }
-        }
-
-        fn call(&self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future<'_> {
             let fut = crate::time::sleep(self.0);
             Box::pin(async move {
                 let _ = fut.await;
@@ -270,10 +255,7 @@ mod tests {
         let timeout = TimeoutService::new(resolution, SleepService(wait_time)).clone();
         assert_eq!(timeout.call(()).await, Ok(()));
         assert!(lazy(|cx| timeout.poll_ready(cx)).await.is_ready());
-        assert!(lazy(|cx| timeout.poll_shutdown(cx, true)).await.is_ready());
-        assert!(lazy(|cx| timeout.poll_shutdown(cx, false))
-            .await
-            .is_pending());
+        assert!(lazy(|cx| timeout.poll_shutdown(cx)).await.is_ready());
     }
 
     #[ntex_macros::rt_test2]
@@ -305,7 +287,7 @@ mod tests {
             Timeout::new(resolution).clone(),
             fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }),
         );
-        let srv = timeout.new_service(&()).await.unwrap();
+        let srv = timeout.create(&()).await.unwrap();
 
         let res = srv.call(()).await.unwrap_err();
         assert_eq!(res, TimeoutError::Timeout);