use std::borrow::Cow;
use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
use std::fmt::Write as _;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Duration;
use bytes::Bytes;
use web_time::Instant;
use crate::client::{Queued, Shared};
use crate::decode::{self, Envelope, epoch_of};
use crate::error::Error;
use crate::handler::{
Connected, Event, Gap, GapReason, Handler, Recovery, ServerError, Subscribed,
};
use crate::message::{Message, OwnedMessage, Payload, Position, Signature};
use crate::security::{Keys, Sealing};
use crate::sequencer::{Streams, Verdict};
const HELD_MAX: usize = 1000;
const UNANSWERED_MAX: u32 = 2;
type Map<V> = HashMap<Box<str>, V, foldhash::fast::RandomState>;
struct Hole {
epoch: u32,
held: BTreeMap<u64, OwnedMessage>,
deadline: Instant,
request: Option<u64>,
requested_from: Option<u64>,
answered: bool,
}
#[derive(Default)]
struct Topic {
streams: Streams,
holes: Vec<Hole>,
live_since: Option<Instant>,
}
struct Request {
id: u64,
for_hole: bool,
named: Vec<u32>,
}
const QUIET_MARGIN: Duration = Duration::from_secs(5);
pub(crate) enum Outgoing {
Text(String),
Handshake(String),
}
pub(crate) struct Session<H> {
pub(crate) handler: H,
shared: Arc<Shared>,
recovery_timeout: Duration,
wanted: BTreeSet<String>,
topics: Map<Topic>,
requests: Map<VecDeque<Request>>,
next_request: u64,
unrecoverable: Map<u32>,
unanswered: u32,
holes: usize,
next_deadline: Option<Instant>,
pub(crate) outbox: Vec<Outgoing>,
keys: Arc<Keys>,
pub(crate) sealing: Option<Sealing>,
pub(crate) fatal: Option<Error>,
pub(crate) ready: bool,
pub(crate) became_ready: bool,
pub(crate) connected_before: bool,
server_recovery: bool,
user_id: Option<String>,
last_user: Option<Option<String>>,
users: u64,
connections: u64,
pub(crate) clock: Instant,
history_ttl: Option<Duration>,
idle_timeout: Duration,
last_alive: Option<Instant>,
alive_since: Option<Instant>,
pub(crate) committed: Option<crate::config::Committed>,
}
impl<H: Handler> Session<H> {
pub(crate) fn new(
handler: H,
shared: Arc<Shared>,
keys: Arc<Keys>,
topics: &[String],
recovery_timeout: Duration,
idle_timeout: Duration,
) -> Self {
Self {
handler,
shared,
keys,
sealing: None,
fatal: None,
recovery_timeout,
wanted: topics.iter().cloned().collect(),
topics: Map::default(),
requests: Map::default(),
next_request: 0,
unrecoverable: Map::default(),
unanswered: 0,
holes: 0,
next_deadline: None,
outbox: Vec::new(),
ready: false,
became_ready: false,
connected_before: false,
server_recovery: false,
user_id: None,
last_user: None,
users: 0,
connections: 0,
clock: Instant::now(),
history_ttl: None,
idle_timeout,
last_alive: None,
alive_since: None,
committed: None,
}
}
pub(crate) fn alive_at(&mut self, now: Instant) {
if self
.last_alive
.is_none_or(|last| now.saturating_duration_since(last) > self.idle_timeout)
{
self.alive_since = Some(now);
}
self.last_alive = Some(now);
}
pub(crate) fn queue(&mut self, frame: Queued) {
if frame.user != self.users {
tracing::warn!("[WSE] a message sent as the previous user was dropped");
} else if frame.only_on.is_some_and(|on| on != self.connections) {
tracing::warn!("[WSE] a message for a connection that went was dropped");
} else {
self.outbox.push(Outgoing::Text(frame.text));
}
}
pub(crate) fn open(&mut self, sealing: Option<Sealing>) {
self.sealing = sealing;
self.fatal = None;
self.ready = false;
self.became_ready = false;
self.server_recovery = false;
self.history_ttl = None;
self.last_alive = None;
self.alive_since = None;
self.user_id = None;
self.requests.clear();
self.unrecoverable.clear();
self.unanswered = 0;
self.outbox.clear();
for topic in self.topics.values_mut() {
for hole in &mut topic.holes {
hole.request = None;
}
}
if let Ok(mut server_kid) = self.shared.server_kid.lock() {
*server_kid = None;
}
if let Ok(mut connection) = self.shared.connection.lock() {
*connection = None;
}
}
pub(crate) fn close(&mut self) {
self.sealing = None;
self.ready = false;
self.shared.ready.store(false, Ordering::Release);
self.requests.clear();
let quiet_before = match (self.history_ttl, self.last_alive, self.alive_since) {
(Some(ttl), Some(last), Some(since)) => last
.checked_sub(ttl + QUIET_MARGIN + self.idle_timeout)
.filter(|before| since <= *before),
_ => None,
};
self.last_alive = None;
self.alive_since = None;
for topic in self.topics.values_mut() {
for hole in &mut topic.holes {
hole.request = None;
}
let since = topic.live_since.take();
if let Some(before) = quiet_before
&& since.is_some_and(|since| since <= before)
{
let holes = &topic.holes;
topic
.streams
.forget_quiet(before, |epoch| holes.iter().any(|h| h.epoch == epoch));
}
}
}
pub(crate) fn finish(&mut self) {
for (topic, epoch) in self.holes_where(|_| true) {
self.give_up(&topic, epoch, GapReason::Closed);
}
}
fn holes_where(&self, pick: impl Fn(&Hole) -> bool) -> Vec<(Box<str>, u32)> {
self.topics
.iter()
.flat_map(|(name, topic)| {
topic
.holes
.iter()
.filter(|hole| pick(hole))
.map(move |hole| (name.clone(), hole.epoch))
})
.collect()
}
pub(crate) fn on_json(&mut self, text: &str, frame: Option<&Bytes>) -> bool {
match decode::json_envelope(text) {
Ok(envelope) => {
self.on_envelope(envelope, frame);
true
}
Err(e) => {
tracing::debug!("[WSE] not a message: {e}");
false
}
}
}
pub(crate) fn on_msgpack(&mut self, data: &[u8], frame: Option<&Bytes>) -> bool {
match decode::msgpack_envelope(data) {
Ok(envelope) => {
self.on_envelope(envelope, frame);
true
}
Err(e) => {
tracing::debug!("[WSE] not a message: {e}");
false
}
}
}
pub(crate) fn on_unsealed(&mut self, text: Option<&str>) {
let envelope = text.and_then(|text| decode::json_envelope(text).ok());
let open = self.sealing.as_ref().is_some_and(Sealing::is_open);
let handshake = envelope.as_ref().is_some_and(|e| {
matches!(
e.t.as_deref(),
Some("server_hello" | "error" | "ping" | "PING" | "pong" | "PONG")
)
});
let ping = envelope
.as_ref()
.is_some_and(|e| matches!(e.t.as_deref(), Some("ping" | "PING" | "pong" | "PONG")));
if ping && !open {
return;
}
match envelope {
Some(mut envelope) if handshake && !open => {
envelope.tp = None;
envelope.e = None;
envelope.o = None;
self.dispatch(&envelope.into_message(None));
}
_ => {
let why = if open { "inside" } else { "before" };
self.fail(Error::Encryption(format!(
"a plaintext frame {why} the session"
)));
}
}
}
pub(crate) fn fail(&mut self, error: Error) {
if self.fatal.is_none() {
tracing::error!("[WSE] {error}: closing, without falling back to plaintext");
self.fatal = Some(error);
}
}
fn on_envelope<'a>(&mut self, envelope: Envelope<'a>, frame: Option<&'a Bytes>) {
if envelope.t.as_deref() == Some("signed") {
self.on_signed(envelope, frame);
return;
}
if envelope.t.as_deref() == Some("batch") {
match envelope.p {
Some(Payload::Json(p)) => {
for message in decode::json_batch(p).unwrap_or_default() {
let _ = self.on_json(message, frame);
}
}
Some(Payload::Msgpack(p)) => {
for message in decode::msgpack_batch(p).unwrap_or_default() {
let _ = self.on_msgpack(message, frame);
}
}
_ => {}
}
return;
}
let message = envelope.into_message(frame);
match (message.position, &message.topic) {
(Some(at), Some(_)) if !is_protocol(message.kind()) => self.on_stamped(message, at),
_ => self.dispatch(&message),
}
}
fn on_signed<'a>(&mut self, outer: Envelope<'a>, frame: Option<&'a Bytes>) {
let (Some(body), Some(sig), Some(kid)) = (outer.sb, outer.sig, outer.kid) else {
tracing::warn!("[WSE] malformed signed message dropped");
return;
};
let verified = match self.keys.check_server(&kid, &body, &sig) {
Ok(verified) => verified,
Err(why) => {
tracing::warn!("[WSE] signed message dropped: {why}");
return;
}
};
let Ok(signed) = decode::json_envelope(&body) else {
tracing::warn!("[WSE] signed message dropped: its body is not a JSON object");
return;
};
if signed.t.is_none() {
tracing::warn!("[WSE] signed message dropped: its body has no type");
return;
}
match (&outer.tp, &signed.tp) {
(Some(came_on), Some(signed_for)) if came_on != signed_for => {
tracing::warn!(
"[WSE] message signed for topic {signed_for} that came on {came_on} dropped"
);
return;
}
(Some(came_on), None) => {
tracing::warn!("[WSE] message signed for no topic that came on {came_on} dropped");
return;
}
_ => {}
}
#[derive(serde::Deserialize)]
struct Signed<'b> {
ts: Option<u64>,
#[serde(borrow)]
to: Option<Cow<'b, str>>,
}
let Ok(Signed { ts, to }) = serde_json::from_str::<Signed<'_>>(&body) else {
tracing::warn!("[WSE] signed message dropped: its body is malformed");
return;
};
if let Some(to) = to
&& self.user_id.as_deref() != Some(&*to)
{
tracing::warn!("[WSE] message signed for user {to} dropped: not this connection's");
return;
}
let signed_at = ts.map(|ms| Cow::Owned(rfc3339_ms(ms)));
let signature = Signature {
body: body.to_string(),
sig: sig.into_owned(),
kid: kid.into_owned(),
verified,
};
let id = signed.n;
let message = Envelope {
t: signed.t,
p: signed.p,
c: outer.c,
ts: signed_at,
tp: outer.tp.or(signed.tp),
e: outer.e,
o: outer.o,
..Envelope::default()
};
let mut message = message.into_message(frame);
message.id = id;
message.signature = Some(Arc::new(signature));
match (message.position, &message.topic) {
(Some(at), Some(_)) if !is_protocol(message.kind()) => self.on_stamped(message, at),
_ => self.dispatch(&message),
}
}
fn dispatch(&mut self, message: &Message<'_>) {
match message.kind() {
"ping" | "PING" => self.answer_ping(message),
"PONG" | "pong" => {}
"server_ready" => self.on_server_ready(message),
"server_hello" => self.on_server_hello(message),
"subscription_update" => self.on_subscription_reply(message),
"error" => self.on_error(message),
_ => self.handler.message(message),
}
}
fn on_stamped(&mut self, message: Message<'_>, at: Position) {
let name = message.topic.as_deref().unwrap_or_default();
let topic = match self.topics.get_mut(name) {
Some(topic) => topic,
None => self.topics.entry(name.into()).or_default(),
};
topic.live_since.get_or_insert(self.clock);
let held_here = topic.holes.iter().any(|h| h.epoch == at.epoch);
match topic.streams.check(at, self.clock) {
Verdict::Duplicate => {}
Verdict::Deliver => {
if !self.unrecoverable.is_empty() {
self.unrecoverable.remove(name);
}
self.handler.message(&message);
if held_here {
self.drain(name, at.epoch);
}
}
Verdict::Gap if held_here => {
let Some(hole) = topic.holes.iter_mut().find(|h| h.epoch == at.epoch) else {
return;
};
hole.held
.entry(at.offset)
.or_insert_with(|| message.to_owned());
if hole.held.len() > HELD_MAX {
self.give_up(name, at.epoch, GapReason::Overflow);
}
}
Verdict::Gap => {
if self.unrecoverable.get(name) == Some(&at.epoch) {
self.unrecoverable.remove(name);
self.skip(name, &message, at, GapReason::NotRecovered);
} else if !self.start_hole(name, &message, at) {
self.skip(name, &message, at, GapReason::Unavailable);
}
}
}
}
fn recovery_available(&self) -> bool {
!self.recovery_timeout.is_zero()
&& self.server_recovery
&& self.unanswered < UNANSWERED_MAX
&& self.ready
}
fn start_hole(&mut self, name: &str, message: &Message<'_>, at: Position) -> bool {
if !self.recovery_available() {
return false;
}
let Some(topic) = self.topics.get_mut(name) else {
return false;
};
if topic.holes.iter().any(|h| h.epoch == at.epoch)
|| topic.streams.stream(at.epoch).is_none()
{
return false;
}
let deadline = Instant::now() + self.recovery_timeout;
let mut held = BTreeMap::new();
held.insert(at.offset, message.to_owned());
topic.holes.push(Hole {
epoch: at.epoch,
held,
deadline,
request: None,
requested_from: None,
answered: false,
});
self.holes += 1;
self.next_deadline = Some(self.next_deadline.map_or(deadline, |d| d.min(deadline)));
self.request_recovery(name, at.epoch);
true
}
fn request_recovery(&mut self, name: &str, epoch: u32) {
let Some(topic) = self.topics.get_mut(name) else {
return;
};
let Some(hole) = topic.holes.iter_mut().find(|h| h.epoch == epoch) else {
return;
};
if hole.request.is_some() {
return;
}
let Some(from) = topic.streams.stream(epoch) else {
return;
};
let id = self.next_request;
self.next_request += 1;
hole.request = Some(id);
hole.requested_from = Some(from.offset);
let streams: Vec<Position> = topic.streams.positions().collect();
let named = streams.iter().map(|s| s.epoch).collect();
self.requests
.entry(name.into())
.or_default()
.push_back(Request {
id,
for_hole: true,
named,
});
let request = subscription(&[name], &[(name, from, streams)]);
self.outbox.push(Outgoing::Text(request));
}
fn drain(&mut self, name: &str, epoch: u32) {
loop {
let Some(topic) = self.topics.get_mut(name) else {
return;
};
let Some(hole) = topic.holes.iter_mut().find(|h| h.epoch == epoch) else {
return;
};
let Some(next_offset) = topic
.streams
.stream(epoch)
.and_then(|last| last.offset.checked_add(1))
else {
break;
};
hole.held = hole.held.split_off(&next_offset);
let Some(next) = hole.held.remove(&next_offset) else {
break;
};
topic.streams.advance(
Position {
epoch,
offset: next_offset,
},
self.clock,
);
self.handler.message(&next.as_message());
}
let filled = self
.topics
.get(name)
.and_then(|t| t.holes.iter().find(|h| h.epoch == epoch))
.is_some_and(|h| h.held.is_empty());
if filled {
self.close_hole(name, epoch);
tracing::info!("[WSE] recovered the gap on {name}");
}
}
fn close_hole(&mut self, name: &str, epoch: u32) -> Option<Hole> {
let holes = &mut self.topics.get_mut(name)?.holes;
let index = holes.iter().position(|h| h.epoch == epoch)?;
let hole = holes.swap_remove(index);
self.holes -= 1;
if self.next_deadline == Some(hole.deadline) || self.holes == 0 {
self.next_deadline = self.first_deadline();
}
Some(hole)
}
fn first_deadline(&self) -> Option<Instant> {
self.topics
.values()
.flat_map(|t| t.holes.iter().map(|h| h.deadline))
.min()
}
fn give_up(&mut self, name: &str, epoch: u32, reason: GapReason) {
let Some(hole) = self.close_hole(name, epoch) else {
return;
};
let mut last = self
.topics
.get(name)
.and_then(|t| t.streams.stream(epoch))
.map(|p| p.offset);
for (offset, message) in hole.held {
if last.is_some_and(|last| offset <= last) {
continue;
}
if let Some(first) = last.and_then(|last| last.checked_add(1))
&& offset > first
{
self.report(name, epoch, Some(first), Some(offset - 1), reason);
}
if let Some(topic) = self.topics.get_mut(name) {
topic
.streams
.advance(Position { epoch, offset }, self.clock);
}
self.handler.message(&message.as_message());
last = Some(offset);
}
}
fn skip(&mut self, name: &str, message: &Message<'_>, at: Position, reason: GapReason) {
let Some(topic) = self.topics.get_mut(name) else {
return;
};
let last = topic.streams.stream(at.epoch);
topic.streams.advance(at, self.clock);
if let Some(first) = last.and_then(|last| last.offset.checked_add(1))
&& at.offset > first
{
self.report(name, at.epoch, Some(first), Some(at.offset - 1), reason);
}
self.handler.message(message);
}
fn report(
&mut self,
topic: &str,
epoch: u32,
first: Option<u64>,
last: Option<u64>,
reason: GapReason,
) {
let gap = Gap {
topic: topic.to_owned(),
epoch,
first,
last,
reason,
};
tracing::warn!(
"[WSE] {topic} lost offsets {first:?}..{last:?} ({:?} messages, {reason:?})",
gap.missed()
);
self.handler.event(Event::Gap(gap));
}
pub(crate) fn next_deadline(&self) -> Option<Instant> {
self.next_deadline
}
pub(crate) fn on_deadline(&mut self, now: Instant) {
self.clock = now;
let unanswered = self
.holes_where(|h| h.deadline <= now && h.request.is_some() && !h.answered)
.len();
self.unanswered = self
.unanswered
.saturating_add(u32::try_from(unanswered).unwrap_or(u32::MAX));
for (name, epoch) in self.holes_where(|h| h.deadline <= now) {
self.give_up(&name, epoch, GapReason::Timeout);
}
}
pub(crate) fn subscribe(&mut self, topics: Vec<String>) {
let new: Vec<String> = topics
.into_iter()
.filter(|t| !t.is_empty())
.filter(|t| self.wanted.insert(t.clone()))
.collect();
if self.ready && !new.is_empty() {
self.rewind_to_committed(&new);
self.send_subscription(&new);
}
}
fn rewind_to_committed(&mut self, topics: &[String]) {
let Some(committed) = self.committed.clone() else {
return;
};
let Some(positions) = committed(self.user_id.as_deref()) else {
return;
};
let now = self.clock;
let mut holes = 0;
for name in topics {
let topic = self.topics.entry(name.as_str().into()).or_default();
holes += topic.holes.len();
topic.holes.clear();
topic.streams = Streams::default();
for at in positions.get(name.as_str()).into_iter().flatten() {
topic.streams.advance(*at, now);
}
}
self.holes -= holes;
self.next_deadline = self.first_deadline();
}
pub(crate) fn unsubscribe(&mut self, topics: Vec<String>) {
for topic in &topics {
self.wanted.remove(topic);
if let Some(state) = self.topics.remove(topic.as_str())
&& !state.holes.is_empty()
{
self.holes -= state.holes.len();
self.next_deadline = self.first_deadline();
}
self.requests.remove(topic.as_str());
self.unrecoverable.remove(topic.as_str());
}
if self.ready && !topics.is_empty() {
let mut text = String::from(
r#"{"c":"WSE","t":"subscription_update","p":{"action":"unsubscribe","topics":"#,
);
push_json(&mut text, &topics);
text.push_str("},\"v\":1}");
self.outbox.push(Outgoing::Text(text));
}
}
fn send_subscription(&mut self, topics: &[String]) {
let mut positions = Vec::new();
if self.server_recovery {
for topic in topics {
let Some(t) = self.topics.get(topic.as_str()) else {
continue;
};
if let Some(at) = t.streams.position() {
positions.push((
topic.as_str(),
at,
t.streams.positions().collect::<Vec<_>>(),
));
}
}
}
let now = Instant::now();
for (topic, at, streams) in &positions {
let (topic, at) = (*topic, *at);
let id = self.next_request;
self.next_request += 1;
let named = streams.iter().map(|s| s.epoch).collect();
let hole = self
.topics
.get_mut(topic)
.and_then(|t| t.holes.iter_mut().find(|h| h.epoch == at.epoch));
let for_hole = hole.is_some();
if let Some(hole) = hole {
hole.request = Some(id);
hole.requested_from = Some(at.offset);
hole.deadline = now + self.recovery_timeout;
}
self.requests
.entry(topic.into())
.or_default()
.push_back(Request {
id,
for_hole,
named,
});
}
if self.holes > 0 {
self.next_deadline = self.first_deadline();
}
let names: Vec<&str> = topics.iter().map(String::as_str).collect();
self.outbox
.push(Outgoing::Text(subscription(&names, &positions)));
for (topic, epoch) in self.holes_where(|h| h.request.is_none()) {
if topics.iter().any(|t| **t == *topic) {
self.request_recovery(&topic, epoch);
}
}
}
fn on_subscription_reply(&mut self, message: &Message<'_>) {
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Reply {
success_topics: Vec<String>,
failed_topics: Vec<String>,
recovery: BTreeMap<String, Info>,
}
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Info {
epoch: Option<String>,
offset: Option<u64>,
recovered: Option<bool>,
count: u64,
streams: Option<BTreeMap<String, u64>>,
}
let Ok(reply) = message.payload::<Reply>() else {
tracing::debug!("[WSE] unreadable subscription reply dropped");
return;
};
if !reply.failed_topics.is_empty() {
tracing::warn!("[WSE] subscription refused for {:?}", reply.failed_topics);
}
if self.ready {
for name in &reply.success_topics {
self.topics
.entry(name.as_str().into())
.or_default()
.live_since
.get_or_insert(self.clock);
}
}
let mut recovery = Vec::with_capacity(reply.recovery.len());
for (topic, info) in &reply.recovery {
let epoch = info.epoch.as_deref().and_then(epoch_of);
let recovered = info.recovered.unwrap_or(true);
let streams: Option<Vec<Position>> = info.streams.as_ref().map(|streams| {
streams
.iter()
.filter_map(|(epoch, offset)| {
Some(Position {
epoch: epoch_of(epoch)?,
offset: *offset,
})
})
.collect()
});
let request = self.on_recovery_reply(
topic,
recovered,
epoch,
info.epoch.is_some(),
info.offset,
streams.is_some(),
);
if let Some(streams) = &streams {
self.take_streams(topic, request.as_ref(), streams, recovered);
}
recovery.push(Recovery {
topic: topic.clone(),
recovered,
count: info.count,
position: epoch
.zip(info.offset)
.map(|(epoch, offset)| Position { epoch, offset }),
});
}
self.handler.event(Event::Subscribed(Subscribed {
topics: reply.success_topics,
failed: reply.failed_topics,
recovery,
}));
}
fn on_recovery_reply(
&mut self,
name: &str,
recovered: bool,
epoch: Option<u32>,
has_epoch: bool,
offset: Option<u64>,
listed_streams: bool,
) -> Option<Request> {
let Some(request) = self.requests.get_mut(name).and_then(VecDeque::pop_front) else {
return None; };
if self.requests.get(name).is_some_and(VecDeque::is_empty) {
self.requests.remove(name);
}
self.unanswered = 0;
let hole = self
.topics
.get_mut(name)
.and_then(|t| t.holes.iter_mut().find(|h| h.request == Some(request.id)));
if let Some(hole) = hole {
hole.request = None;
hole.answered = true;
let (hole_epoch, requested_from) = (hole.epoch, hole.requested_from);
self.drain(name, hole_epoch);
let Some(topic) = self
.topics
.get(name)
.filter(|t| t.holes.iter().any(|h| h.epoch == hole_epoch))
else {
return Some(request); };
let progressed = topic
.streams
.stream(hole_epoch)
.zip(requested_from)
.is_some_and(|(at, from)| at.offset > from);
if progressed && (recovered || epoch == Some(hole_epoch)) {
self.request_recovery(name, hole_epoch);
} else {
let reason = if recovered {
GapReason::Incomplete
} else {
GapReason::NotRecovered
};
self.give_up(name, hole_epoch, reason);
}
return Some(request);
}
if request.for_hole {
return Some(request); }
if recovered || listed_streams {
return Some(request);
}
let Some(at) = self.topics.get(name).and_then(|t| t.streams.position()) else {
return Some(request);
};
match epoch {
None if !has_epoch => self.report(name, at.epoch, None, None, GapReason::EpochChanged),
Some(epoch) if epoch != at.epoch => {
self.report(name, epoch, None, None, GapReason::EpochChanged)
}
_ => {
if offset.is_some_and(|offset| offset <= at.offset) {
return Some(request); }
self.unrecoverable.insert(name.into(), at.epoch);
}
}
Some(request)
}
fn take_streams(
&mut self,
name: &str,
request: Option<&Request>,
listed: &[Position],
recovered: bool,
) {
let now = self.clock;
let lost = !recovered && request.is_some_and(|r| !r.for_hole);
let mut reports: Vec<(u32, Option<u64>, Option<u64>)> = Vec::new();
let topic = self.topics.entry(name.into()).or_default();
let holes: Vec<u32> = topic.holes.iter().map(|h| h.epoch).collect();
for at in listed {
if holes.contains(&at.epoch) {
continue;
}
match topic.streams.stream(at.epoch) {
None => topic.streams.raise(*at, now),
Some(own) if lost && at.offset > own.offset => {
reports.push((at.epoch, own.offset.checked_add(1), Some(at.offset)));
topic.streams.raise(*at, now);
}
Some(_) => {}
}
}
for &epoch in request.map(|r| r.named.as_slice()).unwrap_or_default() {
if holes.contains(&epoch) || listed.iter().any(|at| at.epoch == epoch) {
continue;
}
if lost && let Some(own) = topic.streams.stream(epoch) {
reports.push((epoch, own.offset.checked_add(1), None));
}
topic.streams.forget(epoch);
}
if lost
&& reports.is_empty()
&& let Some(at) = topic.streams.position()
{
reports.push((at.epoch, None, None));
}
for (epoch, first, last) in reports {
self.report(name, epoch, first, last, GapReason::NotRecovered);
}
}
fn answer_ping(&mut self, ping: &Message<'_>) {
#[derive(serde::Deserialize)]
struct Ping<'a> {
#[serde(borrow)]
server_time: Option<&'a serde_json::value::RawValue>,
#[serde(borrow)]
timestamp: Option<&'a serde_json::value::RawValue>,
}
let now = now_ms();
let echoed = ping
.payload::<Ping<'_>>()
.ok()
.and_then(|p| {
p.server_time
.or(p.timestamp)
.map(|raw| raw.get().to_owned())
})
.unwrap_or_else(|| now.to_string());
let pong = format!(
r#"{{"c":"WSE","t":"PONG","p":{{"client_timestamp":{now},"server_timestamp":{echoed}}},"v":1}}"#
);
self.outbox.push(Outgoing::Handshake(pong));
}
fn on_server_ready(&mut self, message: &Message<'_>) {
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Ready {
connection_id: Option<String>,
details: Details,
}
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Details {
connection_id: Option<String>,
user_id: Option<String>,
features: Features,
signing: Option<SigningKey>,
cnf: Option<Cnf>,
}
#[derive(serde::Deserialize)]
struct Cnf {
jkt: Option<String>,
}
let ready = message.payload::<Ready>().unwrap_or_default();
if self.sealing.is_some()
&& let Some(own) = self.keys.bound_thumbprint()
&& ready.details.cnf.as_ref().and_then(|c| c.jkt.as_deref()) != Some(own.as_str())
{
self.fail(Error::Auth(
"the server did not bind the session to this client's key (cnf); for a token \
that names no key, set Encryption::bind_session to false"
.to_owned(),
));
return;
}
if let Some(signing) = ready.details.signing {
self.take_signing_key(signing.kid);
}
let connection_id = ready
.connection_id
.or(ready.details.connection_id)
.unwrap_or_default();
if ready.details.features.recovery {
self.server_recovery = true;
}
if let Some(ttl) = ready.details.features.history_ttl {
self.history_ttl = Some(Duration::from_secs(ttl));
}
self.take_connection(connection_id, ready.details.user_id);
}
fn on_server_hello(&mut self, message: &Message<'_>) {
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Hello {
server_version: Option<String>,
connection_id: Option<String>,
features: Features,
signing: Option<SigningKey>,
e2e: Option<serde_json::Value>,
}
let hello = message.payload::<Hello>().unwrap_or_default();
if hello.features.recovery {
self.server_recovery = true;
}
if let Some(ttl) = hello.features.history_ttl {
self.history_ttl = Some(Duration::from_secs(ttl));
}
if let Some(sealing) = &mut self.sealing {
let answer = hello
.e2e
.as_ref()
.ok_or_else(|| Error::Encryption("the server did not answer the offer".to_owned()))
.and_then(|e2e| {
sealing.accept(
&self.keys,
e2e,
hello.connection_id.as_deref().unwrap_or(""),
)
});
match answer {
Ok(()) => {
tracing::info!("[WSE] end-to-end session open");
let th = self.sealing.as_ref().and_then(Sealing::transcript_hash);
match th.map(|th| self.keys.prove_session(&th)).transpose() {
Ok(Some(Some(proof))) => self.outbox.insert(0, Outgoing::Text(proof)),
Ok(_) => {}
Err(error) => self.fail(error),
}
}
Err(error) => self.fail(error),
}
return;
}
if let Some(signing) = hello.signing {
self.take_signing_key(signing.kid);
}
let older = hello
.server_version
.as_deref()
.and_then(|v| v.split('.').next())
.and_then(|major| major.parse::<u32>().ok())
.is_some_and(|major| major < 3);
if older && !self.ready {
self.take_connection(hello.connection_id.unwrap_or_default(), None);
}
}
fn take_signing_key(&mut self, kid: String) {
let kid = if self.keys.signs_for(&kid) {
Some(kid)
} else {
tracing::warn!("[WSE] the server names signing key {kid}, which is not pinned");
None
};
if let Ok(mut server_kid) = self.shared.server_kid.lock() {
*server_kid = kid;
}
}
fn take_connection(&mut self, connection_id: String, user_id: Option<String>) {
if self.ready {
return;
}
self.ready = true;
self.became_ready = true;
if let Ok(mut connection) = self.shared.connection.lock() {
*connection = Some((connection_id.clone(), user_id.clone()));
}
if self.last_user.as_ref().is_some_and(|last| *last != user_id) {
self.forget_user();
}
self.last_user = Some(user_id.clone());
self.user_id.clone_from(&user_id);
self.connections += 1;
self.shared
.connections
.store(self.connections, Ordering::Release);
self.shared.ready.store(true, Ordering::Release);
let topics: Vec<String> = self.wanted.iter().cloned().collect();
if !topics.is_empty() {
self.rewind_to_committed(&topics);
self.send_subscription(&topics);
}
tracing::info!(
"[WSE] connected as {connection_id} (recovery: {})",
self.server_recovery
);
let reconnected = std::mem::replace(&mut self.connected_before, true);
self.handler.event(Event::Connected(Connected {
connection_id,
user_id,
reconnected,
recovery: self.server_recovery,
}));
}
fn forget_user(&mut self) {
self.users += 1;
self.shared.users.store(self.users, Ordering::Release);
self.topics.clear();
self.unrecoverable.clear();
self.holes = 0;
self.next_deadline = None;
}
fn on_error(&mut self, message: &Message<'_>) {
let details = message.payload_value().unwrap_or_default();
let field = |name: &str| {
details
.get(name)
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
.to_owned()
};
let (code, text) = (field("code"), field("message"));
tracing::warn!("[WSE] server error {code}: {text}");
if self.sealing.is_some()
&& matches!(code.as_str(), "E2E_UNSUPPORTED" | "KEY_EXCHANGE_FAILED")
{
self.fail(Error::Encryption(format!(
"the server refused the session: {text}"
)));
}
self.handler.event(Event::ServerError(ServerError {
code,
message: text,
details,
}));
}
}
fn rfc3339_ms(ms: u64) -> String {
let secs = ms / 1000;
let (days, of_day) = (secs / 86_400, secs % 86_400);
let z = days as i64 + 719_468;
let (era, doe) = (z.div_euclid(146_097), z.rem_euclid(146_097));
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let day = doy - (153 * mp + 2) / 5 + 1;
let month = if mp < 10 { mp + 3 } else { mp - 9 };
let year = yoe + era * 400 + i64::from(month <= 2);
format!(
"{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}.{:03}Z",
of_day / 3600,
of_day % 3600 / 60,
of_day % 60,
ms % 1000
)
}
fn is_protocol(kind: &str) -> bool {
matches!(
kind,
"ping"
| "PING"
| "pong"
| "PONG"
| "server_ready"
| "server_hello"
| "subscription_update"
| "error"
)
}
#[derive(serde::Deserialize, Default)]
#[serde(default)]
struct Features {
recovery: bool,
history_ttl: Option<u64>,
}
#[derive(serde::Deserialize)]
struct SigningKey {
kid: String,
}
fn subscription(topics: &[&str], positions: &[(&str, Position, Vec<Position>)]) -> String {
let mut text =
String::from(r#"{"c":"WSE","t":"subscription_update","p":{"action":"subscribe","topics":"#);
push_json(&mut text, topics);
if !positions.is_empty() {
text.push_str(r#","recover":true,"recovery":{"#);
for (i, (topic, at, streams)) in positions.iter().enumerate() {
if i > 0 {
text.push(',');
}
push_json(&mut text, topic);
let _ = write!(
text,
r#":{{"epoch":"{:08x}","offset":{}"#,
at.epoch, at.offset
);
if !streams.is_empty() {
text.push_str(r#","streams":{"#);
for (j, stream) in streams.iter().enumerate() {
if j > 0 {
text.push(',');
}
let _ = write!(text, r#""{:08x}":{}"#, stream.epoch, stream.offset);
}
text.push('}');
}
text.push('}');
}
text.push('}');
}
text.push_str("},\"v\":1}");
text
}
fn push_json<T: serde::Serialize + ?Sized>(text: &mut String, value: &T) {
text.push_str(&serde_json::to_string(value).unwrap_or_else(|_| "null".to_owned()));
}
pub(crate) fn now_ms() -> u64 {
web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as u64)
}
pub(crate) fn ping() -> String {
format!(
r#"{{"c":"WSE","t":"ping","p":{{"timestamp":{}}},"v":1}}"#,
now_ms()
)
}
pub(crate) fn client_hello(compression: bool, e2e: Option<serde_json::Value>) -> String {
let mut p = serde_json::json!({
"client_version": env!("CARGO_PKG_VERSION"),
"protocol_version": 1,
"features": {
"compression": compression,
"encryption": e2e.is_some(),
"batching": true,
},
});
if let Some(e2e) = e2e {
p["e2e"] = e2e;
}
serde_json::json!({"c": "WSE", "t": "client_hello", "p": p, "v": 1}).to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Default)]
struct Seen {
offsets: Vec<u64>,
events: Vec<Event>,
}
impl Handler for Seen {
fn message(&mut self, message: &Message<'_>) {
if let Some(at) = message.position() {
self.offsets.push(at.offset);
}
}
fn event(&mut self, event: Event) {
self.events.push(event);
}
}
fn session(recovery_timeout: Duration) -> Session<Seen> {
let shared = Arc::new(Shared::new(None));
let keys = Arc::new(Keys::from_config(&crate::Config::new("ws://x")).unwrap());
let mut session = Session::new(
Seen::default(),
shared,
keys,
&["t".to_owned()],
recovery_timeout,
Duration::from_secs(40),
);
session.open(None);
session
}
fn ready(session: &mut Session<Seen>, recovery: bool) {
ready_as(session, "u", recovery);
}
fn ready_as(session: &mut Session<Seen>, user: &str, recovery: bool) {
session.on_json(
&format!(
r#"{{"c":"WSE","t":"server_ready","p":{{"details":{{"connection_id":"c1","user_id":"{user}","features":{{"recovery":{recovery}}}}}}}}}"#
),
None,
);
}
fn feed(session: &mut Session<Seen>, epoch: &str, offsets: &[u64]) {
for o in offsets {
session.on_json(
&format!(r#"{{"tp":"t","e":"{epoch}","o":{o},"c":"U","t":"m","p":{{}}}}"#),
None,
);
}
session.alive_at(session.clock);
}
fn pongs(session: &mut Session<Seen>, n: u32) {
for _ in 0..n {
session.clock += Duration::from_secs(15);
session.alive_at(session.clock);
}
}
fn sent(session: &mut Session<Seen>) -> Vec<serde_json::Value> {
session
.outbox
.drain(..)
.map(|(Outgoing::Text(text) | Outgoing::Handshake(text))| {
serde_json::from_str(text.as_str()).unwrap()
})
.collect()
}
fn gaps(session: &Session<Seen>) -> Vec<(Option<u64>, Option<u64>, GapReason)> {
session
.handler
.events
.iter()
.filter_map(|e| match e {
Event::Gap(g) => Some((g.first, g.last, g.reason)),
_ => None,
})
.collect()
}
const E: &str = "0000000a";
fn reply(s: &mut Session<Seen>, epoch: &str, offset: u64, recovered: bool, count: u64) {
s.on_json(
&format!(
r#"{{"c":"WSE","t":"subscription_update","p":{{"success_topics":["t"],"recovery":{{"t":{{"epoch":"{epoch}","offset":{offset},"recovered":{recovered},"count":{count}}}}}}}}}"#
),
None,
);
}
#[test]
fn an_unsealed_handshake_frame_never_reaches_a_topic() {
let mut s = session(Duration::from_secs(3));
s.on_unsealed(Some(
r#"{"t":"ping","tp":"t","e":"0000000a","o":18446744073709551615,"p":{}}"#,
));
assert!(s.handler.offsets.is_empty());
assert!(
s.topics
.get("t")
.and_then(|t| t.streams.position())
.is_none()
);
assert!(s.outbox.is_empty());
ready(&mut s, true);
s.on_json(
r#"{"t":"error","tp":"t","e":"0000000a","o":99,"p":{"code":"X","message":"y"}}"#,
None,
);
feed(&mut s, E, &[1]);
assert_eq!(s.handler.offsets, [1]);
}
#[test]
fn a_recovery_starts_where_the_application_committed() {
use crate::message::Position;
let committed: Arc<std::sync::Mutex<BTreeMap<String, Vec<Position>>>> = Arc::default();
let positions = Arc::clone(&committed);
let mut s = session(Duration::from_secs(3));
s.committed = Some(Arc::new(move |user: Option<&str>| {
assert_eq!(user, Some("u"));
Some(positions.lock().unwrap().clone())
}));
ready(&mut s, true);
sent(&mut s);
feed(&mut s, E, &[1, 2, 3, 4]);
committed.lock().unwrap().insert(
"t".to_owned(),
vec![Position {
epoch: 0xa,
offset: 2,
}],
);
s.close();
s.open(None);
ready(&mut s, true);
let request = &sent(&mut s)[0];
assert_eq!(
request["p"]["recovery"]["t"]["streams"],
serde_json::json!({ E: 2 })
);
feed(&mut s, E, &[3, 4, 5]);
assert_eq!(s.handler.offsets, [1, 2, 3, 4, 3, 4, 5]);
}
#[test]
fn a_late_answer_settles_only_its_own_hole() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
sent(&mut s);
feed(&mut s, E, &[1, 3]);
feed(&mut s, E, &[2]);
assert_eq!(s.handler.offsets, [1, 2, 3]);
feed(&mut s, E, &[5]);
assert_eq!(sent(&mut s).len(), 2);
reply(&mut s, E, 3, true, 1);
assert!(gaps(&s).is_empty());
feed(&mut s, E, &[4]);
reply(&mut s, E, 5, true, 1);
assert_eq!(s.handler.offsets, [1, 2, 3, 4, 5]);
assert!(gaps(&s).is_empty());
assert_eq!(s.next_deadline(), None);
}
#[test]
fn gaps_in_two_streams_of_a_topic_are_recovered_each() {
const F: &str = "0000000b";
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
sent(&mut s);
feed(&mut s, E, &[1]);
feed(&mut s, F, &[1]);
feed(&mut s, E, &[3]);
feed(&mut s, F, &[3]);
assert_eq!(sent(&mut s).len(), 2);
feed(&mut s, E, &[2]);
feed(&mut s, F, &[2]);
reply(&mut s, E, 3, true, 1);
reply(&mut s, F, 3, true, 1);
assert_eq!(s.handler.offsets, [1, 1, 2, 3, 2, 3]);
assert!(gaps(&s).is_empty());
assert_eq!(s.next_deadline(), None);
}
#[test]
fn a_replay_the_server_cut_short_is_asked_for_again() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
sent(&mut s);
feed(&mut s, E, &[1, 5]);
sent(&mut s);
feed(&mut s, E, &[2]);
reply(&mut s, E, 2, false, 1);
assert!(gaps(&s).is_empty());
let again = sent(&mut s);
assert_eq!(
again[0]["p"]["recovery"],
serde_json::json!({"t": {"epoch": E, "offset": 2, "streams": {E: 2}}})
);
feed(&mut s, E, &[3, 4]);
reply(&mut s, E, 4, true, 2);
assert_eq!(s.handler.offsets, [1, 2, 3, 4, 5]);
assert!(gaps(&s).is_empty());
}
#[test]
fn a_reconnect_gives_a_hole_its_whole_wait_again() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 3]);
let first = s.next_deadline().unwrap();
s.close();
std::thread::sleep(Duration::from_millis(20));
s.open(None);
ready(&mut s, true);
assert!(s.next_deadline().unwrap() > first);
assert!(gaps(&s).is_empty());
}
#[test]
fn signed_times_read_as_the_other_clients_write_them() {
assert_eq!(rfc3339_ms(0), "1970-01-01T00:00:00.000Z");
assert_eq!(rfc3339_ms(951_782_400_000), "2000-02-29T00:00:00.000Z");
assert_eq!(rfc3339_ms(1_700_000_000_123), "2023-11-14T22:13:20.123Z");
}
#[test]
fn a_message_signed_for_no_topic_is_not_taken_on_one() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
s.on_json(
r#"{"t":"signed","tp":"t","e":"0000000a","o":1,"sb":"{\"t\":\"fill\",\"p\":{}}","sig":"AA","kid":"k"}"#,
None,
);
assert!(s.handler.offsets.is_empty());
s.on_json(
r#"{"t":"signed","tp":"t","e":"0000000a","o":1,"sb":"{\"t\":\"fill\",\"tp\":\"t\",\"p\":{}}","sig":"AA","kid":"k"}"#,
None,
);
assert_eq!(s.handler.offsets, [1]);
}
#[test]
fn a_gap_is_filled_by_the_replay_and_what_came_past_it_follows() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
assert_eq!(sent(&mut s)[0]["p"]["topics"], serde_json::json!(["t"]));
feed(&mut s, E, &[1, 2, 4, 5]);
assert_eq!(s.handler.offsets, [1, 2]);
let request = sent(&mut s);
assert_eq!(
request[0]["p"]["recovery"],
serde_json::json!({"t": {"epoch": E, "offset": 2, "streams": {E: 2}}})
);
feed(&mut s, E, &[3, 4, 5]);
s.on_json(
r#"{"c":"WSE","t":"subscription_update","p":{"success_topics":["t"],"failed_topics":[],"recovery":{"t":{"epoch":"0000000a","offset":5,"recovered":true,"count":3}}}}"#,
None,
);
assert_eq!(s.handler.offsets, [1, 2, 3, 4, 5]);
assert!(gaps(&s).is_empty());
assert_eq!(s.next_deadline(), None);
feed(&mut s, E, &[6]);
assert_eq!(s.handler.offsets, [1, 2, 3, 4, 5, 6]);
}
#[test]
fn a_gap_not_filled_in_time_is_reported_and_what_is_held_delivered() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 3, 4]);
assert_eq!(s.handler.offsets, [1]);
s.on_deadline(Instant::now() + Duration::from_secs(4));
assert_eq!(s.handler.offsets, [1, 3, 4]);
assert_eq!(gaps(&s), [(Some(2), Some(2), GapReason::Timeout)]);
feed(&mut s, E, &[5]);
assert_eq!(s.handler.offsets, [1, 3, 4, 5]);
}
#[test]
fn without_recovery_a_gap_is_reported_at_once() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, false);
feed(&mut s, E, &[1, 4, 4, 5]);
assert_eq!(s.handler.offsets, [1, 4, 5]);
assert_eq!(gaps(&s), [(Some(2), Some(3), GapReason::Unavailable)]);
}
#[test]
fn a_new_connection_asks_for_its_topics_from_where_it_left_off() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 2]);
sent(&mut s);
s.close();
s.open(None);
ready(&mut s, true);
let request = sent(&mut s);
assert_eq!(
request[0]["p"],
serde_json::json!({
"action": "subscribe",
"topics": ["t"],
"recover": true,
"recovery": {"t": {"epoch": E, "offset": 2, "streams": {E: 2}}},
})
);
s.on_json(
r#"{"c":"WSE","t":"subscription_update","p":{"success_topics":["t"],"recovery":{"t":{"epoch":"0000000b","offset":0,"recovered":false,"count":0}}}}"#,
None,
);
assert_eq!(gaps(&s), [(None, None, GapReason::EpochChanged)]);
let Some(Event::Connected(again)) = s
.handler
.events
.iter()
.rev()
.find(|e| matches!(e, Event::Connected(_)))
else {
panic!("connected");
};
assert!(again.reconnected);
}
#[test]
fn a_connection_for_another_user_asks_for_its_topics_afresh() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 2]);
sent(&mut s);
s.close();
s.open(None);
ready_as(&mut s, "someone else", true);
let request = sent(&mut s);
assert_eq!(request[0]["p"]["topics"], serde_json::json!(["t"]));
assert_eq!(request[0]["p"].get("recovery"), None);
feed(&mut s, E, &[1]);
assert_eq!(s.handler.offsets, [1, 2, 1]);
}
fn reply_streams(s: &mut Session<Seen>, recovered: bool, streams: &[(&str, u64)]) {
let streams: serde_json::Map<String, serde_json::Value> = streams
.iter()
.map(|(epoch, offset)| ((*epoch).to_owned(), (*offset).into()))
.collect();
let reply = serde_json::json!({
"c": "WSE",
"t": "subscription_update",
"p": {
"success_topics": ["t"],
"recovery": {"t": {
"epoch": E, "offset": 0, "recovered": recovered, "count": 0,
"streams": streams,
}},
},
});
s.on_json(&reply.to_string(), None);
}
fn reconnect(s: &mut Session<Seen>) -> Vec<serde_json::Value> {
sent(s);
s.close();
s.open(None);
ready(s, true);
sent(s)
}
const F: &str = "0000000f";
#[test]
fn a_recovery_names_every_stream_of_the_topic() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, F, &[4]);
feed(&mut s, E, &[1, 2]);
let request = reconnect(&mut s);
assert_eq!(
request[0]["p"]["recovery"],
serde_json::json!({"t": {"epoch": E, "offset": 2, "streams": {E: 2, F: 4}}})
);
}
#[test]
fn a_listed_stream_the_client_did_not_know_starts_where_the_server_was() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
sent(&mut s);
reply_streams(&mut s, false, &[(F, 5)]);
feed(&mut s, F, &[3, 5, 6]);
assert_eq!(s.handler.offsets, [6]);
assert!(gaps(&s).is_empty());
}
#[test]
fn a_recovery_that_did_not_recover_reports_what_each_stream_lost() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 2]);
feed(&mut s, F, &[4]);
reconnect(&mut s);
reply_streams(&mut s, false, &[(E, 5)]);
assert_eq!(
gaps(&s),
[
(Some(3), Some(5), GapReason::NotRecovered),
(Some(5), None, GapReason::NotRecovered),
]
);
feed(&mut s, E, &[6]);
assert_eq!(s.handler.offsets, [1, 2, 4, 6]);
let request = reconnect(&mut s);
assert_eq!(
request[0]["p"]["recovery"]["t"]["streams"],
serde_json::json!({E: 6})
);
}
#[test]
fn a_recovery_with_nothing_to_show_still_says_it_did_not_recover() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 2]);
reconnect(&mut s);
reply_streams(&mut s, false, &[(E, 2)]);
assert_eq!(gaps(&s), [(None, None, GapReason::NotRecovered)]);
}
fn named_after_reconnect(s: &mut Session<Seen>) -> serde_json::Value {
sent(s);
s.close();
s.open(None);
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c2","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
let request = sent(s);
assert_eq!(request[0]["p"]["recover"], true);
request[0]["p"]["recovery"]["t"]["streams"].clone()
}
#[test]
fn a_stream_quiet_for_longer_than_the_server_keeps_it_is_not_named() {
let mut s = session(Duration::from_secs(3));
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c1","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
feed(&mut s, F, &[4]);
pongs(&mut s, 12);
feed(&mut s, E, &[1]);
assert_eq!(named_after_reconnect(&mut s), serde_json::json!({E: 1}));
}
#[test]
fn a_close_heard_only_after_a_sleep_keeps_the_stream() {
let mut s = session(Duration::from_secs(3));
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c1","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
feed(&mut s, E, &[1]);
s.clock += Duration::from_secs(400);
assert_eq!(named_after_reconnect(&mut s), serde_json::json!({E: 1}));
}
#[test]
fn frames_read_on_waking_prove_nothing_about_the_time_asleep() {
let mut s = session(Duration::from_secs(3));
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c1","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
feed(&mut s, E, &[1]);
s.clock += Duration::from_secs(400);
feed(&mut s, F, &[1]);
assert_eq!(
named_after_reconnect(&mut s),
serde_json::json!({E: 1, F: 1})
);
}
#[test]
fn a_sleep_the_connection_lived_through_counts_from_waking() {
let mut s = session(Duration::from_secs(3));
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c1","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
feed(&mut s, F, &[4]);
s.clock += Duration::from_secs(400);
feed(&mut s, E, &[1]);
pongs(&mut s, 12);
feed(&mut s, E, &[2]);
assert_eq!(named_after_reconnect(&mut s), serde_json::json!({E: 2}));
}
#[test]
fn time_away_does_not_count_as_a_quiet_stream() {
let mut s = session(Duration::from_secs(3));
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c1","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
feed(&mut s, E, &[1]);
sent(&mut s);
s.close();
s.clock += Duration::from_secs(400);
s.open(None);
s.on_json(
r#"{"c":"WSE","t":"server_ready","p":{"details":{"connection_id":"c2","user_id":"u","features":{"recovery":true,"history_ttl":60}}}}"#,
None,
);
let request = sent(&mut s);
assert_eq!(request[0]["p"]["recover"], true);
assert_eq!(
request[0]["p"]["recovery"]["t"]["streams"],
serde_json::json!({E: 1})
);
}
#[test]
fn a_topic_left_starts_over_when_joined_again() {
let mut s = session(Duration::from_secs(3));
ready(&mut s, true);
feed(&mut s, E, &[1, 2]);
s.unsubscribe(vec!["t".to_owned()]);
s.subscribe(vec!["t".to_owned()]);
let requests = sent(&mut s);
assert_eq!(requests.last().unwrap()["p"].get("recovery"), None);
feed(&mut s, E, &[9]);
assert_eq!(s.handler.offsets, [1, 2, 9]);
assert!(gaps(&s).is_empty());
}
#[test]
fn requests_are_json() {
let last = Position {
epoch: 0xab,
offset: 7,
};
let other = Position {
epoch: 0x12,
offset: 3,
};
let text = subscription(&["a\"b", "c"], &[("c", last, vec![other, last])]);
let value: serde_json::Value = serde_json::from_str(text.as_str()).unwrap();
assert_eq!(
value["p"],
serde_json::json!({
"action": "subscribe",
"topics": ["a\"b", "c"],
"recover": true,
"recovery": {"c": {
"epoch": "000000ab",
"offset": 7,
"streams": {"00000012": 3, "000000ab": 7},
}},
})
);
let hello: serde_json::Value =
serde_json::from_str(client_hello(true, None).as_str()).unwrap();
assert_eq!(hello["t"], "client_hello");
assert_eq!(hello["p"]["features"]["compression"], true);
}
#[test]
#[ignore]
fn the_cost_of_a_message() {
#[derive(serde::Deserialize)]
struct Tick<'a> {
#[serde(borrow)]
symbol: &'a str,
price: f64,
}
struct Decode(f64);
impl Handler for Decode {
fn message(&mut self, message: &Message<'_>) {
if message.kind() == "tick" {
let tick: Tick<'_> = message.payload().unwrap();
self.0 += tick.price + tick.symbol.len() as f64;
}
}
}
let n = 1_000_000u64;
let frames: Vec<String> = (1..=n)
.map(|o| {
format!(
r#"{{"tp":"bench","e":"0000abcd","o":{o},"t":"tick","p":{{"symbol":"BTCUSDT","price":67012.5,"qty":0.0125,"side":"buy","ts":1794600000000}}}}"#
)
})
.collect();
let shared = Arc::new(Shared::new(None));
let keys = Arc::new(Keys::from_config(&crate::Config::new("ws://x")).unwrap());
let mut s = Session::new(
Decode(0.0),
shared,
keys,
&[],
Duration::from_secs(3),
Duration::from_secs(40),
);
s.open(None);
let started = std::time::Instant::now();
for frame in &frames {
s.on_json(frame, None);
}
let all = started.elapsed().as_nanos() as f64 / n as f64;
let started = std::time::Instant::now();
let mut kinds = 0usize;
for frame in &frames {
kinds += decode::json_envelope(frame).unwrap().t.unwrap().len();
}
let envelope = started.elapsed().as_nanos() as f64 / n as f64;
let started = std::time::Instant::now();
for frame in &frames {
let value: serde_json::Value = serde_json::from_str(frame).unwrap();
kinds += value["t"].as_str().unwrap().len();
}
let value = started.elapsed().as_nanos() as f64 / n as f64;
println!(
"per message: session {all:.0} ns (envelope {envelope:.0} ns); a serde_json::Value {value:.0} ns [{kinds} {}]",
s.handler.0
);
}
}