pub mod mock;
pub mod remote;
use std::sync::{
Arc,
atomic::{AtomicU64, AtomicUsize, Ordering},
};
pub use mock::MockAdapter;
pub use remote::RemoteAdapter;
use crate::{
overflow,
ports::{MarketEventStream, OverflowPolicy, PortError},
proto::{common, market},
};
#[must_use]
pub fn market_event_key(event: &market::MarketDataEvent) -> String {
let channel = match event.event.as_ref() {
Some(market::market_data_event::Event::Ticker(_)) => "ticker",
Some(market::market_data_event::Event::Orderbook(_)) => "book",
Some(market::market_data_event::Event::Trade(_)) => "trade",
Some(market::market_data_event::Event::Ohlcv(_)) => "ohlcv",
None => "none",
};
let symbol = match event.event.as_ref() {
Some(market::market_data_event::Event::Ticker(t)) => t.symbol.clone(),
Some(market::market_data_event::Event::Orderbook(b)) => b.symbol.clone(),
Some(market::market_data_event::Event::Trade(t)) => t.symbol.clone(),
_ => String::new(),
};
format!("{channel}:{symbol}")
}
pub fn poll_market_data<F, Fut>(
req: market::StreamMarketDataRequest,
policy: OverflowPolicy,
fetcher: F,
) -> MarketEventStream
where
F: FnMut(market::StreamChannel, common::ExchangeId, String, Arc<AtomicU64>) -> Fut
+ Send
+ 'static
+ Clone,
Fut: std::future::Future<Output = Result<Option<market::MarketDataEvent>, PortError>>
+ Send
+ 'static,
{
const POLL_INTERVAL_MS: u64 = 1_000;
const BUFFER_CAP: usize = 16;
let seq = Arc::new(AtomicU64::new(0));
let (tx, rx) = overflow::policy_channel(BUFFER_CAP, policy, market_event_key);
let Some(default_exchange) = req.exchange_id.as_option().cloned() else {
tx.close();
return rx;
};
let live_tasks = Arc::new(AtomicUsize::new(0));
for sub in req.subscriptions {
let channel = match sub.channel {
buffa::EnumValue::Known(c) => c,
buffa::EnumValue::Unknown(_) => market::StreamChannel::Unspecified,
};
if sub.symbol.is_empty() {
continue;
}
let exchange_id = default_exchange.clone();
let tx = tx.clone();
let seq = Arc::clone(&seq);
let live_tasks = Arc::clone(&live_tasks);
let symbol = sub.symbol;
let mut fetcher = fetcher.clone();
live_tasks.fetch_add(1, Ordering::Relaxed);
tokio::spawn(async move {
let mut ticker =
tokio::time::interval(std::time::Duration::from_millis(POLL_INTERVAL_MS));
loop {
if tx.is_closed() {
break;
}
ticker.tick().await;
if tx.is_closed() {
break;
}
match fetcher(channel, exchange_id.clone(), symbol.clone(), Arc::clone(&seq)).await
{
Ok(Some(event)) => {
if !tx.send(event).await {
break;
}
}
Ok(None) => {}
Err(err) => {
tracing::warn!(error = %err, symbol = %symbol, "market poll failed");
}
}
}
if live_tasks.fetch_sub(1, Ordering::AcqRel) == 1 {
tx.close();
}
});
}
if live_tasks.load(Ordering::Acquire) == 0 {
tx.close();
}
rx
}
#[cfg(test)]
mod tests {
use proptest::prelude::*;
use super::*;
type Fetch = futures_util::future::BoxFuture<
'static,
Result<Option<market::MarketDataEvent>, PortError>,
>;
#[test]
fn exchange_id_carries_both_the_venue_and_the_label() {
let id = crate::ports::exchange_id("binance", "sub-1");
assert_eq!(id.id, "binance");
assert_eq!(id.label, "sub-1");
}
#[test]
fn an_empty_exchange_id_is_preserved() {
let id = crate::ports::exchange_id("", "");
assert!(id.id.is_empty());
assert!(id.label.is_empty());
}
fn ticker_event(symbol: &str) -> market::MarketDataEvent {
market::MarketDataEvent {
event: Some(market::market_data_event::Event::Ticker(Box::new(market::Ticker {
symbol: symbol.into(),
..Default::default()
}))),
..Default::default()
}
}
fn book_event(symbol: &str) -> market::MarketDataEvent {
market::MarketDataEvent {
event: Some(market::market_data_event::Event::Orderbook(Box::new(market::OrderBook {
symbol: symbol.into(),
..Default::default()
}))),
..Default::default()
}
}
fn trade_event(symbol: &str) -> market::MarketDataEvent {
market::MarketDataEvent {
event: Some(market::market_data_event::Event::Trade(Box::new(market::PublicTrade {
symbol: symbol.into(),
..Default::default()
}))),
..Default::default()
}
}
fn ohlcv_event() -> market::MarketDataEvent {
market::MarketDataEvent {
event: Some(market::market_data_event::Event::Ohlcv(Box::default())),
..Default::default()
}
}
#[test]
fn the_coalesce_key_is_channel_and_symbol() {
assert_eq!(market_event_key(&ticker_event("BTC/USDT")), "ticker:BTC/USDT");
assert_eq!(market_event_key(&book_event("BTC/USDT")), "book:BTC/USDT");
assert_eq!(market_event_key(&trade_event("ETH/USDT")), "trade:ETH/USDT");
}
#[test]
fn the_coalesce_key_falls_back_for_symbolless_variants() {
assert_eq!(market_event_key(&ohlcv_event()), "ohlcv:");
assert_eq!(market_event_key(&market::MarketDataEvent::default()), "none:");
}
#[test]
fn distinct_channels_on_one_symbol_do_not_collide() {
let ticker = market_event_key(&ticker_event("X"));
let book = market_event_key(&book_event("X"));
let trade = market_event_key(&trade_event("X"));
assert_ne!(ticker, book);
assert_ne!(ticker, trade);
assert_ne!(book, trade);
}
#[test]
fn the_coalesce_key_is_stable_for_the_same_event() {
assert_eq!(market_event_key(&ticker_event("X")), market_event_key(&ticker_event("X")));
}
fn request(symbols: &[&str]) -> market::StreamMarketDataRequest {
market::StreamMarketDataRequest {
exchange_id: buffa::MessageField::some(crate::ports::exchange_id("mock", "")),
subscriptions: symbols
.iter()
.map(|symbol| market::StreamSubscription {
channel: buffa::EnumValue::Known(market::StreamChannel::Ticker),
symbol: (*symbol).to_string(),
..Default::default()
})
.collect(),
..Default::default()
}
}
fn ticker_fetcher()
-> impl FnMut(market::StreamChannel, common::ExchangeId, String, Arc<AtomicU64>) -> Fetch
+ Send
+ Clone
+ 'static {
move |_, _, symbol, _| {
Box::pin(async move {
Ok(Some(market::MarketDataEvent {
event: Some(market::market_data_event::Event::Ticker(Box::new(
market::Ticker { symbol, ..Default::default() },
))),
..Default::default()
}))
})
}
}
async fn expect_silence(rx: &mut tokio::sync::mpsc::Receiver<market::MarketDataEvent>) -> bool {
let idle = std::time::Duration::from_millis(250);
tokio::time::timeout(idle, rx.recv()).await.is_err()
}
async fn expect_end_of_stream(rx: &mut tokio::sync::mpsc::Receiver<market::MarketDataEvent>) {
let idle = std::time::Duration::from_millis(250);
let outcome = tokio::time::timeout(idle, rx.recv()).await;
assert!(outcome.is_ok(), "the stream must end, not stay open with nothing to report");
let received = outcome.expect("the timeout outcome was just checked");
assert!(received.is_none(), "an unproducible request must emit no event: {received:?}");
}
#[tokio::test]
async fn a_request_without_an_exchange_id_yields_an_empty_stream() {
let req = market::StreamMarketDataRequest {
exchange_id: buffa::MessageField::none(),
subscriptions: vec![market::StreamSubscription {
channel: buffa::EnumValue::Known(market::StreamChannel::Ticker),
symbol: "BTC/USDT".into(),
..Default::default()
}],
..Default::default()
};
let mut rx = poll_market_data(req, OverflowPolicy::DropOldest, ticker_fetcher());
expect_end_of_stream(&mut rx).await;
}
#[tokio::test]
async fn subscriptions_without_a_symbol_are_skipped() {
let mut rx = poll_market_data(request(&[""]), OverflowPolicy::DropOldest, ticker_fetcher());
expect_end_of_stream(&mut rx).await;
}
#[tokio::test]
async fn a_request_with_no_subscriptions_yields_an_empty_stream() {
let mut rx = poll_market_data(request(&[]), OverflowPolicy::DropOldest, ticker_fetcher());
expect_end_of_stream(&mut rx).await;
}
#[tokio::test]
async fn a_polled_subscription_delivers_events() {
let mut rx =
poll_market_data(request(&["BTC/USDT"]), OverflowPolicy::DropOldest, ticker_fetcher());
let event = rx.recv().await.expect("the first tick delivers an event");
assert!(
matches!(event.event, Some(market::market_data_event::Event::Ticker(_))),
"got a non-ticker event"
);
}
#[tokio::test]
async fn a_none_result_is_not_forwarded() {
let fetcher = move |_, _, _, _| Box::pin(async { Ok(None) }) as Fetch;
let mut rx = poll_market_data(request(&["BTC/USDT"]), OverflowPolicy::DropOldest, fetcher);
assert!(expect_silence(&mut rx).await, "Ok(None) must not become an event");
}
#[tokio::test]
async fn a_poll_error_does_not_close_the_stream() {
let fetcher = move |_, _, _, _| {
Box::pin(async { Err(PortError::Transport("venue down".into())) }) as Fetch
};
let mut rx = poll_market_data(request(&["BTC/USDT"]), OverflowPolicy::DropOldest, fetcher);
assert!(expect_silence(&mut rx).await, "an errored poll delivers nothing");
assert!(!rx.is_closed(), "an errored poll must not close the channel");
}
#[tokio::test]
async fn distinct_symbols_are_polled_independently() {
let mut rx =
poll_market_data(request(&["A", "B"]), OverflowPolicy::Coalesce, ticker_fetcher());
let mut seen = Vec::new();
while seen.len() < 2 {
let event = rx.recv().await.expect("both subscriptions deliver");
let Some(market::market_data_event::Event::Ticker(ticker)) = event.event else {
continue;
};
seen.push(ticker.symbol);
}
seen.sort();
assert_eq!(seen, vec!["A".to_string(), "B".to_string()]);
}
#[tokio::test(start_paused = true)]
async fn the_poll_loop_stops_once_the_client_drops_the_receiver() {
let polls = Arc::new(AtomicU64::new(0));
let counter = Arc::clone(&polls);
let fetcher = move |_, _, _, _| {
let counter = Arc::clone(&counter);
Box::pin(async move {
counter.fetch_add(1, Ordering::Relaxed);
Ok(None)
}) as Fetch
};
let rx = poll_market_data(request(&["BTC/USDT"]), OverflowPolicy::DropOldest, fetcher);
tokio::time::advance(std::time::Duration::from_secs(5)).await;
for _ in 0..4 {
tokio::task::yield_now().await;
}
let running = polls.load(Ordering::Acquire);
assert!(running > 0, "test setup: the poll task must have polled at least once");
drop(rx);
tokio::time::advance(std::time::Duration::from_secs(10)).await;
for _ in 0..8 {
tokio::task::yield_now().await;
}
assert_eq!(
polls.load(Ordering::Acquire),
running,
"a dropped receiver must end the poll loop instead of leaking a poller"
);
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(256))]
#[test]
fn the_coalesce_key_is_always_channel_colon_symbol(symbol in "[a-zA-Z0-9/_.:-]{0,24}") {
let key = market_event_key(&ticker_event(&symbol));
let (channel, rest) = key.split_once(':').expect("the key contains a colon");
prop_assert_eq!(channel, "ticker");
prop_assert_eq!(rest, symbol.as_str());
}
#[test]
fn distinct_symbols_never_share_a_coalesce_key(
a in "[a-z0-9]{1,8}",
b in "[a-z0-9]{1,8}",
) {
prop_assume!(a != b);
prop_assert_ne!(
market_event_key(&ticker_event(&a)),
market_event_key(&ticker_event(&b))
);
prop_assert_ne!(market_event_key(&book_event(&a)), market_event_key(&book_event(&b)));
prop_assert_ne!(
market_event_key(&trade_event(&a)),
market_event_key(&trade_event(&b))
);
}
#[test]
fn exchange_id_never_transforms_its_inputs(
id in "[a-z0-9_-]{0,16}",
label in "[a-z0-9_-]{0,16}",
) {
let built = crate::ports::exchange_id(&id, &label);
prop_assert_eq!(built.id.as_str(), id.as_str());
prop_assert_eq!(built.label.as_str(), label.as_str());
}
}
}