use std::time::Duration;
use std::{panic::AssertUnwindSafe, time::Instant};
use tracing::{error, trace};
use crate::core::{ActorContext, ActorCore, ActorHandle};
use crate::wait;
pub trait ThreadActor: ActorCore {
fn run(self, ctx: ActorContext<Self>);
fn spawn_thread(self, name: &str) -> ActorHandle<Self>
where
Self: Send + 'static,
{
spawn_thread(name, move || self)
}
}
pub fn spawn_thread<A, F>(name: &str, factory: F) -> ActorHandle<A>
where
A: ThreadActor + 'static,
F: FnOnce() -> A + Send + 'static,
{
try_spawn_thread(name, factory).expect("failed to start thread actor")
}
pub const STARTUP_TIMEOUT: Duration = Duration::from_secs(5);
#[derive(Debug)]
#[non_exhaustive]
pub enum SpawnError {
Thread(std::io::Error),
ConstructorPanicked(String),
StartupTimeout(Duration),
}
impl std::fmt::Display for SpawnError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Thread(e) => write!(f, "failed to spawn actor thread: {e}"),
Self::ConstructorPanicked(msg) => write!(f, "actor failed to start: {msg}"),
Self::StartupTimeout(d) => {
write!(f, "actor did not hand over its handle within {d:?}")
}
}
}
}
impl std::error::Error for SpawnError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Thread(e) => Some(e),
_ => None,
}
}
}
pub fn try_spawn_thread<A, F>(name: &str, factory: F) -> Result<ActorHandle<A>, SpawnError>
where
A: ThreadActor + 'static,
F: FnOnce() -> A + Send + 'static,
{
let thread_name = name.to_owned();
let (handle_tx, handle_rx) = std::sync::mpsc::channel::<Result<ActorHandle<A>, SpawnError>>();
std::thread::Builder::new()
.name(thread_name.clone())
.spawn(move || {
let actor = match std::panic::catch_unwind(AssertUnwindSafe(factory)) {
Ok(actor) => actor,
Err(payload) => {
let _ = handle_tx.send(Err(SpawnError::ConstructorPanicked(panic_message(
&*payload,
))));
return;
}
};
let (init_state, init_progress) = match std::panic::catch_unwind(AssertUnwindSafe(
|| actor.init_state_and_progress(),
)) {
Ok(v) => v,
Err(payload) => {
let _ = handle_tx.send(Err(SpawnError::ConstructorPanicked(panic_message(
&*payload,
))));
return;
}
};
let (ctx, handle) = A::channel(init_state, init_progress);
handle.attach_current_thread();
if handle_tx.send(Ok(handle)).is_err() {
return; }
trace!(
actor = std::any::type_name::<A>(),
thread = %thread_name,
"thread actor started"
);
if let Err(payload) = std::panic::catch_unwind(AssertUnwindSafe(|| actor.run(ctx))) {
error!(
actor = std::any::type_name::<A>(),
panic = %panic_message(&*payload),
"thread actor panicked"
);
}
})
.map_err(SpawnError::Thread)?;
match handle_rx.recv_timeout(STARTUP_TIMEOUT) {
Ok(result) => result,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
Err(SpawnError::StartupTimeout(STARTUP_TIMEOUT))
}
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Err(
SpawnError::ConstructorPanicked("actor thread died during startup".to_owned()),
),
}
}
fn panic_message(payload: &(dyn std::any::Any + Send)) -> String {
payload
.downcast_ref::<&str>()
.map(|s| (*s).to_owned())
.or_else(|| payload.downcast_ref::<String>().cloned())
.unwrap_or_else(|| "<non-string panic payload>".to_owned())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum CmdWait {
Timeout,
Closed,
}
impl<A: ThreadActor> ActorHandle<A> {
pub(crate) fn attach_current_thread(&self) {
self.waker.attach_current();
}
}
impl<A: ThreadActor> ActorContext<A> {
pub fn recv_cmd_timeout(&mut self, dur: Duration) -> Result<A::Cmd, CmdWait> {
if self.cancel.is_cancelled() {
return Err(CmdWait::Closed);
}
let waker = self.waker.waker();
let deadline = Instant::now().checked_add(dur);
let cmd_fut = self.cmd_rx.recv();
let cancel_fut = self.cancel.cancelled();
match wait::drive_either(cmd_fut, cancel_fut, deadline, &waker) {
Some(wait::Either2::First(Some(cmd))) => Ok(cmd),
Some(wait::Either2::First(None)) => Err(CmdWait::Closed), Some(wait::Either2::Second(())) => Err(CmdWait::Closed), None => Err(CmdWait::Timeout),
}
}
pub fn recv_cmd(&mut self) -> Option<A::Cmd> {
match self.recv_cmd_timeout(Duration::MAX) {
Ok(cmd) => Some(cmd),
Err(CmdWait::Closed) => None,
Err(CmdWait::Timeout) => unreachable!("无限等待不会超时"),
}
}
}