use super::GarrisonDao;
use crate::dao::repository::make_statement;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use dbnexus::sea_orm::{ConnectionTrait, DbBackend, Value};
use dbnexus::DbPool;
use std::time::Duration;
pub struct DbnexusKvDao {
pool: DbPool,
}
macro_rules! kv_session {
($self:expr, $op:expr, $session:ident, $conn:ident) => {
let $session = $self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{}-session::{}", $op, e)))?;
let $conn = $session
.connection()
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{}-connection::{}", $op, e)))?;
};
}
impl DbnexusKvDao {
pub fn new(pool: DbPool) -> Self {
Self { pool }
}
pub async fn ensure_table(&self) -> GarrisonResult<()> {
kv_session!(self, "ensure-table", session, conn);
let k_type = match conn.get_database_backend() {
DbBackend::MySql => "VARCHAR(255)",
_ => "VARCHAR",
};
let stmt = make_statement(
conn,
&format!(
"CREATE TABLE IF NOT EXISTS garrison_kv (\
k {k_type} PRIMARY KEY, \
v TEXT NOT NULL, \
expire_at BIGINT)"
),
vec![],
);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-ensure-table-execute::{e}")))?;
Ok(())
}
fn now_secs() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or_default()
}
fn live_cond() -> &'static str {
"(expire_at IS NULL OR expire_at > ?)"
}
fn expire_at_from_ttl(ttl_seconds: u64) -> Option<i64> {
if ttl_seconds == 0 {
None
} else {
Some(Self::now_secs() + ttl_seconds as i64)
}
}
fn remaining_secs(expire_at: Option<i64>) -> Option<Duration> {
expire_at.map(|at| Duration::from_secs((at - Self::now_secs()).max(0) as u64))
}
async fn query_row(
&self,
op: &str,
sql: &str,
values: Vec<Value>,
) -> GarrisonResult<Option<(String, Option<i64>)>> {
kv_session!(self, op, session, conn);
let stmt = make_statement(conn, sql, values);
let rows = conn
.query_all_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{op}-query::{e}")))?;
match rows.first() {
None => Ok(None),
Some(row) => {
let v = row
.try_get::<String>("", "v")
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{op}-read-v::{e}")))?;
let expire_at = row
.try_get::<Option<i64>>("", "expire_at")
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{op}-read-expire::{e}")))?;
Ok(Some((v, expire_at)))
},
}
}
async fn execute(&self, op: &str, sql: &str, values: Vec<Value>) -> GarrisonResult<u64> {
kv_session!(self, op, session, conn);
let stmt = make_statement(conn, sql, values);
let result = conn
.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-{op}-execute::{e}")))?;
Ok(result.rows_affected())
}
async fn upsert(&self, key: &str, value: &str, expire_at: Option<i64>) -> GarrisonResult<()> {
kv_session!(self, "upsert", session, conn);
let sql = match conn.get_database_backend() {
DbBackend::MySql => {
"INSERT INTO garrison_kv (k, v, expire_at) VALUES (?, ?, ?) \
ON DUPLICATE KEY UPDATE v = VALUES(v), expire_at = VALUES(expire_at)"
},
_ => {
"INSERT INTO garrison_kv (k, v, expire_at) VALUES (?, ?, ?) \
ON CONFLICT (k) DO UPDATE SET v = excluded.v, expire_at = excluded.expire_at"
},
};
let stmt = make_statement(
conn,
sql,
vec![
Value::String(Some(key.to_string())),
Value::String(Some(value.to_string())),
Value::BigInt(expire_at),
],
);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-upsert-execute::{e}")))?;
Ok(())
}
async fn live_row(&self, op: &str, key: &str) -> GarrisonResult<Option<(String, Option<i64>)>> {
let now = Self::now_secs();
let found = self
.query_row(
op,
&format!(
"SELECT v, expire_at FROM garrison_kv WHERE k = ? AND {}",
Self::live_cond()
),
vec![
Value::String(Some(key.to_string())),
Value::BigInt(Some(now)),
],
)
.await?;
if found.is_none() {
self.execute(
&format!("{op}-cleanup"),
&format!(
"DELETE FROM garrison_kv WHERE k = ? AND {}",
Self::expired_cond()
),
vec![
Value::String(Some(key.to_string())),
Value::BigInt(Some(now)),
],
)
.await?;
}
Ok(found)
}
fn expired_cond() -> &'static str {
"(expire_at IS NOT NULL AND expire_at <= ?)"
}
}
#[async_trait]
impl GarrisonDao for DbnexusKvDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
Ok(self.live_row("get", key).await?.map(|(v, _)| v))
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.upsert(key, value, Self::expire_at_from_ttl(ttl_seconds))
.await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let now = Self::now_secs();
let affected = self
.execute(
"update",
&format!(
"UPDATE garrison_kv SET v = ? WHERE k = ? AND {}",
Self::live_cond()
),
vec![
Value::String(Some(value.to_string())),
Value::String(Some(key.to_string())),
Value::BigInt(Some(now)),
],
)
.await?;
if affected == 0 {
return Err(GarrisonError::Dao(format!("dao-key-missing::{key}")));
}
Ok(())
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
let now = Self::now_secs();
let affected = self
.execute(
"expire",
&format!(
"UPDATE garrison_kv SET expire_at = ? WHERE k = ? AND {}",
Self::live_cond()
),
vec![
Value::BigInt(Self::expire_at_from_ttl(seconds)),
Value::String(Some(key.to_string())),
Value::BigInt(Some(now)),
],
)
.await?;
if affected == 0 {
return Err(GarrisonError::Dao(format!("dao-key-missing::{key}")));
}
Ok(())
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.execute(
"delete",
"DELETE FROM garrison_kv WHERE k = ?",
vec![Value::String(Some(key.to_string()))],
)
.await?;
Ok(())
}
async fn vacuum_expired(&self) -> GarrisonResult<u64> {
let now = Self::now_secs();
self.execute(
"vacuum-expired",
&format!("DELETE FROM garrison_kv WHERE {}", Self::expired_cond()),
vec![Value::BigInt(Some(now))],
)
.await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
kv_session!(self, "set-if-absent", session, conn);
let now = Self::now_secs();
let expire_at = Self::expire_at_from_ttl(ttl_seconds);
if conn.get_database_backend() == DbBackend::MySql {
use dbnexus::sea_orm::TransactionTrait;
let txn = conn
.begin()
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-set-if-absent-begin::{e}")))?;
let sel = make_statement(
&txn,
"SELECT v, expire_at FROM garrison_kv WHERE k = ? FOR UPDATE",
vec![Value::String(Some(key.to_string()))],
);
let rows = txn
.query_all_raw(sel)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-set-if-absent-select::{e}")))?;
let live = match rows.first() {
None => false,
Some(row) => {
let expire = row.try_get::<Option<i64>>("", "expire_at").map_err(|e| {
GarrisonError::Dao(format!("dao-kv-set-if-absent-read-expire::{e}"))
})?;
expire.is_none() || expire > Some(now)
},
};
let result = if live {
Ok(false)
} else {
let up = make_statement(
&txn,
"INSERT INTO garrison_kv (k, v, expire_at) VALUES (?, ?, ?) \
ON DUPLICATE KEY UPDATE v = ?, expire_at = ?",
vec![
Value::String(Some(key.to_string())),
Value::String(Some(value.to_string())),
Value::BigInt(expire_at),
Value::String(Some(value.to_string())),
Value::BigInt(expire_at),
],
);
txn.execute_raw(up).await.map_err(|e| {
GarrisonError::Dao(format!("dao-kv-set-if-absent-execute::{e}"))
})?;
Ok(true)
};
txn.commit()
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-set-if-absent-commit::{e}")))?;
return result;
}
let (sql, values) = (
"INSERT INTO garrison_kv (k, v, expire_at) VALUES (?, ?, ?) \
ON CONFLICT (k) DO UPDATE SET v = excluded.v, expire_at = excluded.expire_at \
WHERE (garrison_kv.expire_at IS NOT NULL AND garrison_kv.expire_at <= ?)",
vec![
Value::String(Some(key.to_string())),
Value::String(Some(value.to_string())),
Value::BigInt(expire_at),
Value::BigInt(Some(now)),
],
);
let stmt = make_statement(conn, sql, values);
let result = conn
.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-set-if-absent-execute::{e}")))?;
Ok(result.rows_affected() > 0)
}
async fn get_timeout(&self, key: &str) -> GarrisonResult<Option<Duration>> {
Ok(self
.live_row("get-timeout", key)
.await?
.and_then(|(_, expire_at)| Self::remaining_secs(expire_at)))
}
#[cfg(feature = "dao-key-index")]
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let now = Self::now_secs();
kv_session!(self, "keys", session, conn);
let stmt = make_statement(
conn,
&format!(
"SELECT k, expire_at FROM garrison_kv WHERE {}",
Self::live_cond()
),
vec![Value::BigInt(Some(now))],
);
let rows = conn
.query_all_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-kv-keys-query::{e}")))?;
let mut keys = Vec::new();
for row in &rows {
let k = row
.try_get::<String>("", "k")
.map_err(|e| GarrisonError::Dao(format!("dao-kv-keys-read-k::{e}")))?;
if super::in_memory::glob_match(pattern, &k) {
keys.push(k);
}
}
Ok(keys)
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
let Some((v, expire_at)) = self.live_row("rename", old_key).await? else {
return Err(GarrisonError::InvalidParam(format!(
"dao-key-not-found::{old_key}"
)));
};
self.upsert(new_key, &v, expire_at).await?;
self.delete(old_key).await?;
Ok(())
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
let Some((v, _)) = self.live_row("get-and-delete", key).await? else {
return Ok(None);
};
self.delete(key).await?;
Ok(Some(v))
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
let Some((v, expire_at)) = self.live_row("incr", key).await? else {
self.set(key, "1", ttl_seconds).await?;
return Ok(1);
};
let cur: u64 = v
.parse()
.map_err(|_| GarrisonError::Dao(format!("dao-incr-parse-u64::{key}::{v}")))?;
let new_val = cur
.checked_add(1)
.ok_or_else(|| GarrisonError::Dao(format!("dao-incr-overflow-u64::{key}")))?;
self.upsert(key, &new_val.to_string(), expire_at).await?;
Ok(new_val)
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
let Some((v, expire_at)) = self.live_row("decr", key).await? else {
return Ok(0);
};
let cur: u64 = v
.parse()
.map_err(|_| GarrisonError::Dao(format!("dao-decr-parse-u64::{key}::{v}")))?;
if cur == 0 {
return Ok(0);
}
let new_val = cur - 1;
if new_val == 0 {
self.delete(key).await?;
} else {
self.upsert(key, &new_val.to_string(), expire_at).await?;
}
Ok(new_val)
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
let now = Self::now_secs();
self.execute(
"compare-and-swap-cleanup",
&format!(
"DELETE FROM garrison_kv WHERE k = ? AND {}",
Self::expired_cond()
),
vec![
Value::String(Some(key.to_string())),
Value::BigInt(Some(now)),
],
)
.await?;
match expected {
Some(expected_value) => {
let affected = self
.execute(
"compare-and-swap",
"UPDATE garrison_kv SET v = ?, expire_at = ? WHERE k = ? AND v = ?",
vec![
Value::String(Some(new_value.to_string())),
Value::BigInt(Self::expire_at_from_ttl(ttl_seconds)),
Value::String(Some(key.to_string())),
Value::String(Some(expected_value.to_string())),
],
)
.await?;
Ok(affected > 0)
},
None => self.set_if_absent(key, new_value, ttl_seconds).await,
}
}
}