use crate::error::{Error, Result};
use crate::session::{
FingerprintMode, SessionData, SessionFingerprint, SessionStorage, StorageStats,
};
use async_trait::async_trait;
use deadpool_redis::{Config, Pool, PoolConfig, Runtime};
use redis::AsyncCommands;
use serde_json;
use simd_json;
use std::collections::HashMap;
use std::net::IpAddr;
use std::time::Duration;
#[derive(Clone)]
pub struct RedisSessionStorage {
pool: Pool,
prefix: String,
fingerprint_mode: FingerprintMode,
default_ttl: Duration,
#[allow(dead_code)]
connection_timeout: Duration,
command_timeout: Duration,
}
impl RedisSessionStorage {
pub async fn new() -> Result<Self> {
Self::from_url(
"redis://localhost:6379",
"rustf:session:",
10,
FingerprintMode::Soft,
Duration::from_secs(1800), Duration::from_secs(5), Duration::from_secs(3), )
.await
}
pub async fn from_url(
redis_url: &str,
prefix: &str,
pool_size: usize,
fingerprint_mode: FingerprintMode,
default_ttl: Duration,
connection_timeout: Duration,
command_timeout: Duration,
) -> Result<Self> {
let mut cfg = Config::from_url(redis_url);
cfg.pool = Some(PoolConfig {
max_size: pool_size,
..Default::default()
});
let pool = cfg.create_pool(Some(Runtime::Tokio1))?;
let mut conn = pool.get().await?;
tokio::time::timeout(
command_timeout,
redis::cmd("PING").query_async::<String>(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis connection test timed out"))?
.map_err(|e| Error::internal(format!("Redis connection test failed: {}", e)))?;
Ok(Self {
pool,
prefix: prefix.to_string(),
fingerprint_mode,
default_ttl,
connection_timeout,
command_timeout,
})
}
pub async fn from_config(
config: Config,
prefix: &str,
fingerprint_mode: FingerprintMode,
default_ttl: Duration,
connection_timeout: Duration,
command_timeout: Duration,
) -> Result<Self> {
let pool = config.create_pool(Some(Runtime::Tokio1))?;
let mut conn = pool.get().await?;
tokio::time::timeout(
command_timeout,
redis::cmd("PING").query_async::<String>(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis connection test timed out"))?
.map_err(|e| Error::internal(format!("Redis connection test failed: {}", e)))?;
Ok(Self {
pool,
prefix: prefix.to_string(),
fingerprint_mode,
default_ttl,
connection_timeout,
command_timeout,
})
}
fn session_key(&self, session_id: &str) -> String {
format!("{}{}", self.prefix, session_id)
}
fn validate_fingerprint(
&self,
stored: &SessionFingerprint,
current: &SessionFingerprint,
) -> bool {
match self.fingerprint_mode {
FingerprintMode::Disabled => true,
FingerprintMode::Soft => {
let stored_ip_prefix = Self::extract_ip_prefix(&stored.ip);
let current_ip_prefix = Self::extract_ip_prefix(¤t.ip);
let stored_ua_hash = Self::hash_user_agent(&stored.user_agent);
let current_ua_hash = Self::hash_user_agent(¤t.user_agent);
stored_ip_prefix == current_ip_prefix && stored_ua_hash == current_ua_hash
}
FingerprintMode::Strict => {
stored.ip == current.ip && stored.user_agent == current.user_agent
}
}
}
fn extract_ip_prefix(ip: &str) -> String {
if let Ok(ip_addr) = ip.parse::<IpAddr>() {
match ip_addr {
IpAddr::V4(ipv4) => {
let octets = ipv4.octets();
format!("{}.{}.{}", octets[0], octets[1], octets[2])
}
IpAddr::V6(ipv6) => {
let segments = ipv6.segments();
format!(
"{:x}:{:x}:{:x}:{:x}",
segments[0], segments[1], segments[2], segments[3]
)
}
}
} else {
if ip.contains(':') {
let parts: Vec<&str> = ip.split(':').take(4).collect();
if parts.len() == 4 {
parts.join(":")
} else {
ip.split(':').take(3).collect::<Vec<_>>().join(":")
}
} else {
ip.split('.').take(3).collect::<Vec<_>>().join(".")
}
}
}
fn hash_user_agent(user_agent: &str) -> String {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
let mut hasher = DefaultHasher::new();
user_agent.hash(&mut hasher);
format!("{:x}", hasher.finish())
}
}
#[async_trait]
impl SessionStorage for RedisSessionStorage {
async fn get(
&self,
session_id: &str,
current_fingerprint: Option<&SessionFingerprint>,
) -> Result<Option<SessionData>> {
let mut conn = self.pool.get().await?;
let key = self.session_key(session_id);
let json_data: Option<String> =
tokio::time::timeout(self.command_timeout, conn.get::<&str, Option<String>>(&key))
.await
.map_err(|_| Error::internal("Redis GET operation timed out"))?
.map_err(|e| Error::internal(format!("Redis GET failed: {}", e)))?;
match json_data {
Some(data) => {
let mut json_bytes = data.into_bytes();
let mut session_data: SessionData = simd_json::from_slice(&mut json_bytes)
.map_err(|e| {
Error::internal(format!(
"Failed to deserialize session data (corrupted?): {}",
e
))
})?;
if let Some(current_fp) = current_fingerprint {
if let Some(ref stored_fp) = session_data.fingerprint {
if !self.validate_fingerprint(stored_fp, current_fp) {
log::warn!(
"RedisStorage: Session {} failed fingerprint validation",
session_id
);
return Ok(None);
}
}
}
let current_ttl: i64 = tokio::time::timeout(
self.command_timeout,
redis::cmd("TTL").arg(&key).query_async(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis TTL operation timed out"))?
.map_err(|e| Error::internal(format!("Redis TTL failed: {}", e)))?;
session_data.touch();
let ttl_to_use = if current_ttl > 0 {
current_ttl as u64
} else if current_ttl == -1 {
tokio::time::timeout(
self.command_timeout,
redis::cmd("EXPIRE")
.arg(&key)
.arg(self.default_ttl.as_secs())
.query_async::<()>(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis EXPIRE operation timed out"))?
.map_err(|e| Error::internal(format!("Redis EXPIRE failed: {}", e)))?;
self.default_ttl.as_secs()
} else {
return Ok(None);
};
if ttl_to_use < (self.default_ttl.as_secs() / 2) {
tokio::time::timeout(
self.command_timeout,
redis::cmd("EXPIRE")
.arg(&key)
.arg(self.default_ttl.as_secs())
.query_async::<()>(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis EXPIRE operation timed out"))?
.map_err(|e| Error::internal(format!("Redis EXPIRE failed: {}", e)))?;
}
Ok(Some(session_data))
}
None => Ok(None),
}
}
async fn set(&self, session_id: &str, data: &SessionData, ttl: Duration) -> Result<()> {
let mut conn = self.pool.get().await?;
let key = self.session_key(session_id);
let json_data = serde_json::to_string(data)
.map_err(|e| Error::internal(format!("Failed to serialize session data: {}", e)))?;
let ttl_seconds = ttl.as_secs();
tokio::time::timeout(
self.command_timeout,
conn.set_ex::<&str, &str, ()>(&key, &json_data, ttl_seconds),
)
.await
.map_err(|_| Error::internal("Redis SETEX operation timed out"))?
.map_err(|e| Error::internal(format!("Redis SETEX failed: {}", e)))?;
Ok(())
}
async fn delete(&self, session_id: &str) -> Result<()> {
let mut conn = self.pool.get().await?;
let key = self.session_key(session_id);
tokio::time::timeout(self.command_timeout, conn.del::<&str, i32>(&key))
.await
.map_err(|_| Error::internal("Redis DEL operation timed out"))?
.map_err(|e| Error::internal(format!("Redis DEL failed: {}", e)))?;
Ok(())
}
async fn exists(&self, session_id: &str) -> Result<bool> {
let mut conn = self.pool.get().await?;
let key = self.session_key(session_id);
let exists: bool =
tokio::time::timeout(self.command_timeout, conn.exists::<&str, bool>(&key))
.await
.map_err(|_| Error::internal("Redis EXISTS operation timed out"))?
.map_err(|e| Error::internal(format!("Redis EXISTS failed: {}", e)))?;
Ok(exists)
}
async fn cleanup_expired(&self) -> Result<usize> {
Ok(0)
}
fn backend_name(&self) -> &'static str {
"redis"
}
async fn stats(&self) -> Result<StorageStats> {
let mut conn = self.pool.get().await?;
let pattern = format!("{}*", self.prefix);
let mut total_sessions = 0;
let mut cursor = 0u64;
loop {
let (new_cursor, keys): (u64, Vec<String>) = tokio::time::timeout(
self.command_timeout,
redis::cmd("SCAN")
.arg(cursor)
.arg("MATCH")
.arg(&pattern)
.arg("COUNT")
.arg(1000) .query_async(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis SCAN operation timed out"))?
.map_err(|e| Error::internal(format!("Redis SCAN failed: {}", e)))?;
total_sessions += keys.len();
cursor = new_cursor;
if cursor == 0 {
break;
}
}
let info: String = tokio::time::timeout(
self.command_timeout,
redis::cmd("INFO").arg("memory").query_async(&mut conn),
)
.await
.map_err(|_| Error::internal("Redis INFO operation timed out"))?
.map_err(|e| Error::internal(format!("Redis INFO failed: {}", e)))?;
let mut backend_metrics = HashMap::new();
backend_metrics.insert("redis_pattern".to_string(), pattern);
backend_metrics.insert("scan_method".to_string(), "non-blocking".to_string());
for line in info.lines() {
if line.starts_with("used_memory_human:") {
let memory = line.split(':').nth(1).unwrap_or("unknown").trim();
backend_metrics.insert("redis_memory_used".to_string(), memory.to_string());
}
if line.starts_with("used_memory_peak_human:") {
let memory = line.split(':').nth(1).unwrap_or("unknown").trim();
backend_metrics.insert("redis_memory_peak".to_string(), memory.to_string());
}
}
Ok(StorageStats {
total_sessions,
active_sessions: total_sessions, expired_sessions: 0, backend_metrics,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use tokio::test;
async fn try_test_storage() -> Option<RedisSessionStorage> {
match RedisSessionStorage::new().await {
Ok(storage) => Some(storage),
Err(err) => {
if std::env::var_os("RUSTF_TEST_REDIS").is_some() {
panic!(
"RUSTF_TEST_REDIS is set but Redis is unreachable: {err}. \
Start Redis on 127.0.0.1:6379 to run Redis session tests."
);
}
eprintln!("skipping Redis session test — no server on 127.0.0.1:6379 ({err})");
None
}
}
}
#[test]
async fn test_redis_storage_get_missing_fingerprint() {
let Some(storage) = try_test_storage().await else {
return;
};
let session_id = "test_missing_fingerprint";
let result = storage.get(session_id, None).await;
assert!(result.is_ok());
assert!(result.unwrap().is_none());
}
#[test]
async fn test_redis_storage_basic_operations() {
let Some(storage) = try_test_storage().await else {
return;
};
let session_id = "test_redis_session_123";
assert!(storage.get(session_id, None).await.unwrap().is_none());
assert!(!storage.exists(session_id).await.unwrap());
let mut session_data = SessionData::new();
if let serde_json::Value::Object(ref mut map) = session_data.data {
map.insert("user_id".to_string(), serde_json::Value::Number(123.into()));
}
if let serde_json::Value::Object(ref mut map) = session_data.flash {
map.insert(
"message".to_string(),
serde_json::Value::String("Hello Redis".to_string()),
);
}
storage
.set(session_id, &session_data, Duration::from_secs(3600))
.await
.unwrap();
assert!(storage.exists(session_id).await.unwrap());
let retrieved = storage.get(session_id, None).await.unwrap().unwrap();
assert_eq!(
retrieved.data.get("user_id").unwrap(),
&serde_json::Value::Number(123.into())
);
assert_eq!(
retrieved.flash.get("message").unwrap(),
&serde_json::Value::String("Hello Redis".to_string())
);
storage.delete(session_id).await.unwrap();
assert!(storage.get(session_id, None).await.unwrap().is_none());
assert!(!storage.exists(session_id).await.unwrap());
}
#[test]
async fn test_redis_storage_ttl() {
let Some(storage) = try_test_storage().await else {
return;
};
let session_id = "expiring_redis_session";
let session_data = SessionData::new();
storage
.set(session_id, &session_data, Duration::from_secs(1))
.await
.unwrap();
assert!(storage.exists(session_id).await.unwrap());
tokio::time::sleep(Duration::from_secs(2)).await;
assert!(storage.get(session_id, None).await.unwrap().is_none());
assert!(!storage.exists(session_id).await.unwrap());
}
#[test]
async fn test_redis_storage_stats() {
let Some(storage) = try_test_storage().await else {
return;
};
for i in 0..3 {
let session_id = format!("redis_stats_session_{}", i);
let _ = storage.delete(&session_id).await;
}
for i in 0..3 {
let session_id = format!("redis_stats_session_{}", i);
let mut session_data = SessionData::new();
if let serde_json::Value::Object(ref mut map) = session_data.data {
map.insert("counter".to_string(), serde_json::Value::Number(i.into()));
}
storage
.set(&session_id, &session_data, Duration::from_secs(3600))
.await
.unwrap();
}
let stats = storage.stats().await.unwrap();
assert!(stats.total_sessions >= 3); assert_eq!(stats.active_sessions, stats.total_sessions); assert_eq!(stats.expired_sessions, 0); assert!(stats.backend_metrics.contains_key("redis_pattern"));
for i in 0..3 {
let session_id = format!("redis_stats_session_{}", i);
let _ = storage.delete(&session_id).await;
}
}
#[test]
async fn test_redis_storage_concurrent_access() {
let Some(storage) = try_test_storage().await else {
return;
};
let session_id = "concurrent_redis_session";
let _ = storage.delete(session_id).await;
let session_data = SessionData::new();
storage
.set(session_id, &session_data, Duration::from_secs(3600))
.await
.unwrap();
let handles: Vec<_> = (0..10)
.map(|i| {
let storage_clone = storage.clone();
let session_id = session_id.to_string();
tokio::spawn(async move {
let session_opt = storage_clone.get(&session_id, None).await.unwrap();
assert!(session_opt.is_some());
let mut session_data = session_opt.unwrap();
if let serde_json::Value::Object(ref mut map) = session_data.data {
map.insert(
format!("task_{}", i),
serde_json::Value::String(format!("value_{}", i)),
);
}
storage_clone
.set(&session_id, &session_data, Duration::from_secs(3600))
.await
.unwrap();
})
})
.collect();
for handle in handles {
handle.await.unwrap();
}
let final_session = storage.get(session_id, None).await.unwrap().unwrap();
if let serde_json::Value::Object(ref map) = final_session.data {
assert!(!map.is_empty());
} else {
panic!("Expected data to be an object");
}
storage.delete(session_id).await.unwrap();
}
}