use crate::redis::backend::reconnect_delay;
use crate::{DbError, RedisClient, RedisValue, Result};
use futures_util::StreamExt;
#[derive(Clone, PartialEq, Eq)]
pub struct RedisMessage {
pub channel: String,
pub payload: Vec<u8>,
pub pattern: Option<String>,
}
impl std::fmt::Debug for RedisMessage {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RedisMessage")
.field("channel", &self.channel)
.field("pattern", &self.pattern)
.field(
"payload",
&format!("<redacted {} bytes>", self.payload.len()),
)
.finish()
}
}
pub struct RedisPubSub {
client: redis::Client,
pubsub: redis::aio::PubSub,
channels: Vec<String>,
patterns: Vec<String>,
reconnect_retries: u32,
reconnect_max_delay_ms: u64,
}
impl RedisClient {
pub async fn pubsub(&self) -> Result<RedisPubSub> {
let client = self.direct_client()?.clone();
let pubsub = client.get_async_pubsub().await.map_err(DbError::from)?;
Ok(RedisPubSub {
client,
pubsub,
channels: Vec::new(),
patterns: Vec::new(),
reconnect_retries: self.config().reconnect_retries,
reconnect_max_delay_ms: self.config().reconnect_max_delay_ms,
})
}
pub async fn pubsub_channels(&self, pattern: Option<&str>) -> Result<Vec<String>> {
let mut cmd = redis::cmd("PUBSUB");
cmd.arg("CHANNELS");
if let Some(pattern) = pattern {
cmd.arg(pattern);
}
parse_string_array(&self.execute(&cmd).await?)
}
pub async fn pubsub_numsub(&self, channels: &[String]) -> Result<Vec<(String, i64)>> {
let mut cmd = redis::cmd("PUBSUB");
cmd.arg("NUMSUB");
for channel in channels {
cmd.arg(channel);
}
let value = self.execute(&cmd).await?;
let items = value.as_array().ok_or_else(|| {
DbError::RedisTypeConversionError("PUBSUB NUMSUB 结果不是数组".to_string())
})?;
if items.len() % 2 != 0 {
return Err(DbError::RedisTypeConversionError(
"PUBSUB NUMSUB 返回数量不是偶数".to_string(),
));
}
items
.chunks_exact(2)
.map(|pair| {
let channel = pair[0].as_string().ok_or_else(|| {
DbError::RedisTypeConversionError("PUBSUB NUMSUB 频道不是字符串".to_string())
})?;
let count = pair[1].as_i64().ok_or_else(|| {
DbError::RedisTypeConversionError("PUBSUB NUMSUB 计数不是整数".to_string())
})?;
Ok((channel, count))
})
.collect()
}
pub async fn pubsub_numpat(&self) -> Result<i64> {
let mut cmd = redis::cmd("PUBSUB");
cmd.arg("NUMPAT");
self.execute(&cmd)
.await?
.as_i64()
.ok_or_else(|| DbError::RedisTypeConversionError("PUBSUB NUMPAT 不是整数".to_string()))
}
}
impl RedisPubSub {
pub async fn subscribe(&mut self, channels: &[String]) -> Result<()> {
for channel in channels {
self.pubsub
.subscribe(channel.as_str())
.await
.map_err(DbError::from)?;
if !self.channels.contains(channel) {
self.channels.push(channel.clone());
}
}
Ok(())
}
pub async fn psubscribe(&mut self, patterns: &[String]) -> Result<()> {
for pattern in patterns {
self.pubsub
.psubscribe(pattern.as_str())
.await
.map_err(DbError::from)?;
if !self.patterns.contains(pattern) {
self.patterns.push(pattern.clone());
}
}
Ok(())
}
pub async fn unsubscribe(&mut self, channels: &[String]) -> Result<()> {
for channel in channels {
self.pubsub
.unsubscribe(channel.as_str())
.await
.map_err(DbError::from)?;
self.channels.retain(|item| item != channel);
}
Ok(())
}
pub async fn punsubscribe(&mut self, patterns: &[String]) -> Result<()> {
for pattern in patterns {
self.pubsub
.punsubscribe(pattern.as_str())
.await
.map_err(DbError::from)?;
self.patterns.retain(|item| item != pattern);
}
Ok(())
}
pub async fn next_message(&mut self) -> Result<Option<RedisMessage>> {
loop {
let message = {
let mut stream = self.pubsub.on_message();
stream.next().await
};
match message {
Some(message) => {
return Ok(Some(RedisMessage {
channel: message.get_channel_name().to_string(),
payload: message.get_payload_bytes().to_vec(),
pattern: message.get_pattern::<String>().ok(),
}));
}
None => {
log::warn!("Redis Pub/Sub 连接已断开,准备重连并重订阅");
self.reconnect().await?;
}
}
}
}
async fn reconnect(&mut self) -> Result<()> {
let mut attempt = 0u32;
loop {
attempt += 1;
match self.client.get_async_pubsub().await {
Ok(mut pubsub) => {
for channel in &self.channels {
pubsub
.subscribe(channel.as_str())
.await
.map_err(DbError::from)?;
}
for pattern in &self.patterns {
pubsub
.psubscribe(pattern.as_str())
.await
.map_err(DbError::from)?;
}
self.pubsub = pubsub;
return Ok(());
}
Err(error) if attempt <= self.reconnect_retries => {
let delay = reconnect_delay(attempt, self.reconnect_max_delay_ms);
log::warn!(
"Redis Pub/Sub 重连失败,第 {}/{} 次: {}",
attempt,
self.reconnect_retries,
error
);
tokio::time::sleep(delay).await;
}
Err(error) => return Err(DbError::from(error)),
}
}
}
}
fn parse_string_array(value: &RedisValue) -> Result<Vec<String>> {
let items = value
.as_array()
.ok_or_else(|| DbError::RedisTypeConversionError("Redis 结果不是数组".to_string()))?;
items
.iter()
.map(|item| {
item.as_string().ok_or_else(|| {
DbError::RedisTypeConversionError("Redis 数组包含非字符串元素".to_string())
})
})
.collect()
}