CHANGELOG.md

@@ -1,13 +0,0 @@
-# [0.3.0]
-
-- Update dependencies
-- Added new example
-- Port to rocket `0.5.0-rc.2`
-
-# [0.2.2]
-
-- Update dependencies
-
-# [0.2.1]
-
-- change from `thread_rng` to `OsRng` for better session ID entropy

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "rocket_session"
-version = "0.3.0"
+version = "0.2.0"
 authors = ["Ondřej Hruška <ondra@ondrovo.com>"]
-edition = "2021"
+edition = "2018"
 license = "MIT"
 description = "Rocket.rs plug-in for cookie-based sessions holding arbitrary data"
 repository = "https://git.ondrovo.com/packages/rocket_session"
@@ -16,6 +16,6 @@ categories = [
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rand = "0.8"
-rocket = "0.5.0-rc.2"
-parking_lot = "0.12"
+rand = "0.7.2"
+rocket = "0.4.2"
+parking_lot = "0.10.0"

README.md

@@ -13,8 +13,6 @@ The implementation is generic to support any type as session data: a custom stru
 The session lifetime, cookie name, and other parameters can be configured by calling chained 
 methods on the fairing. When a session expires, the data associated with it is dropped.
 
-Example: `Session::fairing().with_lifetime(Duration::from_secs(15))`
-
 ## Usage
 
 To use session in a route, first make sure you have the fairing attached by calling
@@ -33,7 +31,7 @@ the session list does not waste memory.
 
 ## Examples
 
-More examples are in the "examples" folder - run with `cargo run --example=NAME`
+(More examples are in the examples folder)
 
 ### Basic Example
 
@@ -41,32 +39,34 @@ This simple example uses u64 as the session variable; note that it can be a stru
 it just needs to implement `Send + Sync + Default`. 
 
 ```rust
-#[macro_use]
-extern crate rocket;
+#![feature(proc_macro_hygiene, decl_macro)]
+#[macro_use] extern crate rocket;
+
+use std::time::Duration;
 
-type Session<'a> = rocket_session::Session<'a, u64>;
+// It's convenient to define a type alias:
+pub type Session<'a> = rocket_session::Session<'a, u64>;
 
-#[launch]
-fn rocket() -> _ {
-    rocket::build()
+fn main() {
+    rocket::ignite()
         .attach(Session::fairing())
         .mount("/", routes![index])
+        .launch();
 }
 
 #[get("/")]
 fn index(session: Session) -> String {
     let count = session.tap(|n| {
-        // Change the stored value (it is &mut)
+        // Change the stored value (it is &mut) 
         *n += 1;
 
-        // Return something to the caller.
-        // This can be any type, 'tap' is generic.
+        // Return something to the caller. 
+        // This can be any type, 'tap' is generic.        
         *n
     });
 
     format!("{} visits", count)
 }
-
 ```
 
 ## Extending Session by a Trait
@@ -76,8 +76,8 @@ The `.tap()` method is powerful, but sometimes you may wish for something more c
 Here is an example of using a custom trait and the `json_dotpath` crate to implement
 a polymorphic store based on serde serialization. 
 
-Note that this approach is prone to data races if you're accessing the session object multiple times per request, 
-since every method contains its own `.tap()`. It may be safer to simply call the `.dot_*()` methods manually in one shared closure.
+Note that this approach is prone to data races, since every method contains its own `.tap()`.
+It may be safer to simply call the `.dot_*()` methods manually in one shared closure.
 
 ```rust
 use serde_json::Value;

examples/dog_list/main.rs

@@ -1,20 +1,22 @@
+#![feature(proc_macro_hygiene, decl_macro)]
 #[macro_use]
 extern crate rocket;
 
-use rocket::response::content::RawHtml;
+use rocket::request::Form;
+use rocket::response::content::Html;
 use rocket::response::Redirect;
 
 type Session<'a> = rocket_session::Session<'a, Vec<String>>;
 
-#[launch]
-fn rocket() -> _ {
-    rocket::build()
+fn main() {
+    rocket::ignite()
         .attach(Session::fairing())
         .mount("/", routes![index, add, remove])
+        .launch();
 }
 
 #[get("/")]
-fn index(session: Session) -> RawHtml<String> {
+fn index(session: Session) -> Html<String> {
     let mut page = String::new();
     page.push_str(
         r#"
@@ -28,23 +30,38 @@ fn index(session: Session) -> RawHtml<String> {
             <ul>
         "#,
     );
+
     session.tap(|sess| {
         for (n, dog) in sess.iter().enumerate() {
             page.push_str(&format!(
-                r#"<li>&#x1F436; {} <a href="/remove/{}">Remove</a></li>"#,
+                r#"
+                <li>&#x1F436; {} <a href="/remove/{}">Remove</a></li>
+            "#,
                 dog, n
             ));
         }
     });
-    page.push_str("</ul>");
-    RawHtml(page)
+
+    page.push_str(
+        r#"
+            </ul>
+        "#,
+    );
+
+    Html(page)
+}
+
+#[derive(FromForm)]
+struct AddForm {
+    name: String,
 }
 
 #[post("/add", data = "<dog>")]
-fn add(session: Session, dog: String) -> Redirect {
+fn add(session: Session, dog: Form<AddForm>) -> Redirect {
     session.tap(move |sess| {
-        sess.push(dog);
+        sess.push(dog.into_inner().name);
     });
+
     Redirect::found("/")
 }
 
@@ -55,5 +72,6 @@ fn remove(session: Session, dog: usize) -> Redirect {
             sess.remove(dog);
         }
     });
+
     Redirect::found("/")
 }

examples/minimal/main.rs

@@ -1,28 +0,0 @@
-#[macro_use]
-extern crate rocket;
-
-use std::time::Duration;
-
-type Session<'a> = rocket_session::Session<'a, u64>;
-
-#[launch]
-fn rocket() -> _ {
-    // This session expires in 15 seconds as a demonstration of session configuration
-    rocket::build()
-        .attach(Session::fairing().with_lifetime(Duration::from_secs(15)))
-        .mount("/", routes![index])
-}
-
-#[get("/")]
-fn index(session: Session) -> String {
-    let count = session.tap(|n| {
-        // Change the stored value (it is &mut)
-        *n += 1;
-
-        // Return something to the caller.
-        // This can be any type, 'tap' is generic.
-        *n
-    });
-
-    format!("{} visits", count)
-}

examples/visit_counter/main.rs

@@ -2,10 +2,11 @@
 //!
 //! The expiry time is set to 10 seconds to illustrate how a session is cleared if inactive.
 
+#![feature(proc_macro_hygiene, decl_macro)]
 #[macro_use]
 extern crate rocket;
 
-use rocket::response::content::RawHtml;
+use rocket::response::content::Html;
 use std::time::Duration;
 
 #[derive(Default, Clone)]
@@ -17,9 +18,8 @@ struct SessionData {
 // It's convenient to define a type alias:
 type Session<'a> = rocket_session::Session<'a, SessionData>;
 
-#[launch]
-fn rocket() -> _ {
-    rocket::build()
+fn main() {
+    rocket::ignite()
         .attach(
             Session::fairing()
                 // 10 seconds of inactivity until session expires
@@ -30,10 +30,11 @@ fn rocket() -> _ {
                 .with_cookie_len(20),
         )
         .mount("/", routes![index, about])
+        .launch();
 }
 
 #[get("/")]
-fn index(session: Session) -> RawHtml<String> {
+fn index(session: Session) -> Html<String> {
     // Here we build the entire response inside the 'tap' closure.
 
     // While inside, the session is locked to parallel changes, e.g.
@@ -41,7 +42,7 @@ fn index(session: Session) -> RawHtml<String> {
     session.tap(|sess| {
         sess.visits1 += 1;
 
-        RawHtml(format!(
+        Html(format!(
             r##"
                 <!DOCTYPE html>
                 <h1>Home</h1>
@@ -54,14 +55,14 @@ fn index(session: Session) -> RawHtml<String> {
 }
 
 #[get("/about")]
-fn about(session: Session) -> RawHtml<String> {
+fn about(session: Session) -> Html<String> {
     // Here we return a value from the tap function and use it below
     let count = session.tap(|sess| {
         sess.visits2 += 1;
         sess.visits2
     });
 
-    RawHtml(format!(
+    Html(format!(
         r##"
             <!DOCTYPE html>
             <h1>About</h1>

src/lib.rs

@@ -1,20 +1,20 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fmt::{self, Display, Formatter};
-use std::marker::PhantomData;
-use std::ops::Add;
-use std::time::{Duration, Instant};
-
 use parking_lot::{Mutex, RwLock, RwLockUpgradableReadGuard};
-use rand::{rngs::OsRng, Rng};
+use rand::Rng;
+
 use rocket::{
     fairing::{self, Fairing, Info},
     http::{Cookie, Status},
-    outcome::Outcome,
     request::FromRequest,
-    Build, Request, Response, Rocket, State,
+    Outcome, Request, Response, Rocket, State,
 };
 
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fmt::{self, Display, Formatter};
+use std::marker::PhantomData;
+use std::ops::Add;
+use std::time::{Duration, Instant};
+
 /// Session store (shared state)
 #[derive(Debug)]
 pub struct SessionStore<D>
@@ -114,29 +114,29 @@ where
     D: 'static + Sync + Send + Default,
 {
     /// The shared state reference
-    store: &'a State<SessionStore<D>>,
+    store: State<'a, SessionStore<D>>,
     /// Session ID
     id: &'a SessionID,
 }
 
-#[rocket::async_trait]
-impl<'r, D> FromRequest<'r> for Session<'r, D>
+impl<'a, 'r, D> FromRequest<'a, 'r> for Session<'a, D>
 where
     D: 'static + Sync + Send + Default,
 {
     type Error = ();
 
-    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, (Status, Self::Error), ()> {
-        let store = request.guard::<&State<SessionStore<D>>>().await.unwrap();
+    fn from_request(request: &'a Request<'r>) -> Outcome<Self, (Status, Self::Error), ()> {
+        let store: State<SessionStore<D>> = request.guard().unwrap();
         Outcome::Success(Session {
             id: request.local_cache(|| {
                 let store_ug = store.inner.upgradable_read();
 
                 // Resolve session ID
-                let id = request
-                    .cookies()
-                    .get(&store.config.cookie_name)
-                    .map(|cookie| SessionID(cookie.value().to_string()));
+                let id = if let Some(cookie) = request.cookies().get(&store.config.cookie_name) {
+                    Some(SessionID(cookie.value().to_string()))
+                } else {
+                    None
+                };
 
                 let expires = Instant::now().add(store.config.lifespan);
 
@@ -176,10 +176,9 @@ where
 
                     // Find a new unique ID - we are still safely inside the write guard
                     let new_id = SessionID(loop {
-                        let token: String = OsRng
+                        let token: String = rand::thread_rng()
                             .sample_iter(&rand::distributions::Alphanumeric)
                             .take(store.config.cookie_len)
-                            .map(char::from)
                             .collect();
 
                         if !store_wg.sessions.contains_key(&token) {
@@ -295,7 +294,6 @@ where
     }
 }
 
-#[rocket::async_trait]
 impl<D> Fairing for SessionFairing<D>
 where
     D: 'static + Sync + Send + Default,
@@ -303,11 +301,11 @@ where
     fn info(&self) -> Info {
         Info {
             name: "Session",
-            kind: fairing::Kind::Ignite | fairing::Kind::Response,
+            kind: fairing::Kind::Attach | fairing::Kind::Response,
         }
     }
 
-    async fn on_ignite(&self, rocket: Rocket<Build>) -> Result<Rocket<Build>, Rocket<Build>> {
+    fn on_attach(&self, rocket: Rocket) -> Result<Rocket, Rocket> {
         // install the store singleton
         Ok(rocket.manage(SessionStore::<D> {
             inner: Default::default(),
@@ -315,7 +313,7 @@ where
         }))
     }
 
-    async fn on_response<'r>(&self, request: &'r Request<'_>, response: &mut Response) {
+    fn on_response<'r>(&self, request: &'r Request, response: &mut Response) {
         // send the session cookie, if session started
         let session = request.local_cache(|| SessionID("".to_string()));