use std::sync::Arc;
use async_trait::async_trait;
use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpStream;
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
use crate::clock::Clock;
use crate::error::{Error, Result};
use crate::types::VenueId;
use crate::venue::{FeedTransport, RawFrame};
pub struct WsTransport {
venue: VenueId,
stream: WebSocketStream<MaybeTlsStream<TcpStream>>,
clock: Arc<dyn Clock>,
}
impl WsTransport {
pub async fn connect(venue: VenueId, url: &str, clock: Arc<dyn Clock>) -> Result<Self> {
let (stream, _response) = tokio_tungstenite::connect_async(url).await?;
Ok(WsTransport {
venue,
stream,
clock,
})
}
}
#[async_trait]
impl FeedTransport for WsTransport {
async fn recv(&mut self) -> Result<Option<RawFrame>> {
loop {
match self.stream.next().await {
Some(Ok(Message::Text(text))) => {
let stamp = self.clock.stamp();
return Ok(Some(RawFrame::new(
self.venue,
text.as_bytes().to_vec(),
stamp,
)));
}
Some(Ok(Message::Binary(bytes))) => {
let stamp = self.clock.stamp();
return Ok(Some(RawFrame::new(self.venue, bytes.to_vec(), stamp)));
}
Some(Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_))) => continue,
Some(Ok(Message::Close(_))) | None => return Ok(None),
Some(Err(e)) => return Err(Error::from(e)),
}
}
}
async fn send_text(&mut self, text: &str) -> Result<()> {
self.stream.send(Message::Text(text.into())).await?;
Ok(())
}
async fn close(&mut self) -> Result<()> {
self.stream.close(None).await?;
Ok(())
}
}