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(&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, _config: &JsonValue, _schema: &JsonValue) -> Result<(), BaseError> {
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()
}
}