use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
use futures::StreamExt;
use redis::AsyncCommands;
use tokio::sync::watch;
use tokio_util::sync::CancellationToken;
use crate::client::RedisClient;
use crate::config::MAX_REDIS_RUNTIME_DURATION_MS;
use crate::error::{NasaRedisError, Result};
const LOCK_LUA: &str = r#"if redis.call('exists', KEYS[1]) == 0 then
redis.call('hincrby', KEYS[1], ARGV[2], 1)
redis.call('pexpire', KEYS[1], ARGV[1])
return nil
end
if redis.call('hexists', KEYS[1], ARGV[2]) == 1 then
redis.call('hincrby', KEYS[1], ARGV[2], 1)
redis.call('pexpire', KEYS[1], ARGV[1])
return nil
end
return redis.call('pttl', KEYS[1])
"#;
const UNLOCK_LUA: &str = r#"if redis.call('hexists', KEYS[1], ARGV[2]) == 0 then
return nil
end
local count = redis.call('hincrby', KEYS[1], ARGV[2], -1)
if count > 0 then
redis.call('pexpire', KEYS[1], ARGV[1])
return 0
end
redis.call('del', KEYS[1])
return 1
"#;
const RENEW_LUA: &str = r#"if redis.call('hexists', KEYS[1], ARGV[2]) == 1 then
redis.call('pexpire', KEYS[1], ARGV[1])
return 1
end
return 0
"#;
const HOLDS_LUA: &str = r#"if redis.call('hexists', KEYS[1], ARGV[1]) == 1 then
return 1
end
return 0
"#;
fn instance_id() -> &'static str {
static ID: OnceLock<String> = OnceLock::new();
ID.get_or_init(|| uuid::Uuid::new_v4().simple().to_string())
}
static GUARD_SEQ: AtomicU64 = AtomicU64::new(0);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HoldStatus {
Held,
Lost,
Unknown,
}
#[derive(Clone)]
pub struct DistributedLock {
client: Arc<RedisClient>,
prefix: String,
lease_ms: u64,
}
struct GuardInner {
client: Arc<RedisClient>,
lock_key: String,
holder: String,
lease_ms: u64,
depth: AtomicU32,
released: AtomicBool,
cancel: CancellationToken,
lost_tx: watch::Sender<bool>,
}
impl GuardInner {
async fn server_unlock(self: &Arc<Self>) -> Result<()> {
let r: std::result::Result<Option<i64>, redis::RedisError> = redis::Script::new(UNLOCK_LUA)
.key(&self.lock_key)
.arg(self.lease_ms)
.arg(&self.holder)
.invoke_async(&mut self.client.conn())
.await;
self.cancel.cancel(); match r {
Ok(Some(_)) => {
let channel = format!("{}:pub", self.lock_key);
if let Err(e) = self.client.conn().publish::<_, _, i64>(&channel, "").await {
tracing::warn!(key = %self.lock_key, err = %e, "解锁后 pub 唤醒失败(等锁者将靠 PTTL 兜底迟醒)");
}
Ok(())
}
Ok(None) => Err(NasaRedisError::LockNotHeld(self.lock_key.clone())),
Err(e) => Err(NasaRedisError::ExecutionUnknown(format!(
"UNLOCK 失败,锁释放结果不确定;看门狗已停、锁将于 ≤lease 后过期(不再续租): {e}"
))),
}
}
}
pub struct LockGuard {
inner: Option<Arc<GuardInner>>,
}
impl DistributedLock {
pub fn new(client: Arc<RedisClient>) -> Self {
let prefix = client.config().lock.prefix.clone();
let lease_ms = client.config().lock.lease_ms;
Self {
client,
prefix,
lease_ms,
}
}
fn full_key(&self, key: &str) -> String {
if !self.prefix.is_empty() && key.starts_with(&self.prefix) {
key.to_string()
} else {
format!("{}{}", self.prefix, key)
}
}
fn new_holder() -> String {
format!(
"{}:{}",
instance_id(),
GUARD_SEQ.fetch_add(1, Ordering::Relaxed)
)
}
pub async fn try_lock(&self, key: &str) -> Result<Option<LockGuard>> {
self.try_lock_inner(self.full_key(key), Self::new_holder())
.await
}
async fn try_lock_inner(&self, lock_key: String, holder: String) -> Result<Option<LockGuard>> {
let r: Option<i64> = redis::Script::new(LOCK_LUA)
.key(&lock_key)
.arg(self.lease_ms)
.arg(&holder)
.invoke_async(&mut self.client.conn())
.await?;
match r {
None => Ok(Some(self.spawn_guard(lock_key, holder))),
Some(_pttl) => Ok(None),
}
}
fn spawn_guard(&self, lock_key: String, holder: String) -> LockGuard {
let (lost_tx, _) = watch::channel(false);
let inner = Arc::new(GuardInner {
client: Arc::clone(&self.client),
lock_key,
holder,
lease_ms: self.lease_ms,
depth: AtomicU32::new(1),
released: AtomicBool::new(false),
cancel: CancellationToken::new(),
lost_tx,
});
let wd = Arc::clone(&inner);
tokio::spawn(async move {
struct LostOnExit(watch::Sender<bool>, bool);
impl Drop for LostOnExit {
fn drop(&mut self) {
if self.1 {
let _ = self.0.send(true);
}
}
}
let mut lost_guard = LostOnExit(wd.lost_tx.clone(), true);
let interval = Duration::from_millis((wd.lease_ms / 3).max(1));
let mut tick = tokio::time::interval(interval);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
tick.tick().await; loop {
tokio::select! {
_ = wd.cancel.cancelled() => {
lost_guard.1 = false; break;
}
_ = tick.tick() => {
let mut conn = wd.client.conn();
let script = redis::Script::new(RENEW_LUA);
let mut invocation = script.prepare_invoke();
invocation.key(&wd.lock_key).arg(wd.lease_ms).arg(&wd.holder);
let renew = invocation.invoke_async::<i64>(&mut conn);
let r = tokio::time::timeout(interval, renew).await;
match r {
Ok(Ok(1)) => {} Ok(Ok(_)) => {
let _ = wd.lost_tx.send(true);
lost_guard.1 = false;
tracing::warn!(key = %wd.lock_key, "看门狗:服务端确认锁已丢失,停止续期");
break;
}
Ok(Err(e)) => tracing::warn!(key = %wd.lock_key, err = %e, "看门狗续期异常(Unknown),继续重试"),
Err(_) => tracing::warn!(key = %wd.lock_key, "看门狗续期超时(Unknown),继续重试"),
}
}
}
}
});
LockGuard { inner: Some(inner) }
}
pub async fn lock(&self, key: &str, timeout: Option<Duration>) -> Result<LockGuard> {
let lock_key = self.full_key(key);
match timeout {
Some(t) => {
if t > Duration::from_millis(MAX_REDIS_RUNTIME_DURATION_MS) {
return Err(NasaRedisError::Config(format!(
"lock timeout 超过运行时上限 {MAX_REDIS_RUNTIME_DURATION_MS}ms"
)));
}
let d = tokio::time::Instant::now().checked_add(t).ok_or_else(|| {
NasaRedisError::Config("lock timeout 无法表示为 Tokio deadline".into())
})?;
let this = self.clone();
let lk = lock_key.clone();
let mut task = tokio::spawn(async move { this.lock_inner(&lk, Some(d)).await });
match tokio::time::timeout_at(d, &mut task).await {
Ok(joined) => match joined {
Ok(r) => r, Err(e) => Err(NasaRedisError::LockTimeout(format!(
"{lock_key}: 获取任务异常: {e}"
))),
},
Err(_) => {
let grace = Duration::from_millis((self.lease_ms / 10).clamp(50, 500));
match tokio::time::timeout(grace, &mut task).await {
Ok(Ok(Ok(g))) => {
let lk = lock_key.clone();
match tokio::time::timeout(grace, g.unlock()).await {
Ok(Ok(())) => {}
Ok(Err(e)) => {
tracing::warn!(key = %lk, err = %e, "等锁超时后释放刚获取的锁失败(lease 兜底)")
}
Err(_) => {
tracing::warn!(key = %lk, "等锁超时后释放刚获取的锁超时(lease 兜底)")
}
}
Err(NasaRedisError::LockTimeout(lock_key))
}
Ok(Ok(Err(_))) | Ok(Err(_)) => {
Err(NasaRedisError::LockTimeout(lock_key))
}
Err(_) => {
task.abort();
Err(NasaRedisError::LockTimeout(lock_key))
}
}
}
}
}
None => self.lock_inner(&lock_key, None).await,
}
}
async fn lock_inner(
&self,
lock_key: &str,
deadline: Option<tokio::time::Instant>,
) -> Result<LockGuard> {
loop {
if deadline.is_some_and(|dl| tokio::time::Instant::now() >= dl) {
return Err(NasaRedisError::LockTimeout(lock_key.to_string()));
}
let holder = Self::new_holder();
if let Some(g) = self
.try_lock_inner(lock_key.to_string(), holder.clone())
.await?
{
return Ok(g);
}
let channel = format!("{lock_key}:pub");
let mut pubsub = self.client.raw_client().get_async_pubsub().await?;
pubsub.subscribe(&channel).await?;
if let Some(g) = self
.try_lock_inner(lock_key.to_string(), holder.clone())
.await?
{
return Ok(g);
}
let pttl: i64 = self
.client
.conn()
.pttl(lock_key)
.await
.unwrap_or(self.lease_ms as i64);
let nap = Duration::from_millis(match pttl {
-2 => 20,
-1 => self.lease_ms,
ms if ms >= 0 => (ms as u64).clamp(20, self.lease_ms),
_ => 20,
});
let nap = match deadline {
Some(dl) => nap.min(dl.saturating_duration_since(tokio::time::Instant::now())),
None => nap,
};
let mut msgs = pubsub.on_message();
tokio::select! {
_ = msgs.next() => {}
_ = tokio::time::sleep(nap) => {}
}
}
}
pub async fn with_lock<F, Fut, T>(
&self,
key: &str,
timeout: Option<Duration>,
f: F,
) -> Result<T>
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = T>,
{
let guard = self.lock(key, timeout).await?;
let out = f().await;
guard.unlock().await?;
Ok(out)
}
pub async fn holds_status(&self, key: &str, holder: &str) -> HoldStatus {
let r: std::result::Result<i64, redis::RedisError> = redis::Script::new(HOLDS_LUA)
.key(self.full_key(key))
.arg(holder)
.invoke_async(&mut self.client.conn())
.await;
match r {
Ok(1) => HoldStatus::Held,
Ok(_) => HoldStatus::Lost,
Err(_) => HoldStatus::Unknown,
}
}
}
impl LockGuard {
pub(crate) fn abandon(mut self) {
if let Some(inner) = self.inner.take() {
inner.cancel.cancel();
inner.released.store(true, Ordering::Release);
}
}
#[inline]
fn arc(&self) -> &Arc<GuardInner> {
self.inner
.as_ref()
.expect("LockGuard inner accessed after unlock/drop")
}
pub fn holder(&self) -> &str {
&self.arc().holder
}
pub fn lock_key(&self) -> &str {
&self.arc().lock_key
}
pub async fn still_held(&self) -> HoldStatus {
let r: std::result::Result<i64, redis::RedisError> = redis::Script::new(HOLDS_LUA)
.key(&self.arc().lock_key) .arg(&self.arc().holder)
.invoke_async(&mut self.arc().client.conn())
.await;
match r {
Ok(1) => HoldStatus::Held,
Ok(_) => HoldStatus::Lost,
Err(_) => HoldStatus::Unknown,
}
}
pub fn lost(&self) -> watch::Receiver<bool> {
self.arc().lost_tx.subscribe()
}
pub fn reenter(&self) -> LockGuard {
debug_assert!(
!self.arc().released.load(Ordering::Acquire),
"对已释放的 LockGuard reenter():幽灵 guard(契约违反)"
);
self.arc().depth.fetch_add(1, Ordering::AcqRel);
LockGuard {
inner: Some(Arc::clone(self.arc())),
}
}
pub async fn unlock(mut self) -> Result<()> {
let inner = self
.inner
.take()
.expect("LockGuard::unlock called after inner was already taken");
let prev = inner.depth.fetch_sub(1, Ordering::AcqRel);
if prev > 1 {
return Err(NasaRedisError::StillReentered {
remaining: prev - 1,
});
}
if inner.released.swap(true, Ordering::AcqRel) {
return Err(NasaRedisError::LockNotHeld(inner.lock_key.clone()));
}
inner.server_unlock().await
}
}
impl Drop for LockGuard {
fn drop(&mut self) {
let Some(inner) = self.inner.take() else {
return;
};
if inner.depth.fetch_sub(1, Ordering::AcqRel) == 1
&& !inner.released.swap(true, Ordering::AcqRel)
{
inner.cancel.cancel();
tracing::warn!(key = %inner.lock_key, "LockGuard 被 Drop(未显式 unlock),best-effort 释放");
if let Ok(handle) = tokio::runtime::Handle::try_current() {
handle.spawn(async move {
let _ = inner.server_unlock().await;
});
}
}
}
}