use std::cell::Cell;
use std::fmt;
use std::panic::AssertUnwindSafe;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, PoisonError, Weak};
use std::time::Duration;
use futures_util::FutureExt;
use tokio::sync::{mpsc, oneshot, watch};
use crate::actor::{Actor, Command, Cut, Dispatch, Link};
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: usize;
}
thread_local! {
pub(crate) static IN_HANDLER_THREAD: Cell<usize> = const { Cell::new(0) };
}
const HANDLER_DRAIN: Duration = Duration::from_secs(5);
pub(crate) struct Inner {
cmd: mpsc::UnboundedSender<Command>,
_shutdown: oneshot::Sender<()>,
state: watch::Receiver<ConnectionState>,
link: Link,
handlers: Mutex<Handlers>,
nsp: Arc<str>,
buffer_while_disconnected: bool,
}
#[derive(Clone)]
pub struct Client {
inner: Arc<Inner>,
}
#[derive(Clone)]
pub struct WeakClient {
inner: Weak<Inner>,
}
impl WeakClient {
pub fn upgrade(&self) -> Option<Client> {
self.inner.upgrade().map(|inner| Client { inner })
}
}
impl fmt::Debug for WeakClient {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WeakClient")
.field("alive", &(self.inner.strong_count() > 0))
.finish()
}
}
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 (url, nsp) = resolve(&config)?;
let nsp: Arc<str> = nsp.into();
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();
let (state_tx, state_rx) = watch::channel(ConnectionState::Connecting { attempt: 0 });
let link = Link::default();
let cut: Cut = Arc::new(AtomicU64::new(0));
let inner = Arc::new(Inner {
cmd: cmd_tx.clone(),
_shutdown: shutdown_tx,
state: state_rx,
link: link.clone(),
handlers: Mutex::new(handlers),
nsp: Arc::clone(&nsp),
buffer_while_disconnected: config.buffer_while_disconnected,
});
tokio::spawn(dispatch(
dispatch_rx,
Arc::downgrade(&inner),
Arc::clone(&cut),
));
let panic_state = state_tx.clone();
let panic_dispatch = dispatch_tx.clone();
let actor = Actor::new(
config,
url,
nsp,
cmd_rx,
cmd_tx,
shutdown_rx,
state_tx,
dispatch_tx,
link,
cut,
);
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");
let closed = ConnectionState::Closed {
reason: crate::DisconnectReason::TransportError,
error: None,
};
panic_state.send_replace(closed.clone());
let _ = panic_dispatch.send(Dispatch::State(closed));
}
});
match ready_rx.await {
Ok(Ok(())) => Ok(Client { inner }),
Ok(Err(err)) => Err(err),
Err(_) => Err(Error::Closed),
}
}
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>, cut: Cut) {
while let Some(item) = rx.recv().await {
let Some(strong) = inner.upgrade() else {
break;
};
let client = Client { inner: strong };
let key = client.key();
match item {
Dispatch::Event { session, event } => {
let handlers = client.handlers().take_for_event(event.name());
for handler in handlers {
if session < cut.load(Ordering::Acquire) {
break;
}
run(key, || handler(event.clone(), client.clone())).await;
}
}
Dispatch::State(state) => {
let handlers = client.handlers().state_handlers();
for handler in handlers {
run(key, || handler(state.clone(), client.clone())).await;
}
}
Dispatch::Fence(reached) => {
let _ = reached.send(());
}
}
}
}
async fn run(key: usize, call: impl FnOnce() -> futures_util::future::BoxFuture<'static, ()>) {
let guarded = async move {
let fut = std::panic::catch_unwind(AssertUnwindSafe(call)).map_err(|_| ())?;
AssertUnwindSafe(fut).catch_unwind().await.map_err(|_| ())
};
if IN_HANDLER_TASK.scope(key, guarded).await.is_err() {
tracing::error!("an event handler panicked");
}
}
impl Client {
pub fn downgrade(&self) -> WeakClient {
WeakClient {
inner: Arc::downgrade(&self.inner),
}
}
pub(crate) fn key(&self) -> usize {
Arc::as_ptr(&self.inner) as usize
}
fn in_own_handler(&self) -> bool {
let key = self.key();
IN_HANDLER_TASK.try_with(|k| *k == key).unwrap_or(false)
|| IN_HANDLER_THREAD.with(Cell::get) == key
}
pub async fn reconnect(&self) -> Result<()> {
let (ready, rx) = oneshot::channel();
self.inner
.cmd
.send(Command::Reconnect { ready })
.map_err(|_| Error::Closed)?;
rx.await.map_err(|_| Error::Closed)?
}
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<()> {
match &*self.inner.state.borrow() {
ConnectionState::Closed { .. } => Err(Error::Closed),
ConnectionState::Connected { .. } => Ok(()),
_ if self.inner.buffer_while_disconnected => Ok(()),
_ => Err(Error::NotConnected),
}
}
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.inner
.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.inner
.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.state.borrow().is_connected()
}
pub fn id(&self) -> Option<String> {
match &*self.inner.state.borrow() {
ConnectionState::Connected { sid, .. } => Some(sid.clone()),
_ => None,
}
}
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.link.get().clone()
}
pub async fn disconnect(&self) -> Result<()> {
let (done, rx) = oneshot::channel();
if self.inner.cmd.send(Command::Disconnect { done }).is_err() {
return Ok(()); }
let Ok(fence) = rx.await else {
return Ok(());
};
if !self.in_own_handler() && tokio::time::timeout(HANDLER_DRAIN, fence).await.is_err() {
tracing::warn!("handlers still running {HANDLER_DRAIN:?} after disconnect()");
}
Ok(())
}
}
#[cfg(test)]
mod tests {
#[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");
}
}