use std::{
collections::VecDeque,
hash::Hash,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
use tokio::sync::{Mutex, Notify, mpsc};
use crate::ports::OverflowPolicy;
pub use crate::ports::{
DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT, OVERFLOW_BALANCES, OVERFLOW_OHLCV, OVERFLOW_ORDERBOOK,
OVERFLOW_ORDERS, OVERFLOW_POSITIONS, OVERFLOW_TICKER, OVERFLOW_TRADES, page_limit_or_default,
};
struct PipeState<T, K> {
tx: mpsc::Sender<T>,
buf: Mutex<VecDeque<(K, T)>>,
cap: usize,
policy: OverflowPolicy,
key_fn: Arc<dyn Fn(&T) -> K + Send + Sync>,
notify: Notify,
source_closed: AtomicBool,
}
impl<T, K> PipeState<T, K>
where
T: Send + 'static,
K: Eq + Hash + Send + 'static,
{
async fn forward_loop(self: Arc<Self>) {
loop {
if self.source_closed.load(Ordering::Acquire) {
let drained: VecDeque<(K, T)> = std::mem::take(&mut *self.buf.lock().await);
for (_, item) in drained {
if self.tx.send(item).await.is_err() {
return;
}
}
return;
}
let items: VecDeque<(K, T)> = {
let mut buf = self.buf.lock().await;
if buf.is_empty() { VecDeque::new() } else { std::mem::take(&mut *buf) }
};
if !items.is_empty() {
for (_, item) in items {
if self.tx.send(item).await.is_err() {
return;
}
}
continue;
}
self.notify.notified().await;
}
}
}
pub struct PolicySender<T, K> {
state: Arc<PipeState<T, K>>,
}
impl<T, K> Clone for PolicySender<T, K> {
fn clone(&self) -> Self {
Self { state: Arc::clone(&self.state) }
}
}
impl<T, K> PolicySender<T, K>
where
T: Send + 'static,
K: Eq + Hash + Send + 'static,
{
pub async fn send(&self, item: T) -> bool {
match self.state.policy {
OverflowPolicy::Block => {
self.state.tx.send(item).await.is_ok()
}
OverflowPolicy::DropOldest | OverflowPolicy::Coalesce => {
if self.state.tx.is_closed() {
return false;
}
let key = (self.state.key_fn)(&item);
{
let mut buf = self.state.buf.lock().await;
debug_assert!(self.state.cap <= 1024, "coalesce cap unexpectedly large");
if self.state.policy == OverflowPolicy::Coalesce {
if let Some(slot) = buf.iter_mut().find(|(k, _)| *k == key) {
slot.1 = item;
} else {
buf.push_back((key, item));
while buf.len() > self.state.cap {
buf.pop_front();
}
}
} else {
buf.push_back((key, item));
while buf.len() > self.state.cap {
buf.pop_front();
}
}
}
self.state.notify.notify_one();
true
}
}
}
pub fn close(&self) {
self.state.source_closed.store(true, Ordering::Release);
self.state.notify.notify_one();
}
pub fn is_closed(&self) -> bool {
self.state.tx.is_closed()
}
}
pub fn policy_channel<T, K>(
cap: usize,
policy: OverflowPolicy,
key_of: impl Fn(&T) -> K + Send + Sync + 'static,
) -> (PolicySender<T, K>, mpsc::Receiver<T>)
where
T: Send + 'static,
K: Eq + Hash + Send + 'static,
{
let cap = cap.max(1);
let (tx, rx) = mpsc::channel(cap);
let state = Arc::new(PipeState {
tx,
buf: Mutex::new(VecDeque::new()),
cap,
policy,
key_fn: Arc::new(key_of),
notify: Notify::new(),
source_closed: AtomicBool::new(false),
});
tokio::spawn(state.clone().forward_loop());
(PolicySender { state }, rx)
}
#[cfg(test)]
mod tests {
use super::*;
async fn drive<T, K>(
cap: usize,
policy: OverflowPolicy,
key_of: impl Fn(&T) -> K + Send + Sync + 'static,
produce: impl FnOnce(PolicySender<T, K>) -> futures_util::future::BoxFuture<'static, ()>
+ Send
+ 'static,
) -> mpsc::Receiver<T>
where
T: Send + 'static,
K: Eq + Hash + Send + 'static,
{
let (tx, rx) = policy_channel(cap, policy, key_of);
tokio::spawn(async move {
produce(tx.clone()).await;
tx.close();
});
rx
}
#[tokio::test]
async fn block_policy_never_drops() {
let mut rx = drive(
2,
OverflowPolicy::Block,
|v| *v,
|tx| {
Box::pin(async move {
for v in 0..8u64 {
tx.send(v).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![0, 1, 2, 3, 4, 5, 6, 7]);
}
#[tokio::test]
async fn drop_oldest_keeps_newest_window() {
let mut rx = drive(
3,
OverflowPolicy::DropOldest,
|v| *v,
|tx| {
Box::pin(async move {
for v in 0..10u64 {
tx.send(v).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![7, 8, 9], "only the newest `cap` items survive");
}
#[tokio::test]
async fn coalesce_keeps_newest_per_key_in_arrival_order() {
let mut rx = drive(
4,
OverflowPolicy::Coalesce,
|item: &(char, u32)| item.0,
|tx| {
Box::pin(async move {
for &(k, v) in &[('a', 1), ('b', 1), ('a', 2), ('a', 3), ('c', 9)] {
tx.send((k, v)).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![('a', 3), ('b', 1), ('c', 9)]);
}
#[tokio::test]
async fn close_drains_buffer_before_closing_receiver() {
let mut rx = drive(
4,
OverflowPolicy::DropOldest,
|v| *v,
|tx| {
Box::pin(async move {
tx.send(1).await;
tx.send(2).await;
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![1, 2]);
}
#[tokio::test]
async fn a_zero_capacity_is_clamped_to_one() {
let mut rx = drive(
0,
OverflowPolicy::DropOldest,
|v| *v,
|tx| {
Box::pin(async move {
for v in 0..6u64 {
tx.send(v).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![5], "cap 0 behaves as cap 1: only the newest survives");
}
#[tokio::test]
async fn block_policy_with_a_clamped_capacity_still_delivers_everything() {
let mut rx = drive(
0,
OverflowPolicy::Block,
|v| *v,
|tx| {
Box::pin(async move {
for v in 0..4u64 {
tx.send(v).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![0, 1, 2, 3]);
}
#[tokio::test]
async fn coalesce_drops_the_oldest_key_when_distinct_keys_exceed_cap() {
let mut rx = drive(
2,
OverflowPolicy::Coalesce,
|item: &(char, u32)| item.0,
|tx| {
Box::pin(async move {
for &(k, v) in &[('a', 1), ('b', 2), ('c', 3), ('d', 4)] {
tx.send((k, v)).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![('c', 3), ('d', 4)], "the two newest keys survive");
}
#[tokio::test]
async fn coalesce_refreshing_a_key_does_not_consume_capacity() {
let mut rx = drive(
2,
OverflowPolicy::Coalesce,
|item: &(char, u32)| item.0,
|tx| {
Box::pin(async move {
for &(k, v) in &[('a', 1), ('b', 1), ('a', 2), ('a', 3), ('a', 4)] {
tx.send((k, v)).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![('a', 4), ('b', 1)], "key 'a' was refreshed, not duplicated");
}
#[tokio::test]
async fn coalesce_on_one_key_keeps_only_the_latest() {
let mut rx = drive(
8,
OverflowPolicy::Coalesce,
|item: &(char, u32)| item.0,
|tx| {
Box::pin(async move {
for v in 1..=20u32 {
tx.send(('x', v)).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![('x', 20)]);
}
#[tokio::test]
async fn drop_oldest_keeps_every_item_even_when_keys_repeat() {
let mut rx = drive(
3,
OverflowPolicy::DropOldest,
|item: &(char, u32)| item.0,
|tx| {
Box::pin(async move {
for v in 1..=10u32 {
tx.send(('x', v)).await;
}
})
},
)
.await;
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(
seen,
vec![('x', 8), ('x', 9), ('x', 10)],
"keys do not dedupe under DropOldest"
);
}
#[tokio::test]
async fn is_closed_follows_the_downstream_receiver() {
let (tx, rx) = policy_channel::<u64, u64>(2, OverflowPolicy::Block, |v| *v);
assert!(!tx.is_closed(), "a live receiver is not closed");
drop(rx);
for _ in 0..100 {
if tx.is_closed() {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(5)).await;
}
assert!(tx.is_closed(), "dropping the receiver must close the sender");
}
#[tokio::test]
async fn closing_an_empty_pipe_terminates_the_stream() {
let (tx, mut rx) = policy_channel::<u64, u64>(2, OverflowPolicy::DropOldest, |v| *v);
tx.close();
drop(tx);
let idle = std::time::Duration::from_secs(5);
let closed = tokio::time::timeout(idle, rx.recv()).await;
assert!(matches!(closed, Ok(None)), "close with no items yields an empty stream");
}
#[tokio::test]
async fn clones_share_one_pipe() {
let (tx, mut rx) = policy_channel::<u64, u64>(4, OverflowPolicy::DropOldest, |v| *v);
let other = tx.clone();
other.send(1).await;
other.send(2).await;
tx.close();
drop(tx);
drop(other);
let mut seen = Vec::new();
while let Some(v) = rx.recv().await {
seen.push(v);
}
assert_eq!(seen, vec![1, 2], "items sent through either clone arrive in order");
}
#[tokio::test]
async fn closing_twice_is_harmless() {
let (tx, mut rx) = policy_channel::<u64, u64>(2, OverflowPolicy::Block, |v| *v);
tx.close();
tx.close();
drop(tx);
let idle = std::time::Duration::from_secs(5);
let closed = tokio::time::timeout(idle, rx.recv()).await;
assert!(matches!(closed, Ok(None)), "a repeated close must still terminate");
}
}