use super::{
queue::{Origin, Queued, enqueue, propagation},
record::ChannelRaw,
};
use crate::{
error::{BoxError, Error},
message::Delivery,
shutdown::CancellationToken,
source::{Receive, ReceiveError, Source},
};
use tokio::sync::{mpsc, oneshot};
pub struct ChannelSender<T> {
sender: mpsc::Sender<Queued<T>>,
}
impl<T> Clone for ChannelSender<T> {
fn clone(&self) -> Self {
Self {
sender: self.sender.clone(),
}
}
}
impl<T> ChannelSender<T> {
pub async fn send(&self, value: T) -> Result<(), Error> {
let permit = self
.sender
.reserve()
.await
.map_err(|_| Error::closed("channel receiving end has stopped"))?;
let (done, _) = oneshot::channel();
permit.send(Queued {
value,
done,
abandoned: CancellationToken::new(),
propagation: propagation(),
origin: Origin::default(),
});
Ok(())
}
pub async fn send_and_wait(&self, value: T) -> Result<(), Error> {
enqueue(&self.sender, value, Origin::default())
.await?
.wait()
.await
.map_err(|error| Error::unbox(error, "channel delivery failed"))
}
}
pub struct ChannelSource<T> {
pub(super) receiver: mpsc::Receiver<Queued<T>>,
pub(super) stops_on_shutdown: bool,
}
impl<T> ChannelSource<T> {
pub fn bounded(capacity: usize) -> (ChannelSender<T>, Self) {
let (sender, receiver) = mpsc::channel(capacity);
(
ChannelSender { sender },
Self {
receiver,
stops_on_shutdown: true,
},
)
}
}
impl<T: Clone + Send + Sync + 'static> Source for ChannelSource<T> {
type Message = Delivery<T, ChannelRaw>;
async fn receive(&mut self) -> Result<Receive<Self::Message>, ReceiveError> {
loop {
let Some(queued) = self.receiver.recv().await else {
return Ok(Receive::End);
};
if queued.abandoned.is_cancelled() {
continue;
}
let Queued {
value,
done,
abandoned,
propagation,
origin,
} = queued;
let mut delivery = Delivery::new(value, move || async move {
let _ = done.send(());
Ok(())
})
.with_revocation(abandoned)
.with_propagation_fields(propagation);
if let Some(key) = origin.ordering_key {
delivery = delivery.with_ordering_key(key);
}
return Ok(Receive::Message(delivery.with_raw(origin.raw)));
}
}
fn stops_on_shutdown(&self) -> bool {
self.stops_on_shutdown
}
async fn close(&mut self) -> Result<(), BoxError> {
self.receiver.close();
Ok(())
}
}