From 44053504ad39b2bb023712c7577a06091629ad41 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Thu, 18 Jul 2019 18:03:19 +0600 Subject: [PATCH] reenable uds example; cargo fmt --- Cargo.toml | 2 +- redis-session/src/main.rs | 261 ++++++++++++------- simple-auth-server/src/auth_handler.rs | 3 +- simple-auth-server/src/email_service.rs | 4 +- simple-auth-server/src/errors.rs | 13 +- simple-auth-server/src/invitation_handler.rs | 15 +- simple-auth-server/src/main.rs | 15 +- simple-auth-server/src/models.rs | 6 +- unix-socket/Cargo.toml | 6 +- unix-socket/README.md | 2 +- unix-socket/src/main.rs | 35 +-- 11 files changed, 216 insertions(+), 146 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index edcf2b57..0caeb8da 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,7 +33,7 @@ members = [ "template_yarte", "template_handlebars", "tls", - #"unix-socket", + "unix-socket", "web-cors/backend", "websocket", "websocket-chat", diff --git a/redis-session/src/main.rs b/redis-session/src/main.rs index 944c3b9e..e85b59e0 100644 --- a/redis-session/src/main.rs +++ b/redis-session/src/main.rs @@ -6,56 +6,63 @@ //! use actix_redis::RedisSession; use actix_session::Session; -use actix_web::{middleware, web, App, HttpResponse, HttpServer, Result, - web::{resource, get, post}}; +use actix_web::{ + middleware, web, + web::{get, post, resource}, + App, HttpResponse, HttpServer, Result, +}; use serde::{Deserialize, Serialize}; - #[derive(Serialize, Deserialize, Debug, PartialEq)] pub struct IndexResponse { user_id: Option, - counter: i32 + counter: i32, } fn index(session: Session) -> Result { let user_id: Option = session.get::("user_id").unwrap(); - let counter: i32 = session.get::("counter") - .unwrap_or(Some(0)) - .unwrap_or(0); + let counter: i32 = session + .get::("counter") + .unwrap_or(Some(0)) + .unwrap_or(0); - Ok(HttpResponse::Ok().json(IndexResponse{user_id, counter})) + Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter })) } - fn do_something(session: Session) -> Result { let user_id: Option = session.get::("user_id").unwrap(); - let counter: i32 = session.get::("counter") - .unwrap_or(Some(0)) - .map_or(1, |inner| inner + 1); + let counter: i32 = session + .get::("counter") + .unwrap_or(Some(0)) + .map_or(1, |inner| inner + 1); session.set("counter", counter)?; - Ok(HttpResponse::Ok().json(IndexResponse{user_id, counter})) + Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter })) } #[derive(Deserialize)] struct Identity { - user_id: String + user_id: String, } fn login(user_id: web::Json, session: Session) -> Result { let id = user_id.into_inner().user_id; session.set("user_id", &id)?; session.renew(); - let counter: i32 = session.get::("counter") - .unwrap_or(Some(0)) - .unwrap_or(0); + let counter: i32 = session + .get::("counter") + .unwrap_or(Some(0)) + .unwrap_or(0); - Ok(HttpResponse::Ok().json(IndexResponse{user_id: Some(id), counter})) + Ok(HttpResponse::Ok().json(IndexResponse { + user_id: Some(id), + counter, + })) } fn logout(session: Session) -> Result { let id: Option = session.get("user_id")?; - if let Some(x) = id{ + if let Some(x) = id { session.purge(); Ok(format!("Logged out: {}", x).into()) } else { @@ -71,7 +78,7 @@ fn main() -> std::io::Result<()> { App::new() // redis session middleware .wrap(RedisSession::new("127.0.0.1:6379", &[0; 32])) - // enable logger - always register actix-web Logger middleware last + // enable logger - always register actix-web Logger middleware last .wrap(middleware::Logger::default()) .service(resource("/").route(get().to(index))) .service(resource("/do_something").route(post().to(do_something))) @@ -82,29 +89,32 @@ fn main() -> std::io::Result<()> { .run() } - #[cfg(test)] mod test { use super::*; - use actix_http::{HttpService, httpmessage::HttpMessage}; - use actix_http_test::{TestServer, block_on}; - use actix_web::{middleware, App, web::{resource, get, post}}; + use actix_http::{httpmessage::HttpMessage, HttpService}; + use actix_http_test::{block_on, TestServer}; + use actix_web::{ + middleware, + web::{get, post, resource}, + App, + }; use serde_json::json; use time; #[test] fn test_workflow() { - // Step 1: GET index + // Step 1: GET index // - set-cookie actix-session will be in response (session cookie #1) // - response should be: {"counter": 0, "user_id": None} // Step 2: GET index, including session cookie #1 in request // - set-cookie will *not* be in response // - response should be: {"counter": 0, "user_id": None} // Step 3: POST to do_something, including session cookie #1 in request - // - adds new session state in redis: {"counter": 1} + // - adds new session state in redis: {"counter": 1} // - response should be: {"counter": 1, "user_id": None} // Step 4: POST again to do_something, including session cookie #1 in request - // - updates session state in redis: {"counter": 2} + // - updates session state in redis: {"counter": 2} // - response should be: {"counter": 2, "user_id": None} // Step 5: POST to login, including session cookie #1 in request // - set-cookie actix-session will be in response (session cookie #2) @@ -124,86 +134,124 @@ mod test { // - set-cookie actix-session will be in response (session cookie #3) // - response should be: {"counter": 0, "user_id": None} - let mut srv = - TestServer::new(|| { - HttpService::new( - App::new() - .wrap(RedisSession::new("127.0.0.1:6379", &[0; 32]) - .cookie_name("test-session")) - .wrap(middleware::Logger::default()) - .service(resource("/").route(get().to(index))) - .service(resource("/do_something").route(post().to(do_something))) - .service(resource("/login").route(post().to(login))) - .service(resource("/logout").route(post().to(logout))) - ) - }); + let mut srv = TestServer::new(|| { + HttpService::new( + App::new() + .wrap( + RedisSession::new("127.0.0.1:6379", &[0; 32]) + .cookie_name("test-session"), + ) + .wrap(middleware::Logger::default()) + .service(resource("/").route(get().to(index))) + .service(resource("/do_something").route(post().to(do_something))) + .service(resource("/login").route(post().to(login))) + .service(resource("/logout").route(post().to(logout))), + ) + }); - - // Step 1: GET index + // Step 1: GET index // - set-cookie actix-session will be in response (session cookie #1) // - response should be: {"counter": 0, "user_id": None} let req_1a = srv.get("/").send(); let mut resp_1 = srv.block_on(req_1a).unwrap(); - let cookie_1 = resp_1.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session") - .unwrap(); + let cookie_1 = resp_1 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); let result_1 = block_on(resp_1.json::()).unwrap(); - assert_eq!(result_1, IndexResponse{user_id: None, counter: 0}); - + assert_eq!( + result_1, + IndexResponse { + user_id: None, + counter: 0 + } + ); // Step 2: GET index, including session cookie #1 in request // - set-cookie will *not* be in response // - response should be: {"counter": 0, "user_id": None} let req_2 = srv.get("/").cookie(cookie_1.clone()).send(); let resp_2 = srv.block_on(req_2).unwrap(); - let cookie_2 = resp_2.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session"); + let cookie_2 = resp_2 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session"); assert_eq!(cookie_2, None); - // Step 3: POST to do_something, including session cookie #1 in request - // - adds new session state in redis: {"counter": 1} + // - adds new session state in redis: {"counter": 1} // - response should be: {"counter": 1, "user_id": None} let req_3 = srv.post("/do_something").cookie(cookie_1.clone()).send(); let mut resp_3 = srv.block_on(req_3).unwrap(); let result_3 = block_on(resp_3.json::()).unwrap(); - assert_eq!(result_3, IndexResponse{user_id: None, counter: 1}); - + assert_eq!( + result_3, + IndexResponse { + user_id: None, + counter: 1 + } + ); // Step 4: POST again to do_something, including session cookie #1 in request - // - updates session state in redis: {"counter": 2} + // - updates session state in redis: {"counter": 2} // - response should be: {"counter": 2, "user_id": None} let req_4 = srv.post("/do_something").cookie(cookie_1.clone()).send(); let mut resp_4 = srv.block_on(req_4).unwrap(); let result_4 = block_on(resp_4.json::()).unwrap(); - assert_eq!(result_4, IndexResponse{user_id: None, counter: 2}); - + assert_eq!( + result_4, + IndexResponse { + user_id: None, + counter: 2 + } + ); // Step 5: POST to login, including session cookie #1 in request // - set-cookie actix-session will be in response (session cookie #2) // - updates session state in redis: {"counter": 2, "user_id": "ferris"} - let req_5 = srv.post("/login") - .cookie(cookie_1.clone()) - .send_json(&json!({"user_id": "ferris"})); + let req_5 = srv + .post("/login") + .cookie(cookie_1.clone()) + .send_json(&json!({"user_id": "ferris"})); let mut resp_5 = srv.block_on(req_5).unwrap(); - let cookie_2 = resp_5.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session") - .unwrap(); - assert_eq!(true, cookie_1.value().to_string() != cookie_2.value().to_string()); + let cookie_2 = resp_5 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + assert_eq!( + true, + cookie_1.value().to_string() != cookie_2.value().to_string() + ); let result_5 = block_on(resp_5.json::()).unwrap(); - assert_eq!(result_5, IndexResponse{user_id: Some("ferris".into()), counter: 2}); - + assert_eq!( + result_5, + IndexResponse { + user_id: Some("ferris".into()), + counter: 2 + } + ); // Step 6: GET index, including session cookie #2 in request // - response should be: {"counter": 2, "user_id": "ferris"} - let req_6 = srv.get("/") - .cookie(cookie_2.clone()) - .send(); + let req_6 = srv.get("/").cookie(cookie_2.clone()).send(); let mut resp_6 = srv.block_on(req_6).unwrap(); let result_6 = block_on(resp_6.json::()).unwrap(); - assert_eq!(result_6, IndexResponse{user_id: Some("ferris".into()), counter: 2}); - + assert_eq!( + result_6, + IndexResponse { + user_id: Some("ferris".into()), + counter: 2 + } + ); // Step 7: POST again to do_something, including session cookie #2 in request // - updates session state in redis: {"counter": 3, "user_id": "ferris"} @@ -211,50 +259,71 @@ mod test { let req_7 = srv.post("/do_something").cookie(cookie_2.clone()).send(); let mut resp_7 = srv.block_on(req_7).unwrap(); let result_7 = block_on(resp_7.json::()).unwrap(); - assert_eq!(result_7, IndexResponse{user_id: Some("ferris".into()), counter: 3}); - + assert_eq!( + result_7, + IndexResponse { + user_id: Some("ferris".into()), + counter: 3 + } + ); // Step 8: GET index, including session cookie #1 in request // - set-cookie actix-session will be in response (session cookie #3) // - response should be: {"counter": 0, "user_id": None} - let req_8 = srv.get("/") - .cookie(cookie_1.clone()) - .send(); + let req_8 = srv.get("/").cookie(cookie_1.clone()).send(); let mut resp_8 = srv.block_on(req_8).unwrap(); - let cookie_3 = resp_8.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session") - .unwrap(); + let cookie_3 = resp_8 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); let result_8 = block_on(resp_8.json::()).unwrap(); - assert_eq!(result_8, IndexResponse{user_id: None, counter: 0}); + assert_eq!( + result_8, + IndexResponse { + user_id: None, + counter: 0 + } + ); assert!(cookie_3.value().to_string() != cookie_2.value().to_string()); - // Step 9: POST to logout, including session cookie #2 // - set-cookie actix-session will be in response with session cookie #2 // invalidation logic - let req_9 = srv.post("/logout") - .cookie(cookie_2.clone()) - .send(); + let req_9 = srv.post("/logout").cookie(cookie_2.clone()).send(); let resp_9 = srv.block_on(req_9).unwrap(); - let cookie_4 = resp_9.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session") - .unwrap(); + let cookie_4 = resp_9 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); assert!(&time::now().tm_year != &cookie_4.expires().map(|t| t.tm_year).unwrap()); - // Step 10: GET index, including session cookie #2 in request // - set-cookie actix-session will be in response (session cookie #3) // - response should be: {"counter": 0, "user_id": None} - let req_10 = srv.get("/") - .cookie(cookie_2.clone()) - .send(); + let req_10 = srv.get("/").cookie(cookie_2.clone()).send(); let mut resp_10 = srv.block_on(req_10).unwrap(); let result_10 = block_on(resp_10.json::()).unwrap(); - assert_eq!(result_10, IndexResponse{user_id: None, counter: 0}); - - let cookie_5 = resp_10.cookies().unwrap().clone() - .into_iter().find(|c| c.name() == "test-session") - .unwrap(); + assert_eq!( + result_10, + IndexResponse { + user_id: None, + counter: 0 + } + ); + + let cookie_5 = resp_10 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); assert!(cookie_5.value().to_string() != cookie_2.value().to_string()); } -} \ No newline at end of file +} diff --git a/simple-auth-server/src/auth_handler.rs b/simple-auth-server/src/auth_handler.rs index 7f0f47d8..9c75efc0 100644 --- a/simple-auth-server/src/auth_handler.rs +++ b/simple-auth-server/src/auth_handler.rs @@ -1,6 +1,7 @@ use actix_identity::Identity; use actix_web::{ - dev::Payload, error::BlockingError, web, Error, FromRequest, HttpRequest, HttpResponse, + dev::Payload, error::BlockingError, web, Error, FromRequest, HttpRequest, + HttpResponse, }; use diesel::prelude::*; use diesel::PgConnection; diff --git a/simple-auth-server/src/email_service.rs b/simple-auth-server/src/email_service.rs index 1583e042..4f22497f 100644 --- a/simple-auth-server/src/email_service.rs +++ b/simple-auth-server/src/email_service.rs @@ -11,8 +11,8 @@ static ref API_KEY: String = std::env::var("SPARKPOST_API_KEY").expect("SPARKPOS pub fn send_invitation(invitation: &Invitation) -> Result<(), ServiceError> { let tm = Transmission::new_eu(API_KEY.as_str()); - let sending_email = - std::env::var("SENDING_EMAIL_ADDRESS").expect("SENDING_EMAIL_ADDRESS must be set"); + let sending_email = std::env::var("SENDING_EMAIL_ADDRESS") + .expect("SENDING_EMAIL_ADDRESS must be set"); // new email message with sender name and email let mut email = Message::new(EmailAddress::new(sending_email, "Let's Organise")); diff --git a/simple-auth-server/src/errors.rs b/simple-auth-server/src/errors.rs index c6ade0ff..1cea664b 100644 --- a/simple-auth-server/src/errors.rs +++ b/simple-auth-server/src/errors.rs @@ -22,10 +22,12 @@ impl ResponseError for ServiceError { match self { ServiceError::InternalServerError => HttpResponse::InternalServerError() .json("Internal Server Error, Please try later"), - ServiceError::BadRequest(ref message) => HttpResponse::BadRequest() - .json(message), - ServiceError::Unauthorized => HttpResponse::Unauthorized() - .json("Unauthorized"), + ServiceError::BadRequest(ref message) => { + HttpResponse::BadRequest().json(message) + } + ServiceError::Unauthorized => { + HttpResponse::Unauthorized().json("Unauthorized") + } } } } @@ -45,7 +47,8 @@ impl From for ServiceError { match error { DBError::DatabaseError(kind, info) => { if let DatabaseErrorKind::UniqueViolation = kind { - let message = info.details().unwrap_or_else(|| info.message()).to_string(); + let message = + info.details().unwrap_or_else(|| info.message()).to_string(); return ServiceError::BadRequest(message); } ServiceError::InternalServerError diff --git a/simple-auth-server/src/invitation_handler.rs b/simple-auth-server/src/invitation_handler.rs index 26246471..11b137bd 100644 --- a/simple-auth-server/src/invitation_handler.rs +++ b/simple-auth-server/src/invitation_handler.rs @@ -16,15 +16,15 @@ pub fn post_invitation( pool: web::Data, ) -> impl Future { // run diesel blocking code - web::block(move || create_invitation(invitation_data.into_inner().email, pool)).then(|res| { - match res { + web::block(move || create_invitation(invitation_data.into_inner().email, pool)).then( + |res| match res { Ok(_) => Ok(HttpResponse::Ok().finish()), Err(err) => match err { BlockingError::Error(service_error) => Err(service_error), BlockingError::Canceled => Err(ServiceError::InternalServerError), }, - } - }) + }, + ) } fn create_invitation( @@ -36,10 +36,13 @@ fn create_invitation( } /// Diesel query -fn query(eml: String, pool: web::Data) -> Result { +fn query( + eml: String, + pool: web::Data, +) -> Result { use crate::schema::invitations::dsl::invitations; - let new_invitation : Invitation = eml.into(); + let new_invitation: Invitation = eml.into(); let conn: &PgConnection = &pool.get().unwrap(); let inserted_invitation = diesel::insert_into(invitations) diff --git a/simple-auth-server/src/main.rs b/simple-auth-server/src/main.rs index aaccf080..7271ec3e 100644 --- a/simple-auth-server/src/main.rs +++ b/simple-auth-server/src/main.rs @@ -31,7 +31,8 @@ fn main() -> std::io::Result<()> { let pool: models::Pool = r2d2::Pool::builder() .build(manager) .expect("Failed to create pool."); - let domain: String = std::env::var("DOMAIN").unwrap_or_else(|_| "localhost".to_string()); + let domain: String = + std::env::var("DOMAIN").unwrap_or_else(|_| "localhost".to_string()); // Start http server HttpServer::new(move || { @@ -51,13 +52,13 @@ fn main() -> std::io::Result<()> { // everything under '/api/' route .service( web::scope("/api") + .service(web::resource("/invitation").route( + web::post().to_async(invitation_handler::post_invitation), + )) .service( - web::resource("/invitation") - .route(web::post().to_async(invitation_handler::post_invitation)), - ) - .service( - web::resource("/register/{invitation_id}") - .route(web::post().to_async(register_handler::register_user)), + web::resource("/register/{invitation_id}").route( + web::post().to_async(register_handler::register_user), + ), ) .service( web::resource("/auth") diff --git a/simple-auth-server/src/models.rs b/simple-auth-server/src/models.rs index dc07509b..1f5d9695 100644 --- a/simple-auth-server/src/models.rs +++ b/simple-auth-server/src/models.rs @@ -31,8 +31,10 @@ pub struct Invitation { } // any type that implements Into can be used to create Invitation -impl From for Invitation where - T: Into { +impl From for Invitation +where + T: Into, +{ fn from(email: T) -> Self { Invitation { id: uuid::Uuid::new_v4(), diff --git a/unix-socket/Cargo.toml b/unix-socket/Cargo.toml index 423ac7b1..0eba6e2e 100644 --- a/unix-socket/Cargo.toml +++ b/unix-socket/Cargo.toml @@ -2,11 +2,11 @@ name = "unix-socket" version = "0.1.0" authors = ["Messense Lv "] -workspace = "../" +workspace = ".." +edition = "2018" [dependencies] env_logger = "0.5" tokio-uds = "0.2" -actix = "0.7" -actix-web = "0.7" +actix-web = { version = "1.0.5", features = ["uds"] } diff --git a/unix-socket/README.md b/unix-socket/README.md index 03b0066a..94870320 100644 --- a/unix-socket/README.md +++ b/unix-socket/README.md @@ -7,7 +7,7 @@ Hello world! Although this will only one thread for handling incoming connections according to the -[documentation](https://actix.github.io/actix-web/actix_web/struct.HttpServer.html#method.start_incoming). +[documentation](https://actix.github.io/actix-web/actix_web/struct.HttpServer.html#method.bind_uds). And it does not delete the socket file (`/tmp/actix-uds.socket`) when stopping the server so it will fail to start next time you run it unless you delete diff --git a/unix-socket/src/main.rs b/unix-socket/src/main.rs index 6a3e3ed3..055b597c 100644 --- a/unix-socket/src/main.rs +++ b/unix-socket/src/main.rs @@ -1,31 +1,22 @@ -extern crate actix; -extern crate actix_web; -extern crate env_logger; -extern crate tokio_uds; +use actix_web::{middleware, web, App, HttpRequest, HttpServer}; -use actix::*; -use actix_web::{middleware, server, App, HttpRequest}; -use tokio_uds::UnixListener; - -fn index(_req: &HttpRequest) -> &'static str { +fn index(_req: HttpRequest) -> &'static str { "Hello world!" } -fn main() { - ::std::env::set_var("RUST_LOG", "actix_web=info"); +fn main() -> std::io::Result<()> { + ::std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info"); env_logger::init(); - let sys = actix::System::new("unix-socket"); - let listener = UnixListener::bind("/tmp/actix-uds.socket").expect("bind failed"); - server::new(|| { + HttpServer::new(|| { App::new() - // enable logger - .middleware(middleware::Logger::default()) - .resource("/index.html", |r| r.f(|_| "Hello world!")) - .resource("/", |r| r.f(index)) + // enable logger - always register actix-web Logger middleware last + .wrap(middleware::Logger::default()) + .service( + web::resource("/index.html").route(web::get().to(|| "Hello world!")), + ) + .service(web::resource("/").to(index)) }) - .start_incoming(listener.incoming(), false); - - println!("Started http server: /tmp/actix-uds.socket"); - let _ = sys.run(); + .bind_uds("/tmp/actix-uds.socket")? + .run() }