use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio_tungstenite::tungstenite::Utf8Bytes;
use tokio_tungstenite::tungstenite::protocol::Message;
use super::handler::Presence;
use super::{
ConnectionHandle, QueueGroup, ServerCommand, SharedState, format_presence_msg, is_pattern,
};
use crate::cluster::ClusterCommand;
use crate::presence::{TrackResult, UntrackResult};
use crate::recovery::RecoveryResult;
pub(crate) const MAX_TOPIC_LEN: usize = 256;
pub(crate) const MAX_PATTERNS_PER_CONNECTION: usize = 16;
pub(crate) const MAX_TOPICS_PER_REQUEST: usize = 1024;
pub(crate) const CLIENT_SUBSCRIPTION_LIMIT: usize = 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct TopicRecovery {
pub(crate) epoch: Option<u32>,
pub(crate) offset: u64,
pub(crate) recovered: bool,
pub(crate) recoverable: bool,
pub(crate) count: usize,
}
impl TopicRecovery {
const UNKNOWN: Self = Self {
epoch: None,
offset: 0,
recovered: false,
recoverable: false,
count: 0,
};
pub(crate) fn epoch_hex(&self) -> Option<String> {
self.epoch.map(|epoch| format!("{epoch:08x}"))
}
}
impl SharedState {
pub(crate) fn admit_topics(
&self,
conn_id: &str,
requested: Vec<String>,
queue_group: Option<&str>,
) -> Result<Vec<String>, usize> {
let mut topics: Vec<String> = match self.topics.acls.get(conn_id) {
Some(acl) => requested
.into_iter()
.filter(|t| acl.is_allowed(t))
.collect(),
None => requested,
};
let asked = topics.len();
topics.retain(|t| {
!t.is_empty() && t.len() <= MAX_TOPIC_LEN && !t.bytes().any(|b| b.is_ascii_control())
});
if topics.len() < asked {
tracing::warn!(
"[WSE] Refusing {} invalid topic name(s) (conn {conn_id})",
asked - topics.len()
);
}
let held = self.conn_topics.get(conn_id);
let mut patterns = held
.as_ref()
.map_or(0, |held| held.iter().filter(|t| is_pattern(t)).count());
let mut over = 0usize;
topics.retain(|t| {
if !is_pattern(t) || held.as_ref().is_some_and(|held| held.contains(t)) {
return true;
}
patterns += 1;
if patterns > MAX_PATTERNS_PER_CONNECTION {
over += 1;
return false;
}
true
});
if over > 0 {
tracing::warn!(
"[WSE] Refusing {over} pattern(s): {MAX_PATTERNS_PER_CONNECTION} per connection (conn {conn_id})"
);
}
let max_subs = self.max_subscriptions_per_connection;
if max_subs > 0 {
let memberships = self.conn_queue_groups.get(conn_id);
let current = held.as_ref().map_or(0, |held| held.len())
+ memberships.as_ref().map_or(0, |v| v.len());
let held_already = |t: &String| match queue_group {
None => held.as_ref().is_some_and(|held| held.contains(t)),
Some(group) => memberships
.as_ref()
.is_some_and(|v| v.iter().any(|(topic, g)| topic == t && g == group)),
};
let mut room = max_subs.saturating_sub(current);
let mut refused = false;
topics.retain(|t| {
if held_already(t) {
return true;
}
if room == 0 {
refused = true;
return false;
}
room -= 1;
true
});
if refused && topics.is_empty() {
return Err(max_subs);
}
}
drop(held);
Ok(topics)
}
pub(crate) fn subscribe_topics(
&self,
conn_id: &str,
handle: &ConnectionHandle,
topics: &[String],
queue_group: Option<&str>,
) {
let mut newly_subscribed: Vec<String> = Vec::new();
for topic in topics {
match queue_group {
Some(group_name) => {
{
let topic_groups = self.queue_groups.entry(topic.clone()).or_default();
let mut group =
topic_groups
.entry(group_name.to_owned())
.or_insert_with(|| QueueGroup {
members: Vec::new(),
next: AtomicUsize::new(0),
});
if !group.members.iter().any(|(id, _)| id == conn_id) {
group.members.push((conn_id.to_owned(), handle.clone()));
}
}
let mut memberships = self
.conn_queue_groups
.entry(conn_id.to_owned())
.or_default();
let pair = (topic.clone(), group_name.to_owned());
if !memberships.contains(&pair) {
memberships.push(pair);
newly_subscribed.push(topic.clone());
}
}
None => {
self.topics.subscribe(topic, conn_id, handle);
let is_new = self
.conn_topics
.entry(conn_id.to_owned())
.or_default()
.insert(topic.clone());
if is_new {
newly_subscribed.push(topic.clone());
}
}
}
}
self.add_local_interest(&newly_subscribed);
}
pub(crate) fn unsubscribe_topics(
&self,
conn_id: &str,
topics: Option<&[String]>,
) -> Vec<String> {
let removed: Vec<String> = match topics {
Some(topics) => {
let mut removed = Vec::new();
if let Some(held) = self.conn_topics.get(conn_id) {
for topic in topics {
if held.remove(topic).is_some() {
self.topics.unsubscribe(topic, conn_id);
removed.push(topic.clone());
}
}
}
self.conn_topics
.remove_if(conn_id, |_, held| held.is_empty());
removed
}
None => self
.conn_topics
.remove(conn_id)
.map(|(_, held)| {
held.iter()
.map(|topic| {
self.topics.unsubscribe(&topic, conn_id);
topic.clone()
})
.collect()
})
.unwrap_or_default(),
};
let mut left_groups: Vec<String> = Vec::new();
if let Some(mut memberships) = self.conn_queue_groups.get_mut(conn_id) {
memberships.retain(|(topic, group_name)| {
if topics.is_some_and(|topics| !topics.contains(topic)) {
return true;
}
if let Some(topic_groups) = self.queue_groups.get(topic) {
if let Some(mut group) = topic_groups.get_mut(group_name) {
group.members.retain(|(id, _)| id != conn_id);
}
topic_groups.remove_if(group_name, |_, g| g.members.is_empty());
}
self.queue_groups
.remove_if(topic, |_, groups| groups.is_empty());
left_groups.push(topic.clone());
false
});
}
self.conn_queue_groups
.remove_if(conn_id, |_, v| v.is_empty());
self.remove_local_interest(&left_groups);
if let Some(ref pm) = self.presence {
self.announce_untracked(pm.untrack_topics(conn_id, &removed));
}
self.remove_local_interest(&removed);
removed
}
pub(crate) fn announce_untracked(&self, results: Vec<(String, UntrackResult)>) {
for (topic, result) in results {
match result {
UntrackResult::LastLeave { user_id, data } => {
self.announce_presence_leave(topic, user_id, data, true);
}
UntrackResult::LastLocalLeave { user_id, data } => {
self.announce_presence_leave(topic, user_id, data, false);
}
UntrackResult::StillPresent | UntrackResult::NotTracked => {}
}
}
}
pub(crate) fn announce_presence_leave(
&self,
topic: String,
user_id: String,
data: serde_json::Value,
local: bool,
) {
if local {
self.tell_presence_leave(&topic, &user_id, &data);
}
let cluster_tx = self.cluster_cmd_tx.load_full();
if let Some(tx) = cluster_tx {
let _ = tx.send(ClusterCommand::PresenceUpdate {
topic,
user_id,
action: 1, data: serde_json::to_string(&data).unwrap_or_default(),
updated_at: crate::presence::epoch_ms(),
});
}
}
pub(crate) fn tell_presence(&self, event: Presence) {
if let Some(events) = &*self.presence_events.load() {
events(event);
}
}
pub(crate) fn track_presence(
&self,
conn_id: &str,
topics: &[String],
data: &serde_json::Value,
) {
let Some(pm) = &self.presence else {
return;
};
let cluster_tx = self.cluster_cmd_tx.load_full();
for topic in topics {
let TrackResult::FirstJoin {
user_id,
data: join_data,
} = pm.track(conn_id, topic, data)
else {
continue;
};
self.tell_presence(Presence::Join {
topic: topic.clone(),
user_id: user_id.clone(),
data: join_data.clone(),
});
if let Some(tx) = &*self.commands.load() {
let _ = tx.send(ServerCommand::BroadcastLocal {
topic: topic.clone(),
data: format_presence_msg("presence_join", &user_id, &join_data),
skip_recovery: true,
publish: false,
});
}
if let Some(ref ctx) = cluster_tx {
let _ = ctx.send(ClusterCommand::PresenceUpdate {
topic: topic.clone(),
user_id: user_id.clone(),
action: 0, data: serde_json::to_string(&join_data).unwrap_or_default(),
updated_at: crate::presence::epoch_ms(),
});
}
}
}
pub(crate) fn update_presence(&self, conn_id: &str, data: &serde_json::Value) -> bool {
let Some(pm) = &self.presence else {
return true;
};
let Some((user_id, topics)) = pm.update_data(conn_id, data) else {
return false;
};
if let Some(tx) = &*self.commands.load() {
let msg = format_presence_msg("presence_update", &user_id, data);
for topic in &topics {
let _ = tx.send(ServerCommand::BroadcastLocal {
topic: topic.clone(),
data: msg.clone(),
skip_recovery: true,
publish: false,
});
}
}
if let Some(ctx) = self.cluster_cmd_tx.load_full() {
let data = serde_json::to_string(data).unwrap_or_default();
let now = crate::presence::epoch_ms();
for topic in topics {
let _ = ctx.send(ClusterCommand::PresenceUpdate {
topic,
user_id: user_id.clone(),
action: 2, data: data.clone(),
updated_at: now,
});
}
}
true
}
pub(crate) fn tell_presence_leave(&self, topic: &str, user_id: &str, data: &serde_json::Value) {
self.tell_presence(Presence::Leave {
topic: topic.to_owned(),
user_id: user_id.to_owned(),
data: data.clone(),
});
if let Some(tx) = &*self.commands.load() {
let _ = tx.send(ServerCommand::BroadcastLocal {
topic: topic.to_owned(),
data: format_presence_msg("presence_leave", user_id, data),
skip_recovery: true,
publish: false,
});
}
}
pub(crate) fn topic_head(&self, topic: &str) -> Option<(u32, u64)> {
self.recovery.as_ref().and_then(|r| r.get_position(topic))
}
pub(crate) fn recover_topic(
&self,
handle: &ConnectionHandle,
topic: &str,
anchor: Option<(u32, u64)>,
head_before: Option<(u32, u64)>,
) -> TopicRecovery {
let Some(ref recovery) = self.recovery else {
return TopicRecovery::UNKNOWN;
};
let not_recovered = match head_before {
Some((epoch, head)) if head > 0 => TopicRecovery {
epoch: Some(epoch),
offset: head - 1,
recovered: false,
recoverable: true,
count: 0,
},
_ => TopicRecovery::UNKNOWN,
};
let Some((epoch, after)) = anchor else {
return not_recovered;
};
match recovery.recover(topic, epoch, after) {
RecoveryResult::Recovered {
publications,
epoch,
offset,
} => {
let total = publications.len();
let mut queued = 0;
for payload in publications {
let Ok(text) = Utf8Bytes::try_from(payload) else {
break;
};
if !handle.send_one(
Message::Text(text),
self.max_outbound_queue_bytes,
self.slow_consumer_drops.shard(usize::from(handle.lane)),
) {
break;
}
queued += 1;
}
TopicRecovery {
epoch: Some(epoch),
offset: if queued == total {
offset
} else {
after + queued as u64
},
recovered: queued == total,
recoverable: true,
count: queued,
}
}
RecoveryResult::NotRecovered { epoch, offset } => {
tracing::debug!(
"[WSE] {topic}: not recovered from {after} (epoch now {epoch:08x}, head {offset})"
);
not_recovered
}
RecoveryResult::NoHistory => not_recovered,
}
}
pub(crate) fn subscribe_and_recover(
&self,
conn_id: &str,
handle: &ConnectionHandle,
requested: Vec<String>,
anchors: &HashMap<String, (u32, u64)>,
) -> Result<(Vec<String>, HashMap<String, TopicRecovery>), usize> {
let accepted = self.admit_topics(conn_id, requested, None)?;
self.subscribe_topics(conn_id, handle, &accepted, None);
let heads: Vec<Option<(u32, u64)>> = accepted.iter().map(|t| self.topic_head(t)).collect();
let recovered = accepted
.iter()
.zip(heads)
.map(|(topic, head)| {
let anchor = anchors.get(topic).copied();
(
topic.clone(),
self.recover_topic(handle, topic, anchor, head),
)
})
.collect();
Ok((accepted, recovered))
}
}
pub(crate) fn requested_compression(
compression: Option<&serde_json::Value>,
threshold: Option<&serde_json::Value>,
) -> Option<usize> {
match compression.and_then(serde_json::Value::as_bool) {
Some(false) => Some(0),
Some(true) => Some(
threshold
.and_then(serde_json::Value::as_u64)
.map_or(1024, |t| usize::try_from(t).unwrap_or(usize::MAX)),
),
None => None,
}
}
pub(crate) fn parse_anchor(position: &serde_json::Value) -> Option<(u32, u64)> {
let epoch = u32::from_str_radix(position.get("epoch")?.as_str()?, 16).ok()?;
let offset = position.get("offset")?.as_u64()?;
Some((epoch, offset))
}
#[cold]
#[inline(never)]
pub(crate) fn answer_subscription_request(
state: &SharedState,
conn_id: &str,
handle: &ConnectionHandle,
p: &serde_json::Value,
) {
let topics: Vec<String> = p
.get("topics")
.and_then(serde_json::Value::as_array)
.map(|topics| {
topics
.iter()
.filter_map(|t| t.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default();
match p.get("action").and_then(serde_json::Value::as_str) {
Some("subscribe") => {}
Some("unsubscribe") => {
state.unsubscribe_topics(conn_id, Some(&topics));
return;
}
_ => return,
}
let recover = p.get("recover").and_then(serde_json::Value::as_bool) == Some(true);
let anchors: HashMap<String, (u32, u64)> = if recover {
p.get("recovery")
.and_then(serde_json::Value::as_object)
.map(|positions| {
positions
.iter()
.filter_map(|(topic, position)| Some((topic.clone(), parse_anchor(position)?)))
.collect()
})
.unwrap_or_default()
} else {
HashMap::new()
};
let mut asked: Vec<String> = Vec::with_capacity(topics.len().min(MAX_TOPICS_PER_REQUEST));
let mut seen: HashSet<&str> = HashSet::with_capacity(asked.capacity());
for topic in &topics {
if asked.len() == MAX_TOPICS_PER_REQUEST {
break;
}
if seen.insert(topic) {
asked.push(topic.clone());
}
}
if state.max_subscriptions_per_connection == 0 {
let held = state.conn_topics.get(conn_id);
let mut room =
CLIENT_SUBSCRIPTION_LIMIT.saturating_sub(held.as_ref().map_or(0, |held| held.len()));
asked.retain(|t| {
if held.as_ref().is_some_and(|held| held.contains(t)) {
return true;
}
if room == 0 {
return false;
}
room -= 1;
true
});
}
let (accepted, recovered) = if handle.out.admitted.load(Ordering::Acquire) && !asked.is_empty()
{
state
.subscribe_and_recover(conn_id, handle, asked, &anchors)
.unwrap_or_default()
} else {
Default::default()
};
let taken: HashSet<&str> = accepted.iter().map(String::as_str).collect();
let failed: Vec<&String> = topics
.iter()
.filter(|t| !taken.contains(t.as_str()))
.collect();
let recovery: serde_json::Map<String, serde_json::Value> = recovered
.iter()
.map(|(topic, r)| {
(
topic.clone(),
serde_json::json!({
"epoch": r.epoch_hex(),
"offset": r.offset,
"recovered": r.recovered,
"count": r.count,
}),
)
})
.collect();
let reply = serde_json::json!({
"c": "WSE",
"t": "subscription_update",
"id": uuid::Uuid::now_v7().to_string(),
"p": {
"success": failed.is_empty() || !accepted.is_empty(),
"success_topics": accepted,
"failed_topics": failed,
"recovery": recovery,
},
"v": 1,
});
handle.send_one(
Message::Text(reply.to_string().into()),
state.max_outbound_queue_bytes,
state.slow_consumer_drops.shard(usize::from(handle.lane)),
);
}