use async_trait::async_trait;
use serde_json::Value as JsonValue;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use crate::error::BaseError;
#[async_trait]
pub trait Plugin: Send + Sync {
fn name(&self) -> &str;
fn version(&self) -> &str {
"0.1.0"
}
fn dependencies(&self) -> Vec<&str> {
Vec::new()
}
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<(), Box<dyn std::error::Error>> {
Ok(())
}
async fn on_init(&self) -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error>> {
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 = 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(|e| BaseError::PluginRegisterFailed(name.clone(), e.to_string()))?;
{
let mut plugins = self.plugins.write().await;
plugins.insert(name.clone(), plugin);
}
log::info!("插件已注册: {}", name);
Ok(())
}
pub async fn get(&self, name: &str) -> Option<Arc<dyn Plugin>> {
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 plugin = self
.get(name)
.await
.ok_or_else(|| BaseError::PluginNotFound(name.to_string()))?;
if let Some(schema) = plugin.config_schema() {
self.validate_config(name, &config, &schema)?;
}
{
let mut configs = self.configs.write().await;
configs.insert(name.to_string(), config);
}
Ok(())
}
pub async fn get_config(&self, name: &str) -> Option<JsonValue> {
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());
}
}
}
}
}
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();
for plugin in plugins {
let name = plugin.name();
if let Err(e) = plugin.on_shutdown().await {
log::error!("插件 {} 关闭失败: {}", name, e);
return Err(BaseError::PluginShutdownFailed(
name.to_string(),
e.to_string(),
));
}
log::info!("插件已关闭: {}", name);
}
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 = 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(|e| BaseError::PluginRegisterFailed(name.clone(), e.to_string()))?;
self.plugins.insert(name.clone(), plugin);
log::info!("插件已注册(构建阶段): {}", name);
Ok(())
}
pub fn build(self) -> Result<PluginRegistry, BaseError> {
for plugin in self.plugins.values() {
let plugin_name = plugin.name().to_string();
for dep in plugin.dependencies() {
if !self.plugins.contains_key(dep) {
return Err(BaseError::PluginDependencyMissing(
plugin_name,
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>> {
self.plugins.get(name)
}
pub fn get_all(&self) -> &[Arc<dyn Plugin>] {
&self.sorted_plugins
}
pub fn get_config(&self, name: &str) -> Option<&JsonValue> {
self.configs.get(name)
}
pub async fn shutdown(&self) -> Result<(), BaseError> {
for plugin in self.sorted_plugins.iter().rev() {
let name = plugin.name();
if let Err(e) = plugin.on_shutdown().await {
log::error!("插件 {} 关闭失败: {}", name, e);
return Err(BaseError::PluginShutdownFailed(
name.to_string(),
e.to_string(),
));
}
log::info!("插件已关闭: {}", name);
}
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 plugin in plugins.values() {
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_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 mut sorted_plugins: Vec<Arc<dyn Plugin>> = plugins.values().cloned().collect();
sorted_plugins.sort_by_key(|p| {
sorted_names
.iter()
.position(|n| n == p.name())
.unwrap_or(usize::MAX)
});
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) -> Vec<&str> {
vec!["plugin_a"]
}
}
struct PluginC;
#[async_trait]
impl Plugin for PluginC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> Vec<&str> {
vec!["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>> {
Err("注册失败".into())
}
}
#[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_callback_failure_returns_error() {
let mut builder = PluginManagerBuilder::new();
let result = builder.register(PluginFailing).await;
assert!(
matches!(result, Err(BaseError::PluginRegisterFailed(_, _))),
"注册回调失败应返回 PluginRegisterFailed 错误"
);
}
#[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_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) -> Vec<&str> {
vec!["plugin_y"]
}
}
struct PluginY;
#[async_trait]
impl Plugin for PluginY {
fn name(&self) -> &str {
"plugin_y"
}
fn dependencies(&self) -> Vec<&str> {
vec!["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 错误"
);
}
}