migrate actix-web to std::future

src/resource.rs

@@ -1,14 +1,17 @@
 use std::cell::RefCell;
 use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
 use std::rc::Rc;
+use std::task::{Context, Poll};
 
 use actix_http::{Error, Extensions, Response};
 use actix_service::boxed::{self, BoxedNewService, BoxedService};
 use actix_service::{
-    apply_transform, IntoNewService, IntoTransform, NewService, Service, Transform,
+    apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
 };
-use futures::future::{ok, Either, FutureResult};
-use futures::{Async, Future, IntoFuture, Poll};
+use futures::future::{ok, Either, LocalBoxFuture, Ready};
+use pin_project::pin_project;
 
 use crate::data::Data;
 use crate::dev::{insert_slash, AppService, HttpServiceFactory, ResourceDef};
@@ -74,7 +77,7 @@ impl Resource {
 
 impl<T> Resource<T>
 where
-    T: NewService<
+    T: ServiceFactory<
         Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
@@ -243,8 +246,8 @@ where
     /// use actix_web::*;
     /// use futures::future::{ok, Future};
     ///
-    /// fn index(req: HttpRequest) -> impl Future<Item=HttpResponse, Error=Error> {
-    ///     ok(HttpResponse::Ok().finish())
+    /// async fn index(req: HttpRequest) -> Result<HttpResponse, Error> {
+    ///     Ok(HttpResponse::Ok().finish())
     /// }
     ///
     /// App::new().service(web::resource("/").to_async(index));
@@ -255,19 +258,19 @@ where
     /// ```rust
     /// # use actix_web::*;
     /// # use futures::future::Future;
-    /// # fn index(req: HttpRequest) -> Box<dyn Future<Item=HttpResponse, Error=Error>> {
+    /// # async fn index(req: HttpRequest) -> Result<HttpResponse, Error> {
     /// #     unimplemented!()
     /// # }
     /// App::new().service(web::resource("/").route(web::route().to_async(index)));
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    pub fn to_async<F, I, R>(mut self, handler: F) -> Self
+    pub fn to_async<F, I, R, O, E>(mut self, handler: F) -> Self
     where
-        F: AsyncFactory<I, R>,
+        F: AsyncFactory<I, R, O, E>,
         I: FromRequest + 'static,
-        R: IntoFuture + 'static,
-        R::Item: Responder,
-        R::Error: Into<Error>,
+        R: Future<Output = Result<O, E>> + 'static,
+        O: Responder + 'static,
+        E: Into<Error> + 'static,
     {
         self.routes.push(Route::new().to_async(handler));
         self
@@ -280,11 +283,11 @@ where
     /// type (i.e modify response's body).
     ///
     /// **Note**: middlewares get called in opposite order of middlewares registration.
-    pub fn wrap<M, F>(
+    pub fn wrap<M>(
         self,
-        mw: F,
+        mw: M,
     ) -> Resource<
-        impl NewService<
+        impl ServiceFactory<
             Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
@@ -300,11 +303,9 @@ where
             Error = Error,
             InitError = (),
         >,
-        F: IntoTransform<M, T::Service>,
     {
-        let endpoint = apply_transform(mw, self.endpoint);
         Resource {
-            endpoint,
+            endpoint: apply(mw, self.endpoint),
             rdef: self.rdef,
             name: self.name,
             guards: self.guards,
@@ -337,13 +338,16 @@ where
     /// fn main() {
     ///     let app = App::new().service(
     ///         web::resource("/index.html")
-    ///             .wrap_fn(|req, srv|
-    ///                 srv.call(req).map(|mut res| {
+    ///             .wrap_fn(|req, srv| {
+    ///                 let fut = srv.call(req);
+    ///                 async {
+    ///                     let mut res = fut.await?;
     ///                     res.headers_mut().insert(
     ///                        CONTENT_TYPE, HeaderValue::from_static("text/plain"),
     ///                     );
-    ///                     res
-    ///                 }))
+    ///                     Ok(res)
+    ///                 }
+    ///             })
     ///             .route(web::get().to(index)));
     /// }
     /// ```
@@ -351,7 +355,7 @@ where
         self,
         mw: F,
     ) -> Resource<
-        impl NewService<
+        impl ServiceFactory<
             Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
@@ -361,9 +365,18 @@ where
     >
     where
         F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
-        R: IntoFuture<Item = ServiceResponse, Error = Error>,
+        R: Future<Output = Result<ServiceResponse, Error>>,
     {
-        self.wrap(mw)
+        Resource {
+            endpoint: apply_fn_factory(self.endpoint, mw),
+            rdef: self.rdef,
+            name: self.name,
+            guards: self.guards,
+            routes: self.routes,
+            default: self.default,
+            data: self.data,
+            factory_ref: self.factory_ref,
+        }
     }
 
     /// Default service to be used if no matching route could be found.
@@ -371,8 +384,8 @@ where
     /// default handler from `App` or `Scope`.
     pub fn default_service<F, U>(mut self, f: F) -> Self
     where
-        F: IntoNewService<U>,
-        U: NewService<
+        F: IntoServiceFactory<U>,
+        U: ServiceFactory<
                 Config = (),
                 Request = ServiceRequest,
                 Response = ServiceResponse,
@@ -381,8 +394,8 @@ where
         U::InitError: fmt::Debug,
     {
         // create and configure default resource
-        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::new_service(
-            f.into_new_service().map_init_err(|e| {
+        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
+            f.into_factory().map_init_err(|e| {
                 log::error!("Can not construct default service: {:?}", e)
             }),
         )))));
@@ -393,7 +406,7 @@ where
 
 impl<T> HttpServiceFactory for Resource<T>
 where
-    T: NewService<
+    T: ServiceFactory<
             Config = (),
             Request = ServiceRequest,
             Response = ServiceResponse,
@@ -423,9 +436,9 @@ where
     }
 }
 
-impl<T> IntoNewService<T> for Resource<T>
+impl<T> IntoServiceFactory<T> for Resource<T>
 where
-    T: NewService<
+    T: ServiceFactory<
         Config = (),
         Request = ServiceRequest,
         Response = ServiceResponse,
@@ -433,7 +446,7 @@ where
         InitError = (),
     >,
 {
-    fn into_new_service(self) -> T {
+    fn into_factory(self) -> T {
         *self.factory_ref.borrow_mut() = Some(ResourceFactory {
             routes: self.routes,
             data: self.data.map(Rc::new),
@@ -450,7 +463,7 @@ pub struct ResourceFactory {
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }
 
-impl NewService for ResourceFactory {
+impl ServiceFactory for ResourceFactory {
     type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
@@ -488,31 +501,30 @@ pub struct CreateResourceService {
     fut: Vec<CreateRouteServiceItem>,
     data: Option<Rc<Extensions>>,
     default: Option<HttpService>,
-    default_fut: Option<Box<dyn Future<Item = HttpService, Error = ()>>>,
+    default_fut: Option<LocalBoxFuture<'static, Result<HttpService, ()>>>,
 }
 
 impl Future for CreateResourceService {
-    type Item = ResourceService;
-    type Error = ();
+    type Output = Result<ResourceService, ()>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let mut done = true;
 
         if let Some(ref mut fut) = self.default_fut {
-            match fut.poll()? {
-                Async::Ready(default) => self.default = Some(default),
-                Async::NotReady => done = false,
+            match Pin::new(fut).poll(cx)? {
+                Poll::Ready(default) => self.default = Some(default),
+                Poll::Pending => done = false,
             }
         }
 
         // poll http services
         for item in &mut self.fut {
             match item {
-                CreateRouteServiceItem::Future(ref mut fut) => match fut.poll()? {
-                    Async::Ready(route) => {
-                        *item = CreateRouteServiceItem::Service(route)
-                    }
-                    Async::NotReady => {
+                CreateRouteServiceItem::Future(ref mut fut) => match Pin::new(fut)
+                    .poll(cx)?
+                {
+                    Poll::Ready(route) => *item = CreateRouteServiceItem::Service(route),
+                    Poll::Pending => {
                         done = false;
                     }
                 },
@@ -529,13 +541,13 @@ impl Future for CreateResourceService {
                     CreateRouteServiceItem::Future(_) => unreachable!(),
                 })
                 .collect();
-            Ok(Async::Ready(ResourceService {
+            Poll::Ready(Ok(ResourceService {
                 routes,
                 data: self.data.clone(),
                 default: self.default.take(),
             }))
         } else {
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
 }
@@ -551,12 +563,12 @@ impl Service for ResourceService {
     type Response = ServiceResponse;
     type Error = Error;
     type Future = Either<
-        FutureResult<ServiceResponse, Error>,
-        Box<dyn Future<Item = ServiceResponse, Error = Error>>,
+        Ready<Result<ServiceResponse, Error>>,
+        LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
     >;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
     }
 
     fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
@@ -565,14 +577,14 @@ impl Service for ResourceService {
                 if let Some(ref data) = self.data {
                     req.set_data_container(data.clone());
                 }
-                return route.call(req);
+                return Either::Right(route.call(req));
             }
         }
         if let Some(ref mut default) = self.default {
-            default.call(req)
+            Either::Right(default.call(req))
         } else {
             let req = req.into_parts().0;
-            Either::A(ok(ServiceResponse::new(
+            Either::Left(ok(ServiceResponse::new(
                 req,
                 Response::MethodNotAllowed().finish(),
             )))
@@ -591,7 +603,7 @@ impl ResourceEndpoint {
     }
 }
 
-impl NewService for ResourceEndpoint {
+impl ServiceFactory for ResourceEndpoint {
     type Config = ();
     type Request = ServiceRequest;
     type Response = ServiceResponse;
@@ -610,18 +622,19 @@ mod tests {
     use std::time::Duration;
 
     use actix_service::Service;
-    use futures::{Future, IntoFuture};
-    use tokio_timer::sleep;
+    use futures::future::{ok, Future};
+    use tokio_timer::delay_for;
 
     use crate::http::{header, HeaderValue, Method, StatusCode};
+    use crate::middleware::DefaultHeaders;
     use crate::service::{ServiceRequest, ServiceResponse};
-    use crate::test::{call_service, init_service, TestRequest};
+    use crate::test::{block_on, call_service, init_service, TestRequest};
     use crate::{guard, web, App, Error, HttpResponse};
 
     fn md<S, B>(
         req: ServiceRequest,
         srv: &mut S,
-    ) -> impl IntoFuture<Item = ServiceResponse<B>, Error = Error>
+    ) -> impl Future<Output = Result<ServiceResponse<B>, Error>>
     where
         S: Service<
             Request = ServiceRequest,
@@ -629,178 +642,210 @@ mod tests {
             Error = Error,
         >,
     {
-        srv.call(req).map(|mut res| {
+        let fut = srv.call(req);
+        async move {
+            let mut res = fut.await?;
             res.headers_mut()
                 .insert(header::CONTENT_TYPE, HeaderValue::from_static("0001"));
-            res
-        })
+            Ok(res)
+        }
     }
 
     #[test]
     fn test_middleware() {
-        let mut srv = init_service(
-            App::new().service(
-                web::resource("/test")
-                    .name("test")
-                    .wrap(md)
-                    .route(web::get().to(|| HttpResponse::Ok())),
-            ),
-        );
-        let req = TestRequest::with_uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            HeaderValue::from_static("0001")
-        );
+        block_on(async {
+            let mut srv = init_service(
+                App::new().service(
+                    web::resource("/test")
+                        .name("test")
+                        .wrap(DefaultHeaders::new().header(
+                            header::CONTENT_TYPE,
+                            HeaderValue::from_static("0001"),
+                        ))
+                        .route(web::get().to(|| HttpResponse::Ok())),
+                ),
+            )
+            .await;
+            let req = TestRequest::with_uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+            assert_eq!(
+                resp.headers().get(header::CONTENT_TYPE).unwrap(),
+                HeaderValue::from_static("0001")
+            );
+        })
     }
 
     #[test]
     fn test_middleware_fn() {
-        let mut srv = init_service(
-            App::new().service(
-                web::resource("/test")
-                    .wrap_fn(|req, srv| {
-                        srv.call(req).map(|mut res| {
-                            res.headers_mut().insert(
-                                header::CONTENT_TYPE,
-                                HeaderValue::from_static("0001"),
-                            );
-                            res
+        block_on(async {
+            let mut srv = init_service(
+                App::new().service(
+                    web::resource("/test")
+                        .wrap_fn(|req, srv| {
+                            let fut = srv.call(req);
+                            async {
+                                fut.await.map(|mut res| {
+                                    res.headers_mut().insert(
+                                        header::CONTENT_TYPE,
+                                        HeaderValue::from_static("0001"),
+                                    );
+                                    res
+                                })
+                            }
                         })
-                    })
-                    .route(web::get().to(|| HttpResponse::Ok())),
-            ),
-        );
-        let req = TestRequest::with_uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            HeaderValue::from_static("0001")
-        );
+                        .route(web::get().to(|| HttpResponse::Ok())),
+                ),
+            )
+            .await;
+            let req = TestRequest::with_uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+            assert_eq!(
+                resp.headers().get(header::CONTENT_TYPE).unwrap(),
+                HeaderValue::from_static("0001")
+            );
+        })
     }
 
     #[test]
     fn test_to_async() {
-        let mut srv =
-            init_service(App::new().service(web::resource("/test").to_async(|| {
-                sleep(Duration::from_millis(100)).then(|_| HttpResponse::Ok())
-            })));
-        let req = TestRequest::with_uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
+        block_on(async {
+            let mut srv = init_service(App::new().service(
+                web::resource("/test").to_async(|| {
+                    async {
+                        delay_for(Duration::from_millis(100)).await;
+                        Ok::<_, Error>(HttpResponse::Ok())
+                    }
+                }),
+            ))
+            .await;
+            let req = TestRequest::with_uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+        })
     }
 
     #[test]
     fn test_default_resource() {
-        let mut srv = init_service(
-            App::new()
-                .service(
-                    web::resource("/test").route(web::get().to(|| HttpResponse::Ok())),
-                )
-                .default_service(|r: ServiceRequest| {
-                    r.into_response(HttpResponse::BadRequest())
-                }),
-        );
-        let req = TestRequest::with_uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
-
-        let req = TestRequest::with_uri("/test")
-            .method(Method::POST)
-            .to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-
-        let mut srv = init_service(
-            App::new().service(
-                web::resource("/test")
-                    .route(web::get().to(|| HttpResponse::Ok()))
+        block_on(async {
+            let mut srv = init_service(
+                App::new()
+                    .service(
+                        web::resource("/test")
+                            .route(web::get().to(|| HttpResponse::Ok())),
+                    )
                     .default_service(|r: ServiceRequest| {
-                        r.into_response(HttpResponse::BadRequest())
+                        ok(r.into_response(HttpResponse::BadRequest()))
                     }),
-            ),
-        );
+            )
+            .await;
+            let req = TestRequest::with_uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
 
-        let req = TestRequest::with_uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
+            let req = TestRequest::with_uri("/test")
+                .method(Method::POST)
+                .to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
 
-        let req = TestRequest::with_uri("/test")
-            .method(Method::POST)
-            .to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+            let mut srv = init_service(
+                App::new().service(
+                    web::resource("/test")
+                        .route(web::get().to(|| HttpResponse::Ok()))
+                        .default_service(|r: ServiceRequest| {
+                            ok(r.into_response(HttpResponse::BadRequest()))
+                        }),
+                ),
+            )
+            .await;
+
+            let req = TestRequest::with_uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+
+            let req = TestRequest::with_uri("/test")
+                .method(Method::POST)
+                .to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+        })
     }
 
     #[test]
     fn test_resource_guards() {
-        let mut srv = init_service(
-            App::new()
-                .service(
-                    web::resource("/test/{p}")
-                        .guard(guard::Get())
-                        .to(|| HttpResponse::Ok()),
-                )
-                .service(
-                    web::resource("/test/{p}")
-                        .guard(guard::Put())
-                        .to(|| HttpResponse::Created()),
-                )
-                .service(
-                    web::resource("/test/{p}")
-                        .guard(guard::Delete())
-                        .to(|| HttpResponse::NoContent()),
-                ),
-        );
+        block_on(async {
+            let mut srv = init_service(
+                App::new()
+                    .service(
+                        web::resource("/test/{p}")
+                            .guard(guard::Get())
+                            .to(|| HttpResponse::Ok()),
+                    )
+                    .service(
+                        web::resource("/test/{p}")
+                            .guard(guard::Put())
+                            .to(|| HttpResponse::Created()),
+                    )
+                    .service(
+                        web::resource("/test/{p}")
+                            .guard(guard::Delete())
+                            .to(|| HttpResponse::NoContent()),
+                    ),
+            )
+            .await;
 
-        let req = TestRequest::with_uri("/test/it")
-            .method(Method::GET)
-            .to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
+            let req = TestRequest::with_uri("/test/it")
+                .method(Method::GET)
+                .to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
 
-        let req = TestRequest::with_uri("/test/it")
-            .method(Method::PUT)
-            .to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::CREATED);
+            let req = TestRequest::with_uri("/test/it")
+                .method(Method::PUT)
+                .to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::CREATED);
 
-        let req = TestRequest::with_uri("/test/it")
-            .method(Method::DELETE)
-            .to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::NO_CONTENT);
+            let req = TestRequest::with_uri("/test/it")
+                .method(Method::DELETE)
+                .to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::NO_CONTENT);
+        })
     }
 
     #[test]
     fn test_data() {
-        let mut srv = init_service(
-            App::new()
-                .data(1.0f64)
-                .data(1usize)
-                .register_data(web::Data::new('-'))
-                .service(
-                    web::resource("/test")
-                        .data(10usize)
-                        .register_data(web::Data::new('*'))
-                        .guard(guard::Get())
-                        .to(
-                            |data1: web::Data<usize>,
-                             data2: web::Data<char>,
-                             data3: web::Data<f64>| {
-                                assert_eq!(*data1, 10);
-                                assert_eq!(*data2, '*');
-                                assert_eq!(*data3, 1.0);
-                                HttpResponse::Ok()
-                            },
-                        ),
-                ),
-        );
+        block_on(async {
+            let mut srv = init_service(
+                App::new()
+                    .data(1.0f64)
+                    .data(1usize)
+                    .register_data(web::Data::new('-'))
+                    .service(
+                        web::resource("/test")
+                            .data(10usize)
+                            .register_data(web::Data::new('*'))
+                            .guard(guard::Get())
+                            .to(
+                                |data1: web::Data<usize>,
+                                 data2: web::Data<char>,
+                                 data3: web::Data<f64>| {
+                                    assert_eq!(*data1, 10);
+                                    assert_eq!(*data2, '*');
+                                    assert_eq!(*data3, 1.0);
+                                    HttpResponse::Ok()
+                                },
+                            ),
+                    ),
+            )
+            .await;
 
-        let req = TestRequest::get().uri("/test").to_request();
-        let resp = call_service(&mut srv, req);
-        assert_eq!(resp.status(), StatusCode::OK);
+            let req = TestRequest::get().uri("/test").to_request();
+            let resp = call_service(&mut srv, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+        })
     }
 }