Use async fn for Responder and Handler traits (#283)

ntex-service/src/middleware.rs

@@ -27,23 +27,21 @@ where
 ///     timeout: Duration,
 /// }
 ///
-/// impl<S> Service for Timeout<S>
+/// impl<S, R> Service<R> for Timeout<S>
 /// where
-///     S: Service,
+///     S: Service<R>,
 /// {
-///     type Request = S::Request;
 ///     type Response = S::Response;
 ///     type Error = TimeoutError<S::Error>;
-///     type Future = TimeoutResponse<S>;
 ///
 ///     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-///         ready!(self.service.poll_ready(cx)).map_err(TimeoutError::Service)
+///         self.service.poll_ready(cx).map_err(TimeoutError::Service)
 ///     }
 ///
-///     fn call(&self, req: S::Request) -> Self::Future {
-///         TimeoutServiceResponse {
-///             fut: self.service.call(req),
-///             sleep: Delay::new(clock::now() + self.timeout),
+///     async fn call(&self, req: S::Request) -> Result<Self::Response, Self::Error> {
+///         match select(sleep(self.timeout), ctx.call(&self.service, req)).await {
+///             Either::Left(_) => Err(TimeoutError::Timeout),
+///             Either::Right(res) => res.map_err(TimeoutError::Service),
 ///         }
 ///     }
 /// }
@@ -65,8 +63,6 @@ where
 /// }
 ///
 /// impl<S> Middleware<S> for TimeoutMiddleware<E>
-/// where
-///     S: Service,
 /// {
 ///     type Service = Timeout<S>;
 ///

ntex/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.0.0] - 2024-01-09
+
+* web: Use async fn for Responder and Handler traits
+
 ## [1.0.0-b.1] - 2024-01-08
 
 * web: Refactor FromRequest trait, use async fn

ntex/src/web/handler.rs

@@ -14,11 +14,8 @@ where
     Err: ErrorRenderer,
 {
     type Output: Responder<Err>;
-    type Future<'f>: Future<Output = Self::Output>
-    where
-        Self: 'f;
 
-    fn call(&self, param: T) -> Self::Future<'_>;
+    fn call(&self, param: T) -> impl Future<Output = Self::Output>;
 }
 
 impl<F, R, Err> Handler<(), Err> for F
@@ -28,11 +25,10 @@ where
     R::Output: Responder<Err>,
     Err: ErrorRenderer,
 {
-    type Future<'f> = R where Self: 'f;
     type Output = R::Output;
 
-    fn call(&self, _: ()) -> R {
-        (self)()
+    async fn call(&self, _: ()) -> R::Output {
+        (self)().await
     }
 }
 
@@ -96,11 +92,10 @@ macro_rules! factory_tuple ({ $(($n:tt, $T:ident)),+} => {
           Res::Output: Responder<Err>,
           Err: ErrorRenderer,
     {
-        type Future<'f> = Res where Self: 'f;
         type Output = Res::Output;
 
-        fn call(&self, param: ($($T,)+)) -> Res {
-            (self)($(param.$n,)+)
+        async fn call(&self, param: ($($T,)+)) -> Self::Output {
+            (self)($(param.$n,)+).await
         }
     }
 });

ntex/src/web/mod.rs

@@ -155,11 +155,11 @@ pub mod dev {
     #[inline(always)]
     pub fn __assert_handler<Err, Fun, Fut>(
         f: Fun,
-    ) -> impl for<'r> Handler<(), Err, Future<'r> = Fut, Output = Fut::Output>
+    ) -> impl Handler<(), Err, Output = Fut::Output>
     where
         Err: super::ErrorRenderer,
         Fun: Fn() -> Fut + 'static,
-        Fut: std::future::Future + 'static,
+        Fut: std::future::Future,
         Fut::Output: super::Responder<Err>,
     {
         f
@@ -170,12 +170,12 @@ pub mod dev {
         #[inline(always)]
         pub fn $name<Err, Fun, Fut, $($T,)+>(
             f: Fun,
-        ) -> impl for<'r> Handler<($($T,)+), Err, Future<'r> = Fut, Output = Fut::Output>
+        ) -> impl Handler<($($T,)+), Err, Output = Fut::Output>
         where
             Err: $crate::web::ErrorRenderer,
             Fun: Fn($($T,)+) -> Fut + 'static,
             Fut: std::future::Future + 'static,
-            Fut::Output: $crate::web::Responder<Err>,
+            Fut::Output: super::Responder<Err>,
         $($T: $crate::web::FromRequest<Err>),+,
         {
             f

ntex/src/web/responder.rs

@@ -1,5 +1,4 @@
-use std::task::{Context, Poll};
-use std::{future::Future, marker::PhantomData, pin::Pin};
+use std::{future::Future, marker::PhantomData};
 
 use crate::http::error::HttpError;
 use crate::http::header::{HeaderMap, HeaderName, HeaderValue};
@@ -11,34 +10,12 @@ use super::error::{
 };
 use super::httprequest::HttpRequest;
 
-pub struct Ready<T>(Option<T>);
-
-impl<T> Unpin for Ready<T> {}
-
-impl<T> From<T> for Ready<T> {
-    fn from(t: T) -> Self {
-        Ready(Some(t))
-    }
-}
-
-impl<T> Future for Ready<T> {
-    type Output = T;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<T> {
-        Poll::Ready(self.0.take().expect("Ready polled after completion"))
-    }
-}
-
 /// Trait implemented by types that can be converted to a http response.
 ///
 /// Types that implement this trait can be used as the return type of a handler.
 pub trait Responder<Err = DefaultError> {
-    /// The future response value.
-    type Future: Future<Output = Response>;
-
-    /// Convert itself to `AsyncResult` or `Error`.
-    fn respond_to(self, req: &HttpRequest) -> Self::Future;
+    /// Convert itself to http response.
+    fn respond_to(self, req: &HttpRequest) -> impl Future<Output = Response>;
 
     /// Override a status code for a Responder.
     ///
@@ -90,20 +67,16 @@ pub trait Responder<Err = DefaultError> {
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for Response {
-    type Future = Ready<Response>;
-
     #[inline]
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(self))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        self
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for ResponseBuilder {
-    type Future = Ready<Response>;
-
     #[inline]
-    fn respond_to(mut self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(self.finish()))
+    async fn respond_to(mut self, _: &HttpRequest) -> Response {
+        self.finish()
     }
 }
 
@@ -112,14 +85,10 @@ where
     T: Responder<Err>,
     Err: ErrorRenderer,
 {
-    type Future = Either<T::Future, Ready<Response>>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+    async fn respond_to(self, req: &HttpRequest) -> Response {
         match self {
-            Some(t) => Either::Left(t.respond_to(req)),
-            None => {
-                Either::Right(Ready(Some(Response::build(StatusCode::NOT_FOUND).finish())))
-            }
+            Some(t) => t.respond_to(req).await,
+            None => Response::build(StatusCode::NOT_FOUND).finish(),
         }
     }
 }
@@ -130,12 +99,10 @@ where
     E: Into<Err::Container>,
     Err: ErrorRenderer,
 {
-    type Future = Either<T::Future, Ready<Response>>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+    async fn respond_to(self, req: &HttpRequest) -> Response {
         match self {
-            Ok(val) => Either::Left(val.respond_to(req)),
-            Err(e) => Either::Right(Ready(Some(e.into().error_response(req)))),
+            Ok(val) => val.respond_to(req).await,
+            Err(e) => e.into().error_response(req),
         }
     }
 }
@@ -145,86 +112,58 @@ where
     T: Responder<Err>,
     Err: ErrorRenderer,
 {
-    type Future = CustomResponderFut<T, Err>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        CustomResponderFut {
-            fut: self.0.respond_to(req),
-            status: Some(self.1),
-            headers: None,
-        }
+    async fn respond_to(self, req: &HttpRequest) -> Response {
+        let mut res = self.0.respond_to(req).await;
+        *res.status_mut() = self.1;
+        res
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for &'static str {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("text/plain; charset=utf-8")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("text/plain; charset=utf-8")
+            .body(self)
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for &'static [u8] {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("application/octet-stream")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("application/octet-stream")
+            .body(self)
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for String {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("text/plain; charset=utf-8")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("text/plain; charset=utf-8")
+            .body(self)
     }
 }
 
 impl<'a, Err: ErrorRenderer> Responder<Err> for &'a String {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("text/plain; charset=utf-8")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("text/plain; charset=utf-8")
+            .body(self)
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for Bytes {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("application/octet-stream")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("application/octet-stream")
+            .body(self)
     }
 }
 
 impl<Err: ErrorRenderer> Responder<Err> for BytesMut {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        Ready(Some(
-            Response::build(StatusCode::OK)
-                .content_type("application/octet-stream")
-                .body(self),
-        ))
+    async fn respond_to(self, _: &HttpRequest) -> Response {
+        Response::build(StatusCode::OK)
+            .content_type("application/octet-stream")
+            .body(self)
     }
 }
 
@@ -308,47 +247,18 @@ impl<T: Responder<Err>, Err> CustomResponder<T, Err> {
 }
 
 impl<T: Responder<Err>, Err: ErrorRenderer> Responder<Err> for CustomResponder<T, Err> {
-    type Future = CustomResponderFut<T, Err>;
+    async fn respond_to(self, req: &HttpRequest) -> Response {
+        let mut res = self.responder.respond_to(req).await;
 
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        CustomResponderFut {
-            fut: self.responder.respond_to(req),
-            status: self.status,
-            headers: self.headers,
-        }
-    }
-}
-
-pin_project_lite::pin_project! {
-    pub struct CustomResponderFut<T: Responder<Err>, Err: ErrorRenderer> {
-        #[pin]
-        fut: T::Future,
-        status: Option<StatusCode>,
-        headers: Option<HeaderMap>,
-    }
-}
-
-impl<T: Responder<Err>, Err: ErrorRenderer> Future for CustomResponderFut<T, Err> {
-    type Output = Response;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        let mut res = if let Poll::Ready(res) = this.fut.poll(cx) {
-            res
-        } else {
-            return Poll::Pending;
-        };
-
-        if let Some(status) = this.status.take() {
+        if let Some(status) = self.status {
             *res.status_mut() = status;
         }
-        if let Some(ref headers) = this.headers {
+        if let Some(ref headers) = self.headers {
             for (k, v) in headers {
                 res.headers_mut().insert(k.clone(), v.clone());
             }
         }
-        Poll::Ready(res)
+        res
     }
 }
 
@@ -375,12 +285,10 @@ where
     B: Responder<Err>,
     Err: ErrorRenderer,
 {
-    type Future = Either<A::Future, B::Future>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+    async fn respond_to(self, req: &HttpRequest) -> Response {
         match self {
-            Either::Left(a) => Either::Left(a.respond_to(req)),
-            Either::Right(b) => Either::Right(b.respond_to(req)),
+            Either::Left(a) => a.respond_to(req).await,
+            Either::Right(b) => b.respond_to(req).await,
         }
     }
 }
@@ -390,10 +298,8 @@ where
     T: std::fmt::Debug + std::fmt::Display + 'static,
     Err: ErrorRenderer,
 {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        Ready(Some(self.error_response(req)))
+    async fn respond_to(self, req: &HttpRequest) -> Response {
+        self.error_response(req)
     }
 }
 

ntex/src/web/types/form.rs

@@ -10,8 +10,7 @@ use crate::http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use crate::http::{HttpMessage, Payload, Response, StatusCode};
 use crate::util::{stream_recv, BoxFuture, BytesMut};
 use crate::web::error::{ErrorRenderer, UrlencodedError, WebResponseError};
-use crate::web::responder::{Ready, Responder};
-use crate::web::{FromRequest, HttpRequest};
+use crate::web::{FromRequest, HttpRequest, Responder};
 
 /// Form data helper (`application/x-www-form-urlencoded`)
 ///
@@ -134,18 +133,15 @@ impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Form<T>
 where
     Err::Container: From<serde_urlencoded::ser::Error>,
 {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+    async fn respond_to(self, req: &HttpRequest) -> Response {
         let body = match serde_urlencoded::to_string(&self.0) {
             Ok(body) => body,
-            Err(e) => return e.error_response(req).into(),
+            Err(e) => return e.error_response(req),
         };
 
         Response::build(StatusCode::OK)
             .header(CONTENT_TYPE, "application/x-www-form-urlencoded")
             .body(body)
-            .into()
     }
 }
 

ntex/src/web/types/json.rs

@@ -9,8 +9,7 @@ use crate::http::header::CONTENT_LENGTH;
 use crate::http::{HttpMessage, Payload, Response, StatusCode};
 use crate::util::{stream_recv, BoxFuture, BytesMut};
 use crate::web::error::{ErrorRenderer, JsonError, JsonPayloadError, WebResponseError};
-use crate::web::responder::{Ready, Responder};
-use crate::web::{FromRequest, HttpRequest};
+use crate::web::{FromRequest, HttpRequest, Responder};
 
 /// Json helper
 ///
@@ -112,18 +111,15 @@ impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Json<T>
 where
     Err::Container: From<JsonError>,
 {
-    type Future = Ready<Response>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
+    async fn respond_to(self, req: &HttpRequest) -> Response {
         let body = match serde_json::to_string(&self.0) {
             Ok(body) => body,
-            Err(e) => return e.error_response(req).into(),
+            Err(e) => return e.error_response(req),
         };
 
         Response::build(StatusCode::OK)
             .content_type("application/json")
             .body(body)
-            .into()
     }
 }