Skip to main content

socketio_next/
handler.rs

1//! Event handlers: plain closures or closures returning a future, no manual boxing.
2
3use std::collections::HashMap;
4use std::fmt;
5use std::future::Future;
6use std::sync::Arc;
7
8use futures_util::FutureExt;
9use futures_util::future::BoxFuture;
10
11use crate::Client;
12
13/// A handler, type-erased.
14pub(crate) type BoxHandler<A> = Arc<dyn Fn(A, Client) -> BoxFuture<'static, ()> + Send + Sync>;
15
16/// Something that can handle `A` (an [`Event`](crate::Event) or a
17/// [`ConnectionState`](crate::ConnectionState)) together with the [`Client`].
18///
19/// Implemented for
20/// - `Fn(A, Client) -> impl Future<Output = ()>`: `|event, client| async move { .. }`, run on
21///   the client's event task;
22/// - `Fn(A, Client)`: a plain closure, run on tokio's blocking pool so it may block.
23///
24/// Handlers run one at a time, in arrival order. The marker `M` only tells the two apart.
25pub trait Handler<A, M>: Send + Sync + 'static {
26    #[doc(hidden)]
27    fn into_boxed(self) -> BoxHandler<A>;
28}
29
30#[doc(hidden)]
31#[derive(Debug)]
32pub enum AsyncHandler {}
33#[doc(hidden)]
34#[derive(Debug)]
35pub enum SyncHandler {}
36
37impl<A, F, Fut> Handler<A, (AsyncHandler, Fut)> for F
38where
39    A: Send + 'static,
40    F: Fn(A, Client) -> Fut + Send + Sync + 'static,
41    Fut: Future<Output = ()> + Send + 'static,
42{
43    fn into_boxed(self) -> BoxHandler<A> {
44        Arc::new(move |arg, client| self(arg, client).boxed())
45    }
46}
47
48impl<A, F> Handler<A, SyncHandler> for F
49where
50    A: Send + 'static,
51    F: Fn(A, Client) + Send + Sync + 'static,
52{
53    fn into_boxed(self) -> BoxHandler<A> {
54        let f = Arc::new(self);
55        Arc::new(move |arg, client: Client| {
56            let f = Arc::clone(&f);
57            async move {
58                let key = client.key();
59                let result = tokio::task::spawn_blocking(move || {
60                    /// Clears the marker even when the handler panics.
61                    struct Reset;
62                    impl Drop for Reset {
63                        fn drop(&mut self) {
64                            crate::client::IN_HANDLER_THREAD.with(|k| k.set(0));
65                        }
66                    }
67                    crate::client::IN_HANDLER_THREAD.with(|k| k.set(key));
68                    let _reset = Reset;
69                    f(arg, client);
70                })
71                .await;
72                if let Err(err) = result {
73                    if err.is_panic() {
74                        tracing::error!("an event handler panicked");
75                    }
76                }
77            }
78            .boxed()
79        })
80    }
81}
82
83/// Identifies one registered listener (see [`Client::off_listener`](crate::Client::off_listener)).
84#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
85pub struct ListenerId(u64);
86
87struct Entry<A> {
88    id: ListenerId,
89    handler: BoxHandler<A>,
90    once: bool,
91}
92
93impl<A> Clone for Entry<A> {
94    fn clone(&self) -> Self {
95        Entry {
96            id: self.id,
97            handler: Arc::clone(&self.handler),
98            once: self.once,
99        }
100    }
101}
102
103/// All listeners of one client.
104pub(crate) struct Handlers {
105    next_id: u64,
106    events: HashMap<String, Vec<Entry<crate::Event>>>,
107    any: Vec<Entry<crate::Event>>,
108    state: Vec<Entry<crate::ConnectionState>>,
109}
110
111impl fmt::Debug for Handlers {
112    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
113        f.debug_struct("Handlers")
114            .field("events", &self.events.keys().collect::<Vec<_>>())
115            .field("any", &self.any.len())
116            .field("state", &self.state.len())
117            .finish()
118    }
119}
120
121impl Default for Handlers {
122    fn default() -> Self {
123        Handlers {
124            next_id: 1,
125            events: HashMap::new(),
126            any: Vec::new(),
127            state: Vec::new(),
128        }
129    }
130}
131
132impl Handlers {
133    fn id(&mut self) -> ListenerId {
134        self.next_id += 1;
135        ListenerId(self.next_id)
136    }
137
138    pub(crate) fn on(
139        &mut self,
140        event: String,
141        handler: BoxHandler<crate::Event>,
142        once: bool,
143    ) -> ListenerId {
144        let id = self.id();
145        self.events
146            .entry(event)
147            .or_default()
148            .push(Entry { id, handler, once });
149        id
150    }
151
152    pub(crate) fn on_any(&mut self, handler: BoxHandler<crate::Event>) -> ListenerId {
153        let id = self.id();
154        self.any.push(Entry {
155            id,
156            handler,
157            once: false,
158        });
159        id
160    }
161
162    pub(crate) fn on_state(&mut self, handler: BoxHandler<crate::ConnectionState>) -> ListenerId {
163        let id = self.id();
164        self.state.push(Entry {
165            id,
166            handler,
167            once: false,
168        });
169        id
170    }
171
172    /// Removes every listener of `event`.
173    pub(crate) fn off(&mut self, event: &str) -> usize {
174        self.events.remove(event).map_or(0, |v| v.len())
175    }
176
177    pub(crate) fn off_any(&mut self) -> usize {
178        std::mem::take(&mut self.any).len()
179    }
180
181    pub(crate) fn off_listener(&mut self, id: ListenerId) -> bool {
182        let mut removed = false;
183        for list in self.events.values_mut() {
184            let before = list.len();
185            list.retain(|e| e.id != id);
186            removed |= list.len() != before;
187        }
188        self.events.retain(|_, list| !list.is_empty());
189        let before = self.any.len();
190        self.any.retain(|e| e.id != id);
191        removed |= self.any.len() != before;
192        let before = self.state.len();
193        self.state.retain(|e| e.id != id);
194        removed | (self.state.len() != before)
195    }
196
197    pub(crate) fn listener_count(&self, event: &str) -> usize {
198        self.events.get(event).map_or(0, Vec::len)
199    }
200
201    /// The handlers for `event`: catch-all ones first (socket.io-client `onAny` order), then
202    /// the event's own. `once` listeners are removed here.
203    pub(crate) fn take_for_event(&mut self, event: &str) -> Vec<BoxHandler<crate::Event>> {
204        let mut out: Vec<_> = self.any.iter().map(|e| Arc::clone(&e.handler)).collect();
205        if let Some(list) = self.events.get_mut(event) {
206            out.extend(list.iter().map(|e| Arc::clone(&e.handler)));
207            list.retain(|e| !e.once);
208            if list.is_empty() {
209                self.events.remove(event);
210            }
211        }
212        out
213    }
214
215    pub(crate) fn state_handlers(&self) -> Vec<BoxHandler<crate::ConnectionState>> {
216        self.state.iter().map(|e| Arc::clone(&e.handler)).collect()
217    }
218}