use core::{any::Any, hash::Hash, time::Duration};
use std::{
collections::{HashMap, HashSet},
sync::{Arc, Mutex},
};
use smol_bytes::Utf8Bytes;
use crate::operator::Receipts;
use super::{
ItemId, NodeName,
fate::Fate,
lifecycle::{Lifecycle, Observation},
window::Owed,
};
pub type ReceiptMap<K> = Option<Box<HashMap<K, Box<dyn Any + Send + Sync>>>>;
pub type SettledParts<K> = (
HashSet<K>,
Utf8Bytes,
Observation,
Option<Box<dyn Any + Send + Sync>>,
ReceiptMap<K>,
);
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Item<T, K = ItemId> {
key: K,
value: T,
}
impl<T, K> Item<T, K> {
#[inline]
pub const fn new(key: K, value: T) -> Self {
Self { key, value }
}
#[inline]
pub const fn key(&self) -> &K {
&self.key
}
#[inline]
pub const fn value(&self) -> &T {
&self.value
}
#[inline]
pub fn into_parts(self) -> (K, T) {
(self.key, self.value)
}
#[inline]
pub fn into_value(self) -> T {
self.value
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Payload<T, K = ItemId> {
One(Item<T, K>),
Batch(Vec<Item<T, K>>),
}
impl<T, K> Payload<T, K> {
#[inline]
pub fn len(&self) -> usize {
match self {
Self::One(_) => 1,
Self::Batch(items) => items.len(),
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[inline]
pub fn keys(&self) -> impl Iterator<Item = &K> {
match self {
Self::One(item) => core::slice::from_ref(item),
Self::Batch(items) => items.as_slice(),
}
.iter()
.map(Item::key)
}
}
impl<T, K> Payload<T, K> {
pub fn map<U>(self, mut map: impl FnMut(T) -> U) -> Payload<U, K> {
match self {
Self::One(item) => {
let (key, value) = item.into_parts();
Payload::One(Item::new(key, map(value)))
}
Self::Batch(items) => Payload::Batch(
items
.into_iter()
.map(|item| {
let (key, value) = item.into_parts();
Item::new(key, map(value))
})
.collect(),
),
}
}
}
impl<T, K> IntoIterator for Payload<T, K> {
type IntoIter = PayloadIter<T, K>;
type Item = Item<T, K>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
match self {
Self::One(item) => PayloadIter::One(Some(item)),
Self::Batch(items) => PayloadIter::Batch(items.into_iter()),
}
}
}
#[derive(Debug)]
pub enum PayloadIter<T, K = ItemId> {
One(Option<Item<T, K>>),
Batch(std::vec::IntoIter<Item<T, K>>),
}
impl<T, K> Iterator for PayloadIter<T, K> {
type Item = Item<T, K>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
match self {
Self::One(item) => item.take(),
Self::Batch(items) => items.next(),
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
match self {
Self::One(item) => {
let n = usize::from(item.is_some());
(n, Some(n))
}
Self::Batch(items) => items.size_hint(),
}
}
}
impl<T, K> ExactSizeIterator for PayloadIter<T, K> {}
#[derive(Debug)]
pub struct Delivery<T, K = ItemId> {
payload: Payload<T, K>,
ack: Option<Custody<K>>,
}
impl<T, K> Delivery<T, K> {
#[inline]
pub const fn new(payload: Payload<T, K>, ack: AckSender<K>) -> Self {
Self {
payload,
ack: Some(Custody::sole(ack)),
}
}
#[inline]
pub const fn joined(payload: Payload<T, K>, custody: Custody<K>) -> Self {
Self {
payload,
ack: Some(custody),
}
}
#[inline]
pub const fn in_custody(payload: Payload<T, K>) -> Self {
Self { payload, ack: None }
}
#[inline]
pub const fn payload(&self) -> &Payload<T, K> {
&self.payload
}
#[inline]
pub fn into_items(self) -> PayloadIter<T, K> {
self.payload.into_iter()
}
#[inline]
pub fn map<U>(self, map: impl FnMut(T) -> U) -> Delivery<U, K> {
Delivery {
payload: self.payload.map(map),
ack: self.ack,
}
}
#[inline]
pub fn into_parts(self) -> (Payload<T, K>, Option<Custody<K>>) {
(self.payload, self.ack)
}
}
#[derive(Debug)]
pub struct Ack<K, I> {
released: HashSet<K>,
worker: Utf8Bytes,
lifecycle: Lifecycle<I>,
receipts: ReceiptMap<K>,
}
impl<K, I> Ack<K, I> {
#[inline]
pub fn holding(worker: impl Into<Utf8Bytes>, lifecycle: Lifecycle<I>) -> Self {
Self {
released: HashSet::new(),
worker: worker.into(),
lifecycle,
receipts: None,
}
}
#[inline]
pub fn new(released: HashSet<K>, worker: impl Into<Utf8Bytes>, lifecycle: Lifecycle<I>) -> Self {
Self {
released,
worker: worker.into(),
lifecycle,
receipts: None,
}
}
#[inline]
pub const fn released(&self) -> &HashSet<K> {
&self.released
}
#[inline]
pub fn worker(&self) -> &NodeName {
NodeName::new(&self.worker)
}
#[inline]
pub const fn lifecycle(&self) -> &Lifecycle<I> {
&self.lifecycle
}
#[inline]
#[must_use]
pub fn releasing(mut self, key: K) -> Self
where
K: Eq + Hash,
{
self.released.insert(key);
self
}
#[inline]
#[must_use]
pub fn receipting<R>(mut self, key: K, receipt: R) -> Self
where
K: Eq + Hash,
R: Any + Send + Sync,
{
self
.receipts
.get_or_insert_with(Box::default)
.insert(key, Box::new(receipt));
self
}
#[inline]
#[must_use]
pub fn receipting_of<M>(self, key: K, receipt: M::Receipt) -> Self
where
K: Eq + Hash,
M: Receipts,
M::Receipt: Any + Send + Sync,
{
self.receipting(key, receipt)
}
#[inline]
pub fn receipt<R: Any>(&self, key: &K) -> Option<&R>
where
K: Eq + Hash,
{
self
.receipts
.as_ref()?
.get(key)
.and_then(|receipt| receipt.downcast_ref())
}
#[inline]
#[must_use]
pub(crate) fn carrying(mut self, receipts: ReceiptMap<K>) -> Self {
self.receipts = receipts;
self
}
}
#[derive(Debug)]
pub struct Settled<K> {
released: HashSet<K>,
worker: Utf8Bytes,
observation: Observation,
message: Option<Box<dyn Any + Send + Sync>>,
receipts: ReceiptMap<K>,
}
impl<K> Settled<K> {
#[inline]
pub const fn released(&self) -> &HashSet<K> {
&self.released
}
#[inline]
pub fn worker(&self) -> &NodeName {
NodeName::new(&self.worker)
}
#[inline]
pub const fn observation(&self) -> &Observation {
&self.observation
}
#[inline]
pub fn message<M: Any>(&self) -> Option<&M> {
self
.message
.as_ref()
.and_then(|message| message.downcast_ref())
}
#[inline]
pub fn receipt_of<M>(&self, key: &K) -> Result<&M::Receipt, Unreceipted>
where
K: Eq + Hash,
M: Receipts,
M::Receipt: Any,
{
self.receipt::<M::Receipt>(key)
}
#[inline]
pub fn receipt<R: Any>(&self, key: &K) -> Result<&R, Unreceipted>
where
K: Eq + Hash,
{
let receipt = self
.receipts
.as_ref()
.and_then(|receipts| receipts.get(key))
.ok_or(Unreceipted::Silent)?;
receipt.downcast_ref().ok_or(Unreceipted::Mismatched)
}
pub fn take_receipt<R: Any>(&mut self, key: &K) -> Result<R, Unreceipted>
where
K: Eq + Hash,
{
let Some(receipts) = self.receipts.as_mut() else {
return Err(Unreceipted::Silent);
};
let Some((key, receipt)) = receipts.remove_entry(key) else {
return Err(Unreceipted::Silent);
};
match receipt.downcast::<R>() {
Ok(receipt) => Ok(*receipt),
Err(receipt) => {
receipts.insert(key, receipt);
Err(Unreceipted::Mismatched)
}
}
}
#[inline]
#[must_use]
pub fn has_receipt(&self, key: &K) -> bool
where
K: Eq + Hash,
{
self
.receipts
.as_ref()
.is_some_and(|receipts| receipts.contains_key(key))
}
#[inline]
pub fn into_parts(self) -> SettledParts<K> {
(
self.released,
self.worker,
self.observation,
self.message,
self.receipts,
)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, derive_more::Display, derive_more::IsVariant)]
pub enum Unreceipted {
#[display("the consumer hung up without answering")]
HungUp,
#[display("the consumer did not answer within the deadline")]
TimedOut,
#[display("the consumer answered and stated no receipt for this item")]
Silent,
#[display("the consumer's receipt is not of the type this caller asked for")]
Mismatched,
}
impl core::error::Error for Unreceipted {}
impl From<Unsettled> for Unreceipted {
#[inline]
fn from(unsettled: Unsettled) -> Self {
match unsettled {
Unsettled::HungUp => Self::HungUp,
Unsettled::TimedOut => Self::TimedOut,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, derive_more::Display, derive_more::IsVariant)]
pub enum Unsettled {
#[display("the consumer hung up without answering")]
HungUp,
#[display("the consumer did not answer within the deadline")]
TimedOut,
}
impl core::error::Error for Unsettled {}
#[derive(Debug)]
pub enum Custody<K> {
Sole(AckSender<K>),
Joined {
key: K,
shares: Vec<Share<K>>,
},
}
impl<K> Custody<K> {
#[inline]
#[must_use]
pub const fn sole(ack: AckSender<K>) -> Self {
Self::Sole(ack)
}
#[inline]
#[must_use]
pub const fn joined(key: K, shares: Vec<Share<K>>) -> Self {
Self::Joined { key, shares }
}
pub fn send<I>(self, answer: Ack<K, I>) -> bool
where
K: Eq + Hash,
I: core::any::Any + Clone + Send + Sync,
{
match self {
Self::Sole(ack) => ack.send(answer),
Self::Joined { key, shares } => {
let Ack {
released,
worker,
lifecycle,
receipts: _,
} = answer;
let took = released.contains(&key);
let mut answered = false;
for share in shares {
let Share { owing, member } = share;
let mut owed = owing.0.lock().unwrap_or_else(|held| held.into_inner());
if took {
owed.release(member);
} else {
owed.withhold(&member);
}
if owed.is_complete() {
answered |= owed.settle(worker.clone(), lifecycle.clone());
}
}
answered
}
}
}
pub fn fate<M>(self, released: HashSet<K>, worker: impl Into<Utf8Bytes>, fate: Fate<M>) -> bool
where
K: Eq + Hash,
M: Any + Clone + Send + Sync,
{
let worker = worker.into();
match self {
Self::Sole(ack) => ack.fate(released, worker, fate),
Self::Joined { shares, .. } => {
let mut answered = false;
for share in shares {
let Share { owing, member } = share;
let mut owed = owing.0.lock().unwrap_or_else(|held| held.into_inner());
owed.release(member);
if owed.is_complete() {
answered |= owed.settle_fate(worker.clone(), fate.clone());
}
}
answered
}
}
}
}
#[derive(Debug)]
pub struct Owing<K>(Arc<Mutex<Owed<K>>>);
impl<K> Owing<K> {
#[must_use]
pub fn open(keys: impl IntoIterator<Item = K>, ack: Option<Custody<K>>) -> Self
where
K: Eq + Hash,
{
Self(Arc::new(Mutex::new(Owed::open(keys, ack))))
}
#[inline]
#[must_use]
pub fn share(&self, member: K) -> Share<K> {
Share {
owing: Self(Arc::clone(&self.0)),
member,
}
}
#[must_use]
pub fn held(&self) -> usize {
self
.0
.lock()
.unwrap_or_else(|held| held.into_inner())
.held()
}
#[must_use]
pub fn is_settled(&self) -> bool {
self
.0
.lock()
.unwrap_or_else(|held| held.into_inner())
.is_settled()
}
}
#[derive(Debug)]
pub struct Share<K> {
owing: Owing<K>,
member: K,
}
#[derive(Debug)]
pub struct AckSender<K> {
tx: flume::Sender<Settled<K>>,
}
impl<K> AckSender<K> {
#[inline]
pub fn send<I>(self, ack: Ack<K, I>) -> bool
where
I: core::any::Any + Send + Sync,
{
let settled = Settled {
released: ack.released,
worker: ack.worker,
observation: ack.lifecycle.erase(),
message: None,
receipts: ack.receipts,
};
self.tx.send(settled).is_ok()
}
#[inline]
pub fn fate<M>(self, released: HashSet<K>, worker: impl Into<Utf8Bytes>, fate: Fate<M>) -> bool
where
M: Any + Send + Sync,
{
let (observation, message) = fate.erase();
let settled = Settled {
released,
worker: worker.into(),
observation,
message: Some(Box::new(message)),
receipts: None,
};
self.tx.send(settled).is_ok()
}
}
#[derive(Debug)]
pub struct AckReceiver<K> {
rx: flume::Receiver<Settled<K>>,
}
impl<K> AckReceiver<K> {
#[inline]
pub fn take(&self) -> Answer<K> {
match self.rx.try_recv() {
Ok(settled) => Answer::Settled(settled),
Err(flume::TryRecvError::Empty) => Answer::Waiting,
Err(flume::TryRecvError::Disconnected) => Answer::HungUp,
}
}
#[inline]
pub fn settled(self) -> Result<Settled<K>, Unsettled> {
self.rx.recv().map_err(|_| Unsettled::HungUp)
}
#[inline]
pub fn settled_within(self, deadline: Duration) -> Result<Settled<K>, Unsettled> {
self.rx.recv_timeout(deadline).map_err(|error| match error {
flume::RecvTimeoutError::Timeout => Unsettled::TimedOut,
flume::RecvTimeoutError::Disconnected => Unsettled::HungUp,
})
}
#[inline]
pub async fn settled_async(self) -> Result<Settled<K>, Unsettled> {
self.rx.recv_async().await.map_err(|_| Unsettled::HungUp)
}
}
#[derive(Debug, derive_more::IsVariant)]
pub enum Answer<K> {
Settled(Settled<K>),
Waiting,
HungUp,
}
#[inline]
#[must_use]
pub fn ack_channel<K>() -> (AckSender<K>, AckReceiver<K>) {
let (tx, rx) = flume::bounded(1);
(AckSender { tx }, AckReceiver { rx })
}
#[cfg(test)]
mod tests;