use std::{
collections::VecDeque,
fmt,
sync::{Arc, PoisonError},
task::{Context, Waker},
};
use crate::sync::Mutex;
use rig_core::{
effect::{Family, HandlerDescriptor, HandlerKey},
error::{ErrorKind, ErrorReport},
};
use rig_core::serve::{ErasedHandler, Serve};
use super::dispatcher::Shared;
use rig_core::effect::Key;
pub(super) fn family_proof_failed(
key: &HandlerKey,
wanted: rig_core::effect::EffectFamily,
descriptor: &HandlerDescriptor,
) -> ErrorReport {
ErrorReport::new(
ErrorKind::HandlerUnavailable,
format!(
"handler for `{key}` serves the {} family; a `Key<{wanted}>` cannot name it",
descriptor.family.family()
),
)
.with_retryable(false)
}
pub(super) enum Registration {
Install {
key: HandlerKey,
handler: ErasedHandler,
},
Remove {
key: HandlerKey,
},
}
struct MailboxInner {
pending: VecDeque<Registration>,
driver: Option<Waker>,
closed: bool,
}
pub(super) struct Mailbox {
inner: Mutex<MailboxInner>,
}
impl Mailbox {
pub(super) fn new() -> Self {
Self {
inner: Mutex::new(MailboxInner {
pending: VecDeque::new(),
driver: None,
closed: false,
}),
}
}
pub(super) fn register(
&self,
shared: &Shared,
key: HandlerKey,
handler: ErasedHandler,
) -> Result<(), ErrorReport> {
let descriptor = handler.descriptor();
let driver = {
let mut inner = self.inner.lock().unwrap_or_else(PoisonError::into_inner);
shared.publish_descriptor(key.clone(), descriptor)?;
if !inner.closed {
inner
.pending
.push_back(Registration::Install { key, handler });
}
inner.driver.take()
};
if let Some(driver) = driver {
driver.wake();
}
Ok(())
}
pub(super) fn deregister(&self, shared: &Shared, key: &HandlerKey) -> bool {
let (removed, driver) = {
let mut inner = self.inner.lock().unwrap_or_else(PoisonError::into_inner);
let removed = shared.retract_descriptor(key);
if !inner.closed {
inner
.pending
.push_back(Registration::Remove { key: key.clone() });
}
(removed, inner.driver.take())
};
if let Some(driver) = driver {
driver.wake();
}
removed
}
pub(super) fn take_pending(&self) -> VecDeque<Registration> {
let mut inner = self.inner.lock().unwrap_or_else(PoisonError::into_inner);
std::mem::take(&mut inner.pending)
}
pub(super) fn drain(&self, cx: &Context<'_>) -> VecDeque<Registration> {
let mut inner = self.inner.lock().unwrap_or_else(PoisonError::into_inner);
match &mut inner.driver {
Some(driver) if driver.will_wake(cx.waker()) => {}
slot => *slot = Some(cx.waker().clone()),
}
std::mem::take(&mut inner.pending)
}
pub(super) fn clear(&self) {
let pending = {
let mut inner = self.inner.lock().unwrap_or_else(PoisonError::into_inner);
inner.closed = true;
std::mem::take(&mut inner.pending)
};
drop(pending);
}
}
#[derive(Clone)]
pub struct Registrar {
pub(super) shared: Arc<Shared>,
pub(super) mailbox: Arc<Mailbox>,
}
impl fmt::Debug for Registrar {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Registrar")
.field("closed", &self.shared.is_closed())
.field("handlers", &self.shared.keys())
.finish_non_exhaustive()
}
}
impl Registrar {
pub fn register(
&self,
key: impl Into<HandlerKey>,
handler: impl Serve + 'static,
) -> Result<(), ErrorReport> {
self.register_erased(key, ErasedHandler::new(handler))
}
pub fn register_erased(
&self,
key: impl Into<HandlerKey>,
handler: ErasedHandler,
) -> Result<(), ErrorReport> {
self.mailbox.register(&self.shared, key.into(), handler)
}
pub fn register_typed<F: Family>(
&self,
key: impl Into<HandlerKey>,
handler: impl Serve + 'static,
) -> Result<Key<F>, ErrorReport> {
let key = key.into();
let handler = ErasedHandler::new(handler);
let descriptor = handler.descriptor();
if descriptor.family.family() != F::FAMILY {
return Err(family_proof_failed(&key, F::FAMILY, &descriptor));
}
self.register_erased(key.clone(), handler)?;
Ok(Key::new_unchecked(key))
}
pub fn deregister(&self, key: &HandlerKey) -> bool {
self.mailbox.deregister(&self.shared, key)
}
pub fn descriptor(&self, key: &HandlerKey) -> Option<HandlerDescriptor> {
self.shared.descriptor(key)
}
pub fn keys(&self) -> Vec<HandlerKey> {
self.shared.keys()
}
pub fn descriptors(&self) -> Vec<HandlerDescriptor> {
self.shared.descriptors()
}
pub fn is_closed(&self) -> bool {
self.shared.is_closed()
}
}
#[cfg(not(target_family = "wasm"))]
const _: () = {
const fn assert_send_sync<T: Clone + Send + Sync + 'static>() {}
assert_send_sync::<Registrar>();
};
#[cfg(target_family = "wasm")]
const _: fn(&Registrar) = |registrar| {
struct Local(std::rc::Rc<std::cell::Cell<usize>>);
impl Serve for Local {
type Family = rig_core::effect::family::Dynamic;
fn descriptor(&self) -> HandlerDescriptor {
HandlerDescriptor {
key: HandlerKey::from("local"),
family: rig_core::effect::FamilyDescriptor::Custom {
kind: "local".into(),
},
layers: Vec::new(),
}
}
async fn serve(
&self,
_kind: rig_core::effect::EffectKind,
_dispatch: rig_core::serve::Dispatch,
) -> rig_core::serve::Reply {
self.0.set(self.0.get() + 1);
return rig_core::serve::Reply::Outcome(Ok(rig_core::effect::Outcome::Custom {
payload: serde_json::Value::Null,
}));
}
}
let _ = registrar.register("local", Local(std::rc::Rc::default()));
};