use super::{record::ChannelRaw, sink::ChannelSink, source::ChannelSource};
use crate::error::Error;
use crate::{message::OrderingKey, shutdown::CancellationToken, sink::Completion};
use tokio::sync::{mpsc, oneshot};
pub(super) struct Queued<T> {
pub(super) value: T,
pub(super) done: oneshot::Sender<()>,
pub(super) abandoned: CancellationToken,
pub(super) propagation: Vec<(String, String)>,
pub(super) origin: Origin,
}
#[derive(Clone, Default)]
pub(super) struct Origin {
pub(super) ordering_key: Option<OrderingKey>,
pub(super) raw: ChannelRaw,
}
pub(super) fn propagation() -> Vec<(String, String)> {
#[cfg(feature = "opentelemetry")]
return crate::telemetry::current_fields();
#[cfg(not(feature = "opentelemetry"))]
Vec::new()
}
struct AbandonOnDrop(Option<CancellationToken>);
impl AbandonOnDrop {
fn disarm(mut self) {
self.0 = None;
}
}
impl Drop for AbandonOnDrop {
fn drop(&mut self) {
if let Some(token) = self.0.take() {
token.cancel();
}
}
}
pub fn channel<T>(capacity: usize) -> (ChannelSink<T>, ChannelSource<T>) {
let (sender, receiver) = mpsc::channel(capacity);
(
ChannelSink::new(sender),
ChannelSource {
receiver,
stops_on_shutdown: false,
},
)
}
pub(super) async fn enqueue<T>(
sender: &mpsc::Sender<Queued<T>>,
value: T,
origin: Origin,
) -> Result<Completion, Error> {
let permit = sender
.reserve()
.await
.map_err(|_| Error::closed("channel receiving end has stopped"))?;
let (done, completed) = oneshot::channel();
let abandoned = CancellationToken::new();
let guard = AbandonOnDrop(Some(abandoned.clone()));
permit.send(Queued {
value,
done,
abandoned,
propagation: propagation(),
origin,
});
Ok(Completion::pending(async move {
let result = completed.await;
guard.disarm();
result.map_err(|_| {
Error::closed(
"channel receiving end stopped before taking responsibility for the value",
)
.into()
})
}))
}