1use crate::error::Result;
2use async_trait::async_trait;
3
4#[async_trait]
32pub trait Plugin: Send + Sync {
33 fn name(&self) -> &str;
35
36 async fn start(&self) -> Result<()>;
41
42 async fn stop(&self) -> Result<()>;
47
48 fn depends_on(&self) -> &[&str] {
52 &[]
53 }
54
55 fn priority(&self) -> i32 {
65 100
66 }
67
68 async fn on_degrade(&self) -> Result<()> {
74 Ok(())
75 }
76
77 async fn on_resume(&self) -> Result<()> {
82 Ok(())
83 }
84
85 async fn on_fault(&self) -> Result<()> {
90 Ok(())
91 }
92}
93
94#[async_trait]
99impl<T: Plugin + ?Sized> Plugin for Arc<T> {
100 fn name(&self) -> &str {
101 (**self).name()
102 }
103
104 fn depends_on(&self) -> &[&str] {
105 (**self).depends_on()
106 }
107
108 fn priority(&self) -> i32 {
109 (**self).priority()
110 }
111
112 async fn start(&self) -> Result<()> {
113 (**self).start().await
114 }
115
116 async fn stop(&self) -> Result<()> {
117 (**self).stop().await
118 }
119
120 async fn on_degrade(&self) -> Result<()> {
121 (**self).on_degrade().await
122 }
123
124 async fn on_resume(&self) -> Result<()> {
125 (**self).on_resume().await
126 }
127
128 async fn on_fault(&self) -> Result<()> {
129 (**self).on_fault().await
130 }
131}
132
133use std::collections::{HashMap, HashSet};
134use std::sync::Arc;
135use tracing::{error, info, warn};
136
137use crate::state::{PluginState, PluginTrigger};
138
139enum StartedRecord {
141 NotStarted,
143 Running(Vec<Arc<dyn Plugin>>),
145 Stopped,
147}
148
149pub struct PluginManager {
166 plugins: Vec<Arc<dyn Plugin>>,
167 started: std::sync::Mutex<StartedRecord>,
169 states: std::sync::Mutex<HashMap<String, PluginState>>,
171}
172
173impl PluginManager {
174 pub fn new() -> Self {
176 Self {
177 plugins: Vec::new(),
178 started: std::sync::Mutex::new(StartedRecord::NotStarted),
179 states: std::sync::Mutex::new(HashMap::new()),
180 }
181 }
182
183 fn states_locked(&self) -> std::sync::MutexGuard<'_, HashMap<String, PluginState>> {
185 let mut map = self.states.lock().unwrap();
186 for p in &self.plugins {
187 map.entry(p.name().to_owned()).or_insert(PluginState::Stopped);
188 }
189 map
190 }
191
192 fn apply(
194 &self,
195 states: &mut HashMap<String, PluginState>,
196 name: &str,
197 trigger: PluginTrigger,
198 ) -> std::result::Result<(), String> {
199 let cur = states.get(name).copied().unwrap_or(PluginState::Stopped);
200 let next = cur.transition(trigger)?;
201 states.insert(name.to_owned(), next);
202 Ok(())
203 }
204
205 #[allow(clippy::should_implement_trait)]
217 pub fn add<P: Plugin + 'static>(mut self, plugin: P) -> Self {
218 self.plugins.push(Arc::new(plugin));
219 self
220 }
221
222 pub fn add_discovered(mut self, plugins: Vec<Arc<dyn Plugin>>) -> Self {
226 self.plugins.extend(plugins);
227 self
228 }
229
230 pub async fn start_all(&self) -> Result<()> {
237 let ordered = self.topological_sort()?;
238 let previous: Vec<Arc<dyn Plugin>> = match &*self.started.lock().unwrap() {
241 StartedRecord::Running(list) => list.clone(),
242 _ => Vec::new(),
243 };
244 let mut started: Vec<Arc<dyn Plugin>> = Vec::new();
245
246 for plugin in ordered {
247 {
249 let mut states = self.states_locked();
250 if let Err(reason) = self.apply(&mut states, plugin.name(), PluginTrigger::Start) {
251 warn!("插件 {} 跳过启动: {}", plugin.name(), reason);
252 continue;
253 }
254 }
255 info!("启动插件: {}", plugin.name());
256 if let Err(e) = plugin.start().await {
257 error!("插件 {} 启动失败: {}", plugin.name(), e);
258 {
259 let mut states = self.states_locked();
260 let _ = self.apply(&mut states, plugin.name(), PluginTrigger::StartFailed);
261 }
262 for p in started.iter().rev() {
264 info!("回滚已启动插件: {}", p.name());
265 {
266 let mut states = self.states_locked();
267 let _ = self.apply(&mut states, p.name(), PluginTrigger::Stop);
268 }
269 if let Err(e2) = p.stop().await {
270 error!("插件 {} 回滚停止异常: {}", p.name(), e2);
271 }
272 }
273 *self.started.lock().unwrap() = if previous.is_empty() {
274 StartedRecord::Stopped
275 } else {
276 StartedRecord::Running(previous)
277 };
278 return Err(e);
279 }
280 {
281 let mut states = self.states_locked();
282 let _ = self.apply(&mut states, plugin.name(), PluginTrigger::StartOk);
283 }
284 started.push(Arc::clone(&plugin));
285 }
286
287 let mut merged = previous;
289 merged.retain(|p| !started.iter().any(|s| s.name() == p.name()));
290 merged.extend(started);
291 *self.started.lock().unwrap() = StartedRecord::Running(merged);
292 Ok(())
293 }
294
295 pub async fn stop_all(&self) {
301 let list = {
302 let mut record = self.started.lock().unwrap();
303 match std::mem::replace(&mut *record, StartedRecord::Stopped) {
304 StartedRecord::Running(list) => list,
305 StartedRecord::Stopped => return,
306 StartedRecord::NotStarted => self.plugins.clone(),
307 }
308 };
309 for plugin in list.iter().rev() {
310 info!("停止插件: {}", plugin.name());
311 {
314 let mut states = self.states_locked();
315 if let Err(reason) = self.apply(&mut states, plugin.name(), PluginTrigger::Stop) {
316 warn!("插件 {} 状态转移告警: {}", plugin.name(), reason);
317 }
318 }
319 if let Err(e) = plugin.stop().await {
320 error!("插件 {} 停止异常: {}", plugin.name(), e);
321 }
322 }
323 }
324
325 pub fn state(&self, name: &str) -> Option<PluginState> {
327 self.states_locked().get(name).copied()
328 }
329
330 pub async fn degrade_all(&self) {
334 let list = match &*self.started.lock().unwrap() {
335 StartedRecord::Running(list) => list.clone(),
336 _ => return, };
338 for plugin in list.iter().rev() {
339 let name = plugin.name();
340 {
341 let mut states = self.states_locked();
342 if let Err(reason) = self.apply(&mut states, name, PluginTrigger::Degrade) {
343 warn!("插件 {} 跳过降级: {}", name, reason);
344 continue;
345 }
346 }
347 info!("降级插件: {}", name);
348 if let Err(e) = plugin.on_degrade().await {
349 error!("插件 {} 降级异常: {}", name, e);
350 self.fault_plugin(plugin, &format!("降级失败: {e}")).await;
351 continue;
352 }
353 let mut states = self.states_locked();
354 let _ = self.apply(&mut states, name, PluginTrigger::DegradeOk);
355 }
356 }
357
358 pub async fn resume_all(&self) {
362 let list = match &*self.started.lock().unwrap() {
363 StartedRecord::Running(list) => list.clone(),
364 _ => return,
365 };
366 for plugin in list.iter() {
367 let name = plugin.name();
368 {
369 let mut states = self.states_locked();
370 if let Err(reason) = self.apply(&mut states, name, PluginTrigger::Resume) {
371 warn!("插件 {} 跳过恢复: {}", name, reason);
372 continue;
373 }
374 }
375 info!("恢复插件: {}", name);
376 if let Err(e) = plugin.on_resume().await {
377 error!("插件 {} 恢复异常: {}", name, e);
378 self.fault_plugin(plugin, &format!("恢复失败: {e}")).await;
379 continue;
380 }
381 let mut states = self.states_locked();
382 let _ = self.apply(&mut states, name, PluginTrigger::ResumeOk);
383 }
384 }
385
386 pub async fn fault(&self, name: &str) -> bool {
391 let Some(plugin) = self.plugins.iter().find(|p| p.name() == name) else {
392 warn!("fault: 未知插件 {}", name);
393 return false;
394 };
395 match self.state(name) {
396 Some(PluginState::Faulted) => true, Some(PluginState::Stopped) => {
398 warn!("插件 {} 未启动,无可故障转移", name);
399 false
400 }
401 Some(_) => {
402 self.fault_plugin(plugin, "手动触发").await;
403 true
404 }
405 None => false,
406 }
407 }
408
409 pub fn reset(&self, name: &str) -> bool {
413 if !self.plugins.iter().any(|p| p.name() == name) {
414 return false;
415 }
416 let mut states = self.states_locked();
417 self.apply(&mut states, name, PluginTrigger::Reset).is_ok()
418 }
419
420 async fn fault_plugin(&self, plugin: &Arc<dyn Plugin>, reason: &str) {
422 {
423 let mut states = self.states_locked();
424 if let Err(r) = self.apply(&mut states, plugin.name(), PluginTrigger::Fault) {
425 warn!("插件 {} 故障转移被拒绝: {}", plugin.name(), r);
426 return;
427 }
428 }
429 error!("插件 {} 进入故障状态: {}", plugin.name(), reason);
430 if let Err(e) = plugin.on_fault().await {
431 error!("插件 {} 故障清理钩子异常: {}", plugin.name(), e);
432 }
433 }
434
435 fn topological_sort(&self) -> Result<Vec<Arc<dyn Plugin>>> {
440 self.check_duplicate_names()
442 .map_err(crate::error::Error::Config)?;
443
444 let name_to_idx: HashMap<&str, usize> = self
445 .plugins
446 .iter()
447 .enumerate()
448 .map(|(i, p)| (p.name(), i))
449 .collect();
450
451 let count = self.plugins.len();
452 let mut in_degree = vec![0usize; count];
453 let mut adj = vec![Vec::new(); count];
454
455 for (i, plugin) in self.plugins.iter().enumerate() {
456 for dep in plugin.depends_on() {
457 match name_to_idx.get(dep) {
458 Some(&j) => {
459 adj[j].push(i);
460 in_degree[i] += 1;
461 }
462 None => {
464 return Err(crate::error::Error::Config(format!(
465 "插件 {} 依赖的插件 {} 未注册",
466 plugin.name(),
467 dep
468 )));
469 }
470 }
471 }
472 }
473
474 let mut ready: Vec<usize> = (0..count).filter(|&i| in_degree[i] == 0).collect();
476 ready.sort_by_key(|&idx| self.plugins[idx].priority());
478
479 let mut sorted = Vec::with_capacity(count);
480 while !ready.is_empty() {
481 let u = ready.remove(0);
483 sorted.push(Arc::clone(&self.plugins[u]));
484 let mut newly_ready = Vec::new();
485 for &v in &adj[u] {
486 in_degree[v] -= 1;
487 if in_degree[v] == 0 {
488 newly_ready.push(v);
489 }
490 }
491 if !newly_ready.is_empty() {
492 ready.extend(newly_ready);
493 ready.sort_by_key(|&idx| self.plugins[idx].priority());
494 }
495 }
496
497 if sorted.len() != count {
498 let cycle: Vec<&str> = self
500 .plugins
501 .iter()
502 .enumerate()
503 .filter(|(i, _)| in_degree[*i] > 0)
504 .map(|(_, p)| p.name())
505 .collect();
506 return Err(crate::error::Error::Config(format!(
507 "插件循环依赖: {:?}",
508 cycle
509 )));
510 }
511
512 Ok(sorted)
513 }
514
515 pub fn check_duplicate_names(&self) -> std::result::Result<(), String> {
517 let mut seen = HashSet::new();
518 for p in &self.plugins {
519 if !seen.insert(p.name()) {
520 return Err(format!("插件名重复: {}", p.name()));
521 }
522 }
523 Ok(())
524 }
525}
526
527impl Default for PluginManager {
528 fn default() -> Self {
529 Self::new()
530 }
531}
532
533#[cfg(test)]
534mod tests {
535 use super::*;
536 use async_trait::async_trait;
537 use parking_lot::Mutex;
538 use std::sync::Arc;
539
540 struct TestPlugin {
541 name: &'static str,
542 deps: &'static [&'static str],
543 prio: i32,
544 order: Arc<Mutex<Vec<String>>>,
545 }
546
547 #[async_trait]
548 impl Plugin for TestPlugin {
549 fn name(&self) -> &str {
550 self.name
551 }
552 async fn start(&self) -> Result<()> {
553 self.order.lock().push(format!("start:{}", self.name));
554 Ok(())
555 }
556 async fn stop(&self) -> Result<()> {
557 self.order.lock().push(format!("stop:{}", self.name));
558 Ok(())
559 }
560 fn depends_on(&self) -> &[&str] {
561 self.deps
562 }
563 fn priority(&self) -> i32 {
564 self.prio
565 }
566 }
567
568 #[tokio::test]
569 async fn test_topological_start() {
570 let order = Arc::new(Mutex::new(Vec::new()));
571
572 let mgr = PluginManager::new()
573 .add(TestPlugin {
574 name: "c",
575 deps: &["a", "b"],
576 prio: 100,
577 order: order.clone(),
578 })
579 .add(TestPlugin {
580 name: "b",
581 deps: &["a"],
582 prio: 100,
583 order: order.clone(),
584 })
585 .add(TestPlugin {
586 name: "a",
587 deps: &[],
588 prio: 100,
589 order: order.clone(),
590 });
591
592 mgr.start_all().await.unwrap();
593
594 let log = order.lock();
595 assert_eq!(log[0], "start:a");
596 assert_eq!(log[1], "start:b");
597 assert_eq!(log[2], "start:c");
598 }
599
600 #[tokio::test]
601 async fn test_cycle_detection() {
602 let order = Arc::new(Mutex::new(Vec::new()));
603
604 let mgr = PluginManager::new()
605 .add(TestPlugin {
606 name: "x",
607 deps: &["y"],
608 prio: 100,
609 order: order.clone(),
610 })
611 .add(TestPlugin {
612 name: "y",
613 deps: &["x"],
614 prio: 100,
615 order: order.clone(),
616 });
617
618 let result = mgr.start_all().await;
619 assert!(result.is_err());
620 }
621
622 #[tokio::test]
623 async fn test_stop_reverses_topological_order() {
624 let order = Arc::new(Mutex::new(Vec::new()));
625
626 let mgr = PluginManager::new()
628 .add(TestPlugin {
629 name: "c",
630 deps: &["a", "b"],
631 prio: 100,
632 order: order.clone(),
633 })
634 .add(TestPlugin {
635 name: "b",
636 deps: &["a"],
637 prio: 100,
638 order: order.clone(),
639 })
640 .add(TestPlugin {
641 name: "a",
642 deps: &[],
643 prio: 100,
644 order: order.clone(),
645 });
646
647 mgr.start_all().await.unwrap();
648 mgr.stop_all().await;
649
650 let log = order.lock();
651 assert_eq!(log[0], "start:a");
652 assert_eq!(log[1], "start:b");
653 assert_eq!(log[2], "start:c");
654 assert_eq!(log[3], "stop:c");
656 assert_eq!(log[4], "stop:b");
657 assert_eq!(log[5], "stop:a");
658 }
659
660 struct FailOnStartPlugin {
661 name: &'static str,
662 fail: bool,
663 order: Arc<Mutex<Vec<String>>>,
664 }
665
666 #[async_trait]
667 impl Plugin for FailOnStartPlugin {
668 fn name(&self) -> &str {
669 self.name
670 }
671 async fn start(&self) -> Result<()> {
672 self.order.lock().push(format!("start:{}", self.name));
673 if self.fail {
674 Err(crate::error::Error::Config(format!(
675 "{} 启动失败(测试)",
676 self.name
677 )))
678 } else {
679 Ok(())
680 }
681 }
682 async fn stop(&self) -> Result<()> {
683 self.order.lock().push(format!("stop:{}", self.name));
684 Ok(())
685 }
686 }
687
688 #[tokio::test]
689 async fn test_partial_start_rolls_back() {
690 let order = Arc::new(Mutex::new(Vec::new()));
691
692 let mgr = PluginManager::new()
693 .add(FailOnStartPlugin {
694 name: "a",
695 fail: false,
696 order: order.clone(),
697 })
698 .add(FailOnStartPlugin {
699 name: "b",
700 fail: true,
701 order: order.clone(),
702 });
703
704 let result = mgr.start_all().await;
705 assert!(result.is_err());
706
707 {
709 let log = order.lock();
710 assert_eq!(log[0], "start:a");
711 assert_eq!(log[1], "start:b");
712 assert_eq!(log[2], "stop:a");
713 assert_eq!(log.len(), 3);
714 }
715
716 mgr.stop_all().await;
718 assert_eq!(order.lock().len(), 3);
719 }
720
721 #[tokio::test]
722 async fn test_repeated_start_stop() {
723 let order = Arc::new(Mutex::new(Vec::new()));
724
725 let mgr = PluginManager::new().add(TestPlugin {
726 name: "a",
727 deps: &[],
728 prio: 100,
729 order: order.clone(),
730 });
731
732 mgr.start_all().await.unwrap();
733 mgr.stop_all().await;
734 mgr.start_all().await.unwrap();
736 mgr.stop_all().await;
737
738 let log = order.lock();
739 assert_eq!(&*log, &["start:a", "stop:a", "start:a", "stop:a"]);
740 }
741
742 #[tokio::test]
743 async fn test_priority_ordering() {
744 let order = Arc::new(Mutex::new(Vec::new()));
745
746 let mgr = PluginManager::new()
749 .add(TestPlugin {
750 name: "late",
751 deps: &[],
752 prio: 200,
753 order: order.clone(),
754 })
755 .add(TestPlugin {
756 name: "early",
757 deps: &[],
758 prio: 10,
759 order: order.clone(),
760 })
761 .add(TestPlugin {
762 name: "mid",
763 deps: &[],
764 prio: 50,
765 order: order.clone(),
766 });
767
768 mgr.start_all().await.unwrap();
769
770 let log = order.lock();
771 assert_eq!(log[0], "start:early"); assert_eq!(log[1], "start:mid"); assert_eq!(log[2], "start:late"); }
775
776 #[test]
777 fn duplicate_names_rejected() {
778 let order = Arc::new(Mutex::new(Vec::new()));
779 let mgr = PluginManager::new()
780 .add(TestPlugin { name: "dup", deps: &[], prio: 0, order: order.clone() })
781 .add(TestPlugin { name: "dup", deps: &[], prio: 0, order: order.clone() });
782 assert!(mgr.check_duplicate_names().is_err());
783 assert!(futures_block(mgr.start_all()).is_err());
785 }
786
787 #[test]
788 fn missing_dependency_rejected() {
789 let order = Arc::new(Mutex::new(Vec::new()));
790 let mgr = PluginManager::new()
791 .add(TestPlugin { name: "a", deps: &["ghost"], prio: 0, order: order.clone() });
792 let err = futures_block(mgr.start_all()).unwrap_err();
793 assert!(err.to_string().contains("ghost"));
794 }
795
796 #[test]
797 fn stop_all_without_start_falls_back_to_registry_reverse() {
798 let order = Arc::new(Mutex::new(Vec::new()));
799 let mgr = PluginManager::new()
800 .add(TestPlugin { name: "a", deps: &[], prio: 0, order: order.clone() })
801 .add(TestPlugin { name: "b", deps: &[], prio: 0, order: order.clone() });
802 futures_block(mgr.stop_all());
804 assert_eq!(&*order.lock(), &["stop:b", "stop:a"]);
805 }
806
807 #[test]
808 fn add_discovered_collects_arc_plugins() {
809 let order = Arc::new(Mutex::new(Vec::new()));
810 let p: Arc<dyn Plugin> = Arc::new(TestPlugin {
811 name: "discovered",
812 deps: &[],
813 prio: 0,
814 order: order.clone(),
815 });
816 let mgr = PluginManager::new().add_discovered(vec![p]);
817 assert_eq!(mgr.check_duplicate_names(), Ok(()));
818 futures_block(mgr.start_all()).unwrap();
819 assert_eq!(&*order.lock(), &["start:discovered"]);
820 }
821
822 #[tokio::test]
823 async fn arc_plugin_forwards_methods() {
824 let order = Arc::new(Mutex::new(Vec::new()));
825 let inner = Arc::new(TestPlugin { name: "wrapped", deps: &[], prio: 7, order: order.clone() });
826 let arc: Arc<dyn Plugin> = inner.clone();
827 assert_eq!(arc.name(), "wrapped");
828 assert_eq!(arc.priority(), 7);
829 assert!(arc.depends_on().is_empty());
830 arc.start().await.unwrap();
831 arc.stop().await.unwrap();
832 assert_eq!(&*order.lock(), &["start:wrapped", "stop:wrapped"]);
833 }
834
835 #[test]
836 fn default_manager() {
837 let mgr = PluginManager::default();
838 assert!(mgr.check_duplicate_names().is_ok());
839 }
840
841 struct LifecyclePlugin {
845 name: &'static str,
846 fail_degrade: bool,
847 fail_resume: bool,
848 order: Arc<Mutex<Vec<String>>>,
849 }
850
851 #[async_trait]
852 impl Plugin for LifecyclePlugin {
853 fn name(&self) -> &str {
854 self.name
855 }
856 async fn start(&self) -> Result<()> {
857 self.order.lock().push(format!("start:{}", self.name));
858 Ok(())
859 }
860 async fn stop(&self) -> Result<()> {
861 self.order.lock().push(format!("stop:{}", self.name));
862 Ok(())
863 }
864 async fn on_degrade(&self) -> Result<()> {
865 self.order.lock().push(format!("degrade:{}", self.name));
866 if self.fail_degrade {
867 Err(crate::error::Error::Config("降级失败(测试)".into()))
868 } else {
869 Ok(())
870 }
871 }
872 async fn on_resume(&self) -> Result<()> {
873 self.order.lock().push(format!("resume:{}", self.name));
874 if self.fail_resume {
875 Err(crate::error::Error::Config("恢复失败(测试)".into()))
876 } else {
877 Ok(())
878 }
879 }
880 async fn on_fault(&self) -> Result<()> {
881 self.order.lock().push(format!("fault:{}", self.name));
882 Ok(())
883 }
884 }
885
886 #[tokio::test]
887 async fn degrade_resume_lifecycle_transitions() {
888 let order = Arc::new(Mutex::new(Vec::new()));
889 let mgr = PluginManager::new()
890 .add(LifecyclePlugin {
891 name: "a",
892 fail_degrade: false,
893 fail_resume: false,
894 order: order.clone(),
895 })
896 .add(LifecyclePlugin {
897 name: "b",
898 fail_degrade: false,
899 fail_resume: false,
900 order: order.clone(),
901 });
902
903 mgr.start_all().await.unwrap();
904 assert_eq!(mgr.state("a"), Some(PluginState::Running));
905 assert_eq!(mgr.state("unknown"), None, "未知插件返回 None");
906
907 mgr.degrade_all().await;
908 assert_eq!(mgr.state("a"), Some(PluginState::Degraded));
909 assert!(mgr.state("a").unwrap().is_available(), "降级仍可用");
910 assert!(!mgr.state("a").unwrap().is_running());
911
912 mgr.resume_all().await;
913 assert_eq!(mgr.state("a"), Some(PluginState::Running));
914
915 mgr.degrade_all().await;
917 mgr.stop_all().await;
918 assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
919
920 assert_eq!(
921 &*order.lock(),
922 &[
923 "start:a", "start:b",
924 "degrade:b", "degrade:a", "resume:a", "resume:b",
926 "degrade:b", "degrade:a",
927 "stop:b", "stop:a"
929 ]
930 );
931 }
932
933 #[tokio::test]
934 async fn degrade_order_is_reverse_of_start_order() {
935 struct DepPlugin {
936 name: &'static str,
937 deps: &'static [&'static str],
938 order: Arc<Mutex<Vec<String>>>,
939 }
940 #[async_trait]
941 impl Plugin for DepPlugin {
942 fn name(&self) -> &str {
943 self.name
944 }
945 fn depends_on(&self) -> &[&str] {
946 self.deps
947 }
948 async fn start(&self) -> Result<()> {
949 Ok(())
950 }
951 async fn stop(&self) -> Result<()> {
952 Ok(())
953 }
954 async fn on_degrade(&self) -> Result<()> {
955 self.order.lock().push(format!("degrade:{}", self.name));
956 Ok(())
957 }
958 }
959
960 let order = Arc::new(Mutex::new(Vec::new()));
961 let mgr = PluginManager::new()
962 .add(DepPlugin { name: "a", deps: &[], order: order.clone() })
963 .add(DepPlugin { name: "b", deps: &["a"], order: order.clone() });
964 mgr.start_all().await.unwrap();
965 mgr.degrade_all().await;
966 assert_eq!(&*order.lock(), &["degrade:b", "degrade:a"]);
968 }
969
970 #[tokio::test]
971 async fn degrade_failure_triggers_fault_transfer() {
972 let order = Arc::new(Mutex::new(Vec::new()));
973 let mgr = PluginManager::new().add(LifecyclePlugin {
974 name: "a",
975 fail_degrade: true,
976 fail_resume: false,
977 order: order.clone(),
978 });
979
980 mgr.start_all().await.unwrap();
981 mgr.degrade_all().await;
982
983 assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
985 assert!(order.lock().contains(&"fault:a".to_string()));
986
987 mgr.resume_all().await;
989 assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
990 mgr.stop_all().await;
991 assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
992 }
993
994 #[tokio::test]
995 async fn resume_failure_triggers_fault_transfer() {
996 let order = Arc::new(Mutex::new(Vec::new()));
997 let mgr = PluginManager::new().add(LifecyclePlugin {
998 name: "a",
999 fail_degrade: false,
1000 fail_resume: true,
1001 order: order.clone(),
1002 });
1003
1004 mgr.start_all().await.unwrap();
1005 mgr.degrade_all().await;
1006 mgr.resume_all().await;
1007
1008 assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
1009 assert!(order.lock().contains(&"fault:a".to_string()));
1010 }
1011
1012 #[tokio::test]
1013 async fn manual_fault_and_reset_allow_restart() {
1014 let order = Arc::new(Mutex::new(Vec::new()));
1015 let mgr = PluginManager::new().add(LifecyclePlugin {
1016 name: "a",
1017 fail_degrade: false,
1018 fail_resume: false,
1019 order: order.clone(),
1020 });
1021
1022 mgr.start_all().await.unwrap();
1023
1024 assert!(!mgr.fault("ghost").await);
1026
1027 assert!(mgr.fault("a").await);
1028 assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
1029 assert!(order.lock().contains(&"fault:a".to_string()));
1030 assert!(mgr.fault("a").await);
1032
1033 mgr.start_all().await.unwrap();
1035 assert_eq!(mgr.state("a"), Some(PluginState::Faulted), "Faulted 跳过启动");
1036 assert!(mgr.reset("a"));
1037 assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
1038 assert!(!mgr.reset("a"), "非 Faulted 不可重置");
1039
1040 mgr.start_all().await.unwrap();
1041 assert_eq!(mgr.state("a"), Some(PluginState::Running));
1042 let starts = order.lock().iter().filter(|e| e.as_str() == "start:a").count();
1043 assert_eq!(starts, 2, "reset 后重新执行了 start 钩子");
1044 }
1045
1046 #[tokio::test]
1047 async fn start_failure_marks_plugin_faulted() {
1048 let order = Arc::new(Mutex::new(Vec::new()));
1049 let mgr = PluginManager::new()
1050 .add(FailOnStartPlugin { name: "ok", fail: true, order: order.clone() });
1051 assert!(mgr.start_all().await.is_err());
1053 assert_eq!(mgr.state("ok"), Some(PluginState::Faulted));
1054 assert!(!mgr.state("ok").unwrap().is_available());
1055 }
1056
1057 #[tokio::test]
1058 async fn double_start_is_rejected_by_state_gate() {
1059 let order = Arc::new(Mutex::new(Vec::new()));
1060 let mgr = PluginManager::new().add(LifecyclePlugin {
1061 name: "a",
1062 fail_degrade: false,
1063 fail_resume: false,
1064 order: order.clone(),
1065 });
1066
1067 mgr.start_all().await.unwrap();
1068 mgr.start_all().await.unwrap();
1070 assert_eq!(mgr.state("a"), Some(PluginState::Running));
1071 assert_eq!(order.lock().iter().filter(|e| e.as_str() == "start:a").count(), 1);
1072
1073 mgr.stop_all().await;
1075 assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
1076 assert_eq!(order.lock().iter().filter(|e| e.as_str() == "stop:a").count(), 1);
1077 }
1078
1079 #[tokio::test]
1080 async fn double_stop_does_not_rerun_hooks() {
1081 let order = Arc::new(Mutex::new(Vec::new()));
1082 let mgr = PluginManager::new().add(TestPlugin {
1083 name: "a",
1084 deps: &[],
1085 prio: 100,
1086 order: order.clone(),
1087 });
1088 mgr.start_all().await.unwrap();
1089 mgr.stop_all().await;
1090 mgr.stop_all().await;
1092 assert_eq!(&*order.lock(), &["start:a", "stop:a"]);
1093 }
1094
1095 #[tokio::test]
1096 async fn restart_after_fault_keeps_stop_record_consistent() {
1097 let order = Arc::new(Mutex::new(Vec::new()));
1098 let mgr = PluginManager::new()
1099 .add(LifecyclePlugin { name: "a", fail_degrade: false, fail_resume: false, order: order.clone() })
1100 .add(LifecyclePlugin { name: "b", fail_degrade: false, fail_resume: false, order: order.clone() });
1101 mgr.start_all().await.unwrap();
1102 assert!(mgr.fault("a").await);
1103 assert!(mgr.reset("a"));
1104 mgr.start_all().await.unwrap();
1106 mgr.stop_all().await;
1107 let stops: Vec<String> = order.lock().iter().filter(|e| e.starts_with("stop:")).cloned().collect();
1108 assert_eq!(stops, vec!["stop:a".to_string(), "stop:b".to_string()]);
1110 }
1111
1112 fn futures_block<F: std::future::Future>(fut: F) -> F::Output {
1114 tokio::runtime::Builder::new_current_thread()
1115 .enable_all()
1116 .build()
1117 .unwrap()
1118 .block_on(fut)
1119 }
1120}