use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Duration;
use zeroize::Zeroizing;
use super::TopicAcl;
use super::handler::Connect;
use super::publisher::{Error, Publisher};
use super::state::{ConnectionHandle, ServerCommand, SharedState};
use super::subscribe::TopicRecovery;
use crate::jwt::{self, JwtConfig};
#[derive(Clone, Debug, Default)]
#[non_exhaustive]
pub struct Subscribe {
pub queue_group: Option<String>,
pub presence: Option<serde_json::Value>,
}
impl Subscribe {
pub fn queue_group(group: impl Into<String>) -> Self {
Self {
queue_group: Some(group.into()),
presence: None,
}
}
pub fn presence(data: serde_json::Value) -> Self {
Self {
queue_group: None,
presence: Some(data),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Recovered {
pub epoch: Option<String>,
pub offset: u64,
pub recoverable: bool,
pub recovered: bool,
pub count: usize,
pub subscribed: bool,
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Member {
pub user_id: String,
pub data: serde_json::Value,
pub connections: usize,
}
#[derive(Clone)]
#[non_exhaustive]
pub struct JwtKeys {
pub secret: Vec<u8>,
pub previous_secret: Option<Vec<u8>>,
pub key_id: Option<String>,
pub private_key: Option<Vec<u8>>,
}
impl std::fmt::Debug for JwtKeys {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let set = |key: bool| if key { "Some(<redacted>)" } else { "None" };
f.debug_struct("JwtKeys")
.field("secret", &format_args!("<redacted>"))
.field(
"previous_secret",
&format_args!("{}", set(self.previous_secret.is_some())),
)
.field("key_id", &self.key_id)
.field(
"private_key",
&format_args!("{}", set(self.private_key.is_some())),
)
.finish()
}
}
impl JwtKeys {
pub fn new(secret: impl Into<Vec<u8>>) -> Self {
Self {
secret: secret.into(),
previous_secret: None,
key_id: None,
private_key: None,
}
}
}
fn subscribe(
shared: &SharedState,
conn_id: &str,
handle: &ConnectionHandle,
topics: Vec<String>,
options: &Subscribe,
) -> Result<Vec<String>, Error> {
let accepted = shared
.admit_topics(conn_id, topics, options.queue_group.as_deref())
.map_err(|max| Error::TooManyTopics(conn_id.to_owned(), max))?;
shared.subscribe_topics(conn_id, handle, &accepted, options.queue_group.as_deref());
if !shared.conn_last_activity.contains_key(conn_id) {
shared.unsubscribe_topics(conn_id, None);
return Ok(Vec::new());
}
if let Some(data) = &options.presence {
shared.track_presence(conn_id, &accepted, data);
}
Ok(accepted)
}
fn recover(
shared: &SharedState,
conn_id: &str,
handle: Option<&ConnectionHandle>,
topics: Vec<String>,
positions: &HashMap<String, (u32, u64)>,
) -> Result<HashMap<String, Recovered>, Error> {
let (accepted, recovered) = match handle {
Some(handle) => shared
.subscribe_and_recover(conn_id, handle, topics.clone(), positions)
.map_err(|max| Error::TooManyTopics(conn_id.to_owned(), max))?,
None => (Vec::new(), HashMap::new()),
};
let (accepted, recovered) = if shared.conn_last_activity.contains_key(conn_id) {
(accepted, recovered)
} else {
shared.unsubscribe_topics(conn_id, None);
(Vec::new(), HashMap::new())
};
Ok(topics
.into_iter()
.map(|topic| {
let r = recovered.get(&topic).copied().unwrap_or(TopicRecovery {
epoch: None,
offset: 0,
recovered: false,
recoverable: false,
count: 0,
});
let subscribed = accepted.contains(&topic);
let result = Recovered {
epoch: r.epoch_hex(),
offset: r.offset,
recoverable: r.recoverable,
recovered: r.recovered,
count: r.count,
subscribed,
};
(topic, result)
})
.collect())
}
impl Connect<'_> {
pub fn subscribe(
&self,
topics: Vec<String>,
options: &Subscribe,
) -> Result<Vec<String>, Error> {
subscribe(self.state, self.conn_id, self.handle, topics, options)
}
pub fn set_topic_acl(&self, allow: Option<Vec<String>>, deny: Option<Vec<String>>) {
let acl = match allow {
Some(allow) if allow.is_empty() => TopicAcl::deny_all(),
allow => TopicAcl {
allow: allow.unwrap_or_default(),
deny: deny.unwrap_or_default(),
},
};
self.state.topics.acls.insert((**self.conn_id).clone(), acl);
}
}
impl Publisher {
pub fn connections(&self) -> Vec<String> {
self.shared
.conn_last_activity
.iter()
.map(|entry| entry.key().clone())
.collect()
}
pub fn connection_count(&self) -> usize {
self.shared.connection_count.load(Ordering::Relaxed)
}
pub fn is_draining(&self) -> bool {
self.shared.draining.load(Ordering::Relaxed)
}
pub fn disconnect(&self, conn_id: &str) -> Result<(), Error> {
self.command(ServerCommand::Disconnect {
conn_id: conn_id.to_owned(),
})
}
pub fn user_connections(&self, user_id: &str) -> Vec<String> {
self.shared
.user_conns
.get(user_id)
.map_or_else(Vec::new, |conns| conns.iter().cloned().collect())
}
pub fn send_to_user(&self, user_id: &str, text: &str) -> Result<usize, Error> {
let conns = self.user_connections(user_id);
for conn_id in &conns {
self.send(conn_id, text)?;
}
Ok(conns.len())
}
pub fn send_event_to_user(
&self,
user_id: &str,
event: &serde_json::Map<String, serde_json::Value>,
compression_threshold: usize,
) -> Result<usize, Error> {
let conns = self.user_connections(user_id);
let mut sent = 0;
for conn_id in &conns {
if self.send_event(conn_id, event.clone(), compression_threshold)? > 0 {
sent += 1;
}
}
Ok(sent)
}
pub fn disconnect_user(&self, user_id: &str) -> Result<usize, Error> {
let conns = self.user_connections(user_id);
for conn_id in &conns {
self.disconnect(conn_id)?;
}
Ok(conns.len())
}
pub fn subscribe(
&self,
conn_id: &str,
topics: Vec<String>,
options: &Subscribe,
) -> Result<Vec<String>, Error> {
let handle = self.shared.connections.read().get(conn_id).cloned();
match handle {
Some(handle) => subscribe(&self.shared, conn_id, &handle, topics, options),
None => Ok(Vec::new()),
}
}
pub fn subscribe_with_recovery(
&self,
conn_id: &str,
topics: Vec<String>,
positions: &HashMap<String, (u32, u64)>,
) -> Result<HashMap<String, Recovered>, Error> {
let handle = self.shared.connections.read().get(conn_id).cloned();
recover(&self.shared, conn_id, handle.as_ref(), topics, positions)
}
pub fn unsubscribe(&self, conn_id: &str, topics: Option<&[String]>) {
self.shared.unsubscribe_topics(conn_id, topics);
}
pub fn set_topic_acl(
&self,
conn_id: &str,
allow: Option<Vec<String>>,
deny: Option<Vec<String>>,
) -> bool {
let shared = &self.shared;
if !shared.conn_last_activity.contains_key(conn_id) {
return false;
}
let acl = match allow {
Some(allow) if allow.is_empty() => TopicAcl::deny_all(),
allow => TopicAcl {
allow: allow.unwrap_or_default(),
deny: deny.unwrap_or_default(),
},
};
shared.topics.acls.insert(conn_id.to_owned(), acl);
if !shared.conn_last_activity.contains_key(conn_id) {
shared.topics.acls.remove(conn_id);
return false;
}
true
}
pub fn topic_subscriber_count(&self, topic: &str) -> usize {
self.shared
.topics
.subscribers
.get(topic)
.map_or(0, |subscribers| subscribers.len())
}
pub fn queue_groups(&self, topic: &str) -> Vec<(String, usize)> {
match self.shared.queue_groups.get(topic) {
Some(groups) => groups
.iter()
.map(|entry| (entry.key().clone(), entry.value().members.len()))
.collect(),
None => Vec::new(),
}
}
pub fn presence(&self, topic: &str) -> Vec<Member> {
match &self.shared.presence {
Some(pm) => pm
.query(topic)
.into_iter()
.map(|(user_id, data, connections)| Member {
user_id,
data,
connections,
})
.collect(),
None => Vec::new(),
}
}
pub fn presence_stats(&self, topic: &str) -> (usize, usize) {
self.shared
.presence
.as_ref()
.map_or((0, 0), |pm| pm.stats(topic))
}
pub fn update_presence(&self, conn_id: &str, data: &serde_json::Value) -> bool {
self.shared.update_presence(conn_id, data)
}
pub fn sign(
&self,
event_type: &str,
payload: serde_json::Value,
topic: Option<&str>,
) -> Result<String, Error> {
self.shared.sign(event_type, payload, topic, None)
}
pub fn sign_to(
&self,
user_id: &str,
event_type: &str,
payload: serde_json::Value,
) -> Result<String, Error> {
self.shared.sign(event_type, payload, None, Some(user_id))
}
pub fn signing_public_key(&self) -> Option<String> {
self.shared.signer.as_ref().map(|s| s.public_key.clone())
}
pub fn e2e_identity_public_key(&self) -> Option<String> {
use base64::Engine;
self.shared
.e2e_identity
.as_ref()
.map(|k| base64::engine::general_purpose::STANDARD.encode(k.public_key()))
}
pub fn set_client_key(&self, conn_id: &str, public_key: Option<&str>) -> Result<bool, Error> {
self.shared.set_client_key(conn_id, public_key)
}
pub fn issue_token(
&self,
sub: &str,
ttl: Duration,
claims: serde_json::Map<String, serde_json::Value>,
) -> Result<String, Error> {
let holder = self.shared.jwt_config.as_ref().ok_or(Error::NoJwt)?;
let cfg = holder.load();
let key: &[u8] = match cfg.algorithm.key_kind() {
jwt::KeyKind::Secret { .. } => &cfg.secret,
_ => cfg.signing_key.as_deref().ok_or_else(|| {
Error::Jwt(format!(
"{:?} signs with jwt_private_key, which this server was not given",
cfg.algorithm
))
})?,
};
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let mut token = serde_json::Map::new();
token.insert("iat".into(), now.into());
token.insert("exp".into(), now.saturating_add(ttl.as_secs()).into());
if !cfg.issuer.is_empty() {
token.insert("iss".into(), cfg.issuer.clone().into());
}
if !cfg.audience.is_empty() {
token.insert("aud".into(), cfg.audience.clone().into());
}
token.extend(claims);
token.insert("sub".into(), sub.into());
jwt::jwt_encode(
&serde_json::Value::Object(token),
key,
cfg.algorithm,
cfg.key_id.as_deref(),
)
.map_err(|e| Error::Jwt(format!("JWT encode error: {e}")))
}
pub fn reload_jwt_keys(&self, keys: JwtKeys) -> Result<(), Error> {
let holder = self.shared.jwt_config.as_ref().ok_or(Error::NoJwt)?;
let current = holder.load();
let alg = current.algorithm;
let key_error =
|option: &str, e: jwt::JwtError| Error::BadJwtKey(format!("{option} for {alg:?}: {e}"));
jwt::check_verification_key(alg, &keys.secret).map_err(|e| key_error("jwt_secret", e))?;
if let Some(ref key) = keys.previous_secret {
jwt::check_verification_key(alg, key)
.map_err(|e| key_error("jwt_previous_secret", e))?;
}
if let Some(ref key) = keys.private_key {
jwt::check_signing_key(alg, key).map_err(|e| key_error("jwt_private_key", e))?;
} else if current.signing_key.is_some()
&& !matches!(alg.key_kind(), jwt::KeyKind::Secret { .. })
&& keys.secret.as_slice() != current.secret.as_slice()
{
return Err(Error::BadJwtKey(
"jwt_private_key: a new jwt_secret needs the private key that goes with it, \
for issue_token()"
.to_owned(),
));
}
holder.store(Arc::new(JwtConfig {
algorithm: alg,
secret: Zeroizing::new(keys.secret),
previous_secret: keys.previous_secret.map(Zeroizing::new),
signing_key: keys
.private_key
.map(Zeroizing::new)
.or_else(|| current.signing_key.clone()),
key_id: keys.key_id.or_else(|| current.key_id.clone()),
issuer: current.issuer.clone(),
audience: current.audience.clone(),
cookie_name: current.cookie_name.clone(),
}));
tracing::info!("[WSE] JWT keys reloaded");
Ok(())
}
}