use crate::error::{ErrorKind, NetError};
use crate::Result;
use std::cell::Cell;
use std::fmt;
use std::sync::{Arc, Mutex, MutexGuard, Weak};
use std::task::{Context, Poll};
pub(crate) mod common_executor;
mod dispatch;
#[cfg(feature = "net-status")]
pub(crate) use dispatch::submit_tracked;
mod event;
mod event_registration;
pub use event::EventReceiver;
pub(crate) use event::{
event_channel, EventOverflow, EventPublisher, EventQueueLimit, EventResources,
};
#[cfg(any(feature = "ws-client", feature = "net-status"))]
pub(crate) use event::{EventPublication, EventSeed};
mod registration;
mod source;
pub(crate) use source::{StatePublication, StatePublisher, StateSource};
pub(crate) trait CallbackExecutor: Send + Sync + 'static {
fn ensure_ready(&self) -> Result<()>;
fn submit(&self, job: Box<dyn FnOnce() + Send + 'static>) -> Result<()>;
}
pub(crate) trait SubscriptionControl: Send + Sync {
fn is_active(&self) -> bool;
fn unsubscribe(&self) -> bool;
fn poll_close(&self, cx: &mut Context<'_>) -> Poll<Result<()>>;
}
pub(crate) fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
match mutex.lock() {
Ok(guard) => guard,
Err(poisoned) => {
crate::log_e!(crate::common::log::log_def::LogType::Common;
"subscription_lock", "kind|reason", format!("{:?}", ErrorKind::Internal), "poisoned mutex recovered");
poisoned.into_inner()
}
}
}
thread_local! {
static CALLBACK_DEPTH: Cell<usize> = const { Cell::new(0) };
}
pub(crate) struct CallbackScope;
impl CallbackScope {
pub(crate) fn enter() -> Self {
CALLBACK_DEPTH.with(|depth| depth.set(depth.get() + 1));
Self
}
pub(crate) fn is_current() -> bool {
CALLBACK_DEPTH.with(|depth| depth.get() != 0)
}
}
impl Drop for CallbackScope {
fn drop(&mut self) {
CALLBACK_DEPTH.with(|depth| depth.set(depth.get() - 1));
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SubscriptionId(u64);
impl SubscriptionId {
pub fn as_u64(self) -> u64 {
self.0
}
}
impl fmt::Display for SubscriptionId {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(formatter)
}
}
#[must_use]
pub struct StateReceiver<T> {
registration: Arc<registration::Registration<T>>,
owns_subscription: bool,
}
impl<T> fmt::Debug for StateReceiver<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("StateReceiver")
.field("id", &self.registration.id)
.finish_non_exhaustive()
}
}
impl<T: Clone> StateReceiver<T> {
#[cfg_attr(not(any(feature = "http-client", test)), allow(dead_code))]
pub(crate) fn bind_lifetime(&self, lifetime: impl Send + Sync + 'static) -> Result<()> {
self.registration.bind_lifetime(Box::new(lifetime))
}
pub fn id(&self) -> SubscriptionId {
self.registration.id
}
pub fn current(&self) -> T {
self.registration.current()
}
pub async fn recv(&mut self) -> Result<Option<T>> {
std::future::poll_fn(|cx| self.registration.poll_next(cx))
.await
.transpose()
}
pub fn unsubscribe(&self) -> bool {
self.registration.unsubscribe()
}
pub fn into_callback<F>(mut self, callback: F) -> Result<Subscription>
where
T: Send + Sync + 'static,
F: Fn(CallbackContext, Result<T>) + Send + Sync + 'static,
{
self.registration.install_callback(callback)?;
self.owns_subscription = false;
Ok(Subscription {
id: self.registration.id,
control: self.registration.clone(),
})
}
}
impl<T: Clone> futures_util::Stream for StateReceiver<T> {
type Item = Result<T>;
fn poll_next(self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
self.registration.poll_next(cx)
}
}
impl<T> Drop for StateReceiver<T> {
fn drop(&mut self) {
if self.owns_subscription {
self.registration.unsubscribe();
}
}
}
#[must_use]
pub struct Subscription {
id: SubscriptionId,
control: Arc<dyn SubscriptionControl>,
}
impl Subscription {
#[cfg(feature = "net-status")]
pub(crate) fn from_control(id: SubscriptionId, control: Arc<dyn SubscriptionControl>) -> Self {
Self { id, control }
}
pub fn id(&self) -> SubscriptionId {
self.id
}
pub fn is_active(&self) -> bool {
self.control.is_active()
}
pub fn unsubscribe(&self) -> bool {
self.control.unsubscribe()
}
pub async fn close(self) -> Result<()> {
self.unsubscribe();
std::future::poll_fn(|cx| {
if CallbackScope::is_current() {
return Poll::Ready(Err(NetError::input(
"subscription.close",
"await subscription close outside subscription callbacks; use unsubscribe inside callbacks",
)
.with_stage(crate::error::ErrorStage::Dispatch)));
}
self.control.poll_close(cx)
})
.await
}
}
impl Drop for Subscription {
fn drop(&mut self) {
self.control.unsubscribe();
}
}
impl fmt::Debug for Subscription {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Subscription")
.field("id", &self.id)
.field("active", &self.is_active())
.finish()
}
}
#[derive(Clone)]
pub struct CallbackContext {
id: SubscriptionId,
control: Weak<dyn SubscriptionControl>,
}
impl CallbackContext {
#[cfg(feature = "net-status")]
pub(crate) fn from_control(id: SubscriptionId, control: &Arc<dyn SubscriptionControl>) -> Self {
Self {
id,
control: Arc::downgrade(control),
}
}
pub fn id(&self) -> SubscriptionId {
self.id
}
pub fn unsubscribe(&self) -> bool {
self.control
.upgrade()
.is_some_and(|control| control.unsubscribe())
}
}
impl fmt::Debug for CallbackContext {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("CallbackContext")
.field("id", &self.id)
.finish_non_exhaustive()
}
}
#[cfg(test)]
mod close_context_tests;
#[cfg(test)]
mod lifetime_tests;
#[cfg(test)]
mod tests;
#[cfg(test)]
mod event_regression_tests;
#[cfg(test)]
mod event_tests;