use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PluginState {
Stopped,
Starting,
Running,
Degrading,
Degraded,
Resuming,
Faulted,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PluginTrigger {
Start,
StartOk,
StartFailed,
Stop,
Degrade,
DegradeOk,
Resume,
ResumeOk,
Fault,
Reset,
}
impl PluginState {
pub fn transition(self, trigger: PluginTrigger) -> Result<Self, String> {
use PluginState as S;
use PluginTrigger as T;
match (self, trigger) {
(S::Stopped, T::Start) => Ok(S::Starting),
(S::Starting, T::StartOk) => Ok(S::Running),
(S::Starting, T::StartFailed | T::Fault) => Ok(S::Faulted),
(S::Running, T::Stop) => Ok(S::Stopped),
(S::Running, T::Degrade) => Ok(S::Degrading),
(S::Degrading, T::DegradeOk) => Ok(S::Degraded),
(S::Degraded, T::Resume) => Ok(S::Resuming),
(S::Resuming, T::ResumeOk) => Ok(S::Running),
(S::Stopped, T::Stop) => Ok(S::Stopped),
(S::Degraded, T::Stop) => Ok(S::Stopped),
(S::Faulted, T::Stop) => Ok(S::Stopped),
(S::Running, T::Fault) => Ok(S::Faulted),
(S::Degrading, T::Fault) => Ok(S::Faulted),
(S::Degraded, T::Fault) => Ok(S::Faulted),
(S::Resuming, T::Fault) => Ok(S::Faulted),
(S::Faulted, T::Fault) => Ok(S::Faulted),
(S::Faulted, T::Reset) => Ok(S::Stopped),
(state, trigger) => Err(format!("非法状态转移: {state:?} + {trigger:?}")),
}
}
pub fn is_running(self) -> bool {
matches!(self, Self::Running)
}
pub fn is_available(self) -> bool {
matches!(self, Self::Running | Self::Degraded)
}
}
impl fmt::Display for PluginState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{self:?}")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn legal_happy_path_transitions() {
use PluginTrigger as T;
use PluginState as S;
assert_eq!(S::Stopped.transition(T::Start), Ok(S::Starting));
assert_eq!(S::Starting.transition(T::StartOk), Ok(S::Running));
assert_eq!(S::Running.transition(T::Degrade), Ok(S::Degrading));
assert_eq!(S::Degrading.transition(T::DegradeOk), Ok(S::Degraded));
assert_eq!(S::Degraded.transition(T::Resume), Ok(S::Resuming));
assert_eq!(S::Resuming.transition(T::ResumeOk), Ok(S::Running));
assert_eq!(S::Running.transition(T::Stop), Ok(S::Stopped));
}
#[test]
fn start_failure_goes_to_faulted() {
use PluginTrigger as T;
use PluginState as S;
assert_eq!(
S::Starting.transition(T::StartFailed),
Ok(S::Faulted),
"启动失败必须进入 Faulted 而不是静默回 Stopped"
);
assert_eq!(S::Faulted.transition(T::Reset), Ok(S::Stopped));
}
#[test]
fn fault_is_reachable_from_any_live_state_and_idempotent() {
use PluginTrigger as T;
use PluginState as S;
for live in [S::Starting, S::Running, S::Degrading, S::Degraded, S::Resuming] {
assert_eq!(live.transition(T::Fault), Ok(S::Faulted), "{live:?} 应可故障转移");
}
assert_eq!(S::Faulted.transition(T::Fault), Ok(S::Faulted), "Fault 幂等");
assert!(S::Stopped.transition(T::Fault).is_err());
}
#[test]
fn stop_is_always_allowed_for_shutdown() {
use PluginTrigger as T;
use PluginState as S;
assert_eq!(S::Stopped.transition(T::Stop), Ok(S::Stopped));
assert_eq!(S::Degraded.transition(T::Stop), Ok(S::Stopped));
assert_eq!(S::Faulted.transition(T::Stop), Ok(S::Stopped));
}
#[test]
fn illegal_transitions_rejected() {
use PluginTrigger as T;
use PluginState as S;
assert!(S::Running.transition(T::Start).is_err());
assert!(S::Running.transition(T::StartOk).is_err());
assert!(S::Degraded.transition(T::Degrade).is_err());
assert!(S::Stopped.transition(T::Resume).is_err());
assert!(S::Stopped.transition(T::Reset).is_err());
assert!(S::Faulted.transition(T::Start).is_err(), "Faulted 必须先 Reset");
assert!(S::Faulted.transition(T::Resume).is_err());
assert!(S::Starting.transition(T::Stop).is_err());
assert!(S::Degrading.transition(T::Stop).is_err());
assert!(S::Resuming.transition(T::Stop).is_err());
}
#[test]
fn availability_predicates() {
use PluginState as S;
assert!(S::Running.is_running());
assert!(!S::Degraded.is_running());
assert!(S::Degraded.is_available(), "降级仍提供受限服务");
assert!(S::Running.is_available());
assert!(!S::Faulted.is_available());
assert!(!S::Stopped.is_available());
}
}