Merge pull request #10 from SakaDream/update-dependencies

SakaDream · web-flow · commit bbc4914b638c · 2020-01-01T00:47:01.000+07:00
👋 2019, 🎉 2020!
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -4,6 +4,24 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'actix-web-rest-api-with-jwt'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=actix-web-rest-api-with-jwt",
+                    "--package=actix-web-rest-api-with-jwt"
+                ],
+                "filter": {
+                    "name": "actix-web-rest-api-with-jwt",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
         {
             "type": "lldb",
             "request": "launch",
diff --git a/Cargo.toml b/Cargo.toml
@@ -5,29 +5,29 @@ authors = ["SakaDream <bahaimt@gmail.com>"]
 edition = "2018"
 
 [dependencies]
-actix-web = "1.0.8"
-actix-rt = "0.2.5"
-actix-service = "0.4.2"
+actix-web = "2.0.0"
+actix-rt = "1.0.0"
+actix-service = "1.0.1"
 log = "0.4.8"
 env_logger = "0.7.1"
 diesel_migrations = "1.4.0"
-serde = "1.0.102"
-serde_derive = "1.0.102"
-serde_json = "1.0.41"
+serde = "1.0.104"
+serde_derive = "1.0.104"
+serde_json = "1.0.44"
 dotenv = "0.15.0"
-futures = "0.1.29"
+futures = "0.3.1"
 failure = "0.1.6"
-derive_more = "0.15.0"
+derive_more = "0.99.2"
 jsonwebtoken = "6.0.1"
 bcrypt = "0.6.1"
-time = "0.1.42"
+time = "0.2.1"
 
 [dependencies.diesel]
 version = "1.4.3"
 features = ["postgres", "r2d2", "chrono"]
 
 [dependencies.chrono]
-version = "0.4.9"
+version = "0.4.10"
 features = ["serde"]
 
 [dependencies.uuid]
diff --git a/src/api/account_controller.rs b/src/api/account_controller.rs
@@ -7,31 +7,30 @@ use crate::{
     },
     services::account_service,
 };
-use actix_web::{web, Error, HttpRequest, HttpResponse};
-use futures::future::{ok, Future};
+use actix_web::{web, HttpRequest, HttpResponse, Result};
 
 // POST api/auth/signup
-pub fn signup(user_dto: web::Json<UserDTO>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn signup(user_dto: web::Json<UserDTO>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match account_service::signup(user_dto.0, &pool) {
-        Ok(message) => ok(HttpResponse::Ok().json(ResponseBody::new(&message, constants::EMPTY))),
-        Err(err) => ok(err.response()),
+        Ok(message) => Ok(HttpResponse::Ok().json(ResponseBody::new(&message, constants::EMPTY))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // POST api/auth/login
-pub fn login(login_dto: web::Json<LoginDTO>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn login(login_dto: web::Json<LoginDTO>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match account_service::login(login_dto.0, &pool) {
-        Ok(token_res) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_LOGIN_SUCCESS, token_res))),
-        Err(err) => ok(err.response()),
+        Ok(token_res) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_LOGIN_SUCCESS, token_res))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // POST api/auth/logout
-pub fn logout(req: HttpRequest, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn logout(req: HttpRequest, pool: web::Data<Pool>) -> Result<HttpResponse> {
     if let Some(authen_header) = req.headers().get(constants::AUTHORIZATION) {
         account_service::logout(authen_header, &pool);
-        ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_LOGOUT_SUCCESS, constants::EMPTY)))
+        Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_LOGOUT_SUCCESS, constants::EMPTY)))
     } else {
-        ok(HttpResponse::BadRequest().json(ResponseBody::new(constants::MESSAGE_TOKEN_MISSING, constants::EMPTY)))
+        Ok(HttpResponse::BadRequest().json(ResponseBody::new(constants::MESSAGE_TOKEN_MISSING, constants::EMPTY)))
     }
 }
diff --git a/src/api/address_book_controller.rs b/src/api/address_book_controller.rs
@@ -7,53 +7,52 @@ use crate::{
     },
     services::address_book_service,
 };
-use actix_web::{web, Error, HttpResponse};
-use futures::future::{ok, Future};
+use actix_web::{web, HttpResponse, Result};
 
 // GET api/address-book
-pub fn find_all(pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn find_all(pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::find_all(&pool) {
-        Ok(people) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, people))),
-        Err(err) => ok(err.response()),
+        Ok(people) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, people))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // GET api/address-book/{id}
-pub fn find_by_id(id: web::Path<String>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn find_by_id(id: web::Path<String>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::find_by_id(id.into_inner().parse::<i32>().unwrap(), &pool) {
-        Ok(person) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, person))),
-        Err(err) => ok(err.response()),
+        Ok(person) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, person))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // GET api/address-book/query/{query}
-pub fn query(query: web::Path<String>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn query(query: web::Path<String>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::query(query.into_inner(), &pool) {
-        Ok(people) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, people))),
-        Err(err) => ok(err.response()),
+        Ok(people) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, people))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // POST api/address-book
-pub fn insert(new_person: web::Json<PersonDTO>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn insert(new_person: web::Json<PersonDTO>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::insert(new_person.0, &pool) {
-        Ok(()) => ok(HttpResponse::Created().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
-        Err(err) => ok(err.response()),
+        Ok(()) => Ok(HttpResponse::Created().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // PUT api/address-book/{id}
-pub fn update(id: web::Path<String>, updated_person: web::Json<PersonDTO>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn update(id: web::Path<String>, updated_person: web::Json<PersonDTO>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::update(id.into_inner().parse::<i32>().unwrap(), updated_person.0, &pool) {
-        Ok(()) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
-        Err(err) => ok(err.response()),
+        Ok(()) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
+        Err(err) => Ok(err.response()),
     }
 }
 
 // DELETE api/address-book/{id}
-pub fn delete(id: web::Path<String>, pool: web::Data<Pool>) -> impl Future<Item = HttpResponse, Error = Error> {
+pub async fn delete(id: web::Path<String>, pool: web::Data<Pool>) -> Result<HttpResponse> {
     match address_book_service::delete(id.into_inner().parse::<i32>().unwrap(), &pool) {
-        Ok(()) => ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
-        Err(err) => ok(err.response()),
+        Ok(()) => Ok(HttpResponse::Ok().json(ResponseBody::new(constants::MESSAGE_OK, constants::EMPTY))),
+        Err(err) => Ok(err.response()),
     }
 }
diff --git a/src/config/app.rs b/src/config/app.rs
@@ -10,33 +10,33 @@ pub fn config_services(cfg: &mut web::ServiceConfig) {
                 web::scope("/auth")
                     .service(
                         web::resource("/signup")
-                            .route(web::post().to_async(account_controller::signup))
+                            .route(web::post().to(account_controller::signup))
                     )
                     .service(
                         web::resource("/login")
-                            .route(web::post().to_async(account_controller::login))
+                            .route(web::post().to(account_controller::login))
                     )
                     .service(
                         web::resource("/logout")
-                            .route(web::post().to_async(account_controller::logout))
+                            .route(web::post().to(account_controller::logout))
                     )
             )
             .service(
                 web::scope("/address-book")
                     .service(
                         web::resource("")
-                            .route(web::get().to_async(address_book_controller::find_all))
-                            .route(web::post().to_async(address_book_controller::insert))
+                            .route(web::get().to(address_book_controller::find_all))
+                            .route(web::post().to(address_book_controller::insert))
                     )
                     .service(
                         web::resource("/{id}")
-                            .route(web::get().to_async(address_book_controller::find_by_id))
-                            .route(web::put().to_async(address_book_controller::update))
-                            .route(web::delete().to_async(address_book_controller::delete))
+                            .route(web::get().to(address_book_controller::find_by_id))
+                            .route(web::put().to(address_book_controller::update))
+                            .route(web::delete().to(address_book_controller::delete))
                     )
                     .service(
                         web::resource("/query/{query}")
-                            .route(web::get().to_async(address_book_controller::query))   
+                            .route(web::get().to(address_book_controller::query))   
                     )
             )
     );
diff --git a/src/main.rs b/src/main.rs
@@ -35,9 +35,12 @@ mod services;
 mod utils;
 
 use actix_web::{HttpServer, App};
+use actix_service::Service;
+use futures::FutureExt;
 use std::{io, env};
 
-fn main() -> io::Result<()> {
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
     dotenv::dotenv().expect("Failed to read .env file");
     env::set_var("RUST_LOG", "actix_web=debug");
 
@@ -48,20 +51,19 @@ fn main() -> io::Result<()> {
     let app_url = format!("{}:{}", &app_host, &app_port);
     let db_url = env::var("DATABASE_URL").expect("DATABASE_URL not found.");
 
-    let sys = actix_rt::System::new("address-book");
     let pool = config::db::migrate_and_config_db(&db_url);
 
     HttpServer::new(move || {
         App::new()
             .data(pool.clone())
             .wrap(actix_web::middleware::Logger::default())
             .wrap(crate::middleware::authen_middleware::Authentication)
+            .wrap_fn(|req, srv| {
+                srv.call(req).map(|res| res)
+            })
             .configure(config::app::config_services)
         })
     .bind(&app_url)?
-    .start();
-
-    info!("Server is started at {}", &app_url);
-
-    sys.run()
+    .run()
+    .await
 }
diff --git a/src/middleware/authen_middleware.rs b/src/middleware/authen_middleware.rs
@@ -1,17 +1,16 @@
-use crate::{
-    config::db::Pool,
-    constants,
-    models::response::ResponseBody,
-    utils::token_utils,
-};
+use crate::{config::db::Pool, constants, models::response::ResponseBody, utils::token_utils};
 use actix_service::{Service, Transform};
 use actix_web::{
-    Error, HttpResponse,
     dev::{ServiceRequest, ServiceResponse},
+    Error, HttpResponse,
 };
 use futures::{
-    Poll,
-    future::{ok, Either, FutureResult},
+    future::{ok, Ready},
+    Future,
+};
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
 };
 
 pub struct Authentication;
@@ -20,13 +19,14 @@ impl<S, B> Transform<S> for Authentication
 where
     S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
+    B: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type InitError = ();
     type Transform = AuthenticationMiddleware<S>;
-    type Future = FutureResult<Self::Transform, Self::InitError>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
         ok(AuthenticationMiddleware { service })
@@ -40,21 +40,24 @@ impl<S, B> Service for AuthenticationMiddleware<S>
 where
     S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
+    B: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type Future = Either<S::Future, FutureResult<Self::Response, Self::Error>>;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
     }
 
     fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
+        let mut authenticate_pass: bool = false;
+
         // Bypass some account routes
         for ignore_route in constants::IGNORE_ROUTES.iter() {
             if req.path().starts_with(ignore_route) {
-                return Either::A(self.service.call(req));
+                authenticate_pass = true;
             }
         }
 
@@ -63,21 +66,16 @@ where
             if let Some(authen_header) = req.headers_mut().get(constants::AUTHORIZATION) {
                 info!("Parsing authorization header...");
                 if let Ok(authen_str) = authen_header.to_str() {
-                    if authen_str.starts_with("bearer") {
+                    if authen_str.starts_with("bearer") || authen_str.starts_with("Bearer") {
                         info!("Parsing token...");
                         let token = authen_str[6..authen_str.len()].trim();
                         if let Ok(token_data) = token_utils::decode_token(token.to_string()) {
                             info!("Decoding token...");
                             if token_utils::verify_token(&token_data, &pool).is_ok() {
                                 info!("Valid token");
-                                return Either::A(self.service.call(req));
+                                authenticate_pass = true;
                             } else {
                                 error!("Invalid token");
-                                return Either::B(ok(req.into_response(
-                                    HttpResponse::Unauthorized()
-                                        .json(ResponseBody::new(constants::MESSAGE_INVALID_TOKEN, constants::EMPTY))
-                                        .into_body()
-                                )));
                             }
                         }
                     }
@@ -86,10 +84,23 @@ where
         }
 
         error!("{}", constants::MESSAGE_PROCESS_TOKEN_ERROR);
-        Either::B(ok(req.into_response(
-            HttpResponse::InternalServerError()
-                .json(ResponseBody::new(constants::MESSAGE_PROCESS_TOKEN_ERROR, constants::EMPTY))
-                .into_body()
-        )))
+        if authenticate_pass {
+            let fut = self.service.call(req);
+            Box::pin(async move {
+                let res = fut.await?;
+                Ok(res)
+            })
+        } else {
+            Box::pin(async move {
+                Ok(req.into_response(
+                    HttpResponse::Unauthorized()
+                        .json(ResponseBody::new(
+                            constants::MESSAGE_INVALID_TOKEN,
+                            constants::EMPTY,
+                        ))
+                        .into_body(),
+                ))
+            })
+        }
     }
 }
diff --git a/src/models/user_token.rs b/src/models/user_token.rs

Original file line number	Diff line number	Diff line change
`@@ -10,33 +10,33 @@ pub fn config_services(cfg: &mut web::ServiceConfig) {`
`10`	`10`	`web::scope("/auth")`
`11`	`11`	`.service(`
`12`	`12`	`web::resource("/signup")`
`13`		`- .route(web::post().to_async(account_controller::signup))`
	`13`	`+ .route(web::post().to(account_controller::signup))`
`14`	`14`	`)`
`15`	`15`	`.service(`
`16`	`16`	`web::resource("/login")`
`17`		`- .route(web::post().to_async(account_controller::login))`
	`17`	`+ .route(web::post().to(account_controller::login))`
`18`	`18`	`)`
`19`	`19`	`.service(`
`20`	`20`	`web::resource("/logout")`
`21`		`- .route(web::post().to_async(account_controller::logout))`
	`21`	`+ .route(web::post().to(account_controller::logout))`
`22`	`22`	`)`
`23`	`23`	`)`
`24`	`24`	`.service(`
`25`	`25`	`web::scope("/address-book")`
`26`	`26`	`.service(`
`27`	`27`	`web::resource("")`
`28`		`- .route(web::get().to_async(address_book_controller::find_all))`
`29`		`- .route(web::post().to_async(address_book_controller::insert))`
	`28`	`+ .route(web::get().to(address_book_controller::find_all))`
	`29`	`+ .route(web::post().to(address_book_controller::insert))`
`30`	`30`	`)`
`31`	`31`	`.service(`
`32`	`32`	`web::resource("/{id}")`
`33`		`- .route(web::get().to_async(address_book_controller::find_by_id))`
`34`		`- .route(web::put().to_async(address_book_controller::update))`
`35`		`- .route(web::delete().to_async(address_book_controller::delete))`
	`33`	`+ .route(web::get().to(address_book_controller::find_by_id))`
	`34`	`+ .route(web::put().to(address_book_controller::update))`
	`35`	`+ .route(web::delete().to(address_book_controller::delete))`
`36`	`36`	`)`
`37`	`37`	`.service(`
`38`	`38`	`web::resource("/query/{query}")`
`39`		`- .route(web::get().to_async(address_book_controller::query))`
	`39`	`+ .route(web::get().to(address_book_controller::query))`
`40`	`40`	`)`
`41`	`41`	`)`
`42`	`42`	`);`