use citadel_io::tokio::sync::mpsc::{Receiver, Sender};
use citadel_io::Mutex;
use futures::Stream;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::pin::Pin;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::task::{Context, Poll};
pub struct TrackedCallbackChannel<T, R> {
inner: Arc<TrackedCallbackChannelInner<T, R>>,
}
impl<T, R> Clone for TrackedCallbackChannel<T, R> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
pub type TrackedCallbackError = citadel_io::NetworkError;
const NO_RESPONSE: u64 = 0;
struct TrackedCallbackChannelInner<T, R> {
map: Mutex<HashMap<u64, citadel_io::tokio::sync::oneshot::Sender<R>>>,
to_channel: Sender<TrackedCallbackChannelPayload<T, R>>,
id: AtomicU64,
}
pub struct TrackedCallbackChannelPayload<T, R> {
id: u64,
pub payload: T,
_pd: PhantomData<R>,
}
impl<T, R> TrackedCallbackChannelPayload<T, R> {
pub fn new(&self, payload: R) -> TrackedCallbackChannelPayload<R, T> {
TrackedCallbackChannelPayload {
id: self.id,
payload,
_pd: Default::default(),
}
}
pub fn expects_response(&self) -> bool {
self.id != NO_RESPONSE
}
}
impl<T: Send + Sync, R: Send + Sync> TrackedCallbackChannel<T, R> {
pub fn new(buffer: usize) -> (Self, CallbackReceiver<T, R>) {
let (to_channel, from_channel) = citadel_io::tokio::sync::mpsc::channel(buffer);
(
Self {
inner: Arc::new(TrackedCallbackChannelInner {
to_channel,
map: Mutex::new(Default::default()),
id: AtomicU64::new(1),
}),
},
CallbackReceiver {
inner: from_channel,
},
)
}
pub async fn send(&self, payload: T) -> Result<R, TrackedCallbackError> {
let (rx, id) = {
let (tx, rx) = citadel_io::tokio::sync::oneshot::channel();
let next_value = self.inner.id.fetch_add(1, Ordering::Relaxed);
self.inner.map.lock().insert(next_value, tx);
(rx, next_value)
};
self.inner
.to_channel
.send(TrackedCallbackChannelPayload {
id,
payload,
_pd: Default::default(),
})
.await
.map_err(|_| {
TrackedCallbackError::channel_send("tracked callback channel send failed")
})?;
rx.await.map_err(|_| TrackedCallbackError::channel_recv())
}
pub async fn send_no_callback(&self, payload: T) -> Result<(), TrackedCallbackError> {
self.inner
.to_channel
.send(TrackedCallbackChannelPayload {
id: NO_RESPONSE,
payload,
_pd: Default::default(),
})
.await
.map_err(|_| TrackedCallbackError::channel_send("tracked callback channel send failed"))
}
pub fn try_reply(
&self,
payload: TrackedCallbackChannelPayload<R, T>,
) -> Result<(), TrackedCallbackError> {
let sender = {
self.inner.map.lock().remove(&payload.id).ok_or_else(|| {
TrackedCallbackError::channel_internal("Mapping does not exist for id")
})?
};
sender
.send(payload.payload)
.map_err(|_| TrackedCallbackError::channel_send("tracked callback reply send failed"))
}
}
pub struct CallbackReceiver<T, R> {
inner: Receiver<TrackedCallbackChannelPayload<T, R>>,
}
impl<T, R> Stream for CallbackReceiver<T, R> {
type Item = TrackedCallbackChannelPayload<T, R>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.inner).poll_recv(cx)
}
}
#[cfg(test)]
mod tests {
use crate::sync::tracked_callback_channel::{TrackedCallbackChannel, TrackedCallbackError};
use citadel_io::tokio;
use futures::StreamExt;
#[tokio::test]
async fn test_tracked_callback() {
citadel_logging::setup_log();
let (tx0, mut rx) = TrackedCallbackChannel::<u32, u64>::new(10);
let tx1 = tx0.clone();
const COUNT: u32 = 10000;
let server = async move {
while let Some(val) = rx.next().await {
assert!(val.expects_response());
let input = val.payload;
tx0.try_reply(val.new((input + 1) as u64)).unwrap();
if input == COUNT {
return;
}
}
};
let client = async move {
for x in 0..=COUNT {
assert_eq!(tx1.send(x).await.unwrap(), (x + 1) as u64);
}
};
let server = citadel_io::tokio::spawn(server);
let client = citadel_io::tokio::spawn(client);
let (_, _) = citadel_io::tokio::join!(server, client);
}
#[tokio::test]
async fn test_tracked_callback_no_response() {
citadel_logging::setup_log();
let (tx0, mut rx) = TrackedCallbackChannel::<u32, u64>::new(10);
let tx1 = tx0.clone();
const COUNT: u32 = 10000;
let server = async move {
while let Some(val) = rx.next().await {
assert!(!val.expects_response());
let input = val.payload;
assert!(tx0.try_reply(val.new((input + 1) as u64)).is_err());
if input == COUNT {
return;
}
}
};
let client = async move {
for x in 0..=COUNT {
tx1.send_no_callback(x).await.unwrap();
}
};
let server = citadel_io::tokio::spawn(server);
let client = citadel_io::tokio::spawn(client);
let (_, _) = citadel_io::tokio::join!(server, client);
}
#[test]
fn test_error() {
let err0 = TrackedCallbackError::channel_send("send failed");
let err1 = TrackedCallbackError::channel_recv();
let err2 = TrackedCallbackError::channel_internal("other");
assert_eq!(err0.code, citadel_io::ErrorCode::ChannelSend);
assert_eq!(err1.code, citadel_io::ErrorCode::ChannelRecv);
assert_eq!(err2.code, citadel_io::ErrorCode::ChannelInternal);
let _data = format!("{err0:?} {err1:?} {err2:?}");
}
}