nadis 2.0.1

Redis 基础层:业务键有序分区消费、Stream/Proxy 生命周期、有界微批、幂等管线、锁与 RedisJob
Documentation
use super::*;
use std::time::Duration;

/// 业务作用:周期执行分区再平衡,并在单轮失败后等待下一轮重试。
///
/// 参数说明:
/// - `rt`: 持有已验证再平衡周期、后台停止信号和分区组状态的运行时。
///
/// 返回:后台停止时退出;每轮等待再平衡动作结束,失败后延迟至下一周期继续尝试。
/// 已发布的持有事件与排干责任仍由协调器收口,不因轮次报错而回滚。
pub(super) async fn rebalance_loop(rt: Arc<GroupRuntime>) {
    let period = Duration::from_millis(rt.cfg.rebalance_ms);
    let mut tick = tokio::time::interval(period);
    tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
    loop {
        tokio::select! {
            _ = rt.bg_cancel.cancelled() => {
                return;
            }
            _ = tick.tick() => {
            }
        }
        if let Err(e) = rebalance_once(&rt).await {
            tracing::warn!(err = %e, "再平衡轮次失败,下轮重试");
        }
    }
}

/// 业务作用:刷新组心跳并按存活节点分配份额,取得来源或提交幂等的保留目标。
///
/// 参数说明:
/// - `rt`: 周期或 wake 触发的物理分区组,提供节点身份、心跳布局、来源锁和协调器通道。
///
/// 返回:已有轮次执行时直接成功;否则刷新心跳、估算份额并串行尝试取得缺少的来源锁。
/// Redis 失败立即返回错误,已经发布的事件不撤销;超额时只提交保留目标,实际解锁由协调器在排干后执行。
pub(super) async fn rebalance_once(rt: &Arc<GroupRuntime>) -> Result<()> {
    // 周期与 wake 共用单轮互斥,合并并发触发,避免同时发布相互竞争的持有决策。
    let _guard = match rt.rebalance_lock.try_lock() {
        Ok(g) => g,
        Err(_) => return Ok(()),
    };
    let nodes_key = rt.layout.nodes();
    // LegacyV1 与 Java 节点共享墙钟 score;RustV2 使用 Redis TIME 避免节点时钟漂移影响存活判断。
    let now_ms: f64 = if rt.client.profile() == crate::config::CompatibilityProfile::RustV2 {
        super::command::redis_now(&rt.client).await? as f64
    } else {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("墙钟早于 epoch")
            .as_millis() as f64
    };
    let expire_at = now_ms + (3 * rt.cfg.rebalance_ms) as f64;

    // 先延长本节点存活证据再清理过期节点;份额只是争抢目标,实际独占性仍由各来源锁判定。
    rt.client
        .z_add(&nodes_key, expire_at, rt.node_id.as_str())
        .await?;
    rt.client
        .z_rem_range_by_score(&nodes_key, f64::NEG_INFINITY, now_ms)
        .await?;
    let alive = rt.client.z_card(&nodes_key).await?.max(1);

    // 节点数保持完整宽度,避免截断为零或更小除数;商至多为分区数,最少保留一次争抢机会。
    let fair = u64::from(rt.count).div_ceil(alive).max(1) as u32;
    let owned: Vec<u32> = rt.claimed.read().expect("claimed").clone();

    if (owned.len() as u32) < fair {
        // 只有取得分区锁后才能交给协调器建立来源;退出时停止争抢,已交接责任按原有排干顺序收口。
        let mut acquired = 0u32;
        let need = fair - owned.len() as u32;
        for p in 0..rt.count {
            if acquired >= need || rt.bg_cancel.is_cancelled() {
                break;
            }
            if owned.contains(&p) {
                continue;
            }
            if let Some(guard) = rt.lock.try_lock(&rt.layout.lock_business_key(p)).await? {
                acquired += 1;
                let _ = rt
                    .event_tx
                    .send(Event::ClaimAcquired {
                        p,
                        guard,
                    })
                    .await;
            }
        }
    } else if (owned.len() as u32) > fair {
        // claimed 包含仍在排干的持锁来源,只能用来触发份额归约,不能据此重复指定让出数量。
        // coordinator 以当前 Active 数量执行保留目标,并在真实 unlock 后发布 wake。
        let _ = rt
            .event_tx
            .send(Event::RetainShare {
                target: fair as usize,
            })
            .await;
    }
    Ok(())
}