use crate::config::SessionStorageConfig;
use crate::error::Result;
use crate::session::{storage::MemorySessionStorage, FingerprintMode, SessionStorage};
use std::sync::Arc;
use std::time::Duration;
pub struct SessionStorageFactory;
impl SessionStorageFactory {
pub async fn create_storage(
config: &SessionStorageConfig,
fingerprint_mode: FingerprintMode,
session_config: Option<&crate::config::SessionConfig>,
) -> Result<Arc<dyn SessionStorage>> {
let definitions = crate::definitions::get().await;
let defs = definitions.read().await;
if let Some(factory) = defs.get_session_storage_factory() {
log::info!("Using custom session storage from definitions");
let session_config = session_config
.cloned()
.unwrap_or(crate::config::SessionConfig {
enabled: true,
cookie_name: "rustf.sid".to_string(),
idle_timeout: 1800,
absolute_timeout: 86400,
same_site: "lax".to_string(),
fingerprint_mode: match fingerprint_mode {
FingerprintMode::Disabled => "disabled".to_string(),
FingerprintMode::Soft => "soft".to_string(),
FingerprintMode::Strict => "strict".to_string(),
},
storage: config.clone(),
exempt_routes: vec![],
});
match factory(&session_config) {
Ok(storage) => {
log::info!("Successfully created custom session storage");
return Ok(storage);
}
Err(e) => {
log::warn!(
"Failed to create custom session storage: {}, falling back to default",
e
);
}
}
}
match config {
SessionStorageConfig::Memory { cleanup_interval } => {
let storage = Arc::new(MemorySessionStorage::with_config(
Duration::from_secs(30 * 60), Duration::from_secs(*cleanup_interval),
fingerprint_mode,
));
Ok(storage)
}
SessionStorageConfig::Redis {
url,
prefix,
pool_size,
connection_timeout,
command_timeout,
} => {
#[cfg(feature = "redis")]
{
use crate::session::redis::RedisSessionStorage;
let storage = Arc::new(
RedisSessionStorage::from_url(
url,
prefix,
*pool_size,
fingerprint_mode,
Duration::from_secs(30 * 60), Duration::from_millis(*connection_timeout),
Duration::from_millis(*command_timeout),
)
.await?,
);
Ok(storage)
}
#[cfg(not(feature = "redis"))]
{
let _ = (url, prefix, pool_size, connection_timeout, command_timeout);
Err(crate::error::Error::internal(
"Redis session storage requires the `redis` feature (enabled by \
default). It was disabled via --no-default-features; re-enable it \
or provide a custom SessionStorage implementation."
.to_string(),
))
}
}
SessionStorageConfig::Database {
table: _,
connection_url: _,
cleanup_interval: _,
} => {
Err(crate::error::Error::internal(
"Database session storage must be implemented by the application. \
Please implement the SessionStorage trait for your database backend. \
See the documentation for examples using SQLx or other database libraries."
.to_string(),
))
}
}
}
pub fn create_memory_storage() -> Arc<dyn SessionStorage> {
Arc::new(MemorySessionStorage::new())
}
#[cfg(feature = "redis")]
pub async fn create_redis_storage(
redis_url: &str,
fingerprint_mode: FingerprintMode,
) -> Result<Arc<dyn SessionStorage>> {
use crate::session::redis::RedisSessionStorage;
let storage = Arc::new(
RedisSessionStorage::from_url(
redis_url,
"rustf:session:",
10,
fingerprint_mode,
Duration::from_secs(30 * 60), Duration::from_secs(5), Duration::from_secs(3), )
.await?,
);
Ok(storage)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::SessionStorageConfig;
use crate::session::FingerprintMode;
#[tokio::test]
async fn test_create_memory_storage() {
let config = SessionStorageConfig::Memory {
cleanup_interval: 300,
};
let storage = SessionStorageFactory::create_storage(&config, FingerprintMode::Soft, None)
.await
.unwrap();
assert_eq!(storage.backend_name(), "memory");
}
#[tokio::test]
async fn test_create_redis_storage() {
let config = SessionStorageConfig::Redis {
url: "redis://localhost:6379".to_string(),
prefix: "test:session:".to_string(),
pool_size: 5,
connection_timeout: 5000,
command_timeout: 3000,
};
if let Ok(storage) =
SessionStorageFactory::create_storage(&config, FingerprintMode::Soft, None).await
{
assert_eq!(storage.backend_name(), "redis");
} else {
println!("Redis not available, skipping Redis storage test");
}
}
#[tokio::test]
async fn test_create_default_memory_storage() {
let storage = SessionStorageFactory::create_memory_storage();
assert_eq!(storage.backend_name(), "memory");
}
}