use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use serde_json::Value;
use tokio::net::TcpStream;
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
use crate::server::socket_layer;
type Socket = WebSocketStream<MaybeTlsStream<TcpStream>>;
const TIMEOUT: Duration = Duration::from_secs(2);
#[derive(Debug, thiserror::Error)]
pub enum LiveError {
#[error("the connection was refused: {0}")]
Refused(String),
#[error("timed out waiting for {0}")]
Timeout(String),
#[error("socket error: {0}")]
Socket(String),
#[error("io error: {0}")]
Io(#[from] std::io::Error),
}
type LiveResult<T> = Result<T, LiveError>;
pub struct LiveSocketHarness {
address: std::net::SocketAddr,
shutdown: Option<tokio::sync::oneshot::Sender<()>>,
}
impl LiveSocketHarness {
pub async fn start(layer: socketioxide::layer::SocketIoLayer) -> LiveResult<Self> {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
let app = axum::Router::new().layer(layer);
let (shutdown, signal) = tokio::sync::oneshot::channel();
tokio::spawn(async move {
let _ = axum::serve(listener, app)
.with_graceful_shutdown(async {
let _ = signal.await;
})
.await;
});
Ok(Self {
address,
shutdown: Some(shutdown),
})
}
pub async fn start_with<F>(build: F) -> LiveResult<Self>
where
F: FnOnce(&socketioxide::SocketIo),
{
let (layer, io) = socket_layer();
build(&io);
Self::start(layer).await
}
pub fn address(&self) -> std::net::SocketAddr {
self.address
}
pub async fn connect(&self, namespace: &str) -> LiveResult<LiveClient> {
self.connect_with(namespace, None, None).await
}
pub async fn connect_with_query(&self, namespace: &str, query: &str) -> LiveResult<LiveClient> {
self.connect_with(namespace, Some(query), None).await
}
pub async fn connect_with_auth(
&self,
namespace: &str,
auth: Option<Value>,
) -> LiveResult<LiveClient> {
self.connect_with(namespace, None, auth).await
}
pub async fn connect_with(
&self,
namespace: &str,
query: Option<&str>,
auth: Option<Value>,
) -> LiveResult<LiveClient> {
let extra = query
.map(|query| format!("&{}", query.trim_start_matches(['?', '&'])))
.unwrap_or_default();
let url = format!(
"ws://{}/socket.io/?EIO=4&transport=websocket{extra}",
self.address
);
let (mut socket, _) = tokio_tungstenite::connect_async(&url)
.await
.map_err(|error| LiveError::Socket(error.to_string()))?;
let open = next_text(&mut socket, "the engine.io open packet").await?;
if !open.starts_with('0') {
return Err(LiveError::Socket(format!(
"unexpected opening frame: {open}"
)));
}
let namespace = normalize(namespace);
let connect = match auth {
Some(auth) => format!("40{namespace},{auth}"),
None => format!("40{namespace},"),
};
socket
.send(Message::Text(connect.into()))
.await
.map_err(|error| LiveError::Socket(error.to_string()))?;
let mut client = LiveClient {
socket,
namespace,
next_ack: 0,
pending: Vec::new(),
};
loop {
let frame = client.next_frame("the namespace connect reply").await?;
if frame.starts_with("40") {
return Ok(client);
}
if frame.starts_with("44") {
let payload = frame
.splitn(2, '{')
.nth(1)
.map(|rest| format!("{{{rest}"))
.unwrap_or_else(|| frame.clone());
return Err(LiveError::Refused(payload));
}
}
}
}
impl Drop for LiveSocketHarness {
fn drop(&mut self) {
if let Some(shutdown) = self.shutdown.take() {
let _ = shutdown.send(());
}
}
}
pub struct LiveClient {
socket: Socket,
namespace: String,
next_ack: u64,
pending: Vec<(String, Vec<Value>)>,
}
impl LiveClient {
pub async fn emit_with_ack(&mut self, event: &str, payload: Value) -> LiveResult<Vec<Value>> {
let id = self.next_ack;
self.next_ack += 1;
let frame = format!(
"42{},{}{}",
self.namespace,
id,
serde_json::json!([event, payload])
);
self.send(frame).await?;
loop {
let frame = self.next_frame(&format!("an ack for '{event}'")).await?;
let Some(rest) = frame.strip_prefix("43") else {
self.stash(&frame);
continue;
};
let rest = rest
.trim_start_matches(&self.namespace)
.trim_start_matches(',');
let (ack_id, body) = split_ack(rest);
if ack_id != Some(id) {
continue;
}
return Ok(serde_json::from_str(body).unwrap_or_default());
}
}
pub async fn emit(&mut self, event: &str, payload: Value) -> LiveResult<()> {
let frame = format!(
"42{},{}",
self.namespace,
serde_json::json!([event, payload])
);
self.send(frame).await
}
pub async fn wait_for(&mut self, event: &str) -> LiveResult<Vec<Value>> {
if let Some(index) = self.pending.iter().position(|(name, _)| name == event) {
return Ok(self.pending.remove(index).1);
}
loop {
let frame = self.next_frame(&format!("the '{event}' event")).await?;
if let Some((name, args)) = parse_event(&frame, &self.namespace) {
if name == event {
return Ok(args);
}
self.pending.push((name, args));
}
}
}
pub async fn saw(&mut self, event: &str) -> bool {
self.wait_for(event).await.is_ok()
}
pub async fn close(mut self) {
let _ = self.socket.close(None).await;
}
async fn send(&mut self, frame: String) -> LiveResult<()> {
self.socket
.send(Message::Text(frame.into()))
.await
.map_err(|error| LiveError::Socket(error.to_string()))
}
fn stash(&mut self, frame: &str) {
if let Some(parsed) = parse_event(frame, &self.namespace) {
self.pending.push(parsed);
}
}
async fn next_frame(&mut self, waiting_for: &str) -> LiveResult<String> {
loop {
let text = next_text(&mut self.socket, waiting_for).await?;
if text == "2" {
self.send("3".into()).await?;
continue;
}
return Ok(text);
}
}
}
async fn next_text(socket: &mut Socket, waiting_for: &str) -> LiveResult<String> {
loop {
let message = tokio::time::timeout(TIMEOUT, socket.next())
.await
.map_err(|_| LiveError::Timeout(waiting_for.to_string()))?
.ok_or_else(|| LiveError::Socket("the connection closed".into()))?
.map_err(|error| LiveError::Socket(error.to_string()))?;
match message {
Message::Text(text) => return Ok(text.to_string()),
Message::Close(_) => return Err(LiveError::Socket("the server closed it".into())),
_ => continue,
}
}
}
fn normalize(namespace: &str) -> String {
match namespace {
"" | "/" => "/".to_string(),
other if other.starts_with('/') => other.to_string(),
other => format!("/{other}"),
}
}
fn parse_event(frame: &str, namespace: &str) -> Option<(String, Vec<Value>)> {
let rest = frame.strip_prefix("42")?;
let rest = rest.strip_prefix(namespace).unwrap_or(rest);
let rest = rest.trim_start_matches(',');
let body = rest.trim_start_matches(|c: char| c.is_ascii_digit());
let mut args: Vec<Value> = serde_json::from_str(body).ok()?;
if args.is_empty() {
return None;
}
let name = args.remove(0).as_str()?.to_string();
Some((name, args))
}
fn split_ack(rest: &str) -> (Option<u64>, &str) {
let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
let body = &rest[digits.len()..];
(digits.parse().ok(), body)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_namespace_is_normalized_the_way_the_protocol_wants_it() {
assert_eq!(normalize(""), "/");
assert_eq!(normalize("/"), "/");
assert_eq!(normalize("chat"), "/chat");
assert_eq!(normalize("/chat"), "/chat");
}
#[test]
fn an_event_frame_is_parsed() {
let (name, args) = parse_event(r#"42/chat,["message",{"text":"hi"}]"#, "/chat").unwrap();
assert_eq!(name, "message");
assert_eq!(args[0]["text"], "hi");
}
#[test]
fn an_event_on_the_root_namespace_is_parsed() {
let (name, args) = parse_event(r#"42["tick",1]"#, "/").unwrap();
assert_eq!(name, "tick");
assert_eq!(args[0], 1);
}
#[test]
fn an_ack_id_is_split_from_its_body() {
assert_eq!(
split_ack(r#"7[{"ok":true}]"#),
(Some(7), r#"[{"ok":true}]"#)
);
assert_eq!(split_ack("[]"), (None, "[]"));
}
}