use std::collections::BTreeMap;
use tokio::sync::broadcast;
use tokio::sync::broadcast::error::RecvError;
use tokio::time::timeout;
use crate::common::decimals::{Price, Volume};
use crate::common::errors::{ConnectorError, FixError, TransportError};
use crate::common::ids::SymbolId;
use crate::fix::client::FixClient;
use crate::fix::messages::{
BookSide, BookUpdate, MarketDataRequest, MarketDataSnapshot, MarketDepth, Message,
};
use crate::fix::session::Event;
const REQUEST_PREFIX: &str = "md";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SpotQuote {
pub symbol: SymbolId,
pub bid: Option<Price>,
pub offer: Option<Price>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BookEntry {
pub id: String,
pub side: BookSide,
pub price: Price,
pub size: Option<Volume>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Book {
symbol: SymbolId,
entries: BTreeMap<String, BookEntry>,
}
impl Book {
#[must_use]
pub const fn new(symbol: SymbolId) -> Self {
Self {
symbol,
entries: BTreeMap::new(),
}
}
#[must_use]
pub const fn symbol(&self) -> SymbolId {
self.symbol
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
#[must_use]
pub fn bids(&self) -> Vec<&BookEntry> {
let mut bids = self.side(BookSide::Bid);
bids.sort_by(|a, b| b.price.cmp(&a.price));
bids
}
#[must_use]
pub fn offers(&self) -> Vec<&BookEntry> {
let mut offers = self.side(BookSide::Offer);
offers.sort_by(|a, b| a.price.cmp(&b.price));
offers
}
fn side(&self, side: BookSide) -> Vec<&BookEntry> {
self.entries
.values()
.filter(|entry| entry.side == side)
.collect()
}
pub fn replace(&mut self, snapshot: &MarketDataSnapshot) {
if snapshot.symbol != self.symbol {
return;
}
self.entries.clear();
for (position, entry) in snapshot.entries.iter().enumerate() {
let id = entry
.id
.clone()
.unwrap_or_else(|| format!("{}{position}", entry.side.as_str()));
self.entries.insert(
id.clone(),
BookEntry {
id,
side: entry.side,
price: entry.price,
size: entry.size,
},
);
}
}
pub fn apply(&mut self, update: &BookUpdate) {
match update {
BookUpdate::New {
side,
id,
symbol,
price,
size,
} if *symbol == self.symbol => {
self.entries.insert(
id.clone(),
BookEntry {
id: id.clone(),
side: *side,
price: *price,
size: *size,
},
);
}
BookUpdate::Delete { id, symbol } if *symbol == self.symbol => {
self.entries.remove(id);
}
_ => {}
}
}
}
enum Step {
Snapshot(MarketDataSnapshot),
Changes(Vec<BookUpdate>),
}
#[derive(Debug)]
struct Feed {
client: FixClient,
events: broadcast::Receiver<Event>,
md_req_id: String,
symbol: SymbolId,
depth: MarketDepth,
seq: u64,
ended: bool,
}
impl Feed {
fn request(&self, subscribe: bool) -> Message {
MarketDataRequest {
md_req_id: self.md_req_id.clone(),
subscribe,
depth: self.depth,
symbols: vec![self.symbol],
sides: vec![BookSide::Bid, BookSide::Offer],
}
.into()
}
async fn open(
client: &FixClient,
symbol: SymbolId,
depth: MarketDepth,
) -> Result<Self, ConnectorError> {
let mut feed = Self {
client: client.clone(),
events: client.events(),
md_req_id: client.next_id(REQUEST_PREFIX),
symbol,
depth,
seq: 0,
ended: false,
};
feed.seq = client.send(feed.request(true)).await?;
Ok(feed)
}
fn mine(&self, md_req_id: Option<&str>) -> bool {
md_req_id == Some(self.md_req_id.as_str())
}
async fn step(&mut self) -> Result<Step, ConnectorError> {
if self.ended {
return Err(ConnectorError::Closed);
}
loop {
let inbound = match self.events.recv().await {
Ok(Event::Message(inbound)) => inbound,
Ok(Event::Disconnected(error)) => return Err(error.into()),
Ok(Event::LoggedOut { .. } | Event::Ended) | Err(RecvError::Closed) => {
self.ended = true;
return Err(TransportError::Closed.into());
}
Ok(Event::Reconnected { .. }) => {
self.seq = self.client.send(self.request(true)).await?;
continue;
}
Ok(_) => continue,
Err(RecvError::Lagged(skipped)) => {
return Err(ConnectorError::Lagged { skipped });
}
};
match inbound.message {
Message::MarketDataSnapshot(snapshot)
if self.mine(snapshot.md_req_id.as_deref())
&& snapshot.symbol == self.symbol =>
{
return Ok(Step::Snapshot(snapshot));
}
Message::MarketDataIncremental(changes)
if self.mine(changes.md_req_id.as_deref()) =>
{
return Ok(Step::Changes(changes.entries));
}
Message::MarketDataReject(reject) if reject.md_req_id == self.md_req_id => {
return Err(FixError::MarketDataRejected {
reason: reject.reason,
text: reject.text,
}
.into());
}
Message::Reject(reject) if reject.ref_seq_num == self.seq => {
return Err(FixError::Rejected {
ref_seq_num: self.seq,
tag: reject.ref_tag_id,
reason: reject.reason,
text: reject.text,
}
.into());
}
Message::BusinessReject(reject)
if reject.ref_seq_num == Some(self.seq)
|| reject.ref_id.as_deref() == Some(self.md_req_id.as_str()) =>
{
return Err(FixError::BusinessRejected {
ref_id: reject.ref_id,
reason: reject.reason,
text: reject.text,
}
.into());
}
_ => {}
}
}
}
async fn first(&mut self) -> Result<Step, ConnectorError> {
let limit = self.client.timeout();
timeout(limit, self.step())
.await
.map_err(|_| ConnectorError::Timeout(limit))?
}
async fn close(&self) -> Result<(), ConnectorError> {
self.client.send(self.request(false)).await.map(|_| ())
}
}
#[derive(Debug)]
pub struct SpotStream {
feed: Feed,
last: SpotQuote,
}
impl SpotStream {
#[must_use]
pub const fn symbol(&self) -> SymbolId {
self.feed.symbol
}
#[must_use]
pub const fn last(&self) -> SpotQuote {
self.last
}
fn take(&mut self, step: Step) -> Option<SpotQuote> {
let Step::Snapshot(snapshot) = step else {
return None;
};
let best = |side: BookSide| {
snapshot
.entries
.iter()
.find(|entry| entry.side == side)
.map(|entry| entry.price)
};
self.last = SpotQuote {
symbol: snapshot.symbol,
bid: best(BookSide::Bid),
offer: best(BookSide::Offer),
};
Some(self.last)
}
pub async fn next(&mut self) -> Result<SpotQuote, ConnectorError> {
loop {
let step = self.feed.step().await?;
if let Some(quote) = self.take(step) {
return Ok(quote);
}
}
}
pub async fn unsubscribe(self) -> Result<(), ConnectorError> {
self.feed.close().await
}
}
#[derive(Debug)]
pub struct DepthStream {
feed: Feed,
book: Book,
}
impl DepthStream {
#[must_use]
pub const fn symbol(&self) -> SymbolId {
self.feed.symbol
}
#[must_use]
pub const fn book(&self) -> &Book {
&self.book
}
fn take(&mut self, step: &Step) {
match step {
Step::Snapshot(snapshot) => self.book.replace(snapshot),
Step::Changes(changes) => {
for change in changes {
self.book.apply(change);
}
}
}
}
pub async fn next(&mut self) -> Result<&Book, ConnectorError> {
let step = self.feed.step().await?;
self.take(&step);
Ok(&self.book)
}
pub async fn unsubscribe(self) -> Result<(), ConnectorError> {
self.feed.close().await
}
}
impl FixClient {
pub async fn subscribe_spot(&self, symbol: SymbolId) -> Result<SpotStream, ConnectorError> {
let mut stream = SpotStream {
feed: Feed::open(self, symbol, MarketDepth::Spot).await?,
last: SpotQuote {
symbol,
bid: None,
offer: None,
},
};
loop {
let step = stream.feed.first().await?;
if stream.take(step).is_some() {
return Ok(stream);
}
}
}
pub async fn subscribe_depth(&self, symbol: SymbolId) -> Result<DepthStream, ConnectorError> {
let mut stream = DepthStream {
feed: Feed::open(self, symbol, MarketDepth::Full).await?,
book: Book::new(symbol),
};
let step = stream.feed.first().await?;
stream.take(&step);
Ok(stream)
}
}