use super::registry::Registry;
use crate::error::TransportError;
use futures_channel::oneshot;
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use wasm_bindgen::closure::Closure;
use wasm_bindgen::JsCast;
use web_sys::{CloseEvent, Event, MessageEvent, WebSocket};
#[derive(Debug)]
struct Socket {
socket: WebSocket,
_on_message: Closure<dyn FnMut(MessageEvent)>,
_on_close: Closure<dyn FnMut(CloseEvent)>,
_on_error: Closure<dyn FnMut(Event)>,
}
impl Drop for Socket {
fn drop(&mut self) {
self.socket.set_onmessage(None);
self.socket.set_onclose(None);
self.socket.set_onerror(None);
let _ = self.socket.close();
}
}
#[derive(Debug, Clone)]
pub(crate) struct Conn {
inner: Rc<Socket>,
}
impl Conn {
pub(crate) fn send(&self, text: String) -> Result<(), TransportError> {
if self.inner.socket.ready_state() != WebSocket::OPEN {
return Err(TransportError::closed("websocket connection is closed"));
}
self.inner
.socket
.send_with_str(&text)
.map_err(|e| TransportError::other(format!("websocket send failed: {e:?}")))
}
pub(crate) fn send_binary(&self, frame: Vec<u8>) -> Result<(), TransportError> {
if self.inner.socket.ready_state() != WebSocket::OPEN {
return Err(TransportError::closed("websocket connection is closed"));
}
self.inner
.socket
.send_with_u8_array(&frame)
.map_err(|e| TransportError::other(format!("websocket send failed: {e:?}")))
}
pub(crate) fn close(&self) {
let _ = self.inner.socket.close();
}
}
pub(crate) async fn connect(url: &str, registry: Arc<Registry>) -> Result<Conn, TransportError> {
let socket =
WebSocket::new(url).map_err(|e| TransportError::connect(format!("{url}: {e:?}")))?;
adopt(socket, registry).await
}
pub(crate) async fn adopt(socket: WebSocket, registry: Arc<Registry>) -> Result<Conn, TransportError> {
match socket.ready_state() {
WebSocket::CONNECTING | WebSocket::OPEN => {}
state => return Err(TransportError::connect(format!("the websocket handed over is closing or closed (readyState {state})"))),
}
let (opened_tx, opened_rx) = oneshot::channel::<Result<(), TransportError>>();
let opened_tx = Rc::new(RefCell::new(Some(opened_tx)));
let on_message = {
let registry = registry.clone();
let socket = socket.clone();
Closure::<dyn FnMut(MessageEvent)>::new(move |event: MessageEvent| {
if let Some(text) = event.data().as_string() {
super::trace("←", &text);
if let Some(frame) = registry.on_text(&text) {
super::trace("→", &frame);
let _ = socket.send_with_str(&frame);
}
}
})
};
socket.set_onmessage(Some(on_message.as_ref().unchecked_ref()));
let on_close = {
let registry = registry.clone();
let opened_tx = opened_tx.clone();
Closure::<dyn FnMut(CloseEvent)>::new(move |event: CloseEvent| {
let reason = format!(
"websocket closed by the peer (code {}, {})",
event.code(),
event.reason()
);
if let Some(tx) = opened_tx.borrow_mut().take() {
let _ = tx.send(Err(TransportError::connect(reason.clone())));
}
registry.on_close(reason);
})
};
socket.set_onclose(Some(on_close.as_ref().unchecked_ref()));
let on_error = {
let registry = registry.clone();
let opened_tx = opened_tx.clone();
Closure::<dyn FnMut(Event)>::new(move |_event: Event| {
let reason = "websocket error".to_string();
if let Some(tx) = opened_tx.borrow_mut().take() {
let _ = tx.send(Err(TransportError::connect(reason.clone())));
}
registry.on_close(reason);
})
};
socket.set_onerror(Some(on_error.as_ref().unchecked_ref()));
let on_open = {
let opened_tx = opened_tx.clone();
Closure::<dyn FnMut(Event)>::new(move |_event: Event| {
if let Some(tx) = opened_tx.borrow_mut().take() {
let _ = tx.send(Ok(()));
}
})
};
socket.set_onopen(Some(on_open.as_ref().unchecked_ref()));
if socket.ready_state() == WebSocket::OPEN {
if let Some(tx) = opened_tx.borrow_mut().take() {
let _ = tx.send(Ok(()));
}
}
let conn = Conn {
inner: Rc::new(Socket {
socket,
_on_message: on_message,
_on_close: on_close,
_on_error: on_error,
}),
};
let outcome = opened_rx
.await
.unwrap_or_else(|_| Err(TransportError::connect("websocket never opened")));
conn.inner.socket.set_onopen(None);
drop(on_open);
outcome?;
Ok(conn)
}