use crate::envelope::{Content, RawItem, StreamItem, StreamMetadata};
use crate::error::TransportError;
use futures_channel::{mpsc, oneshot};
use serde::de::{DeserializeSeed, Error as _, IgnoredAny, MapAccess, Visitor};
use serde::{Deserialize, Deserializer};
use serde_json::value::RawValue;
use serde_json::{json, Value};
use std::borrow::Cow;
use std::collections::HashMap;
use std::fmt;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
#[derive(Debug)]
pub(crate) enum Delivered {
Item(StreamItem),
Raw(RawItem),
Input(InputSignal),
}
impl Delivered {
pub(crate) fn is_terminal(&self) -> bool {
match self {
Delivered::Item(item) => item.is_terminal(),
Delivered::Raw(item) => item.is_terminal(),
Delivered::Input(_) => false,
}
}
pub(crate) fn into_item(self) -> StreamItem {
match self {
Delivered::Item(item) => item,
Delivered::Raw(_) | Delivered::Input(_) => unreachable!("a call is handed the items it asked for"),
}
}
pub(crate) fn into_raw(self) -> RawItem {
match self {
Delivered::Raw(item) => item,
Delivered::Item(item) => RawItem::from(item),
Delivered::Input(_) => unreachable!("a call is handed the items it asked for"),
}
}
}
pub(crate) type Items = mpsc::UnboundedReceiver<Result<Delivered, TransportError>>;
type ItemsTx = mpsc::UnboundedSender<Result<Delivered, TransportError>>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum InputSignal {
Credit(u64),
Closed,
Ack,
}
impl InputSignal {
fn of(result: &Value) -> Option<Self> {
match result.get("type")?.as_str()? {
"credit" => Some(Self::Credit(result.get("n")?.as_u64()?)),
"input_closed" => Some(Self::Closed),
"ack" => Some(Self::Ack),
_ => None,
}
}
}
#[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 subscription(&self) -> Option<Value> {
self.lock().subscription.clone()
}
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>>,
raw: bool,
}
#[derive(Debug)]
struct Sub {
sink: ItemsTx,
slot: Arc<SubSlot>,
raw: bool,
content_type: Option<Arc<str>>,
}
#[derive(Debug, Default)]
struct State {
pending: HashMap<u64, Pending>,
subs: HashMap<String, Sub>,
closed: Option<TransportError>,
early: Vec<(String, String)>,
early_bytes: usize,
}
const EARLY_FRAMES: usize = 1024;
const EARLY_BYTES: usize = 4 << 20;
fn shared(last: &mut Option<Arc<str>>, named: Option<&str>) -> Option<Arc<str>> {
let named = named?;
if last.as_deref() != Some(named) {
*last = Some(Arc::from(named));
}
last.clone()
}
fn keep_early(state: &mut State, key: &str, text: &str) {
if !state.pending.is_empty() && state.early.len() < EARLY_FRAMES && state.early_bytes + text.len() <= EARLY_BYTES {
state.early_bytes += text.len();
state.early.push((key.to_owned(), text.to_owned()));
}
}
#[derive(Debug)]
pub(crate) struct Registry {
hub_namespace: Arc<str>,
next_id: AtomicU64,
state: Mutex<State>,
typed: AtomicBool,
}
const KINDS: [&str; 5] = ["data", "progress", "error", "request", "done"];
fn key_of(id: &Value) -> String {
id.to_string()
}
fn key_of_text(id: &RawValue) -> Cow<'_, str> {
let text = id.get();
let bytes = text.as_bytes();
let integer = !bytes.is_empty() && bytes.len() <= 19 && bytes.iter().all(u8::is_ascii_digit) && (bytes.len() == 1 || bytes[0] != b'0');
let string = bytes.len() >= 2
&& bytes[0] == b'"'
&& bytes[bytes.len() - 1] == b'"'
&& !bytes[1..bytes.len() - 1].iter().any(|&b| b == b'\\' || b == b'"' || b < 0x20);
if integer || string {
Cow::Borrowed(text)
} else {
Cow::Owned(key_of(&value_of(id)))
}
}
fn value_of(text: &RawValue) -> Value {
serde_json::from_str(text.get()).unwrap_or(Value::Null)
}
#[derive(Deserialize)]
struct Frame<'a> {
#[serde(default, borrow)]
id: Option<&'a RawValue>,
#[serde(default, borrow)]
result: Option<&'a RawValue>,
#[serde(default, borrow)]
error: Option<&'a RawValue>,
#[serde(default, borrow)]
params: Option<Note<'a>>,
}
struct Note<'a> {
subscription: &'a RawValue,
item: Fields<'a>,
}
impl<'de: 'a, 'a> Deserialize<'de> for Note<'a> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Read<'a>(std::marker::PhantomData<&'a ()>);
impl<'de: 'a, 'a> Visitor<'de> for Read<'a> {
type Value = Note<'a>;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a notification's params")
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Note<'a>, A::Error> {
let (mut subscription, mut item) = (None, None);
while let Some(key) = map.next_key::<NoteKey>()? {
match key {
NoteKey::Subscription => subscription = Some(map.next_value()?),
NoteKey::Result => item = Some(map.next_value()?),
NoteKey::Other => drop(map.next_value::<IgnoredAny>()?),
}
}
Ok(Note {
subscription: subscription.ok_or_else(|| A::Error::missing_field("subscription"))?,
item: item.ok_or_else(|| A::Error::missing_field("result"))?,
})
}
}
d.deserialize_map(Read(std::marker::PhantomData))
}
}
#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")]
enum NoteKey {
Subscription,
Result,
#[serde(other)]
Other,
}
#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")]
enum FrameKey {
Id,
Result,
Error,
Params,
#[serde(other)]
Other,
}
#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")]
enum ItemKey {
Type,
ContentType,
Content,
#[serde(other)]
Other,
}
fn plexus_core_data(text: &str) -> Option<(&RawValue, &str, std::ops::Range<usize>)> {
let rest = text.strip_prefix(r#"{"jsonrpc":"2.0","method":"#)?;
let (_, rest) = value_at(rest)?;
let rest = rest.strip_prefix(r#","params":{"subscription":"#)?;
let (subscription, rest) = value_at(rest)?;
let mut rest = rest.strip_prefix(r#","result":{"type":"data","#)?;
if let Some(metadata) = rest.strip_prefix(r#""metadata":"#) {
rest = value_at(metadata)?.1.strip_prefix(',')?;
}
let (content_type, rest) = value_at(rest.strip_prefix(r#""content_type":"#)?)?;
let content_type = content_type.get().strip_prefix('"')?.strip_suffix('"')?;
let rest = rest.strip_prefix(r#","content":"#)?;
let (start, end) = (text.len() - rest.len(), text.len().checked_sub(3)?);
(!content_type.contains('\\') && text.ends_with("}}}") && start < end).then_some((subscription, content_type, start..end))
}
fn value_at(text: &str) -> Option<(&RawValue, &str)> {
let mut values = serde_json::Deserializer::from_str(text).into_iter::<&RawValue>();
let value = values.next()?.ok()?;
Some((value, &text[values.byte_offset()..]))
}
const HEAD_FRAMES_FROM: usize = 4096;
#[derive(Default)]
struct Head<'a> {
subscription: Option<&'a RawValue>,
kind: Option<Kind>,
content_type: Option<&'a str>,
at_content: bool,
}
impl<'a> Head<'a> {
fn read(text: &'a str) -> Option<Self> {
let mut head = Head::default();
let read = HeadSeed(&mut head, Level::Frame).deserialize(&mut serde_json::Deserializer::from_str(text));
(read.is_err() && head.at_content && head.subscription.is_some() && head.content_type.is_some()).then_some(head)
}
}
#[derive(Clone, Copy)]
enum Level {
Frame,
Params,
Item,
}
struct HeadSeed<'h, 'a>(&'h mut Head<'a>, Level);
impl<'de: 'a, 'a> DeserializeSeed<'de> for HeadSeed<'_, 'a> {
type Value = ();
fn deserialize<D: Deserializer<'de>>(self, d: D) -> Result<(), D::Error> {
d.deserialize_map(self)
}
}
impl<'de: 'a, 'a> Visitor<'de> for HeadSeed<'_, 'a> {
type Value = ();
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a notification")
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<(), A::Error> {
let HeadSeed(head, level) = self;
match level {
Level::Frame => {
while let Some(key) = map.next_key::<FrameKey>()? {
match key {
FrameKey::Params => return map.next_value_seed(HeadSeed(head, Level::Params)),
FrameKey::Id | FrameKey::Result | FrameKey::Error => return Err(A::Error::custom("a reply")),
FrameKey::Other => drop(map.next_value::<IgnoredAny>()?),
}
}
}
Level::Params => {
while let Some(key) = map.next_key::<NoteKey>()? {
match key {
NoteKey::Subscription => head.subscription = Some(map.next_value()?),
NoteKey::Result => map.next_value_seed(HeadSeed(&mut *head, Level::Item))?,
NoteKey::Other => drop(map.next_value::<IgnoredAny>()?),
}
}
}
Level::Item => {
while let Some(key) = map.next_key::<ItemKey>()? {
match key {
ItemKey::Type => head.kind = Some(map.next_value()?),
ItemKey::ContentType => head.content_type = map.next_value()?,
ItemKey::Content => {
head.at_content = true;
return Err(A::Error::custom("the content"));
}
ItemKey::Other => drop(map.next_value::<IgnoredAny>()?),
}
}
}
}
Ok(())
}
}
#[derive(Deserialize)]
struct Fields<'a> {
#[serde(rename = "type")]
kind: Option<Kind>,
#[serde(default, borrow)]
metadata: Option<&'a RawValue>,
#[serde(default, borrow)]
content_type: Option<Cow<'a, str>>,
#[serde(default, borrow, deserialize_with = "present")]
content: Option<&'a RawValue>,
#[serde(default, borrow, rename = "requestId")]
request_id: Option<Cow<'a, str>>,
#[serde(default, borrow, rename = "requestData", deserialize_with = "present")]
request_data: Option<&'a RawValue>,
#[serde(default, rename = "timeoutMs")]
timeout_ms: Option<u64>,
}
fn present<'de: 'a, 'a, D: Deserializer<'de>>(d: D) -> Result<Option<&'a RawValue>, D::Error> {
<&'a RawValue>::deserialize(d).map(Some)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "snake_case")]
enum Kind {
Data,
Progress,
Error,
Request,
Done,
Credit,
Ack,
InputClosed,
#[serde(other)]
Other,
}
impl Fields<'_> {
fn stream_item(&self, kind: Kind) -> Option<StreamItem> {
let metadata = match self.metadata {
Some(m) if m.get() != "null" => Some(serde_json::from_str::<StreamMetadata>(m.get()).ok()?),
_ => None,
};
Some(match kind {
Kind::Data => StreamItem::Data {
metadata,
content_type: self.content_type.as_deref().map(str::to_owned),
content: serde_json::from_str(self.content?.get()).ok()?,
},
Kind::Progress => StreamItem::Progress {
metadata,
content_type: self.content_type.as_deref().map(str::to_owned),
content: serde_json::from_str(self.content?.get()).ok()?,
},
Kind::Error => return None,
Kind::Request => StreamItem::Request {
request_id: self.request_id.as_deref()?.to_owned(),
request_data: serde_json::from_str(self.request_data?.get()).ok()?,
timeout_ms: self.timeout_ms.unwrap_or(0),
},
Kind::Done => StreamItem::Done { metadata },
Kind::Credit | Kind::Ack | Kind::InputClosed | Kind::Other => return None,
})
}
fn raw_item(&self, kind: Kind, content_type: Option<Arc<str>>) -> Option<RawItem> {
Some(match kind {
Kind::Data => RawItem::Data { content_type, content: Content::from(self.content?.to_owned()) },
Kind::Progress => RawItem::Progress { content_type, content: Content::from(self.content?.to_owned()) },
Kind::Error => return None,
Kind::Request => RawItem::Request,
Kind::Done => RawItem::Done,
Kind::Credit | Kind::Ack | Kind::InputClosed | Kind::Other => return None,
})
}
}
impl Registry {
pub(crate) fn new(hub_namespace: Arc<str>) -> Self {
Self {
hub_namespace,
next_id: AtomicU64::new(1),
state: Mutex::new(State::default()),
typed: AtomicBool::new(false),
}
}
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>,
raw: bool,
) -> 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, raw });
if raw {
self.typed.store(true, Ordering::Relaxed);
}
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.forget_key(&key_of(subscription));
}
fn forget_key(&self, key: &str) {
self.lock().subs.remove(key);
}
#[must_use = "the returned frame cancels a subscription nobody is reading"]
pub(crate) fn on_text(&self, text: &str) -> Option<String> {
if self.typed.load(Ordering::Relaxed) {
if let Some((subscription, content_type, span)) = plexus_core_data(text) {
if self.on_data(subscription, Some(content_type), text, Some(span)) {
return None;
}
} else if text.len() > HEAD_FRAMES_FROM {
if let Some(Head { subscription: Some(subscription), kind: Some(Kind::Data), content_type, .. }) = Head::read(text) {
if self.on_data(subscription, content_type, text, None) {
return None;
}
}
}
}
let Ok(frame) = serde_json::from_str::<Frame<'_>>(text) else {
return self.on_value(text);
};
if let Some(request_id) = frame.id.and_then(|id| id.get().parse::<u64>().ok()) {
if frame.result.is_some() || frame.error.is_some() {
return self.on_response(request_id, frame.result.map(value_of), frame.error.map(value_of));
}
}
if let Some(note) = frame.params {
self.on_note(note, text);
}
None
}
fn on_value(&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.get("result").cloned(), frame.get("error").cloned());
}
}
if let Some(subscription) = frame.pointer("/params/subscription") {
self.on_notification(&subscription.clone(), &frame, text);
}
None
}
fn on_response(&self, request_id: u64, result: Option<Value>, error: Option<Value>) -> Option<String> {
let mut state = self.lock();
let pending = state.pending.remove(&request_id)?;
if let Some(error) = error {
if state.pending.is_empty() {
state.early.clear();
state.early_bytes = 0;
}
drop(state);
let _ = pending.waiter.send(Err(TransportError::protocol(format!(
"subscribe rejected: {error}"
))));
return None;
}
let subscription = result.unwrap_or(Value::Null);
if pending.slot.acknowledged(&subscription) {
drop(state);
drop(self.take_early(&key_of(&subscription)));
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(),
raw: pending.raw,
content_type: None,
},
);
drop(state);
if pending.waiter.send(Ok(items)).is_err() {
self.lock().subs.remove(&key);
}
for frame in self.take_early(&key) {
let _ = self.on_text(&frame);
}
None
}
fn take_early(&self, key: &str) -> Vec<String> {
let mut state = self.lock();
if state.early.is_empty() {
return Vec::new();
}
let (mine, rest): (Vec<_>, Vec<_>) = std::mem::take(&mut state.early).into_iter().partition(|(k, _)| k == key);
if !state.pending.is_empty() {
state.early = rest;
}
state.early_bytes = state.early.iter().map(|(_, f)| f.len()).sum();
mine.into_iter().map(|(_, f)| f).collect()
}
fn on_data(&self, subscription: &RawValue, content_type: Option<&str>, text: &str, span: Option<std::ops::Range<usize>>) -> bool {
let key = key_of_text(subscription);
let mut state = self.lock();
let Some(sub) = state.subs.get_mut(key.as_ref()) else {
keep_early(&mut state, &key, text);
return true;
};
if !sub.raw {
return false;
}
let content_type = shared(&mut sub.content_type, content_type);
let sink = sub.sink.clone();
drop(state);
let _ = sink.unbounded_send(Ok(Delivered::Raw(RawItem::Data { content_type, content: Content::frame(text, span) })));
true
}
fn on_note(&self, note: Note<'_>, text: &str) {
let Some(kind) = note.item.kind else {
return drop(self.on_value(text));
};
if kind == Kind::Other {
return;
}
if matches!(kind, Kind::Credit | Kind::Ack | Kind::InputClosed) {
return drop(self.on_value(text));
}
let key = key_of_text(note.subscription);
let mut state = self.lock();
let Some(sub) = state.subs.get_mut(key.as_ref()) else {
keep_early(&mut state, &key, text);
return;
};
let (sink, slot) = (sub.sink.clone(), sub.slot.clone());
let item = if sub.raw {
let content_type = shared(&mut sub.content_type, note.item.content_type.as_deref());
drop(state);
note.item.raw_item(kind, content_type).map(Delivered::Raw)
} else {
drop(state);
note.item.stream_item(kind).map(Delivered::Item)
};
let Some(item) = item else {
return drop(self.on_value(text));
};
let terminal = item.is_terminal();
let _ = sink.unbounded_send(Ok(item));
if terminal {
slot.mark_finished();
self.forget_key(&key);
}
}
fn on_notification(&self, subscription: &Value, frame: &Value, text: &str) {
let key = key_of(subscription);
let mut state = self.lock();
let Some((sink, slot, raw)) = state
.subs
.get(&key)
.map(|sub| (sub.sink.clone(), sub.slot.clone(), sub.raw))
else {
keep_early(&mut state, &key, text);
return;
};
drop(state);
let payload = frame.pointer("/params/result").cloned().unwrap_or(Value::Null);
if let Some(signal) = InputSignal::of(&payload) {
let _ = sink.unbounded_send(Ok(Delivered::Input(signal)));
return;
}
if payload.get("type").and_then(Value::as_str).is_some_and(|kind| !KINDS.contains(&kind)) {
return;
}
let parsed = StreamItem::deserialize(&payload).or_else(|e| {
crate::spec05::item(&payload).and_then(|v| serde_json::from_value::<StreamItem>(v).ok()).ok_or(e)
});
match parsed {
Ok(item) => {
let terminal = item.is_terminal();
let item = if raw { Delivered::Raw(RawItem::from(item)) } else { Delivered::Item(item) };
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());
state.early = Vec::new();
state.early_bytes = 0;
(
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()
}
pub(crate) fn input_frame(hub_namespace: &str, subscription: &Value, seq: u64, items: &str) -> String {
format!(
r#"{{"jsonrpc":"2.0","method":{},"params":{{"subscription":{subscription},"seq":{seq},"items":[{items}]}}}}"#,
Value::from(format!("{hub_namespace}.input"))
)
}
pub(crate) fn end_frame(hub_namespace: &str, subscription: &Value, seq: u64) -> String {
json!({
"jsonrpc": "2.0",
"method": format!("{hub_namespace}.end"),
"params": { "subscription": subscription, "seq": seq },
})
.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::*;
use futures_util::{FutureExt, StreamExt};
fn subscribed(registry: &Registry, id: u64, subscription: &str) -> Items {
subscribed_as(registry, id, subscription, false)
}
fn subscribed_as(registry: &Registry, id: u64, subscription: &str, raw: bool) -> Items {
let reply = registry.register_pending(id, SubSlot::new(), raw).unwrap();
let answer = format!(r#"{{"jsonrpc":"2.0","id":{id},"result":{subscription}}}"#);
assert!(registry.on_text(&answer).is_none());
reply.now_or_never().expect("answered").expect("not dropped").expect("subscribed")
}
fn note(subscription: &str, item: &str) -> String {
format!(r#"{{"jsonrpc":"2.0","method":"kit.call","params":{{"subscription":{subscription},"result":{item}}}}}"#)
}
const DATA: &str = r#"{"type":"data","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"content_type":"kit.say","content":{"type":"said","text":"hi"}}"#;
const DONE: &str = r#"{"type":"done","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1}}"#;
fn drain(items: &mut Items) -> Vec<Result<StreamItem, TransportError>> {
std::iter::from_fn(|| items.next().now_or_never().flatten()).map(|item| item.map(Delivered::into_item)).collect()
}
fn drain_raw(items: &mut Items) -> Vec<Result<RawItem, TransportError>> {
std::iter::from_fn(|| items.next().now_or_never().flatten()).map(|item| item.map(Delivered::into_raw)).collect()
}
#[test]
fn an_item_of_a_type_it_does_not_know_is_skipped_and_the_stream_goes_on() {
let registry = Registry::new(Arc::from("kit"));
let mut items = subscribed(®istry, 1, "7");
for item in [
r#"{"type":"header","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"columns":["a"]}"#,
r#"{"type":"guidance","error_type":"retired","suggestion":"none"}"#,
DATA,
DONE,
] {
assert!(registry.on_text(¬e("7", item)).is_none());
}
let got = drain(&mut items);
assert!(matches!(got[..], [Ok(StreamItem::Data { .. }), Ok(StreamItem::Done { .. })]), "{got:?}");
}
#[test]
fn an_item_before_its_subscription_id_is_kept_until_the_id_arrives() {
let registry = Registry::new(Arc::from("kit"));
let reply = registry.register_pending(1, SubSlot::new(), false).unwrap();
assert!(registry.on_text(¬e("7", DATA)).is_none());
assert!(registry.on_text(r#"{"jsonrpc":"2.0","id":1,"result":7}"#).is_none());
assert!(registry.on_text(¬e("7", DONE)).is_none());
let mut items = reply.now_or_never().unwrap().unwrap().unwrap();
let got = drain(&mut items);
assert!(matches!(got[..], [Ok(StreamItem::Data { .. }), Ok(StreamItem::Done { .. })]), "{got:?}");
}
#[test]
fn an_item_for_an_id_no_call_waits_on_is_dropped() {
let registry = Registry::new(Arc::from("kit"));
let _first = subscribed(®istry, 1, "7");
assert!(registry.on_text(¬e("8", DATA)).is_none());
let mut items = subscribed(®istry, 2, "8");
assert!(registry.on_text(¬e("8", DONE)).is_none());
let got = drain(&mut items);
assert!(matches!(got[..], [Ok(StreamItem::Done { .. })]), "{got:?}");
}
#[test]
fn a_typed_call_is_handed_the_content_as_the_wires_text() {
let registry = Registry::new(Arc::from("kit"));
let mut items = subscribed_as(®istry, 1, "7", true);
for item in [DATA, DONE] {
assert!(registry.on_text(¬e("7", item)).is_none());
}
match &drain_raw(&mut items)[..] {
[Ok(RawItem::Data { content, content_type }), Ok(RawItem::Done)] => {
assert_eq!(content.as_text(), Some(r#"{"type":"said","text":"hi"}"#));
assert_eq!(content_type.as_deref(), Some("kit.say"));
}
other => panic!("{other:?}"),
}
}
#[test]
fn a_typed_call_and_a_value_call_read_the_same_items() {
let registry = Registry::new(Arc::from("kit"));
let mut values = subscribed_as(®istry, 1, "7", false);
let mut raws = subscribed_as(®istry, 2, "\"s-8\"", true);
let items = [
DATA,
r#"{"type":"data","content":{"n":[1,2.5,"x\"y"]},"content_type":"kit.n"}"#,
r#"{"type":"progress","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"content_type":"kit.n","content":{"message":"half","percentage":50.0}}"#,
r#"{"type":"progress","content":{"message":"none yet"}}"#,
r#"{"type":"request","requestId":"r-1","requestData":{"type":"confirm"},"timeoutMs":30000}"#,
r#"{"type":"error","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"message":"no","code":"too_many_calls","recoverable":true,"error":{"kind":"too_many_calls","max":8},"error_kind":"too_many_calls","max":8}"#,
];
for item in items {
assert!(registry.on_text(¬e("7", item)).is_none());
assert!(registry.on_text(¬e("\"s-8\"", item)).is_none());
}
let (values, raws) = (drain(&mut values), drain_raw(&mut raws));
assert_eq!(values.len(), items.len(), "{values:?}");
assert_eq!(raws.len(), items.len(), "{raws:?}");
for (value, raw) in values.into_iter().zip(raws) {
match (value.unwrap(), raw.unwrap()) {
(StreamItem::Data { content: v, content_type: a, .. }, RawItem::Data { content: r, content_type: b }) => {
assert_eq!(r.into_value().unwrap(), v);
assert_eq!(a.as_deref(), b.as_deref());
}
(StreamItem::Progress { content: v, content_type: a, .. }, RawItem::Progress { content: r, content_type: b }) => {
assert_eq!(r.into_value().unwrap(), v);
assert_eq!(a.as_deref(), b.as_deref());
}
(StreamItem::Request { .. }, RawItem::Request) => {}
(
StreamItem::Error { message: m, code: c, recoverable: r, error: e, .. },
RawItem::Error { message, code, recoverable, error },
) => {
assert_eq!((m, c, r, e), (message, code, recoverable, *error));
}
other => panic!("{other:?}"),
}
}
}
#[test]
fn the_in_place_reading_makes_the_stream_item_serde_makes() {
for item in [
DATA,
DONE,
r#"{"type":"done"}"#,
r#"{"type":"data","content":{"n":[1,2.5,"x\"y"]},"content_type":"kit.n"}"#,
r#"{"type":"data","metadata":null,"content_type":null,"content":null}"#,
r#"{"content":{"a":1},"extra":{"ignored":[true]},"type":"data"}"#,
r#"{"type":"data","metadata":{"provenance":["a","b"],"plexus_hash":"x","timestamp":-1,"more":1},"content":"s"}"#,
r#"{"type":"data","metadata":{},"content":{}}"#,
r#"{"type":"progress","metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"content_type":"kit.n","content":{"message":"half","percentage":50.0}}"#,
r#"{"type":"progress","content":{"message":"none yet"}}"#,
r#"{"type":"request","requestId":"r-1","requestData":{"type":"confirm"},"timeoutMs":30000}"#,
r#"{"type":"request","requestId":"r-2","requestData":null}"#,
] {
let fields: Fields<'_> = serde_json::from_str(item).unwrap();
let built = fields.stream_item(fields.kind.unwrap());
assert_eq!(built, Some(serde_json::from_str::<StreamItem>(item).unwrap()), "{item}");
}
for item in [
r#"{"type":"error","message":"no","code":"-32000","recoverable":true,"metadata":{"provenance":[],"plexus_hash":"","timestamp":0},"error":{"kind":"execution","message":"no"}}"#,
r#"{"type":"error","recoverable":false,"error":{"kind":"unauthenticated"}}"#,
] {
let fields: Fields<'_> = serde_json::from_str(item).unwrap();
assert_eq!(fields.stream_item(fields.kind.unwrap()), None, "{item}");
assert!(serde_json::from_str::<StreamItem>(item).is_ok(), "{item}");
}
}
#[test]
fn every_subscription_id_routes_alike_read_in_place_or_as_a_value() {
for id in ["7", r#""s-8""#, r#""a\"b""#, r#""é""#, "12345678901234567890", "0", r#""""#] {
let registry = Registry::new(Arc::from("kit"));
let mut items = subscribed_as(®istry, 1, id, true);
assert!(registry.on_text(¬e(id, DONE)).is_none());
assert!(matches!(drain_raw(&mut items)[..], [Ok(RawItem::Done)]), "{id}");
}
}
#[test]
fn a_typed_call_decodes_from_its_frames_what_a_value_call_decodes() {
use crate::{decode, decode_raw, ItemStream, RawItemStream};
#[derive(Debug, PartialEq, serde::Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
enum Ev {
Said { text: String },
Row { id: String, labels: Vec<String>, parent: Option<String> },
Ready,
}
let long = "a \\\"long\\\" body, é and \\n ".repeat(200);
let big = [
format!(r#"{{"type":"said","text":"{long}"}}"#),
format!(r#"{{"type":"said","text":7,"pad":"{long}"}}"#),
format!(r#"{{"type":"row","id":"{long}","labels":[]}}"#),
];
let contents = [
r#"{"type":"said","text":"hi \"there\"\n\u00e9"}"#,
r#"{"type":"row","id":"MQ-1","labels":["perf"],"parent":null}"#,
r#"{"type":"ready"}"#,
r#"{"type":"said"}"#,
r#"{"type":"said","text":7}"#,
r#"{"type":"gone"}"#,
"null",
&big[0],
&big[1],
&big[2],
];
let head = |c: &str| format!(r#"{{"type":"data","metadata":{{"provenance":["kit"],"plexus_hash":"h","timestamp":1}},"content_type":"kit.say","content":{c}}}"#);
let whole = |c: &str| format!(r#"{{"content":{c},"type":"data","content_type":"kit.say"}}"#);
let after = |c: &str| format!(r#"{{"type":"data","content_type":"kit.say","content":{c},"later":{{"x":[1,"}}}}}}"]}}}}"#);
let forms = [&head as &dyn Fn(&str) -> String, &whole, &after];
for item in forms.iter().flat_map(|form| contents.iter().map(move |c| form(c))) {
let registry = Registry::new(Arc::from("kit"));
let values = subscribed_as(®istry, 1, "7", false);
let raws = subscribed_as(®istry, 2, "8", true);
for sub in ["7", "8"] {
assert!(registry.on_text(¬e(sub, &item)).is_none());
assert!(registry.on_text(¬e(sub, DONE)).is_none());
}
let values: ItemStream<'static> = Box::pin(values.map(|i| i.map(Delivered::into_item)));
let raws: RawItemStream<'static> = Box::pin(raws.map(|i| i.map(Delivered::into_raw)));
let a: Vec<_> = futures_util::stream::StreamExt::collect::<Vec<_>>(decode::<Ev>(values)).now_or_never().unwrap();
let b: Vec<_> = futures_util::stream::StreamExt::collect::<Vec<_>>(decode_raw::<Ev>(raws)).now_or_never().unwrap();
assert_eq!(a, b, "{item}");
}
}
#[test]
fn a_large_item_reaches_a_typed_call_in_its_frame() {
let registry = Registry::new(Arc::from("kit"));
let mut items = subscribed_as(®istry, 1, "7", true);
let body = format!(r#"{{"type":"said","text":"{}"}}"#, "x".repeat(HEAD_FRAMES_FROM));
let large = format!(r#"{{"type":"data","metadata":{{"provenance":["kit"],"plexus_hash":"h","timestamp":1}},"content_type":"kit.say","content":{body}}}"#);
for item in [DATA, large.as_str()] {
assert!(registry.on_text(¬e("7", item)).is_none());
}
match &drain_raw(&mut items)[..] {
[Ok(RawItem::Data { content: small, .. }), Ok(RawItem::Data { content: large, content_type })] => {
assert_eq!((small.in_frame(), large.in_frame()), (Some(true), Some(true)));
assert_eq!(large.as_text(), Some(body.as_str()));
assert_eq!(content_type.as_deref(), Some("kit.say"));
}
other => panic!("{other:?}"),
}
}
#[test]
fn plexus_cores_data_notification_is_read_by_its_bytes() {
let read = |item: &str| {
let text = note("296970649928868", item);
plexus_core_data(&text).map(|(id, ct, span)| (id.get().to_owned(), ct.to_owned(), text[span].to_owned()))
};
let said = r#"{"type":"said","text":"}}}"}"#;
let with = |rest: &str| format!(r#"{{"type":"data",{rest}"content":{said}}}"#);
let want = Some(("296970649928868".to_owned(), "kit.say".to_owned(), said.to_owned()));
assert_eq!(read(&with(r#""metadata":{"provenance":["kit"],"plexus_hash":"h","timestamp":1},"content_type":"kit.say","#)), want);
assert_eq!(read(&with(r#""content_type":"kit.say","#)), want);
assert_eq!(read(&with(r#""content_type":"kit\u002esay","#)), None);
assert_eq!(read(&with(r#""metadata":null,"content_type":"kit.say","#)), want);
assert_eq!(read(r#"{"type":"done"}"#), None);
assert_eq!(read(r#"{"content_type":"kit.say","type":"data","content":1}"#), None);
assert_eq!(read(&with(r#""metadata" : {},"content_type":"kit.say","#)), None);
assert!(plexus_core_data(r#"{"jsonrpc":"2.0","id":1,"result":7}"#).is_none());
assert!(plexus_core_data(r#"{"method":"kit.call","jsonrpc":"2.0","params":{"subscription":7,"result":{"type":"data","content_type":"x","content":1}}}"#).is_none());
assert!(plexus_core_data(r#"{"jsonrpc":"2.0","method":"kit.call","params":{"subscription":7,"result":{"type":"data","content_type":"x","content":1}}} "#).is_none());
}
#[test]
fn the_head_is_read_only_in_plexus_cores_order() {
let at = |item: &str| Head::read(¬e("7", item)).map(|h| (h.kind, h.content_type.map(str::to_owned)));
assert_eq!(at(DATA), Some((Some(Kind::Data), Some("kit.say".into()))));
assert_eq!(at(r#"{"content":1,"type":"data","content_type":"kit.say"}"#), None);
assert_eq!(at(r#"{"type":"data","content":1}"#), None);
assert_eq!(at(DONE), None);
assert!(Head::read(r#"{"jsonrpc":"2.0","id":1,"result":7}"#).is_none());
assert!(Head::read(r#"{"jsonrpc":"2.0","method":"kit.call","params":{"result":{"type":"data","content_type":"x","content":1},"subscription":7}}"#).is_none());
}
#[test]
fn an_item_that_is_not_one_is_still_an_error() {
for item in [r#"{"content":{"a":1}}"#, r#"{"type":"data","metadata":{"provenance":[],"plexus_hash":"h","timestamp":1}}"#, "42"] {
let registry = Registry::new(Arc::from("kit"));
let mut items = subscribed(®istry, 1, "7");
assert!(registry.on_text(¬e("7", item)).is_none());
let got = drain(&mut items);
assert!(matches!(got[..], [Err(_)]), "{item}: {got:?}");
}
}
#[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 the_input_frames_are_the_ones_the_wire_says() {
let frame: Value = serde_json::from_str(&input_frame("menger", &json!(21), 0, r#"{"t":"The"},{"t":" cat"}"#)).unwrap();
assert_eq!(frame, json!({"jsonrpc":"2.0","method":"menger.input","params":{"subscription":21,"seq":0,"items":[{"t":"The"},{"t":" cat"}]}}));
let frame: Value = serde_json::from_str(&end_frame("menger", &json!(21), 2)).unwrap();
assert_eq!(frame, json!({"jsonrpc":"2.0","method":"menger.end","params":{"subscription":21,"seq":2}}));
}
#[test]
fn an_item_before_its_subscribe_reply_is_held_for_it() {
let registry = Registry::new(Arc::from("menger"));
let slot = SubSlot::new();
let id = registry.next_request_id();
let mut reply = registry.register_pending(id, slot, false).unwrap();
let credit = json!({"jsonrpc":"2.0","method":"result","params":{"subscription":21,"result":{"type":"credit","n":64}}}).to_string();
assert!(registry.on_text(&credit).is_none());
let answer = json!({"jsonrpc":"2.0","id":id,"result":21}).to_string();
assert!(registry.on_text(&answer).is_none());
let mut items = reply.try_recv().unwrap().unwrap().unwrap();
assert!(matches!(items.try_recv().unwrap(), Ok(Delivered::Input(InputSignal::Credit(64)))));
}
#[test]
fn an_item_of_no_subscription_is_not_kept() {
let registry = Registry::new(Arc::from("menger"));
let stray = json!({"jsonrpc":"2.0","method":"result","params":{"subscription":9,"result":{"type":"done"}}}).to_string();
assert!(registry.on_text(&stray).is_none());
assert!(registry.lock().early.is_empty());
}
#[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)));
}
}