update examples to v4 (#258)

examples/middleware/Cargo.toml

@@ -4,8 +4,7 @@ version = "1.0.0"
 edition = "2018"
 
 [dependencies]
-actix-web = "3"
-actix-service = "1"
-actix-session = "0.4"
-futures = "0.3"
+actix-web = "4"
+actix-session = "0.5.0-beta.8"
+futures-util = { version = "0.3.7", default-features = false, features = ["std"] }
 env_logger = "0.7"

examples/middleware/src/default_headers.rs

@@ -1,23 +1,18 @@
 // <default-headers>
-use actix_web::{http, middleware, HttpResponse};
+use actix_web::{http::Method, middleware, web, App, HttpResponse, HttpServer};
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    use actix_web::{web, App, HttpServer};
-
     HttpServer::new(|| {
         App::new()
-            .wrap(middleware::DefaultHeaders::new().header("X-Version", "0.2"))
+            .wrap(middleware::DefaultHeaders::new().add(("X-Version", "0.2")))
             .service(
                 web::resource("/test")
-                    .route(web::get().to(|| HttpResponse::Ok()))
-                    .route(
-                        web::method(http::Method::HEAD)
-                            .to(|| HttpResponse::MethodNotAllowed()),
-                    ),
+                    .route(web::get().to(HttpResponse::Ok))
+                    .route(web::method(Method::HEAD).to(HttpResponse::MethodNotAllowed)),
             )
     })
-    .bind("127.0.0.1:8080")?
+    .bind(("127.0.0.1", 8080))?
     .run()
     .await
 }

examples/middleware/src/errorhandler.rs

@@ -1,31 +1,33 @@
 #![allow(dead_code)]
 
 // <error-handler>
-use actix_web::middleware::errhandlers::{ErrorHandlerResponse, ErrorHandlers};
-use actix_web::{dev, http, web, App, HttpResponse, HttpServer, Result};
+use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers};
+use actix_web::{
+    dev,
+    http::{header, StatusCode},
+    web, App, HttpResponse, HttpServer, Result,
+};
 
 fn add_error_header<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
     res.response_mut().headers_mut().insert(
-        http::header::CONTENT_TYPE,
-        http::HeaderValue::from_static("Error"),
+        header::CONTENT_TYPE,
+        header::HeaderValue::from_static("Error"),
     );
-    Ok(ErrorHandlerResponse::Response(res))
+
+    Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
 }
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     HttpServer::new(|| {
         App::new()
-            .wrap(ErrorHandlers::new().handler(
-                http::StatusCode::INTERNAL_SERVER_ERROR,
-                add_error_header,
-            ))
-            .service(
-                web::resource("/")
-                    .route(web::get().to(HttpResponse::InternalServerError)),
+            .wrap(
+                ErrorHandlers::new()
+                    .handler(StatusCode::INTERNAL_SERVER_ERROR, add_error_header),
             )
+            .service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)))
     })
-    .bind("127.0.0.1:8080")?
+    .bind(("127.0.0.1", 8080))?
     .run()
     .await
 }

examples/middleware/src/logger.rs

@@ -13,7 +13,7 @@ async fn main() -> std::io::Result<()> {
             .wrap(Logger::default())
             .wrap(Logger::new("%a %{User-Agent}i"))
     })
-    .bind("127.0.0.1:8080")?
+    .bind(("127.0.0.1", 8080))?
     .run()
     .await
 }

examples/middleware/src/main.rs

@@ -5,13 +5,13 @@ pub mod user_sessions;
 pub mod wrap_fn;
 
 // <simple>
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::future::{ready, Ready};
 
-use actix_service::{Service, Transform};
-use actix_web::{dev::ServiceRequest, dev::ServiceResponse, Error};
-use futures::future::{ok, Ready};
-use futures::Future;
+use actix_web::{
+    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
+    Error,
+};
+use futures_util::future::LocalBoxFuture;
 
 // There are two steps in middleware processing.
 // 1. Middleware initialization, middleware factory gets called with
@@ -19,16 +19,15 @@ use futures::Future;
 // 2. Middleware's call method gets called with normal request.
 pub struct SayHi;
 
-// Middleware factory is `Transform` trait from actix-service crate
+// Middleware factory is `Transform` trait
 // `S` - type of the next service
 // `B` - type of response's body
-impl<S, B> Transform<S> for SayHi
+impl<S, B> Transform<S, ServiceRequest> for SayHi
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type InitError = ();
@@ -36,7 +35,7 @@ where
     type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        ok(SayHiMiddleware { service })
+        ready(Ok(SayHiMiddleware { service }))
     }
 }
 
@@ -44,22 +43,19 @@ pub struct SayHiMiddleware<S> {
     service: S,
 }
 
-impl<S, B> Service for SayHiMiddleware<S>
+impl<S, B> Service<ServiceRequest> for SayHiMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx)
-    }
+    forward_ready!(service);
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&self, req: ServiceRequest) -> Self::Future {
         println!("Hi from start. You requested: {}", req.path());
 
         let fut = self.service.call(req);
@@ -80,13 +76,12 @@ async fn main() -> std::io::Result<()> {
 
     HttpServer::new(|| {
         App::new().wrap(SayHi).service(
-            web::resource("/")
-                .to(|| async {
-                    "Hello, middleware! Check the console where the server is run."
-                }),
+            web::resource("/").to(|| async {
+                "Hello, middleware! Check the console where the server is run."
+            }),
         )
     })
-    .bind("127.0.0.1:8080")?
+    .bind(("127.0.0.1", 8080))?
     .run()
     .await
 }

examples/middleware/src/user_sessions.rs

@@ -7,9 +7,9 @@ use actix_web::{web, App, Error, HttpResponse, HttpServer};
 async fn index(session: Session) -> Result<HttpResponse, Error> {
     // access session data
     if let Some(count) = session.get::<i32>("counter")? {
-        session.set("counter", count + 1)?;
+        session.insert("counter", count + 1)?;
     } else {
-        session.set("counter", 1)?;
+        session.insert("counter", 1)?;
     }
 
     Ok(HttpResponse::Ok().body(format!(
@@ -28,7 +28,7 @@ async fn main() -> std::io::Result<()> {
             )
             .service(web::resource("/").to(index))
     })
-    .bind("127.0.0.1:8080")?
+    .bind(("127.0.0.1", 8080))?
     .run()
     .await
 }

examples/middleware/src/wrap_fn.rs

@@ -1,9 +1,8 @@
 #![allow(dead_code, unused_variables)]
 
 // <wrap-fn>
-use actix_web::dev::Service;
-use actix_web::{web, App};
-use futures::future::FutureExt;
+use actix_web::{dev::Service as _, web, App};
+use futures_util::future::FutureExt;
 
 #[actix_web::main]
 async fn main() {
@@ -17,9 +16,7 @@ async fn main() {
         })
         .route(
             "/index.html",
-            web::get().to(|| async {
-                "Hello, middleware!"
-            }),
+            web::get().to(|| async { "Hello, middleware!" }),
         );
 }
 // </wrap-fn>