use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, OnceLock};
use ahash::AHashSet;
use bytes::Bytes;
use dashmap::DashMap;
use tokio::sync::mpsc;
use tokio_tungstenite::tungstenite::protocol::Message;
use super::e2e::{e2e_frame, e2e_message};
use super::frames::{encode_ws_frame, ws_frame_size};
use super::state::Seal;
use super::{ConnectionHandle, QueueGroup, Tally, WsFrame};
use crate::cluster::ClusterMetrics;
use crate::msgpack::serde_json_to_rmpv;
pub(crate) fn glob_match(pattern: &str, text: &str) -> bool {
let pb = pattern.as_bytes();
let tb = text.as_bytes();
let (mut pi, mut ti) = (0usize, 0usize);
let (mut star_p, mut star_t) = (usize::MAX, 0usize);
while ti < tb.len() {
if pi < pb.len() && (pb[pi] == b'?' || pb[pi] == tb[ti]) {
pi += 1;
ti += 1;
} else if pi < pb.len() && pb[pi] == b'*' {
star_p = pi;
star_t = ti;
pi += 1;
} else if star_p != usize::MAX {
pi = star_p + 1;
star_t += 1;
ti = star_t;
} else {
return false;
}
}
while pi < pb.len() && pb[pi] == b'*' {
pi += 1;
}
pi == pb.len()
}
#[derive(Debug, Clone)]
pub(crate) struct TopicAcl {
pub(crate) allow: Vec<String>,
pub(crate) deny: Vec<String>,
}
impl TopicAcl {
pub(crate) fn deny_all() -> Self {
Self {
allow: Vec::new(),
deny: vec!["*".to_string()],
}
}
pub(crate) fn is_allowed(&self, topic: &str) -> bool {
for pattern in &self.deny {
if glob_match(pattern, topic) {
return false;
}
}
if self.allow.is_empty() {
return true;
}
for pattern in &self.allow {
if glob_match(pattern, topic) {
return true;
}
}
false
}
}
pub(crate) struct Outgoing {
payload: Bytes,
frame: Bytes,
text: bool,
packed: OnceLock<Option<(Bytes, Bytes)>>,
}
impl Outgoing {
pub(crate) fn text(payload: Bytes) -> Self {
let frame = encode_ws_frame(0x01, &payload);
Self {
payload,
frame,
text: true,
packed: OnceLock::new(),
}
}
pub(crate) fn binary(payload: Bytes) -> Self {
let frame = encode_ws_frame(0x02, &payload);
Self {
payload,
frame,
text: false,
packed: OnceLock::new(),
}
}
fn for_handle(&self, h: &ConnectionHandle) -> (&Bytes, &Bytes) {
if h.msgpack
&& self.text
&& let Some((payload, frame)) = self.packed.get_or_init(|| {
let payload = to_msgpack(&self.payload)?;
let frame = encode_ws_frame(0x02, &payload);
Some((payload, frame))
})
{
return (payload, frame);
}
(&self.payload, &self.frame)
}
}
pub(crate) fn to_msgpack(json: &[u8]) -> Option<Bytes> {
let value: serde_json::Value = serde_json::from_slice(json).ok()?;
let mut buf = Vec::with_capacity(json.len());
buf.extend_from_slice(b"M:");
rmpv::encode::write_value(&mut buf, &serde_json_to_rmpv(&value)).ok()?;
Some(Bytes::from(buf))
}
impl ConnectionHandle {
pub(crate) fn deliver(
&self,
msg: &Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
) -> bool {
if !self.has_room(max_pending, slow_drops) {
return false;
}
let (payload, frame) = msg.for_handle(self);
match self.out.cipher.get() {
None => self.push_frame(frame),
Some(Seal::Legacy(cipher)) => match e2e_frame(cipher, payload) {
Some(frame) => self.push_frame(&frame),
None => return false,
},
Some(Seal::Session) => return self.queue(WsFrame::Seal(payload.clone())),
}
true
}
fn has_room(&self, max_pending: usize, slow_drops: &AtomicU64) -> bool {
if self.out.closed.load(Ordering::Relaxed) {
return false;
}
if max_pending > 0 && self.out.pending.load(Ordering::Relaxed) >= max_pending {
slow_drops.fetch_add(1, Ordering::Relaxed);
return false;
}
true
}
fn queue_sized(&self, frame: WsFrame) -> Option<usize> {
let bytes = ws_frame_size(&frame);
self.out.pending.fetch_add(bytes, Ordering::Relaxed);
if self.tx.send(frame).is_err() {
self.out.pending.fetch_sub(bytes, Ordering::Relaxed);
return None;
}
Some(bytes)
}
fn queue(&self, frame: WsFrame) -> bool {
self.queue_sized(frame).is_some()
}
pub(crate) fn send_control(&self, msg: Message) -> bool {
match (self.out.cipher.get(), msg) {
(Some(Seal::Session), Message::Text(text)) => {
self.queue(WsFrame::Seal(Bytes::from(text)))
}
(Some(Seal::Session), Message::Binary(data)) => self.queue(WsFrame::Seal(data)),
(_, msg) => self.queue(WsFrame::Msg(msg)),
}
}
pub(crate) fn send_one(
&self,
msg: Message,
max_pending: usize,
slow_drops: &AtomicU64,
) -> Option<usize> {
if max_pending > 0 && self.out.pending.load(Ordering::Relaxed) >= max_pending {
slow_drops.fetch_add(1, Ordering::Relaxed);
return None;
}
self.send_owed(msg)
}
pub(crate) fn send_owed(&self, msg: Message) -> Option<usize> {
let msg = match msg {
Message::Text(text) if self.msgpack => match to_msgpack(text.as_bytes()) {
Some(packed) => Message::Binary(packed),
None => Message::Text(text),
},
msg => msg,
};
let frame = match (self.out.cipher.get(), msg) {
(Some(Seal::Legacy(cipher)), Message::Text(text)) => {
WsFrame::Msg(e2e_message(cipher, text.as_bytes())?)
}
(Some(Seal::Legacy(cipher)), Message::Binary(data)) => {
WsFrame::Msg(e2e_message(cipher, &data)?)
}
(Some(Seal::Session), Message::Text(text)) => WsFrame::Seal(Bytes::from(text)),
(Some(Seal::Session), Message::Binary(data)) => WsFrame::Seal(data),
(_, msg) => WsFrame::Msg(msg),
};
self.queue_sized(frame)
}
fn push_frame(&self, frame: &Bytes) {
let out = &*self.out;
out.pending.fetch_add(frame.len(), Ordering::Relaxed);
let was_empty = {
let mut queue = out.frames.lock();
let empty = queue.is_empty();
queue.push(frame);
empty
};
if was_empty {
out.notify.notify_one();
}
}
}
type ConnMap = HashMap<String, ConnectionHandle, ahash::RandomState>;
const MAX_LANES: usize = 64;
const LANE_BATCH: usize = 64;
pub(crate) const BEHIND_BYTES: usize = 64 * 1024;
const LANE_PACE: std::time::Duration = std::time::Duration::from_millis(1);
const PACE_MIN: usize = 32;
#[derive(Default, Clone, Copy)]
struct Served {
delivered: u64,
dropped: u64,
behind: usize,
}
impl Served {
fn deliver(
&mut self,
h: &ConnectionHandle,
msg: &Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
) {
let behind = h.out.pending.load(Ordering::Relaxed) >= BEHIND_BYTES;
if h.deliver(msg, max_pending, slow_drops) {
self.delivered += 1;
self.behind += usize::from(behind);
} else {
self.dropped += 1;
}
}
fn lagging(&self) -> bool {
let reached = (self.delivered + self.dropped) as usize;
reached >= PACE_MIN && self.behind * 2 > self.delivered as usize
}
}
#[cfg(test)]
mod pacing_tests {
use super::*;
#[test]
fn a_closed_or_full_connection_never_holds_the_lane_back() {
let drops = AtomicU64::new(0);
let msg = Outgoing::text(bytes::Bytes::from_static(b"{}"));
let lagging = |max_pending: usize, closed: bool| {
let mut served = Served::default();
for _ in 0..PACE_MIN {
let (h, _rx) = super::super::tests::test_handle();
h.out.pending.store(BEHIND_BYTES, Ordering::Relaxed);
h.out.closed.store(closed, Ordering::Relaxed);
served.deliver(&h, &msg, max_pending, &drops);
}
served.lagging()
};
assert!(lagging(0, false));
assert!(!lagging(BEHIND_BYTES, false));
assert!(!lagging(0, true));
}
#[test]
fn many_reached_and_most_takers_behind_hold_the_lane_back() {
let drops = AtomicU64::new(0);
let msg = Outgoing::text(bytes::Bytes::from_static(b"{}"));
let mut served = Served::default();
for i in 0..PACE_MIN {
let (h, _rx) = super::super::tests::test_handle();
let full = i % 3 != 0;
h.out.pending.store(
if full { 2 * BEHIND_BYTES } else { BEHIND_BYTES },
Ordering::Relaxed,
);
served.deliver(&h, &msg, 2 * BEHIND_BYTES, &drops);
}
assert!((served.delivered as usize) < PACE_MIN);
assert!(served.lagging());
}
}
pub(super) const LANE_QUEUE: usize = 1024;
pub(crate) fn lane_count() -> usize {
std::thread::available_parallelism()
.map_or(1, std::num::NonZeroUsize::get)
.min(MAX_LANES)
}
fn lanes_of(mut mask: u64) -> impl Iterator<Item = usize> {
std::iter::from_fn(move || {
(mask != 0).then(|| {
let lane = mask.trailing_zeros() as usize;
mask &= mask - 1;
lane
})
})
}
#[derive(Default)]
pub(crate) struct Subscribers {
parts: Vec<ConnMap>,
pub(super) mask: u64,
len: usize,
}
impl Subscribers {
pub(crate) fn len(&self) -> usize {
self.len
}
fn slot(&self, lane: u8) -> usize {
(self.mask & ((1u64 << lane) - 1)).count_ones() as usize
}
fn part(&self, lane: u8) -> Option<&ConnMap> {
(self.mask & (1u64 << lane) != 0).then(|| &self.parts[self.slot(lane)])
}
fn insert(&mut self, conn_id: &str, handle: &ConnectionHandle) -> bool {
let lane = handle.lane;
let slot = self.slot(lane);
if self.mask & (1u64 << lane) == 0 {
self.parts.insert(slot, ConnMap::default());
self.mask |= 1u64 << lane;
}
let added = self.parts[slot]
.insert(conn_id.to_owned(), handle.clone())
.is_none();
self.len += usize::from(added);
added
}
fn remove(&mut self, conn_id: &str) -> bool {
let Some(slot) = self
.parts
.iter_mut()
.position(|part| part.remove(conn_id).is_some())
else {
return false;
};
self.len -= 1;
if self.parts[slot].is_empty() {
self.parts.remove(slot);
let mut rest = self.mask;
for _ in 0..slot {
rest &= rest - 1;
}
self.mask &= !(rest & rest.wrapping_neg());
}
true
}
}
#[derive(Clone)]
pub(crate) struct TopicIndex {
pub(crate) subscribers: Arc<DashMap<String, Subscribers>>,
patterns: Arc<DashMap<String, Vec<String>>>,
pattern_count: Arc<AtomicUsize>,
pub(crate) acls: Arc<DashMap<String, TopicAcl>>,
everyone: Arc<[parking_lot::RwLock<ConnMap>]>,
pub(super) occupied: Arc<AtomicU64>,
drained: Arc<[Arc<tokio::sync::Notify>]>,
joined: Arc<AtomicUsize>,
}
pub(crate) fn is_pattern(topic: &str) -> bool {
topic.contains(['*', '?'])
}
fn is_separator(b: u8) -> bool {
matches!(b, b':' | b'.' | b'/')
}
fn pattern_bucket(pattern: &str) -> &str {
let literal = &pattern[..pattern.find(['*', '?']).unwrap_or(pattern.len())];
match literal.bytes().rposition(is_separator) {
Some(i) => &literal[..=i],
None => "",
}
}
impl TopicIndex {
pub(crate) fn new(lanes: usize) -> Self {
Self {
subscribers: Arc::default(),
patterns: Arc::default(),
pattern_count: Arc::default(),
acls: Arc::default(),
everyone: (0..lanes.clamp(1, MAX_LANES))
.map(|_| parking_lot::RwLock::new(ConnMap::default()))
.collect(),
occupied: Arc::default(),
drained: (0..lanes.clamp(1, MAX_LANES))
.map(|_| Arc::new(tokio::sync::Notify::new()))
.collect(),
joined: Arc::default(),
}
}
pub(crate) fn lanes(&self) -> usize {
self.everyone.len()
}
#[cfg(test)]
pub(crate) fn pattern_count(&self) -> usize {
self.pattern_count.load(Ordering::Relaxed)
}
pub(crate) fn drained(&self, lane: u8) -> Arc<tokio::sync::Notify> {
Arc::clone(&self.drained[usize::from(lane)])
}
pub(crate) fn next_lane(&self) -> u8 {
(self.joined.fetch_add(1, Ordering::Relaxed) % self.lanes()) as u8
}
pub(crate) fn join(&self, conn_id: &str, handle: &ConnectionHandle) {
let mut conns = self.everyone[usize::from(handle.lane)].write();
conns.insert(conn_id.to_owned(), handle.clone());
self.occupied
.fetch_or(1u64 << handle.lane, Ordering::Release);
}
pub(crate) fn leave(&self, conn_id: &str, lane: u8) {
let mut conns = self.everyone[usize::from(lane)].write();
conns.remove(conn_id);
if conns.is_empty() {
self.occupied.fetch_and(!(1u64 << lane), Ordering::Release);
}
}
pub(crate) fn subscribe(&self, topic: &str, conn_id: &str, handle: &ConnectionHandle) -> bool {
let mut subs = self.subscribers.entry(topic.to_owned()).or_default();
let added = subs.insert(conn_id, handle);
if added && subs.len == 1 && is_pattern(topic) {
self.patterns
.entry(pattern_bucket(topic).to_owned())
.or_default()
.push(topic.to_owned());
self.pattern_count.fetch_add(1, Ordering::Relaxed);
}
added
}
pub(crate) fn unsubscribe(&self, topic: &str, conn_id: &str) -> bool {
if let dashmap::Entry::Occupied(mut subs) = self.subscribers.entry(topic.to_owned()) {
subs.get_mut().remove(conn_id);
if subs.get().len == 0 {
subs.remove();
if is_pattern(topic) {
let bucket = pattern_bucket(topic);
if let Some(mut patterns) = self.patterns.get_mut(bucket) {
patterns.retain(|p| p != topic);
}
self.patterns
.remove_if(bucket, |_, patterns| patterns.is_empty());
self.pattern_count.fetch_sub(1, Ordering::Relaxed);
}
return true;
}
}
false
}
fn reach(&self, topic: &str) -> (Vec<String>, u64) {
let mut mask = self.subscribers.get(topic).map_or(0, |subs| subs.mask);
if self.pattern_count.load(Ordering::Relaxed) == 0 {
return (Vec::new(), mask);
}
let mut matching: Vec<String> = Vec::new();
let mut look = |bucket: &str| {
if let Some(patterns) = self.patterns.get(bucket) {
matching.extend(
patterns
.iter()
.filter(|pattern| pattern.as_str() != topic && glob_match(pattern, topic))
.cloned(),
);
}
};
look("");
for (i, b) in topic.bytes().enumerate() {
if is_separator(b) {
look(&topic[..=i]);
}
}
for pattern in &matching {
mask |= self.subscribers.get(pattern).map_or(0, |subs| subs.mask);
}
(matching, mask)
}
fn deliver_all(
&self,
lane: u8,
msg: &Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
) -> Served {
let mut served = Served::default();
for h in self.everyone[usize::from(lane)].read().values() {
served.deliver(h, msg, max_pending, slow_drops);
}
served
}
#[allow(clippy::too_many_arguments)]
fn deliver_topic(
&self,
lane: u8,
topic: &str,
patterns: &[String],
msg: &Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
seen: &mut AHashSet<usize>,
) -> Served {
let mut served = Served::default();
if patterns.is_empty() {
if let Some(subs) = self.subscribers.get(topic)
&& let Some(part) = subs.part(lane)
{
for h in part.values() {
served.deliver(h, msg, max_pending, slow_drops);
}
}
return served;
}
seen.clear();
let id = |h: &ConnectionHandle| Arc::as_ptr(&h.out) as usize;
if let Some(subs) = self.subscribers.get(topic)
&& let Some(part) = subs.part(lane)
{
for h in part.values() {
if seen.insert(id(h)) {
served.deliver(h, msg, max_pending, slow_drops);
}
}
}
for pattern in patterns {
let Some(subs) = self.subscribers.get(pattern) else {
continue;
};
let Some(part) = subs.part(lane) else {
continue;
};
for (conn_id, h) in part {
let allowed = self
.acls
.get(conn_id)
.is_none_or(|acl| acl.is_allowed(topic));
if allowed && seen.insert(id(h)) {
served.deliver(h, msg, max_pending, slow_drops);
}
}
}
served
}
#[cfg(test)]
pub(crate) fn fanout(
&self,
topic: &str,
msg: &Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
) -> (u64, u64) {
let (patterns, mask) = self.reach(topic);
let mut seen = AHashSet::new();
lanes_of(mask).fold((0, 0), |(delivered, dropped), lane| {
let served = self.deliver_topic(
lane as u8,
topic,
&patterns,
msg,
max_pending,
slow_drops,
&mut seen,
);
(delivered + served.delivered, dropped + served.dropped)
})
}
}
enum Job {
All(Arc<Outgoing>),
Topic(Arc<TopicMessage>),
One(ConnectionHandle, Arc<Outgoing>),
}
struct TopicMessage {
topic: String,
patterns: Vec<String>,
msg: Outgoing,
tally: Option<Arc<ClusterMetrics>>,
}
#[derive(Clone)]
pub(crate) struct Fanout {
index: TopicIndex,
lanes: Arc<[mpsc::Sender<Job>]>,
}
async fn hand(lane: &mpsc::Sender<Job>, job: Job) {
if let Err(mpsc::error::TrySendError::Full(job)) = lane.try_send(job) {
let _ = lane.send(job).await;
}
}
impl Fanout {
pub(crate) fn start(index: TopicIndex, max_pending: usize, slow_drops: Arc<Tally>) -> Self {
let lanes = (0..index.lanes())
.map(|lane| {
let (tx, rx) = mpsc::channel(LANE_QUEUE);
tokio::spawn(run_lane(
lane as u8,
rx,
index.clone(),
max_pending,
Arc::clone(&slow_drops),
));
tx
})
.collect();
Self { index, lanes }
}
#[cfg(test)]
pub(super) fn room(&self, lane: usize) -> usize {
self.lanes[lane].capacity()
}
pub(crate) async fn broadcast(&self, msg: Outgoing) {
let occupied = self.index.occupied.load(Ordering::Acquire);
if occupied == 0 {
return;
}
let msg = Arc::new(msg);
for lane in lanes_of(occupied) {
hand(&self.lanes[lane], Job::All(Arc::clone(&msg))).await;
}
}
pub(crate) async fn publish(
&self,
topic: String,
msg: impl FnOnce() -> Outgoing,
tally: Option<&Arc<ClusterMetrics>>,
) {
let (patterns, mask) = self.index.reach(&topic);
if mask == 0 {
return;
}
let message = Arc::new(TopicMessage {
topic,
patterns,
msg: msg(),
tally: tally.cloned(),
});
for lane in lanes_of(mask) {
hand(&self.lanes[lane], Job::Topic(Arc::clone(&message))).await;
}
}
pub(crate) async fn queue_groups(
&self,
queue_groups: &DashMap<String, DashMap<String, QueueGroup>>,
topic: &str,
msg: impl FnOnce() -> Outgoing,
max_pending: usize,
slow_drops: &AtomicU64,
) -> (u64, u64) {
let mut chosen = Vec::new();
let mut dropped = 0u64;
{
let Some(topic_groups) = queue_groups.get(topic) else {
return (0, 0);
};
for group in topic_groups.iter() {
let len = group.members.len();
if len == 0 {
continue;
}
let base = group.next.fetch_add(1, Ordering::Relaxed);
let member = (0..len)
.map(|attempt| &group.members[(base + attempt) % len].1)
.find(|h| h.has_room(max_pending, slow_drops));
match member {
Some(h) => chosen.push(h.clone()),
None => dropped += 1,
}
}
}
if !chosen.is_empty() {
let msg = Arc::new(msg());
for h in &chosen {
hand(
&self.lanes[usize::from(h.lane)],
Job::One(h.clone(), Arc::clone(&msg)),
)
.await;
}
}
(chosen.len() as u64, dropped)
}
}
async fn run_lane(
lane: u8,
mut jobs: mpsc::Receiver<Job>,
index: TopicIndex,
max_pending: usize,
slow_drops: Arc<Tally>,
) {
let mut batch = Vec::with_capacity(LANE_BATCH);
let mut seen = AHashSet::new();
let drained = index.drained(lane);
let slow_drops = slow_drops.shard(usize::from(lane));
while jobs.recv_many(&mut batch, LANE_BATCH).await > 0 {
let mut served_any = false;
for job in batch.drain(..) {
let served = match job {
Job::All(msg) => index.deliver_all(lane, &msg, max_pending, slow_drops),
Job::Topic(message) => {
let served = index.deliver_topic(
lane,
&message.topic,
&message.patterns,
&message.msg,
max_pending,
slow_drops,
&mut seen,
);
if let Some(metrics) = &message.tally {
metrics.add_delivered(served.delivered);
if served.dropped > 0 {
metrics.add_dropped(served.dropped);
}
}
served
}
Job::One(h, msg) => {
let mut served = Served::default();
served.deliver(&h, &msg, max_pending, slow_drops);
served
}
};
served_any = true;
if served.lagging() {
tokio::select! {
() = drained.notified() => {}
() = tokio::time::sleep(LANE_PACE) => {}
}
served_any = false;
}
}
if served_any {
tokio::task::yield_now().await;
}
}
}
pub(crate) fn count_message(counts: &DashMap<String, AtomicU64>, topic: &str) {
match counts.get(topic) {
Some(count) => count.fetch_add(1, Ordering::Relaxed),
None => counts
.entry(topic.to_owned())
.or_default()
.fetch_add(1, Ordering::Relaxed),
};
}
pub(crate) fn unstamped(payload: &Bytes) -> Bytes {
let Ok(text) = std::str::from_utf8(payload) else {
return payload.clone();
};
let Some(rest) = text.strip_prefix("{\"tp\":") else {
return payload.clone();
};
let mut chars = rest.char_indices();
if !matches!(chars.next(), Some((_, '"'))) {
return payload.clone();
}
let mut after_topic = None;
let mut escaped = false;
for (i, c) in chars {
match (escaped, c) {
(true, _) => escaped = false,
(false, '\\') => escaped = true,
(false, '"') => {
after_topic = Some(i + 1);
break;
}
_ => {}
}
}
let Some(after_topic) = after_topic else {
return payload.clone();
};
let rest = &rest[after_topic..];
let Some(rest) = rest.strip_prefix(",\"e\":\"") else {
return payload.clone();
};
if rest.len() < 8 || !rest.as_bytes()[..8].iter().all(u8::is_ascii_hexdigit) {
return payload.clone();
}
let Some(rest) = rest[8..].strip_prefix("\",\"o\":") else {
return payload.clone();
};
let digits = rest.bytes().take_while(u8::is_ascii_digit).count();
if digits == 0 {
return payload.clone();
}
let rest = &rest[digits..];
let body = rest.strip_prefix(',').unwrap_or(rest);
let mut out = String::with_capacity(1 + body.len());
out.push('{');
out.push_str(body);
Bytes::from(out)
}
pub(crate) fn stamp_prefix(topic: &str) -> Vec<u8> {
let topic_json = serde_json::to_string(topic).unwrap_or_else(|_| "\"\"".to_string());
format!("{{\"tp\":{topic_json},\"e\":\"").into_bytes()
}
pub(crate) fn stamped_position(message: &[u8], prefix: &[u8]) -> Option<(u32, u64)> {
let rest = message.strip_prefix(prefix)?;
let hex = std::str::from_utf8(rest.get(..8)?).ok()?;
let epoch = u32::from_str_radix(hex, 16).ok()?;
let rest = rest.get(8..)?.strip_prefix(b"\",\"o\":")?;
let digits = rest.iter().take_while(|b| b.is_ascii_digit()).count();
let offset = std::str::from_utf8(&rest[..digits]).ok()?.parse().ok()?;
Some((epoch, offset))
}
pub(crate) fn stamp_recovery_fields(json: &str, topic: &str, epoch: u32, offset: u64) -> String {
let trimmed = json.trim_start();
match trimmed.strip_prefix('{') {
Some(rest) => {
let sep = if rest.trim_start().starts_with('}') {
""
} else {
","
};
let topic_json = serde_json::to_string(topic).unwrap_or_else(|_| "\"\"".to_string());
format!("{{\"tp\":{topic_json},\"e\":\"{epoch:08x}\",\"o\":{offset}{sep}{rest}")
}
None => json.to_owned(),
}
}