use std::sync::Arc;
use serde::{Deserialize, Serialize};
use super::KeyLayout;
use crate::client::RedisClient;
use crate::error::{NasaRedisError, Result};
pub fn marker_key(layout: &KeyLayout, p: u32, op_id: &str) -> String {
format!("{}:retryop:{}:{}", layout.prefix, p, op_id)
}
pub fn operation_id(layout: &KeyLayout, consumer: &str, claim_term: u64, ids: &[String]) -> String {
let mut sorted: Vec<&str> = ids.iter().map(|s| s.as_str()).collect();
sorted.sort_unstable();
let payload = format!(
"{}|{}|{}|{}",
sorted.join(","),
layout.group(),
consumer,
claim_term
);
crate::keytag::fnv1a64_hex(payload.as_bytes())
}
const RETRYOP_MARKER_TTL: std::time::Duration = std::time::Duration::from_secs(600);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetryIntent {
pub id: String,
pub desired: u64,
}
#[derive(Debug)]
pub enum RetryOutcome {
Claimed(Vec<u8>),
Have(Vec<u8>),
Resolved,
OwnershipChanged,
Superseded,
Corrupt,
}
pub struct FenceArgs<'a> {
pub holder: &'a str,
pub lock_key: &'a str,
pub fence_key: &'a str,
pub round: u64,
pub nonce: &'a str,
pub counter: u64,
}
const RETRY_CAS_LUA: &str = r#"
-- owner/fence 前缀:KEYS[2]=lock KEYS[3]=fence;ARGV[5]=holder ARGV[6]=has_fence
-- ARGV[7]=round ARGV[8]=nonce ARGV[9]=p ARGV[10]=counter。任一不符 → 'OWNER'(交新 owner)。
if redis.call('hexists', KEYS[2], ARGV[5]) == 0 then return {'OWNER'} end
if ARGV[6] == '1' then
if redis.call('HGET', KEYS[3], 'state') ~= 'Ready' then return {'OWNER'} end
if redis.call('HGET', KEYS[3], 'round') ~= ARGV[7] then return {'OWNER'} end
if redis.call('HGET', KEYS[3], 'nonce') ~= ARGV[8] then return {'OWNER'} end
if redis.call('HGET', KEYS[3], 'c:' .. ARGV[9]) ~= ARGV[10] then return {'OWNER'} end
end
local pend = redis.call('XPENDING', KEYS[1], ARGV[1], ARGV[3], ARGV[3], 1)
if #pend == 0 then
return {'RESOLVED'}
end
-- XPENDING 详式返回 {id, consumer, idle, delivery-count}
local owner = pend[1][2]
local count = tonumber(pend[1][4])
local desired = tonumber(ARGV[4])
if owner ~= ARGV[2] then
return {'OWNER'}
end
if count > desired then
return {'SUPERSEDED'}
end
if count < desired - 1 then
return {'CORRUPT'}
end
-- 取 payload 的辅助:XRANGE 精确单条,提取 data field
local function payload_of()
local rows = redis.call('XRANGE', KEYS[1], ARGV[3], ARGV[3])
if #rows == 0 then
return nil -- entry 已删(tombstone):PEL 在、payload 无
end
local fields = rows[1][2]
for i = 1, #fields, 2 do
if fields[i] == 'data' then
return fields[i + 1]
end
end
return nil
end
if count == desired then
local pl = payload_of()
if pl == nil then return {'RESOLVED'} end
return {'HAVE', pl}
end
-- count == desired - 1:执行 claim(置 count = desired,幂等重放的唯一递增点)
local claimed = redis.call('XCLAIM', KEYS[1], ARGV[1], ARGV[2], 0, ARGV[3], 'RETRYCOUNT', desired)
if #claimed == 0 then
return {'RESOLVED'}
end
local pl = payload_of()
if pl == nil then return {'RESOLVED'} end
return {'CLAIMED', pl}
"#;
pub async fn ensure_pending(
client: &Arc<RedisClient>,
layout: &KeyLayout,
p: u32,
op_id: &str,
ids: &[String],
) -> Result<Vec<RetryIntent>> {
let uniq: std::collections::BTreeSet<&str> = ids.iter().map(|s| s.as_str()).collect();
if uniq.len() != ids.len() {
return Err(NasaRedisError::ProtocolMarker(format!(
"retry-op 请求含重复 ID(分区 {p}):{ids:?},fail-closed"
)));
}
let mkey = marker_key(layout, p, op_id);
let state: Option<String> = client.h_get(&mkey, "state").await?;
if state.as_deref() == Some("Pending") {
let json: Option<String> = client.h_get(&mkey, "ids").await?;
let old: Vec<RetryIntent> = serde_json::from_str(&json.unwrap_or_default())
.map_err(|e| NasaRedisError::Codec(format!("retryop ids 解析失败: {e}")))?;
let marker_set: std::collections::BTreeSet<&str> =
old.iter().map(|i| i.id.as_str()).collect();
let req_set: std::collections::BTreeSet<&str> = ids.iter().map(|s| s.as_str()).collect();
if marker_set == req_set {
return Ok(old); }
return Err(NasaRedisError::ProtocolMarker(format!(
"retry-op op_id 碰撞(marker ids 与请求不一致),fail-closed: op_id={op_id}"
)));
}
let mut intents = Vec::with_capacity(ids.len());
for id in ids {
if let Some(count) = actual_count(client, layout, p, id).await? {
intents.push(RetryIntent {
id: id.clone(),
desired: count + 1,
});
}
}
if intents.is_empty() {
return Ok(intents); }
let json = serde_json::to_string(&intents).map_err(|e| NasaRedisError::Codec(e.to_string()))?;
let _: redis::Value = redis::Script::new(ENSURE_PENDING_LUA)
.key(&mkey)
.arg(json.as_str())
.arg(RETRYOP_MARKER_TTL.as_millis() as u64)
.invoke_async(&mut client.conn())
.await?;
Ok(intents)
}
const ENSURE_PENDING_LUA: &str = r#"
redis.call('HSET', KEYS[1], 'ids', ARGV[1], 'state', 'Pending')
redis.call('PEXPIRE', KEYS[1], ARGV[2])
return 1
"#;
pub async fn execute(
client: &Arc<RedisClient>,
layout: &KeyLayout,
p: u32,
consumer: &str,
intents: &[RetryIntent],
fence: &FenceArgs<'_>,
) -> Result<Vec<(String, RetryOutcome)>> {
let stream = layout.stream(p);
let lua = redis::Script::new(RETRY_CAS_LUA);
let has_fence = if fence.fence_key.is_empty() {
"0"
} else {
"1"
};
let mut out = Vec::with_capacity(intents.len());
for it in intents {
let v: redis::Value = lua
.key(&stream)
.key(fence.lock_key)
.key(if fence.fence_key.is_empty() {
stream.as_str()
} else {
fence.fence_key
})
.arg(layout.group())
.arg(consumer)
.arg(&it.id)
.arg(it.desired)
.arg(fence.holder)
.arg(has_fence)
.arg(fence.round.to_string())
.arg(fence.nonce)
.arg(p.to_string())
.arg(fence.counter.to_string())
.invoke_async(&mut client.conn())
.await?;
let outcome = parse_outcome(v);
if matches!(outcome, RetryOutcome::Corrupt) {
tracing::error!(p, id = %it.id, "retry-op 协议损坏(count < desired-1),停止自动修改");
}
out.push((it.id.clone(), outcome));
}
Ok(out)
}
pub async fn actual_count(
client: &Arc<RedisClient>,
layout: &KeyLayout,
p: u32,
id: &str,
) -> Result<Option<u64>> {
let v: redis::Value = redis::cmd("XPENDING")
.arg(layout.stream(p))
.arg(layout.group())
.arg(id)
.arg(id)
.arg(1)
.query_async(&mut client.conn())
.await?;
let redis::Value::Array(rows) = v else {
return Err(NasaRedisError::ProtocolMarker(format!(
"XPENDING 详式响应非数组(分区 {p} id={id}): {v:?}"
)));
};
let Some(first) = rows.into_iter().next() else {
return Ok(None); };
let redis::Value::Array(row) = first else {
return Err(NasaRedisError::ProtocolMarker(format!(
"XPENDING 行非数组(分区 {p} id={id})"
)));
};
match row.get(3) {
Some(redis::Value::Int(count)) => u64::try_from(*count).map(Some).map_err(|_| {
NasaRedisError::ProtocolMarker(format!(
"XPENDING delivery count 为负(分区 {p} id={id}): {count}"
))
}),
other => Err(NasaRedisError::ProtocolMarker(format!(
"XPENDING 行缺 count 字段(分区 {p} id={id}): {other:?}"
))),
}
}
pub async fn finish(
client: &Arc<RedisClient>,
layout: &KeyLayout,
p: u32,
op_id: &str,
) -> Result<()> {
client.del(&[&marker_key(layout, p, op_id)]).await?;
Ok(())
}
fn parse_outcome(v: redis::Value) -> RetryOutcome {
let redis::Value::Array(mut arr) = v else {
return RetryOutcome::Corrupt;
};
let tag = match arr.first() {
Some(redis::Value::BulkString(b)) => String::from_utf8_lossy(b).into_owned(),
Some(redis::Value::SimpleString(s)) => s.clone(),
_ => return RetryOutcome::Corrupt,
};
match tag.as_str() {
"CLAIMED" | "HAVE" => {
let payload = match arr.pop() {
Some(redis::Value::BulkString(b)) => b,
_ => return RetryOutcome::Corrupt,
};
if tag == "CLAIMED" {
RetryOutcome::Claimed(payload)
} else {
RetryOutcome::Have(payload)
}
}
"RESOLVED" => RetryOutcome::Resolved,
"OWNER" => RetryOutcome::OwnershipChanged,
"SUPERSEDED" => RetryOutcome::Superseded,
_ => RetryOutcome::Corrupt,
}
}