Skip to content

Commit

Permalink
redefine SessionStore to take &mut Session and &str
Browse files Browse the repository at this point in the history
  • Loading branch information
@jbr
jbr committed Mar 30, 2023
1 parent a1a094e commit 60aaa4f
Show file tree
Hide file tree
Showing 5 changed files with 60 additions and 53 deletions.
38 changes: 19 additions & 19 deletions src/cookie_store.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,18 +51,18 @@ pub enum CookieStoreError {
impl SessionStore for CookieStore {
type Error = CookieStoreError;

async fn load_session(&self, cookie_value: String) -> Result<Option<Session>, Self::Error> {
async fn load_session(&self, cookie_value: &str) -> Result<Option<Session>, Self::Error> {
let serialized = BASE64.decode(cookie_value)?;
let session: Session = bincode_json::from_slice(&serialized)?;
Ok(session.validate())
}

async fn store_session(&self, session: Session) -> Result<Option<String>, Self::Error> {
let serialized = bincode_json::to_vec(&session)?;
async fn store_session(&self, session: &mut Session) -> Result<Option<String>, Self::Error> {
let serialized = bincode_json::to_vec(session)?;
Ok(Some(BASE64.encode(serialized)))
}

async fn destroy_session(&self, _session: Session) -> Result<(), Self::Error> {
async fn destroy_session(&self, _session: &mut Session) -> Result<(), Self::Error> {
Ok(())
}

Expand All @@ -82,8 +82,8 @@ mod tests {
let mut session = Session::new();
session.insert("key", "Hello")?;
let cloned = session.clone();
let cookie_value = store.store_session(session).await?.unwrap();
let loaded_session = store.load_session(cookie_value).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();
let loaded_session = store.load_session(&cookie_value).await?.unwrap();
assert_eq!(cloned.id(), loaded_session.id());
assert_eq!("Hello", &loaded_session.get::<String>("key").unwrap());
assert!(!loaded_session.is_expired());
Expand All @@ -97,14 +97,14 @@ mod tests {
let mut session = Session::new();

session.insert("key", "value")?;
let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
let mut session = store.load_session(&cookie_value.clone()).await?.unwrap();
session.insert("key", "other value")?;

let new_cookie_value = store.store_session(session).await?.unwrap();
let session = store.load_session(new_cookie_value).await?.unwrap();
assert_eq!(&session.get::<String>("key").unwrap(), "other value");
let new_cookie_value = store.store_session(&mut session).await?.unwrap();
let session = store.load_session(&new_cookie_value).await?.unwrap();
assert_eq!(&mut session.get::<String>("key").unwrap(), "other value");

Ok(())
}
Expand All @@ -115,20 +115,20 @@ mod tests {
let mut session = Session::new();
session.expire_in(Duration::from_secs(1));
let original_expires = *session.expiry().unwrap();
let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
let mut session = store.load_session(&cookie_value.clone()).await?.unwrap();

assert_eq!(session.expiry().unwrap(), &original_expires);
session.expire_in(Duration::from_secs(3));
let new_expires = *session.expiry().unwrap();
let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let session = store.load_session(cookie_value.clone()).await?.unwrap();
let session = store.load_session(&cookie_value.clone()).await?.unwrap();
assert_eq!(session.expiry().unwrap(), &new_expires);

task::sleep(Duration::from_secs(3)).await;
assert_eq!(None, store.load_session(cookie_value).await?);
assert_eq!(None, store.load_session(&cookie_value).await?);

Ok(())
}
Expand All @@ -141,16 +141,16 @@ mod tests {
session.insert("key", "value")?;
let cloned = session.clone();

let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let loaded_session = store.load_session(cookie_value.clone()).await?.unwrap();
let loaded_session = store.load_session(&cookie_value.clone()).await?.unwrap();
assert_eq!(cloned.id(), loaded_session.id());
assert_eq!("value", &*loaded_session.get::<String>("key").unwrap());

assert!(!loaded_session.is_expired());

task::sleep(Duration::from_secs(3)).await;
assert_eq!(None, store.load_session(cookie_value).await?);
assert_eq!(None, store.load_session(&cookie_value).await?);

Ok(())
}
Expand Down
6 changes: 3 additions & 3 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,10 +22,10 @@
//! assert!(session.data_changed());
//!
//! // retrieve the cookie value to store in a session cookie
//! let cookie_value = store.store_session(session).await?.unwrap();
//! let cookie_value = store.store_session(&mut session).await?.unwrap();
//!
//! // Retrieve the session using the cookie.
//! let session = store.load_session(cookie_value).await?.unwrap();
//! let session = store.load_session(&cookie_value).await?.unwrap();
//! assert_eq!(session.get::<usize>("user_id").unwrap(), 1);
//! assert!(!session.data_changed());
//! #
Expand Down Expand Up @@ -58,6 +58,6 @@ pub use cookie_store::{CookieStore, CookieStoreError};
#[cfg(feature = "memory-store")]
pub use memory_store::{MemoryStore, MemoryStoreError};
pub use session::Session;
pub use session_store::SessionStore;
pub use session_store::{SessionStore};

pub use async_trait::async_trait;
57 changes: 29 additions & 28 deletions src/memory_store.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,8 +39,8 @@ pub enum MemoryStoreError {
impl SessionStore for MemoryStore {
type Error = MemoryStoreError;

async fn load_session(&self, cookie_value: String) -> Result<Option<Session>, Self::Error> {
let id = Session::id_from_cookie_value(&cookie_value)?;
async fn load_session(&self, cookie_value: &str) -> Result<Option<Session>, Self::Error> {
let id = Session::id_from_cookie_value(cookie_value)?;
log::trace!("loading session by id `{}`", id);
let Occupied(entry) = self.0.entry(id) else {
return Ok(None);
Expand All @@ -54,14 +54,15 @@ impl SessionStore for MemoryStore {
}
}

async fn store_session(&self, mut session: Session) -> Result<Option<String>, Self::Error> {
async fn store_session(&self, session: &mut Session) -> Result<Option<String>, Self::Error> {
log::trace!("storing session by id `{}`", session.id());
session.reset_data_changed();
let cookie_value = session.take_cookie_value();
self.0.insert(session.id().to_string(), session.clone());
Ok(session.into_cookie_value())
Ok(cookie_value)
}

async fn destroy_session(&self, session: Session) -> Result<(), Self::Error> {
async fn destroy_session(&self, session: &mut Session) -> Result<(), Self::Error> {
log::trace!("destroying session by id `{}`", session.id());
self.0.remove(session.id());
Ok(())
Expand Down Expand Up @@ -95,7 +96,7 @@ impl MemoryStore {
/// # fn main() -> Result<(), Box<dyn std::error::Error>> { async_std::task::block_on(async {
/// let mut store = MemoryStore::new();
/// assert_eq!(store.count(), 0);
/// store.store_session(Session::new()).await?;
/// store.store_session(&mut Session::new()).await?;
/// assert_eq!(store.count(), 1);
/// # Ok(()) }) }
/// ```
Expand All @@ -115,8 +116,8 @@ mod tests {
let mut session = Session::new();
session.insert("key", "Hello")?;
let cloned = session.clone();
let cookie_value = store.store_session(session).await?.unwrap();
let loaded_session = store.load_session(cookie_value).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();
let loaded_session = store.load_session(&cookie_value).await?.unwrap();
assert_eq!(cloned.id(), loaded_session.id());
assert_eq!("Hello", &loaded_session.get::<String>("key").unwrap());
assert!(!loaded_session.is_expired());
Expand All @@ -130,14 +131,14 @@ mod tests {
let mut session = Session::new();

session.insert("key", "value")?;
let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
let mut session = store.load_session(&cookie_value).await?.unwrap();
session.insert("key", "other value")?;

assert_eq!(store.store_session(session).await?, None);
let session = store.load_session(cookie_value).await?.unwrap();
assert_eq!(&session.get::<String>("key").unwrap(), "other value");
assert_eq!(store.store_session(&mut session).await?, None);
let session = store.load_session(&cookie_value).await?.unwrap();
assert_eq!(&mut session.get::<String>("key").unwrap(), "other value");

Ok(())
}
Expand All @@ -148,20 +149,20 @@ mod tests {
let mut session = Session::new();
session.expire_in(Duration::from_secs(1));
let original_expires = *session.expiry().unwrap();
let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
let mut session = store.load_session(&cookie_value).await?.unwrap();

assert_eq!(session.expiry().unwrap(), &original_expires);
session.expire_in(Duration::from_secs(3));
let new_expires = *session.expiry().unwrap();
assert_eq!(None, store.store_session(session).await?);
assert_eq!(None, store.store_session(&mut session).await?);

let session = store.load_session(cookie_value.clone()).await?.unwrap();
let session = store.load_session(&cookie_value).await?.unwrap();
assert_eq!(session.expiry().unwrap(), &new_expires);

task::sleep(Duration::from_secs(3)).await;
assert_eq!(None, store.load_session(cookie_value).await?);
assert_eq!(None, store.load_session(&cookie_value).await?);

Ok(())
}
Expand All @@ -174,16 +175,16 @@ mod tests {
session.insert("key", "value")?;
let cloned = session.clone();

let cookie_value = store.store_session(session).await?.unwrap();
let cookie_value = store.store_session(&mut session).await?.unwrap();

let loaded_session = store.load_session(cookie_value.clone()).await?.unwrap();
let loaded_session = store.load_session(&cookie_value).await?.unwrap();
assert_eq!(cloned.id(), loaded_session.id());
assert_eq!("value", &*loaded_session.get::<String>("key").unwrap());

assert!(!loaded_session.is_expired());

task::sleep(Duration::from_secs(3)).await;
assert_eq!(None, store.load_session(cookie_value).await?);
assert_eq!(None, store.load_session(&cookie_value).await?);

Ok(())
}
Expand All @@ -192,26 +193,26 @@ mod tests {
async fn destroying_a_single_session() -> Result<(), MemoryStoreError> {
let store = MemoryStore::new();
for _ in 0..3i8 {
store.store_session(Session::new()).await?;
store.store_session(&mut Session::new()).await?;
}

let cookie = store.store_session(Session::new()).await?.unwrap();
let cookie = store.store_session(&mut Session::new()).await?.unwrap();
assert_eq!(4, store.count());
let session = store.load_session(cookie.clone()).await?.unwrap();
store.destroy_session(session.clone()).await?;
assert_eq!(None, store.load_session(cookie).await?);
let mut session = store.load_session(&cookie).await?.unwrap();
store.destroy_session(&mut session).await?;
assert_eq!(None, store.load_session(&cookie).await?);
assert_eq!(3, store.count());

// attempting to destroy the session again is not an error
assert!(store.destroy_session(session).await.is_ok());
assert!(store.destroy_session(&mut session).await.is_ok());
Ok(())
}

#[async_std::test]
async fn clearing_the_whole_store() -> Result<(), MemoryStoreError> {
let store = MemoryStore::new();
for _ in 0..3i8 {
store.store_session(Session::new()).await?;
store.store_session(&mut Session::new()).await?;
}

assert_eq!(3, store.count());
Expand Down
6 changes: 6 additions & 0 deletions src/session.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -581,6 +581,12 @@ impl Session {
/// # Ok(()) }) }
/// ```
pub fn into_cookie_value(mut self) -> Option<String> {
self.take_cookie_value()
}

/// take the cookie value. this is generally only performed by a
/// session store.
pub fn take_cookie_value(&mut self) -> Option<String> {
self.cookie_value.take()
}
}
Expand Down
6 changes: 3 additions & 3 deletions src/session_store.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,16 +11,16 @@ pub trait SessionStore {
/// The input is expected to be the value of an identifying
/// cookie. This will then be parsed by the session middleware
/// into a session if possible
async fn load_session(&self, cookie_value: String) -> Result<Option<Session>, Self::Error>;
async fn load_session(&self, cookie_value: &str) -> Result<Option<Session>, Self::Error>;

/// Store a session on the storage backend.
///
/// The return value is the value of the cookie to store for the
/// user that represents this session
async fn store_session(&self, session: Session) -> Result<Option<String>, Self::Error>;
async fn store_session(&self, session: &mut Session) -> Result<Option<String>, Self::Error>;

/// Remove a session from the session store
async fn destroy_session(&self, session: Session) -> Result<(), Self::Error>;
async fn destroy_session(&self, session: &mut Session) -> Result<(), Self::Error>;

/// Empties the entire store, destroying all sessions
async fn clear_store(&self) -> Result<(), Self::Error>;
Expand Down

0 comments on commit 60aaa4f

Please sign in to comment.