use std::any::TypeId;
use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicUsize, Ordering};
use parking_lot::RwLock;
use std::sync::Arc;
use tokio::sync::mpsc;
use tracing::{trace, warn};
use super::types::IpcPushNotification;
pub type ConnectionId = usize;
pub type PushSender = mpsc::Sender<IpcPushNotification>;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SubscriptionPattern(String);
impl SubscriptionPattern {
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn matches(&self, name: &str) -> bool {
name.starts_with(&self.0[..self.0.len() - 1])
}
}
impl std::fmt::Display for SubscriptionPattern {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl TryFrom<String> for SubscriptionPattern {
type Error = PatternSubscriptionError;
fn try_from(value: String) -> Result<Self, Self::Error> {
if value.len() > 256 {
return Err(PatternSubscriptionError::PatternTooLong);
}
let Some(prefix) = value.strip_suffix('*') else {
return Err(PatternSubscriptionError::InvalidPattern);
};
if prefix.contains('*') {
return Err(PatternSubscriptionError::InvalidPattern);
}
Ok(Self(value))
}
}
impl std::str::FromStr for SubscriptionPattern {
type Err = PatternSubscriptionError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
Self::try_from(value.to_owned())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum PatternSubscriptionError {
InvalidPattern,
PatternTooLong,
TooManyPatterns,
UnknownConnection,
}
impl std::fmt::Display for PatternSubscriptionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::InvalidPattern => "pattern must contain exactly one terminal '*'",
Self::PatternTooLong => "pattern exceeds 256 UTF-8 bytes",
Self::TooManyPatterns => "pattern limit of 128 exceeded",
Self::UnknownConnection => "connection is not registered",
})
}
}
impl std::error::Error for PatternSubscriptionError {}
fn validate_patterns(
values: &[String],
) -> Result<HashSet<SubscriptionPattern>, PatternSubscriptionError> {
if values.len() > 128 {
return Err(PatternSubscriptionError::TooManyPatterns);
}
values.iter().map(|value| value.parse()).collect()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PeerCredentials {
pid: Option<u32>,
uid: u32,
gid: u32,
}
impl PeerCredentials {
pub(crate) fn from_raw(pid: Option<i32>, uid: u32, gid: u32) -> Self {
Self {
pid: pid.and_then(|pid| u32::try_from(pid).ok()),
uid,
gid,
}
}
#[must_use]
pub const fn pid(self) -> Option<u32> {
self.pid
}
#[must_use]
pub const fn uid(self) -> u32 {
self.uid
}
#[must_use]
pub const fn gid(self) -> u32 {
self.gid
}
}
impl std::fmt::Display for PeerCredentials {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self.pid {
Some(pid) => write!(f, "pid={pid} uid={} gid={}", self.uid, self.gid),
None => write!(f, "pid=unknown uid={} gid={}", self.uid, self.gid),
}
}
}
#[derive(Debug, Default)]
pub struct SubscriptionStats {
pub subscriptions_added: AtomicUsize,
pub subscriptions_removed: AtomicUsize,
pub push_notifications_sent: AtomicUsize,
pub push_notifications_dropped: AtomicUsize,
}
impl SubscriptionStats {
#[must_use]
pub fn subscriptions_added(&self) -> usize {
self.subscriptions_added.load(Ordering::Relaxed)
}
#[must_use]
pub fn subscriptions_removed(&self) -> usize {
self.subscriptions_removed.load(Ordering::Relaxed)
}
#[must_use]
pub fn push_notifications_sent(&self) -> usize {
self.push_notifications_sent.load(Ordering::Relaxed)
}
#[must_use]
pub fn push_notifications_dropped(&self) -> usize {
self.push_notifications_dropped.load(Ordering::Relaxed)
}
}
struct ConnectionInfo {
push_sender: PushSender,
subscribed_types: HashSet<String>,
subscribed_patterns: HashSet<SubscriptionPattern>,
peer: Option<PeerCredentials>,
}
pub struct SubscriptionManager {
state: RwLock<SubscriptionState>,
routes: RwLock<HashMap<String, Arc<[ConnectionId]>>>,
type_id_to_name: RwLock<HashMap<TypeId, String>>,
stats: SubscriptionStats,
}
#[derive(Default)]
struct SubscriptionState {
connections: HashMap<ConnectionId, ConnectionInfo>,
exact: HashMap<String, HashSet<ConnectionId>>,
patterns: HashMap<SubscriptionPattern, HashSet<ConnectionId>>,
}
fn remove_index<K: Eq + std::hash::Hash>(
index: &mut HashMap<K, HashSet<ConnectionId>>,
key: &K,
id: ConnectionId,
) {
if let Some(ids) = index.get_mut(key) {
ids.remove(&id);
if ids.is_empty() {
index.remove(key);
}
}
}
impl SubscriptionState {
fn remove_connection(&mut self, id: ConnectionId) -> usize {
let Some(info) = self.connections.remove(&id) else {
return 0;
};
for name in &info.subscribed_types {
remove_index(&mut self.exact, name, id);
}
for pattern in &info.subscribed_patterns {
remove_index(&mut self.patterns, pattern, id);
}
info.subscribed_types.len() + info.subscribed_patterns.len()
}
}
impl Default for SubscriptionManager {
fn default() -> Self {
Self::new()
}
}
impl std::fmt::Debug for SubscriptionManager {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let state = self.state.read();
f.debug_struct("SubscriptionManager")
.field("connection_count", &state.connections.len())
.field("subscribed_types_count", &state.exact.len())
.field("subscribed_patterns_count", &state.patterns.len())
.field("cached_routes", &self.routes.read().len())
.field("type_id_mappings", &self.type_id_to_name.read().len())
.field("stats", &self.stats)
.finish()
}
}
impl SubscriptionManager {
#[must_use]
pub fn new() -> Self {
Self {
state: RwLock::new(SubscriptionState::default()),
routes: RwLock::new(HashMap::new()),
type_id_to_name: RwLock::new(HashMap::new()),
stats: SubscriptionStats::default(),
}
}
#[must_use]
pub const fn stats(&self) -> &SubscriptionStats {
&self.stats
}
pub fn register_connection(
&self,
conn_id: ConnectionId,
push_sender: PushSender,
peer: Option<PeerCredentials>,
) {
let mut state = self.state.write();
let removed = state.remove_connection(conn_id);
self.stats
.subscriptions_removed
.fetch_add(removed, Ordering::Relaxed);
state.connections.insert(
conn_id,
ConnectionInfo {
push_sender,
peer,
subscribed_types: HashSet::new(),
subscribed_patterns: HashSet::new(),
},
);
self.routes.write().clear();
drop(state);
}
#[must_use]
pub fn peer_credentials(&self, conn_id: ConnectionId) -> Option<PeerCredentials> {
self.state
.read()
.connections
.get(&conn_id)
.and_then(|info| info.peer)
}
#[must_use]
pub fn peer_pid(&self, conn_id: ConnectionId) -> Option<u32> {
self.peer_credentials(conn_id)
.and_then(PeerCredentials::pid)
}
pub fn unregister_connection(&self, conn_id: ConnectionId) {
let mut state = self.state.write();
let removed = state.remove_connection(conn_id);
self.stats
.subscriptions_removed
.fetch_add(removed, Ordering::Relaxed);
self.routes.write().clear();
drop(state);
}
pub fn subscribe(&self, conn_id: ConnectionId, message_types: &[String]) -> Vec<String> {
let mut state = self.state.write();
let SubscriptionState {
connections, exact, ..
} = &mut *state;
let Some(info) = connections.get_mut(&conn_id) else {
return Vec::new();
};
for name in message_types {
if info.subscribed_types.insert(name.clone()) {
exact.entry(name.clone()).or_default().insert(conn_id);
self.stats
.subscriptions_added
.fetch_add(1, Ordering::Relaxed);
}
}
self.routes.write().clear();
let subscriptions = info.subscribed_types.iter().cloned().collect();
drop(state);
subscriptions
}
pub fn unsubscribe(&self, conn_id: ConnectionId, message_types: &[String]) -> Vec<String> {
let mut state = self.state.write();
let SubscriptionState {
connections,
exact,
patterns,
} = &mut *state;
let Some(info) = connections.get_mut(&conn_id) else {
return Vec::new();
};
let names = if message_types.is_empty() {
for pattern in info.subscribed_patterns.drain() {
remove_index(patterns, &pattern, conn_id);
self.stats
.subscriptions_removed
.fetch_add(1, Ordering::Relaxed);
}
info.subscribed_types.iter().cloned().collect::<Vec<_>>()
} else {
message_types.to_vec()
};
for name in names {
if info.subscribed_types.remove(&name) {
remove_index(exact, &name, conn_id);
self.stats
.subscriptions_removed
.fetch_add(1, Ordering::Relaxed);
}
}
self.routes.write().clear();
let subscriptions = info.subscribed_types.iter().cloned().collect();
drop(state);
subscriptions
}
pub fn subscribe_patterns(
&self,
conn_id: ConnectionId,
values: &[String],
) -> Result<Vec<String>, PatternSubscriptionError> {
let validated = validate_patterns(values)?;
let mut state = self.state.write();
let SubscriptionState {
connections,
patterns,
..
} = &mut *state;
let info = connections
.get_mut(&conn_id)
.ok_or(PatternSubscriptionError::UnknownConnection)?;
if info.subscribed_patterns.union(&validated).count() > 128 {
return Err(PatternSubscriptionError::TooManyPatterns);
}
for pattern in validated {
if info.subscribed_patterns.insert(pattern.clone()) {
patterns.entry(pattern).or_default().insert(conn_id);
self.stats
.subscriptions_added
.fetch_add(1, Ordering::Relaxed);
}
}
self.routes.write().clear();
let subscriptions = sorted_patterns(&info.subscribed_patterns);
drop(state);
Ok(subscriptions)
}
pub fn unsubscribe_patterns(
&self,
conn_id: ConnectionId,
values: &[String],
) -> Result<Vec<String>, PatternSubscriptionError> {
let validated = validate_patterns(values)?;
let mut state = self.state.write();
let SubscriptionState {
connections,
patterns,
..
} = &mut *state;
let info = connections
.get_mut(&conn_id)
.ok_or(PatternSubscriptionError::UnknownConnection)?;
let selected = if values.is_empty() {
info.subscribed_patterns.clone()
} else {
validated
};
for pattern in selected {
if info.subscribed_patterns.remove(&pattern) {
remove_index(patterns, &pattern, conn_id);
self.stats
.subscriptions_removed
.fetch_add(1, Ordering::Relaxed);
}
}
self.routes.write().clear();
let subscriptions = sorted_patterns(&info.subscribed_patterns);
drop(state);
Ok(subscriptions)
}
#[must_use]
pub fn get_subscriptions(&self, conn_id: ConnectionId) -> Vec<String> {
self.state
.read()
.connections
.get(&conn_id)
.map(|info| info.subscribed_types.iter().cloned().collect())
.unwrap_or_default()
}
#[must_use]
pub fn get_pattern_subscriptions(&self, conn_id: ConnectionId) -> Vec<String> {
self.state
.read()
.connections
.get(&conn_id)
.map(|info| sorted_patterns(&info.subscribed_patterns))
.unwrap_or_default()
}
#[must_use]
pub fn has_subscriptions(&self, conn_id: ConnectionId) -> bool {
self.state
.read()
.connections
.get(&conn_id)
.is_some_and(|info| {
!info.subscribed_types.is_empty() || !info.subscribed_patterns.is_empty()
})
}
pub fn register_type_mapping(&self, type_id: TypeId, type_name: String) {
self.type_id_to_name.write().insert(type_id, type_name);
}
#[must_use]
pub fn get_type_name(&self, type_id: &TypeId) -> Option<String> {
self.type_id_to_name.read().get(type_id).cloned()
}
fn recipients(&self, state: &SubscriptionState, name: &str) -> Arc<[ConnectionId]> {
if let Some(ids) = self.routes.read().get(name) {
return Arc::clone(ids);
}
let mut ids = state.exact.get(name).cloned().unwrap_or_default();
for (pattern, subscribers) in &state.patterns {
if pattern.matches(name) {
ids.extend(subscribers);
}
}
let ids: Arc<[ConnectionId]> = ids.into_iter().collect();
if name.len() <= 256 {
let mut routes = self.routes.write();
if routes.len() >= 1024 && !routes.contains_key(name) {
if let Some(evicted) = routes.keys().next().cloned() {
routes.remove(&evicted);
}
}
routes.insert(name.to_owned(), Arc::clone(&ids));
}
ids
}
pub fn forward_to_subscribers(&self, notification: &IpcPushNotification) {
let state = self.state.read();
let ids = self.recipients(&state, ¬ification.message_type);
for conn_id in ids.iter() {
if let Some(info) = state.connections.get(conn_id) {
match info.push_sender.try_send(notification.clone()) {
Ok(()) => {
self.stats
.push_notifications_sent
.fetch_add(1, Ordering::Relaxed);
}
Err(mpsc::error::TrySendError::Full(_)) => {
self.stats
.push_notifications_dropped
.fetch_add(1, Ordering::Relaxed);
warn!(conn_id, message_type = %notification.message_type, "Push channel full, dropping notification");
}
Err(mpsc::error::TrySendError::Closed(_)) => {
self.stats
.push_notifications_dropped
.fetch_add(1, Ordering::Relaxed);
trace!(conn_id, "Push channel closed");
}
}
}
}
}
#[must_use]
pub fn connection_count(&self) -> usize {
self.state.read().connections.len()
}
#[must_use]
pub fn subscribed_types_count(&self) -> usize {
self.state.read().exact.len()
}
#[must_use]
pub fn subscribed_patterns_count(&self) -> usize {
self.state.read().patterns.len()
}
#[must_use]
pub fn total_subscriptions(&self) -> usize {
let state = self.state.read();
state.exact.values().map(HashSet::len).sum::<usize>()
+ state.patterns.values().map(HashSet::len).sum::<usize>()
}
}
fn sorted_patterns(patterns: &HashSet<SubscriptionPattern>) -> Vec<String> {
let mut values: Vec<_> = patterns.iter().map(ToString::to_string).collect();
values.sort();
values
}
pub struct PushReceiver {
#[allow(dead_code)]
pub conn_id: ConnectionId,
pub receiver: mpsc::Receiver<IpcPushNotification>,
}
#[must_use]
pub fn create_push_channel(
conn_id: ConnectionId,
buffer_size: usize,
) -> (PushSender, PushReceiver) {
let (sender, receiver) = mpsc::channel(buffer_size);
(sender, PushReceiver { conn_id, receiver })
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
#[test]
fn test_subscription_manager_new() {
let manager = SubscriptionManager::new();
assert_eq!(manager.connection_count(), 0);
assert_eq!(manager.subscribed_types_count(), 0);
}
#[test]
fn test_register_unregister_connection() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
assert_eq!(manager.connection_count(), 1);
manager.unregister_connection(1);
assert_eq!(manager.connection_count(), 0);
}
#[test]
fn a_reported_pid_is_carried_through() {
let creds = PeerCredentials::from_raw(Some(4321), 1000, 1000);
assert_eq!(creds.pid(), Some(4321));
assert_eq!(creds.uid(), 1000);
assert_eq!(creds.gid(), 1000);
}
#[test]
fn a_negative_pid_is_treated_as_unreported() {
let creds = PeerCredentials::from_raw(Some(-1), 1000, 1000);
assert_eq!(creds.pid(), None);
assert_eq!(creds.uid(), 1000, "uid survives an unusable pid");
}
#[test]
fn an_absent_pid_stays_absent() {
assert_eq!(PeerCredentials::from_raw(None, 0, 0).pid(), None);
}
#[test]
fn root_credentials_are_representable() {
let creds = PeerCredentials::from_raw(Some(1), 0, 0);
assert_eq!(creds.pid(), Some(1));
assert_eq!(creds.uid(), 0);
assert_eq!(creds.gid(), 0);
}
#[test]
fn credentials_render_for_logs() {
assert_eq!(
PeerCredentials::from_raw(Some(7), 1000, 20).to_string(),
"pid=7 uid=1000 gid=20"
);
assert_eq!(
PeerCredentials::from_raw(None, 1000, 20).to_string(),
"pid=unknown uid=1000 gid=20"
);
}
#[test]
fn a_registered_connection_reports_its_peer() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
let creds = PeerCredentials::from_raw(Some(4321), 1000, 1000);
manager.register_connection(1, sender, Some(creds));
assert_eq!(manager.peer_credentials(1), Some(creds));
assert_eq!(manager.peer_pid(1), Some(4321));
}
#[test]
fn a_connection_registered_without_credentials_reports_none() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
assert_eq!(manager.peer_credentials(1), None);
assert_eq!(manager.peer_pid(1), None);
}
#[test]
fn an_unknown_connection_has_no_peer() {
let manager = SubscriptionManager::new();
assert_eq!(manager.peer_credentials(99), None);
assert_eq!(manager.peer_pid(99), None);
}
#[test]
fn credentials_survive_subscription_changes_and_end_with_the_connection() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
let creds = PeerCredentials::from_raw(Some(4321), 1000, 1000);
manager.register_connection(1, sender, Some(creds));
manager.subscribe(1, &["TypeA".to_string()]);
assert_eq!(manager.peer_credentials(1), Some(creds));
manager.unsubscribe(1, &["TypeA".to_string()]);
assert_eq!(manager.peer_credentials(1), Some(creds));
manager.unregister_connection(1);
assert_eq!(manager.peer_credentials(1), None);
}
#[test]
fn each_connection_keeps_its_own_peer() {
let manager = SubscriptionManager::new();
let (sender1, _r1) = mpsc::channel(10);
let (sender2, _r2) = mpsc::channel(10);
manager.register_connection(1, sender1, Some(PeerCredentials::from_raw(Some(11), 1, 1)));
manager.register_connection(2, sender2, Some(PeerCredentials::from_raw(Some(22), 2, 2)));
assert_eq!(manager.peer_pid(1), Some(11));
assert_eq!(manager.peer_pid(2), Some(22));
}
#[test]
fn test_subscribe_unsubscribe() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
let subscribed = manager.subscribe(1, &["TypeA".to_string(), "TypeB".to_string()]);
assert_eq!(subscribed.len(), 2);
assert!(subscribed.contains(&"TypeA".to_string()));
assert!(subscribed.contains(&"TypeB".to_string()));
assert_eq!(manager.subscribed_types_count(), 2);
assert_eq!(manager.total_subscriptions(), 2);
let subscribed = manager.unsubscribe(1, &["TypeA".to_string()]);
assert_eq!(subscribed.len(), 1);
assert!(subscribed.contains(&"TypeB".to_string()));
assert_eq!(manager.subscribed_types_count(), 1);
assert_eq!(manager.total_subscriptions(), 1);
let subscribed = manager.unsubscribe(1, &[]);
assert!(subscribed.is_empty());
assert_eq!(manager.subscribed_types_count(), 0);
}
#[test]
fn test_unregister_cleans_subscriptions() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe(1, &["TypeA".to_string(), "TypeB".to_string()]);
assert_eq!(manager.subscribed_types_count(), 2);
manager.unregister_connection(1);
assert_eq!(manager.subscribed_types_count(), 0);
}
#[test]
fn test_multiple_connections_same_type() {
let manager = SubscriptionManager::new();
let (sender1, _receiver1) = mpsc::channel(10);
let (sender2, _receiver2) = mpsc::channel(10);
manager.register_connection(1, sender1, None);
manager.register_connection(2, sender2, None);
manager.subscribe(1, &["TypeA".to_string()]);
manager.subscribe(2, &["TypeA".to_string()]);
assert_eq!(manager.subscribed_types_count(), 1);
assert_eq!(manager.total_subscriptions(), 2);
manager.unregister_connection(1);
assert_eq!(manager.subscribed_types_count(), 1);
assert_eq!(manager.total_subscriptions(), 1);
manager.unregister_connection(2);
assert_eq!(manager.subscribed_types_count(), 0);
}
#[tokio::test]
async fn test_forward_to_subscribers() {
let manager = Arc::new(SubscriptionManager::new());
let (sender, mut receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe(1, &["PriceUpdate".to_string()]);
let notification = IpcPushNotification::new(
"PriceUpdate",
Some("price_service".to_string()),
serde_json::json!({ "price": 100.0 }),
);
manager.forward_to_subscribers(¬ification);
let notification_out = receiver.try_recv().unwrap();
assert_eq!(notification_out.message_type, "PriceUpdate");
assert_eq!(manager.stats().push_notifications_sent(), 1);
}
#[test]
fn test_forward_no_subscribers() {
let manager = Arc::new(SubscriptionManager::new());
let notification =
IpcPushNotification::new("UnsubscribedType", None, serde_json::json!({}));
manager.forward_to_subscribers(¬ification);
assert_eq!(manager.stats().push_notifications_sent(), 0);
}
#[test]
fn test_type_mapping() {
struct TestMessage;
let manager = SubscriptionManager::new();
let type_id = TypeId::of::<TestMessage>();
manager.register_type_mapping(type_id, "TestMessage".to_string());
assert_eq!(
manager.get_type_name(&type_id),
Some("TestMessage".to_string())
);
}
#[tokio::test]
async fn test_create_push_channel() {
let conn_id = 42;
let buffer_size = 10;
let (sender, receiver) = create_push_channel(conn_id, buffer_size);
assert_eq!(receiver.conn_id, conn_id);
let notification = IpcPushNotification::new(
"TestMessage",
Some("test_actor".to_string()),
serde_json::json!({ "test": true }),
);
sender.send(notification.clone()).await.unwrap();
let mut channel = receiver.receiver;
let msg = channel.recv().await.unwrap();
assert_eq!(msg.message_type, "TestMessage");
}
#[test]
fn test_push_receiver_struct() {
let (_, receiver) = create_push_channel(123, 5);
assert_eq!(receiver.conn_id, 123);
}
fn notification(name: &str) -> IpcPushNotification {
IpcPushNotification::new(name, None, serde_json::json!({}))
}
#[test]
fn active_subscriptions_are_scoped_to_each_connection() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
let (sender, _other_receiver) = mpsc::channel(10);
manager.register_connection(2, sender, None);
manager.subscribe_patterns(1, &["*".into()]).unwrap();
assert!(manager.has_subscriptions(1));
assert!(!manager.has_subscriptions(2));
assert!(!manager.has_subscriptions(99));
manager.subscribe(2, &["Exact".into()]);
assert!(manager.has_subscriptions(2));
manager.unsubscribe_patterns(1, &[]).unwrap();
assert!(!manager.has_subscriptions(1));
assert!(manager.has_subscriptions(2));
}
#[test]
fn patterns_validate_literal_prefixes_and_utf8_limits() {
for invalid in ["", "Order", "*Order", "Order**", "Or*der*"] {
assert_eq!(
invalid.parse::<SubscriptionPattern>(),
Err(PatternSubscriptionError::InvalidPattern)
);
}
let pattern: SubscriptionPattern = "注文::*".parse().unwrap();
assert!(pattern.matches("注文::Created"));
assert!(pattern.matches("注文::"));
assert!(!pattern.matches("注文Created"));
assert!("*".parse::<SubscriptionPattern>().unwrap().matches(""));
assert!(!"Order*"
.parse::<SubscriptionPattern>()
.unwrap()
.matches("orderCreated"));
assert!("[?]*"
.parse::<SubscriptionPattern>()
.unwrap()
.matches("[?]Created"));
assert!(format!("{}*", "a".repeat(255))
.parse::<SubscriptionPattern>()
.is_ok());
assert_eq!(
format!("{}*", "é".repeat(128)).parse::<SubscriptionPattern>(),
Err(PatternSubscriptionError::PatternTooLong)
);
}
#[test]
fn overlapping_selectors_deliver_once_and_reuse_cached_routes() {
let manager = SubscriptionManager::new();
let (sender, mut receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe(1, &["OrderCreated".into()]);
assert_eq!(
manager
.subscribe_patterns(1, &["Order*".into(), "*".into(), "Order*".into()])
.unwrap(),
vec!["*", "Order*"]
);
let event = notification("OrderCreated");
manager.forward_to_subscribers(&event);
let cached = Arc::clone(manager.routes.read().get("OrderCreated").unwrap());
manager.forward_to_subscribers(&event);
assert!(Arc::ptr_eq(
&cached,
manager.routes.read().get("OrderCreated").unwrap()
));
assert!(receiver.try_recv().is_ok());
assert!(receiver.try_recv().is_ok());
assert!(receiver.try_recv().is_err());
assert_eq!(manager.total_subscriptions(), 3);
assert_eq!(manager.subscribed_types_count(), 1);
assert_eq!(manager.subscribed_patterns_count(), 2);
assert_eq!(manager.stats().subscriptions_added(), 3);
}
#[test]
fn failed_batches_do_not_change_subscriptions_or_cache() {
let manager = SubscriptionManager::new();
let (sender, _receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe_patterns(1, &["Keep*".into()]).unwrap();
manager.forward_to_subscribers(¬ification("KeepAlive"));
let cached = Arc::clone(manager.routes.read().get("KeepAlive").unwrap());
for values in [
vec!["Valid*".into(), "invalid".into()],
vec!["*".into(); 129],
] {
assert!(manager.subscribe_patterns(1, &values).is_err());
assert!(manager.unsubscribe_patterns(1, &values).is_err());
}
assert_eq!(manager.get_pattern_subscriptions(1), vec!["Keep*"]);
assert!(Arc::ptr_eq(
&cached,
manager.routes.read().get("KeepAlive").unwrap()
));
let full: Vec<_> = (0..127).map(|i| format!("{i}*")).collect();
manager.subscribe_patterns(1, &full).unwrap();
assert_eq!(
manager.subscribe_patterns(1, &["Extra*".into()]),
Err(PatternSubscriptionError::TooManyPatterns)
);
assert_eq!(manager.get_pattern_subscriptions(1).len(), 128);
assert_eq!(
manager.subscribe_patterns(9, &["*".into()]),
Err(PatternSubscriptionError::UnknownConnection)
);
}
#[test]
fn negative_routes_invalidate_and_patterns_match_future_names() {
let manager = SubscriptionManager::new();
let (sender, mut receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.forward_to_subscribers(¬ification("OrderCreated"));
assert!(manager
.routes
.read()
.get("OrderCreated")
.unwrap()
.is_empty());
manager.subscribe_patterns(1, &["Order*".into()]).unwrap();
assert!(manager.routes.read().is_empty());
manager.forward_to_subscribers(¬ification("OrderCreated"));
manager.forward_to_subscribers(¬ification("OrderFuture"));
assert_eq!(receiver.try_recv().unwrap().message_type, "OrderCreated");
assert_eq!(receiver.try_recv().unwrap().message_type, "OrderFuture");
manager.unsubscribe_patterns(1, &["Order*".into()]).unwrap();
manager.forward_to_subscribers(¬ification("OrderCreated"));
assert!(receiver.try_recv().is_err());
manager.subscribe(1, &["OrderCreated".into()]);
manager.forward_to_subscribers(¬ification("OrderCreated"));
assert!(receiver.try_recv().is_ok());
}
#[test]
fn unsubscribe_semantics_preserve_other_selectors() {
let manager = SubscriptionManager::new();
let (sender, mut receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe(1, &["OrderCreated".into(), "Literal*".into()]);
manager.subscribe_patterns(1, &["Order*".into()]).unwrap();
manager.unsubscribe(1, &["OrderCreated".into()]);
manager.forward_to_subscribers(¬ification("OrderCreated"));
assert!(receiver.try_recv().is_ok());
manager.unsubscribe_patterns(1, &[]).unwrap();
manager.forward_to_subscribers(¬ification("LiteralOther"));
assert!(receiver.try_recv().is_err());
manager.forward_to_subscribers(¬ification("Literal*"));
assert!(receiver.try_recv().is_ok());
manager.subscribe_patterns(1, &["*".into()]).unwrap();
manager.unsubscribe(1, &[]);
assert!(!manager.has_subscriptions(1));
assert_eq!(manager.total_subscriptions(), 0);
assert_eq!(
manager.stats().subscriptions_added(),
manager.stats().subscriptions_removed()
);
}
#[test]
fn replacement_and_disconnect_remove_indices_and_cached_recipients() {
let manager = SubscriptionManager::new();
let (sender, mut old_receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.subscribe(1, &["OrderCreated".into()]);
manager.subscribe_patterns(1, &["*".into()]).unwrap();
manager.forward_to_subscribers(¬ification("OrderCreated"));
old_receiver.try_recv().unwrap();
let (sender, mut receiver) = mpsc::channel(10);
manager.register_connection(1, sender, None);
manager.forward_to_subscribers(¬ification("OrderCreated"));
assert!(receiver.try_recv().is_err());
assert!(!manager.has_subscriptions(1));
assert_eq!(manager.stats().subscriptions_removed(), 2);
manager.subscribe_patterns(1, &["*".into()]).unwrap();
manager.forward_to_subscribers(¬ification("OrderCreated"));
receiver.try_recv().unwrap();
manager.unregister_connection(1);
assert!(manager.routes.read().is_empty());
assert!(!manager.has_subscriptions(1));
assert_eq!(manager.stats().subscriptions_removed(), 3);
}
#[test]
fn route_cache_is_bounded_and_long_names_still_deliver() {
let manager = SubscriptionManager::new();
let (sender, mut receiver) = mpsc::channel(1);
manager.register_connection(1, sender, None);
manager.subscribe_patterns(1, &["*".into()]).unwrap();
for i in 0..1025 {
manager.forward_to_subscribers(¬ification(&format!("Event{i}")));
receiver.try_recv().unwrap();
assert!(manager.routes.read().len() <= 1024);
}
assert_eq!(manager.routes.read().len(), 1024);
let long_name = "a".repeat(257);
manager.forward_to_subscribers(¬ification(&long_name));
assert_eq!(receiver.try_recv().unwrap().message_type, long_name);
assert!(!manager.routes.read().contains_key(&long_name));
}
#[test]
fn overlapping_patterns_count_drops_once_per_recipient() {
let manager = SubscriptionManager::new();
let (sender, receiver) = mpsc::channel(1);
manager.register_connection(1, sender, None);
manager
.subscribe_patterns(1, &["*".into(), "Order*".into()])
.unwrap();
let event = notification("OrderCreated");
manager.forward_to_subscribers(&event);
manager.forward_to_subscribers(&event);
assert_eq!(manager.stats().push_notifications_sent(), 1);
assert_eq!(manager.stats().push_notifications_dropped(), 1);
drop(receiver);
manager.forward_to_subscribers(&event);
assert_eq!(manager.stats().push_notifications_dropped(), 2);
}
#[test]
fn concurrent_mutations_leave_no_stale_routes() {
let manager = SubscriptionManager::new();
let (sender, mut receiver) = mpsc::channel(1024);
manager.register_connection(1, sender, None);
std::thread::scope(|scope| {
scope.spawn(|| {
for _ in 0..128 {
manager.subscribe_patterns(1, &["*".into()]).unwrap();
manager.unsubscribe_patterns(1, &[]).unwrap();
}
});
scope.spawn(|| {
for _ in 0..128 {
manager.subscribe(1, &["Event".into()]);
manager.unsubscribe(1, &["Event".into()]);
}
});
for _ in 0..128 {
manager.forward_to_subscribers(¬ification("Event"));
}
});
while receiver.try_recv().is_ok() {}
manager.forward_to_subscribers(¬ification("Event"));
assert!(receiver.try_recv().is_err());
assert!(!manager.has_subscriptions(1));
assert_eq!(
manager.stats().subscriptions_added(),
manager.stats().subscriptions_removed()
);
}
}