use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, Weak};
use std::time::{Duration, Instant};
use futures_util::{SinkExt, StreamExt};
use serde::Deserialize;
use serde_json::{Map, Value, json};
use tokio::sync::{Notify, mpsc, oneshot};
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::http::HeaderValue;
use url::Url;
use crate::amount::Amount;
use crate::client::{Client, check_secure_url};
use crate::error::{Error, Result, WsError};
use crate::models_gen::ErrorCode;
use crate::orderbook::{BookSnapshot, LiveOrderBook};
pub const DEFAULT_WEBSOCKET_URL: &str = "wss://api.cexy.io/api/v1/ws";
pub const SUPPORTED_PROTOCOL_VERSION: i64 = 1;
pub const PRIVATE_CHANNELS: [&str; 5] =
["orders", "balances", "deposits", "withdrawals", "account"];
const MAX_CHANNEL_LENGTH: usize = 64;
const MAX_FRAME_SIZE: usize = 4 << 20;
const KNOWN_EVENT_TYPES: [&str; 14] = [
"ticker.update",
"orderbook.update",
"trade.new",
"market.status",
"order.created",
"order.updated",
"order.cancelled",
"order.filled",
"balance.updated",
"deposit.detected",
"deposit.updated",
"deposit.completed",
"withdrawal.updated",
"session.revoked",
];
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct Welcome {
#[serde(default)]
pub protocol_version: i64,
#[serde(default)]
pub heartbeat_interval_seconds: i64,
#[serde(default)]
pub max_subscriptions: i64,
#[serde(default)]
pub connection_id: String,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct WsFrame {
#[serde(rename = "type")]
pub r#type: String,
#[serde(default)]
pub channel: String,
#[serde(default)]
pub sequence: Option<i64>,
#[serde(default)]
pub timestamp: Option<String>,
#[serde(default)]
pub data: Value,
}
impl WsFrame {
pub fn decode<T: serde::de::DeserializeOwned>(&self) -> Result<T> {
serde_json::from_value(self.data.clone())
.map_err(|e| Error::Decode(format!("{}: {e}", self.r#type)))
}
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct OrderBookUpdate {
#[serde(default)]
pub symbol: String,
#[serde(default)]
pub full: bool,
#[serde(default)]
pub bids: Vec<Vec<Amount>>,
#[serde(default)]
pub asks: Vec<Vec<Amount>>,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct SessionRevoked {
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub reason: String,
#[serde(default)]
pub current: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CloseInfo {
pub code: u16,
pub reason: String,
pub will_reconnect: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SubscribeResult {
pub added: Vec<String>,
pub refused: Vec<String>,
pub already_subscribed: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct AuthResult {
pub user_id: Option<String>,
pub queued: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResyncReason {
ConcurrentModification,
Reconnect,
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum BookEvent {
Updated(BookSnapshot),
Stale {
symbol: String,
expected: i64,
received: i64,
},
Healed {
symbol: String,
},
Resync {
symbol: String,
},
SnapshotFailed {
symbol: String,
message: String,
},
}
#[derive(Debug)]
#[non_exhaustive]
pub enum WsEvent {
Welcome(Welcome),
Event(WsFrame),
Subscribed(Vec<String>),
Unsubscribed(Vec<String>),
Authenticated {
user_id: Option<String>,
},
Pong {
id: Option<String>,
},
ServerError(WsError),
Error(Error),
Warning(String),
Close(CloseInfo),
Reconnecting {
attempt: u32,
delay: Duration,
},
Reconnected(Welcome),
Resync(ResyncReason),
AuthLost(WsFrame),
Book(BookEvent),
}
pub type WsEvents = mpsc::Receiver<WsEvent>;
#[derive(Debug, Clone)]
pub struct WsOptions {
pub url: Option<String>,
pub allow_insecure: bool,
pub ping_interval: Duration,
pub liveness_timeout: Duration,
pub welcome_timeout: Duration,
pub ack_timeout: Duration,
pub reconnect: bool,
pub reconnect_base_delay: Duration,
pub reconnect_max_delay: Duration,
pub max_reconnect_attempts: u32,
pub max_subscriptions: usize,
pub max_messages_per_minute: u32,
pub user_agent: Option<String>,
pub event_buffer: usize,
}
impl Default for WsOptions {
fn default() -> Self {
WsOptions {
url: None,
allow_insecure: false,
ping_interval: Duration::from_secs(30),
liveness_timeout: Duration::from_secs(75),
welcome_timeout: Duration::from_secs(10),
ack_timeout: Duration::from_secs(5),
reconnect: true,
reconnect_base_delay: Duration::from_secs(1),
reconnect_max_delay: Duration::from_secs(30),
max_reconnect_attempts: 0,
max_subscriptions: 100,
max_messages_per_minute: 200,
user_agent: None,
event_buffer: 10_000,
}
}
}
struct Pending {
kind: &'static str,
channels: Vec<String>,
tx: oneshot::Sender<std::result::Result<Value, WsError>>,
}
#[derive(Default)]
pub(crate) struct State {
out: Option<mpsc::UnboundedSender<Message>>,
stop: Option<oneshot::Sender<()>>,
conn_gen: u64,
welcome: Option<Welcome>,
channels: Vec<String>,
pub(crate) token: Option<String>,
pending: HashMap<String, Pending>,
next_id: u64,
closed_by_user: bool,
ever_connected: bool,
reconnecting: bool,
window_start: Option<Instant>,
window_count: u32,
warned_version: bool,
books: HashMap<String, LiveOrderBook>,
}
pub(crate) struct Inner {
url: String,
opts: WsOptions,
pub(crate) snapshots: Option<Client>,
pub(crate) st: Mutex<State>,
events: mpsc::Sender<WsEvent>,
events_rx: Mutex<Option<WsEvents>>,
dropped: AtomicU64,
connect_lock: tokio::sync::Mutex<()>,
closing: Notify,
}
#[derive(Clone)]
pub struct WebSocket {
pub(crate) inner: Arc<Inner>,
}
impl std::fmt::Debug for WebSocket {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "cexy::WebSocket({})", self.inner.url)
}
}
impl Client {
pub fn websocket(&self, mut options: WsOptions) -> Result<WebSocket> {
if options.url.is_none() {
let base = &self.t.base_url;
let ws = if let Some(rest) = base.strip_prefix("https") {
format!("wss{rest}")
} else {
format!("ws{}", base.strip_prefix("http").unwrap_or(base))
};
options.url = Some(format!("{ws}/api/v1/ws"));
}
options.allow_insecure |= self.t.allow_insecure;
if options.user_agent.is_none() {
options.user_agent = Some(self.t.user_agent.clone());
}
WebSocket::build(options, Some(self.clone()))
}
}
impl WebSocket {
pub fn new(options: WsOptions) -> Result<WebSocket> {
WebSocket::build(options, None)
}
fn build(mut opts: WsOptions, snapshots: Option<Client>) -> Result<WebSocket> {
let url = opts
.url
.clone()
.unwrap_or_else(|| DEFAULT_WEBSOCKET_URL.to_string());
let u = Url::parse(&url)
.map_err(|_| Error::config(format!("invalid WebSocket URL: {url:?}")))?;
if u.host_str().is_none_or(str::is_empty) {
return Err(Error::config(format!("invalid WebSocket URL: {url:?}")));
}
check_secure_url(&u, "wss", "ws", opts.allow_insecure, "WebSocket URL")?;
if !u.username().is_empty() || u.password().is_some() {
return Err(Error::config(
"WebSocket URL must not contain credentials (user:password@)",
));
}
if u.query().is_some() || u.fragment().is_some() {
return Err(Error::config(
"WebSocket URL must not contain a query string or fragment",
));
}
if opts
.user_agent
.as_deref()
.is_some_and(|s| s.contains(['\r', '\n']))
{
return Err(Error::config("user_agent must not contain line breaks"));
}
let d = WsOptions::default();
for (v, dv) in [
(&mut opts.ping_interval, d.ping_interval),
(&mut opts.liveness_timeout, d.liveness_timeout),
(&mut opts.welcome_timeout, d.welcome_timeout),
(&mut opts.ack_timeout, d.ack_timeout),
(&mut opts.reconnect_base_delay, d.reconnect_base_delay),
(&mut opts.reconnect_max_delay, d.reconnect_max_delay),
] {
if v.is_zero() {
*v = dv;
}
}
if opts.max_subscriptions == 0 {
opts.max_subscriptions = d.max_subscriptions;
}
if opts.max_messages_per_minute == 0 {
opts.max_messages_per_minute = d.max_messages_per_minute;
}
let (tx, rx) = mpsc::channel(opts.event_buffer.max(1));
let st = State {
closed_by_user: true,
next_id: 1,
..Default::default()
};
Ok(WebSocket {
inner: Arc::new(Inner {
url,
opts,
snapshots,
st: Mutex::new(st),
events: tx,
events_rx: Mutex::new(Some(rx)),
dropped: AtomicU64::new(0),
connect_lock: tokio::sync::Mutex::new(()),
closing: Notify::new(),
}),
})
}
pub fn events(&self) -> Option<WsEvents> {
self.inner.events_rx.lock().unwrap().take()
}
pub fn dropped_events(&self) -> u64 {
self.inner.dropped.load(Ordering::Relaxed)
}
pub fn url(&self) -> &str {
&self.inner.url
}
pub fn welcome(&self) -> Option<Welcome> {
self.inner.st.lock().unwrap().welcome.clone()
}
pub fn is_connected(&self) -> bool {
let s = self.inner.st.lock().unwrap();
s.out.is_some() && s.welcome.is_some()
}
pub fn channels(&self) -> Vec<String> {
self.inner.st.lock().unwrap().channels.clone()
}
pub async fn connect(&self) -> Result<Welcome> {
let _g = self.inner.connect_lock.lock().await;
{
let mut s = self.inner.st.lock().unwrap();
if s.out.is_some()
&& let Some(w) = &s.welcome
{
return Ok(w.clone());
}
s.closed_by_user = false;
}
Inner::open(&self.inner).await
}
pub async fn auth(&self, token: &str) -> Result<AuthResult> {
if token.is_empty() {
return Err(WsError::local("CONFIG", "auth: token is required").into());
}
let connected = {
let mut s = self.inner.st.lock().unwrap();
s.token = Some(token.to_string());
s.out.is_some() && s.welcome.is_some()
};
if !connected {
return Ok(AuthResult {
user_id: None,
queued: true,
});
}
Inner::auth(&self.inner, token).await
}
pub async fn ping(&self) -> Result<Duration> {
let start = Instant::now();
Inner::request(&self.inner, "ping", Map::new(), vec![], true).await?;
Ok(start.elapsed())
}
pub async fn subscribe(&self, channels: &[&str]) -> Result<SubscribeResult> {
let wanted = uniq(channels.iter().map(|c| c.to_string()));
if let Some(bad) = wanted
.iter()
.find(|c| c.is_empty() || c.len() > MAX_CHANNEL_LENGTH)
{
return Err(WsError::local("CONFIG", format!("invalid channel name: {bad:?}")).into());
}
let mut res = SubscribeResult::default();
let (accepted, connected) = {
let mut s = self.inner.st.lock().unwrap();
let mut fresh = vec![];
for c in wanted {
if s.channels.contains(&c) {
res.already_subscribed.push(c);
} else {
fresh.push(c);
}
}
let room = self
.inner
.opts
.max_subscriptions
.saturating_sub(s.channels.len());
let accepted: Vec<String> = fresh.iter().take(room).cloned().collect();
res.refused = fresh[accepted.len()..].to_vec();
s.channels.extend(accepted.iter().cloned());
(accepted, s.out.is_some() && s.welcome.is_some())
};
if !res.refused.is_empty() {
self.inner.emit(WsEvent::Warning(format!(
"subscription cap of {} reached; refused {:?}",
self.inner.opts.max_subscriptions, res.refused
)));
}
if accepted.is_empty() || !connected {
return Ok(res);
}
res.added = Inner::send_subscribe(&self.inner, accepted).await?;
Ok(res)
}
pub async fn unsubscribe(&self, channels: &[&str]) -> Result<()> {
Inner::unsubscribe(
&self.inner,
channels.iter().map(|c| c.to_string()).collect(),
)
.await
}
pub async fn order_book(&self, symbol: &str) -> Result<LiveOrderBook> {
if self.inner.snapshots.is_none() {
return Err(WsError::local(
"CONFIG",
"order_book needs a WebSocket made by Client::websocket",
)
.into());
}
let book = {
let mut s = self.inner.st.lock().unwrap();
if let Some(b) = s.books.get(symbol) {
return Ok(b.clone());
}
let b = LiveOrderBook::new(symbol, Arc::downgrade(&self.inner));
s.books.insert(symbol.to_string(), b.clone());
b
};
let channel = format!("orderbook:{symbol}");
let mut result = self.subscribe(&[&channel]).await;
if let Ok(r) = &result
&& !r.refused.is_empty()
{
result = Err(WsError::local(
"LOCAL_SUBSCRIPTION_LIMIT",
format!("cannot subscribe to {channel}: cap reached"),
)
.into());
}
let result = match result {
Ok(_) => book.initial_sync().await,
Err(e) => Err(e),
};
if let Err(e) = result {
self.inner.st.lock().unwrap().books.remove(symbol);
book.mark_closed();
let _ = self.unsubscribe(&[&channel]).await;
return Err(e);
}
Ok(book)
}
pub async fn close(&self) {
Inner::close(&self.inner);
}
}
impl Inner {
pub(crate) fn emit(&self, ev: WsEvent) {
if let Err(mpsc::error::TrySendError::Full(_)) = self.events.try_send(ev) {
self.dropped.fetch_add(1, Ordering::Relaxed);
}
}
fn emit_error(&self, e: Error) {
if let Error::WebSocket(w) = &e
&& (w.code == "DISCONNECTED" || w.code == "CLOSED")
{
return;
}
self.emit(WsEvent::Error(e));
}
async fn open(this: &Arc<Inner>) -> Result<Welcome> {
let mut req = this
.url
.as_str()
.into_client_request()
.map_err(|e| Error::config(format!("WebSocket URL: {e}")))?;
if let Some(ua) = &this.opts.user_agent {
let v = HeaderValue::from_str(ua).map_err(|_| Error::config("invalid User-Agent"))?;
req.headers_mut().insert("user-agent", v);
}
let mut cfg = tokio_tungstenite::tungstenite::protocol::WebSocketConfig::default();
cfg.max_message_size = Some(MAX_FRAME_SIZE);
cfg.max_frame_size = Some(MAX_FRAME_SIZE);
let welcome_timeout = this.opts.welcome_timeout;
let handshake = async {
let connector = tokio_tungstenite::Connector::Rustls(crate::tls::client_config());
let (mut stream, _) = tokio_tungstenite::connect_async_tls_with_config(
req,
Some(cfg),
false,
Some(connector),
)
.await
.map_err(|e| {
WsError::local(
"CONNECT_FAILED",
format!("could not connect to {}: {e}", this.url),
)
})?;
let mut early = vec![];
loop {
let msg = match stream.next().await {
Some(Ok(m)) => m,
Some(Err(e)) => {
return Err(WsError::local(
"CONNECT_FAILED",
format!("connection closed before welcome: {e}"),
));
}
None => {
return Err(WsError::local(
"CONNECT_FAILED",
"connection closed before welcome",
));
}
};
let Some(frame) = parse_frame(&msg) else {
continue;
};
if frame.get("type").and_then(Value::as_str) == Some("welcome") {
let welcome: Welcome =
serde_json::from_value(Value::Object(frame)).unwrap_or(Welcome {
protocol_version: 0,
heartbeat_interval_seconds: 0,
max_subscriptions: 0,
connection_id: String::new(),
});
return Ok((stream, welcome, early));
}
early.push(frame);
}
};
let (stream, welcome, early) = match tokio::time::timeout(welcome_timeout, handshake).await
{
Ok(r) => r?,
Err(_) => return Err(WsError::local("TIMEOUT", "no welcome frame from server").into()),
};
let (out_tx, out_rx) = mpsc::unbounded_channel();
let (stop_tx, stop_rx) = oneshot::channel();
let generation = {
let mut s = this.st.lock().unwrap();
if s.closed_by_user {
None
} else {
s.conn_gen += 1;
s.out = Some(out_tx);
s.stop = Some(stop_tx);
s.welcome = Some(welcome.clone());
s.window_start = None;
s.window_count = 0;
Some(s.conn_gen)
}
};
let Some(generation) = generation else {
let (mut sink, _) = stream.split();
let _ = sink.send(Message::Close(None)).await;
return Err(WsError::local("CLOSED", "connection closed by client").into());
};
tokio::spawn(run_connection(
Arc::downgrade(this),
stream,
out_rx,
stop_rx,
generation,
this.opts.clone(),
));
for f in early {
Inner::on_frame(this, f);
}
Inner::on_welcome(this, welcome.clone());
Ok(welcome)
}
fn on_welcome(this: &Arc<Inner>, welcome: Welcome) {
let (is_reconnect, token, channels, books, warn) = {
let mut s = this.st.lock().unwrap();
let warn = welcome.protocol_version != SUPPORTED_PROTOCOL_VERSION && !s.warned_version;
if warn {
s.warned_version = true;
}
let r = s.ever_connected;
s.ever_connected = true;
(
r,
s.token.clone(),
s.channels.clone(),
s.books.values().cloned().collect::<Vec<_>>(),
warn,
)
};
if warn {
this.emit(WsEvent::Warning(format!(
"server WebSocket protocol_version {} differs from the {SUPPORTED_PROTOCOL_VERSION} this SDK supports; continuing",
welcome.protocol_version
)));
}
this.emit(WsEvent::Welcome(welcome.clone()));
if token.is_some() || !channels.is_empty() {
let inner = this.clone();
tokio::spawn(async move {
if let Some(t) = token
&& let Err(e) = Inner::auth(&inner, &t).await
{
inner.emit_error(e);
}
if !channels.is_empty()
&& let Err(e) = Inner::send_subscribe(&inner, channels).await
{
inner.emit_error(e);
}
});
}
if is_reconnect {
this.emit(WsEvent::Reconnected(welcome));
this.emit(WsEvent::Resync(ResyncReason::Reconnect));
for b in books {
b.spawn_resync(0);
}
}
}
async fn auth(this: &Arc<Inner>, token: &str) -> Result<AuthResult> {
let mut payload = Map::new();
payload.insert("token".into(), Value::String(token.to_string()));
match Inner::request(this, "auth", payload, vec![], true).await {
Ok(ack) => Ok(AuthResult {
user_id: ack
.get("user_id")
.and_then(Value::as_str)
.map(str::to_string),
queued: false,
}),
Err(e) => {
if let Error::WebSocket(w) = &e
&& w.from_server
{
let mut s = this.st.lock().unwrap();
if s.token.as_deref() == Some(token) {
s.token = None; }
}
Err(e)
}
}
}
async fn send_subscribe(this: &Arc<Inner>, channels: Vec<String>) -> Result<Vec<String>> {
let mut payload = Map::new();
payload.insert("channels".into(), json!(channels));
let ack = Inner::request(this, "subscribe", payload, channels, false).await?;
Ok(string_list(ack.get("channels")))
}
async fn unsubscribe(this: &Arc<Inner>, channels: Vec<String>) -> Result<()> {
let (held, connected) = {
let mut s = this.st.lock().unwrap();
let mut held = vec![];
for c in uniq(channels) {
if let Some(i) = s.channels.iter().position(|x| x == &c) {
s.channels.remove(i);
held.push(c);
}
}
(held, s.out.is_some() && s.welcome.is_some())
};
if held.is_empty() || !connected {
return Ok(());
}
let mut payload = Map::new();
payload.insert("channels".into(), json!(held));
Inner::request(this, "unsubscribe", payload, held, false)
.await
.map(|_| ())
}
async fn request(
this: &Arc<Inner>,
kind: &'static str,
mut payload: Map<String, Value>,
channels: Vec<String>,
strict: bool,
) -> Result<Map<String, Value>> {
let (tx, rx) = oneshot::channel();
let id = {
let mut s = this.st.lock().unwrap();
let id = s.next_id.to_string();
s.next_id += 1;
s.pending.insert(id.clone(), Pending { kind, channels, tx });
id
};
payload.insert("op".into(), Value::String(kind.to_string()));
payload.insert("id".into(), Value::String(id.clone()));
if let Err(e) = this.send(Value::Object(payload)) {
this.st.lock().unwrap().pending.remove(&id);
return Err(e.into());
}
match tokio::time::timeout(this.opts.ack_timeout, rx).await {
Ok(Ok(Ok(Value::Object(m)))) => Ok(m),
Ok(Ok(Ok(_))) => Ok(Map::new()),
Ok(Ok(Err(e))) => Err(e.into()),
Ok(Err(_)) => Err(WsError::local("DISCONNECTED", "connection lost").into()),
Err(_) => {
this.st.lock().unwrap().pending.remove(&id);
if strict {
let ack = match kind {
"auth" => "authenticated",
"subscribe" => "subscribed",
"unsubscribe" => "unsubscribed",
_ => "pong",
};
Err(WsError::local(
"TIMEOUT",
format!("no {ack} acknowledgement for {kind} (id {id})"),
)
.into())
} else {
Ok(Map::new())
}
}
}
}
fn send(&self, frame: Value) -> std::result::Result<(), WsError> {
let is_ping = frame.get("op").and_then(Value::as_str) == Some("ping");
let text = frame.to_string();
let mut s = self.st.lock().unwrap();
let Some(out) = s.out.clone() else {
return Err(WsError::local(
"NOT_CONNECTED",
"WebSocket is not connected",
));
};
let now = Instant::now();
if s.window_start
.is_none_or(|w| now.duration_since(w) >= Duration::from_secs(60))
{
s.window_start = Some(now);
s.window_count = 0;
}
if !is_ping && s.window_count >= self.opts.max_messages_per_minute {
return Err(WsError::local(
"LOCAL_RATE_LIMIT",
format!(
"more than {} messages this minute; the server closes the socket above 240",
self.opts.max_messages_per_minute
),
));
}
s.window_count += 1;
drop(s);
out.send(Message::text(text))
.map_err(|_| WsError::local("NOT_CONNECTED", "WebSocket is not connected"))
}
fn settle(&self, id: &str, kind: Option<&str>, result: std::result::Result<Value, WsError>) {
let p = {
let mut s = self.st.lock().unwrap();
match s.pending.get(id) {
Some(p) if kind.is_none_or(|k| k == p.kind) => s.pending.remove(id),
_ => None,
}
};
if let Some(p) = p {
let _ = p.tx.send(result);
}
}
fn settle_by_channel(&self, kind: &str, channels: &[String], frame: Value) {
let p = {
let mut s = self.st.lock().unwrap();
let id = s
.pending
.iter()
.find(|(_, p)| p.kind == kind && p.channels.iter().any(|c| channels.contains(c)))
.map(|(id, _)| id.clone());
id.and_then(|id| s.pending.remove(&id))
};
if let Some(p) = p {
let _ = p.tx.send(Ok(frame));
}
}
fn on_frame(this: &Arc<Inner>, frame: Map<String, Value>) {
let typ = frame
.get("type")
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let id = frame.get("id").and_then(Value::as_str).map(str::to_string);
let value = Value::Object(frame.clone());
match typ.as_str() {
"welcome" => {
if let Ok(w) = serde_json::from_value::<Welcome>(value) {
this.st.lock().unwrap().welcome = Some(w.clone());
Inner::on_welcome(this, w);
}
}
"pong" => {
if let Some(id) = &id {
this.settle(id, Some("ping"), Ok(value));
}
this.emit(WsEvent::Pong { id });
}
"authenticated" => {
if let Some(id) = &id {
this.settle(id, Some("auth"), Ok(value));
}
let user_id = frame
.get("user_id")
.and_then(Value::as_str)
.map(str::to_string);
this.emit(WsEvent::Authenticated { user_id });
}
"subscribed" | "unsubscribed" => {
let channels = string_list(frame.get("channels"));
let kind = if typ == "subscribed" {
"subscribe"
} else {
"unsubscribe"
};
match &id {
Some(id) => this.settle(id, Some(kind), Ok(value)),
None => this.settle_by_channel(kind, &channels, value), }
this.emit(if typ == "subscribed" {
WsEvent::Subscribed(channels)
} else {
WsEvent::Unsubscribed(channels)
});
}
"error" => {
let code = frame
.get("code")
.and_then(Value::as_str)
.filter(|s| !s.is_empty())
.unwrap_or("UNKNOWN");
let message = frame
.get("message")
.and_then(Value::as_str)
.filter(|s| !s.is_empty())
.unwrap_or(code);
let err = WsError {
code: code.to_string(),
message: message.to_string(),
from_server: true,
};
if let Some(id) = &id {
this.settle(id, None, Err(err.clone()));
}
this.emit(WsEvent::ServerError(err));
if code == ErrorCode::ConcurrentModification.as_str() && id.is_none() {
this.emit(WsEvent::Resync(ResyncReason::ConcurrentModification));
let books: Vec<_> = this.st.lock().unwrap().books.values().cloned().collect();
for b in books {
b.spawn_resync(0);
}
}
}
t if KNOWN_EVENT_TYPES.contains(&t) => {
let Ok(ev) = serde_json::from_value::<WsFrame>(value) else {
return;
};
if ev.r#type == "session.revoked" {
{
let mut s = this.st.lock().unwrap();
s.token = None;
s.channels
.retain(|c| !PRIVATE_CHANNELS.contains(&c.as_str()));
}
this.emit(WsEvent::AuthLost(ev.clone()));
}
if ev.r#type == "orderbook.update" {
let symbol = match ev.channel.strip_prefix("orderbook:") {
Some(s) => s.to_string(),
None => ev
.decode::<OrderBookUpdate>()
.map(|d| d.symbol)
.unwrap_or_default(),
};
let book = this.st.lock().unwrap().books.get(&symbol).cloned();
if let Some(b) = book {
b.on_update(&ev);
}
}
this.emit(WsEvent::Event(ev));
}
_ => {} }
}
fn on_dropped(this: &Arc<Inner>, generation: u64, code: u16, reason: String) {
let (books, will_reconnect, start) = {
let mut s = this.st.lock().unwrap();
if generation != s.conn_gen || s.out.is_none() {
return;
}
Inner::teardown(
&mut s,
WsError::local("DISCONNECTED", format!("connection lost (code {code})")),
);
let will = !s.closed_by_user && this.opts.reconnect;
let start = will && !s.reconnecting;
if start {
s.reconnecting = true;
}
(s.books.values().cloned().collect::<Vec<_>>(), will, start)
};
for b in books {
b.mark_disconnected(); }
this.emit(WsEvent::Close(CloseInfo {
code,
reason,
will_reconnect,
}));
if start {
tokio::spawn(Inner::reconnect_loop(this.clone()));
}
}
async fn reconnect_loop(this: Arc<Inner>) {
let mut attempt = 0u32;
loop {
attempt += 1;
if this.opts.max_reconnect_attempts > 0 && attempt > this.opts.max_reconnect_attempts {
this.emit_error(
WsError::local(
"RECONNECT_FAILED",
format!(
"gave up after {} reconnect attempts",
this.opts.max_reconnect_attempts
),
)
.into(),
);
break;
}
let base = this.opts.reconnect_base_delay.as_secs_f64()
* 2f64.powi((attempt - 1).min(30) as i32);
let capped = base.min(this.opts.reconnect_max_delay.as_secs_f64());
let delay = Duration::from_secs_f64(rand::random::<f64>() * capped); this.emit(WsEvent::Reconnecting { attempt, delay });
tokio::select! {
_ = tokio::time::sleep(delay) => {}
_ = this.closing.notified() => break,
}
if this.st.lock().unwrap().closed_by_user {
break;
}
match Inner::open(&this).await {
Ok(_) => break,
Err(e) => {
if this.st.lock().unwrap().closed_by_user {
break;
}
this.emit_error(e);
}
}
}
this.st.lock().unwrap().reconnecting = false;
}
fn teardown(s: &mut State, err: WsError) {
if let Some(stop) = s.stop.take() {
let _ = stop.send(());
}
s.out = None;
s.welcome = None;
for (_, p) in s.pending.drain() {
let _ = p.tx.send(Err(err.clone()));
}
}
fn close(this: &Arc<Inner>) {
let (books, was_open) = {
let mut s = this.st.lock().unwrap();
if s.closed_by_user && s.out.is_none() {
return;
}
s.closed_by_user = true;
let was_open = s.out.is_some();
Inner::teardown(
&mut s,
WsError::local("CLOSED", "connection closed by client"),
);
(s.books.values().cloned().collect::<Vec<_>>(), was_open)
};
this.closing.notify_waiters();
for b in books {
b.mark_disconnected();
}
if was_open {
this.emit(WsEvent::Close(CloseInfo {
code: 1000,
reason: "client closing".into(),
will_reconnect: false,
}));
}
}
pub(crate) fn remove_book(&self, symbol: &str, book: &LiveOrderBook) {
let mut s = self.st.lock().unwrap();
if s.books.get(symbol).is_some_and(|b| b.same(book)) {
s.books.remove(symbol);
}
}
pub(crate) fn unsubscribe_later(this: &Arc<Inner>, channel: String) {
let inner = this.clone();
tokio::spawn(async move {
let _ = Inner::unsubscribe(&inner, vec![channel]).await;
});
}
}
async fn run_connection(
inner: Weak<Inner>,
stream: tokio_tungstenite::WebSocketStream<
tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
>,
mut out: mpsc::UnboundedReceiver<Message>,
mut stop: oneshot::Receiver<()>,
generation: u64,
opts: WsOptions,
) {
let (mut sink, mut read) = stream.split();
let mut ping = tokio::time::interval_at(
tokio::time::Instant::now() + opts.ping_interval,
opts.ping_interval,
);
let liveness = tokio::time::sleep(opts.liveness_timeout);
tokio::pin!(liveness);
let (code, reason) = loop {
tokio::select! {
_ = &mut stop => {
let _ = sink.send(Message::Close(None)).await;
return;
}
msg = out.recv() => match msg {
Some(m) => {
if let Err(e) = sink.send(m).await {
break (1006, e.to_string());
}
}
None => {
let _ = sink.send(Message::Close(None)).await;
return;
}
},
_ = ping.tick() => {
if let Some(i) = inner.upgrade() {
let _ = i.send(json!({"op": "ping"}));
}
}
_ = &mut liveness => break (4000, "liveness timeout".to_string()),
r = read.next() => {
liveness
.as_mut()
.reset(tokio::time::Instant::now() + opts.liveness_timeout);
match r {
None => break (1006, "connection closed".to_string()),
Some(Err(e)) => break (1006, e.to_string()),
Some(Ok(Message::Close(frame))) => {
let (c, r) = frame
.map(|f| (u16::from(f.code), f.reason.to_string()))
.unwrap_or((1005, String::new()));
break (c, r);
}
Some(Ok(m)) => {
let Some(i) = inner.upgrade() else { return };
if let Some(frame) = parse_frame(&m) {
Inner::on_frame(&i, frame);
}
}
}
}
}
};
if let Some(i) = inner.upgrade() {
Inner::on_dropped(&i, generation, code, reason);
}
}
fn parse_frame(m: &Message) -> Option<Map<String, Value>> {
let text = match m {
Message::Text(t) => t.as_str(),
Message::Binary(b) => std::str::from_utf8(b).ok()?,
_ => return None,
};
match serde_json::from_str::<Value>(text) {
Ok(Value::Object(m)) => Some(m),
_ => None,
}
}
fn string_list(v: Option<&Value>) -> Vec<String> {
v.and_then(Value::as_array)
.map(|a| {
a.iter()
.filter_map(Value::as_str)
.map(str::to_string)
.collect()
})
.unwrap_or_default()
}
fn uniq(it: impl IntoIterator<Item = String>) -> Vec<String> {
let mut out: Vec<String> = vec![];
for s in it {
if !out.contains(&s) {
out.push(s);
}
}
out
}