Migrate ntex-util to async fn in trait

ntex-util/src/services/timeout.rs

@@ -2,12 +2,12 @@
 //!
 //! If the response does not complete within the specified timeout, the response
 //! will be aborted.
-use std::{fmt, future::Future, marker, pin::Pin, task::Context, task::Poll};
+use std::{fmt, marker};
 
-use ntex_service::{IntoService, Middleware, Service, ServiceCall, ServiceCtx};
+use ntex_service::{IntoService, Middleware, Service, ServiceCtx};
 
-use crate::future::Either;
-use crate::time::{sleep, Millis, Sleep};
+use crate::future::{select, Either};
+use crate::time::{sleep, Millis};
 
 /// Applies a timeout to requests.
 ///
@@ -123,20 +123,21 @@ where
 {
     type Response = S::Response;
     type Error = TimeoutError<S::Error>;
-    type Future<'f> = Either<TimeoutServiceResponse<'f, S, R>, TimeoutServiceResponse2<'f, S, R>> where Self: 'f, R: 'f;
 
-    fn call<'a>(&'a self, request: R, ctx: ServiceCtx<'a, Self>) -> Self::Future<'a> {
+    async fn call(
+        &self,
+        request: R,
+        ctx: ServiceCtx<'_, Self>,
+    ) -> Result<Self::Response, Self::Error> {
         if self.timeout.is_zero() {
-            Either::Right(TimeoutServiceResponse2 {
-                fut: ctx.call(&self.service, request),
-                _t: marker::PhantomData,
-            })
+            ctx.call(&self.service, request)
+                .await
+                .map_err(TimeoutError::Service)
         } else {
-            Either::Left(TimeoutServiceResponse {
-                fut: ctx.call(&self.service, request),
-                sleep: sleep(self.timeout),
-                _t: marker::PhantomData,
-            })
+            match select(sleep(self.timeout), ctx.call(&self.service, request)).await {
+                Either::Left(_) => Err(TimeoutError::Timeout),
+                Either::Right(res) => res.map_err(TimeoutError::Service),
+            }
         }
     }
 
@@ -144,72 +145,6 @@ where
     ntex_service::forward_poll_shutdown!(service);
 }
 
-pin_project_lite::pin_project! {
-    /// `TimeoutService` response future
-    #[doc(hidden)]
-    #[must_use = "futures do nothing unless polled"]
-    pub struct TimeoutServiceResponse<'f, T: Service<R>, R>
-    where T: 'f, R: 'f,
-    {
-        #[pin]
-        fut: ServiceCall<'f, T, R>,
-        sleep: Sleep,
-        _t: marker::PhantomData<R>
-    }
-}
-
-impl<'f, T, R> Future for TimeoutServiceResponse<'f, T, R>
-where
-    T: Service<R>,
-{
-    type Output = Result<T::Response, TimeoutError<T::Error>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        // First, try polling the future
-        match this.fut.poll(cx) {
-            Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)),
-            Poll::Ready(Err(e)) => return Poll::Ready(Err(TimeoutError::Service(e))),
-            Poll::Pending => {}
-        }
-
-        // Now check the sleep
-        match this.sleep.poll_elapsed(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(_) => Poll::Ready(Err(TimeoutError::Timeout)),
-        }
-    }
-}
-
-pin_project_lite::pin_project! {
-    /// `TimeoutService` response future
-    #[doc(hidden)]
-    #[must_use = "futures do nothing unless polled"]
-    pub struct TimeoutServiceResponse2<'f, T: Service<R>, R>
-    where T: 'f, R: 'f,
-    {
-        #[pin]
-        fut: ServiceCall<'f, T, R>,
-        _t: marker::PhantomData<R>,
-    }
-}
-
-impl<'f, T, R> Future for TimeoutServiceResponse2<'f, T, R>
-where
-    T: Service<R>,
-{
-    type Output = Result<T::Response, TimeoutError<T::Error>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.project().fut.poll(cx) {
-            Poll::Ready(Ok(v)) => Poll::Ready(Ok(v)),
-            Poll::Ready(Err(e)) => Poll::Ready(Err(TimeoutError::Service(e))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::{fmt, time::Duration};
@@ -217,7 +152,7 @@ mod tests {
     use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceFactory};
 
     use super::*;
-    use crate::future::{lazy, BoxFuture};
+    use crate::future::lazy;
 
     #[derive(Clone, Debug, PartialEq)]
     struct SleepService(Duration);
@@ -234,14 +169,14 @@ mod tests {
     impl Service<()> for SleepService {
         type Response = ();
         type Error = SrvError;
-        type Future<'f> = BoxFuture<'f, Result<(), SrvError>>;
 
-        fn call<'a>(&'a self, _: (), _: ServiceCtx<'a, Self>) -> Self::Future<'a> {
-            let fut = crate::time::sleep(self.0);
-            Box::pin(async move {
-                fut.await;
-                Ok::<_, SrvError>(())
-            })
+        async fn call<'a>(
+            &'a self,
+            _: (),
+            _: ServiceCtx<'a, Self>,
+        ) -> Result<(), SrvError> {
+            crate::time::sleep(self.0).await;
+            Ok::<_, SrvError>(())
         }
     }