Struct SessionManager 

pub struct SessionManager { /* private fields */ }

Session manager for handling user sessions.

Example

use auth_framework::auth_modular::SessionManager;
use std::sync::Arc;

let mgr = SessionManager::new(storage.clone());
let sid = mgr.create_session("user-1", Duration::from_secs(3600), None, None).await?;

Implementations

impl SessionManager

pub fn new(storage: Arc<dyn AuthStorage>) -> Self

Create a new session manager.

Example

use auth_framework::auth_modular::SessionManager;
let mgr = SessionManager::new(storage.clone());

pub fn set_distributed_store(&mut self, store: Arc<dyn DistributedSessionStore>)

Replace the distributed session store (multi-node deployments).

Example

mgr.set_distributed_store(Arc::new(RedisSessionStore::new("redis://...").await?));

pub async fn create_session( &self, user_id: &str, expires_in: Duration, ip_address: Option<String>, user_agent: Option<String>, ) -> Result<String>

Create a new session.

Example

let sid = mgr.create_session(
    "user-1",
    Duration::from_secs(3600),
    Some("127.0.0.1".into()),
    Some("Mozilla/5.0".into()),
).await?;

pub async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>>

Get session information.

Returns None if the session does not exist or has expired.

Example

if let Some(session) = mgr.get_session("sess_abc").await? {
    println!("user: {}", session.user_id);
}

pub async fn delete_session(&self, session_id: &str) -> Result<()>

Delete a session.

Example

mgr.delete_session("sess_abc").await?;

pub async fn update_session_activity(&self, session_id: &str) -> Result<()>

Update session last activity timestamp.

Example

mgr.update_session_activity("sess_abc").await?;

pub async fn get_user_sessions( &self, user_id: &str, ) -> Result<Vec<(String, SessionData)>>

Get all active (non-expired) sessions for a user.

Example

let sessions = mgr.get_user_sessions("user-1").await?;
for (id, data) in &sessions {
    println!("session {}: ip={:?}", id, data.ip_address);
}

pub async fn delete_user_sessions(&self, user_id: &str) -> Result<()>

Delete all sessions for a user.

Example

mgr.delete_user_sessions("user-1").await?;

pub async fn cleanup_expired_sessions(&self) -> Result<()>

Clean up expired sessions from storage.

Example

mgr.cleanup_expired_sessions().await?;

pub async fn validate_session(&self, session_id: &str) -> Result<Option<String>>

Validate a session and return the owning user ID.

Returns None if the session is missing or expired.

Example

if let Some(user_id) = mgr.validate_session("sess_abc").await? {
    println!("session belongs to {}", user_id);
}

pub async fn extend_session( &self, session_id: &str, additional_time: Duration, ) -> Result<()>

Extend session expiration by additional_time.

Example

mgr.extend_session("sess_abc", Duration::from_secs(1800)).await?;

pub async fn create_session_limited( &self, user_id: &str, expires_in: Duration, ip_address: Option<String>, user_agent: Option<String>, ) -> Result<(String, u64)>

Create a new session with resource-limit guards.

Enforces a global cap of 100 000 total sessions and a per-user cap of 50 sessions to prevent DoS / resource exhaustion.

Returns (session_id, new_total_count) so the caller can update monitoring.

Example

let (sid, total) = mgr.create_session_limited(
    "user-1", Duration::from_secs(3600), None, None,
).await?;
println!("created session {} (total active: {})", sid, total);

pub async fn count_active_sessions(&self) -> Result<u64>

Count the number of currently active sessions.

Used for security audit statistics.

Example

let n = mgr.count_active_sessions().await?;
println!("{} active sessions", n);

pub async fn get_session_security_metrics( &self, ) -> Result<HashMap<String, Value>>

Get security metrics for sessions.

Example

let metrics = mgr.get_session_security_metrics().await?;
println!("active: {:?}", metrics.get("active_sessions"));

pub async fn coordinate_distributed_sessions( &self, ) -> Result<SessionCoordinationStats>

Coordinate session state across distributed instances.

Example

let stats = mgr.coordinate_distributed_sessions().await?;
println!("synced: {}", stats.synchronized_sessions);

pub async fn synchronize_session(&self, session_id: &str) -> Result<()>

Synchronize a specific session with remote instances.

Example

mgr.synchronize_session("sess_abc").await?;