Struct axum_session::SessionStore

pub struct SessionStore<T>where
    T: DatabasePool + Clone + Debug + Sync + Send + 'static,{
    pub client: Option<T>,
    pub(crate) inner: Arc<DashMap<String, SessionData>>,
    pub(crate) keys: Arc<DashMap<String, SessionKey>>,
    pub config: SessionConfig,
    pub(crate) timers: Arc<RwLock<SessionTimers>>,
    pub(crate) filter: Arc<RwLock<CountingBloomFilter>>,
}

Contains the main Services storage for all session’s and database access for persistant Sessions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();

Fields

client: Option<T>

Client for the database.

inner: Arc<DashMap<String, SessionData>>

locked Hashmap containing UserID and their session data.

keys: Arc<DashMap<String, SessionKey>>

locked Hashmap containing KeyID and their Key data.

config: SessionConfig

Session Configuration.

timers: Arc<RwLock<SessionTimers>>

Session Timers used for Clearing Memory and Database.

filter: Arc<RwLock<CountingBloomFilter>>

Filter used to keep track of what uuid’s exist.

Implementations

impl<T> SessionStore<T>where T: DatabasePool + Clone + Debug + Sync + Send + 'static,

pub async fn new( client: Option<T>, config: SessionConfig ) -> Result<Self, SessionError>

Constructs a New SessionStore and Creates the Database Table needed for the Session if it does not exist if client is not None.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();

pub(crate) async fn create_filter( client: &Option<T>, config: &SessionConfig ) -> Result<CountingBloomFilter, SessionError>

Used to create and Fill the Filter.

pub fn is_persistent(&self) -> bool

Checks if the database is in persistent mode.

Returns true if client is Some().

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();
let is_persistent = session_store.is_persistent();

pub async fn cleanup(&self) -> Result<Vec<String>, SessionError>

Cleans Expired sessions from the Database based on Utc::now().

If client is None it will return Ok(()).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();
async {
    let _ = session_store.cleanup().await.unwrap();
};

pub async fn count(&self) -> Result<i64, SessionError>

Returns count of existing sessions within database.

If client is None it will return Ok(0).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();
async {
    let count = session_store.count().await.unwrap();
};

pub(crate) async fn load_session( &self, cookie_value: String ) -> Result<Option<SessionData>, SessionError>

private internal function that loads a session’s data from the database using a UUID string.

If client is None it will return Ok(None).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.
• [‘SessionError::SerdeJson’] is returned if it failed to deserialize the sessions data.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();
let token = Uuid::new_v4();
async {
    let session_data = session_store.load_session(token.to_string()).await.unwrap();
};

pub(crate) async fn load_key( &self, cookie_value: String ) -> Result<Option<SessionKey>, SessionError>

private internal function that loads an encryption key for the session’s cookie from the database using a UUID string.

If client is None it will return Ok(None).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config).await.unwrap();
let token = Uuid::new_v4();
let key = Key::generate();
async {
    let session_key = session_store.load_key(token.to_string(), key).await.unwrap();
};

pub(crate) async fn store_session( &self, session: &SessionData ) -> Result<(), SessionError>

private internal function that stores a session’s data to the database.

If client is None it will return Ok(()).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.
• [‘SessionError::SerdeJson’] is returned if it failed to serialize the sessions data.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore, SessionData};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config.clone()).await.unwrap();
let token = Uuid::new_v4();
let session_data = SessionData::new(token, true, &config);

async {
    let _ = session_store.store_session(&session_data).await.unwrap();
};

pub(crate) async fn store_key( &self, key: &SessionKey, expires: i64 ) -> Result<(), SessionError>

private internal function that stores a keys data to the database as a session.

If client is None it will return Ok(()).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore, SessionKey};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config.clone()).await.unwrap();
let token = Uuid::new_v4();
let key = Key::generate();
let session_key = SessionKey::new(token);

async {
    let _ = session_store.store_key(&session_key, key).await.unwrap();
};

pub async fn clear_store(&self) -> Result<(), SessionError>

Deletes all sessions in the database.

If client is None it will return Ok(()).

Errors

• [‘SessionError::Sqlx’] is returned if database connection has failed or user does not have permissions.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config.clone()).await.unwrap();

async {
    let _ = session_store.clear_store().await.unwrap();
};

pub async fn clear(&mut self)

Deletes all sessions in Memory. This will also Clear those keys from the filter cache if a persistent database does not exist.

Examples

use axum_session::{SessionNullPool, SessionConfig, SessionStore};
use uuid::Uuid;

let config = SessionConfig::default();
let session_store = SessionStore::<SessionNullPool>::new(None, config.clone()).await.unwrap();

async {
    let _ = session_store.clear().await.unwrap();
};

pub(crate) fn service_session_data(&self, session: &Session<T>) -> bool

Attempts to load check and clear Data.

If no session is found returns false.

pub(crate) fn renew(&self, id: String)

pub(crate) fn renew_key(&self, id: String)

pub(crate) fn destroy(&self, id: String)

pub(crate) fn set_longterm(&self, id: String, longterm: bool)

pub(crate) fn set_store(&self, id: String, storable: bool)

pub(crate) fn update(&self, id: String)

pub(crate) fn get<N: DeserializeOwned>( &self, id: String, key: &str ) -> Option<N>

pub(crate) fn get_remove<N: DeserializeOwned>( &self, id: String, key: &str ) -> Option<N>

pub(crate) fn set(&self, id: String, key: &str, value: impl Serialize)

pub(crate) fn remove(&self, id: String, key: &str)

pub(crate) fn clear_session_data(&self, id: String)

pub(crate) fn set_session_request(&self, id: String)

pub(crate) fn remove_session_request(&self, id: String)

pub(crate) fn is_session_parallel(&self, id: String) -> bool

pub(crate) async fn count_sessions(&self) -> i64

pub(crate) fn auto_handles_expiry(&self) -> bool

pub(crate) fn verify(&self, id: String) -> Result<(), SessionError>

pub(crate) fn update_database_expires( &self, id: String ) -> Result<(), SessionError>

pub(crate) fn update_memory_expires( &self, id: String ) -> Result<(), SessionError>

pub(crate) async fn force_database_update( &self, id: String ) -> Result<(), SessionError>

pub(crate) fn memory_remove_session( &self, id: String ) -> Result<(), SessionError>

pub(crate) async fn database_remove_session( &self, id: String ) -> Result<(), SessionError>

Trait Implementations

impl<T> Clone for SessionStore<T>where T: DatabasePool + Clone + Debug + Sync + Send + 'static + Clone,

fn clone(&self) -> SessionStore<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SessionStore<T>where T: DatabasePool + Clone + Debug + Sync + Send + 'static + Debug,

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

Formats the value using the given formatter.

impl<T, S> FromRequestParts<S> for SessionStore<T>where T: DatabasePool + Clone + Debug + Sync + Send + 'static, S: Send + Sync,

type Rejection = (StatusCode, &'static str)

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>( parts: &'life0 mut Parts, _state: &'life1 S ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform the extraction.