cripsy_binary_api/transport/
router.rs1use std::collections::HashMap;
10use std::sync::Mutex;
11
12use serde_json::Value;
13use tokio::sync::oneshot;
14
15pub 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 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 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 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 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 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 pub fn pending_count(&self) -> usize {
100 self.pending.lock().expect("router no envenenado").len()
101 }
102}
103
104fn 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}