use crate::envelope::StreamItem;
use crate::error::TransportError;
use futures_channel::{mpsc, oneshot};
use serde_json::{json, Value};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
pub(crate) type Items = mpsc::UnboundedReceiver<Result<StreamItem, TransportError>>;
type ItemsTx = mpsc::UnboundedSender<Result<StreamItem, TransportError>>;
#[derive(Debug, Default)]
pub(crate) struct SubSlot {
state: Mutex<SlotState>,
}
#[derive(Debug, Default)]
struct SlotState {
subscription: Option<Value>,
dropped: bool,
finished: bool,
}
impl SubSlot {
pub(crate) fn new() -> Arc<Self> {
Arc::new(Self::default())
}
pub(crate) fn mark_finished(&self) {
self.lock().finished = true;
}
pub(crate) fn on_dropped(&self) -> Option<Value> {
let mut state = self.lock();
state.dropped = true;
if state.finished {
return None;
}
state.subscription.clone()
}
fn acknowledged(&self, subscription: &Value) -> bool {
let mut state = self.lock();
state.subscription = Some(subscription.clone());
state.dropped && !state.finished
}
fn lock(&self) -> MutexGuard<'_, SlotState> {
self.state.lock().unwrap_or_else(|e| e.into_inner())
}
}
#[derive(Debug)]
struct Pending {
slot: Arc<SubSlot>,
waiter: oneshot::Sender<Result<Items, TransportError>>,
}
#[derive(Debug)]
struct Sub {
sink: ItemsTx,
slot: Arc<SubSlot>,
}
#[derive(Debug, Default)]
struct State {
pending: HashMap<u64, Pending>,
subs: HashMap<String, Sub>,
closed: Option<TransportError>,
}
#[derive(Debug)]
pub(crate) struct Registry {
hub_namespace: Arc<str>,
next_id: AtomicU64,
state: Mutex<State>,
}
fn key_of(id: &Value) -> String {
id.to_string()
}
impl Registry {
pub(crate) fn new(hub_namespace: Arc<str>) -> Self {
Self {
hub_namespace,
next_id: AtomicU64::new(1),
state: Mutex::new(State::default()),
}
}
pub(crate) fn next_request_id(&self) -> u64 {
self.next_id.fetch_add(1, Ordering::Relaxed)
}
pub(crate) fn hub_namespace(&self) -> &str {
&self.hub_namespace
}
pub(crate) fn register_pending(
&self,
request_id: u64,
slot: Arc<SubSlot>,
) -> Result<oneshot::Receiver<Result<Items, TransportError>>, TransportError> {
let mut state = self.lock();
if let Some(err) = &state.closed {
return Err(err.clone());
}
let (waiter, reply) = oneshot::channel();
state.pending.insert(request_id, Pending { slot, waiter });
Ok(reply)
}
pub(crate) fn forget_pending(&self, request_id: u64) {
self.lock().pending.remove(&request_id);
}
pub(crate) fn forget_sub(&self, subscription: &Value) {
self.lock().subs.remove(&key_of(subscription));
}
#[must_use = "the returned frame cancels a subscription nobody is reading"]
pub(crate) fn on_text(&self, text: &str) -> Option<String> {
let frame = serde_json::from_str::<Value>(text).ok()?;
if let Some(request_id) = frame.get("id").and_then(Value::as_u64) {
if frame.get("result").is_some() || frame.get("error").is_some() {
return self.on_response(request_id, &frame);
}
}
if let Some(subscription) = frame.pointer("/params/subscription") {
self.on_notification(&subscription.clone(), &frame);
}
None
}
fn on_response(&self, request_id: u64, frame: &Value) -> Option<String> {
let mut state = self.lock();
let pending = state.pending.remove(&request_id)?;
if let Some(error) = frame.get("error") {
drop(state);
let _ = pending.waiter.send(Err(TransportError::protocol(format!(
"subscribe rejected: {error}"
))));
return None;
}
let subscription = frame.get("result").cloned().unwrap_or(Value::Null);
if pending.slot.acknowledged(&subscription) {
drop(state);
return Some(self.unsubscribe(&subscription));
}
let key = key_of(&subscription);
let (sink, items) = mpsc::unbounded();
state.subs.insert(
key.clone(),
Sub {
sink,
slot: pending.slot.clone(),
},
);
drop(state);
if pending.waiter.send(Ok(items)).is_err() {
self.lock().subs.remove(&key);
}
None
}
fn on_notification(&self, subscription: &Value, frame: &Value) {
let key = key_of(subscription);
let state = self.lock();
let Some((sink, slot)) = state
.subs
.get(&key)
.map(|sub| (sub.sink.clone(), sub.slot.clone()))
else {
return;
};
drop(state);
let payload = frame.pointer("/params/result").cloned().unwrap_or(Value::Null);
match serde_json::from_value::<StreamItem>(payload) {
Ok(item) => {
let terminal = item.is_terminal();
let _ = sink.unbounded_send(Ok(item));
if terminal {
slot.mark_finished();
self.forget_sub(subscription);
}
}
Err(e) => {
let _ = sink.unbounded_send(Err(TransportError::protocol(format!(
"notification payload is not a Plexus stream item: {e}"
))));
self.forget_sub(subscription);
}
}
}
pub(crate) fn on_close(&self, reason: impl Into<String>) {
let error = TransportError::closed(reason);
let (pending, subs) = {
let mut state = self.lock();
if state.closed.is_some() {
return;
}
state.closed = Some(error.clone());
(
std::mem::take(&mut state.pending),
std::mem::take(&mut state.subs),
)
};
for (_, waiting) in pending {
let _ = waiting.waiter.send(Err(error.clone()));
}
for (_, sub) in subs {
let _ = sub.sink.unbounded_send(Err(error.clone()));
}
}
pub(crate) fn is_closed(&self) -> bool {
self.lock().closed.is_some()
}
pub(crate) fn unsubscribe(&self, subscription: &Value) -> String {
unsubscribe_frame(self.next_request_id(), &self.hub_namespace, subscription)
}
fn lock(&self) -> MutexGuard<'_, State> {
self.state.lock().unwrap_or_else(|e| e.into_inner())
}
}
pub(crate) fn subscribe_frame(
request_id: u64,
hub_namespace: &str,
qualified_method: &str,
params: &Value,
) -> String {
json!({
"jsonrpc": "2.0",
"id": request_id,
"method": format!("{hub_namespace}.call"),
"params": { "method": qualified_method, "params": params },
})
.to_string()
}
fn unsubscribe_frame(request_id: u64, hub_namespace: &str, subscription: &Value) -> String {
json!({
"jsonrpc": "2.0",
"id": request_id,
"method": format!("{hub_namespace}.call_unsub"),
"params": [subscription],
})
.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_subscribe_frame_is_the_one_menger_speaks() {
let frame = subscribe_frame(1, "menger", "tickets.watch", &json!({"epic": "MACRO"}));
let parsed: Value = serde_json::from_str(&frame).unwrap();
assert_eq!(parsed["jsonrpc"], "2.0");
assert_eq!(parsed["id"], 1);
assert_eq!(parsed["method"], "menger.call");
assert_eq!(parsed["params"]["method"], "tickets.watch");
assert_eq!(parsed["params"]["params"], json!({"epic": "MACRO"}));
}
#[test]
fn the_unsubscribe_frame_carries_the_id_positionally() {
let frame = unsubscribe_frame(9, "menger", &json!(42));
let parsed: Value = serde_json::from_str(&frame).unwrap();
assert_eq!(parsed["method"], "menger.call_unsub");
assert_eq!(parsed["params"], json!([42]));
}
#[test]
fn a_numeric_and_a_string_subscription_id_do_not_collide() {
assert_ne!(key_of(&json!(7)), key_of(&json!("7")));
}
#[test]
fn an_acknowledged_slot_leaves_cancellation_to_the_caller() {
let slot = SubSlot::new();
assert!(!slot.acknowledged(&json!(1)), "nobody has dropped anything");
assert_eq!(slot.on_dropped(), Some(json!(1)), "the caller cancels");
}
#[test]
fn a_slot_dropped_before_the_reply_is_cancelled_by_the_reader() {
let slot = SubSlot::new();
assert_eq!(slot.on_dropped(), None, "no id to cancel with yet");
assert!(slot.acknowledged(&json!(1)), "the reader cancels");
}
#[test]
fn a_finished_slot_is_never_cancelled() {
let slot = SubSlot::new();
assert!(!slot.acknowledged(&json!(1)));
slot.mark_finished();
assert_eq!(slot.on_dropped(), None);
let slot = SubSlot::new();
slot.mark_finished();
assert_eq!(slot.on_dropped(), None);
assert!(!slot.acknowledged(&json!(1)));
}
}