mf_state/plugin/
manager.rs

1use std::collections::{HashMap, HashSet};
2use std::sync::Arc;
3use tokio::sync::RwLock;
4use anyhow::Result;
5
6use super::dependency::DependencyManager;
7use super::plugin::Plugin;
8
9/// 插件管理器
10#[derive(Debug, Clone)]
11pub struct PluginManager {
12    pub plugins: Arc<RwLock<HashMap<String, Arc<Plugin>>>>,
13    pub dependency_manager: Arc<RwLock<DependencyManager>>,
14    pub plugin_order: Arc<RwLock<Vec<String>>>,
15    // 新增：标记是否已完成初始化
16    pub initialized: Arc<RwLock<bool>>,
17}
18
19impl PluginManager {
20    pub fn new() -> Self {
21        Self {
22            plugins: Arc::new(RwLock::new(HashMap::new())),
23            dependency_manager: Arc::new(RwLock::new(DependencyManager::new())),
24            plugin_order: Arc::new(RwLock::new(Vec::new())),
25            initialized: Arc::new(RwLock::new(false)),
26        }
27    }
28
29    /// 注册插件
30    pub async fn register_plugin(
31        &self,
32        plugin: Arc<Plugin>,
33    ) -> Result<()> {
34        let plugin_name = plugin.spec.tr.metadata().name.clone();
35
36        // 检查插件是否已存在
37        {
38            let plugins = self.plugins.read().await;
39            if plugins.contains_key(&plugin_name) {
40                return Err(anyhow::anyhow!("插件 '{}' 已存在", plugin_name));
41            }
42        }
43        // 注册插件
44        {
45            let mut plugins = self.plugins.write().await;
46            plugins.insert(plugin_name.clone(), plugin.clone());
47        }
48
49        // 更新依赖图
50        self.update_dependency_graph(&plugin).await?;
51
52        tracing::info!("插件 '{}' 注册成功", plugin_name);
53        Ok(())
54    }
55    /// 验证插件依赖
56    pub async fn finalize_registration(&self) -> Result<()> {
57        // 检查循环依赖
58        self.check_circular_dependencies().await?;
59
60        // 检查缺失的依赖
61        self.check_missing_dependencies().await?;
62
63        // 检查插件冲突
64        self.check_plugin_conflicts().await?;
65
66        // 更新插件执行顺序
67        self.update_plugin_order().await?;
68
69        // 标记为已初始化
70        {
71            let mut initialized = self.initialized.write().await;
72            *initialized = true;
73        }
74
75        tracing::info!("插件注册完成，共注册 {} 个插件", {
76            let plugins = self.plugins.read().await;
77            plugins.len()
78        });
79
80        Ok(())
81    }
82    /// 检查循环依赖
83    async fn check_circular_dependencies(&self) -> Result<()> {
84        let dependency_manager = self.dependency_manager.read().await;
85        if dependency_manager.has_circular_dependencies() {
86            let report = dependency_manager.get_circular_dependency_report();
87            return Err(anyhow::anyhow!(
88                "检测到循环依赖: {:?}",
89                report.to_string()
90            ));
91        }
92        Ok(())
93    }
94    /// 检查缺失的依赖
95    async fn check_missing_dependencies(&self) -> Result<()> {
96        let dependency_manager = self.dependency_manager.read().await;
97        let report = dependency_manager.check_missing_dependencies();
98        if report.has_missing_dependencies {
99            return Err(anyhow::anyhow!(
100                "检测到缺失依赖: {:?}",
101                report.to_string()
102            ));
103        }
104        Ok(())
105    }
106    /// 检查插件冲突
107    async fn check_plugin_conflicts(&self) -> Result<()> {
108        let plugins = self.plugins.read().await;
109        let available_plugins: HashSet<String> =
110            plugins.keys().cloned().collect();
111
112        for (name, plugin) in plugins.iter() {
113            let metadata = plugin.spec.tr.metadata();
114
115            for conflict in &metadata.conflicts {
116                if available_plugins.contains(conflict) {
117                    return Err(anyhow::anyhow!(
118                        "插件 '{}' 与插件 '{}' 冲突",
119                        name,
120                        conflict
121                    ));
122                }
123            }
124        }
125
126        Ok(())
127    }
128
129    /// 更新依赖图
130    async fn update_dependency_graph(
131        &self,
132        plugin: &Arc<Plugin>,
133    ) -> Result<()> {
134        let mut dependency_manager = self.dependency_manager.write().await;
135
136        let metadata = plugin.spec.tr.metadata();
137
138        // 添加插件节点
139        dependency_manager.add_plugin(&metadata.name);
140
141        // 添加依赖关系
142        for dep in &metadata.dependencies {
143            dependency_manager.add_dependency(&metadata.name, dep)?;
144        }
145
146        Ok(())
147    }
148    /// 更新插件执行顺序
149    async fn update_plugin_order(&self) -> Result<()> {
150        let dependency_manager = self.dependency_manager.read().await;
151        let order = dependency_manager.get_topological_order()?;
152
153        let mut plugin_order = self.plugin_order.write().await;
154        *plugin_order = order;
155
156        Ok(())
157    }
158    /// 获取排序后的插件
159    /// 按照依赖关系排序
160    pub async fn get_sorted_plugins(&self) -> Vec<Arc<Plugin>> {
161        let plugin_order = self.plugin_order.read().await;
162        let plugins = self.plugins.read().await;
163        let mut sorted_plugins = Vec::new();
164        for plugin_name in plugin_order.iter() {
165            if let Some(plugin) = plugins.get(plugin_name) {
166                sorted_plugins.push(plugin.clone());
167            }
168        }
169        sorted_plugins
170    }
171
172    /// 检查初始化状态
173    pub async fn is_initialized(&self) -> bool {
174        let initialized = self.initialized.read().await;
175        *initialized
176    }
177}
mf_state/plugin/manager.rs

mf_state/plugin/
manager.rs
