use std::cell::Cell;
use std::fmt;
use std::panic::AssertUnwindSafe;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, PoisonError, Weak};
use std::time::Duration;
use futures_util::FutureExt;
use tokio::sync::{mpsc, oneshot, watch};
use tokio::task::JoinHandle;
use crate::actor::{Actor, Command, Dispatch};
use crate::builder::Config;
use crate::handler::{Handler, Handlers, ListenerId};
use crate::protocol::socketio::{Packet, is_reserved_event};
use crate::state::LinkInfo;
use crate::{ConnectionState, Error, Event, Payload, Result};
tokio::task_local! {
static IN_HANDLER_TASK: ();
}
thread_local! {
pub(crate) static IN_HANDLER_THREAD: Cell<bool> = const { Cell::new(false) };
}
fn in_handler() -> bool {
IN_HANDLER_TASK.try_with(|_| ()).is_ok() || IN_HANDLER_THREAD.with(Cell::get)
}
const HANDLER_DRAIN: Duration = Duration::from_secs(5);
pub(crate) struct Inner {
cmd: Mutex<mpsc::UnboundedSender<Command>>,
_shutdown: Mutex<oneshot::Sender<()>>,
state: watch::Receiver<ConnectionState>,
state_tx: watch::Sender<ConnectionState>,
config: Config,
url: url::Url,
restart: tokio::sync::Mutex<()>,
lifecycle: Mutex<u64>,
handlers: Mutex<Handlers>,
shared: Arc<Shared>,
nsp: Arc<str>,
buffer_while_disconnected: bool,
actor: Mutex<Option<JoinHandle<()>>>,
dispatcher: Mutex<Option<JoinHandle<()>>>,
}
#[derive(Debug, Default)]
pub(crate) struct Shared {
pub(crate) connected: AtomicBool,
pub(crate) closed: AtomicBool,
pub(crate) muted: AtomicBool,
pub(crate) link: Mutex<LinkInfo>,
}
impl Shared {
pub(crate) fn link(&self) -> std::sync::MutexGuard<'_, LinkInfo> {
self.link.lock().unwrap_or_else(PoisonError::into_inner)
}
}
#[derive(Clone)]
pub struct Client {
inner: Arc<Inner>,
}
impl fmt::Debug for Client {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Client")
.field("nsp", &self.inner.nsp)
.field("state", &*self.inner.state.borrow())
.finish_non_exhaustive()
}
}
pub(crate) async fn connect(config: Config, handlers: Handlers) -> Result<Client> {
let (cmd_tx, _) = mpsc::unbounded_channel();
let (shutdown_tx, _) = oneshot::channel();
let (state_tx, state_rx) = watch::channel(ConnectionState::Connecting { attempt: 0 });
let (url, nsp) = resolve(&config)?;
let inner = Arc::new(Inner {
cmd: Mutex::new(cmd_tx),
_shutdown: Mutex::new(shutdown_tx),
state: state_rx,
state_tx,
handlers: Mutex::new(handlers),
shared: Arc::new(Shared::default()),
nsp: nsp.into(),
buffer_while_disconnected: config.buffer_while_disconnected,
config,
url,
restart: tokio::sync::Mutex::new(()),
lifecycle: Mutex::new(0),
actor: Mutex::default(),
dispatcher: Mutex::default(),
});
let ready = start(&inner);
match ready.await {
Ok(Ok(())) => Ok(Client { inner }),
Ok(Err(err)) => Err(err),
Err(_) => Err(Error::Closed),
}
}
fn start(inner: &Arc<Inner>) -> oneshot::Receiver<Result<()>> {
let (cmd_tx, cmd_rx) = mpsc::unbounded_channel();
let (shutdown_tx, shutdown_rx) = oneshot::channel();
let (dispatch_tx, dispatch_rx) = mpsc::unbounded_channel();
let (ready_tx, ready_rx) = oneshot::channel();
inner
.state_tx
.send_replace(ConnectionState::Connecting { attempt: 0 });
let shared = Arc::clone(&inner.shared);
shared.closed.store(false, Ordering::Release);
shared.muted.store(false, Ordering::Release);
*inner.cmd.lock().unwrap_or_else(PoisonError::into_inner) = cmd_tx.clone();
*inner
._shutdown
.lock()
.unwrap_or_else(PoisonError::into_inner) = shutdown_tx;
let dispatcher = tokio::spawn(dispatch(dispatch_rx, Arc::downgrade(inner)));
let panic_state = inner.state_tx.clone();
let actor = Actor::new(
inner.config.clone(),
inner.url.clone(),
Arc::clone(&inner.nsp),
cmd_rx,
cmd_tx,
shutdown_rx,
inner.state_tx.clone(),
dispatch_tx,
Arc::clone(&shared),
);
let actor = tokio::spawn(async move {
if AssertUnwindSafe(actor.run(ready_tx))
.catch_unwind()
.await
.is_err()
{
tracing::error!("the socket.io connection task panicked; the client is closed");
shared.connected.store(false, Ordering::Release);
shared.closed.store(true, Ordering::Release);
panic_state.send_replace(ConnectionState::Closed {
reason: crate::DisconnectReason::TransportError,
error: None,
});
}
});
*inner.actor.lock().unwrap_or_else(PoisonError::into_inner) = Some(actor);
*inner
.dispatcher
.lock()
.unwrap_or_else(PoisonError::into_inner) = Some(dispatcher);
ready_rx
}
pub(crate) fn resolve(config: &Config) -> Result<(url::Url, String)> {
let mut url = url::Url::parse(&config.address)?;
let url_nsp = match url.path() {
"" | "/" => None,
path => Some(percent_decode(path)),
};
let nsp = config
.namespace
.clone()
.or(url_nsp)
.unwrap_or_else(|| "/".to_owned());
url.set_path(&config.path);
if !config.query.is_empty() {
url.query_pairs_mut().extend_pairs(&config.query);
}
Ok((url, nsp))
}
fn percent_decode(path: &str) -> String {
let bytes = path.as_bytes();
let mut out = Vec::with_capacity(bytes.len());
let mut i = 0;
while i < bytes.len() {
let hex = |b: u8| (b as char).to_digit(16);
if bytes[i] == b'%' && i + 2 < bytes.len() {
if let (Some(h), Some(l)) = (hex(bytes[i + 1]), hex(bytes[i + 2])) {
out.push((h * 16 + l) as u8);
i += 3;
continue;
}
}
out.push(bytes[i]);
i += 1;
}
String::from_utf8_lossy(&out).into_owned()
}
async fn dispatch(mut rx: mpsc::UnboundedReceiver<Dispatch>, inner: Weak<Inner>) {
while let Some(item) = rx.recv().await {
let Some(strong) = inner.upgrade() else {
break;
};
if strong.shared.muted.load(Ordering::Acquire) {
continue;
}
let client = Client {
inner: Arc::clone(&strong),
};
drop(strong);
match item {
Dispatch::Event(event) => {
let handlers = client.handlers().take_for_event(event.name());
for handler in handlers {
if client.inner.shared.muted.load(Ordering::Acquire) {
break;
}
run(handler(event.clone(), client.clone())).await;
}
}
Dispatch::State(state) => {
let handlers = client.handlers().state_handlers();
for handler in handlers {
if client.inner.shared.muted.load(Ordering::Acquire) {
break;
}
run(handler(state.clone(), client.clone())).await;
}
}
}
}
}
async fn run(fut: futures_util::future::BoxFuture<'static, ()>) {
if IN_HANDLER_TASK
.scope((), AssertUnwindSafe(fut).catch_unwind())
.await
.is_err()
{
tracing::error!("an event handler panicked");
}
}
impl Client {
fn cmd(&self) -> mpsc::UnboundedSender<Command> {
self.inner
.cmd
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
pub async fn reconnect(&self) -> Result<()> {
let _guard = self.inner.restart.lock().await;
let seen = *self.lifecycle();
if !self.state().is_closed() {
return Ok(());
}
let actor = self
.inner
.actor
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
if let Some(actor) = actor {
let _ = actor.await;
}
let dispatcher = self
.inner
.dispatcher
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
if let Some(dispatcher) = dispatcher {
if tokio::time::timeout(HANDLER_DRAIN, &mut Box::pin(dispatcher))
.await
.is_err()
{
tracing::warn!(
"handlers still running after {HANDLER_DRAIN:?}; reconnecting anyway"
);
}
}
#[cfg(test)]
tests::reconnect_pause(&self.inner.nsp).await;
let ready = {
let lifecycle = self.lifecycle();
if *lifecycle != seen {
return Err(Error::Closed);
}
start(&self.inner)
};
match ready.await {
Ok(result) => result,
Err(_) => Err(Error::Closed),
}
}
fn lifecycle(&self) -> std::sync::MutexGuard<'_, u64> {
self.inner
.lifecycle
.lock()
.unwrap_or_else(PoisonError::into_inner)
}
fn handlers(&self) -> std::sync::MutexGuard<'_, Handlers> {
self.inner
.handlers
.lock()
.unwrap_or_else(PoisonError::into_inner)
}
fn event_packet(&self, event: &str, data: Payload) -> Result<Packet> {
if is_reserved_event(event) {
return Err(Error::ReservedEvent(event.to_owned()));
}
Ok(Packet::new_event(data, event, &self.inner.nsp, None)?)
}
fn check_open(&self) -> Result<()> {
let shared = &self.inner.shared;
if shared.closed.load(Ordering::Acquire) {
return Err(Error::Closed);
}
if !self.inner.buffer_while_disconnected && !shared.connected.load(Ordering::Acquire) {
return Err(Error::NotConnected);
}
Ok(())
}
pub fn emit(&self, event: impl AsRef<str>, data: impl Into<Payload>) -> Result<()> {
let packet = self.event_packet(event.as_ref(), data.into())?;
self.check_open()?;
self.cmd()
.send(Command::Emit { packet, ack: None })
.map_err(|_| Error::Closed)
}
pub async fn emit_with_ack(
&self,
event: impl AsRef<str>,
data: impl Into<Payload>,
timeout: Duration,
) -> Result<Payload> {
let packet = self.event_packet(event.as_ref(), data.into())?;
self.check_open()?;
let (tx, rx) = oneshot::channel();
self.cmd()
.send(Command::Emit {
packet,
ack: Some((tx, timeout)),
})
.map_err(|_| Error::Closed)?;
rx.await.map_err(|_| Error::Closed)?
}
pub fn on<M>(&self, event: impl Into<String>, handler: impl Handler<Event, M>) -> ListenerId {
self.handlers()
.on(event.into(), handler.into_boxed(), false)
}
pub fn once<M>(&self, event: impl Into<String>, handler: impl Handler<Event, M>) -> ListenerId {
self.handlers().on(event.into(), handler.into_boxed(), true)
}
pub fn on_any<M>(&self, handler: impl Handler<Event, M>) -> ListenerId {
self.handlers().on_any(handler.into_boxed())
}
pub fn on_state_change<M>(&self, handler: impl Handler<ConnectionState, M>) -> ListenerId {
self.handlers().on_state(handler.into_boxed())
}
pub fn off(&self, event: &str) -> usize {
self.handlers().off(event)
}
pub fn off_any(&self) -> usize {
self.handlers().off_any()
}
pub fn off_listener(&self, id: ListenerId) -> bool {
self.handlers().off_listener(id)
}
pub fn listener_count(&self, event: &str) -> usize {
self.handlers().listener_count(event)
}
pub fn state(&self) -> ConnectionState {
self.inner.state.borrow().clone()
}
pub fn state_watch(&self) -> watch::Receiver<ConnectionState> {
self.inner.state.clone()
}
pub async fn wait_for(&self, predicate: impl Fn(&ConnectionState) -> bool) -> ConnectionState {
let mut watch = self.inner.state.clone();
loop {
let state = watch.borrow_and_update().clone();
if predicate(&state) || state.is_closed() {
return state;
}
if watch.changed().await.is_err() {
return watch.borrow().clone();
}
}
}
pub fn connected(&self) -> bool {
self.inner.shared.connected.load(Ordering::Acquire)
}
pub fn id(&self) -> Option<String> {
self.inner.shared.link().sid.clone()
}
pub fn namespace(&self) -> &str {
&self.inner.nsp
}
pub fn recovered(&self) -> bool {
matches!(
self.state(),
ConnectionState::Connected {
recovered: true,
..
}
)
}
pub fn link_info(&self) -> LinkInfo {
self.inner.shared.link().clone()
}
pub async fn disconnect(&self) -> Result<()> {
let (cmd, actor, dispatcher) = {
let mut lifecycle = self.lifecycle();
*lifecycle += 1;
let actor = self
.inner
.actor
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
let dispatcher = if in_handler() {
None
} else {
self.inner
.dispatcher
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take()
};
(self.cmd(), actor, dispatcher)
};
let (tx, rx) = oneshot::channel();
if cmd.send(Command::Disconnect { done: tx }).is_ok() {
let _ = rx.await;
}
if let Some(actor) = actor {
let _ = actor.await;
}
{
if let Some(mut dispatcher) = dispatcher {
if tokio::time::timeout(HANDLER_DRAIN, &mut dispatcher)
.await
.is_err()
{
tracing::warn!(
"handlers still running after {HANDLER_DRAIN:?}; event task stopped"
);
dispatcher.abort();
let _ = dispatcher.await;
}
}
}
self.inner.shared.muted.store(true, Ordering::Release);
Ok(())
}
}
impl Drop for Inner {
fn drop(&mut self) {
self.shared.muted.store(true, Ordering::Release);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::OnceLock;
use tokio::sync::Notify;
type Pause = (String, Arc<Notify>, Arc<Notify>);
static PAUSE: OnceLock<Mutex<Option<Pause>>> = OnceLock::new();
pub(super) async fn reconnect_pause(nsp: &str) {
let pause = PAUSE.get_or_init(Mutex::default).lock().unwrap().clone();
if let Some((target, reached, go)) = pause {
if target == nsp {
reached.notify_one();
go.notified().await;
}
}
}
async fn closed_client(url: String) -> Client {
let client = crate::ClientBuilder::new(url).connect().await.unwrap();
client.emit("server_disconnect", ()).unwrap();
client.wait_for(ConnectionState::is_closed).await;
client
}
#[tokio::test(flavor = "multi_thread")]
async fn disconnect_during_reconnect_wins() {
tokio::time::timeout(std::time::Duration::from_secs(90), async move {
let client = closed_client(socketio_next_testing::socket_io_server()).await;
let (reached, go) = (Arc::new(Notify::new()), Arc::new(Notify::new()));
*PAUSE.get_or_init(Mutex::default).lock().unwrap() =
Some(("/".into(), Arc::clone(&reached), Arc::clone(&go)));
let reconnecting = {
let client = client.clone();
tokio::spawn(async move { client.reconnect().await })
};
reached.notified().await;
*PAUSE.get().unwrap().lock().unwrap() = None;
client.disconnect().await.unwrap();
go.notify_one();
let result = tokio::time::timeout(Duration::from_secs(5), reconnecting)
.await
.unwrap()
.unwrap();
assert!(matches!(result, Err(Error::Closed)), "{result:?}");
tokio::time::sleep(Duration::from_millis(300)).await;
assert!(client.state().is_closed() && !client.connected());
})
.await
.expect("test `disconnect_during_reconnect_wins` timed out")
}
#[tokio::test(flavor = "multi_thread")]
async fn disconnect_during_a_reconnect_attempt_returns() {
tokio::time::timeout(std::time::Duration::from_secs(90), async move {
let client = closed_client(format!(
"{}/slow",
socketio_next_testing::socket_io_server()
))
.await;
let reconnecting = {
let client = client.clone();
tokio::spawn(async move { client.reconnect().await })
};
tokio::time::sleep(Duration::from_millis(50)).await;
tokio::time::timeout(Duration::from_secs(5), client.disconnect())
.await
.expect("disconnect did not hang")
.unwrap();
let _ = tokio::time::timeout(Duration::from_secs(5), reconnecting)
.await
.unwrap();
tokio::time::sleep(Duration::from_millis(300)).await;
assert!(
client.state().is_closed() && !client.connected(),
"{:?}",
client.state()
);
})
.await
.expect("test `disconnect_during_a_reconnect_attempt_returns` timed out")
}
#[test]
fn percent_decode_paths() {
assert_eq!(super::percent_decode("/%C3%A4dmin"), "/ädmin");
assert_eq!(super::percent_decode("/a%2"), "/a%2");
assert_eq!(super::percent_decode("/plain"), "/plain");
}
}