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| {
56            let f = Arc::clone(&f);
57            async move {
58                let result = tokio::task::spawn_blocking(move || {
59                    /// Clears the flag even when the handler panics.
60                    struct Reset;
61                    impl Drop for Reset {
62                        fn drop(&mut self) {
63                            crate::client::IN_HANDLER_THREAD.with(|flag| flag.set(false));
64                        }
65                    }
66                    crate::client::IN_HANDLER_THREAD.with(|flag| flag.set(true));
67                    let _reset = Reset;
68                    f(arg, client);
69                })
70                .await;
71                if let Err(err) = result {
72                    if err.is_panic() {
73                        tracing::error!("an event handler panicked");
74                    }
75                }
76            }
77            .boxed()
78        })
79    }
80}
81
82/// Identifies one registered listener (see [`Client::off_listener`](crate::Client::off_listener)).
83#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
84pub struct ListenerId(u64);
85
86struct Entry<A> {
87    id: ListenerId,
88    handler: BoxHandler<A>,
89    once: bool,
90}
91
92impl<A> Clone for Entry<A> {
93    fn clone(&self) -> Self {
94        Entry {
95            id: self.id,
96            handler: Arc::clone(&self.handler),
97            once: self.once,
98        }
99    }
100}
101
102/// All listeners of one client.
103pub(crate) struct Handlers {
104    next_id: u64,
105    events: HashMap<String, Vec<Entry<crate::Event>>>,
106    any: Vec<Entry<crate::Event>>,
107    state: Vec<Entry<crate::ConnectionState>>,
108}
109
110impl fmt::Debug for Handlers {
111    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
112        f.debug_struct("Handlers")
113            .field("events", &self.events.keys().collect::<Vec<_>>())
114            .field("any", &self.any.len())
115            .field("state", &self.state.len())
116            .finish()
117    }
118}
119
120impl Default for Handlers {
121    fn default() -> Self {
122        Handlers {
123            next_id: 1,
124            events: HashMap::new(),
125            any: Vec::new(),
126            state: Vec::new(),
127        }
128    }
129}
130
131impl Handlers {
132    fn id(&mut self) -> ListenerId {
133        self.next_id += 1;
134        ListenerId(self.next_id)
135    }
136
137    pub(crate) fn on(
138        &mut self,
139        event: String,
140        handler: BoxHandler<crate::Event>,
141        once: bool,
142    ) -> ListenerId {
143        let id = self.id();
144        self.events
145            .entry(event)
146            .or_default()
147            .push(Entry { id, handler, once });
148        id
149    }
150
151    pub(crate) fn on_any(&mut self, handler: BoxHandler<crate::Event>) -> ListenerId {
152        let id = self.id();
153        self.any.push(Entry {
154            id,
155            handler,
156            once: false,
157        });
158        id
159    }
160
161    pub(crate) fn on_state(&mut self, handler: BoxHandler<crate::ConnectionState>) -> ListenerId {
162        let id = self.id();
163        self.state.push(Entry {
164            id,
165            handler,
166            once: false,
167        });
168        id
169    }
170
171    /// Removes every listener of `event`.
172    pub(crate) fn off(&mut self, event: &str) -> usize {
173        self.events.remove(event).map_or(0, |v| v.len())
174    }
175
176    pub(crate) fn off_any(&mut self) -> usize {
177        std::mem::take(&mut self.any).len()
178    }
179
180    pub(crate) fn off_listener(&mut self, id: ListenerId) -> bool {
181        let mut removed = false;
182        for list in self.events.values_mut() {
183            let before = list.len();
184            list.retain(|e| e.id != id);
185            removed |= list.len() != before;
186        }
187        self.events.retain(|_, list| !list.is_empty());
188        let before = self.any.len();
189        self.any.retain(|e| e.id != id);
190        removed |= self.any.len() != before;
191        let before = self.state.len();
192        self.state.retain(|e| e.id != id);
193        removed | (self.state.len() != before)
194    }
195
196    pub(crate) fn listener_count(&self, event: &str) -> usize {
197        self.events.get(event).map_or(0, Vec::len)
198    }
199
200    /// The handlers for `event`: catch-all ones first (socket.io-client `onAny` order), then
201    /// the event's own. `once` listeners are removed here.
202    pub(crate) fn take_for_event(&mut self, event: &str) -> Vec<BoxHandler<crate::Event>> {
203        let mut out: Vec<_> = self.any.iter().map(|e| Arc::clone(&e.handler)).collect();
204        if let Some(list) = self.events.get_mut(event) {
205            out.extend(list.iter().map(|e| Arc::clone(&e.handler)));
206            list.retain(|e| !e.once);
207            if list.is_empty() {
208                self.events.remove(event);
209            }
210        }
211        out
212    }
213
214    pub(crate) fn state_handlers(&self) -> Vec<BoxHandler<crate::ConnectionState>> {
215        self.state.iter().map(|e| Arc::clone(&e.handler)).collect()
216    }
217}