1use async_trait::async_trait;
31use serde_json::Value as JsonValue;
32use std::collections::HashMap;
33use std::fmt;
34use std::sync::Arc;
35use tokio::sync::RwLock;
36
37use crate::error::BaseError;
38
39pub type PluginError = Box<dyn std::error::Error + Send + Sync + 'static>;
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq)]
44#[non_exhaustive]
45pub enum PluginLifecycleStage {
46 Register,
48 Initialize,
50 Shutdown,
52}
53
54impl fmt::Display for PluginLifecycleStage {
55 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
56 formatter.write_str(match self {
57 Self::Register => "register",
58 Self::Initialize => "initialize",
59 Self::Shutdown => "shutdown",
60 })
61 }
62}
63
64fn normalize_plugin_name(name: &str) -> Result<&str, BaseError> {
65 let name = name.trim();
66 if name.is_empty() {
67 return Err(BaseError::PluginRegisterFailed(
68 "<empty>".to_string(),
69 "插件名称不能为空".to_string(),
70 ));
71 }
72
73 Ok(name)
74}
75
76fn normalize_plugin_lookup_name(name: &str) -> Option<&str> {
77 let name = name.trim();
78 (!name.is_empty()).then_some(name)
79}
80
81#[async_trait]
111pub trait Plugin: Send + Sync {
112 fn name(&self) -> &str;
119
120 fn version(&self) -> &str {
127 "0.1.0"
128 }
129
130 fn dependencies(&self) -> &[&str] {
138 &[]
139 }
140
141 fn init_sql(&self) -> Vec<String> {
149 Vec::new()
150 }
151
152 fn migration_sql(&self) -> Vec<(String, String)> {
160 Vec::new()
161 }
162
163 fn config_schema(&self) -> Option<JsonValue> {
171 None
172 }
173
174 async fn on_register(&self) -> Result<(), PluginError> {
182 Ok(())
183 }
184
185 async fn on_init(&self) -> Result<(), PluginError> {
194 Ok(())
195 }
196
197 async fn on_shutdown(&self) -> Result<(), PluginError> {
205 Ok(())
206 }
207}
208
209pub struct PluginManager {
240 plugins: Arc<RwLock<HashMap<String, Arc<dyn Plugin>>>>,
243
244 configs: Arc<RwLock<HashMap<String, JsonValue>>>,
247}
248
249impl PluginManager {
250 pub fn new() -> Self {
263 Self {
264 plugins: Arc::new(RwLock::new(HashMap::new())),
265 configs: Arc::new(RwLock::new(HashMap::new())),
266 }
267 }
268
269 pub async fn register<P: Plugin + 'static>(&self, plugin: P) -> Result<(), BaseError> {
287 let name = normalize_plugin_name(plugin.name())?.to_string();
288 let plugin = Arc::new(plugin);
289
290 {
292 let plugins = self.plugins.read().await;
293 if plugins.contains_key(&name) {
294 return Err(BaseError::PluginAlreadyRegistered(name));
295 }
296 } plugin
300 .on_register()
301 .await
302 .map_err(|source| BaseError::PluginLifecycleFailed {
303 plugin: name.clone(),
304 stage: PluginLifecycleStage::Register,
305 source,
306 })?;
307
308 {
310 let mut plugins = self.plugins.write().await;
311 if plugins.contains_key(&name) {
312 return Err(BaseError::PluginAlreadyRegistered(name));
313 }
314 plugins.insert(name.clone(), plugin);
315 }
316
317 log::info!("插件已注册: {}", name);
318 Ok(())
319 }
320
321 pub async fn get(&self, name: &str) -> Option<Arc<dyn Plugin>> {
341 let name = normalize_plugin_lookup_name(name)?;
342 let plugins = self.plugins.read().await;
343 plugins.get(name).cloned()
344 }
345
346 pub async fn get_all(&self) -> Vec<Arc<dyn Plugin>> {
363 let plugins = self.plugins.read().await;
364 let mut plugin_list: Vec<_> = plugins.values().cloned().collect();
365
366 self.topological_sort(&mut plugin_list);
368
369 plugin_list
370 }
371
372 pub async fn load_config(&self, name: &str, config: JsonValue) -> Result<(), BaseError> {
393 let normalized_name = normalize_plugin_lookup_name(name)
394 .ok_or_else(|| BaseError::PluginNotFound(name.to_string()))?;
395
396 let plugin = self
398 .get(normalized_name)
399 .await
400 .ok_or_else(|| BaseError::PluginNotFound(normalized_name.to_string()))?;
401
402 if let Some(schema) = plugin.config_schema() {
404 self.validate_config(normalized_name, &config, &schema)?;
405 }
406
407 {
409 let mut configs = self.configs.write().await;
410 configs.insert(normalized_name.to_string(), config);
411 }
412
413 Ok(())
414 }
415
416 pub async fn get_config(&self, name: &str) -> Option<JsonValue> {
436 let name = normalize_plugin_lookup_name(name)?;
437 let configs = self.configs.read().await;
438 configs.get(name).cloned()
439 }
440
441 fn topological_sort(&self, plugins: &mut Vec<Arc<dyn Plugin>>) {
449 let mut in_degree: HashMap<String, usize> = HashMap::new();
451 let mut graph: HashMap<String, Vec<String>> = HashMap::new();
452
453 for plugin in plugins.iter() {
454 let name = plugin.name().to_string();
455 in_degree.entry(name.clone()).or_insert(0);
456
457 for dep in plugin.dependencies() {
458 graph.entry(dep.to_string()).or_default().push(name.clone());
459 *in_degree.entry(name.clone()).or_insert(0) += 1;
460 }
461 }
462
463 let mut queue: Vec<String> = in_degree
465 .iter()
466 .filter(|(_, °ree)| degree == 0)
467 .map(|(name, _)| name.clone())
468 .collect();
469
470 let mut sorted = Vec::new();
471
472 while let Some(node) = queue.pop() {
473 sorted.push(node.clone());
474
475 if let Some(neighbors) = graph.get(&node) {
476 for neighbor in neighbors {
477 if let Some(degree) = in_degree.get_mut(neighbor) {
478 *degree -= 1;
479 if *degree == 0 {
480 queue.push(neighbor.clone());
481 }
482 }
483 }
484 }
485 }
486
487 if sorted.len() < plugins.len() {
489 let circular: Vec<String> = plugins
490 .iter()
491 .filter(|p| !sorted.iter().any(|n| n == p.name()))
492 .map(|p| p.name().to_string())
493 .collect();
494 log::error!(
495 "检测到循环依赖,以下插件将无法按依赖顺序加载: {}",
496 circular.join(", ")
497 );
498 sorted.extend(circular);
500 }
501
502 plugins.sort_by_key(|p| {
504 sorted
505 .iter()
506 .position(|n| n == p.name())
507 .unwrap_or(usize::MAX)
508 });
509 }
510
511 fn validate_config(
525 &self,
526 plugin_name: &str,
527 config: &JsonValue,
528 schema: &JsonValue,
529 ) -> Result<(), BaseError> {
530 #[cfg(feature = "plugin-schema")]
532 {
533 let validator = jsonschema::validator_for(schema).map_err(|e| {
535 BaseError::PluginConfigInvalid(
536 plugin_name.to_string(),
537 format!("Schema 编译失败: {}", e),
538 )
539 })?;
540
541 let error_msgs: Vec<String> = validator
543 .iter_errors(config)
544 .map(|e| e.to_string())
545 .collect();
546
547 if !error_msgs.is_empty() {
548 return Err(BaseError::PluginConfigInvalid(
549 plugin_name.to_string(),
550 error_msgs.join("; "),
551 ));
552 }
553 }
554
555 #[cfg(not(feature = "plugin-schema"))]
557 {
558 let _ = (plugin_name, config, schema);
559 }
560
561 Ok(())
562 }
563
564 pub async fn shutdown(&self) -> Result<(), BaseError> {
582 let mut plugins = self.get_all().await;
583 plugins.reverse(); let mut errors: Vec<(String, PluginError)> = Vec::new();
586
587 for plugin in plugins {
588 let name = plugin.name();
589 if let Err(e) = plugin.on_shutdown().await {
590 log::error!("插件 {} 关闭失败: {}", name, e);
591 errors.push((name.to_string(), e));
592 } else {
593 log::info!("插件已关闭: {}", name);
594 }
595 }
596
597 if let Some((plugin, source)) = errors.into_iter().next() {
598 Err(BaseError::PluginLifecycleFailed {
599 plugin,
600 stage: PluginLifecycleStage::Shutdown,
601 source,
602 })
603 } else {
604 Ok(())
605 }
606 }
607}
608
609impl Default for PluginManager {
610 fn default() -> Self {
611 Self::new()
612 }
613}
614
615pub struct PluginManagerBuilder {
644 plugins: HashMap<String, Arc<dyn Plugin>>,
647
648 configs: HashMap<String, JsonValue>,
651}
652
653impl PluginManagerBuilder {
654 pub fn new() -> Self {
667 Self {
668 plugins: HashMap::new(),
669 configs: HashMap::new(),
670 }
671 }
672
673 pub async fn register<P: Plugin + 'static>(&mut self, plugin: P) -> Result<(), BaseError> {
693 let name = normalize_plugin_name(plugin.name())?.to_string();
694
695 if self.plugins.contains_key(&name) {
697 return Err(BaseError::PluginAlreadyRegistered(name));
698 }
699
700 let plugin = Arc::new(plugin);
701
702 plugin
704 .on_register()
705 .await
706 .map_err(|source| BaseError::PluginLifecycleFailed {
707 plugin: name.clone(),
708 stage: PluginLifecycleStage::Register,
709 source,
710 })?;
711
712 self.plugins.insert(name.clone(), plugin);
714
715 log::info!("插件已注册(构建阶段): {}", name);
716 Ok(())
717 }
718
719 pub fn build(self) -> Result<PluginRegistry, BaseError> {
739 for (plugin_name, plugin) in &self.plugins {
741 for dep in plugin.dependencies() {
742 let dep = normalize_plugin_name(dep)?;
743 if !self.plugins.contains_key(dep) {
744 return Err(BaseError::PluginDependencyMissing(
746 plugin_name.clone(),
747 dep.to_string(),
748 ));
749 }
750 }
751 }
752 PluginRegistry::new(self.plugins, self.configs)
754 }
755}
756
757impl Default for PluginManagerBuilder {
758 fn default() -> Self {
759 Self::new()
760 }
761}
762
763pub struct PluginRegistry {
795 plugins: HashMap<String, Arc<dyn Plugin>>,
798
799 sorted_plugins: Vec<Arc<dyn Plugin>>,
801
802 configs: HashMap<String, JsonValue>,
805}
806
807impl PluginRegistry {
808 fn new(
821 plugins: HashMap<String, Arc<dyn Plugin>>,
822 configs: HashMap<String, JsonValue>,
823 ) -> Result<Self, BaseError> {
824 let sorted_plugins = Self::compute_topological_sort(&plugins)?;
826 Ok(Self {
827 plugins,
828 sorted_plugins,
829 configs,
830 })
831 }
832
833 pub fn get(&self, name: &str) -> Option<&Arc<dyn Plugin>> {
855 let name = normalize_plugin_lookup_name(name)?;
856 self.plugins.get(name)
857 }
858
859 pub fn get_all(&self) -> &[Arc<dyn Plugin>] {
878 &self.sorted_plugins
879 }
880
881 pub fn get_config(&self, name: &str) -> Option<&JsonValue> {
890 let name = normalize_plugin_lookup_name(name)?;
891 self.configs.get(name)
892 }
893
894 pub async fn shutdown(&self) -> Result<(), BaseError> {
913 let mut errors: Vec<(String, PluginError)> = Vec::new();
915
916 for plugin in self.sorted_plugins.iter().rev() {
917 let name = plugin.name();
918 if let Err(e) = plugin.on_shutdown().await {
919 log::error!("插件 {} 关闭失败: {}", name, e);
920 errors.push((name.to_string(), e));
921 } else {
922 log::info!("插件已关闭: {}", name);
923 }
924 }
925
926 if let Some((plugin, source)) = errors.into_iter().next() {
927 Err(BaseError::PluginLifecycleFailed {
928 plugin,
929 stage: PluginLifecycleStage::Shutdown,
930 source,
931 })
932 } else {
933 Ok(())
934 }
935 }
936
937 fn compute_topological_sort(
949 plugins: &HashMap<String, Arc<dyn Plugin>>,
950 ) -> Result<Vec<Arc<dyn Plugin>>, BaseError> {
951 let mut in_degree: HashMap<String, usize> = HashMap::new();
953 let mut graph: HashMap<String, Vec<String>> = HashMap::new();
954
955 for (name, plugin) in plugins {
956 let name = name.clone();
957 in_degree.entry(name.clone()).or_insert(0);
958
959 for dep in plugin.dependencies() {
960 let dep = normalize_plugin_name(dep)?;
961 graph.entry(dep.to_string()).or_default().push(name.clone());
963 *in_degree.entry(name.clone()).or_insert(0) += 1;
964 }
965 }
966
967 let mut queue: Vec<String> = in_degree
969 .iter()
970 .filter(|(_, °ree)| degree == 0)
971 .map(|(name, _)| name.clone())
972 .collect();
973
974 let mut sorted_names: Vec<String> = Vec::new();
975
976 while let Some(node) = queue.pop() {
977 sorted_names.push(node.clone());
978
979 if let Some(neighbors) = graph.get(&node) {
980 for neighbor in neighbors {
981 if let Some(degree) = in_degree.get_mut(neighbor) {
982 *degree -= 1;
983 if *degree == 0 {
984 queue.push(neighbor.clone());
985 }
986 }
987 }
988 }
989 }
990
991 if sorted_names.len() < plugins.len() {
993 let unsorted: Vec<String> = plugins
995 .keys()
996 .filter(|name| !sorted_names.contains(name))
997 .cloned()
998 .collect();
999 let unsorted_str = unsorted.join(", ");
1000 return Err(BaseError::PluginCircularDependency(format!(
1001 "循环依赖涉及的插件: {}",
1002 unsorted_str
1003 )));
1004 }
1005
1006 let sorted_plugins: Vec<Arc<dyn Plugin>> = sorted_names
1009 .iter()
1010 .filter_map(|name| plugins.get(name).cloned())
1011 .collect();
1012
1013 Ok(sorted_plugins)
1014 }
1015}
1016
1017#[cfg(test)]
1018mod tests {
1019 use super::*;
1020
1021 struct PluginA;
1023
1024 #[async_trait]
1025 impl Plugin for PluginA {
1026 fn name(&self) -> &str {
1027 "plugin_a"
1028 }
1029 }
1030
1031 struct PluginB;
1033
1034 #[async_trait]
1035 impl Plugin for PluginB {
1036 fn name(&self) -> &str {
1037 "plugin_b"
1038 }
1039
1040 fn dependencies(&self) -> &[&str] {
1041 &["plugin_a"]
1042 }
1043 }
1044
1045 struct PluginC;
1047
1048 #[async_trait]
1049 impl Plugin for PluginC {
1050 fn name(&self) -> &str {
1051 "plugin_c"
1052 }
1053
1054 fn dependencies(&self) -> &[&str] {
1055 &["plugin_b"]
1056 }
1057 }
1058
1059 struct PluginFailing;
1061
1062 #[async_trait]
1063 impl Plugin for PluginFailing {
1064 fn name(&self) -> &str {
1065 "plugin_failing"
1066 }
1067
1068 async fn on_register(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
1069 Err("注册失败".into())
1070 }
1071 }
1072
1073 struct PluginASpaced;
1075
1076 #[async_trait]
1077 impl Plugin for PluginASpaced {
1078 fn name(&self) -> &str {
1079 " plugin_a "
1080 }
1081 }
1082
1083 struct PluginBlankName;
1085
1086 #[async_trait]
1087 impl Plugin for PluginBlankName {
1088 fn name(&self) -> &str {
1089 " "
1090 }
1091 }
1092
1093 #[tokio::test]
1095 async fn test_registry_get_matches_registered_plugins() {
1096 let mut builder = PluginManagerBuilder::new();
1097 builder.register(PluginA).await.unwrap();
1098 builder.register(PluginB).await.unwrap();
1099 builder.register(PluginC).await.unwrap();
1100
1101 let registry = builder.build().expect("构建注册表应成功");
1102
1103 let plugin_a = registry.get("plugin_a");
1105 assert!(plugin_a.is_some(), "应能找到 plugin_a");
1106 assert_eq!(plugin_a.unwrap().name(), "plugin_a");
1107
1108 let plugin_b = registry.get("plugin_b");
1109 assert!(plugin_b.is_some(), "应能找到 plugin_b");
1110 assert_eq!(plugin_b.unwrap().name(), "plugin_b");
1111
1112 let plugin_c = registry.get("plugin_c");
1113 assert!(plugin_c.is_some(), "应能找到 plugin_c");
1114 assert_eq!(plugin_c.unwrap().name(), "plugin_c");
1115
1116 assert!(
1118 registry.get("nonexistent").is_none(),
1119 "不存在的插件应返回 None"
1120 );
1121 }
1122
1123 #[tokio::test]
1125 async fn test_registry_get_all_returns_cached_result() {
1126 let mut builder = PluginManagerBuilder::new();
1127 builder.register(PluginA).await.unwrap();
1128 builder.register(PluginB).await.unwrap();
1129 builder.register(PluginC).await.unwrap();
1130
1131 let registry = builder.build().expect("构建注册表应成功");
1132
1133 let all_first = registry.get_all();
1135 let all_second = registry.get_all();
1136
1137 assert_eq!(
1139 all_first.len(),
1140 all_second.len(),
1141 "多次调用 get_all() 应返回相同数量的插件"
1142 );
1143 assert_eq!(all_first.len(), 3, "应有 3 个插件");
1144
1145 let names_first: Vec<&str> = all_first.iter().map(|p| p.name()).collect();
1147 let names_second: Vec<&str> = all_second.iter().map(|p| p.name()).collect();
1148 assert_eq!(
1149 names_first, names_second,
1150 "多次调用 get_all() 应返回相同顺序的插件"
1151 );
1152 }
1153
1154 #[tokio::test]
1156 async fn test_registry_get_all_topological_order() {
1157 let mut builder = PluginManagerBuilder::new();
1158 builder.register(PluginC).await.unwrap();
1160 builder.register(PluginA).await.unwrap();
1161 builder.register(PluginB).await.unwrap();
1162
1163 let registry = builder.build().expect("构建注册表应成功");
1164 let all_plugins = registry.get_all();
1165
1166 let pos_a = all_plugins.iter().position(|p| p.name() == "plugin_a");
1168 let pos_b = all_plugins.iter().position(|p| p.name() == "plugin_b");
1169 let pos_c = all_plugins.iter().position(|p| p.name() == "plugin_c");
1170
1171 assert!(
1172 pos_a.is_some() && pos_b.is_some() && pos_c.is_some(),
1173 "所有插件应在排序结果中"
1174 );
1175
1176 assert!(
1178 pos_a.unwrap() < pos_b.unwrap(),
1179 "plugin_a(被依赖)应在 plugin_b 之前"
1180 );
1181 assert!(
1182 pos_b.unwrap() < pos_c.unwrap(),
1183 "plugin_b(被依赖)应在 plugin_c 之前"
1184 );
1185 }
1186
1187 #[tokio::test]
1189 async fn test_builder_register_duplicate_returns_error() {
1190 let mut builder = PluginManagerBuilder::new();
1191 builder.register(PluginA).await.unwrap();
1192
1193 struct PluginADuplicate;
1195 #[async_trait]
1196 impl Plugin for PluginADuplicate {
1197 fn name(&self) -> &str {
1198 "plugin_a"
1199 }
1200 }
1201
1202 let result = builder.register(PluginADuplicate).await;
1203 assert!(
1204 matches!(result, Err(BaseError::PluginAlreadyRegistered(_))),
1205 "注册重名插件应返回 PluginAlreadyRegistered 错误"
1206 );
1207 }
1208
1209 #[tokio::test]
1210 async fn test_builder_register_trims_plugin_names() {
1211 let mut builder = PluginManagerBuilder::new();
1212 builder
1213 .register(PluginASpaced)
1214 .await
1215 .expect("插件名应在构建期注册时 trim");
1216
1217 let result = builder.register(PluginA).await;
1218 assert!(
1219 matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
1220 "trim 后的重复插件名应返回 PluginAlreadyRegistered"
1221 );
1222
1223 let registry = builder.build().expect("构建注册表应成功");
1224 assert!(registry.get("plugin_a").is_some());
1225 assert!(registry.get(" plugin_a ").is_some());
1226 }
1227
1228 #[tokio::test]
1229 async fn test_plugin_manager_register_trims_plugin_names_and_config_keys() {
1230 let manager = PluginManager::new();
1231 manager
1232 .register(PluginASpaced)
1233 .await
1234 .expect("插件名应在运行期注册时 trim");
1235
1236 assert!(manager.get("plugin_a").await.is_some());
1237 assert!(manager.get(" plugin_a ").await.is_some());
1238
1239 let result = manager.register(PluginA).await;
1240 assert!(
1241 matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
1242 "trim 后的重复插件名应返回 PluginAlreadyRegistered"
1243 );
1244
1245 let config = serde_json::json!({"enabled": true});
1246 manager
1247 .load_config(" plugin_a ", config.clone())
1248 .await
1249 .expect("配置加载应使用 trim 后插件名");
1250
1251 assert_eq!(manager.get_config("plugin_a").await, Some(config.clone()));
1252 assert_eq!(manager.get_config(" plugin_a ").await, Some(config));
1253 }
1254
1255 #[tokio::test]
1256 async fn test_register_rejects_blank_plugin_names() {
1257 let mut builder = PluginManagerBuilder::new();
1258 let builder_result = builder.register(PluginBlankName).await;
1259 assert!(
1260 matches!(builder_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
1261 "构建期注册空白插件名应返回 PluginRegisterFailed"
1262 );
1263
1264 let manager = PluginManager::new();
1265 let manager_result = manager.register(PluginBlankName).await;
1266 assert!(
1267 matches!(manager_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
1268 "运行期注册空白插件名应返回 PluginRegisterFailed"
1269 );
1270 }
1271
1272 #[tokio::test]
1274 async fn test_builder_register_callback_failure_returns_error() {
1275 use std::error::Error;
1276
1277 let mut builder = PluginManagerBuilder::new();
1278 let result = builder.register(PluginFailing).await;
1279 let error = match result {
1280 Err(error) => error,
1281 Ok(()) => panic!("注册回调失败时不应成功"),
1282 };
1283 assert!(matches!(
1284 &error,
1285 BaseError::PluginLifecycleFailed {
1286 plugin,
1287 stage: PluginLifecycleStage::Register,
1288 ..
1289 } if plugin == "plugin_failing"
1290 ));
1291 assert_eq!(error.code(), 100003);
1292 assert!(error.source().is_some(), "注册回调底层错误链不得丢失");
1293 }
1294
1295 #[tokio::test]
1297 async fn test_builder_build_produces_registry() {
1298 let mut builder = PluginManagerBuilder::new();
1299 builder.register(PluginA).await.unwrap();
1300
1301 let registry = builder.build().expect("构建注册表应成功");
1302
1303 assert!(
1305 registry.get("plugin_a").is_some(),
1306 "registry 应包含已注册的插件"
1307 );
1308 assert_eq!(registry.get_all().len(), 1, "registry 应有 1 个插件");
1309 }
1310
1311 #[tokio::test]
1313 async fn test_registry_get_returns_correct_plugin() {
1314 let mut builder = PluginManagerBuilder::new();
1315 builder.register(PluginA).await.unwrap();
1316 builder.register(PluginB).await.unwrap();
1317
1318 let registry = builder.build().expect("构建注册表应成功");
1319
1320 let plugin = registry.get("plugin_a").unwrap();
1322 assert_eq!(plugin.name(), "plugin_a", "get() 应返回正确名称的插件");
1323 assert_eq!(plugin.version(), "0.1.0", "get() 应返回正确版本的插件");
1324 }
1325
1326 #[tokio::test]
1328 async fn test_registry_shutdown_succeeds() {
1329 let mut builder = PluginManagerBuilder::new();
1330 builder.register(PluginA).await.unwrap();
1331 builder.register(PluginB).await.unwrap();
1332
1333 let registry = builder.build().expect("构建注册表应成功");
1334
1335 let result = registry.shutdown().await;
1337 assert!(result.is_ok(), "shutdown() 应成功执行");
1338 }
1339
1340 #[tokio::test]
1346 async fn test_shutdown_calls_in_reverse_topological_order() {
1347 use std::sync::Mutex;
1348
1349 static SHUTDOWN_ORDER: Mutex<Vec<String>> = Mutex::new(Vec::new());
1350 SHUTDOWN_ORDER.lock().unwrap().clear();
1351
1352 struct PluginA;
1354 #[async_trait]
1355 impl Plugin for PluginA {
1356 fn name(&self) -> &str {
1357 "plugin_a"
1358 }
1359 async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
1360 SHUTDOWN_ORDER.lock().unwrap().push("plugin_a".to_string());
1361 Ok(())
1362 }
1363 }
1364
1365 struct PluginB;
1367 #[async_trait]
1368 impl Plugin for PluginB {
1369 fn name(&self) -> &str {
1370 "plugin_b"
1371 }
1372 fn dependencies(&self) -> &[&str] {
1373 &["plugin_a"]
1374 }
1375 async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
1376 SHUTDOWN_ORDER.lock().unwrap().push("plugin_b".to_string());
1377 Ok(())
1378 }
1379 }
1380
1381 struct PluginC;
1383 #[async_trait]
1384 impl Plugin for PluginC {
1385 fn name(&self) -> &str {
1386 "plugin_c"
1387 }
1388 fn dependencies(&self) -> &[&str] {
1389 &["plugin_b"]
1390 }
1391 async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
1392 SHUTDOWN_ORDER.lock().unwrap().push("plugin_c".to_string());
1393 Ok(())
1394 }
1395 }
1396
1397 let mut builder = PluginManagerBuilder::new();
1398 builder.register(PluginA).await.unwrap();
1399 builder.register(PluginB).await.unwrap();
1400 builder.register(PluginC).await.unwrap();
1401
1402 let registry = builder.build().expect("构建注册表应成功");
1403 let result = registry.shutdown().await;
1404 assert!(result.is_ok(), "shutdown() 应成功执行");
1405
1406 let order = SHUTDOWN_ORDER.lock().unwrap().clone();
1407 assert_eq!(
1408 order,
1409 vec!["plugin_c", "plugin_b", "plugin_a"],
1410 "shutdown 应按逆拓扑顺序关闭:C (依赖B) → B (依赖A) → A"
1411 );
1412 }
1413
1414 #[tokio::test]
1416 async fn test_builder_new_creates_empty_builder() {
1417 let builder = PluginManagerBuilder::new();
1418 let registry = builder.build().expect("空构建器构建应成功");
1419
1420 assert_eq!(registry.get_all().len(), 0, "空构建器应生成空 registry");
1422 assert!(
1423 registry.get("any").is_none(),
1424 "空 registry 不应包含任何插件"
1425 );
1426 }
1427
1428 #[tokio::test]
1430 async fn test_build_detects_missing_dependency() {
1431 let mut builder = PluginManagerBuilder::new();
1432 builder
1434 .register(PluginB)
1435 .await
1436 .expect("注册 plugin_b 应成功");
1437
1438 let result = builder.build();
1439 assert!(
1440 matches!(result, Err(BaseError::PluginDependencyMissing(_, _))),
1441 "依赖未注册时应返回 PluginDependencyMissing 错误"
1442 );
1443
1444 if let Err(BaseError::PluginDependencyMissing(plugin, dep)) = result {
1446 assert_eq!(plugin, "plugin_b", "错误应指向 plugin_b");
1447 assert_eq!(dep, "plugin_a", "缺失的依赖应是 plugin_a");
1448 }
1449 }
1450
1451 #[tokio::test]
1453 async fn test_build_detects_circular_dependency() {
1454 struct PluginX;
1456 #[async_trait]
1457 impl Plugin for PluginX {
1458 fn name(&self) -> &str {
1459 "plugin_x"
1460 }
1461 fn dependencies(&self) -> &[&str] {
1462 &["plugin_y"]
1463 }
1464 }
1465
1466 struct PluginY;
1467 #[async_trait]
1468 impl Plugin for PluginY {
1469 fn name(&self) -> &str {
1470 "plugin_y"
1471 }
1472 fn dependencies(&self) -> &[&str] {
1473 &["plugin_x"]
1474 }
1475 }
1476
1477 let mut builder = PluginManagerBuilder::new();
1478 builder
1479 .register(PluginX)
1480 .await
1481 .expect("注册 plugin_x 应成功");
1482 builder
1483 .register(PluginY)
1484 .await
1485 .expect("注册 plugin_y 应成功");
1486
1487 let result = builder.build();
1488 assert!(
1489 matches!(result, Err(BaseError::PluginCircularDependency(_))),
1490 "循环依赖时应返回 PluginCircularDependency 错误"
1491 );
1492
1493 if let Err(BaseError::PluginCircularDependency(msg)) = result {
1495 assert!(
1496 msg.contains("plugin_x") || msg.contains("plugin_y"),
1497 "错误信息应包含循环中的插件名称"
1498 );
1499 }
1500 }
1501
1502 #[cfg(feature = "plugin-schema")]
1504 #[tokio::test]
1505 async fn test_validate_config_with_schema() {
1506 use serde_json::json;
1507
1508 struct SchemaPlugin;
1510 #[async_trait]
1511 impl Plugin for SchemaPlugin {
1512 fn name(&self) -> &str {
1513 "schema_plugin"
1514 }
1515 fn config_schema(&self) -> Option<JsonValue> {
1516 Some(json!({
1517 "type": "object",
1518 "properties": {
1519 "host": {"type": "string"},
1520 "port": {"type": "integer"}
1521 },
1522 "required": ["host", "port"]
1523 }))
1524 }
1525 }
1526
1527 let manager = PluginManager::new();
1528 manager.register(SchemaPlugin).await.expect("注册应成功");
1529
1530 let valid_config = json!({"host": "localhost", "port": 3306});
1532 let result = manager.load_config("schema_plugin", valid_config).await;
1533 assert!(result.is_ok(), "合法配置应通过验证");
1534 }
1535
1536 #[cfg(feature = "plugin-schema")]
1538 #[tokio::test]
1539 async fn test_validate_config_invalid_returns_error() {
1540 use serde_json::json;
1541
1542 struct StrictPlugin;
1544 #[async_trait]
1545 impl Plugin for StrictPlugin {
1546 fn name(&self) -> &str {
1547 "strict_plugin"
1548 }
1549 fn config_schema(&self) -> Option<JsonValue> {
1550 Some(json!({
1551 "type": "object",
1552 "properties": {
1553 "port": {"type": "integer"}
1554 },
1555 "required": ["port"]
1556 }))
1557 }
1558 }
1559
1560 let manager = PluginManager::new();
1561 manager.register(StrictPlugin).await.expect("注册应成功");
1562
1563 let invalid_config = json!({"host": "localhost"});
1565 let result = manager.load_config("strict_plugin", invalid_config).await;
1566 assert!(
1567 matches!(result, Err(BaseError::PluginConfigInvalid(_, _))),
1568 "配置不符合 Schema 应返回 PluginConfigInvalid 错误"
1569 );
1570 }
1571
1572 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
1586 async fn concurrent_same_name_register_keeps_map_consistent() {
1587 struct DupPlugin;
1588 #[async_trait]
1589 impl Plugin for DupPlugin {
1590 fn name(&self) -> &str {
1591 "dup_plugin"
1592 }
1593 }
1594
1595 let manager = Arc::new(PluginManager::new());
1596
1597 let mut handles = Vec::new();
1598 for _ in 0..16 {
1599 let m = Arc::clone(&manager);
1600 handles.push(tokio::spawn(async move { m.register(DupPlugin).await }));
1601 }
1602
1603 let mut ok_count = 0usize;
1604 for h in handles {
1605 let res = h.await.expect("注册任务不应 panic");
1607 if res.is_ok() {
1608 ok_count += 1;
1609 }
1610 }
1611
1612 assert!(ok_count >= 1, "并发同名注册应至少有一个成功");
1614
1615 let got = manager.get("dup_plugin").await;
1617 assert!(got.is_some(), "并发注册后应能查到 dup_plugin");
1618 assert_eq!(got.unwrap().name(), "dup_plugin");
1619 }
1620
1621 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
1623 async fn concurrent_distinct_register_no_loss() {
1624 macro_rules! make_plugin {
1626 ($ty:ident, $name:literal) => {
1627 struct $ty;
1628 #[async_trait]
1629 impl Plugin for $ty {
1630 fn name(&self) -> &str {
1631 $name
1632 }
1633 }
1634 };
1635 }
1636 make_plugin!(P0, "cn_p0");
1637 make_plugin!(P1, "cn_p1");
1638 make_plugin!(P2, "cn_p2");
1639 make_plugin!(P3, "cn_p3");
1640 make_plugin!(P4, "cn_p4");
1641 make_plugin!(P5, "cn_p5");
1642 make_plugin!(P6, "cn_p6");
1643 make_plugin!(P7, "cn_p7");
1644
1645 let manager = Arc::new(PluginManager::new());
1646 let m = Arc::clone(&manager);
1647
1648 let (r0, r1, r2, r3, r4, r5, r6, r7) = tokio::join!(
1650 {
1651 let m = Arc::clone(&m);
1652 async move { m.register(P0).await }
1653 },
1654 {
1655 let m = Arc::clone(&m);
1656 async move { m.register(P1).await }
1657 },
1658 {
1659 let m = Arc::clone(&m);
1660 async move { m.register(P2).await }
1661 },
1662 {
1663 let m = Arc::clone(&m);
1664 async move { m.register(P3).await }
1665 },
1666 {
1667 let m = Arc::clone(&m);
1668 async move { m.register(P4).await }
1669 },
1670 {
1671 let m = Arc::clone(&m);
1672 async move { m.register(P5).await }
1673 },
1674 {
1675 let m = Arc::clone(&m);
1676 async move { m.register(P6).await }
1677 },
1678 {
1679 let m = Arc::clone(&m);
1680 async move { m.register(P7).await }
1681 },
1682 );
1683 for r in [r0, r1, r2, r3, r4, r5, r6, r7] {
1684 r.expect("不同名插件注册应全部成功");
1685 }
1686
1687 for i in 0..8 {
1688 let name = format!("cn_p{}", i);
1689 assert!(
1690 manager.get(&name).await.is_some(),
1691 "{} 应已注册且可查到",
1692 name
1693 );
1694 }
1695 }
1696}