use super::{
queue::{Origin, Queued, enqueue},
record::{ChannelOutput, ChannelRaw},
};
use crate::{
error::{BoxError, Error},
message::SourceMessage,
sink::{Completion, Sink},
};
use std::sync::{Mutex, PoisonError};
use tokio::sync::mpsc;
pub struct ChannelSink<T> {
sender: Mutex<Option<mpsc::Sender<Queued<T>>>>,
}
impl<T> ChannelSink<T> {
pub fn bounded(capacity: usize) -> (Self, ChannelReceiver<T>) {
let (sender, receiver) = mpsc::channel(capacity);
(Self::new(sender), ChannelReceiver { receiver })
}
pub(super) fn new(sender: mpsc::Sender<Queued<T>>) -> Self {
Self {
sender: Mutex::new(Some(sender)),
}
}
fn sender(&self) -> Option<mpsc::Sender<Queued<T>>> {
self.sender
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
}
impl<T> Clone for ChannelSink<T> {
fn clone(&self) -> Self {
Self {
sender: Mutex::new(self.sender()),
}
}
}
impl<T: Clone + Send + Sync + 'static> Sink<T> for ChannelSink<T> {
type Prepared = ChannelOutput<T>;
fn prepare(&self, value: T) -> Result<ChannelOutput<T>, BoxError> {
Ok(value.into())
}
fn prepare_from<M: SourceMessage>(
&self,
value: T,
delivery: &M,
) -> Result<ChannelOutput<T>, BoxError> {
Ok(ChannelOutput {
value,
origin: Origin {
ordering_key: delivery.ordering_key(),
raw: ChannelRaw::of(delivery.raw()),
},
})
}
async fn publish(&self, output: &ChannelOutput<T>) -> Result<(), BoxError> {
self.submit(output).await?.wait().await
}
async fn submit(&self, output: &ChannelOutput<T>) -> Result<Completion, BoxError> {
let sender = self
.sender()
.ok_or_else(|| Error::closed("channel sink is closed"))?;
Ok(enqueue(&sender, output.value.clone(), output.origin.clone()).await?)
}
async fn close(&self) -> Result<(), BoxError> {
self.sender
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
Ok(())
}
}
pub struct ChannelReceiver<T> {
receiver: mpsc::Receiver<Queued<T>>,
}
impl<T> ChannelReceiver<T> {
pub async fn recv(&mut self) -> Option<T> {
loop {
let queued = self.receiver.recv().await?;
if queued.abandoned.is_cancelled() {
continue;
}
let _ = queued.done.send(());
return Some(queued.value);
}
}
pub fn close(&mut self) {
self.receiver.close();
}
}