use std::collections::{BTreeSet, HashSet, VecDeque};
use std::pin::Pin;
use std::task::{Context, Poll};
use bytes::Bytes;
use futures::SinkExt;
use redis_tower_core::{Frame, RedisConnection, RedisError};
use redis_tower_protocol::helpers::{array, bulk};
use tokio_stream::{Stream, StreamExt};
use tokio_util::codec::Framed;
use redis_tower_core::RedisStream;
use redis_tower_protocol::{ProtocolError, RespCodec};
use crate::reconnect::{ConnectionFactory, ReconnectConfig, connect_with_timeout};
pub trait PubSubName: Clone + Ord + Send + Sync + Unpin + 'static {
fn from_name_bytes(bytes: &[u8]) -> Self;
fn name_bytes(&self) -> &[u8];
}
impl PubSubName for String {
fn from_name_bytes(bytes: &[u8]) -> Self {
String::from_utf8_lossy(bytes).into_owned()
}
fn name_bytes(&self) -> &[u8] {
self.as_bytes()
}
}
impl PubSubName for Bytes {
fn from_name_bytes(bytes: &[u8]) -> Self {
Bytes::copy_from_slice(bytes)
}
fn name_bytes(&self) -> &[u8] {
self.as_ref()
}
}
#[derive(Debug, Clone)]
pub struct PubSubMessage {
pub kind: MessageKind,
pub channel: String,
pub pattern: Option<String>,
pub payload: Bytes,
}
impl From<NamedPubSubMessage<String>> for PubSubMessage {
fn from(message: NamedPubSubMessage<String>) -> Self {
Self {
kind: message.kind,
channel: message.channel,
pattern: message.pattern,
payload: message.payload,
}
}
}
pub type BinaryPubSubMessage = NamedPubSubMessage<Bytes>;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Subscriptions {
pub channels: BTreeSet<String>,
pub patterns: BTreeSet<String>,
pub shard_channels: BTreeSet<String>,
}
impl From<&NamedSubscriptions<String>> for Subscriptions {
fn from(names: &NamedSubscriptions<String>) -> Self {
Self {
channels: names.channels.clone(),
patterns: names.patterns.clone(),
shard_channels: names.shard_channels.clone(),
}
}
}
impl Subscriptions {
pub fn is_empty(&self) -> bool {
self.channels.is_empty() && self.patterns.is_empty() && self.shard_channels.is_empty()
}
pub fn replay_frames(&self) -> Vec<Frame> {
NamedSubscriptions {
channels: self.channels.clone(),
patterns: self.patterns.clone(),
shard_channels: self.shard_channels.clone(),
}
.replay_frames()
}
}
pub type BinarySubscriptions = NamedSubscriptions<Bytes>;
pub struct PubSubConnection {
inner: NamedPubSubConnection<String>,
subscriptions: Subscriptions,
}
impl From<NamedPubSubConnection<String>> for PubSubConnection {
fn from(inner: NamedPubSubConnection<String>) -> Self {
let subscriptions = inner.subscriptions().into();
Self {
inner,
subscriptions,
}
}
}
impl PubSubConnection {
pub fn from_connection(connection: RedisConnection) -> Result<Self, RedisError> {
NamedPubSubConnection::from_connection(connection).map(Self::from)
}
pub fn subscriptions(&self) -> &Subscriptions {
&self.subscriptions
}
pub fn into_keyspace_events(self) -> KeyspaceEventStream {
KeyspaceEventStream { inner: self }
}
pub async fn subscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.subscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn psubscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.psubscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn ssubscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.ssubscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn unsubscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.unsubscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn punsubscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.punsubscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn sunsubscribe(&mut self, names: &[&str]) -> Result<(), RedisError> {
let result = self.inner.sunsubscribe(names).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn psubscribe_keyspace(&mut self, db: u32, pattern: &str) -> Result<(), RedisError> {
let result = self.inner.psubscribe_keyspace(db, pattern).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn psubscribe_keyevent(&mut self, db: u32, pattern: &str) -> Result<(), RedisError> {
let result = self.inner.psubscribe_keyevent(db, pattern).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn resubscribe(&mut self) -> Result<(), RedisError> {
let result = self.inner.resubscribe().await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn reconnect_with(
&mut self,
factory: &dyn ConnectionFactory,
) -> Result<(), RedisError> {
let result = self.inner.reconnect_with(factory).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
pub async fn reconnect_with_backoff(
&mut self,
factory: &dyn ConnectionFactory,
config: &ReconnectConfig,
) -> Result<(), RedisError> {
let result = self.inner.reconnect_with_backoff(factory, config).await;
self.subscriptions = self.inner.subscriptions().into();
result
}
#[cfg(test)]
fn parse_message(frame: Frame) -> Result<Option<PubSubMessage>, RedisError> {
NamedPubSubConnection::<String>::parse_message(frame).map(|message| message.map(Into::into))
}
}
impl Stream for PubSubConnection {
type Item = Result<PubSubMessage, RedisError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.inner)
.poll_next(cx)
.map(|message| message.map(|message| message.map(Into::into)))
}
}
pub type BinaryPubSubConnection = NamedPubSubConnection<Bytes>;
#[derive(Debug, Clone)]
pub struct NamedPubSubMessage<N> {
pub kind: MessageKind,
pub channel: N,
pub pattern: Option<N>,
pub payload: Bytes,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MessageKind {
Message,
PMessage,
SMessage,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NotificationKind {
Keyspace,
Keyevent,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct KeyspaceEvent {
pub kind: NotificationKind,
pub db: u32,
pub key: String,
pub event: String,
}
impl KeyspaceEvent {
fn parse_channel(channel: &str) -> Option<(NotificationKind, u32, &str)> {
for (prefix, kind) in [
("__keyspace@", NotificationKind::Keyspace),
("__keyevent@", NotificationKind::Keyevent),
] {
if let Some(rest) = channel.strip_prefix(prefix)
&& let Some((db_str, tail)) = rest.split_once("__:")
&& let Ok(db) = db_str.parse::<u32>()
{
return Some((kind, db, tail));
}
}
None
}
pub fn from_message(msg: &PubSubMessage) -> Option<KeyspaceEvent> {
let (kind, db, tail) = Self::parse_channel(&msg.channel)?;
let payload = String::from_utf8_lossy(&msg.payload).into_owned();
let (key, event) = match kind {
NotificationKind::Keyspace => (tail.to_string(), payload),
NotificationKind::Keyevent => (payload, tail.to_string()),
};
Some(KeyspaceEvent {
kind,
db,
key,
event,
})
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct NamedSubscriptions<N> {
pub channels: BTreeSet<N>,
pub patterns: BTreeSet<N>,
pub shard_channels: BTreeSet<N>,
}
impl<N: PubSubName> NamedSubscriptions<N> {
pub fn is_empty(&self) -> bool {
self.channels.is_empty() && self.patterns.is_empty() && self.shard_channels.is_empty()
}
pub fn replay_frames(&self) -> Vec<Frame> {
let mut frames = Vec::new();
for (cmd, set) in [
("SUBSCRIBE", &self.channels),
("PSUBSCRIBE", &self.patterns),
("SSUBSCRIBE", &self.shard_channels),
] {
if !set.is_empty() {
let mut args = vec![bulk(cmd)];
args.extend(set.iter().map(|s| bulk(s.name_bytes())));
frames.push(array(args));
}
}
frames
}
fn add(set: &mut BTreeSet<N>, names: &[&[u8]]) {
set.extend(names.iter().map(|n| N::from_name_bytes(n)));
}
fn remove(set: &mut BTreeSet<N>, names: &[&[u8]]) {
if names.is_empty() {
set.clear();
} else {
for n in names {
set.remove(&N::from_name_bytes(n));
}
}
}
}
pub struct NamedPubSubConnection<N> {
framed: Framed<RedisStream, RespCodec>,
buffered_frames: VecDeque<Frame>,
subs: NamedSubscriptions<N>,
}
impl<N: PubSubName> NamedPubSubConnection<N> {
pub fn from_connection(conn: RedisConnection) -> Result<Self, RedisError> {
let framed = conn.into_framed()?;
Ok(Self {
framed,
buffered_frames: VecDeque::new(),
subs: NamedSubscriptions {
channels: BTreeSet::new(),
patterns: BTreeSet::new(),
shard_channels: BTreeSet::new(),
},
})
}
async fn send_subscribe(
&mut self,
cmd: &str,
names: &[&[u8]],
kind: &str,
) -> Result<(), RedisError> {
let names = Self::unique_names(names)?;
let mut args = vec![bulk(cmd)];
for name in &names {
args.push(bulk(*name));
}
self.framed
.send(array(args))
.await
.map_err(RedisError::from)?;
self.await_confirmations(&names, kind).await
}
pub async fn subscribe(&mut self, channels: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = channels.iter().map(|name| name.as_bytes()).collect();
self.subscribe_bytes(&names).await
}
pub async fn subscribe_bytes(&mut self, channels: &[&[u8]]) -> Result<(), RedisError> {
self.send_subscribe("SUBSCRIBE", channels, "subscribe")
.await?;
NamedSubscriptions::add(&mut self.subs.channels, channels);
Ok(())
}
pub async fn psubscribe(&mut self, patterns: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = patterns.iter().map(|name| name.as_bytes()).collect();
self.psubscribe_bytes(&names).await
}
pub async fn psubscribe_bytes(&mut self, patterns: &[&[u8]]) -> Result<(), RedisError> {
self.send_subscribe("PSUBSCRIBE", patterns, "psubscribe")
.await?;
NamedSubscriptions::add(&mut self.subs.patterns, patterns);
Ok(())
}
pub async fn psubscribe_keyspace(
&mut self,
db: u32,
key_pattern: &str,
) -> Result<(), RedisError> {
let pattern = format!("__keyspace@{db}__:{key_pattern}");
self.psubscribe(&[pattern.as_str()]).await
}
pub async fn psubscribe_keyevent(
&mut self,
db: u32,
event_pattern: &str,
) -> Result<(), RedisError> {
let pattern = format!("__keyevent@{db}__:{event_pattern}");
self.psubscribe(&[pattern.as_str()]).await
}
pub async fn unsubscribe(&mut self, channels: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = channels.iter().map(|name| name.as_bytes()).collect();
self.unsubscribe_bytes(&names).await
}
pub async fn unsubscribe_bytes(&mut self, channels: &[&[u8]]) -> Result<(), RedisError> {
let tracked: Vec<N> = self.subs.channels.iter().cloned().collect();
self.send_unsubscribe("UNSUBSCRIBE", channels, "unsubscribe", &tracked)
.await?;
NamedSubscriptions::remove(&mut self.subs.channels, channels);
Ok(())
}
pub async fn ssubscribe(&mut self, channels: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = channels.iter().map(|name| name.as_bytes()).collect();
self.ssubscribe_bytes(&names).await
}
pub async fn ssubscribe_bytes(&mut self, channels: &[&[u8]]) -> Result<(), RedisError> {
self.send_subscribe("SSUBSCRIBE", channels, "ssubscribe")
.await?;
NamedSubscriptions::add(&mut self.subs.shard_channels, channels);
Ok(())
}
pub async fn sunsubscribe(&mut self, channels: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = channels.iter().map(|name| name.as_bytes()).collect();
self.sunsubscribe_bytes(&names).await
}
pub async fn sunsubscribe_bytes(&mut self, channels: &[&[u8]]) -> Result<(), RedisError> {
let tracked: Vec<N> = self.subs.shard_channels.iter().cloned().collect();
self.send_unsubscribe("SUNSUBSCRIBE", channels, "sunsubscribe", &tracked)
.await?;
NamedSubscriptions::remove(&mut self.subs.shard_channels, channels);
Ok(())
}
pub async fn punsubscribe(&mut self, patterns: &[&str]) -> Result<(), RedisError> {
let names: Vec<&[u8]> = patterns.iter().map(|name| name.as_bytes()).collect();
self.punsubscribe_bytes(&names).await
}
pub async fn punsubscribe_bytes(&mut self, patterns: &[&[u8]]) -> Result<(), RedisError> {
let tracked: Vec<N> = self.subs.patterns.iter().cloned().collect();
self.send_unsubscribe("PUNSUBSCRIBE", patterns, "punsubscribe", &tracked)
.await?;
NamedSubscriptions::remove(&mut self.subs.patterns, patterns);
Ok(())
}
pub fn subscriptions(&self) -> &NamedSubscriptions<N> {
&self.subs
}
pub async fn resubscribe(&mut self) -> Result<(), RedisError> {
let channels: Vec<N> = self.subs.channels.iter().cloned().collect();
let patterns: Vec<N> = self.subs.patterns.iter().cloned().collect();
let shard: Vec<N> = self.subs.shard_channels.iter().cloned().collect();
if !channels.is_empty() {
let refs: Vec<&[u8]> = channels.iter().map(PubSubName::name_bytes).collect();
self.send_subscribe("SUBSCRIBE", &refs, "subscribe").await?;
}
if !patterns.is_empty() {
let refs: Vec<&[u8]> = patterns.iter().map(PubSubName::name_bytes).collect();
self.send_subscribe("PSUBSCRIBE", &refs, "psubscribe")
.await?;
}
if !shard.is_empty() {
let refs: Vec<&[u8]> = shard.iter().map(PubSubName::name_bytes).collect();
self.send_subscribe("SSUBSCRIBE", &refs, "ssubscribe")
.await?;
}
Ok(())
}
pub async fn reconnect_with(
&mut self,
factory: &dyn ConnectionFactory,
) -> Result<(), RedisError> {
let conn = factory.connect().await?;
self.install_replacement(conn).await
}
pub async fn reconnect_with_backoff(
&mut self,
factory: &dyn ConnectionFactory,
config: &ReconnectConfig,
) -> Result<(), RedisError> {
let mut attempt = 0;
loop {
tokio::time::sleep(config.delay_for_attempt(attempt)).await;
let result = match connect_with_timeout(factory, config.connect_timeout).await {
Ok(conn) => self.install_replacement(conn).await,
Err(error) => Err(error),
};
match result {
Ok(()) => return Ok(()),
Err(last_error) => {
let attempts = attempt.saturating_add(1);
attempt = attempts;
if config.attempt_exhausted(attempt) {
return Err(RedisError::ReconnectFailed {
attempts,
last_error: std::sync::Arc::new(last_error),
});
}
}
}
}
}
async fn install_replacement(&mut self, conn: RedisConnection) -> Result<(), RedisError> {
let mut replacement = Self {
framed: conn.into_framed()?,
buffered_frames: VecDeque::new(),
subs: self.subs.clone(),
};
replacement.resubscribe().await?;
self.framed = replacement.framed;
self.buffered_frames = replacement.buffered_frames;
Ok(())
}
async fn send_unsubscribe(
&mut self,
cmd: &str,
names: &[&[u8]],
kind: &str,
tracked: &[N],
) -> Result<(), RedisError> {
let unique_names = if names.is_empty() {
Vec::new()
} else {
Self::unique_names(names)?
};
let mut args = vec![bulk(cmd)];
args.extend(unique_names.iter().map(|name| bulk(*name)));
self.framed
.send(array(args))
.await
.map_err(RedisError::from)?;
if !unique_names.is_empty() {
return self.await_confirmations(&unique_names, kind).await;
}
if !tracked.is_empty() {
let names: Vec<&[u8]> = tracked.iter().map(PubSubName::name_bytes).collect();
return self.await_confirmations(&names, kind).await;
}
self.await_confirmation(kind).await
}
fn unique_names<'a>(names: &'a [&'a [u8]]) -> Result<Vec<&'a [u8]>, RedisError> {
if names.is_empty() {
return Err(RedisError::Redis(
"pub/sub subscribe requires at least one name".to_string(),
));
}
let mut seen = HashSet::with_capacity(names.len());
Ok(names
.iter()
.copied()
.filter(|name| seen.insert(*name))
.collect())
}
async fn next_wire_frame(&mut self) -> Result<Frame, RedisError> {
self.framed
.next()
.await
.ok_or(RedisError::ConnectionClosed)?
.map_err(RedisError::from)
}
async fn await_confirmations(
&mut self,
names: &[&[u8]],
expected_kind: &str,
) -> Result<(), RedisError> {
let mut pending: HashSet<&[u8]> = names.iter().copied().collect();
let mut deferred = VecDeque::new();
let result = loop {
if pending.is_empty() {
break Ok(());
}
let frame = match self.next_wire_frame().await {
Ok(frame) => frame,
Err(error) => break Err(error),
};
match Self::extract_confirmation_channel(&frame, expected_kind) {
Some(Ok(channel)) => {
if pending.remove(channel.as_ref()) {
continue;
}
deferred.push_back(frame);
}
Some(Err(error)) => break Err(error),
None => {
deferred.push_back(frame);
}
}
};
self.buffered_frames.extend(deferred);
result
}
async fn await_confirmation(&mut self, expected_kind: &str) -> Result<(), RedisError> {
let mut deferred = VecDeque::new();
let result = loop {
let frame = match self.next_wire_frame().await {
Ok(frame) => frame,
Err(error) => break Err(error),
};
match Self::is_confirmation(&frame, expected_kind) {
Some(Ok(())) => break Ok(()),
Some(Err(error)) => break Err(error),
None => deferred.push_back(frame),
}
};
self.buffered_frames.extend(deferred);
result
}
fn extract_confirmation_channel(
frame: &Frame,
expected_kind: &str,
) -> Option<Result<Bytes, RedisError>> {
let items = match frame {
Frame::Array(Some(items)) | Frame::Push(items) => items,
Frame::Error(e) => {
return Some(Err(RedisError::Redis(
String::from_utf8_lossy(e).into_owned(),
)));
}
_ => return None,
};
if items.len() < 3 {
return None;
}
let kind = match &items[0] {
Frame::BulkString(Some(b)) | Frame::SimpleString(b) => b,
_ => return None,
};
if kind.as_ref() != expected_kind.as_bytes() {
return None;
}
match &items[1] {
Frame::BulkString(Some(b)) => Some(Ok(b.clone())),
Frame::SimpleString(b) => Some(Ok(b.clone())),
_ => None,
}
}
fn is_confirmation(frame: &Frame, expected_kind: &str) -> Option<Result<(), RedisError>> {
let items = match frame {
Frame::Array(Some(items)) | Frame::Push(items) => items,
Frame::Error(error) => {
return Some(Err(RedisError::Redis(
String::from_utf8_lossy(error).into_owned(),
)));
}
_ => return None,
};
if items.len() < 3 || !matches!(items.last(), Some(Frame::Integer(_))) {
return None;
}
let kind = match &items[0] {
Frame::BulkString(Some(kind)) | Frame::SimpleString(kind) => kind,
_ => return None,
};
if kind.as_ref() != expected_kind.as_bytes() {
return None;
}
match &items[1] {
Frame::BulkString(_) | Frame::SimpleString(_) => Some(Ok(())),
Frame::Null if expected_kind.ends_with("unsubscribe") => Some(Ok(())),
_ => None,
}
}
fn parse_message(frame: Frame) -> Result<Option<NamedPubSubMessage<N>>, RedisError> {
let items = match frame {
Frame::Array(Some(items)) | Frame::Push(items) => items,
other => {
return Err(RedisError::UnexpectedResponse {
expected: "pub/sub message array",
actual: format!("{other:?}"),
});
}
};
let kind_bytes = match items.first() {
Some(Frame::BulkString(Some(b))) => b,
_ => {
return Err(RedisError::UnexpectedResponse {
expected: "message type",
actual: format!("{items:?}"),
});
}
};
match kind_bytes.as_ref() {
b"message" if items.len() == 3 => {
let channel = Self::extract_string(&items[1])?;
let payload = Self::extract_bytes(&items[2])?;
Ok(Some(NamedPubSubMessage {
kind: MessageKind::Message,
channel,
pattern: None,
payload,
}))
}
b"pmessage" if items.len() == 4 => {
let pattern = Self::extract_string(&items[1])?;
let channel = Self::extract_string(&items[2])?;
let payload = Self::extract_bytes(&items[3])?;
Ok(Some(NamedPubSubMessage {
kind: MessageKind::PMessage,
channel,
pattern: Some(pattern),
payload,
}))
}
b"smessage" if items.len() == 3 => {
let channel = Self::extract_string(&items[1])?;
let payload = Self::extract_bytes(&items[2])?;
Ok(Some(NamedPubSubMessage {
kind: MessageKind::SMessage,
channel,
pattern: None,
payload,
}))
}
b"subscribe" | b"unsubscribe" | b"psubscribe" | b"punsubscribe" | b"ssubscribe"
| b"sunsubscribe" => Ok(None),
other => Err(RedisError::UnexpectedResponse {
expected: "message or pmessage",
actual: format!("{}", String::from_utf8_lossy(other)),
}),
}
}
fn extract_string(frame: &Frame) -> Result<N, RedisError> {
match frame {
Frame::BulkString(Some(b)) => Ok(N::from_name_bytes(b)),
Frame::SimpleString(b) => Ok(N::from_name_bytes(b)),
other => Err(RedisError::UnexpectedResponse {
expected: "string",
actual: format!("{other:?}"),
}),
}
}
fn extract_bytes(frame: &Frame) -> Result<Bytes, RedisError> {
match frame {
Frame::BulkString(Some(b)) => Ok(b.clone()),
Frame::SimpleString(b) => Ok(b.clone()),
other => Err(RedisError::UnexpectedResponse {
expected: "bytes",
actual: format!("{other:?}"),
}),
}
}
}
fn pubsub_stream_error(error: ProtocolError) -> RedisError {
match error {
ProtocolError::Io(error) if error.kind() != std::io::ErrorKind::Unsupported => error.into(),
error => error.into(),
}
}
impl<N: PubSubName> Stream for NamedPubSubConnection<N> {
type Item = Result<NamedPubSubMessage<N>, RedisError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
loop {
let frame = if let Some(frame) = self.buffered_frames.pop_front() {
frame
} else {
match Pin::new(&mut self.framed).poll_next(cx) {
Poll::Ready(Some(Ok(frame))) => frame,
Poll::Ready(Some(Err(e))) => {
return Poll::Ready(Some(Err(pubsub_stream_error(e))));
}
Poll::Ready(None) => return Poll::Ready(None),
Poll::Pending => return Poll::Pending,
}
};
match Self::parse_message(frame) {
Ok(Some(msg)) => return Poll::Ready(Some(Ok(msg))),
Ok(None) => continue, Err(e) => return Poll::Ready(Some(Err(e))),
}
}
}
}
impl NamedPubSubConnection<String> {
pub fn into_keyspace_events(self) -> KeyspaceEventStream {
KeyspaceEventStream { inner: self.into() }
}
}
pub struct KeyspaceEventStream {
inner: PubSubConnection,
}
impl KeyspaceEventStream {
pub fn get_ref(&self) -> &PubSubConnection {
&self.inner
}
pub fn get_mut(&mut self) -> &mut PubSubConnection {
&mut self.inner
}
pub fn into_inner(self) -> PubSubConnection {
self.inner
}
}
impl Stream for KeyspaceEventStream {
type Item = Result<KeyspaceEvent, RedisError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
loop {
match Pin::new(&mut self.inner).poll_next(cx) {
Poll::Ready(Some(Ok(msg))) => match KeyspaceEvent::from_message(&msg) {
Some(event) => return Poll::Ready(Some(Ok(event))),
None => continue, },
Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
Poll::Ready(None) => return Poll::Ready(None),
Poll::Pending => return Poll::Pending,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn stream_errors_distinguish_transport_loss_from_unsupported_protocol() {
let reset = ProtocolError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionReset));
assert!(pubsub_stream_error(reset).is_connection_error());
let unsupported = ProtocolError::Io(std::io::Error::new(
std::io::ErrorKind::Unsupported,
"RESP3 attributed replies are not supported",
));
assert!(matches!(
pubsub_stream_error(unsupported),
RedisError::Protocol(_)
));
}
use redis_tower_protocol::helpers::{array, bulk};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
fn sub_confirmation(kind: &str, channel: &str, count: i64) -> Frame {
array(vec![bulk(kind), bulk(channel), Frame::Integer(count)])
}
fn message(channel: &str, payload: &str) -> Frame {
array(vec![bulk("message"), bulk(channel), bulk(payload)])
}
#[cfg(unix)]
async fn redis_stream_pair() -> (RedisStream, RedisStream) {
let (client, server) = tokio::net::UnixStream::pair().unwrap();
(RedisStream::Unix(client), RedisStream::Unix(server))
}
#[cfg(not(unix))]
async fn redis_stream_pair() -> (RedisStream, RedisStream) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let (client, accepted) =
tokio::join!(tokio::net::TcpStream::connect(addr), listener.accept());
let (server, _) = accepted.unwrap();
(RedisStream::Tcp(client.unwrap()), RedisStream::Tcp(server))
}
async fn pubsub_pair() -> (
PubSubConnection,
Framed<RedisStream, redis_tower_protocol::RespCodec>,
) {
let (client, server) = redis_stream_pair().await;
let connection = RedisConnection::from_stream(client);
let pubsub = PubSubConnection::from_connection(connection).unwrap();
let server = Framed::new(server, redis_tower_protocol::RespCodec::new());
(pubsub, server)
}
#[tokio::test]
async fn binary_names_survive_confirmations_delivery_and_reconnect() {
let (client, server) = redis_stream_pair().await;
let mut pubsub =
BinaryPubSubConnection::from_connection(RedisConnection::from_stream(client)).unwrap();
let mut server = Framed::new(server, redis_tower_protocol::RespCodec::new());
let first = Bytes::from_static(b"channel\xff");
let second = Bytes::from_static(b"channel\xfe");
let wire_names = [first.clone(), second.clone()];
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![
bulk("SUBSCRIBE"),
bulk(wire_names[0].clone()),
bulk(wire_names[1].clone())
])
);
for name in &wire_names {
server
.send(Frame::Push(vec![
bulk("subscribe"),
bulk(name.clone()),
Frame::Integer(2),
]))
.await
.unwrap();
}
server
.send(Frame::Push(vec![
bulk("message"),
bulk(wire_names[1].clone()),
bulk(Bytes::from_static(b"\0\xffpayload")),
]))
.await
.unwrap();
});
tokio::time::timeout(
Duration::from_secs(1),
pubsub.subscribe_bytes(&[&first, &second]),
)
.await
.unwrap()
.unwrap();
let message = pubsub.next().await.unwrap().unwrap();
assert_eq!(message.channel, second);
assert_eq!(message.payload.as_ref(), b"\0\xffpayload");
server_task.await.unwrap();
assert_eq!(pubsub.subscriptions().channels.len(), 2);
let (replacement, server) = redis_stream_pair().await;
let replacement = std::sync::Mutex::new(Some(replacement));
let factory = move || {
let stream = replacement.lock().unwrap().take().unwrap();
async move { Ok(RedisConnection::from_stream(stream)) }
};
let mut server = Framed::new(server, redis_tower_protocol::RespCodec::new());
let names = pubsub
.subscriptions()
.channels
.iter()
.cloned()
.collect::<Vec<_>>();
let expected = pubsub.subscriptions().replay_frames();
let replay = tokio::spawn(async move {
assert_eq!(server.next().await.unwrap().unwrap(), expected[0]);
for name in &names {
server
.send(Frame::Push(vec![
bulk("subscribe"),
bulk(name.clone()),
Frame::Integer(2),
]))
.await
.unwrap();
}
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("UNSUBSCRIBE")])
);
for name in &names {
server
.send(Frame::Push(vec![
bulk("unsubscribe"),
bulk(name.clone()),
Frame::Integer(0),
]))
.await
.unwrap();
}
});
tokio::time::timeout(Duration::from_secs(1), pubsub.reconnect_with(&factory))
.await
.unwrap()
.unwrap();
tokio::time::timeout(Duration::from_secs(1), pubsub.unsubscribe_bytes(&[]))
.await
.unwrap()
.unwrap();
assert!(pubsub.subscriptions().is_empty());
replay.await.unwrap();
}
#[test]
fn binary_pattern_and_shard_messages_preserve_names() {
let pattern = Bytes::from_static(b"prefix\xff*");
let channel = Bytes::from_static(b"prefix\xffitem");
let message = BinaryPubSubConnection::parse_message(Frame::Push(vec![
bulk("pmessage"),
bulk(pattern.clone()),
bulk(channel.clone()),
bulk("value"),
]))
.unwrap()
.unwrap();
assert_eq!(message.pattern, Some(pattern));
assert_eq!(message.channel, channel);
let message = BinaryPubSubConnection::parse_message(array(vec![
bulk("smessage"),
bulk(channel.clone()),
bulk("value"),
]))
.unwrap()
.unwrap();
assert_eq!(message.channel, channel);
assert_eq!(message.kind, MessageKind::SMessage);
}
#[test]
fn extract_confirmation_channel_matches_expected_kind() {
let frame = sub_confirmation("subscribe", "events", 1);
let result =
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe");
assert!(result.is_some());
assert_eq!(result.unwrap().unwrap(), "events");
}
#[test]
fn extract_confirmation_channel_accepts_simple_string_kind() {
let frame = array(vec![
Frame::SimpleString(Bytes::from_static(b"subscribe")),
bulk("events"),
Frame::Integer(1),
]);
assert_eq!(
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe")
.unwrap()
.unwrap(),
"events"
);
}
#[test]
fn extract_confirmation_channel_returns_none_for_wrong_kind() {
let frame = sub_confirmation("psubscribe", "events.*", 1);
let result =
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe");
assert!(result.is_none());
}
#[test]
fn extract_confirmation_channel_returns_err_for_error_frame() {
let frame = Frame::Error(b"ERR something"[..].into());
let result =
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe");
assert!(result.is_some());
assert!(result.unwrap().is_err());
}
#[test]
fn extract_confirmation_channel_returns_none_for_message_frame() {
let frame = array(vec![bulk("message"), bulk("events"), bulk("hello")]);
let result =
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe");
assert!(result.is_none());
}
#[test]
fn extract_confirmation_channel_returns_none_for_short_array() {
let frame = array(vec![bulk("subscribe")]);
let result =
NamedPubSubConnection::<String>::extract_confirmation_channel(&frame, "subscribe");
assert!(result.is_none());
}
#[test]
fn parse_message_returns_channel_message() {
let frame = array(vec![bulk("message"), bulk("events"), bulk("payload")]);
let msg = PubSubConnection::parse_message(frame).unwrap().unwrap();
assert_eq!(msg.kind, MessageKind::Message);
assert_eq!(msg.channel, "events");
assert_eq!(msg.payload.as_ref(), b"payload");
assert!(msg.pattern.is_none());
}
#[test]
fn parse_message_returns_pmessage() {
let frame = array(vec![
bulk("pmessage"),
bulk("ev*"),
bulk("events"),
bulk("data"),
]);
let msg = PubSubConnection::parse_message(frame).unwrap().unwrap();
assert_eq!(msg.kind, MessageKind::PMessage);
assert_eq!(msg.channel, "events");
assert_eq!(msg.pattern, Some("ev*".to_string()));
}
#[test]
fn parse_message_skips_subscribe_confirmation() {
let frame = sub_confirmation("subscribe", "ch1", 1);
assert!(PubSubConnection::parse_message(frame).unwrap().is_none());
}
#[test]
fn is_confirmation_accepts_zero_count() {
let frame = array(vec![bulk("unsubscribe"), bulk("ch1"), Frame::Integer(0)]);
assert!(matches!(
NamedPubSubConnection::<String>::is_confirmation(&frame, "unsubscribe"),
Some(Ok(()))
));
}
#[test]
fn is_confirmation_accepts_nonzero_count() {
let frame = array(vec![bulk("unsubscribe"), bulk("ch1"), Frame::Integer(2)]);
assert!(matches!(
NamedPubSubConnection::<String>::is_confirmation(&frame, "unsubscribe"),
Some(Ok(()))
));
}
#[test]
fn is_confirmation_accepts_null_unsubscribe_name() {
let frame = array(vec![
bulk("unsubscribe"),
Frame::BulkString(None),
Frame::Integer(0),
]);
assert!(matches!(
NamedPubSubConnection::<String>::is_confirmation(&frame, "unsubscribe"),
Some(Ok(()))
));
}
#[test]
fn is_confirmation_accepts_resp3_null_unsubscribe_name() {
let frame = Frame::Push(vec![bulk("unsubscribe"), Frame::Null, Frame::Integer(0)]);
assert!(matches!(
NamedPubSubConnection::<String>::is_confirmation(&frame, "unsubscribe"),
Some(Ok(()))
));
}
#[tokio::test]
async fn subscribe_bypasses_existing_buffer_and_preserves_wire_messages() {
let (mut pubsub, mut server) = pubsub_pair().await;
pubsub
.inner
.buffered_frames
.push_back(message("events", "already-buffered"));
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("SUBSCRIBE"), bulk("new")])
);
server.send(message("events", "from-wire")).await.unwrap();
server
.send(sub_confirmation("subscribe", "new", 2))
.await
.unwrap();
});
tokio::time::timeout(Duration::from_secs(1), pubsub.subscribe(&["new"]))
.await
.expect("subscribe confirmation search cycled buffered data")
.unwrap();
server_task.await.unwrap();
let first = pubsub.next().await.unwrap().unwrap();
let second = pubsub.next().await.unwrap().unwrap();
assert_eq!(first.payload.as_ref(), b"already-buffered");
assert_eq!(second.payload.as_ref(), b"from-wire");
}
#[tokio::test]
async fn subscribe_rejects_empty_names_before_wire_io() {
let (mut pubsub, mut server) = pubsub_pair().await;
let error = pubsub.subscribe(&[]).await.unwrap_err();
assert!(error.to_string().contains("at least one name"));
assert!(
tokio::time::timeout(Duration::from_millis(20), server.next())
.await
.is_err(),
"empty subscribe unexpectedly wrote a command"
);
}
#[tokio::test]
async fn subscribe_deduplicates_names_before_wire_and_confirmation_wait() {
let (mut pubsub, mut server) = pubsub_pair().await;
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("SUBSCRIBE"), bulk("a"), bulk("b")])
);
server
.send(sub_confirmation("subscribe", "a", 1))
.await
.unwrap();
server
.send(sub_confirmation("subscribe", "b", 2))
.await
.unwrap();
});
tokio::time::timeout(
Duration::from_secs(1),
pubsub.subscribe(&["a", "a", "b", "a"]),
)
.await
.expect("duplicate subscribe names left an acknowledgement pending")
.unwrap();
server_task.await.unwrap();
assert_eq!(
pubsub
.subscriptions()
.channels
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
vec!["a", "b"]
);
}
#[tokio::test]
async fn unsubscribe_all_matches_family_names_and_preserves_interleaved_message() {
let (mut pubsub, mut server) = pubsub_pair().await;
NamedSubscriptions::add(
&mut pubsub.inner.subs.channels,
&[b"a".as_slice(), b"b".as_slice()],
);
NamedSubscriptions::add(
&mut pubsub.inner.subs.patterns,
&[b"still-active.*".as_slice()],
);
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("UNSUBSCRIBE")])
);
server
.send(sub_confirmation("unsubscribe", "a", 2))
.await
.unwrap();
server.send(message("a", "between-acks")).await.unwrap();
server
.send(sub_confirmation("unsubscribe", "b", 1))
.await
.unwrap();
});
tokio::time::timeout(Duration::from_secs(1), pubsub.unsubscribe(&[]))
.await
.expect("unsubscribe waited for an aggregate count of zero")
.unwrap();
server_task.await.unwrap();
assert!(pubsub.subscriptions().channels.is_empty());
assert_eq!(
pubsub
.subscriptions()
.patterns
.iter()
.next()
.map(String::as_str),
Some("still-active.*")
);
let buffered = pubsub.next().await.unwrap().unwrap();
assert_eq!(buffered.payload.as_ref(), b"between-acks");
}
#[tokio::test]
async fn unsubscribe_empty_family_accepts_resp3_null_ack_and_preserves_message() {
let (mut pubsub, mut server) = pubsub_pair().await;
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("UNSUBSCRIBE")])
);
server
.send(message("other", "before-null-ack"))
.await
.unwrap();
server
.send(Frame::Push(vec![
bulk("unsubscribe"),
Frame::Null,
Frame::Integer(0),
]))
.await
.unwrap();
});
tokio::time::timeout(Duration::from_secs(1), pubsub.unsubscribe(&[]))
.await
.unwrap()
.unwrap();
server_task.await.unwrap();
let buffered = pubsub.next().await.unwrap().unwrap();
assert_eq!(buffered.payload.as_ref(), b"before-null-ack");
}
#[tokio::test]
async fn unsubscribe_deduplicates_names_before_wire_and_confirmation_wait() {
let (mut pubsub, mut server) = pubsub_pair().await;
NamedSubscriptions::add(
&mut pubsub.inner.subs.channels,
&[b"a".as_slice(), b"b".as_slice()],
);
let server_task = tokio::spawn(async move {
assert_eq!(
server.next().await.unwrap().unwrap(),
array(vec![bulk("UNSUBSCRIBE"), bulk("a"), bulk("b")])
);
server
.send(sub_confirmation("unsubscribe", "a", 1))
.await
.unwrap();
server
.send(sub_confirmation("unsubscribe", "b", 0))
.await
.unwrap();
});
tokio::time::timeout(Duration::from_secs(1), pubsub.unsubscribe(&["a", "a", "b"]))
.await
.expect("duplicate unsubscribe names left an acknowledgement pending")
.unwrap();
server_task.await.unwrap();
assert!(pubsub.subscriptions().channels.is_empty());
}
#[tokio::test]
async fn failed_replacement_replay_does_not_install_partial_session() {
let (pubsub, mut original_server) = pubsub_pair().await;
let mut pubsub = pubsub.inner;
NamedSubscriptions::add(
&mut pubsub.subs.channels,
&[b"a".as_slice(), b"b".as_slice()],
);
pubsub
.buffered_frames
.push_back(message("old", "old-buffer"));
let (candidate, candidate_server) = redis_stream_pair().await;
let candidate = RedisConnection::from_stream(candidate);
let mut candidate_server =
Framed::new(candidate_server, redis_tower_protocol::RespCodec::new());
let candidate_task = tokio::spawn(async move {
assert_eq!(
candidate_server.next().await.unwrap().unwrap(),
array(vec![bulk("SUBSCRIBE"), bulk("a"), bulk("b")])
);
candidate_server
.send(sub_confirmation("subscribe", "a", 1))
.await
.unwrap();
candidate_server
.send(message("candidate", "must-not-leak"))
.await
.unwrap();
candidate_server
.send(Frame::Error(Bytes::from_static(b"ERR replay failed")))
.await
.unwrap();
});
let error = pubsub.install_replacement(candidate).await.unwrap_err();
assert!(error.to_string().contains("replay failed"));
candidate_task.await.unwrap();
original_server
.send(message("old", "old-wire"))
.await
.unwrap();
let buffered = pubsub.next().await.unwrap().unwrap();
let from_original_wire = pubsub.next().await.unwrap().unwrap();
assert_eq!(buffered.payload.as_ref(), b"old-buffer");
assert_eq!(from_original_wire.payload.as_ref(), b"old-wire");
assert_eq!(pubsub.subscriptions().channels.len(), 2);
}
#[tokio::test]
async fn reconnect_with_backoff_returns_final_error_after_zero_delay_budget() {
let (mut pubsub, _server) = pubsub_pair().await;
let calls = Arc::new(AtomicUsize::new(0));
let factory = {
let calls = Arc::clone(&calls);
move || {
calls.fetch_add(1, Ordering::SeqCst);
std::future::ready(Err::<RedisConnection, _>(RedisError::ConnectionClosed))
}
};
let config = ReconnectConfig::default()
.max_retries(2)
.base_delay(Duration::ZERO)
.max_delay(Duration::ZERO)
.jitter(false);
let error = tokio::time::timeout(
Duration::from_secs(1),
pubsub.reconnect_with_backoff(&factory, &config),
)
.await
.unwrap()
.unwrap_err();
assert_eq!(calls.load(Ordering::SeqCst), 3);
match error {
RedisError::ReconnectFailed {
attempts,
last_error,
} => {
assert_eq!(attempts, 3);
assert!(matches!(last_error.as_ref(), RedisError::ConnectionClosed));
}
other => panic!("expected ReconnectFailed, got {other:?}"),
}
}
#[tokio::test]
async fn reconnect_with_backoff_wraps_per_attempt_timeout() {
let (mut pubsub, _server) = pubsub_pair().await;
let factory =
|| async { futures::future::pending::<Result<RedisConnection, RedisError>>().await };
let config = ReconnectConfig::default()
.max_retries(0)
.base_delay(Duration::ZERO)
.max_delay(Duration::ZERO)
.jitter(false)
.connect_timeout(Duration::from_millis(10));
let error = tokio::time::timeout(
Duration::from_secs(1),
pubsub.reconnect_with_backoff(&factory, &config),
)
.await
.unwrap()
.unwrap_err();
match error {
RedisError::ReconnectFailed {
attempts,
last_error,
} => {
assert_eq!(attempts, 1);
assert!(matches!(last_error.as_ref(), RedisError::ConnectTimeout));
}
other => panic!("expected ReconnectFailed, got {other:?}"),
}
}
#[test]
fn subscriptions_add_accumulates_each_kind() {
let mut subs = Subscriptions::default();
assert!(subs.is_empty());
NamedSubscriptions::add(&mut subs.channels, &[b"a".as_slice(), b"b".as_slice()]);
NamedSubscriptions::add(&mut subs.patterns, &[b"p.*".as_slice()]);
NamedSubscriptions::add(&mut subs.shard_channels, &[b"s".as_slice()]);
NamedSubscriptions::add(&mut subs.channels, &[b"b".as_slice(), b"c".as_slice()]); assert!(!subs.is_empty());
assert_eq!(
subs.channels.iter().cloned().collect::<Vec<_>>(),
vec!["a", "b", "c"]
);
assert_eq!(subs.patterns.len(), 1);
assert_eq!(subs.shard_channels.len(), 1);
}
#[test]
fn subscriptions_remove_named_leaves_the_rest() {
let mut subs = Subscriptions::default();
NamedSubscriptions::add(
&mut subs.channels,
&[b"a".as_slice(), b"b".as_slice(), b"c".as_slice()],
);
NamedSubscriptions::remove(&mut subs.channels, &[b"b".as_slice()]);
assert_eq!(
subs.channels.iter().cloned().collect::<Vec<_>>(),
vec!["a", "c"]
);
}
#[test]
fn subscriptions_remove_empty_clears_that_kind_only() {
let mut subs = Subscriptions::default();
NamedSubscriptions::add(&mut subs.channels, &[b"a".as_slice(), b"b".as_slice()]);
NamedSubscriptions::add(&mut subs.patterns, &[b"p.*".as_slice()]);
NamedSubscriptions::remove(&mut subs.channels, &[]);
assert!(subs.channels.is_empty());
assert_eq!(subs.patterns.len(), 1);
assert!(!subs.is_empty());
}
#[test]
fn replay_frames_emits_one_command_per_nonempty_kind() {
let mut subs = Subscriptions::default();
NamedSubscriptions::add(&mut subs.channels, &[b"c1".as_slice(), b"c2".as_slice()]);
NamedSubscriptions::add(&mut subs.shard_channels, &[b"s1".as_slice()]);
let frames = subs.replay_frames();
assert_eq!(
frames,
vec![
array(vec![bulk("SUBSCRIBE"), bulk("c1"), bulk("c2")]),
array(vec![bulk("SSUBSCRIBE"), bulk("s1")]),
]
);
}
#[test]
fn replay_frames_is_empty_when_nothing_subscribed() {
assert!(Subscriptions::default().replay_frames().is_empty());
}
fn keyspace_pmessage(pattern: &str, channel: &str, payload: &str) -> Frame {
array(vec![
bulk("pmessage"),
bulk(pattern),
bulk(channel),
bulk(payload),
])
}
#[test]
fn keyspace_event_parses_keyspace_channel() {
let msg = PubSubConnection::parse_message(keyspace_pmessage(
"__keyspace@0__:*",
"__keyspace@0__:foo",
"set",
))
.unwrap()
.unwrap();
let event = KeyspaceEvent::from_message(&msg).unwrap();
assert_eq!(event.kind, NotificationKind::Keyspace);
assert_eq!(event.db, 0);
assert_eq!(event.key, "foo");
assert_eq!(event.event, "set");
}
#[test]
fn keyspace_event_parses_keyevent_channel() {
let msg = PubSubConnection::parse_message(keyspace_pmessage(
"__keyevent@3__:*",
"__keyevent@3__:expired",
"session:42",
))
.unwrap()
.unwrap();
let event = KeyspaceEvent::from_message(&msg).unwrap();
assert_eq!(event.kind, NotificationKind::Keyevent);
assert_eq!(event.db, 3);
assert_eq!(event.key, "session:42");
assert_eq!(event.event, "expired");
}
#[test]
fn keyspace_event_preserves_colons_in_key() {
let msg = PubSubConnection::parse_message(keyspace_pmessage(
"__keyspace@0__:*",
"__keyspace@0__:a:b:c",
"del",
))
.unwrap()
.unwrap();
let event = KeyspaceEvent::from_message(&msg).unwrap();
assert_eq!(event.key, "a:b:c");
assert_eq!(event.event, "del");
}
#[test]
fn keyspace_event_returns_none_for_ordinary_channel() {
let msg = PubSubConnection::parse_message(array(vec![
bulk("message"),
bulk("events"),
bulk("payload"),
]))
.unwrap()
.unwrap();
assert!(KeyspaceEvent::from_message(&msg).is_none());
}
#[test]
fn keyspace_event_returns_none_for_non_numeric_db() {
let msg = PubSubConnection::parse_message(keyspace_pmessage(
"__keyspace@x__:*",
"__keyspace@x__:foo",
"set",
))
.unwrap()
.unwrap();
assert!(KeyspaceEvent::from_message(&msg).is_none());
}
#[test]
fn keyspace_event_stream_filter_skips_non_keyspace() {
let plain = PubSubConnection::parse_message(array(vec![
bulk("message"),
bulk("events"),
bulk("hi"),
]))
.unwrap()
.unwrap();
assert!(KeyspaceEvent::from_message(&plain).is_none());
let ks = PubSubConnection::parse_message(keyspace_pmessage(
"__keyspace@0__:*",
"__keyspace@0__:k",
"lpush",
))
.unwrap()
.unwrap();
let event = KeyspaceEvent::from_message(&ks).unwrap();
assert_eq!(event.event, "lpush");
assert_eq!(event.key, "k");
}
}