Restructure folders (#411)

session/cookie-auth/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cookie-auth"
+version = "2.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+actix-web = "3"
+actix-identity = "0.3"
+env_logger = "0.8"
+rand = "0.7"

session/cookie-auth/README.md

@@ -0,0 +1,26 @@
+# cookie-auth
+
+Testing with cookie auth with [curl](https://curl.haxx.se).
+
+Login:
+
+        curl -v -b "auth-example=user1" -X POST  http://localhost:8080/login
+        < HTTP/1.1 302 Found
+        < set-cookie: auth-example=GRm2Vku0UpFbJ3CNTKbndzIYHVGi8wc8eoXm/Axtf2BO; HttpOnly; Path=/
+        < location: /
+
+Uses a POST request with a Useridentity `user1`. A cookie is set and a redirect to home `/` follows.
+
+Get:
+
+Now with the cookie `auth-example` sent in a GET request, the `user1` is recognized.
+
+        curl -v -b "auth-example=GRm2Vku0UpFbJ3CNTKbndzIYHVGi8wc8eoXm/Axtf2BO" http://localhost:8080/
+        * Connected to localhost (127.0.0.1) port 8080 (#0)
+        > GET / HTTP/1.1
+        > Host: localhost:8080
+        > Cookie: auth-example=GRm2Vku0UpFbJ3CNTKbndzIYHVGi8wc8eoXm/Axtf2BO
+        > 
+        < HTTP/1.1 200 OK
+        < 
+        Hello user1

session/cookie-auth/src/main.rs

@@ -0,0 +1,48 @@
+use actix_identity::Identity;
+use actix_identity::{CookieIdentityPolicy, IdentityService};
+use actix_web::{middleware, web, App, HttpResponse, HttpServer};
+use rand::Rng;
+
+async fn index(id: Identity) -> String {
+    format!(
+        "Hello {}",
+        id.identity().unwrap_or_else(|| "Anonymous".to_owned())
+    )
+}
+
+async fn login(id: Identity) -> HttpResponse {
+    id.remember("user1".to_owned());
+    HttpResponse::Found().header("location", "/").finish()
+}
+
+async fn logout(id: Identity) -> HttpResponse {
+    id.forget();
+    HttpResponse::Found().header("location", "/").finish()
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    // Generate a random 32 byte key. Note that it is important to use a unique
+    // private key for every project. Anyone with access to the key can generate
+    // authentication cookies for any user!
+    let private_key = rand::thread_rng().gen::<[u8; 32]>();
+    HttpServer::new(move || {
+        App::new()
+            .wrap(IdentityService::new(
+                CookieIdentityPolicy::new(&private_key)
+                    .name("auth-example")
+                    .secure(false),
+            ))
+            // enable logger - always register actix-web Logger middleware last
+            .wrap(middleware::Logger::default())
+            .service(web::resource("/login").route(web::post().to(login)))
+            .service(web::resource("/logout").to(logout))
+            .service(web::resource("/").route(web::get().to(index)))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}

session/cookie-session/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "cookie-session"
+version = "1.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+actix-web = "3"
+actix-session = "0.4"
+env_logger = "0.8"

session/cookie-session/README.md

@@ -0,0 +1,7 @@
+## Cookie session example
+
+```sh
+cd cookie-session
+cargo run
+# Starting http server: 127.0.0.1:8080
+```

session/cookie-session/src/main.rs

@@ -0,0 +1,45 @@
+//! Example of cookie based session
+//! Session data is stored in cookie, it is limited to 4kb
+//!
+//! [Redis session example](https://github.com/actix/examples/tree/master/redis-session)
+//!
+//! [User guide](https://actix.rs/docs/middleware/#user-sessions)
+
+use actix_session::{CookieSession, Session};
+use actix_web::{middleware::Logger, web, App, HttpRequest, HttpServer, Result};
+
+/// simple index handler with session
+async fn index(session: Session, req: HttpRequest) -> Result<&'static str> {
+    println!("{:?}", req);
+
+    // RequestSession trait is used for session access
+    let mut counter = 1;
+    if let Some(count) = session.get::<i32>("counter")? {
+        println!("SESSION value: {}", count);
+        counter = count + 1;
+        session.set("counter", counter)?;
+    } else {
+        session.set("counter", counter)?;
+    }
+
+    Ok("welcome!")
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    println!("Starting http server: 127.0.0.1:8080");
+
+    HttpServer::new(|| {
+        App::new()
+            // enable logger
+            .wrap(Logger::default())
+            // cookie session middleware
+            .wrap(CookieSession::signed(&[0; 32]).secure(false))
+            .service(web::resource("/").to(index))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}

session/redis-session/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "redis_session"
+version = "2.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "dowwie <dkcdkg@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+actix-web = "3"
+actix-session = "0.4"
+actix-redis = "0.9"
+env_logger = "0.8"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+actix-service = "1"
+actix-http = "2"
+rand = "0.7.3"
+time = "0.2"
+
+[dev-dependencies]
+actix-rt = "1"

session/redis-session/src/main.rs

@@ -0,0 +1,334 @@
+//! Example of login and logout using redis-based sessions
+//!
+//! Every request gets a session, corresponding to a cache entry and cookie.
+//! At login, the session key changes and session state in cache re-assigns.
+//! At logout, session state in cache is removed and cookie is invalidated.
+//!
+use actix_redis::RedisSession;
+use actix_session::Session;
+use actix_web::{
+    middleware, web,
+    web::{get, post, resource},
+    App, HttpResponse, HttpServer, Result,
+};
+use rand::Rng;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct IndexResponse {
+    user_id: Option<String>,
+    counter: i32,
+}
+
+async fn index(session: Session) -> Result<HttpResponse> {
+    let user_id: Option<String> = session.get::<String>("user_id").unwrap();
+    let counter: i32 = session
+        .get::<i32>("counter")
+        .unwrap_or(Some(0))
+        .unwrap_or(0);
+
+    Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter }))
+}
+
+async fn do_something(session: Session) -> Result<HttpResponse> {
+    let user_id: Option<String> = session.get::<String>("user_id").unwrap();
+    let counter: i32 = session
+        .get::<i32>("counter")
+        .unwrap_or(Some(0))
+        .map_or(1, |inner| inner + 1);
+    session.set("counter", counter)?;
+
+    Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter }))
+}
+
+#[derive(Deserialize)]
+struct Identity {
+    user_id: String,
+}
+
+async fn login(user_id: web::Json<Identity>, session: Session) -> Result<HttpResponse> {
+    let id = user_id.into_inner().user_id;
+    session.set("user_id", &id)?;
+    session.renew();
+
+    let counter: i32 = session
+        .get::<i32>("counter")
+        .unwrap_or(Some(0))
+        .unwrap_or(0);
+
+    Ok(HttpResponse::Ok().json(IndexResponse {
+        user_id: Some(id),
+        counter,
+    }))
+}
+
+async fn logout(session: Session) -> Result<HttpResponse> {
+    let id: Option<String> = session.get("user_id")?;
+    if let Some(x) = id {
+        session.purge();
+        Ok(format!("Logged out: {}", x).into())
+    } else {
+        Ok("Could not log out anonymous user".into())
+    }
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info,actix_redis=info");
+    env_logger::init();
+
+    // Generate a random 32 byte key. Note that it is important to use a unique
+    // private key for every project. Anyone with access to the key can generate
+    // authentication cookies for any user!
+    let private_key = rand::thread_rng().gen::<[u8; 32]>();
+
+    HttpServer::new(move || {
+        App::new()
+            // redis session middleware
+            .wrap(RedisSession::new("127.0.0.1:6379", &private_key))
+            // 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)))
+            .service(resource("/login").route(post().to(login)))
+            .service(resource("/logout").route(post().to(logout)))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use actix_http::httpmessage::HttpMessage;
+    use actix_web::{
+        middleware, test,
+        web::{get, post, resource},
+        App,
+    };
+    use serde_json::json;
+
+    #[actix_rt::test]
+    async fn test_workflow() {
+        // 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}
+        //   - 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}
+        //   - 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)
+        //   - updates session state in redis: {"counter": 2, "user_id": "ferris"}
+        // Step 6: GET index, including session cookie #2 in request
+        //   - response should be: {"counter": 2, "user_id": "ferris"}
+        // Step 7: POST again to do_something, including session cookie #2 in request
+        //   - updates session state in redis: {"counter": 3, "user_id": "ferris"}
+        //   - response should be: {"counter": 2, "user_id": None}
+        // 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}
+        // Step 9: POST to logout, including session cookie #2
+        //   - set-cookie actix-session will be in response with session cookie #2
+        //     invalidation logic
+        // 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 private_key = rand::thread_rng().gen::<[u8; 32]>();
+        let srv = test::start(move || {
+            App::new()
+                .wrap(
+                    RedisSession::new("127.0.0.1:6379", &private_key)
+                        .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
+        //   - 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 = req_1a.await.unwrap();
+        let cookie_1 = resp_1
+            .cookies()
+            .unwrap()
+            .clone()
+            .into_iter()
+            .find(|c| c.name() == "test-session")
+            .unwrap();
+        let result_1 = resp_1.json::<IndexResponse>().await.unwrap();
+        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 = req_2.await.unwrap();
+        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}
+        //   - response should be: {"counter": 1, "user_id": None}
+        let req_3 = srv.post("/do_something").cookie(cookie_1.clone()).send();
+        let mut resp_3 = req_3.await.unwrap();
+        let result_3 = resp_3.json::<IndexResponse>().await.unwrap();
+        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}
+        //   - response should be: {"counter": 2, "user_id": None}
+        let req_4 = srv.post("/do_something").cookie(cookie_1.clone()).send();
+        let mut resp_4 = req_4.await.unwrap();
+        let result_4 = resp_4.json::<IndexResponse>().await.unwrap();
+        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 mut resp_5 = req_5.await.unwrap();
+        let cookie_2 = resp_5
+            .cookies()
+            .unwrap()
+            .clone()
+            .into_iter()
+            .find(|c| c.name() == "test-session")
+            .unwrap();
+        assert_ne!(cookie_1.value(), cookie_2.value());
+
+        let result_5 = resp_5.json::<IndexResponse>().await.unwrap();
+        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 mut resp_6 = req_6.await.unwrap();
+        let result_6 = resp_6.json::<IndexResponse>().await.unwrap();
+        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"}
+        //   - response should be: {"counter": 2, "user_id": None}
+        let req_7 = srv.post("/do_something").cookie(cookie_2.clone()).send();
+        let mut resp_7 = req_7.await.unwrap();
+        let result_7 = resp_7.json::<IndexResponse>().await.unwrap();
+        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 mut resp_8 = req_8.await.unwrap();
+        let cookie_3 = resp_8
+            .cookies()
+            .unwrap()
+            .clone()
+            .into_iter()
+            .find(|c| c.name() == "test-session")
+            .unwrap();
+        let result_8 = resp_8.json::<IndexResponse>().await.unwrap();
+        assert_eq!(
+            result_8,
+            IndexResponse {
+                user_id: None,
+                counter: 0
+            }
+        );
+        assert_ne!(cookie_3.value(), cookie_2.value());
+
+        // 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 resp_9 = req_9.await.unwrap();
+        let cookie_4 = resp_9
+            .cookies()
+            .unwrap()
+            .clone()
+            .into_iter()
+            .find(|c| c.name() == "test-session")
+            .unwrap();
+
+        let now = time::OffsetDateTime::now_utc();
+        assert!(now.year() != cookie_4.expires().map(|t| t.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 mut resp_10 = req_10.await.unwrap();
+        let result_10 = resp_10.json::<IndexResponse>().await.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_ne!(cookie_5.value(), cookie_2.value());
+    }
+}