#[cfg(feature = "db")]
use parking_lot::RwLock;
#[cfg(feature = "db")]
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::OnceLock;
use std::time::Duration;
use crate::audit::{AuditRecord, AuditWriter};
#[cfg(feature = "template")]
use crate::template_engine::TemplateEngine;
#[cfg(feature = "cache")]
use wordval_cache::SharedCache;
use wordval_config::ConfigManager;
#[cfg(feature = "db")]
use wordval_db::Db;
#[cfg(feature = "fs")]
use wordval_fs::FsBackendEnum;
#[cfg(feature = "db")]
static DBS: OnceLock<RwLock<HashMap<String, Db>>> = OnceLock::new();
#[cfg(feature = "cache")]
static CACHE: OnceLock<SharedCache> = OnceLock::new();
static CONFIG: OnceLock<Arc<ConfigManager>> = OnceLock::new();
#[cfg(feature = "fs")]
static FS: OnceLock<FsBackendEnum> = OnceLock::new();
#[cfg(feature = "template")]
static TEMPLATE: OnceLock<TemplateEngine> = OnceLock::new();
static UPLOAD_PATH: OnceLock<String> = OnceLock::new();
static DOWNLOAD_PATH: OnceLock<String> = OnceLock::new();
static AUDIT: OnceLock<Arc<AuditWriter>> = OnceLock::new();
#[cfg(feature = "db")]
fn registry() -> &'static RwLock<HashMap<String, Db>> {
DBS.get_or_init(|| RwLock::new(HashMap::new()))
}
#[cfg(feature = "db")]
pub fn set_db(db: Db) -> Result<(), &'static str> {
let mut map = registry().write();
if map.contains_key(DEFAULT_DB_NAME) {
return Err("数据库资源已初始化");
}
map.insert(DEFAULT_DB_NAME.to_string(), db);
Ok(())
}
#[cfg(feature = "db")]
pub const DEFAULT_DB_NAME: &str = "default";
#[cfg(feature = "db")]
pub fn set_dbs(dbs: HashMap<String, Db>) -> Result<(), &'static str> {
if !dbs.contains_key(DEFAULT_DB_NAME) {
return Err("数据库注册表必须包含 default 库");
}
let mut map = registry().write();
if map.contains_key(DEFAULT_DB_NAME) {
return Err("数据库资源已初始化");
}
*map = dbs;
Ok(())
}
#[cfg(feature = "cache")]
pub fn set_cache(cache: SharedCache) -> Result<(), &'static str> {
CACHE.set(cache).map_err(|_| "缓存资源已初始化")
}
#[cfg(feature = "fs")]
pub fn set_fs(fs: FsBackendEnum) -> Result<(), &'static str> {
FS.set(fs).map_err(|_| "文件存储资源已初始化")
}
pub fn set_config(config: Arc<ConfigManager>) -> Result<(), &'static str> {
CONFIG.set(config).map_err(|_| "配置资源已初始化")
}
pub fn set_audit_writer(writer: Arc<AuditWriter>) -> Result<(), &'static str> {
AUDIT.set(writer).map_err(|_| "审计写入器已初始化")
}
#[cfg(feature = "template")]
pub fn set_template(template: TemplateEngine) -> Result<(), &'static str> {
TEMPLATE.set(template).map_err(|_| "模板引擎已初始化")
}
#[cfg(feature = "db")]
pub struct DbHandle {
db: Db,
}
#[cfg(feature = "db")]
impl std::ops::Deref for DbHandle {
type Target = Db;
fn deref(&self) -> &Db {
&self.db
}
}
#[cfg(feature = "db")]
impl DbHandle {
pub fn using(self, alias: &str) -> Db {
try_using(alias).unwrap_or_else(|| {
panic!(
"数据库 '{}' 未注册,已注册别名: {:?}",
alias,
db_names()
)
})
}
}
#[cfg(feature = "db")]
pub fn db() -> DbHandle {
try_db().unwrap_or_else(|| panic!("数据库未初始化,请先调用 set_db()/set_dbs()"))
}
#[cfg(feature = "db")]
pub fn try_db() -> Option<DbHandle> {
try_using(DEFAULT_DB_NAME).map(|db| DbHandle { db })
}
#[cfg(feature = "db")]
pub fn db_default() -> Db {
try_using(DEFAULT_DB_NAME)
.unwrap_or_else(|| panic!("数据库未初始化,请先调用 set_db()/set_dbs()"))
}
#[cfg(feature = "db")]
pub fn try_using(alias: &str) -> Option<Db> {
registry().read().get(alias).cloned()
}
#[cfg(feature = "db")]
pub fn register_db(alias: &str, db: Db) {
registry().write().insert(alias.to_string(), db);
}
#[cfg(feature = "db")]
pub fn remove_db(alias: &str) -> Result<Option<Db>, &'static str> {
if alias == DEFAULT_DB_NAME {
tracing::warn!("拒绝移除 default 数据库(db_default 的不变量)");
return Err("不能移除 default 数据库");
}
Ok(registry().write().remove(alias))
}
#[cfg(feature = "db")]
pub fn db_names() -> Vec<String> {
registry().read().keys().cloned().collect()
}
#[cfg(feature = "cache")]
pub fn cache() -> &'static SharedCache {
CACHE.get().expect("缓存未初始化,请先调用 set_cache()")
}
#[cfg(feature = "cache")]
pub fn try_cache() -> Option<&'static SharedCache> {
CACHE.get()
}
#[cfg(feature = "fs")]
pub fn fs() -> &'static FsBackendEnum {
FS.get().expect("文件存储未初始化,请先调用 set_fs()")
}
#[cfg(feature = "fs")]
pub fn try_fs() -> Option<&'static FsBackendEnum> {
FS.get()
}
pub fn config() -> &'static Arc<ConfigManager> {
CONFIG.get().expect("配置未初始化,请先调用 set_config()")
}
pub fn try_config() -> Option<&'static Arc<ConfigManager>> {
CONFIG.get()
}
pub fn cfg() -> &'static wordval_config::AppConfig {
config().get()
}
pub fn audit_writer() -> &'static AuditWriter {
AUDIT
.get()
.expect("审计未初始化,请启用 middleware.audit.enabled 或调用 set_audit_writer()")
}
pub fn try_audit_writer() -> Option<&'static AuditWriter> {
AUDIT.get().map(Arc::as_ref)
}
pub fn audit_write(record: AuditRecord) {
if let Some(writer) = AUDIT.get() {
writer.write(record);
}
}
pub async fn shutdown_audit_writer(timeout: Duration) -> wordval_core::Result<()> {
match AUDIT.get() {
Some(writer) => writer.shutdown(Some(timeout)).await,
None => Ok(()),
}
}
#[cfg(feature = "template")]
pub fn render_template<T: serde::Serialize>(
name: &str,
context: &T,
) -> wordval_core::Result<String> {
TEMPLATE
.get()
.ok_or_else(|| wordval_core::Error::Template("模板引擎未初始化".into()))
.and_then(|t| t.render(name, context))
}
#[cfg(feature = "template")]
pub fn try_template() -> Option<&'static TemplateEngine> {
TEMPLATE.get()
}
pub fn set_upload_path(path: String) -> Result<(), &'static str> {
UPLOAD_PATH.set(path).map_err(|_| "上传路径已初始化")
}
pub fn upload_path() -> &'static str {
UPLOAD_PATH.get().map(|s| s.as_str()).unwrap_or("uploads")
}
pub fn try_upload_path() -> Option<&'static str> {
UPLOAD_PATH.get().map(|s| s.as_str())
}
pub fn set_download_path(path: String) -> Result<(), &'static str> {
DOWNLOAD_PATH.set(path).map_err(|_| "下载路径已初始化")
}
pub fn download_path() -> &'static str {
DOWNLOAD_PATH
.get()
.map(|s| s.as_str())
.unwrap_or("downloads")
}
pub fn try_download_path() -> Option<&'static str> {
DOWNLOAD_PATH.get().map(|s| s.as_str())
}
#[cfg(all(test, feature = "db"))]
mod db_registry_tests {
use super::*;
static REGISTRY_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
async fn temp_db(tag: &str) -> Db {
let dir = std::env::temp_dir().join(format!("wv_res_db_{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let cfg = wordval_config::DatabaseConfig {
enabled: true,
r#type: "sqlite".into(),
name: dir.join(format!("{tag}.db")).to_string_lossy().into_owned(),
..Default::default()
};
wordval_db::create_db(&cfg).await.expect("create sqlite db")
}
#[test]
fn set_dbs_requires_default_alias() {
let err = set_dbs(HashMap::new()).unwrap_err();
assert!(err.contains("default"), "{err}");
assert!(try_using("nope").is_none());
}
#[tokio::test]
async fn db_handle_using_selects_alias() {
let _serial = REGISTRY_LOCK.lock().await;
register_db(DEFAULT_DB_NAME, temp_db("rtdef2").await);
register_db("using_test", temp_db("rtu").await);
let _handle = db();
let _default_ref: &Db = &db();
let _named = db().using("using_test");
assert!(db_names().contains(&"using_test".to_string()));
}
#[tokio::test]
async fn register_and_remove_runtime_alias() {
register_db("runtime_test", temp_db("rt1").await);
assert!(try_using("runtime_test").is_some());
assert!(db_names().contains(&"runtime_test".to_string()));
register_db("runtime_test", temp_db("rt2").await);
assert!(try_using("runtime_test").is_some());
let removed = remove_db("runtime_test").unwrap();
assert!(removed.is_some());
assert!(try_using("runtime_test").is_none());
}
#[tokio::test]
async fn using_alias_supports_transaction() {
let _serial = REGISTRY_LOCK.lock().await;
register_db(DEFAULT_DB_NAME, temp_db("txdef").await);
register_db("tx_other", temp_db("txoth").await);
for d in [db_default(), db().using("tx_other")] {
d.execute("CREATE TABLE tx_t (id INTEGER PRIMARY KEY, v TEXT)", &[])
.await
.unwrap();
}
db()
.transaction(|tx| async move {
tx.execute("INSERT INTO tx_t (v) VALUES ('from-default')", &[])
.await?;
Ok::<(), wordval_db::DbError>(())
})
.await
.unwrap();
let e = db()
.using("tx_other")
.transaction(|tx| async move {
tx.execute("INSERT INTO tx_t (v) VALUES ('rollback-me')", &[])
.await?;
Err::<(), wordval_db::DbError>(wordval_db::DbError::Other("业务失败".into()))
})
.await
.unwrap_err();
assert!(e.to_string().contains("业务失败"), "{e}");
assert_eq!(
db().count("SELECT COUNT(*) FROM tx_t", &[]).await.unwrap(),
1
);
assert_eq!(
db()
.using("tx_other")
.count("SELECT COUNT(*) FROM tx_t", &[])
.await
.unwrap(),
0
);
}
#[tokio::test]
async fn default_alias_cannot_be_removed() {
let _serial = REGISTRY_LOCK.lock().await;
register_db(DEFAULT_DB_NAME, temp_db("rtdef").await);
let err = remove_db(DEFAULT_DB_NAME).unwrap_err();
assert!(err.contains("default"), "{err}");
assert!(try_using(DEFAULT_DB_NAME).is_some());
}
}