Skip to main content

cripsy_binary_api/transport/
router.rs

1//! Router de correlación `request_id` → respuesta.
2//!
3//! El protocolo de los brókeres correlaciona respuestas por `request_id`.
4//! Este router reemplaza el patrón de espera por polling: cada solicitud se
5//! registra con un receptor; cuando llega el mensaje con ese `request_id`,
6//! la respuesta se entrega al receptor. No hay estado global: si nadie espera
7//! el id, el mensaje se descarta con traza.
8
9use std::collections::HashMap;
10use std::sync::Mutex;
11
12use serde_json::Value;
13use tokio::sync::oneshot;
14
15/// Correlaciona identificadores de solicitud con sus receptores.
16pub struct RequestRouter {
17    pending: Mutex<HashMap<String, oneshot::Sender<Value>>>,
18    contador: Mutex<u64>,
19}
20
21impl Default for RequestRouter {
22    fn default() -> Self {
23        Self::new()
24    }
25}
26
27impl RequestRouter {
28    pub fn new() -> Self {
29        Self {
30            pending: Mutex::new(HashMap::new()),
31            contador: Mutex::new(0),
32        }
33    }
34
35    /// Registra una solicitud y devuelve `(request_id, receptor)`.
36    ///
37    /// El `request_id` es único dentro del router. Si el receptor se descarta
38    /// antes de la respuesta, el mensaje se ignora en [`Self::deliver`].
39    pub fn register(&self, prefijo: &str) -> (String, oneshot::Receiver<Value>) {
40        let (tx, rx) = oneshot::channel();
41        let id = self.next_id(prefijo);
42        let mut pending = self.pending.lock().expect("router no envenenado");
43        pending.insert(id.clone(), tx);
44        (id, rx)
45    }
46
47    /// Genera un `request_id` único sin registrar receptor.
48    ///
49    /// Para mensajes que no esperan respuesta correlacionada (suscripciones):
50    /// registrar un receptor que se descarta al instante dejaría una entrada
51    /// que solo se libera si el bróker llega a responder.
52    pub fn next_id(&self, prefijo: &str) -> String {
53        let mut contador = self.contador.lock().expect("router no envenenado");
54        *contador += 1;
55        format!("{prefijo}-{}-{}", uuid_v4_simple(), *contador)
56    }
57
58    /// Retira una solicitud pendiente sin respuesta (por ejemplo, tras un
59    /// timeout). Devuelve `true` si había una entrada registrada.
60    pub fn discard(&self, request_id: &str) -> bool {
61        self.pending
62            .lock()
63            .expect("router no envenenado")
64            .remove(request_id)
65            .is_some()
66    }
67
68    /// Descarta todas las solicitudes pendientes cuando el socket se cierra.
69    ///
70    /// Los receptores despiertan con error, de modo que ninguna espera queda
71    /// colgada hasta agotar su timeout. Devuelve cuántas se descartaron.
72    pub fn fail_all(&self) -> usize {
73        let mut pending = self.pending.lock().expect("router no envenenado");
74        let total = pending.len();
75        pending.clear();
76        total
77    }
78
79    /// Entrega `msg` al receptor pendiente con ese `request_id`.
80    ///
81    /// Devuelve `true` si había un receptor vivo. Ids desconocidos o tardíos
82    /// devuelven `false` (nunca entra en pánico).
83    pub fn deliver(&self, request_id: Option<&str>, msg: Value) -> bool {
84        let id = match request_id {
85            Some(i) if !i.is_empty() => i,
86            _ => return false,
87        };
88        let tx = {
89            let mut pending = self.pending.lock().expect("router no envenenado");
90            pending.remove(id)
91        };
92        match tx {
93            Some(tx) => tx.send(msg).is_ok(),
94            None => false,
95        }
96    }
97
98    /// Número de solicitudes esperando respuesta.
99    pub fn pending_count(&self) -> usize {
100        self.pending.lock().expect("router no envenenado").len()
101    }
102}
103
104/// Identificador aleatorio corto sin dependencia externa.
105fn uuid_v4_simple() -> String {
106    use std::time::{SystemTime, UNIX_EPOCH};
107    let nanos = SystemTime::now()
108        .duration_since(UNIX_EPOCH)
109        .map(|d| d.subsec_nanos())
110        .unwrap_or(0);
111    format!("{nanos:08x}")
112}
113
114#[cfg(test)]
115mod tests {
116    use super::*;
117    use serde_json::json;
118
119    #[test]
120    fn entrega_por_request_id() {
121        let r = RequestRouter::new();
122        let (id, mut rx) = r.register("test");
123        assert_eq!(r.pending_count(), 1);
124        assert!(r.deliver(Some(&id), json!({"ok": true})));
125        assert_eq!(r.pending_count(), 0);
126        let recibido = rx.try_recv().expect("mensaje pendiente");
127        assert_eq!(recibido, json!({"ok": true}));
128    }
129
130    #[test]
131    fn id_desconocido_se_descarta() {
132        let r = RequestRouter::new();
133        assert!(!r.deliver(Some("no-existe"), json!(null)));
134        assert!(!r.deliver(None, json!(null)));
135        assert!(!r.deliver(Some(""), json!(null)));
136    }
137
138    #[test]
139    fn receptor_desperdiciado_se_ignora() {
140        let r = RequestRouter::new();
141        let (id, rx) = r.register("test");
142        drop(rx);
143        assert!(!r.deliver(Some(&id), json!(null)));
144        assert_eq!(r.pending_count(), 0);
145    }
146
147    #[test]
148    fn ids_son_unicos() {
149        let r = RequestRouter::new();
150        let (a, _rx_a) = r.register("x");
151        let (b, _rx_b) = r.register("x");
152        assert_ne!(a, b);
153        assert_eq!(r.pending_count(), 2);
154    }
155
156    #[test]
157    fn discard_libera_la_entrada() {
158        let r = RequestRouter::new();
159        let (id, _rx) = r.register("t");
160        assert!(r.discard(&id));
161        assert_eq!(r.pending_count(), 0);
162        assert!(!r.discard(&id), "descartar dos veces no debe mentir");
163    }
164
165    #[test]
166    fn next_id_no_registra_entrada() {
167        let r = RequestRouter::new();
168        let id = r.next_id("sub");
169        assert!(id.starts_with("sub-"));
170        assert_eq!(r.pending_count(), 0);
171    }
172
173    #[tokio::test]
174    async fn fail_all_despierta_a_los_esperadores() {
175        let r = RequestRouter::new();
176        let (_a, rx_a) = r.register("x");
177        let (_b, rx_b) = r.register("x");
178        assert_eq!(r.fail_all(), 2);
179        assert_eq!(r.pending_count(), 0);
180        assert!(rx_a.await.is_err(), "el esperador debe despertar con error");
181        assert!(rx_b.await.is_err(), "el esperador debe despertar con error");
182    }
183}