use serde_json::Value;
use std::collections::HashMap;
use std::sync::{LazyLock, RwLock};
use tokio::sync::oneshot;
use super::types::BidirError;
type ResponseSender = oneshot::Sender<Value>;
struct Pending {
sender: ResponseSender,
asker: Option<usize>,
}
static PENDING_RESPONSES: LazyLock<RwLock<HashMap<String, Pending>>> =
LazyLock::new(|| RwLock::new(HashMap::new()));
pub fn register_pending_request(request_id: String, sender: ResponseSender) {
let mut registry = PENDING_RESPONSES.write().unwrap();
registry.insert(request_id, Pending { sender, asker: None });
}
pub fn bind_asker(request_id: &str, connection: usize) -> bool {
let mut registry = PENDING_RESPONSES.write().unwrap();
match registry.get_mut(request_id) {
Some(p) if p.asker.is_none() => {
p.asker = Some(connection);
true
}
_ => false,
}
}
pub fn unregister_pending_request(request_id: &str) -> Option<ResponseSender> {
let mut registry = PENDING_RESPONSES.write().unwrap();
registry.remove(request_id).map(|p| p.sender)
}
pub fn handle_pending_response(request_id: &str, response_data: Value) -> Result<(), BidirError> {
answer_pending(request_id, None, response_data)
}
pub fn answer_pending(request_id: &str, from: Option<usize>, response_data: Value) -> Result<(), BidirError> {
let sender = {
let mut registry = PENDING_RESPONSES.write().unwrap();
match registry.get(request_id) {
None => return Err(BidirError::UnknownRequest),
Some(Pending { asker: Some(a), .. }) if from != Some(*a) => return Err(BidirError::NotThisCall),
Some(_) => registry.remove(request_id).map(|p| p.sender),
}
};
match sender {
Some(tx) => tx.send(response_data).map_err(|_| BidirError::ChannelClosed),
None => Err(BidirError::UnknownRequest),
}
}
pub fn is_request_pending(request_id: &str) -> bool {
let registry = PENDING_RESPONSES.read().unwrap();
registry.contains_key(request_id)
}
pub fn pending_count() -> usize {
let registry = PENDING_RESPONSES.read().unwrap();
registry.len()
}
#[cfg(test)]
#[allow(dead_code)]
pub fn clear_all() {
let mut registry = PENDING_RESPONSES.write().unwrap();
registry.clear();
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_register_and_handle() {
let (tx, rx) = oneshot::channel();
let request_id = format!("test-reg-handle-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
assert!(is_request_pending(&request_id));
let response = serde_json::json!({"confirmed": true});
handle_pending_response(&request_id, response.clone()).unwrap();
let received = rx.await.unwrap();
assert_eq!(received, response);
assert!(!is_request_pending(&request_id));
}
#[tokio::test]
async fn test_unknown_request() {
let result = handle_pending_response(
&format!("nonexistent-{}", uuid::Uuid::new_v4()),
serde_json::json!({}),
);
assert!(matches!(result, Err(BidirError::UnknownRequest)));
}
#[tokio::test]
async fn test_unregister() {
let (tx, _rx) = oneshot::channel();
let request_id = format!("test-unreg-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
assert!(is_request_pending(&request_id));
let removed = unregister_pending_request(&request_id);
assert!(removed.is_some());
assert!(!is_request_pending(&request_id));
}
#[tokio::test]
async fn test_channel_closed() {
let (tx, rx) = oneshot::channel();
let request_id = format!("test-closed-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
drop(rx);
let result = handle_pending_response(&request_id, serde_json::json!({}));
assert!(matches!(result, Err(BidirError::ChannelClosed)));
}
#[tokio::test]
async fn test_answer_from_other_connection_refused() {
let (tx, rx) = oneshot::channel();
let request_id = format!("test-asker-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
assert!(bind_asker(&request_id, 7));
assert!(!bind_asker(&request_id, 8), "the first binding holds");
let r = answer_pending(&request_id, Some(8), serde_json::json!(true));
assert!(matches!(r, Err(BidirError::NotThisCall)), "{r:?}");
assert!(is_request_pending(&request_id), "a refused answer leaves the question");
answer_pending(&request_id, Some(7), serde_json::json!(true)).unwrap();
assert_eq!(rx.await.unwrap(), serde_json::json!(true));
assert!(!is_request_pending(&request_id));
}
#[tokio::test]
async fn test_unbound_entry_answers_from_anyone() {
let (tx, rx) = oneshot::channel();
let request_id = format!("test-unbound-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
answer_pending(&request_id, Some(3), serde_json::json!(1)).unwrap();
assert_eq!(rx.await.unwrap(), serde_json::json!(1));
}
#[tokio::test]
async fn test_unchecked_answer_refused_when_bound() {
let (tx, _rx) = oneshot::channel();
let request_id = format!("test-unchecked-{}", uuid::Uuid::new_v4());
register_pending_request(request_id.clone(), tx);
bind_asker(&request_id, 1);
let r = handle_pending_response(&request_id, serde_json::json!(1));
assert!(matches!(r, Err(BidirError::NotThisCall)), "{r:?}");
assert!(is_request_pending(&request_id));
unregister_pending_request(&request_id);
}
}