Struct trillium_sessions::Session

pub struct Session { /* private fields */ }

The main session type.

Cloning and Serialization

The cookie_value field is not cloned or serialized, and it can only be read through into_cookie_value. The intent of this field is that it is set either by initialization or by a session store, and read exactly once in order to set the cookie value.

Change tracking session tracks whether any of its inner data

was changed since it was last serialized. Any sessoin store that does not undergo a serialization-deserialization cycle must call Session::reset_data_changed in order to reset the change tracker on an individual record.

Change tracking example

let mut session = Session::new();
assert!(!session.data_changed());

session.insert("key", 1)?;
assert!(session.data_changed());

session.reset_data_changed();
assert_eq!(session.get::<usize>("key").unwrap(), 1);
assert!(!session.data_changed());

session.insert("key", 2)?;
assert!(session.data_changed());
assert_eq!(session.get::<usize>("key").unwrap(), 2);

session.insert("key", 1)?;
assert!(session.data_changed(), "reverting the data still counts as a change");

session.reset_data_changed();
assert!(!session.data_changed());
session.remove("nonexistent key");
assert!(!session.data_changed());
session.remove("key");
assert!(session.data_changed());

Implementations

impl Session

pub fn new() -> Session

Create a new session. Generates a random id and matching cookie value. Does not set an expiry by default

Example

let session = Session::new();
assert_eq!(None, session.expiry());
assert!(session.into_cookie_value().is_some());

pub fn id_from_cookie_value(string: &str) -> Result<String, DecodeError>

applies a cryptographic hash function on a cookie value returned by Session::into_cookie_value to obtain the session id for that cookie. Returns an error if the cookie format is not recognized

Example

let session = Session::new();
let id = session.id().to_string();
let cookie_value = session.into_cookie_value().unwrap();
assert_eq!(id, Session::id_from_cookie_value(&cookie_value)?);

pub fn destroy(&mut self)

mark this session for destruction. the actual session record is not destroyed until the end of this response cycle.

Example

let mut session = Session::new();
assert!(!session.is_destroyed());
session.destroy();
assert!(session.is_destroyed());

pub fn is_destroyed(&self) -> bool

returns true if this session is marked for destruction

Example

let mut session = Session::new();
assert!(!session.is_destroyed());
session.destroy();
assert!(session.is_destroyed());

pub fn id(&self) -> &str

Gets the session id

Example

let session = Session::new();
let id = session.id().to_owned();
let cookie_value = session.into_cookie_value().unwrap();
assert_eq!(id, Session::id_from_cookie_value(&cookie_value)?);

pub fn insert(&mut self, key: &str, value: impl Serialize) -> Result<(), Error>

inserts a serializable value into the session hashmap. returns an error if the serialization was unsuccessful.

Example

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    legs: u8
}
let mut session = Session::new();
session.insert("user", User { name: "chashu".into(), legs: 4 }).expect("serializable");
assert_eq!(r#"{"name":"chashu","legs":4}"#, session.get_raw("user").unwrap());

pub fn insert_raw(&mut self, key: &str, value: String)

inserts a string into the session hashmap

Example

let mut session = Session::new();
session.insert_raw("ten", "10".to_string());
let ten: usize = session.get("ten").unwrap();
assert_eq!(ten, 10);

pub fn get<T>(&self, key: &str) -> Option<T>

where T: DeserializeOwned,

deserializes a type T out of the session hashmap

Example

let mut session = Session::new();
session.insert("key", vec![1, 2, 3]);
let numbers: Vec<usize> = session.get("key").unwrap();
assert_eq!(vec![1, 2, 3], numbers);

pub fn get_raw(&self, key: &str) -> Option<String>

returns the String value contained in the session hashmap

Example

let mut session = Session::new();
session.insert("key", vec![1, 2, 3]);
assert_eq!("[1,2,3]", session.get_raw("key").unwrap());

pub fn remove(&mut self, key: &str)

removes an entry from the session hashmap

Example

let mut session = Session::new();
session.insert("key", "value");
session.remove("key");
assert!(session.get_raw("key").is_none());
assert_eq!(session.len(), 0);

pub fn len(&self) -> usize

returns the number of elements in the session hashmap

Example

let mut session = Session::new();
assert_eq!(session.len(), 0);
session.insert("key", 0);
assert_eq!(session.len(), 1);

pub fn regenerate(&mut self)

Generates a new id and cookie for this session

Example

let mut session = Session::new();
let old_id = session.id().to_string();
session.regenerate();
assert!(session.id() != &old_id);
let new_id = session.id().to_string();
let cookie_value = session.into_cookie_value().unwrap();
assert_eq!(new_id, Session::id_from_cookie_value(&cookie_value)?);

pub fn set_cookie_value(&mut self, cookie_value: String)

sets the cookie value that this session will use to serialize itself. this should only be called by cookie stores. any other uses of this method will result in the cookie not getting correctly deserialized on subsequent requests.

Example

let mut session = Session::new();
session.set_cookie_value("hello".to_owned());
let cookie_value = session.into_cookie_value().unwrap();
assert_eq!(cookie_value, "hello".to_owned());

pub fn expiry(&self) -> Option<&DateTime<Utc>>

returns the expiry timestamp of this session, if there is one

Example

let mut session = Session::new();
assert_eq!(None, session.expiry());
session.expire_in(std::time::Duration::from_secs(1));
assert!(session.expiry().is_some());

pub fn set_expiry(&mut self, expiry: DateTime<Utc>)

assigns an expiry timestamp to this session

Example

let mut session = Session::new();
assert_eq!(None, session.expiry());
session.set_expiry(chrono::Utc::now());
assert!(session.expiry().is_some());

pub fn expire_in(&mut self, ttl: Duration)

assigns the expiry timestamp to a duration from the current time.

Example

let mut session = Session::new();
assert_eq!(None, session.expiry());
session.expire_in(std::time::Duration::from_secs(1));
assert!(session.expiry().is_some());

pub fn is_expired(&self) -> bool

predicate function to determine if this session is expired. returns false if there is no expiry set, or if it is in the past.

Example

let mut session = Session::new();
assert_eq!(None, session.expiry());
assert!(!session.is_expired());
session.expire_in(Duration::from_secs(1));
assert!(!session.is_expired());
task::sleep(Duration::from_secs(2)).await;
assert!(session.is_expired());

pub fn validate(self) -> Option<Session>

Ensures that this session is not expired. Returns None if it is expired

Example

let session = Session::new();
let mut session = session.validate().unwrap();
session.expire_in(Duration::from_secs(1));
let session = session.validate().unwrap();
task::sleep(Duration::from_secs(2)).await;
assert_eq!(None, session.validate());

pub fn data_changed(&self) -> bool

Checks if the data has been modified. This is based on the implementation of PartialEq for the inner data type.

Example

let mut session = Session::new();
assert!(!session.data_changed(), "new session is not changed");
session.insert("key", 1);
assert!(session.data_changed());

session.reset_data_changed();
assert!(!session.data_changed());
session.remove("key");
assert!(session.data_changed());

pub fn reset_data_changed(&self)

Resets data_changed dirty tracking. This is unnecessary for any session store that serializes the data to a string on storage.

Example

let mut session = Session::new();
assert!(!session.data_changed(), "new session is not changed");
session.insert("key", 1);
assert!(session.data_changed());

session.reset_data_changed();
assert!(!session.data_changed());
session.remove("key");
assert!(session.data_changed());

pub fn expires_in(&self) -> Option<Duration>

Ensures that this session is not expired. Returns None if it is expired

Example

let mut session = Session::new();
session.expire_in(Duration::from_secs(123));
let expires_in = session.expires_in().unwrap();
assert!(123 - expires_in.as_secs() < 2);

Duration from now to the expiry time of this session

pub fn into_cookie_value(self) -> Option<String>

takes the cookie value and consume this session. this is generally only performed by the session store

Example

let mut session = Session::new();
session.set_cookie_value("hello".to_owned());
let cookie_value = session.into_cookie_value().unwrap();
assert_eq!(cookie_value, "hello".to_owned());

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Session

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Session

fn default() -> Session

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Session

fn deserialize<__D>( __deserializer: __D ) -> Result<Session, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Session

fn eq(&self, other: &Session) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Session

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.