use crate::error::Result;
use async_trait::async_trait;
#[async_trait]
pub trait Plugin: Send + Sync {
fn name(&self) -> &str;
async fn start(&self) -> Result<()>;
async fn stop(&self) -> Result<()>;
fn depends_on(&self) -> &[&str] {
&[]
}
fn priority(&self) -> i32 {
100
}
async fn on_degrade(&self) -> Result<()> {
Ok(())
}
async fn on_resume(&self) -> Result<()> {
Ok(())
}
async fn on_fault(&self) -> Result<()> {
Ok(())
}
}
#[async_trait]
impl<T: Plugin + ?Sized> Plugin for Arc<T> {
fn name(&self) -> &str {
(**self).name()
}
fn depends_on(&self) -> &[&str] {
(**self).depends_on()
}
fn priority(&self) -> i32 {
(**self).priority()
}
async fn start(&self) -> Result<()> {
(**self).start().await
}
async fn stop(&self) -> Result<()> {
(**self).stop().await
}
async fn on_degrade(&self) -> Result<()> {
(**self).on_degrade().await
}
async fn on_resume(&self) -> Result<()> {
(**self).on_resume().await
}
async fn on_fault(&self) -> Result<()> {
(**self).on_fault().await
}
}
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use tracing::{error, info, warn};
use crate::state::{PluginState, PluginTrigger};
enum StartedRecord {
NotStarted,
Running(Vec<Arc<dyn Plugin>>),
Stopped,
}
pub struct PluginManager {
plugins: Vec<Arc<dyn Plugin>>,
started: std::sync::Mutex<StartedRecord>,
states: std::sync::Mutex<HashMap<String, PluginState>>,
}
impl PluginManager {
pub fn new() -> Self {
Self {
plugins: Vec::new(),
started: std::sync::Mutex::new(StartedRecord::NotStarted),
states: std::sync::Mutex::new(HashMap::new()),
}
}
fn states_locked(&self) -> std::sync::MutexGuard<'_, HashMap<String, PluginState>> {
let mut map = self.states.lock().unwrap();
for p in &self.plugins {
map.entry(p.name().to_owned()).or_insert(PluginState::Stopped);
}
map
}
fn apply(
&self,
states: &mut HashMap<String, PluginState>,
name: &str,
trigger: PluginTrigger,
) -> std::result::Result<(), String> {
let cur = states.get(name).copied().unwrap_or(PluginState::Stopped);
let next = cur.transition(trigger)?;
states.insert(name.to_owned(), next);
Ok(())
}
#[allow(clippy::should_implement_trait)]
pub fn add<P: Plugin + 'static>(mut self, plugin: P) -> Self {
self.plugins.push(Arc::new(plugin));
self
}
pub fn add_discovered(mut self, plugins: Vec<Arc<dyn Plugin>>) -> Self {
self.plugins.extend(plugins);
self
}
pub async fn start_all(&self) -> Result<()> {
let ordered = self.topological_sort()?;
let previous: Vec<Arc<dyn Plugin>> = match &*self.started.lock().unwrap() {
StartedRecord::Running(list) => list.clone(),
_ => Vec::new(),
};
let mut started: Vec<Arc<dyn Plugin>> = Vec::new();
for plugin in ordered {
{
let mut states = self.states_locked();
if let Err(reason) = self.apply(&mut states, plugin.name(), PluginTrigger::Start) {
warn!("插件 {} 跳过启动: {}", plugin.name(), reason);
continue;
}
}
info!("启动插件: {}", plugin.name());
if let Err(e) = plugin.start().await {
error!("插件 {} 启动失败: {}", plugin.name(), e);
{
let mut states = self.states_locked();
let _ = self.apply(&mut states, plugin.name(), PluginTrigger::StartFailed);
}
for p in started.iter().rev() {
info!("回滚已启动插件: {}", p.name());
{
let mut states = self.states_locked();
let _ = self.apply(&mut states, p.name(), PluginTrigger::Stop);
}
if let Err(e2) = p.stop().await {
error!("插件 {} 回滚停止异常: {}", p.name(), e2);
}
}
*self.started.lock().unwrap() = if previous.is_empty() {
StartedRecord::Stopped
} else {
StartedRecord::Running(previous)
};
return Err(e);
}
{
let mut states = self.states_locked();
let _ = self.apply(&mut states, plugin.name(), PluginTrigger::StartOk);
}
started.push(Arc::clone(&plugin));
}
let mut merged = previous;
merged.retain(|p| !started.iter().any(|s| s.name() == p.name()));
merged.extend(started);
*self.started.lock().unwrap() = StartedRecord::Running(merged);
Ok(())
}
pub async fn stop_all(&self) {
let list = {
let mut record = self.started.lock().unwrap();
match std::mem::replace(&mut *record, StartedRecord::Stopped) {
StartedRecord::Running(list) => list,
StartedRecord::Stopped => return,
StartedRecord::NotStarted => self.plugins.clone(),
}
};
for plugin in list.iter().rev() {
info!("停止插件: {}", plugin.name());
{
let mut states = self.states_locked();
if let Err(reason) = self.apply(&mut states, plugin.name(), PluginTrigger::Stop) {
warn!("插件 {} 状态转移告警: {}", plugin.name(), reason);
}
}
if let Err(e) = plugin.stop().await {
error!("插件 {} 停止异常: {}", plugin.name(), e);
}
}
}
pub fn state(&self, name: &str) -> Option<PluginState> {
self.states_locked().get(name).copied()
}
pub async fn degrade_all(&self) {
let list = match &*self.started.lock().unwrap() {
StartedRecord::Running(list) => list.clone(),
_ => return, };
for plugin in list.iter().rev() {
let name = plugin.name();
{
let mut states = self.states_locked();
if let Err(reason) = self.apply(&mut states, name, PluginTrigger::Degrade) {
warn!("插件 {} 跳过降级: {}", name, reason);
continue;
}
}
info!("降级插件: {}", name);
if let Err(e) = plugin.on_degrade().await {
error!("插件 {} 降级异常: {}", name, e);
self.fault_plugin(plugin, &format!("降级失败: {e}")).await;
continue;
}
let mut states = self.states_locked();
let _ = self.apply(&mut states, name, PluginTrigger::DegradeOk);
}
}
pub async fn resume_all(&self) {
let list = match &*self.started.lock().unwrap() {
StartedRecord::Running(list) => list.clone(),
_ => return,
};
for plugin in list.iter() {
let name = plugin.name();
{
let mut states = self.states_locked();
if let Err(reason) = self.apply(&mut states, name, PluginTrigger::Resume) {
warn!("插件 {} 跳过恢复: {}", name, reason);
continue;
}
}
info!("恢复插件: {}", name);
if let Err(e) = plugin.on_resume().await {
error!("插件 {} 恢复异常: {}", name, e);
self.fault_plugin(plugin, &format!("恢复失败: {e}")).await;
continue;
}
let mut states = self.states_locked();
let _ = self.apply(&mut states, name, PluginTrigger::ResumeOk);
}
}
pub async fn fault(&self, name: &str) -> bool {
let Some(plugin) = self.plugins.iter().find(|p| p.name() == name) else {
warn!("fault: 未知插件 {}", name);
return false;
};
match self.state(name) {
Some(PluginState::Faulted) => true, Some(PluginState::Stopped) => {
warn!("插件 {} 未启动,无可故障转移", name);
false
}
Some(_) => {
self.fault_plugin(plugin, "手动触发").await;
true
}
None => false,
}
}
pub fn reset(&self, name: &str) -> bool {
if !self.plugins.iter().any(|p| p.name() == name) {
return false;
}
let mut states = self.states_locked();
self.apply(&mut states, name, PluginTrigger::Reset).is_ok()
}
async fn fault_plugin(&self, plugin: &Arc<dyn Plugin>, reason: &str) {
{
let mut states = self.states_locked();
if let Err(r) = self.apply(&mut states, plugin.name(), PluginTrigger::Fault) {
warn!("插件 {} 故障转移被拒绝: {}", plugin.name(), r);
return;
}
}
error!("插件 {} 进入故障状态: {}", plugin.name(), reason);
if let Err(e) = plugin.on_fault().await {
error!("插件 {} 故障清理钩子异常: {}", plugin.name(), e);
}
}
fn topological_sort(&self) -> Result<Vec<Arc<dyn Plugin>>> {
self.check_duplicate_names()
.map_err(crate::error::Error::Config)?;
let name_to_idx: HashMap<&str, usize> = self
.plugins
.iter()
.enumerate()
.map(|(i, p)| (p.name(), i))
.collect();
let count = self.plugins.len();
let mut in_degree = vec![0usize; count];
let mut adj = vec![Vec::new(); count];
for (i, plugin) in self.plugins.iter().enumerate() {
for dep in plugin.depends_on() {
match name_to_idx.get(dep) {
Some(&j) => {
adj[j].push(i);
in_degree[i] += 1;
}
None => {
return Err(crate::error::Error::Config(format!(
"插件 {} 依赖的插件 {} 未注册",
plugin.name(),
dep
)));
}
}
}
}
let mut ready: Vec<usize> = (0..count).filter(|&i| in_degree[i] == 0).collect();
ready.sort_by_key(|&idx| self.plugins[idx].priority());
let mut sorted = Vec::with_capacity(count);
while !ready.is_empty() {
let u = ready.remove(0);
sorted.push(Arc::clone(&self.plugins[u]));
let mut newly_ready = Vec::new();
for &v in &adj[u] {
in_degree[v] -= 1;
if in_degree[v] == 0 {
newly_ready.push(v);
}
}
if !newly_ready.is_empty() {
ready.extend(newly_ready);
ready.sort_by_key(|&idx| self.plugins[idx].priority());
}
}
if sorted.len() != count {
let cycle: Vec<&str> = self
.plugins
.iter()
.enumerate()
.filter(|(i, _)| in_degree[*i] > 0)
.map(|(_, p)| p.name())
.collect();
return Err(crate::error::Error::Config(format!(
"插件循环依赖: {:?}",
cycle
)));
}
Ok(sorted)
}
pub fn check_duplicate_names(&self) -> std::result::Result<(), String> {
let mut seen = HashSet::new();
for p in &self.plugins {
if !seen.insert(p.name()) {
return Err(format!("插件名重复: {}", p.name()));
}
}
Ok(())
}
}
impl Default for PluginManager {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use async_trait::async_trait;
use parking_lot::Mutex;
use std::sync::Arc;
struct TestPlugin {
name: &'static str,
deps: &'static [&'static str],
prio: i32,
order: Arc<Mutex<Vec<String>>>,
}
#[async_trait]
impl Plugin for TestPlugin {
fn name(&self) -> &str {
self.name
}
async fn start(&self) -> Result<()> {
self.order.lock().push(format!("start:{}", self.name));
Ok(())
}
async fn stop(&self) -> Result<()> {
self.order.lock().push(format!("stop:{}", self.name));
Ok(())
}
fn depends_on(&self) -> &[&str] {
self.deps
}
fn priority(&self) -> i32 {
self.prio
}
}
#[tokio::test]
async fn test_topological_start() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin {
name: "c",
deps: &["a", "b"],
prio: 100,
order: order.clone(),
})
.add(TestPlugin {
name: "b",
deps: &["a"],
prio: 100,
order: order.clone(),
})
.add(TestPlugin {
name: "a",
deps: &[],
prio: 100,
order: order.clone(),
});
mgr.start_all().await.unwrap();
let log = order.lock();
assert_eq!(log[0], "start:a");
assert_eq!(log[1], "start:b");
assert_eq!(log[2], "start:c");
}
#[tokio::test]
async fn test_cycle_detection() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin {
name: "x",
deps: &["y"],
prio: 100,
order: order.clone(),
})
.add(TestPlugin {
name: "y",
deps: &["x"],
prio: 100,
order: order.clone(),
});
let result = mgr.start_all().await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_stop_reverses_topological_order() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin {
name: "c",
deps: &["a", "b"],
prio: 100,
order: order.clone(),
})
.add(TestPlugin {
name: "b",
deps: &["a"],
prio: 100,
order: order.clone(),
})
.add(TestPlugin {
name: "a",
deps: &[],
prio: 100,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.stop_all().await;
let log = order.lock();
assert_eq!(log[0], "start:a");
assert_eq!(log[1], "start:b");
assert_eq!(log[2], "start:c");
assert_eq!(log[3], "stop:c");
assert_eq!(log[4], "stop:b");
assert_eq!(log[5], "stop:a");
}
struct FailOnStartPlugin {
name: &'static str,
fail: bool,
order: Arc<Mutex<Vec<String>>>,
}
#[async_trait]
impl Plugin for FailOnStartPlugin {
fn name(&self) -> &str {
self.name
}
async fn start(&self) -> Result<()> {
self.order.lock().push(format!("start:{}", self.name));
if self.fail {
Err(crate::error::Error::Config(format!(
"{} 启动失败(测试)",
self.name
)))
} else {
Ok(())
}
}
async fn stop(&self) -> Result<()> {
self.order.lock().push(format!("stop:{}", self.name));
Ok(())
}
}
#[tokio::test]
async fn test_partial_start_rolls_back() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(FailOnStartPlugin {
name: "a",
fail: false,
order: order.clone(),
})
.add(FailOnStartPlugin {
name: "b",
fail: true,
order: order.clone(),
});
let result = mgr.start_all().await;
assert!(result.is_err());
{
let log = order.lock();
assert_eq!(log[0], "start:a");
assert_eq!(log[1], "start:b");
assert_eq!(log[2], "stop:a");
assert_eq!(log.len(), 3);
}
mgr.stop_all().await;
assert_eq!(order.lock().len(), 3);
}
#[tokio::test]
async fn test_repeated_start_stop() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(TestPlugin {
name: "a",
deps: &[],
prio: 100,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.stop_all().await;
mgr.start_all().await.unwrap();
mgr.stop_all().await;
let log = order.lock();
assert_eq!(&*log, &["start:a", "stop:a", "start:a", "stop:a"]);
}
#[tokio::test]
async fn test_priority_ordering() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin {
name: "late",
deps: &[],
prio: 200,
order: order.clone(),
})
.add(TestPlugin {
name: "early",
deps: &[],
prio: 10,
order: order.clone(),
})
.add(TestPlugin {
name: "mid",
deps: &[],
prio: 50,
order: order.clone(),
});
mgr.start_all().await.unwrap();
let log = order.lock();
assert_eq!(log[0], "start:early"); assert_eq!(log[1], "start:mid"); assert_eq!(log[2], "start:late"); }
#[test]
fn duplicate_names_rejected() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin { name: "dup", deps: &[], prio: 0, order: order.clone() })
.add(TestPlugin { name: "dup", deps: &[], prio: 0, order: order.clone() });
assert!(mgr.check_duplicate_names().is_err());
assert!(futures_block(mgr.start_all()).is_err());
}
#[test]
fn missing_dependency_rejected() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin { name: "a", deps: &["ghost"], prio: 0, order: order.clone() });
let err = futures_block(mgr.start_all()).unwrap_err();
assert!(err.to_string().contains("ghost"));
}
#[test]
fn stop_all_without_start_falls_back_to_registry_reverse() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(TestPlugin { name: "a", deps: &[], prio: 0, order: order.clone() })
.add(TestPlugin { name: "b", deps: &[], prio: 0, order: order.clone() });
futures_block(mgr.stop_all());
assert_eq!(&*order.lock(), &["stop:b", "stop:a"]);
}
#[test]
fn add_discovered_collects_arc_plugins() {
let order = Arc::new(Mutex::new(Vec::new()));
let p: Arc<dyn Plugin> = Arc::new(TestPlugin {
name: "discovered",
deps: &[],
prio: 0,
order: order.clone(),
});
let mgr = PluginManager::new().add_discovered(vec![p]);
assert_eq!(mgr.check_duplicate_names(), Ok(()));
futures_block(mgr.start_all()).unwrap();
assert_eq!(&*order.lock(), &["start:discovered"]);
}
#[tokio::test]
async fn arc_plugin_forwards_methods() {
let order = Arc::new(Mutex::new(Vec::new()));
let inner = Arc::new(TestPlugin { name: "wrapped", deps: &[], prio: 7, order: order.clone() });
let arc: Arc<dyn Plugin> = inner.clone();
assert_eq!(arc.name(), "wrapped");
assert_eq!(arc.priority(), 7);
assert!(arc.depends_on().is_empty());
arc.start().await.unwrap();
arc.stop().await.unwrap();
assert_eq!(&*order.lock(), &["start:wrapped", "stop:wrapped"]);
}
#[test]
fn default_manager() {
let mgr = PluginManager::default();
assert!(mgr.check_duplicate_names().is_ok());
}
struct LifecyclePlugin {
name: &'static str,
fail_degrade: bool,
fail_resume: bool,
order: Arc<Mutex<Vec<String>>>,
}
#[async_trait]
impl Plugin for LifecyclePlugin {
fn name(&self) -> &str {
self.name
}
async fn start(&self) -> Result<()> {
self.order.lock().push(format!("start:{}", self.name));
Ok(())
}
async fn stop(&self) -> Result<()> {
self.order.lock().push(format!("stop:{}", self.name));
Ok(())
}
async fn on_degrade(&self) -> Result<()> {
self.order.lock().push(format!("degrade:{}", self.name));
if self.fail_degrade {
Err(crate::error::Error::Config("降级失败(测试)".into()))
} else {
Ok(())
}
}
async fn on_resume(&self) -> Result<()> {
self.order.lock().push(format!("resume:{}", self.name));
if self.fail_resume {
Err(crate::error::Error::Config("恢复失败(测试)".into()))
} else {
Ok(())
}
}
async fn on_fault(&self) -> Result<()> {
self.order.lock().push(format!("fault:{}", self.name));
Ok(())
}
}
#[tokio::test]
async fn degrade_resume_lifecycle_transitions() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(LifecyclePlugin {
name: "a",
fail_degrade: false,
fail_resume: false,
order: order.clone(),
})
.add(LifecyclePlugin {
name: "b",
fail_degrade: false,
fail_resume: false,
order: order.clone(),
});
mgr.start_all().await.unwrap();
assert_eq!(mgr.state("a"), Some(PluginState::Running));
assert_eq!(mgr.state("unknown"), None, "未知插件返回 None");
mgr.degrade_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Degraded));
assert!(mgr.state("a").unwrap().is_available(), "降级仍可用");
assert!(!mgr.state("a").unwrap().is_running());
mgr.resume_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Running));
mgr.degrade_all().await;
mgr.stop_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
assert_eq!(
&*order.lock(),
&[
"start:a", "start:b",
"degrade:b", "degrade:a", "resume:a", "resume:b",
"degrade:b", "degrade:a",
"stop:b", "stop:a"
]
);
}
#[tokio::test]
async fn degrade_order_is_reverse_of_start_order() {
struct DepPlugin {
name: &'static str,
deps: &'static [&'static str],
order: Arc<Mutex<Vec<String>>>,
}
#[async_trait]
impl Plugin for DepPlugin {
fn name(&self) -> &str {
self.name
}
fn depends_on(&self) -> &[&str] {
self.deps
}
async fn start(&self) -> Result<()> {
Ok(())
}
async fn stop(&self) -> Result<()> {
Ok(())
}
async fn on_degrade(&self) -> Result<()> {
self.order.lock().push(format!("degrade:{}", self.name));
Ok(())
}
}
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(DepPlugin { name: "a", deps: &[], order: order.clone() })
.add(DepPlugin { name: "b", deps: &["a"], order: order.clone() });
mgr.start_all().await.unwrap();
mgr.degrade_all().await;
assert_eq!(&*order.lock(), &["degrade:b", "degrade:a"]);
}
#[tokio::test]
async fn degrade_failure_triggers_fault_transfer() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(LifecyclePlugin {
name: "a",
fail_degrade: true,
fail_resume: false,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.degrade_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
assert!(order.lock().contains(&"fault:a".to_string()));
mgr.resume_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
mgr.stop_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
}
#[tokio::test]
async fn resume_failure_triggers_fault_transfer() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(LifecyclePlugin {
name: "a",
fail_degrade: false,
fail_resume: true,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.degrade_all().await;
mgr.resume_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
assert!(order.lock().contains(&"fault:a".to_string()));
}
#[tokio::test]
async fn manual_fault_and_reset_allow_restart() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(LifecyclePlugin {
name: "a",
fail_degrade: false,
fail_resume: false,
order: order.clone(),
});
mgr.start_all().await.unwrap();
assert!(!mgr.fault("ghost").await);
assert!(mgr.fault("a").await);
assert_eq!(mgr.state("a"), Some(PluginState::Faulted));
assert!(order.lock().contains(&"fault:a".to_string()));
assert!(mgr.fault("a").await);
mgr.start_all().await.unwrap();
assert_eq!(mgr.state("a"), Some(PluginState::Faulted), "Faulted 跳过启动");
assert!(mgr.reset("a"));
assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
assert!(!mgr.reset("a"), "非 Faulted 不可重置");
mgr.start_all().await.unwrap();
assert_eq!(mgr.state("a"), Some(PluginState::Running));
let starts = order.lock().iter().filter(|e| e.as_str() == "start:a").count();
assert_eq!(starts, 2, "reset 后重新执行了 start 钩子");
}
#[tokio::test]
async fn start_failure_marks_plugin_faulted() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(FailOnStartPlugin { name: "ok", fail: true, order: order.clone() });
assert!(mgr.start_all().await.is_err());
assert_eq!(mgr.state("ok"), Some(PluginState::Faulted));
assert!(!mgr.state("ok").unwrap().is_available());
}
#[tokio::test]
async fn double_start_is_rejected_by_state_gate() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(LifecyclePlugin {
name: "a",
fail_degrade: false,
fail_resume: false,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.start_all().await.unwrap();
assert_eq!(mgr.state("a"), Some(PluginState::Running));
assert_eq!(order.lock().iter().filter(|e| e.as_str() == "start:a").count(), 1);
mgr.stop_all().await;
assert_eq!(mgr.state("a"), Some(PluginState::Stopped));
assert_eq!(order.lock().iter().filter(|e| e.as_str() == "stop:a").count(), 1);
}
#[tokio::test]
async fn double_stop_does_not_rerun_hooks() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new().add(TestPlugin {
name: "a",
deps: &[],
prio: 100,
order: order.clone(),
});
mgr.start_all().await.unwrap();
mgr.stop_all().await;
mgr.stop_all().await;
assert_eq!(&*order.lock(), &["start:a", "stop:a"]);
}
#[tokio::test]
async fn restart_after_fault_keeps_stop_record_consistent() {
let order = Arc::new(Mutex::new(Vec::new()));
let mgr = PluginManager::new()
.add(LifecyclePlugin { name: "a", fail_degrade: false, fail_resume: false, order: order.clone() })
.add(LifecyclePlugin { name: "b", fail_degrade: false, fail_resume: false, order: order.clone() });
mgr.start_all().await.unwrap();
assert!(mgr.fault("a").await);
assert!(mgr.reset("a"));
mgr.start_all().await.unwrap();
mgr.stop_all().await;
let stops: Vec<String> = order.lock().iter().filter(|e| e.starts_with("stop:")).cloned().collect();
assert_eq!(stops, vec!["stop:a".to_string(), "stop:b".to_string()]);
}
fn futures_block<F: std::future::Future>(fut: F) -> F::Output {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap()
.block_on(fut)
}
}