133 lines
3.4 KiB
Rust
133 lines
3.4 KiB
Rust
use std::{
|
|
path::{Path, PathBuf},
|
|
sync::OnceLock,
|
|
};
|
|
|
|
use super::define::StorageEngine;
|
|
use anyhow::Result;
|
|
use async_trait::async_trait;
|
|
use dashmap::DashMap;
|
|
pub static SLED_DB_POOL: OnceLock<DashMap<PathBuf, sled::Db>> = OnceLock::new();
|
|
pub fn get_sled_db(path: &Path) -> Result<sled::Db> {
|
|
let pool = SLED_DB_POOL.get_or_init(|| DashMap::new());
|
|
if let Some(db) = pool.get(path) {
|
|
Ok(db.clone())
|
|
} else {
|
|
let db = sled::open(path)?;
|
|
pool.insert(path.to_path_buf(), db.clone());
|
|
Ok(db)
|
|
}
|
|
}
|
|
pub fn get_pool() -> &'static DashMap<PathBuf, sled::Db> {
|
|
SLED_DB_POOL.get_or_init(|| DashMap::new())
|
|
}
|
|
pub struct SledDB {
|
|
pub sled_db: sled::Db,
|
|
}
|
|
|
|
impl SledDB {
|
|
pub fn new(path: &Path) -> Result<Self> {
|
|
let db = sled::open(path)?;
|
|
|
|
Ok(Self { sled_db: db })
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl StorageEngine for SledDB {
|
|
async fn open(path: &Path) -> Result<Self> {
|
|
let entry = get_pool().entry(path.to_path_buf());
|
|
let sled_db = entry
|
|
.or_insert_with(|| sled::open(path).expect("Failed to open sled database"))
|
|
.clone();
|
|
Ok(SledDB { sled_db })
|
|
}
|
|
|
|
async fn set_raw(&self, key: &[u8], value: &[u8]) -> Result<()> {
|
|
self.sled_db.insert(key, value)?;
|
|
self.sled_db.flush()?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_raw(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
|
|
let result = self.sled_db.get(key)?;
|
|
Ok(result.map(|i| i.to_vec()))
|
|
}
|
|
|
|
async fn delete_raw(&self, key: &[u8]) -> Result<()> {
|
|
self.sled_db.remove(key)?;
|
|
self.sled_db.flush()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
//INFO: AI写的集成测试
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::path::PathBuf;
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
|
use anyhow::Result;
|
|
|
|
use super::super::define::{DailyBotStore, StorageEngine};
|
|
use super::SledDB;
|
|
|
|
fn unique_db_path() -> PathBuf {
|
|
let nanos = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.expect("time went backwards")
|
|
.as_nanos();
|
|
std::env::temp_dir().join(format!(
|
|
"daily_bot_sled_test_{}_{}",
|
|
std::process::id(),
|
|
nanos
|
|
))
|
|
}
|
|
|
|
fn cleanup_db_path(path: &PathBuf) {
|
|
if path.exists() {
|
|
let _ = std::fs::remove_dir_all(path);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn raw_crud_roundtrip_works() -> Result<()> {
|
|
let db_path = unique_db_path();
|
|
let db = <SledDB as StorageEngine>::open(&db_path).await?;
|
|
|
|
db.set_raw(b"k1", b"v1").await?;
|
|
let got = db.get_raw(b"k1").await?;
|
|
assert_eq!(got, Some(b"v1".to_vec()));
|
|
|
|
db.delete_raw(b"k1").await?;
|
|
let deleted = db.get_raw(b"k1").await?;
|
|
assert_eq!(deleted, None);
|
|
|
|
drop(db);
|
|
cleanup_db_path(&db_path);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn daily_bot_store_namespace_works() -> Result<()> {
|
|
let db_path = unique_db_path();
|
|
let db = SledDB::new(&db_path)?;
|
|
|
|
db.save("user", "alice", b"hello").await?;
|
|
|
|
let loaded = db.load("user", "alice").await?;
|
|
assert_eq!(loaded, Some(b"hello".to_vec()));
|
|
|
|
let raw = db.get_raw(b"user:alice").await?;
|
|
assert_eq!(raw, Some(b"hello".to_vec()));
|
|
|
|
db.remove("user", "alice").await?;
|
|
let removed = db.load("user", "alice").await?;
|
|
assert_eq!(removed, None);
|
|
|
|
drop(db);
|
|
cleanup_db_path(&db_path);
|
|
Ok(())
|
|
}
|
|
}
|