use std::sync::Arc;
use std::time::Duration;
use redis::FromRedisValue;
use tokio::sync::{mpsc, oneshot};
use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use crate::client::RedisClient;
use crate::config::PipelineCfg;
use crate::error::{NasaRedisError, Result};
const H_DECR_BY_AND_DEL_LUA: &str = r#"
local k = KEYS[1]
local hk = ARGV[1]
local delta = ARGV[2]
local increment
-- 调用入口已校验有符号范围;这里只改变文本符号,不让完整整数经过 Lua 浮点数。
if delta == '0' then
increment = '0'
elseif string.sub(delta, 1, 1) == '-' then
increment = string.sub(delta, 2)
else
increment = '-' .. delta
end
-- 精确回读要求 HGET 权限;先执行只读检查,避免因缺少读取权限而在减量之后留下失败结果。
redis.call('HGET', k, hk)
-- HINCRBY 负责整数合法性和溢出裁决;忽略其 Lua 数字回包,从持久字段读取精确十进制结果。
redis.call('HINCRBY', k, hk, increment)
local value = redis.call('HGET', k, hk)
if value == '0' or string.sub(value, 1, 1) == '-' then
-- 先保留余值再删除字段,使最后一个字段被删时仍能返回本次更新结果。
redis.call('HDEL', k, hk)
end
return value
"#;
#[derive(Debug, Clone)]
enum TicketErr {
Server(redis::ServerError),
Unknown(String),
NotSent,
}
pub struct Ticket<T> {
rx: oneshot::Receiver<std::result::Result<redis::Value, TicketErr>>,
reply_check: ReplyCheck,
_t: std::marker::PhantomData<T>,
}
enum ReplyCheck {
General,
PublishCount,
StreamId,
StreamAck {
requested: usize,
},
}
impl<T: FromRedisValue> Ticket<T> {
fn ready(v: redis::Value) -> Ticket<T> {
let (tx, rx) = oneshot::channel();
let _ = tx.send(Ok(v));
Ticket {
rx,
reply_check: ReplyCheck::General,
_t: std::marker::PhantomData,
}
}
pub fn await_result(mut self) -> Result<T> {
match self.rx.try_recv() {
Ok(Ok(v)) => {
match self.reply_check {
ReplyCheck::General => {}
ReplyCheck::PublishCount => crate::pubsub::check_publish_count_reply(&v)?,
ReplyCheck::StreamId => crate::stream::check_stream_id_reply(&v, "*")?,
ReplyCheck::StreamAck {
requested,
} => {
crate::stream::check_stream_ack_reply(&v, requested)?;
}
}
Ok(T::from_redis_value(v)?)
}
Ok(Err(TicketErr::Server(e))) => Err(NasaRedisError::Redis(e.into())),
Ok(Err(TicketErr::Unknown(msg))) => Err(NasaRedisError::ExecutionUnknown(msg)),
Ok(Err(TicketErr::NotSent)) => Err(NasaRedisError::NotExecuted(
"PipelineSession 尾批尚未派发即被释放,命令确定未发送".into(),
)),
Err(oneshot::error::TryRecvError::Closed) => Err(NasaRedisError::ExecutionUnknown(
"ticket 通道关闭(execute 被取消或未送达,命令可能已发到服务端执行)".into(),
)),
Err(oneshot::error::TryRecvError::Empty) => Err(NasaRedisError::SessionLimit(
"execute() 之前不可取结果".into(),
)),
}
}
}
pub struct PipelineSession {
client: Arc<RedisClient>,
cfg: PipelineCfg,
cmds: Vec<(
redis::Cmd,
oneshot::Sender<std::result::Result<redis::Value, TicketErr>>,
)>,
bytes: usize,
flush_chain: Option<JoinHandle<Result<()>>>,
auto_flush: bool,
executed: bool,
}
impl RedisClient {
pub fn pipeline(self: &Arc<Self>) -> PipelineSession {
PipelineSession {
client: Arc::clone(self),
cfg: self.config().pipeline.clone(),
cmds: Vec::new(),
bytes: 0,
flush_chain: None,
auto_flush: true,
executed: false,
}
}
pub(crate) fn deferred_pipeline(self: &Arc<Self>) -> PipelineSession {
let mut session = self.pipeline();
session.auto_flush = false;
session
}
}
impl PipelineSession {
pub fn enqueue<T: FromRedisValue>(&mut self, cmd: redis::Cmd) -> Result<Ticket<T>> {
let sz: usize = cmd
.args_iter()
.map(|a| match a {
redis::Arg::Simple(b) => b.len(),
_ => 8,
})
.sum();
if !self.auto_flush
&& (self.cmds.len() >= self.cfg.session_max_commands
|| self
.bytes
.checked_add(sz)
.is_none_or(|total| total > self.cfg.session_max_bytes))
{
return Err(NasaRedisError::SessionLimit(
"延迟提交会话已达到 session_max_commands 或 session_max_bytes,尚未发送任何命令"
.to_owned(),
));
}
let (tx, rx) = oneshot::channel();
self.bytes += sz;
self.cmds.push((cmd, tx));
if self.auto_flush
&& (self.cmds.len() >= self.cfg.session_max_commands
|| self.bytes >= self.cfg.session_max_bytes)
{
self.seal_and_flush();
}
Ok(Ticket {
rx,
reply_check: ReplyCheck::General,
_t: std::marker::PhantomData,
})
}
fn seal_and_flush(&mut self) {
let Ok(handle) = tokio::runtime::Handle::try_current() else {
return;
};
let batch = std::mem::take(&mut self.cmds);
self.bytes = 0;
if batch.is_empty() {
return;
}
let client = Arc::clone(&self.client);
let prev = self.flush_chain.take();
self.flush_chain = Some(handle.spawn(async move {
let prev_res = match prev {
Some(p) => p.await.unwrap_or_else(join_err_to_unknown),
None => Ok(()),
};
let own = dispatch_jobs(&client, batch).await;
prev_res.and(own)
}));
}
pub fn get<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("GET").arg(key).to_owned())
}
pub fn set<V: redis::ToSingleRedisArg>(&mut self, key: &str, val: V) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("SET").arg(key).arg(val).to_owned())
}
pub fn h_set<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
field: &str,
val: V,
) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("HSET").arg(key).arg(field).arg(val).to_owned())
}
pub fn h_get<T: FromRedisValue>(
&mut self,
key: &str,
field: &str,
) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("HGET").arg(key).arg(field).to_owned())
}
pub fn del(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("DEL").arg(key).to_owned())
}
pub fn incr_by(&mut self, key: &str, delta: i64) -> Result<Ticket<i64>> {
self.enqueue(redis::cmd("INCRBY").arg(key).arg(delta).to_owned())
}
pub fn z_add<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
score: f64,
member: V,
) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("ZADD")
.arg(key)
.arg(score)
.arg(member)
.to_owned(),
)
}
pub fn x_add(&mut self, stream: &str, fields: &[(&str, &[u8])]) -> Result<Ticket<String>> {
let mut c = redis::cmd("XADD");
c.arg(stream).arg("*");
for (f, v) in fields {
c.arg(*f).arg(*v);
}
let mut ticket = self.enqueue(c)?;
ticket.reply_check = ReplyCheck::StreamId;
Ok(ticket)
}
pub fn expire(&mut self, key: &str, ttl: Duration) -> Result<Ticket<bool>> {
let ms = crate::commands::duration_to_millis_floor1(ttl)?;
self.enqueue(redis::cmd("PEXPIRE").arg(key).arg(ms).to_owned())
}
pub fn expire_at_secs(&mut self, key: &str, unix_secs: i64) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("EXPIREAT").arg(key).arg(unix_secs).to_owned())
}
pub fn expire_at_millis(&mut self, key: &str, unix_ms: i64) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("PEXPIREAT").arg(key).arg(unix_ms).to_owned())
}
pub fn persist(&mut self, key: &str) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("PERSIST").arg(key).to_owned())
}
pub fn exists(&mut self, key: &str) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("EXISTS").arg(key).to_owned())
}
pub fn pttl(&mut self, key: &str) -> Result<Ticket<i64>> {
self.enqueue(redis::cmd("PTTL").arg(key).to_owned())
}
pub fn set_nx<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("SETNX").arg(key).arg(val).to_owned())
}
pub fn set_ttl<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
ttl_ms: u64,
) -> Result<Ticket<()>> {
self.enqueue(
redis::cmd("SET")
.arg(key)
.arg(val)
.arg("PX")
.arg(ttl_ms)
.to_owned(),
)
}
pub fn append<V: redis::ToSingleRedisArg>(&mut self, key: &str, val: V) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("APPEND").arg(key).arg(val).to_owned())
}
pub fn get_set<T: FromRedisValue, V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("GETSET").arg(key).arg(val).to_owned())
}
pub fn get_del<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("GETDEL").arg(key).to_owned())
}
pub fn str_len(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("STRLEN").arg(key).to_owned())
}
pub fn mget<T: FromRedisValue>(&mut self, keys: &[&str]) -> Result<Ticket<Vec<Option<T>>>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("MGET");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn h_del(&mut self, key: &str, fields: &[&str]) -> Result<Ticket<u64>> {
if fields.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("HDEL");
c.arg(key);
for f in fields {
c.arg(*f);
}
self.enqueue(c)
}
pub fn h_set_nx<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
field: &str,
val: V,
) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("HSETNX").arg(key).arg(field).arg(val).to_owned())
}
pub fn h_incr_by(&mut self, key: &str, field: &str, delta: i64) -> Result<Ticket<i64>> {
self.enqueue(
redis::cmd("HINCRBY")
.arg(key)
.arg(field)
.arg(delta)
.to_owned(),
)
}
pub fn h_get_all<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<T>> {
self.enqueue(redis::cmd("HGETALL").arg(key).to_owned())
}
pub fn h_mget<T: FromRedisValue>(
&mut self,
key: &str,
fields: &[&str],
) -> Result<Ticket<Vec<Option<T>>>> {
if fields.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("HMGET");
c.arg(key);
for f in fields {
c.arg(*f);
}
self.enqueue(c)
}
pub fn h_keys(&mut self, key: &str) -> Result<Ticket<Vec<String>>> {
self.enqueue(redis::cmd("HKEYS").arg(key).to_owned())
}
pub fn h_len(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("HLEN").arg(key).to_owned())
}
pub fn l_push<V: redis::ToSingleRedisArg>(&mut self, key: &str, val: V) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("LPUSH").arg(key).arg(val).to_owned())
}
pub fn r_push<V: redis::ToSingleRedisArg>(&mut self, key: &str, val: V) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("RPUSH").arg(key).arg(val).to_owned())
}
pub fn l_pop<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("LPOP").arg(key).to_owned())
}
pub fn r_pop<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("RPOP").arg(key).to_owned())
}
pub fn l_range<T: FromRedisValue>(
&mut self,
key: &str,
start: isize,
stop: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("LRANGE")
.arg(key)
.arg(start)
.arg(stop)
.to_owned(),
)
}
pub fn l_rem<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
count: isize,
val: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("LREM").arg(key).arg(count).arg(val).to_owned())
}
pub fn l_len(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("LLEN").arg(key).to_owned())
}
pub fn l_trim(&mut self, key: &str, start: isize, stop: isize) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("LTRIM").arg(key).arg(start).arg(stop).to_owned())
}
pub fn s_add<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("SADD").arg(key).arg(member).to_owned())
}
pub fn s_rem<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("SREM").arg(key).arg(member).to_owned())
}
pub fn s_card(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("SCARD").arg(key).to_owned())
}
pub fn s_members<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("SMEMBERS").arg(key).to_owned())
}
pub fn s_is_member<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("SISMEMBER").arg(key).arg(member).to_owned())
}
pub fn s_pop<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("SPOP").arg(key).to_owned())
}
pub fn z_rem<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("ZREM").arg(key).arg(member).to_owned())
}
pub fn z_card(&mut self, key: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("ZCARD").arg(key).to_owned())
}
pub fn z_score<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<Option<f64>>> {
self.enqueue(redis::cmd("ZSCORE").arg(key).arg(member).to_owned())
}
pub fn z_rank<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<Option<u64>>> {
self.enqueue(redis::cmd("ZRANK").arg(key).arg(member).to_owned())
}
pub fn z_rev_rank<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
member: V,
) -> Result<Ticket<Option<u64>>> {
self.enqueue(redis::cmd("ZREVRANK").arg(key).arg(member).to_owned())
}
pub fn z_count(&mut self, key: &str, min: f64, max: f64) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("ZCOUNT").arg(key).arg(min).arg(max).to_owned())
}
pub fn z_incr_by<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
delta: f64,
member: V,
) -> Result<Ticket<f64>> {
self.enqueue(
redis::cmd("ZINCRBY")
.arg(key)
.arg(delta)
.arg(member)
.to_owned(),
)
}
pub fn z_range_by_score<T: FromRedisValue>(
&mut self,
key: &str,
min: f64,
max: f64,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZRANGEBYSCORE")
.arg(key)
.arg(min)
.arg(max)
.to_owned(),
)
}
pub fn x_del(&mut self, stream: &str, ids: &[&str]) -> Result<Ticket<u64>> {
if ids.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("XDEL");
c.arg(stream);
for id in ids {
c.arg(*id);
}
self.enqueue(c)
}
pub fn x_ack(&mut self, stream: &str, group: &str, ids: &[&str]) -> Result<Ticket<u64>> {
if ids.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("XACK");
c.arg(stream).arg(group);
for id in ids {
c.arg(*id);
}
let mut ticket = self.enqueue(c)?;
ticket.reply_check = ReplyCheck::StreamAck {
requested: ids.len(),
};
Ok(ticket)
}
pub fn x_len(&mut self, stream: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("XLEN").arg(stream).to_owned())
}
pub fn x_trim_maxlen(&mut self, stream: &str, maxlen: u64) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("XTRIM")
.arg(stream)
.arg("MAXLEN")
.arg(maxlen)
.to_owned(),
)
}
pub fn x_trim_maxlen_approx(&mut self, stream: &str, maxlen: u64) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("XTRIM")
.arg(stream)
.arg("MAXLEN")
.arg("~")
.arg(maxlen)
.to_owned(),
)
}
pub fn eval<T: FromRedisValue>(
&mut self,
script: &str,
keys: &[&str],
args: &[&str],
) -> Result<Ticket<T>> {
let mut c = redis::cmd("EVAL");
c.arg(script).arg(keys.len());
for k in keys {
c.arg(*k);
}
for a in args {
c.arg(*a);
}
self.enqueue(c)
}
pub fn eval_sha<T: FromRedisValue>(
&mut self,
sha: &str,
keys: &[&str],
args: &[&str],
) -> Result<Ticket<T>> {
let mut c = redis::cmd("EVALSHA");
c.arg(sha).arg(keys.len());
for k in keys {
c.arg(*k);
}
for a in args {
c.arg(*a);
}
self.enqueue(c)
}
pub fn ttl(&mut self, key: &str) -> Result<Ticket<i64>> {
self.enqueue(redis::cmd("TTL").arg(key).to_owned())
}
pub fn key_type(&mut self, key: &str) -> Result<Ticket<String>> {
self.enqueue(redis::cmd("TYPE").arg(key).to_owned())
}
pub fn keys(&mut self, pattern: &str) -> Result<Ticket<Vec<String>>> {
self.enqueue(redis::cmd("KEYS").arg(pattern).to_owned())
}
pub fn dump(&mut self, key: &str) -> Result<Ticket<Option<Vec<u8>>>> {
self.enqueue(redis::cmd("DUMP").arg(key).to_owned())
}
pub fn del_multi(&mut self, keys: &[&str]) -> Result<Ticket<u64>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("DEL");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn exists_multi(&mut self, keys: &[&str]) -> Result<Ticket<u64>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("EXISTS");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn set_range<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
offset: u64,
val: V,
) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("SETRANGE")
.arg(key)
.arg(offset)
.arg(val)
.to_owned(),
)
}
pub fn get_range(&mut self, key: &str, start: isize, end: isize) -> Result<Ticket<String>> {
self.enqueue(
redis::cmd("GETRANGE")
.arg(key)
.arg(start)
.arg(end)
.to_owned(),
)
}
pub fn decr_by(&mut self, key: &str, delta: i64) -> Result<Ticket<i64>> {
self.enqueue(redis::cmd("DECRBY").arg(key).arg(delta).to_owned())
}
pub fn incr_by_float(&mut self, key: &str, delta: f64) -> Result<Ticket<f64>> {
self.enqueue(redis::cmd("INCRBYFLOAT").arg(key).arg(delta).to_owned())
}
pub fn mset(&mut self, pairs: &[(&str, &[u8])]) -> Result<Ticket<()>> {
if pairs.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("MSET");
for (k, v) in pairs {
c.arg(*k).arg(*v);
}
self.enqueue(c)
}
pub fn multi_set_split(&mut self, pairs: &[(&str, &[u8])]) -> Result<Vec<Ticket<()>>> {
let mut tickets = Vec::with_capacity(pairs.len());
for (k, v) in pairs {
tickets.push(self.enqueue(redis::cmd("SET").arg(*k).arg(*v).to_owned())?);
}
Ok(tickets)
}
pub fn h_m_set(&mut self, key: &str, pairs: &[(&str, &[u8])]) -> Result<Ticket<()>> {
if pairs.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("HSET");
c.arg(key);
for (f, v) in pairs {
c.arg(*f).arg(*v);
}
self.enqueue(c)
}
pub fn h_exists(&mut self, key: &str, field: &str) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("HEXISTS").arg(key).arg(field).to_owned())
}
pub fn h_vals<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("HVALS").arg(key).to_owned())
}
pub fn h_rand_field(&mut self, key: &str) -> Result<Ticket<Option<String>>> {
self.enqueue(redis::cmd("HRANDFIELD").arg(key).to_owned())
}
pub fn h_incr_by_float(&mut self, key: &str, field: &str, delta: f64) -> Result<Ticket<f64>> {
self.enqueue(
redis::cmd("HINCRBYFLOAT")
.arg(key)
.arg(field)
.arg(delta)
.to_owned(),
)
}
pub fn h_decr_by(&mut self, key: &str, field: &str, delta: i64) -> Result<Ticket<i64>> {
let increment = delta.checked_neg().ok_or_else(|| {
NasaRedisError::Config("h_decr_by: delta 无法在 i64 范围内取负".into())
})?;
self.enqueue(
redis::cmd("HINCRBY")
.arg(key)
.arg(field)
.arg(increment)
.to_owned(),
)
}
pub fn l_push_multi(&mut self, key: &str, vals: &[&[u8]]) -> Result<Ticket<u64>> {
if vals.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("LPUSH");
c.arg(key);
for v in vals {
c.arg(*v);
}
self.enqueue(c)
}
pub fn r_push_multi(&mut self, key: &str, vals: &[&[u8]]) -> Result<Ticket<u64>> {
if vals.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("RPUSH");
c.arg(key);
for v in vals {
c.arg(*v);
}
self.enqueue(c)
}
pub fn l_push_if_absent<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("LPUSHX").arg(key).arg(val).to_owned())
}
pub fn r_push_if_absent<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("RPUSHX").arg(key).arg(val).to_owned())
}
pub fn l_index<T: FromRedisValue>(
&mut self,
key: &str,
index: isize,
) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("LINDEX").arg(key).arg(index).to_owned())
}
pub fn l_pos<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
val: V,
) -> Result<Ticket<Option<i64>>> {
self.enqueue(redis::cmd("LPOS").arg(key).arg(val).to_owned())
}
pub fn l_set<V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
index: isize,
val: V,
) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("LSET").arg(key).arg(index).arg(val).to_owned())
}
pub fn l_insert_before<P: redis::ToSingleRedisArg, V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
pivot: P,
val: V,
) -> Result<Ticket<i64>> {
self.enqueue(
redis::cmd("LINSERT")
.arg(key)
.arg("BEFORE")
.arg(pivot)
.arg(val)
.to_owned(),
)
}
pub fn l_insert_after<P: redis::ToSingleRedisArg, V: redis::ToSingleRedisArg>(
&mut self,
key: &str,
pivot: P,
val: V,
) -> Result<Ticket<i64>> {
self.enqueue(
redis::cmd("LINSERT")
.arg(key)
.arg("AFTER")
.arg(pivot)
.arg(val)
.to_owned(),
)
}
pub fn s_add_multi(&mut self, key: &str, members: &[&[u8]]) -> Result<Ticket<u64>> {
if members.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("SADD");
c.arg(key);
for m in members {
c.arg(*m);
}
self.enqueue(c)
}
pub fn s_rem_multi(&mut self, key: &str, members: &[&[u8]]) -> Result<Ticket<u64>> {
if members.is_empty() {
return Ok(Ticket::ready(redis::Value::Int(0)));
}
let mut c = redis::cmd("SREM");
c.arg(key);
for m in members {
c.arg(*m);
}
self.enqueue(c)
}
pub fn s_move<V: redis::ToSingleRedisArg>(
&mut self,
src: &str,
dst: &str,
member: V,
) -> Result<Ticket<bool>> {
self.enqueue(redis::cmd("SMOVE").arg(src).arg(dst).arg(member).to_owned())
}
pub fn s_mis_member(&mut self, key: &str, members: &[&[u8]]) -> Result<Ticket<Vec<bool>>> {
if members.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("SMISMEMBER");
c.arg(key);
for m in members {
c.arg(*m);
}
self.enqueue(c)
}
pub fn s_rand_member<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("SRANDMEMBER").arg(key).to_owned())
}
pub fn s_diff<T: FromRedisValue>(&mut self, keys: &[&str]) -> Result<Ticket<Vec<T>>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("SDIFF");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn s_inter<T: FromRedisValue>(&mut self, keys: &[&str]) -> Result<Ticket<Vec<T>>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("SINTER");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn s_union<T: FromRedisValue>(&mut self, keys: &[&str]) -> Result<Ticket<Vec<T>>> {
if keys.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("SUNION");
for k in keys {
c.arg(*k);
}
self.enqueue(c)
}
pub fn z_rem_range(&mut self, key: &str, start: isize, stop: isize) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("ZREMRANGEBYRANK")
.arg(key)
.arg(start)
.arg(stop)
.to_owned(),
)
}
pub fn z_rem_range_by_lex(&mut self, key: &str, min: &str, max: &str) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("ZREMRANGEBYLEX")
.arg(key)
.arg(min)
.arg(max)
.to_owned(),
)
}
pub fn z_rem_range_by_score(&mut self, key: &str, min: f64, max: f64) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("ZREMRANGEBYSCORE")
.arg(key)
.arg(min)
.arg(max)
.to_owned(),
)
}
pub fn z_m_score(&mut self, key: &str, members: &[&[u8]]) -> Result<Ticket<Vec<Option<f64>>>> {
if members.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("ZMSCORE");
c.arg(key);
for m in members {
c.arg(*m);
}
self.enqueue(c)
}
pub fn z_lex_count(&mut self, key: &str, min: &str, max: &str) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("ZLEXCOUNT")
.arg(key)
.arg(min)
.arg(max)
.to_owned(),
)
}
pub fn z_range<T: FromRedisValue>(
&mut self,
key: &str,
start: isize,
stop: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZRANGE")
.arg(key)
.arg(start)
.arg(stop)
.to_owned(),
)
}
pub fn z_rev_range<T: FromRedisValue>(
&mut self,
key: &str,
start: isize,
stop: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZREVRANGE")
.arg(key)
.arg(start)
.arg(stop)
.to_owned(),
)
}
pub fn z_range_with_scores<T: FromRedisValue>(
&mut self,
key: &str,
start: isize,
stop: isize,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(
redis::cmd("ZRANGE")
.arg(key)
.arg(start)
.arg(stop)
.arg("WITHSCORES")
.to_owned(),
)
}
pub fn z_rev_range_with_scores<T: FromRedisValue>(
&mut self,
key: &str,
start: isize,
stop: isize,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(
redis::cmd("ZREVRANGE")
.arg(key)
.arg(start)
.arg(stop)
.arg("WITHSCORES")
.to_owned(),
)
}
pub fn z_range_by_score_with_scores<T: FromRedisValue>(
&mut self,
key: &str,
min: f64,
max: f64,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(
redis::cmd("ZRANGEBYSCORE")
.arg(key)
.arg(min)
.arg(max)
.arg("WITHSCORES")
.to_owned(),
)
}
pub fn z_rev_range_by_score<T: FromRedisValue>(
&mut self,
key: &str,
max: f64,
min: f64,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZREVRANGEBYSCORE")
.arg(key)
.arg(max)
.arg(min)
.to_owned(),
)
}
pub fn z_rev_range_by_score_with_scores<T: FromRedisValue>(
&mut self,
key: &str,
max: f64,
min: f64,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(
redis::cmd("ZREVRANGEBYSCORE")
.arg(key)
.arg(max)
.arg(min)
.arg("WITHSCORES")
.to_owned(),
)
}
pub fn z_range_by_lex<T: FromRedisValue>(
&mut self,
key: &str,
min: &str,
max: &str,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZRANGEBYLEX")
.arg(key)
.arg(min)
.arg(max)
.to_owned(),
)
}
pub fn z_pop_min<T: FromRedisValue>(
&mut self,
key: &str,
count: usize,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(redis::cmd("ZPOPMIN").arg(key).arg(count).to_owned())
}
pub fn z_pop_max<T: FromRedisValue>(
&mut self,
key: &str,
count: usize,
) -> Result<Ticket<Vec<(T, f64)>>> {
self.enqueue(redis::cmd("ZPOPMAX").arg(key).arg(count).to_owned())
}
pub fn z_rand_member<T: FromRedisValue>(&mut self, key: &str) -> Result<Ticket<Option<T>>> {
self.enqueue(redis::cmd("ZRANDMEMBER").arg(key).to_owned())
}
pub fn x_trim_minid(&mut self, stream: &str, minid: &str) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("XTRIM")
.arg(stream)
.arg("MINID")
.arg(minid)
.to_owned(),
)
}
pub fn x_trim_minid_approx(&mut self, stream: &str, minid: &str) -> Result<Ticket<u64>> {
self.enqueue(
redis::cmd("XTRIM")
.arg(stream)
.arg("MINID")
.arg("~")
.arg(minid)
.to_owned(),
)
}
pub fn script_flush(&mut self) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("SCRIPT").arg("FLUSH").to_owned())
}
pub fn script_kill(&mut self) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("SCRIPT").arg("KILL").to_owned())
}
pub fn script_load(&mut self, script: &str) -> Result<Ticket<String>> {
self.enqueue(redis::cmd("SCRIPT").arg("LOAD").arg(script).to_owned())
}
pub fn script_exists(&mut self, shas: &[&str]) -> Result<Ticket<Vec<bool>>> {
if shas.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let mut c = redis::cmd("SCRIPT");
c.arg("EXISTS");
for s in shas {
c.arg(*s);
}
self.enqueue(c)
}
pub fn l_pop_count<T: FromRedisValue>(
&mut self,
key: &str,
count: usize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("LPOP").arg(key).arg(count).to_owned())
}
pub fn r_pop_count<T: FromRedisValue>(
&mut self,
key: &str,
count: usize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("RPOP").arg(key).arg(count).to_owned())
}
pub fn s_pop_count<T: FromRedisValue>(
&mut self,
key: &str,
count: usize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("SPOP").arg(key).arg(count).to_owned())
}
pub fn s_rand_member_count<T: FromRedisValue>(
&mut self,
key: &str,
count: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("SRANDMEMBER").arg(key).arg(count).to_owned())
}
pub fn z_rand_member_count<T: FromRedisValue>(
&mut self,
key: &str,
count: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(redis::cmd("ZRANDMEMBER").arg(key).arg(count).to_owned())
}
pub fn h_rand_field_count(&mut self, key: &str, count: isize) -> Result<Ticket<Vec<String>>> {
self.enqueue(redis::cmd("HRANDFIELD").arg(key).arg(count).to_owned())
}
pub fn z_range_by_score_limit<T: FromRedisValue>(
&mut self,
key: &str,
min: &str,
max: &str,
offset: isize,
count: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZRANGEBYSCORE")
.arg(key)
.arg(min)
.arg(max)
.arg("LIMIT")
.arg(offset)
.arg(count)
.to_owned(),
)
}
pub fn z_rev_range_by_score_limit<T: FromRedisValue>(
&mut self,
key: &str,
max: &str,
min: &str,
offset: isize,
count: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZREVRANGEBYSCORE")
.arg(key)
.arg(max)
.arg(min)
.arg("LIMIT")
.arg(offset)
.arg(count)
.to_owned(),
)
}
pub fn z_range_by_lex_limit<T: FromRedisValue>(
&mut self,
key: &str,
min: &str,
max: &str,
offset: isize,
count: isize,
) -> Result<Ticket<Vec<T>>> {
self.enqueue(
redis::cmd("ZRANGEBYLEX")
.arg(key)
.arg(min)
.arg(max)
.arg("LIMIT")
.arg(offset)
.arg(count)
.to_owned(),
)
}
pub fn x_range<T: FromRedisValue>(
&mut self,
key: &str,
start: &str,
end: &str,
) -> Result<Ticket<T>> {
self.enqueue(redis::cmd("XRANGE").arg(key).arg(start).arg(end).to_owned())
}
pub fn x_range_count<T: FromRedisValue>(
&mut self,
key: &str,
start: &str,
end: &str,
count: usize,
) -> Result<Ticket<T>> {
self.enqueue(
redis::cmd("XRANGE")
.arg(key)
.arg(start)
.arg(end)
.arg("COUNT")
.arg(count)
.to_owned(),
)
}
pub fn x_rev_range<T: FromRedisValue>(
&mut self,
key: &str,
end: &str,
start: &str,
) -> Result<Ticket<T>> {
self.enqueue(
redis::cmd("XREVRANGE")
.arg(key)
.arg(end)
.arg(start)
.to_owned(),
)
}
pub fn x_rev_range_count<T: FromRedisValue>(
&mut self,
key: &str,
end: &str,
start: &str,
count: usize,
) -> Result<Ticket<T>> {
self.enqueue(
redis::cmd("XREVRANGE")
.arg(key)
.arg(end)
.arg(start)
.arg("COUNT")
.arg(count)
.to_owned(),
)
}
pub fn publish_channel<V: redis::ToSingleRedisArg>(
&mut self,
channel: &str,
message: V,
) -> Result<Ticket<u64>> {
let mut ticket =
self.enqueue(redis::cmd("PUBLISH").arg(channel).arg(message).to_owned())?;
ticket.reply_check = ReplyCheck::PublishCount;
Ok(ticket)
}
pub fn publish<T: serde::Serialize>(
&mut self,
stream: &str,
event: &str,
message: &T,
) -> Result<Ticket<String>> {
let body = crate::stream::stream_publish_body(stream, event, message)?;
let mut ticket = self.enqueue(
redis::cmd("XADD")
.arg(stream)
.arg("*")
.arg(event)
.arg(body)
.to_owned(),
)?;
ticket.reply_check = ReplyCheck::StreamId;
Ok(ticket)
}
pub fn publish_default<T: serde::Serialize>(
&mut self,
stream: &str,
message: &T,
) -> Result<Ticket<String>> {
self.publish(stream, crate::stream::STREAM_EVENT, message)
}
pub fn publish_stream<T: serde::Serialize>(
&mut self,
stream: &str,
event: &str,
data: &T,
) -> Result<Ticket<String>> {
self.publish(stream, event, data)
}
pub fn publish_stream_default<T: serde::Serialize>(
&mut self,
stream: &str,
data: &T,
) -> Result<Ticket<String>> {
self.publish_default(stream, data)
}
pub fn h_decr_by_and_del(&mut self, key: &str, field: &str, delta: i64) -> Result<Ticket<i64>> {
delta.checked_neg().ok_or_else(|| {
NasaRedisError::Config("h_decr_by_and_del: delta 无法在 i64 范围内取负".into())
})?;
self.enqueue(
redis::cmd("EVAL")
.arg(H_DECR_BY_AND_DEL_LUA)
.arg(1)
.arg(key)
.arg(field)
.arg(delta)
.to_owned(),
)
}
pub fn h_decr_by_and_del_one(&mut self, key: &str, field: &str) -> Result<Ticket<i64>> {
self.h_decr_by_and_del(key, field, 1)
}
pub fn h_expire(&mut self, key: &str, field: &str, ttl: Duration) -> Result<Ticket<Vec<i64>>> {
let seconds = crate::commands::duration_to_redis_seconds(ttl)?;
self.enqueue(
redis::cmd("HEXPIRE")
.arg(key)
.arg(seconds)
.arg("FIELDS")
.arg(1)
.arg(field)
.to_owned(),
)
}
pub fn h_expire_multi(
&mut self,
key: &str,
fields: &[&str],
ttl: Duration,
) -> Result<Ticket<Vec<i64>>> {
if fields.is_empty() {
return Ok(Ticket::ready(redis::Value::Array(vec![])));
}
let seconds = crate::commands::duration_to_redis_seconds(ttl)?;
let mut c = redis::cmd("HEXPIRE");
c.arg(key).arg(seconds).arg("FIELDS").arg(fields.len());
for f in fields {
c.arg(*f);
}
self.enqueue(c)
}
#[cfg(feature = "search")]
pub fn json_set(&mut self, key: &str, path: &str, json: &str) -> Result<Ticket<()>> {
self.enqueue(
redis::cmd("JSON.SET")
.arg(key)
.arg(path)
.arg(json)
.to_owned(),
)
}
#[cfg(feature = "search")]
pub fn json_get(&mut self, key: &str, path: &str) -> Result<Ticket<Option<String>>> {
self.enqueue(redis::cmd("JSON.GET").arg(key).arg(path).to_owned())
}
#[cfg(feature = "search")]
pub fn json_del(&mut self, key: &str, path: &str) -> Result<Ticket<u64>> {
self.enqueue(redis::cmd("JSON.DEL").arg(key).arg(path).to_owned())
}
#[cfg(feature = "search")]
pub fn json_num_incr_by(
&mut self,
key: &str,
path: &str,
delta: i64,
) -> Result<Ticket<String>> {
self.enqueue(
redis::cmd("JSON.NUMINCRBY")
.arg(key)
.arg(path)
.arg(delta)
.to_owned(),
)
}
#[cfg(feature = "search")]
pub fn json_num_incr_by_f64(
&mut self,
key: &str,
path: &str,
delta: f64,
) -> Result<Ticket<String>> {
self.enqueue(
redis::cmd("JSON.NUMINCRBY")
.arg(key)
.arg(path)
.arg(delta)
.to_owned(),
)
}
#[cfg(feature = "search")]
pub fn ft_search(&mut self, index: &str, query: &str) -> Result<Ticket<redis::Value>> {
self.enqueue(redis::cmd("FT.SEARCH").arg(index).arg(query).to_owned())
}
#[cfg(feature = "search")]
pub fn ft_aggregate(&mut self, index: &str, query: &str) -> Result<Ticket<redis::Value>> {
self.enqueue(redis::cmd("FT.AGGREGATE").arg(index).arg(query).to_owned())
}
#[cfg(feature = "search")]
pub fn ft_drop_index(&mut self, index: &str) -> Result<Ticket<()>> {
self.enqueue(redis::cmd("FT.DROPINDEX").arg(index).to_owned())
}
#[cfg(feature = "search")]
pub fn ft_drop_index_dd(&mut self, index: &str, dd: bool) -> Result<Ticket<()>> {
let mut c = redis::cmd("FT.DROPINDEX");
c.arg(index);
if dd {
c.arg("DD");
}
self.enqueue(c)
}
#[cfg(feature = "search")]
pub fn ft_info(&mut self, index: &str) -> Result<Ticket<redis::Value>> {
self.enqueue(redis::cmd("FT.INFO").arg(index).to_owned())
}
#[cfg(feature = "search")]
pub fn ft_search_args(&mut self, index: &str, args: &[&str]) -> Result<Ticket<redis::Value>> {
let mut c = redis::cmd("FT.SEARCH");
c.arg(index);
for a in args {
c.arg(*a);
}
self.enqueue(c)
}
#[cfg(feature = "search")]
pub fn ft_aggregate_args(
&mut self,
index: &str,
args: &[&str],
) -> Result<Ticket<redis::Value>> {
let mut c = redis::cmd("FT.AGGREGATE");
c.arg(index);
for a in args {
c.arg(*a);
}
self.enqueue(c)
}
#[cfg(feature = "search")]
pub fn ft_create_args(&mut self, index: &str, args: &[&str]) -> Result<Ticket<()>> {
let mut c = redis::cmd("FT.CREATE");
c.arg(index);
for a in args {
c.arg(*a);
}
self.enqueue(c)
}
pub async fn execute(mut self) -> Result<()> {
let chain_res = match self.flush_chain.take() {
Some(chain) => chain.await.unwrap_or_else(join_err_to_unknown),
None => Ok(()),
};
self.executed = true;
let cmds = std::mem::take(&mut self.cmds);
let last = dispatch_jobs(&self.client, cmds).await;
chain_res.and(last) }
}
impl Drop for PipelineSession {
fn drop(&mut self) {
if !self.executed && !self.cmds.is_empty() {
let pending = self.cmds.len();
for (_cmd, tx) in self.cmds.drain(..) {
let _ = tx.send(Err(TicketErr::NotSent));
}
tracing::warn!(
pending,
"PipelineSession 释放尚未派发的尾批,命令确定未发送,已封批任务继续完成"
);
}
}
}
#[derive(Debug, Clone)]
pub struct MicroBatchCfg {
pub window: Duration,
pub max_batch: usize,
pub queue_capacity: usize,
pub max_command_bytes: usize,
pub max_batch_bytes: usize,
}
impl Default for MicroBatchCfg {
fn default() -> Self {
Self {
window: Duration::from_millis(1),
max_batch: 1000,
queue_capacity: 4096,
max_command_bytes: 0, max_batch_bytes: 0,
}
}
}
fn estimate_cmd_bytes(cmd: &redis::Cmd) -> usize {
cmd.args_iter()
.map(|a| match a {
redis::Arg::Simple(b) => b.len(),
_ => 8, })
.sum()
}
fn auto_pipeline_reject(cmd: &redis::Cmd) -> Option<&'static str> {
let mut it = cmd.args_iter();
let name = match it.next() {
Some(redis::Arg::Simple(b)) if !b.is_empty() => b.to_ascii_uppercase(),
_ => return Some("命令无名字"),
};
match name.as_slice() {
b"MULTI" | b"EXEC" | b"DISCARD" | b"WATCH" | b"UNWATCH" | b"SELECT" | b"AUTH"
| b"HELLO" | b"QUIT" | b"CLIENT" | b"READONLY" | b"READWRITE" | b"ASKING" | b"SYNC"
| b"PSYNC" | b"REPLCONF" => {
Some("连接状态命令不可进 AutoPipeline,请使用独立连接或专门 API")
}
b"BLPOP" | b"BRPOP" | b"BLMOVE" | b"BRPOPLPUSH" | b"BLMPOP" | b"BZPOPMIN" | b"BZPOPMAX"
| b"BZMPOP" | b"WAIT" | b"WAITAOF" => {
Some("阻塞命令不可进 AutoPipeline(会拖住共享 flusher),请走专门 API")
}
b"SUBSCRIBE" | b"PSUBSCRIBE" | b"SSUBSCRIBE" | b"UNSUBSCRIBE" | b"PUNSUBSCRIBE"
| b"SUNSUBSCRIBE" | b"MONITOR" => {
Some("Pub/Sub/MONITOR 不可进 AutoPipeline(改变连接语义),请走 pubsub API")
}
b"SCRIPT" | b"FUNCTION" | b"FLUSHALL" | b"FLUSHDB" | b"SHUTDOWN" | b"FAILOVER"
| b"SWAPDB" | b"RESET" | b"ACL" | b"CONFIG" | b"MODULE" | b"CLUSTER" | b"REPLICAOF"
| b"SLAVEOF" | b"DEBUG" | b"SAVE" | b"BGSAVE" | b"BGREWRITEAOF" | b"MIGRATE" => Some(
"全局/管理命令不可进 AutoPipeline(cluster 下只落任意单节点,语义不等价),请走专门 API",
),
b"XREAD" | b"XREADGROUP" => {
let grouped = name == b"XREADGROUP";
if grouped
&& (!matches!(it.next(), Some(redis::Arg::Simple(s)) if s.eq_ignore_ascii_case(b"GROUP"))
|| !matches!(it.next(), Some(redis::Arg::Simple(_)))
|| !matches!(it.next(), Some(redis::Arg::Simple(_))))
{
return Some("XREADGROUP 缺少完整 GROUP 参数,不可进 AutoPipeline");
}
while let Some(arg) = it.next() {
let redis::Arg::Simple(option) = arg else {
return Some("无法确认 Stream 读取为非阻塞命令,不可进 AutoPipeline");
};
if option.eq_ignore_ascii_case(b"BLOCK") {
return Some("XREAD/XREADGROUP BLOCK 阻塞,不可进 AutoPipeline");
}
if option.eq_ignore_ascii_case(b"STREAMS") {
return None;
}
if option.eq_ignore_ascii_case(b"COUNT")
|| option.eq_ignore_ascii_case(b"MAXCOUNT")
|| option.eq_ignore_ascii_case(b"MAXSIZE")
{
if !matches!(it.next(), Some(redis::Arg::Simple(_))) {
return Some("Stream 读取选项缺少参数,不可进 AutoPipeline");
}
} else if !(grouped && option.eq_ignore_ascii_case(b"NOACK")) {
return Some("无法确认 Stream 读取选项边界,不可进 AutoPipeline");
}
}
Some("Stream 读取缺少 STREAMS 边界,不可进 AutoPipeline")
}
_ => None,
}
}
type BatchJob = (
redis::Cmd,
oneshot::Sender<std::result::Result<redis::Value, TicketErr>>,
);
fn join_err_to_unknown(e: tokio::task::JoinError) -> Result<()> {
Err(NasaRedisError::ExecutionUnknown(format!(
"pipeline auto-flush task 结束异常(panic/cancel): {e}"
)))
}
pub struct AutoPipeline {
tx: mpsc::Sender<BatchJob>,
activity: Arc<crate::activity::Activity>,
cancel: CancellationToken,
max_command_bytes: usize,
admission: Arc<std::sync::Mutex<bool>>,
abort: tokio::task::AbortHandle,
outcome: tokio::sync::watch::Receiver<AutoPipelineState>,
}
struct AutoPipelineQueue {
rx: mpsc::Receiver<BatchJob>,
admission: Arc<std::sync::Mutex<bool>>,
cancel: CancellationToken,
activity: Arc<crate::activity::Activity>,
}
impl Drop for AutoPipelineQueue {
fn drop(&mut self) {
let mut open = self.admission.lock().expect("auto pipeline admission");
self.activity.close();
*open = false;
self.cancel.cancel();
self.rx.close();
while self.rx.try_recv().is_ok() {}
self.activity.queue_dropped();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutoPipelineState {
Running,
Drained,
Failed,
}
impl AutoPipeline {
pub fn with_running<T>(&self, publish: impl FnOnce() -> T) -> Option<T> {
self.activity
.with_tasks(0, 0, 1, || {
if self.cancel.is_cancelled() || self.state() != AutoPipelineState::Running {
None
} else {
Some(publish())
}
})
.flatten()
}
pub fn start(client: Arc<RedisClient>, cfg: MicroBatchCfg) -> Arc<Self> {
let queue_capacity = cfg
.queue_capacity
.clamp(1, tokio::sync::Semaphore::MAX_PERMITS);
let (tx, rx) = mpsc::channel(queue_capacity);
let cancel = CancellationToken::new();
let max_command_bytes = cfg.max_command_bytes;
let activity = Arc::new(crate::activity::Activity::default());
let admission = Arc::new(std::sync::Mutex::new(true));
let queue = AutoPipelineQueue {
rx,
admission: admission.clone(),
cancel: cancel.clone(),
activity: activity.clone(),
};
let active = activity.task(crate::activity::TaskKind::Flusher);
let progress = activity.clone();
let worker_cancel = cancel.clone();
let handle = tokio::spawn(async move {
let mut queue = queue;
let _active = active;
flush_loop(client, &mut queue.rx, cfg, worker_cancel, progress).await;
});
let abort = handle.abort_handle();
let (done, outcome) = tokio::sync::watch::channel(AutoPipelineState::Running);
let done = activity.completion(done);
let task_cancel = cancel.clone();
let owner_stop = cancel.clone().drop_guard();
tokio::spawn(async move {
let _stop = owner_stop;
let state = if handle.await.is_ok() {
AutoPipelineState::Drained
} else {
AutoPipelineState::Failed
};
task_cancel.cancel();
done.send_replace(state);
});
Arc::new(Self {
tx,
activity,
cancel,
max_command_bytes,
admission,
abort,
outcome,
})
}
pub async fn execute<T: FromRedisValue>(&self, cmd: redis::Cmd) -> Result<T> {
self.precheck(&cmd)?;
let (otx, orx) = oneshot::channel();
self.enqueue((cmd, otx)).await?;
match orx.await {
Ok(Ok(v)) => Ok(T::from_redis_value(v)?),
Ok(Err(TicketErr::Server(e))) => Err(NasaRedisError::Redis(e.into())),
Ok(Err(TicketErr::Unknown(m))) => Err(NasaRedisError::ExecutionUnknown(m)),
Ok(Err(TicketErr::NotSent)) => Err(NasaRedisError::NotExecuted("命令未发送".into())),
Err(_) => Err(NasaRedisError::ExecutionUnknown(
"微批回执通道关闭(命令可能已执行)".into(),
)),
}
}
pub async fn submit(&self, cmd: redis::Cmd) -> Result<()> {
self.precheck(&cmd)?;
let (otx, _orx) = oneshot::channel(); self.enqueue((cmd, otx)).await?;
Ok(())
}
async fn enqueue(&self, job: BatchJob) -> Result<()> {
let permit = tokio::select! {
biased;
_ = self.cancel.cancelled() => return Err(NasaRedisError::NotExecuted("自动微批已关闭".into())),
permit = self.tx.reserve() => permit.map_err(|_| NasaRedisError::NotExecuted("自动微批队列已关闭".into()))?,
};
let open = self.admission.lock().expect("auto pipeline admission");
if !*open || self.cancel.is_cancelled() {
return Err(NasaRedisError::NotExecuted("自动微批已关闭".into()));
}
self.activity.accept(1, estimate_cmd_bytes(&job.0));
permit.send(job);
Ok(())
}
pub async fn barrier(&self) -> Result<()> {
self.execute::<redis::Value>(redis::cmd("PING"))
.await
.map(|_| ())
}
fn precheck(&self, cmd: &redis::Cmd) -> Result<()> {
if self.cancel.is_cancelled() {
return Err(NasaRedisError::NotExecuted("自动微批已关闭".into()));
}
if let Some(reason) = auto_pipeline_reject(cmd) {
return Err(NasaRedisError::Config(reason.into()));
}
if self.max_command_bytes > 0 {
let bytes = estimate_cmd_bytes(cmd);
if bytes > self.max_command_bytes {
return Err(NasaRedisError::Config(format!(
"命令参数 {bytes} 字节超 max_command_bytes={}(AutoPipeline 拒绝大 value 入队)",
self.max_command_bytes
)));
}
}
Ok(())
}
pub fn begin_shutdown(&self) {
let mut open = self.admission.lock().expect("auto pipeline admission");
self.activity.close();
*open = false;
self.cancel.cancel();
}
pub fn abort(&self) {
self.begin_shutdown();
self.abort.abort();
}
pub fn state(&self) -> AutoPipelineState {
let disconnected = self.outcome.has_changed().is_err();
let state = *self.outcome.borrow();
if disconnected && state == AutoPipelineState::Running {
AutoPipelineState::Failed
} else {
state
}
}
pub fn queued(&self) -> usize {
self.tx.max_capacity() - self.tx.capacity()
}
pub fn observation(&self) -> crate::RedisTaskObservation {
self.activity.snapshot()
}
pub async fn shutdown_result(&self) -> Result<()> {
self.begin_shutdown();
let mut outcome = self.outcome.clone();
loop {
match *outcome.borrow_and_update() {
AutoPipelineState::Drained => return Ok(()),
AutoPipelineState::Failed => {
return Err(NasaRedisError::ExecutionUnknown(
"自动微批任务异常退出".into(),
))
}
AutoPipelineState::Running => {}
}
if outcome.changed().await.is_err() {
return Err(NasaRedisError::ExecutionUnknown(
"自动微批退出证据不可用".into(),
));
}
}
}
pub async fn shutdown(&self) {
if self.shutdown_result().await.is_err() {
tracing::warn!("自动微批关闭时存在未确认命令");
}
}
}
impl Drop for AutoPipeline {
fn drop(&mut self) {
self.begin_shutdown();
}
}
async fn flush_loop(
client: Arc<RedisClient>,
rx: &mut mpsc::Receiver<BatchJob>,
cfg: MicroBatchCfg,
cancel: CancellationToken,
activity: Arc<crate::activity::Activity>,
) {
loop {
let first = tokio::select! {
_ = cancel.cancelled() => break,
j = rx.recv() => match j {
Some(j) => j,
None => break
},
};
let mut batch_bytes = estimate_cmd_bytes(&first.0);
activity.dequeue(batch_bytes);
let mut batch = vec![first];
let bounded_window = cfg.window.min(Duration::from_secs(365 * 24 * 60 * 60));
let deadline = tokio::time::Instant::now() + bounded_window;
while batch.len() < cfg.max_batch
&& (cfg.max_batch_bytes == 0 || batch_bytes < cfg.max_batch_bytes)
{
tokio::select! {
_ = cancel.cancelled() => break,
r = tokio::time::timeout_at(deadline, rx.recv()) => match r {
Ok(Some(j)) => {
let bytes = estimate_cmd_bytes(&j.0);
activity.dequeue(bytes);
batch_bytes += bytes;
batch.push(j);
}
_ => break, }
}
}
flush_batch(&client, batch, &activity).await;
}
rx.close();
while let Some(first) = rx.recv().await {
let mut bytes = estimate_cmd_bytes(&first.0);
activity.dequeue(bytes);
let mut batch = vec![first];
while batch.len() < cfg.max_batch.max(1)
&& (cfg.max_batch_bytes == 0 || bytes < cfg.max_batch_bytes)
{
let Some(job) = rx.recv().await else {
break;
};
let size = estimate_cmd_bytes(&job.0);
activity.dequeue(size);
bytes = bytes.saturating_add(size);
batch.push(job);
}
flush_batch(&client, batch, &activity).await;
}
}
async fn flush_batch(
client: &Arc<RedisClient>,
batch: Vec<BatchJob>,
activity: &crate::activity::Activity,
) {
let count = batch.len();
let failed = dispatch_jobs(client, batch).await.is_err();
activity.finish(count, failed);
}
async fn dispatch_jobs(client: &RedisClient, jobs: Vec<BatchJob>) -> Result<()> {
if jobs.is_empty() {
return Ok(());
}
if !client.is_cluster() {
return send_one_pipe(client, jobs).await;
}
let mut pending = jobs.into_iter();
let mut first_err = None;
loop {
let mut buckets: std::collections::HashMap<u16, Vec<BatchJob>> =
std::collections::HashMap::new();
let mut keyless = Vec::new();
let mut barrier = None;
for (cmd, tx) in pending.by_ref() {
let is_barrier = {
let mut args = cmd.args_iter();
matches!(args.next(), Some(redis::Arg::Simple(name)) if name.eq_ignore_ascii_case(b"PING"))
&& args.next().is_none()
};
if is_barrier {
barrier = Some((cmd, tx));
break;
}
match first_key_slot(&cmd) {
Some(slot) => buckets.entry(slot).or_default().push((cmd, tx)),
None => keyless.push((cmd, tx)),
}
}
let mut futs: Vec<_> = buckets
.into_values()
.map(|batch| send_one_pipe(client, batch))
.collect();
if !keyless.is_empty() {
futs.push(send_one_pipe(client, keyless));
}
for result in futures::future::join_all(futs).await {
if let Err(error) = result {
first_err.get_or_insert(error);
}
}
let Some(barrier) = barrier else {
break;
};
if let Err(error) = send_one_pipe(client, vec![barrier]).await {
first_err.get_or_insert(error);
}
}
match first_err {
Some(e) => Err(e),
None => Ok(()),
}
}
fn first_key_slot(cmd: &redis::Cmd) -> Option<u16> {
let mut it = cmd.args_iter();
let name = match it.next()? {
redis::Arg::Simple(b) => b,
_ => return None,
};
if is_eval_family(name) {
let _script = it.next()?;
let numkeys: usize = match it.next()? {
redis::Arg::Simple(b) => std::str::from_utf8(b).ok()?.parse().ok()?,
_ => return None,
};
if numkeys == 0 {
return None; }
return match it.next()? {
redis::Arg::Simple(key) => Some(crate::keytag::redis_slot(key)),
_ => None,
};
}
match it.next()? {
redis::Arg::Simple(key) => Some(crate::keytag::redis_slot(key)),
_ => None,
}
}
fn is_eval_family(name: &[u8]) -> bool {
let mut up = name.to_ascii_uppercase();
if up.ends_with(b"_RO") {
up.truncate(up.len() - 3);
}
matches!(up.as_slice(), b"EVAL" | b"EVALSHA" | b"FCALL")
}
async fn send_one_pipe(client: &RedisClient, jobs: Vec<BatchJob>) -> Result<()> {
let n = jobs.len();
if n == 0 {
return Ok(());
}
let mut pipe = redis::pipe();
let mut txs = Vec::with_capacity(n);
for (cmd, tx) in jobs {
pipe.add_command(cmd);
txs.push(tx);
}
let mut conn = match client.pipe_conn().await {
Ok(c) => c,
Err(e) => {
let msg = format!("pipeline 专用连接获取失败,整批结果不确定: {e}");
for tx in txs {
let _ = tx.send(Err(TicketErr::Unknown(msg.clone())));
}
return Err(NasaRedisError::ExecutionUnknown(msg));
}
};
match redis::aio::ConnectionLike::req_packed_commands(&mut conn, &pipe, 0, n).await {
Ok(values) if values.len() == n => {
let mut it = values.into_iter();
for tx in txs {
let _ = match it.next() {
Some(redis::Value::ServerError(e)) => tx.send(Err(TicketErr::Server(e))),
Some(v) => tx.send(Ok(v)),
None => unreachable!("已校验 values.len()==n"),
};
}
Ok(())
}
Ok(values) => {
let msg = format!(
"pipeline 响应数 {} != 命令数 {n}(协议异常,整批结果不确定)",
values.len()
);
for tx in txs {
let _ = tx.send(Err(TicketErr::Unknown(msg.clone())));
}
Err(NasaRedisError::ExecutionUnknown(msg))
}
Err(e) => {
let msg = format!("pipeline 传输失败,整批结果不确定: {e}");
for tx in txs {
let _ = tx.send(Err(TicketErr::Unknown(msg.clone())));
}
Err(NasaRedisError::ExecutionUnknown(msg))
}
}
}