use crate::errors::StorageError;
use crate::{
errors::{AuthError, Result},
storage::{AuthStorage, SessionData},
tokens::AuthToken,
};
use async_trait::async_trait;
use redis::aio::MultiplexedConnection;
use redis::{AsyncCommands, Client};
use serde_json;
use std::time::Duration;
#[derive(Clone)]
pub struct RedisStorage {
client: Client,
key_prefix: String,
default_ttl: Duration,
}
impl RedisStorage {
pub async fn new(redis_url: &str) -> Result<Self> {
let client = Client::open(redis_url)
.map_err(|e| AuthError::Storage(StorageError::connection_failed(e.to_string())))?;
Ok(Self {
client,
key_prefix: "auth:".to_string(),
default_ttl: Duration::from_secs(3600), })
}
pub async fn with_config(
redis_url: &str,
key_prefix: impl Into<String>,
default_ttl: Duration,
) -> Result<Self> {
let mut storage = Self::new(redis_url).await?;
storage.key_prefix = key_prefix.into();
storage.default_ttl = default_ttl;
Ok(storage)
}
fn token_key(&self, token_id: &str) -> String {
format!("{}token:{}", self.key_prefix, token_id)
}
fn access_token_key(&self, access_token: &str) -> String {
format!(
"{}access_h:{}",
self.key_prefix,
crate::storage::key_names::digest("access_token", access_token)
)
}
fn legacy_access_token_key(&self, access_token: &str) -> String {
format!("{}access:{}", self.key_prefix, access_token)
}
fn user_tokens_key(&self, user_id: &str) -> String {
format!("{}user:{}:tokens", self.key_prefix, user_id)
}
fn session_key(&self, session_id: &str) -> String {
format!(
"{}session_h:{}",
self.key_prefix,
crate::storage::key_names::digest("session", session_id)
)
}
fn legacy_session_key(&self, session_id: &str) -> String {
format!("{}session:{}", self.key_prefix, session_id)
}
async fn session_keys(
&self,
conn: &mut redis::aio::MultiplexedConnection,
) -> Result<Vec<String>> {
let mut all = Vec::new();
for pattern in [
format!("{}session_h:*", self.key_prefix),
format!("{}session:*", self.key_prefix),
] {
let mut cursor: u64 = 0;
loop {
let (next_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
.arg(cursor)
.arg("MATCH")
.arg(&pattern)
.arg("COUNT")
.arg(100)
.query_async(&mut *conn)
.await
.map_err(|e| {
AuthError::Storage(StorageError::operation_failed(e.to_string()))
})?;
all.extend(keys);
cursor = next_cursor;
if cursor == 0 {
break;
}
}
}
Ok(all)
}
async fn get_migrating(&self, new_key: &str, legacy_key: &str) -> Result<Option<String>> {
let mut conn = self.get_connection().await?;
let value: Option<String> = redis::cmd("GET")
.arg(new_key)
.query_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
if value.is_some() {
let _ = redis::cmd("DEL")
.arg(legacy_key)
.query_async::<usize>(&mut conn)
.await;
return Ok(value);
}
const MIGRATE: &str = r#"
local l = redis.call('GET', KEYS[2])
if not l then return redis.call('GET', KEYS[1]) end
local v = redis.call('GET', KEYS[1])
if v then
redis.call('DEL', KEYS[2])
return v
end
local t = redis.call('PTTL', KEYS[2])
if t > 0 then
redis.call('SET', KEYS[1], l, 'PX', t)
elseif t == -1 then
redis.call('SET', KEYS[1], l)
else
return false
end
redis.call('DEL', KEYS[2])
return l
"#;
match redis::Script::new(MIGRATE)
.key(new_key)
.key(legacy_key)
.invoke_async::<Option<String>>(&mut conn)
.await
{
Ok(value) => Ok(value),
Err(script_err) => {
tracing::warn!(
error = %script_err,
"legacy-name migration script failed; serving the row unmigrated"
);
let legacy: Option<String> = redis::cmd("GET")
.arg(legacy_key)
.query_async(&mut conn)
.await
.map_err(|e| {
AuthError::Storage(StorageError::operation_failed(e.to_string()))
})?;
Ok(legacy)
}
}
}
async fn del_legacy(&self, legacy_key: &str) -> Result<()> {
let mut conn = self.get_connection().await?;
let _: usize = conn
.del(legacy_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(())
}
fn kv_key(&self, key: &str) -> String {
format!("{}kv:{}", self.key_prefix, key)
}
pub async fn health_check(&self) -> Result<()> {
let mut conn = self.get_connection().await?;
let pong: String = redis::cmd("PING")
.query_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::connection_failed(e.to_string())))?;
if pong == "PONG" {
Ok(())
} else {
Err(AuthError::Storage(StorageError::connection_failed(
format!("unexpected PING response: {pong}"),
)))
}
}
async fn get_connection(&self) -> Result<MultiplexedConnection> {
self.client
.get_multiplexed_async_connection()
.await
.map_err(|e| AuthError::Storage(StorageError::connection_failed(e.to_string())))
}
}
pub(crate) const SWAP_KV_SCRIPT: &str = r#"
local last = #KEYS
local live = false
for i = 1, last - 1 do
if redis.call('EXISTS', KEYS[i]) == 1 then live = true end
end
if not live then return 0 end
if redis.call('EXISTS', KEYS[last]) == 1 then return 0 end
for i = 1, last - 1 do redis.call('DEL', KEYS[i]) end
local ttl = tonumber(ARGV[2])
if ttl > 0 then
redis.call('SET', KEYS[last], ARGV[1], 'PX', ttl)
else
redis.call('SET', KEYS[last], ARGV[1])
end
return 1
"#;
#[async_trait]
impl AuthStorage for RedisStorage {
async fn update_token(&self, token: &AuthToken) -> Result<()> {
self.store_token(token).await
}
async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
let mut conn = self.get_connection().await?;
let session_key = self.session_key(session_id);
let session_data = serde_json::to_string(data)
.map_err(|e| AuthError::Storage(StorageError::serialization(e.to_string())))?;
let ttl = if data.expires_at > chrono::Utc::now() {
(data.expires_at - chrono::Utc::now()).num_seconds() as u64
} else {
self.default_ttl.as_secs()
};
let _: () = conn
.set_ex(&session_key, &session_data, ttl)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
self.del_legacy(&self.legacy_session_key(session_id))
.await?;
Ok(())
}
async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
let session_data = self
.get_migrating(
&self.session_key(session_id),
&self.legacy_session_key(session_id),
)
.await?;
match session_data {
Some(data) => {
let session: SessionData = serde_json::from_str(&data)
.map_err(|e| AuthError::Storage(StorageError::serialization(e.to_string())))?;
Ok(Some(session))
}
None => Ok(None),
}
}
async fn delete_session(&self, session_id: &str) -> Result<()> {
let mut conn = self.get_connection().await?;
let session_key = self.session_key(session_id);
self.del_legacy(&self.legacy_session_key(session_id))
.await?;
let _: usize = conn
.del(&session_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(())
}
async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
let mut conn = self.get_connection().await?;
let keys = self.session_keys(&mut conn).await?;
let mut user_sessions = Vec::new();
let mut seen = std::collections::HashSet::new();
let legacy_prefix = self.legacy_session_key("");
for key in keys {
let session_json = match key.strip_prefix(&legacy_prefix) {
Some(session_id) => self
.get_migrating(&self.session_key(session_id), &key)
.await
.ok()
.flatten(),
None => conn.get::<_, String>(&key).await.ok(),
};
if let Some(session_json) = session_json
&& let Ok(session) = serde_json::from_str::<SessionData>(&session_json)
&& session.user_id == user_id
&& !session.is_expired()
&& seen.insert(session.session_id.clone())
{
user_sessions.push(session);
}
}
Ok(user_sessions)
}
async fn store_kv_if_absent(
&self,
key: &str,
value: &[u8],
ttl: Option<Duration>,
) -> Result<bool> {
let mut conn = self.get_connection().await?;
let kv_key = self.kv_key(key);
let mut cmd = redis::cmd("SET");
cmd.arg(&kv_key).arg(value).arg("NX");
if let Some(duration) = ttl {
let millis = u64::try_from(duration.as_millis())
.unwrap_or(u64::MAX)
.max(1);
cmd.arg("PX").arg(millis);
}
let reply: Option<String> = cmd
.query_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(reply.is_some())
}
async fn swap_kv(
&self,
remove: &[String],
key: &str,
value: &[u8],
ttl: Option<Duration>,
) -> Result<bool> {
if remove.is_empty() {
return Ok(false);
}
let mut conn = self.get_connection().await?;
let script = redis::Script::new(SWAP_KV_SCRIPT);
let mut invocation = script.prepare_invoke();
for name in remove {
invocation.key(self.kv_key(name));
}
invocation.key(self.kv_key(key));
let millis = ttl.map_or(0, |d| {
u64::try_from(d.as_millis()).unwrap_or(u64::MAX).max(1)
});
let swapped: i64 = invocation
.arg(value)
.arg(millis)
.invoke_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(swapped == 1)
}
fn supports_atomic_swap(&self) -> bool {
true
}
async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
let mut conn = self.get_connection().await?;
let kv_key = self.kv_key(key);
if let Some(duration) = ttl {
let millis = u64::try_from(duration.as_millis())
.unwrap_or(u64::MAX)
.max(1);
let _: () = redis::cmd("PSETEX")
.arg(&kv_key)
.arg(millis)
.arg(value)
.query_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
} else {
let _: () = conn
.set(&kv_key, value)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
}
Ok(())
}
async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
let mut conn = self.get_connection().await?;
let kv_key = self.kv_key(key);
let value: Option<Vec<u8>> = conn
.get(&kv_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(value)
}
async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
let mut conn = self.get_connection().await?;
let kv_key = self.kv_key(key);
let millis: i64 = conn
.pttl(&kv_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(u64::try_from(millis)
.ok()
.filter(|millis| *millis > 0)
.map(Duration::from_millis))
}
fn tracks_kv_ttl(&self) -> bool {
true
}
async fn delete_kv(&self, key: &str) -> Result<()> {
let mut conn = self.get_connection().await?;
let kv_key = self.kv_key(key);
let _: usize = conn
.del(&kv_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(())
}
async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
let mut conn = self.get_connection().await?;
let kv_prefix = self.kv_key("");
let mut pattern = String::with_capacity(kv_prefix.len() + prefix.len() + 1);
for c in kv_prefix.chars().chain(prefix.chars()) {
if matches!(c, '*' | '?' | '[' | ']' | '\\') {
pattern.push('\\');
}
pattern.push(c);
}
pattern.push('*');
let mut keys = Vec::new();
let mut cursor: u64 = 0;
loop {
let (next, batch): (u64, Vec<String>) = redis::cmd("SCAN")
.arg(cursor)
.arg("MATCH")
.arg(&pattern)
.arg("COUNT")
.arg(100)
.query_async(&mut conn)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
keys.extend(
batch
.into_iter()
.filter_map(|k| k.strip_prefix(&kv_prefix).map(str::to_owned)),
);
cursor = next;
if cursor == 0 {
break;
}
}
keys.sort_unstable();
keys.dedup();
Ok(keys)
}
async fn cleanup_expired(&self) -> Result<()> {
Ok(())
}
async fn store_token(&self, token: &AuthToken) -> Result<()> {
let mut conn = self.get_connection().await?;
let now = chrono::Utc::now();
if token.expires_at <= now {
return Err(AuthError::Storage(StorageError::operation_failed(
"Cannot store an already-expired token".to_string(),
)));
}
let ttl = (token.expires_at - now).num_seconds() as u64;
let token_data = serde_json::to_string(token)
.map_err(|e| AuthError::Storage(StorageError::serialization(e.to_string())))?;
let token_key = self.token_key(&token.token_id);
let _: () = conn
.set_ex(&token_key, &token_data, ttl)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
let access_key = self.access_token_key(&token.access_token);
let _: () = conn
.set_ex(&access_key, &token.token_id, ttl)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
self.del_legacy(&self.legacy_access_token_key(&token.access_token))
.await?;
let user_tokens_key = self.user_tokens_key(&token.user_id);
let _: () = conn
.sadd(&user_tokens_key, &token.token_id)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
let _: bool = conn
.expire(&user_tokens_key, ttl as i64)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
Ok(())
}
async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
let mut conn = self.get_connection().await?;
let token_key = self.token_key(token_id);
let token_data: Option<String> = conn
.get(&token_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
match token_data {
Some(data) => {
let token: AuthToken = serde_json::from_str(&data)
.map_err(|e| AuthError::Storage(StorageError::serialization(e.to_string())))?;
Ok(Some(token))
}
None => Ok(None),
}
}
async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
let token_id = self
.get_migrating(
&self.access_token_key(access_token),
&self.legacy_access_token_key(access_token),
)
.await?;
match token_id {
Some(id) => self.get_token(&id).await,
None => Ok(None),
}
}
async fn delete_token(&self, token_id: &str) -> Result<()> {
let mut conn = self.get_connection().await?;
if let Some(token) = self.get_token(token_id).await? {
let token_key = self.token_key(token_id);
let access_key = self.access_token_key(&token.access_token);
let user_tokens_key = self.user_tokens_key(&token.user_id);
self.del_legacy(&self.legacy_access_token_key(&token.access_token))
.await?;
let _: usize = conn
.del(&token_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
let _: usize = conn
.del(&access_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
let _: usize = conn
.srem(&user_tokens_key, token_id)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
}
Ok(())
}
async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
let mut conn = self.get_connection().await?;
let user_tokens_key = self.user_tokens_key(user_id);
let token_ids: Vec<String> = conn
.smembers(&user_tokens_key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
let mut tokens = Vec::new();
for token_id in token_ids {
if let Some(token) = self.get_token(&token_id).await? {
tokens.push(token);
}
}
Ok(tokens)
}
async fn count_active_sessions(&self) -> Result<u64> {
let mut conn = self.get_connection().await?;
let keys = self.session_keys(&mut conn).await?;
let keys = crate::storage::key_names::without_shadowed_legacy(
keys,
&self.legacy_session_key(""),
&format!("{}session_h:", self.key_prefix),
"session",
);
let mut active_count = 0u64;
for key in keys {
let ttl: i64 = conn
.ttl(&key)
.await
.map_err(|e| AuthError::Storage(StorageError::operation_failed(e.to_string())))?;
if ttl > 0 || ttl == -1 {
active_count += 1;
}
}
Ok(active_count)
}
}