use super::types::WSEvent;
use crate::core::client::Client;
use crate::core::http::DEFAULT_JSON_TIMEOUT_MS;
use crate::shared::{ApiResponse, Error, Result};
use futures_util::{SinkExt, StreamExt};
use serde::Deserialize;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::Notify;
use tokio_tungstenite::tungstenite::Message;
use tokio_util::sync::CancellationToken;
const HANDSHAKE_TIMEOUT_MS: u64 = 30_000;
const DISCONNECT_DRAIN_MS: u64 = 5_000;
type EventCb = Arc<dyn Fn(WSEvent) + Send + Sync>;
type ConnectCb = Arc<dyn Fn() + Send + Sync>;
type DisconnectCb = Arc<dyn Fn(String) + Send + Sync>;
#[derive(Clone, Default)]
pub struct WSConfig {
pub on_event: Option<EventCb>,
pub on_connect: Option<ConnectCb>,
pub on_disconnect: Option<DisconnectCb>,
pub topics: Vec<String>,
pub reconnect_min_ms: Option<u64>,
pub reconnect_max_ms: Option<u64>,
pub auto_reconnect: Option<bool>,
}
#[derive(Clone)]
struct FilledCfg {
on_event: EventCb,
on_connect: ConnectCb,
on_disconnect: DisconnectCb,
topics: Vec<String>,
reconnect_min_ms: u64,
reconnect_max_ms: u64,
auto_reconnect: bool,
}
impl FilledCfg {
fn from(cfg: WSConfig) -> Self {
FilledCfg {
on_event: cfg.on_event.unwrap_or_else(|| Arc::new(|_| {})),
on_connect: cfg.on_connect.unwrap_or_else(|| Arc::new(|| {})),
on_disconnect: cfg.on_disconnect.unwrap_or_else(|| Arc::new(|_| {})),
topics: cfg.topics,
reconnect_min_ms: cfg.reconnect_min_ms.unwrap_or(2000),
reconnect_max_ms: cfg.reconnect_max_ms.unwrap_or(60_000),
auto_reconnect: cfg.auto_reconnect.unwrap_or(true),
}
}
}
pub struct WsHandle {
abort: CancellationToken,
connected: Arc<AtomicBool>,
done: Arc<Notify>,
}
#[derive(Deserialize)]
struct StreamTicket {
ticket: String,
#[serde(rename = "expiresIn", default)]
#[allow(dead_code)]
expires_in: i64,
}
impl Client {
pub async fn connect(&self, cfg: WSConfig, signal: Option<CancellationToken>) -> Result<()> {
if self.http().is_custom() {
return Err(crate::core::transport::TransportError::UnsupportedWebSocket.into());
}
self.disconnect().await;
let filled = FilledCfg::from(cfg);
let abort = CancellationToken::new();
if let Some(sig) = signal {
if sig.is_cancelled() {
abort.cancel();
} else {
let a = abort.clone();
tokio::spawn(async move {
sig.cancelled().await;
a.cancel();
});
}
}
let connected = Arc::new(AtomicBool::new(false));
let done = Arc::new(Notify::new());
let conn = self.ws_connect_once(&filled, &abort, &connected).await?;
*self.ws_slot().lock().await = Some(WsHandle {
abort: abort.clone(),
connected: connected.clone(),
done: done.clone(),
});
let client = self.clone();
tokio::spawn(async move {
ws_loop(client, filled, abort, connected, done, conn).await;
});
Ok(())
}
pub async fn disconnect(&self) {
let handle = self.ws_slot().lock().await.take();
let handle = match handle {
Some(h) => h,
None => return,
};
handle.abort.cancel();
handle.connected.store(false, Ordering::SeqCst);
let drain = handle.done.notified();
tokio::select! {
_ = drain => {}
_ = tokio::time::sleep(Duration::from_millis(DISCONNECT_DRAIN_MS)) => {}
}
}
pub async fn is_connected(&self) -> bool {
match self.ws_slot().lock().await.as_ref() {
Some(h) => h.connected.load(Ordering::SeqCst),
None => false,
}
}
async fn ws_connect_once(
&self,
cfg: &FilledCfg,
abort: &CancellationToken,
connected: &Arc<AtomicBool>,
) -> Result<WsStream> {
let url = ws_url(self);
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
"/ws/stream-ticket",
None,
Some(abort.clone()),
DEFAULT_JSON_TIMEOUT_MS,
None,
)
.await?;
let env: ApiResponse<StreamTicket> = serde_json::from_slice(&bytes)
.map_err(|e| Error::other(format!("/ws/stream-ticket: decode: {e}")))?;
if let Some(err) = env.business_error() {
return Err(err);
}
let ticket = env.data.ticket;
let full_url = append_ticket(&url, &ticket);
let dial = tokio_tungstenite::connect_async(&full_url);
let (mut conn, _resp) = tokio::select! {
r = dial => r.map_err(|e| Error::other(format!("dial: {e}")))?,
_ = abort.cancelled() => return Err(Error::other("dial: aborted")),
_ = tokio::time::sleep(Duration::from_millis(HANDSHAKE_TIMEOUT_MS)) => {
return Err(Error::other("dial: handshake timeout"));
}
};
let welcome = tokio::select! {
msg = next_text(&mut conn) => msg?,
_ = abort.cancelled() => {
let _ = conn.close(None).await;
return Err(Error::other("dial: aborted"));
}
_ = tokio::time::sleep(Duration::from_millis(HANDSHAKE_TIMEOUT_MS)) => {
let _ = conn.close(None).await;
return Err(Error::other("dial: handshake timeout"));
}
};
let welcome: WSEvent = serde_json::from_str(&welcome)
.map_err(|e| Error::other(format!("parse welcome: {e}")))?;
if welcome.r#type != "welcome" {
let _ = conn.close(None).await;
return Err(Error::other(format!(
"unexpected first message: {}",
welcome.r#type
)));
}
connected.store(true, Ordering::SeqCst);
if !cfg.topics.is_empty() {
let sub = serde_json::json!({ "type": "subscribe", "topics": cfg.topics }).to_string();
if let Err(e) = conn.send(Message::Text(sub)).await {
connected.store(false, Ordering::SeqCst);
let _ = conn.close(None).await;
return Err(Error::other(format!("send subscribe: {e}")));
}
}
(cfg.on_connect)();
Ok(conn)
}
}
type WsStream =
tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;
async fn next_text(conn: &mut WsStream) -> Result<String> {
loop {
match conn.next().await {
Some(Ok(Message::Text(t))) => return Ok(t),
Some(Ok(Message::Binary(b))) => return Ok(String::from_utf8_lossy(&b).into_owned()),
Some(Ok(Message::Close(_))) => return Err(Error::other("closed")),
Some(Ok(_)) => continue, Some(Err(e)) => return Err(Error::other(format!("read: {e}"))),
None => return Err(Error::other("closed")),
}
}
}
async fn ws_loop(
client: Client,
cfg: FilledCfg,
abort: CancellationToken,
connected: Arc<AtomicBool>,
done: Arc<Notify>,
mut conn: WsStream,
) {
loop {
ws_read_loop(&cfg, &abort, &connected, &mut conn).await;
if abort.is_cancelled() {
break;
}
let _ = conn.close(None).await;
connected.store(false, Ordering::SeqCst);
if !cfg.auto_reconnect {
break;
}
let mut delay = cfg.reconnect_min_ms;
let reconnected = loop {
if abort.is_cancelled() {
break None;
}
tokio::select! {
_ = tokio::time::sleep(Duration::from_millis(delay)) => {}
_ = abort.cancelled() => break None,
}
if abort.is_cancelled() {
break None;
}
match client.ws_connect_once(&cfg, &abort, &connected).await {
Ok(c) => break Some(c),
Err(_) => {
delay = (delay * 2).min(cfg.reconnect_max_ms);
}
}
};
match reconnected {
Some(c) => conn = c,
None => break,
}
}
done.notify_waiters();
}
async fn ws_read_loop(
cfg: &FilledCfg,
abort: &CancellationToken,
connected: &Arc<AtomicBool>,
conn: &mut WsStream,
) {
loop {
tokio::select! {
_ = abort.cancelled() => {
let _ = conn.close(None).await;
connected.store(false, Ordering::SeqCst);
return;
}
next = conn.next() => {
match next {
Some(Ok(Message::Text(t))) => {
if let Ok(ev) = serde_json::from_str::<WSEvent>(&t) {
(cfg.on_event)(ev);
}
}
Some(Ok(Message::Binary(b))) => {
if let Ok(ev) = serde_json::from_slice::<WSEvent>(&b) {
(cfg.on_event)(ev);
}
}
Some(Ok(Message::Close(frame))) => {
connected.store(false, Ordering::SeqCst);
let reason = frame
.map(|f| format!("closed: code={} reason={}", u16::from(f.code), f.reason))
.unwrap_or_else(|| "closed".to_string());
(cfg.on_disconnect)(reason);
return;
}
Some(Ok(_)) => { }
Some(Err(e)) => {
connected.store(false, Ordering::SeqCst);
(cfg.on_disconnect)(format!("error: {e}"));
return;
}
None => {
connected.store(false, Ordering::SeqCst);
(cfg.on_disconnect)("closed".to_string());
return;
}
}
}
}
}
}
fn ws_url(c: &Client) -> String {
let base = c.api_url("/ws");
if let Some(rest) = base.strip_prefix("https://") {
format!("wss://{rest}")
} else if let Some(rest) = base.strip_prefix("http://") {
format!("ws://{rest}")
} else {
base
}
}
fn append_ticket(url: &str, ticket: &str) -> String {
let sep = if url.contains('?') { '&' } else { '?' };
format!(
"{url}{sep}ticket={}",
crate::billing::entitlements::urlencoding(ticket)
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ws_url_scheme_swap() {
assert_eq!(
append_ticket("wss://h/api/v4/ws", "T1"),
"wss://h/api/v4/ws?ticket=T1"
);
assert_eq!(
append_ticket("wss://h/api/v4/ws?x=1", "T2"),
"wss://h/api/v4/ws?x=1&ticket=T2"
);
}
}