use std::collections::HashMap;
use std::sync::Mutex;
use serde_json::Value;
use tokio::sync::oneshot;
pub struct RequestRouter {
pending: Mutex<HashMap<String, oneshot::Sender<Value>>>,
contador: Mutex<u64>,
}
impl Default for RequestRouter {
fn default() -> Self {
Self::new()
}
}
impl RequestRouter {
pub fn new() -> Self {
Self {
pending: Mutex::new(HashMap::new()),
contador: Mutex::new(0),
}
}
pub fn register(&self, prefijo: &str) -> (String, oneshot::Receiver<Value>) {
let (tx, rx) = oneshot::channel();
let id = self.next_id(prefijo);
let mut pending = self.pending.lock().expect("router no envenenado");
pending.insert(id.clone(), tx);
(id, rx)
}
pub fn next_id(&self, prefijo: &str) -> String {
let mut contador = self.contador.lock().expect("router no envenenado");
*contador += 1;
format!("{prefijo}-{}-{}", uuid_v4_simple(), *contador)
}
pub fn discard(&self, request_id: &str) -> bool {
self.pending
.lock()
.expect("router no envenenado")
.remove(request_id)
.is_some()
}
pub fn fail_all(&self) -> usize {
let mut pending = self.pending.lock().expect("router no envenenado");
let total = pending.len();
pending.clear();
total
}
pub fn deliver(&self, request_id: Option<&str>, msg: Value) -> bool {
let id = match request_id {
Some(i) if !i.is_empty() => i,
_ => return false,
};
let tx = {
let mut pending = self.pending.lock().expect("router no envenenado");
pending.remove(id)
};
match tx {
Some(tx) => tx.send(msg).is_ok(),
None => false,
}
}
pub fn pending_count(&self) -> usize {
self.pending.lock().expect("router no envenenado").len()
}
}
fn uuid_v4_simple() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.subsec_nanos())
.unwrap_or(0);
format!("{nanos:08x}")
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn entrega_por_request_id() {
let r = RequestRouter::new();
let (id, mut rx) = r.register("test");
assert_eq!(r.pending_count(), 1);
assert!(r.deliver(Some(&id), json!({"ok": true})));
assert_eq!(r.pending_count(), 0);
let recibido = rx.try_recv().expect("mensaje pendiente");
assert_eq!(recibido, json!({"ok": true}));
}
#[test]
fn id_desconocido_se_descarta() {
let r = RequestRouter::new();
assert!(!r.deliver(Some("no-existe"), json!(null)));
assert!(!r.deliver(None, json!(null)));
assert!(!r.deliver(Some(""), json!(null)));
}
#[test]
fn receptor_desperdiciado_se_ignora() {
let r = RequestRouter::new();
let (id, rx) = r.register("test");
drop(rx);
assert!(!r.deliver(Some(&id), json!(null)));
assert_eq!(r.pending_count(), 0);
}
#[test]
fn ids_son_unicos() {
let r = RequestRouter::new();
let (a, _rx_a) = r.register("x");
let (b, _rx_b) = r.register("x");
assert_ne!(a, b);
assert_eq!(r.pending_count(), 2);
}
#[test]
fn discard_libera_la_entrada() {
let r = RequestRouter::new();
let (id, _rx) = r.register("t");
assert!(r.discard(&id));
assert_eq!(r.pending_count(), 0);
assert!(!r.discard(&id), "descartar dos veces no debe mentir");
}
#[test]
fn next_id_no_registra_entrada() {
let r = RequestRouter::new();
let id = r.next_id("sub");
assert!(id.starts_with("sub-"));
assert_eq!(r.pending_count(), 0);
}
#[tokio::test]
async fn fail_all_despierta_a_los_esperadores() {
let r = RequestRouter::new();
let (_a, rx_a) = r.register("x");
let (_b, rx_b) = r.register("x");
assert_eq!(r.fail_all(), 2);
assert_eq!(r.pending_count(), 0);
assert!(rx_a.await.is_err(), "el esperador debe despertar con error");
assert!(rx_b.await.is_err(), "el esperador debe despertar con error");
}
}