use crate::actor::{Actor, ActorContext, ActorError};
use crate::hotswap::ActorFactory;
use crate::hotswap::types::{WorkerMessage, WorkerResponder};
use std::collections::HashMap;
use std::marker::PhantomData;
use std::sync::atomic::{AtomicU64, Ordering};
pub trait WorkPayload: Send + 'static {
fn to_bytes(&self) -> Vec<u8>;
}
pub struct DynamicSupervisor<T, R>
where
T: WorkPayload,
R: Send + 'static,
{
pub module_name: String,
factory: std::sync::Arc<ActorFactory>,
work_counter: AtomicU64,
pending: HashMap<u64, WorkerResponder<R>>,
_phantom: PhantomData<T>,
}
impl<T, R> DynamicSupervisor<T, R>
where
T: WorkPayload,
R: Send + 'static,
{
pub fn new(module_name: &str, factory: std::sync::Arc<ActorFactory>) -> Self {
Self {
module_name: module_name.to_string(),
factory,
work_counter: AtomicU64::new(0),
pending: HashMap::new(),
_phantom: PhantomData,
}
}
pub fn current_version(&self) -> Option<String> {
self.factory.current_version(&self.module_name)
}
}
impl<T, R> Actor for DynamicSupervisor<T, R>
where
T: WorkPayload,
R: Send + 'static,
{
type Message = WorkerMessage<T, R>;
fn handle(&mut self, msg: Self::Message, ctx: &mut ActorContext) -> Result<(), ActorError> {
match msg {
WorkerMessage::SubmitWork { work, responder } => {
let work_id = self.work_counter.fetch_add(1, Ordering::Relaxed);
self.pending.insert(work_id, responder);
let initial_state = work.payload.to_bytes();
ctx.spawn_child(&self.module_name, initial_state)
.map_err(|e| ActorError::Handler(e.to_string()))?;
}
WorkerMessage::ChildCompleted { work_id, result } => {
if let Some(responder) = self.pending.remove(&work_id) {
responder.respond(result);
}
}
WorkerMessage::Shutdown => {
}
}
Ok(())
}
}