use crate::error::{ErrorKind, NetError};
use crate::Result;
use std::fmt;
use std::sync::{Arc, Mutex, MutexGuard, Weak};
use std::task::{Context, Poll};
pub(crate) mod common_executor;
mod dispatch;
mod event;
mod event_registration;
pub use event::EventReceiver;
pub(crate) use event::{
event_channel, EventOverflow, EventPublisher, EventQueueLimit, EventResources,
};
#[cfg(feature = "ws-client")]
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<()>;
}
trait SubscriptionControl: Send + Sync {
fn is_active(&self) -> bool;
fn unsubscribe(&self) -> bool;
fn poll_close(&self, cx: &mut Context<'_>) -> Poll<Result<()>>;
}
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()
}
}
}
#[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>> {
futures::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::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 {
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();
futures::future::poll_fn(|cx| 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 {
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 lifetime_tests;
#[cfg(test)]
mod tests;
#[cfg(test)]
mod event_regression_tests;
#[cfg(test)]
mod event_tests;