use crate::addr::{ActorId, ActorName};
use std::fmt;
use tokio::sync::watch;
pub trait ActorMsg: Send + 'static {}
impl<T: Send + 'static> ActorMsg for T {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum StopCause {
Requested,
Panicked,
ResourceLimit,
SystemShutdown,
MailboxClosed,
Missing,
}
impl fmt::Display for StopCause {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match self {
StopCause::Requested => "requested",
StopCause::Panicked => "panicked",
StopCause::ResourceLimit => "resource-limit",
StopCause::SystemShutdown => "system-shutdown",
StopCause::MailboxClosed => "mailbox-closed",
StopCause::Missing => "missing",
};
f.write_str(s)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ActorPhase {
Running,
Restarting {
generation: u32,
attempt: u32,
},
Stopped {
cause: StopCause,
detail: Option<String>,
},
}
impl ActorPhase {
#[must_use = "存活探测结果不应被静默忽略"]
pub fn is_alive(&self) -> bool {
!matches!(self, ActorPhase::Stopped { .. })
}
}
pub(crate) fn request_stop(tx: &watch::Sender<ActorPhase>, cause: StopCause) -> bool {
let listeners = !tx.is_closed();
let _ = tx.send_if_modified(|phase| match phase {
ActorPhase::Stopped { .. } => false,
_ => {
*phase = ActorPhase::Stopped {
cause,
detail: None,
};
true
}
});
listeners
}
pub(crate) fn publish_phase(tx: &watch::Sender<ActorPhase>, phase: ActorPhase) {
let _ = tx.send_if_modified(|cur| {
if *cur == phase || matches!(cur, ActorPhase::Stopped { .. }) {
return false;
}
*cur = phase;
true
});
}
#[derive(Debug, Clone)]
pub struct Terminated {
pub actor: ActorId,
pub name: Option<ActorName>,
pub cause: StopCause,
pub detail: Option<String>,
}
#[derive(Debug, Clone)]
pub enum ActorSignal {
Terminated(Terminated),
}
pub(crate) enum Signal {
WatchdogFire { arm: u64 },
System(ActorSignal),
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn stop_cause_display() {
assert_eq!(StopCause::Requested.to_string(), "requested");
assert_eq!(StopCause::Panicked.to_string(), "panicked");
assert_eq!(StopCause::ResourceLimit.to_string(), "resource-limit");
assert_eq!(StopCause::SystemShutdown.to_string(), "system-shutdown");
assert_eq!(StopCause::MailboxClosed.to_string(), "mailbox-closed");
}
#[test]
fn phase_channel_guards() {
let (tx, rx) = watch::channel(ActorPhase::Running);
publish_phase(
&tx,
ActorPhase::Restarting {
generation: 2,
attempt: 1,
},
);
assert_eq!(
*tx.borrow(),
ActorPhase::Restarting {
generation: 2,
attempt: 1
}
);
assert!(request_stop(&tx, StopCause::Requested), "有监听端应报 true");
assert_eq!(
*tx.borrow(),
ActorPhase::Stopped {
cause: StopCause::Requested,
detail: None
}
);
publish_phase(&tx, ActorPhase::Running);
assert!(
matches!(&*tx.borrow(), ActorPhase::Stopped { .. }),
"Stopped 之后发布 Running 必须被守卫拒绝"
);
let _ = tx.send_replace(ActorPhase::Stopped {
cause: StopCause::Panicked,
detail: Some("boom".to_string()),
});
assert!(request_stop(&tx, StopCause::Requested));
assert_eq!(
*tx.borrow(),
ActorPhase::Stopped {
cause: StopCause::Panicked,
detail: Some("boom".to_string())
},
"停止请求不得覆盖真实死因"
);
drop(rx);
let (tx, rx) = watch::channel(ActorPhase::Running);
drop(rx);
assert!(
!request_stop(&tx, StopCause::SystemShutdown),
"零接收端时停止请求必须报 false"
);
assert_eq!(
*tx.borrow(),
ActorPhase::Stopped {
cause: StopCause::SystemShutdown,
detail: None
},
"零接收端下停止请求仍须落值(死后补订阅可读)"
);
}
#[test]
fn oneshot_reply_message_satisfies_actor_msg() {
fn assert_msg<T: ActorMsg>() {}
#[allow(dead_code)] struct WithOneshot {
reply: tokio::sync::oneshot::Sender<u32>,
}
assert_msg::<WithOneshot>();
assert_msg::<crate::Reply<u32>>();
}
}