use std::sync::Arc;
use std::time::Duration;
use super::GroupRuntime;
pub(super) async fn auto_trim_loop(rt: Arc<GroupRuntime>) {
let rate = rt.stream_cfg.auto_trim_rate_ms;
if rate == 0 {
tracing::info!(group = %rt.layout.prefix, "autoTrim 已禁用(auto_trim_rate_ms=0)");
return;
}
let leader = crate::leader::Leader::elect(
Arc::clone(&rt.lock),
format!("{}:leader", rt.layout.prefix),
Duration::from_millis(rt.cfg.rebalance_ms.max(1)),
);
if let Some(ah) = leader.abort_handle() {
rt.bg_aborts.lock().expect("bg_aborts").push(ah);
}
let mut tick = tokio::time::interval(Duration::from_millis(rate));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
tick.tick().await;
loop {
tokio::select! {
_ = rt.bg_cancel.cancelled() => break,
_ = tick.tick() => {
let rt2 = Arc::clone(&rt);
leader
.run_if_leader_cancellable(|tok| async move { trim_round(&rt2, &tok).await })
.await;
}
}
}
leader.shutdown().await;
}
async fn trim_round(rt: &Arc<GroupRuntime>, term: &tokio_util::sync::CancellationToken) {
let now = match super::command::redis_now(&rt.client).await {
Ok(n) => n,
Err(e) => {
tracing::warn!(err = %e, "autoTrim 取 Redis TIME 失败,跳过本轮");
return;
}
};
let time_min_id = format!("{}-0", now.saturating_sub(rt.stream_cfg.data_expire_ms));
let group = rt.layout.group().to_string();
let mut trimmed = 0i64;
for p in 0..rt.count {
if rt.bg_cancel.is_cancelled() || term.is_cancelled() {
break;
}
let stream = rt.layout.stream(p);
let min_id = match oldest_pending_id(&rt.client, &stream, &group).await {
Ok(Some(pel_oldest)) => lesser_stream_id(&time_min_id, &pel_oldest),
Ok(None) => time_min_id.clone(), Err(e) => {
tracing::warn!(p, stream = %stream, err = %e, "autoTrim 取 PEL 最老 id 失败,保守跳过本分区");
continue; }
};
let r: std::result::Result<i64, redis::RedisError> = redis::cmd("XTRIM")
.arg(&stream)
.arg("MINID")
.arg("~")
.arg(&min_id)
.query_async(&mut rt.client.conn())
.await;
match r {
Ok(n) => trimmed += n,
Err(e) => tracing::warn!(p, stream = %stream, err = %e, "autoTrim XTRIM 失败"),
}
}
if trimmed > 0 {
tracing::debug!(group = %rt.layout.prefix, time_min_id = %time_min_id, trimmed, "autoTrim 裁剪 stream entries(裁剪边界已按各分区 PEL 最老 id 兜底)");
}
}
async fn oldest_pending_id(
client: &crate::client::RedisClient,
stream: &str,
group: &str,
) -> std::result::Result<Option<String>, redis::RedisError> {
fn parse_err(msg: &str) -> redis::RedisError {
redis::RedisError::from((
redis::ErrorKind::Parse,
"XPENDING summary 形态异常",
msg.to_string(),
))
}
let v: redis::Value = redis::cmd("XPENDING")
.arg(stream)
.arg(group)
.query_async(&mut client.conn())
.await?;
let (redis::Value::Array(cols) | redis::Value::Set(cols)) = &v else {
return Err(parse_err("顶层非 Array/Set"));
};
let count = match cols.first() {
Some(redis::Value::Int(n)) => *n,
_ => return Err(parse_err("缺 count 或非整数")),
};
if count == 0 {
return Ok(None);
}
match cols.get(1) {
Some(redis::Value::BulkString(b)) => Ok(Some(String::from_utf8_lossy(b).into_owned())),
Some(redis::Value::SimpleString(s)) => Ok(Some(s.clone())),
_ => Err(parse_err("count>0 但 min-id 非字符串")),
}
}
fn lesser_stream_id(a: &str, b: &str) -> String {
fn parse(id: &str) -> Option<(u64, u64)> {
let mut it = id.splitn(2, '-');
let ms = it.next()?.parse::<u64>().ok()?;
let seq = it.next().unwrap_or("0").parse::<u64>().ok()?;
Some((ms, seq))
}
match (parse(a), parse(b)) {
(Some(pa), Some(pb)) => {
if pa <= pb {
a.to_string()
} else {
b.to_string()
}
}
(Some(_), None) => a.to_string(),
(None, Some(_)) => b.to_string(),
(None, None) => a.to_string(),
}
}