use async_trait::async_trait;
use serde_json::Value as JsonValue;
use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
use tokio::sync::RwLock;
use crate::error::BaseError;
pub type PluginError = Box<dyn std::error::Error + Send + Sync + 'static>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum PluginLifecycleStage {
Register,
Initialize,
Shutdown,
}
impl fmt::Display for PluginLifecycleStage {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::Register => "register",
Self::Initialize => "initialize",
Self::Shutdown => "shutdown",
})
}
}
fn normalize_plugin_name(name: &str) -> Result<&str, BaseError> {
let name = name.trim();
if name.is_empty() {
return Err(BaseError::PluginRegisterFailed(
"<empty>".to_string(),
"插件名称不能为空".to_string(),
));
}
Ok(name)
}
fn normalize_plugin_lookup_name(name: &str) -> Option<&str> {
let name = name.trim();
(!name.is_empty()).then_some(name)
}
#[async_trait]
pub trait Plugin: Send + Sync {
fn name(&self) -> &str;
fn version(&self) -> &str {
"0.1.0"
}
fn dependencies(&self) -> &[&str] {
&[]
}
fn init_sql(&self) -> Vec<String> {
Vec::new()
}
fn migration_sql(&self) -> Vec<(String, String)> {
Vec::new()
}
fn config_schema(&self) -> Option<JsonValue> {
None
}
async fn on_register(&self) -> Result<(), PluginError> {
Ok(())
}
async fn on_init(&self) -> Result<(), PluginError> {
Ok(())
}
async fn on_shutdown(&self) -> Result<(), PluginError> {
Ok(())
}
}
pub struct PluginManager {
plugins: Arc<RwLock<HashMap<String, Arc<dyn Plugin>>>>,
configs: Arc<RwLock<HashMap<String, JsonValue>>>,
}
impl PluginManager {
pub fn new() -> Self {
Self {
plugins: Arc::new(RwLock::new(HashMap::new())),
configs: Arc::new(RwLock::new(HashMap::new())),
}
}
pub async fn register<P: Plugin + 'static>(&self, plugin: P) -> Result<(), BaseError> {
let name = normalize_plugin_name(plugin.name())?.to_string();
let plugin = Arc::new(plugin);
{
let plugins = self.plugins.read().await;
if plugins.contains_key(&name) {
return Err(BaseError::PluginAlreadyRegistered(name));
}
}
plugin
.on_register()
.await
.map_err(|source| BaseError::PluginLifecycleFailed {
plugin: name.clone(),
stage: PluginLifecycleStage::Register,
source,
})?;
{
let mut plugins = self.plugins.write().await;
if plugins.contains_key(&name) {
return Err(BaseError::PluginAlreadyRegistered(name));
}
plugins.insert(name.clone(), plugin);
}
log::info!("插件已注册: {}", name);
Ok(())
}
pub async fn get(&self, name: &str) -> Option<Arc<dyn Plugin>> {
let name = normalize_plugin_lookup_name(name)?;
let plugins = self.plugins.read().await;
plugins.get(name).cloned()
}
pub async fn get_all(&self) -> Vec<Arc<dyn Plugin>> {
let plugins = self.plugins.read().await;
let mut plugin_list: Vec<_> = plugins.values().cloned().collect();
self.topological_sort(&mut plugin_list);
plugin_list
}
pub async fn load_config(&self, name: &str, config: JsonValue) -> Result<(), BaseError> {
let normalized_name = normalize_plugin_lookup_name(name)
.ok_or_else(|| BaseError::PluginNotFound(name.to_string()))?;
let plugin = self
.get(normalized_name)
.await
.ok_or_else(|| BaseError::PluginNotFound(normalized_name.to_string()))?;
if let Some(schema) = plugin.config_schema() {
self.validate_config(normalized_name, &config, &schema)?;
}
{
let mut configs = self.configs.write().await;
configs.insert(normalized_name.to_string(), config);
}
Ok(())
}
pub async fn get_config(&self, name: &str) -> Option<JsonValue> {
let name = normalize_plugin_lookup_name(name)?;
let configs = self.configs.read().await;
configs.get(name).cloned()
}
fn topological_sort(&self, plugins: &mut Vec<Arc<dyn Plugin>>) {
let mut in_degree: HashMap<String, usize> = HashMap::new();
let mut graph: HashMap<String, Vec<String>> = HashMap::new();
for plugin in plugins.iter() {
let name = plugin.name().to_string();
in_degree.entry(name.clone()).or_insert(0);
for dep in plugin.dependencies() {
graph.entry(dep.to_string()).or_default().push(name.clone());
*in_degree.entry(name.clone()).or_insert(0) += 1;
}
}
let mut queue: Vec<String> = in_degree
.iter()
.filter(|(_, °ree)| degree == 0)
.map(|(name, _)| name.clone())
.collect();
let mut sorted = Vec::new();
while let Some(node) = queue.pop() {
sorted.push(node.clone());
if let Some(neighbors) = graph.get(&node) {
for neighbor in neighbors {
if let Some(degree) = in_degree.get_mut(neighbor) {
*degree -= 1;
if *degree == 0 {
queue.push(neighbor.clone());
}
}
}
}
}
if sorted.len() < plugins.len() {
let circular: Vec<String> = plugins
.iter()
.filter(|p| !sorted.iter().any(|n| n == p.name()))
.map(|p| p.name().to_string())
.collect();
log::error!(
"检测到循环依赖,以下插件将无法按依赖顺序加载: {}",
circular.join(", ")
);
sorted.extend(circular);
}
plugins.sort_by_key(|p| {
sorted
.iter()
.position(|n| n == p.name())
.unwrap_or(usize::MAX)
});
}
fn validate_config(
&self,
plugin_name: &str,
config: &JsonValue,
schema: &JsonValue,
) -> Result<(), BaseError> {
#[cfg(feature = "plugin-schema")]
{
let validator = jsonschema::validator_for(schema).map_err(|e| {
BaseError::PluginConfigInvalid(
plugin_name.to_string(),
format!("Schema 编译失败: {}", e),
)
})?;
let error_msgs: Vec<String> = validator
.iter_errors(config)
.map(|e| e.to_string())
.collect();
if !error_msgs.is_empty() {
return Err(BaseError::PluginConfigInvalid(
plugin_name.to_string(),
error_msgs.join("; "),
));
}
}
#[cfg(not(feature = "plugin-schema"))]
{
let _ = (plugin_name, config, schema);
}
Ok(())
}
pub async fn shutdown(&self) -> Result<(), BaseError> {
let mut plugins = self.get_all().await;
plugins.reverse();
let mut errors: Vec<(String, PluginError)> = Vec::new();
for plugin in plugins {
let name = plugin.name();
if let Err(e) = plugin.on_shutdown().await {
log::error!("插件 {} 关闭失败: {}", name, e);
errors.push((name.to_string(), e));
} else {
log::info!("插件已关闭: {}", name);
}
}
if let Some((plugin, source)) = errors.into_iter().next() {
Err(BaseError::PluginLifecycleFailed {
plugin,
stage: PluginLifecycleStage::Shutdown,
source,
})
} else {
Ok(())
}
}
}
impl Default for PluginManager {
fn default() -> Self {
Self::new()
}
}
pub struct PluginManagerBuilder {
plugins: HashMap<String, Arc<dyn Plugin>>,
configs: HashMap<String, JsonValue>,
}
impl PluginManagerBuilder {
pub fn new() -> Self {
Self {
plugins: HashMap::new(),
configs: HashMap::new(),
}
}
pub async fn register<P: Plugin + 'static>(&mut self, plugin: P) -> Result<(), BaseError> {
let name = normalize_plugin_name(plugin.name())?.to_string();
if self.plugins.contains_key(&name) {
return Err(BaseError::PluginAlreadyRegistered(name));
}
let plugin = Arc::new(plugin);
plugin
.on_register()
.await
.map_err(|source| BaseError::PluginLifecycleFailed {
plugin: name.clone(),
stage: PluginLifecycleStage::Register,
source,
})?;
self.plugins.insert(name.clone(), plugin);
log::info!("插件已注册(构建阶段): {}", name);
Ok(())
}
pub fn build(self) -> Result<PluginRegistry, BaseError> {
for (plugin_name, plugin) in &self.plugins {
for dep in plugin.dependencies() {
let dep = normalize_plugin_name(dep)?;
if !self.plugins.contains_key(dep) {
return Err(BaseError::PluginDependencyMissing(
plugin_name.clone(),
dep.to_string(),
));
}
}
}
PluginRegistry::new(self.plugins, self.configs)
}
}
impl Default for PluginManagerBuilder {
fn default() -> Self {
Self::new()
}
}
pub struct PluginRegistry {
plugins: HashMap<String, Arc<dyn Plugin>>,
sorted_plugins: Vec<Arc<dyn Plugin>>,
configs: HashMap<String, JsonValue>,
}
impl PluginRegistry {
fn new(
plugins: HashMap<String, Arc<dyn Plugin>>,
configs: HashMap<String, JsonValue>,
) -> Result<Self, BaseError> {
let sorted_plugins = Self::compute_topological_sort(&plugins)?;
Ok(Self {
plugins,
sorted_plugins,
configs,
})
}
pub fn get(&self, name: &str) -> Option<&Arc<dyn Plugin>> {
let name = normalize_plugin_lookup_name(name)?;
self.plugins.get(name)
}
pub fn get_all(&self) -> &[Arc<dyn Plugin>] {
&self.sorted_plugins
}
pub fn get_config(&self, name: &str) -> Option<&JsonValue> {
let name = normalize_plugin_lookup_name(name)?;
self.configs.get(name)
}
pub async fn shutdown(&self) -> Result<(), BaseError> {
let mut errors: Vec<(String, PluginError)> = Vec::new();
for plugin in self.sorted_plugins.iter().rev() {
let name = plugin.name();
if let Err(e) = plugin.on_shutdown().await {
log::error!("插件 {} 关闭失败: {}", name, e);
errors.push((name.to_string(), e));
} else {
log::info!("插件已关闭: {}", name);
}
}
if let Some((plugin, source)) = errors.into_iter().next() {
Err(BaseError::PluginLifecycleFailed {
plugin,
stage: PluginLifecycleStage::Shutdown,
source,
})
} else {
Ok(())
}
}
fn compute_topological_sort(
plugins: &HashMap<String, Arc<dyn Plugin>>,
) -> Result<Vec<Arc<dyn Plugin>>, BaseError> {
let mut in_degree: HashMap<String, usize> = HashMap::new();
let mut graph: HashMap<String, Vec<String>> = HashMap::new();
for (name, plugin) in plugins {
let name = name.clone();
in_degree.entry(name.clone()).or_insert(0);
for dep in plugin.dependencies() {
let dep = normalize_plugin_name(dep)?;
graph.entry(dep.to_string()).or_default().push(name.clone());
*in_degree.entry(name.clone()).or_insert(0) += 1;
}
}
let mut queue: Vec<String> = in_degree
.iter()
.filter(|(_, °ree)| degree == 0)
.map(|(name, _)| name.clone())
.collect();
let mut sorted_names: Vec<String> = Vec::new();
while let Some(node) = queue.pop() {
sorted_names.push(node.clone());
if let Some(neighbors) = graph.get(&node) {
for neighbor in neighbors {
if let Some(degree) = in_degree.get_mut(neighbor) {
*degree -= 1;
if *degree == 0 {
queue.push(neighbor.clone());
}
}
}
}
}
if sorted_names.len() < plugins.len() {
let unsorted: Vec<String> = plugins
.keys()
.filter(|name| !sorted_names.contains(name))
.cloned()
.collect();
let unsorted_str = unsorted.join(", ");
return Err(BaseError::PluginCircularDependency(format!(
"循环依赖涉及的插件: {}",
unsorted_str
)));
}
let sorted_plugins: Vec<Arc<dyn Plugin>> = sorted_names
.iter()
.filter_map(|name| plugins.get(name).cloned())
.collect();
Ok(sorted_plugins)
}
}
#[cfg(test)]
mod tests {
use super::*;
struct PluginA;
#[async_trait]
impl Plugin for PluginA {
fn name(&self) -> &str {
"plugin_a"
}
}
struct PluginB;
#[async_trait]
impl Plugin for PluginB {
fn name(&self) -> &str {
"plugin_b"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a"]
}
}
struct PluginC;
#[async_trait]
impl Plugin for PluginC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> &[&str] {
&["plugin_b"]
}
}
struct PluginFailing;
#[async_trait]
impl Plugin for PluginFailing {
fn name(&self) -> &str {
"plugin_failing"
}
async fn on_register(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
Err("注册失败".into())
}
}
struct PluginASpaced;
#[async_trait]
impl Plugin for PluginASpaced {
fn name(&self) -> &str {
" plugin_a "
}
}
struct PluginBlankName;
#[async_trait]
impl Plugin for PluginBlankName {
fn name(&self) -> &str {
" "
}
}
#[tokio::test]
async fn test_registry_get_matches_registered_plugins() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let plugin_a = registry.get("plugin_a");
assert!(plugin_a.is_some(), "应能找到 plugin_a");
assert_eq!(plugin_a.unwrap().name(), "plugin_a");
let plugin_b = registry.get("plugin_b");
assert!(plugin_b.is_some(), "应能找到 plugin_b");
assert_eq!(plugin_b.unwrap().name(), "plugin_b");
let plugin_c = registry.get("plugin_c");
assert!(plugin_c.is_some(), "应能找到 plugin_c");
assert_eq!(plugin_c.unwrap().name(), "plugin_c");
assert!(
registry.get("nonexistent").is_none(),
"不存在的插件应返回 None"
);
}
#[tokio::test]
async fn test_registry_get_all_returns_cached_result() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let all_first = registry.get_all();
let all_second = registry.get_all();
assert_eq!(
all_first.len(),
all_second.len(),
"多次调用 get_all() 应返回相同数量的插件"
);
assert_eq!(all_first.len(), 3, "应有 3 个插件");
let names_first: Vec<&str> = all_first.iter().map(|p| p.name()).collect();
let names_second: Vec<&str> = all_second.iter().map(|p| p.name()).collect();
assert_eq!(
names_first, names_second,
"多次调用 get_all() 应返回相同顺序的插件"
);
}
#[tokio::test]
async fn test_registry_get_all_topological_order() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginC).await.unwrap();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let all_plugins = registry.get_all();
let pos_a = all_plugins.iter().position(|p| p.name() == "plugin_a");
let pos_b = all_plugins.iter().position(|p| p.name() == "plugin_b");
let pos_c = all_plugins.iter().position(|p| p.name() == "plugin_c");
assert!(
pos_a.is_some() && pos_b.is_some() && pos_c.is_some(),
"所有插件应在排序结果中"
);
assert!(
pos_a.unwrap() < pos_b.unwrap(),
"plugin_a(被依赖)应在 plugin_b 之前"
);
assert!(
pos_b.unwrap() < pos_c.unwrap(),
"plugin_b(被依赖)应在 plugin_c 之前"
);
}
#[tokio::test]
async fn test_builder_register_duplicate_returns_error() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
struct PluginADuplicate;
#[async_trait]
impl Plugin for PluginADuplicate {
fn name(&self) -> &str {
"plugin_a"
}
}
let result = builder.register(PluginADuplicate).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(_))),
"注册重名插件应返回 PluginAlreadyRegistered 错误"
);
}
#[tokio::test]
async fn test_builder_register_trims_plugin_names() {
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginASpaced)
.await
.expect("插件名应在构建期注册时 trim");
let result = builder.register(PluginA).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
"trim 后的重复插件名应返回 PluginAlreadyRegistered"
);
let registry = builder.build().expect("构建注册表应成功");
assert!(registry.get("plugin_a").is_some());
assert!(registry.get(" plugin_a ").is_some());
}
#[tokio::test]
async fn test_plugin_manager_register_trims_plugin_names_and_config_keys() {
let manager = PluginManager::new();
manager
.register(PluginASpaced)
.await
.expect("插件名应在运行期注册时 trim");
assert!(manager.get("plugin_a").await.is_some());
assert!(manager.get(" plugin_a ").await.is_some());
let result = manager.register(PluginA).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
"trim 后的重复插件名应返回 PluginAlreadyRegistered"
);
let config = serde_json::json!({"enabled": true});
manager
.load_config(" plugin_a ", config.clone())
.await
.expect("配置加载应使用 trim 后插件名");
assert_eq!(manager.get_config("plugin_a").await, Some(config.clone()));
assert_eq!(manager.get_config(" plugin_a ").await, Some(config));
}
#[tokio::test]
async fn test_register_rejects_blank_plugin_names() {
let mut builder = PluginManagerBuilder::new();
let builder_result = builder.register(PluginBlankName).await;
assert!(
matches!(builder_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
"构建期注册空白插件名应返回 PluginRegisterFailed"
);
let manager = PluginManager::new();
let manager_result = manager.register(PluginBlankName).await;
assert!(
matches!(manager_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
"运行期注册空白插件名应返回 PluginRegisterFailed"
);
}
#[tokio::test]
async fn test_builder_register_callback_failure_returns_error() {
use std::error::Error;
let mut builder = PluginManagerBuilder::new();
let result = builder.register(PluginFailing).await;
let error = match result {
Err(error) => error,
Ok(()) => panic!("注册回调失败时不应成功"),
};
assert!(matches!(
&error,
BaseError::PluginLifecycleFailed {
plugin,
stage: PluginLifecycleStage::Register,
..
} if plugin == "plugin_failing"
));
assert_eq!(error.code(), 100003);
assert!(error.source().is_some(), "注册回调底层错误链不得丢失");
}
#[tokio::test]
async fn test_builder_build_produces_registry() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
assert!(
registry.get("plugin_a").is_some(),
"registry 应包含已注册的插件"
);
assert_eq!(registry.get_all().len(), 1, "registry 应有 1 个插件");
}
#[tokio::test]
async fn test_registry_get_returns_correct_plugin() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let plugin = registry.get("plugin_a").unwrap();
assert_eq!(plugin.name(), "plugin_a", "get() 应返回正确名称的插件");
assert_eq!(plugin.version(), "0.1.0", "get() 应返回正确版本的插件");
}
#[tokio::test]
async fn test_registry_shutdown_succeeds() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let result = registry.shutdown().await;
assert!(result.is_ok(), "shutdown() 应成功执行");
}
#[tokio::test]
async fn test_shutdown_calls_in_reverse_topological_order() {
use std::sync::Mutex;
static SHUTDOWN_ORDER: Mutex<Vec<String>> = Mutex::new(Vec::new());
SHUTDOWN_ORDER.lock().unwrap().clear();
struct PluginA;
#[async_trait]
impl Plugin for PluginA {
fn name(&self) -> &str {
"plugin_a"
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_a".to_string());
Ok(())
}
}
struct PluginB;
#[async_trait]
impl Plugin for PluginB {
fn name(&self) -> &str {
"plugin_b"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_b".to_string());
Ok(())
}
}
struct PluginC;
#[async_trait]
impl Plugin for PluginC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> &[&str] {
&["plugin_b"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_c".to_string());
Ok(())
}
}
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let result = registry.shutdown().await;
assert!(result.is_ok(), "shutdown() 应成功执行");
let order = SHUTDOWN_ORDER.lock().unwrap().clone();
assert_eq!(
order,
vec!["plugin_c", "plugin_b", "plugin_a"],
"shutdown 应按逆拓扑顺序关闭:C (依赖B) → B (依赖A) → A"
);
}
#[tokio::test]
async fn test_builder_new_creates_empty_builder() {
let builder = PluginManagerBuilder::new();
let registry = builder.build().expect("空构建器构建应成功");
assert_eq!(registry.get_all().len(), 0, "空构建器应生成空 registry");
assert!(
registry.get("any").is_none(),
"空 registry 不应包含任何插件"
);
}
#[tokio::test]
async fn test_build_detects_missing_dependency() {
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginB)
.await
.expect("注册 plugin_b 应成功");
let result = builder.build();
assert!(
matches!(result, Err(BaseError::PluginDependencyMissing(_, _))),
"依赖未注册时应返回 PluginDependencyMissing 错误"
);
if let Err(BaseError::PluginDependencyMissing(plugin, dep)) = result {
assert_eq!(plugin, "plugin_b", "错误应指向 plugin_b");
assert_eq!(dep, "plugin_a", "缺失的依赖应是 plugin_a");
}
}
#[tokio::test]
async fn test_build_detects_circular_dependency() {
struct PluginX;
#[async_trait]
impl Plugin for PluginX {
fn name(&self) -> &str {
"plugin_x"
}
fn dependencies(&self) -> &[&str] {
&["plugin_y"]
}
}
struct PluginY;
#[async_trait]
impl Plugin for PluginY {
fn name(&self) -> &str {
"plugin_y"
}
fn dependencies(&self) -> &[&str] {
&["plugin_x"]
}
}
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginX)
.await
.expect("注册 plugin_x 应成功");
builder
.register(PluginY)
.await
.expect("注册 plugin_y 应成功");
let result = builder.build();
assert!(
matches!(result, Err(BaseError::PluginCircularDependency(_))),
"循环依赖时应返回 PluginCircularDependency 错误"
);
if let Err(BaseError::PluginCircularDependency(msg)) = result {
assert!(
msg.contains("plugin_x") || msg.contains("plugin_y"),
"错误信息应包含循环中的插件名称"
);
}
}
#[cfg(feature = "plugin-schema")]
#[tokio::test]
async fn test_validate_config_with_schema() {
use serde_json::json;
struct SchemaPlugin;
#[async_trait]
impl Plugin for SchemaPlugin {
fn name(&self) -> &str {
"schema_plugin"
}
fn config_schema(&self) -> Option<JsonValue> {
Some(json!({
"type": "object",
"properties": {
"host": {"type": "string"},
"port": {"type": "integer"}
},
"required": ["host", "port"]
}))
}
}
let manager = PluginManager::new();
manager.register(SchemaPlugin).await.expect("注册应成功");
let valid_config = json!({"host": "localhost", "port": 3306});
let result = manager.load_config("schema_plugin", valid_config).await;
assert!(result.is_ok(), "合法配置应通过验证");
}
#[cfg(feature = "plugin-schema")]
#[tokio::test]
async fn test_validate_config_invalid_returns_error() {
use serde_json::json;
struct StrictPlugin;
#[async_trait]
impl Plugin for StrictPlugin {
fn name(&self) -> &str {
"strict_plugin"
}
fn config_schema(&self) -> Option<JsonValue> {
Some(json!({
"type": "object",
"properties": {
"port": {"type": "integer"}
},
"required": ["port"]
}))
}
}
let manager = PluginManager::new();
manager.register(StrictPlugin).await.expect("注册应成功");
let invalid_config = json!({"host": "localhost"});
let result = manager.load_config("strict_plugin", invalid_config).await;
assert!(
matches!(result, Err(BaseError::PluginConfigInvalid(_, _))),
"配置不符合 Schema 应返回 PluginConfigInvalid 错误"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_same_name_register_keeps_map_consistent() {
struct DupPlugin;
#[async_trait]
impl Plugin for DupPlugin {
fn name(&self) -> &str {
"dup_plugin"
}
}
let manager = Arc::new(PluginManager::new());
let mut handles = Vec::new();
for _ in 0..16 {
let m = Arc::clone(&manager);
handles.push(tokio::spawn(async move { m.register(DupPlugin).await }));
}
let mut ok_count = 0usize;
for h in handles {
let res = h.await.expect("注册任务不应 panic");
if res.is_ok() {
ok_count += 1;
}
}
assert!(ok_count >= 1, "并发同名注册应至少有一个成功");
let got = manager.get("dup_plugin").await;
assert!(got.is_some(), "并发注册后应能查到 dup_plugin");
assert_eq!(got.unwrap().name(), "dup_plugin");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_distinct_register_no_loss() {
macro_rules! make_plugin {
($ty:ident, $name:literal) => {
struct $ty;
#[async_trait]
impl Plugin for $ty {
fn name(&self) -> &str {
$name
}
}
};
}
make_plugin!(P0, "cn_p0");
make_plugin!(P1, "cn_p1");
make_plugin!(P2, "cn_p2");
make_plugin!(P3, "cn_p3");
make_plugin!(P4, "cn_p4");
make_plugin!(P5, "cn_p5");
make_plugin!(P6, "cn_p6");
make_plugin!(P7, "cn_p7");
let manager = Arc::new(PluginManager::new());
let m = Arc::clone(&manager);
let (r0, r1, r2, r3, r4, r5, r6, r7) = tokio::join!(
{
let m = Arc::clone(&m);
async move { m.register(P0).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P1).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P2).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P3).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P4).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P5).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P6).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P7).await }
},
);
for r in [r0, r1, r2, r3, r4, r5, r6, r7] {
r.expect("不同名插件注册应全部成功");
}
for i in 0..8 {
let name = format!("cn_p{}", i);
assert!(
manager.get(&name).await.is_some(),
"{} 应已注册且可查到",
name
);
}
}
}