use std::collections::{BTreeMap, HashMap, VecDeque};
use std::sync::Arc;
use crate::client::RedisClient;
use crate::error::{NasaRedisError, Result};
use crate::job::config::JobConfig;
use crate::job::definition::JobDefinition;
use crate::job::keyspace::JobKeyspace;
use crate::job::metrics::JobFireResult;
use crate::job::model::{JobMisfire, JobScheduleType, JobTrigger};
use crate::job::repository::{FireDueBatchItem, JobRepository};
use crate::job::trigger::{first_fire_at_after, next_fire_at};
const CRON_ADVANCE_LIMIT: usize = 1_000_000;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct JobScanOutcome {
pub fired: usize,
pub schedule_lag_ms: i64,
pub fire_results: BTreeMap<JobFireResult, u64>,
}
pub struct JobScanner {
repository: JobRepository,
config: Arc<JobConfig>,
definitions: HashMap<String, JobDefinition>,
}
impl JobScanner {
pub fn new(client: Arc<RedisClient>, keyspace: JobKeyspace, config: Arc<JobConfig>) -> Self {
let repository = JobRepository::new(client, keyspace, config.clone());
Self {
repository,
config,
definitions: HashMap::new(),
}
}
pub fn register_definition(&mut self, definition: JobDefinition) {
self.definitions
.insert(definition.name().to_owned(), definition);
}
pub async fn scan_once(&self, shard: u32) -> Result<usize> {
Ok(self.scan_once_observed(shard).await?.fired)
}
pub(crate) async fn scan_once_observed(&self, shard: u32) -> Result<JobScanOutcome> {
let mut outcome = JobScanOutcome {
fired: 0,
schedule_lag_ms: 0,
fire_results: BTreeMap::new(),
};
for _ in 0..self.config.need_recompute_max_retries {
let scan = self
.repository
.scan_schedule_due(shard, self.config.scan_batch_size)
.await?;
if !scan.namespace_enabled {
return Ok(outcome);
}
let mut requests = Vec::new();
for entry in &scan.entries {
let Some(definition) = self.definitions.get(&entry.job_name) else {
continue;
};
if definition.trigger() == JobTrigger::FanoutOnly
|| definition.definition_revision() != entry.definition_revision
{
continue;
}
outcome.schedule_lag_ms = outcome
.schedule_lag_ms
.max(scan.redis_now.saturating_sub(entry.logical_fire_at).max(0));
requests.extend(self.fire_requests(
definition,
entry.logical_fire_at,
scan.redis_now,
)?);
}
let mut need_recompute = false;
for batch in requests.chunks(self.config.scan_batch_size as usize) {
let results = self.repository.fire_due_batch(shard, batch).await?;
for result in results {
let fire_result = JobFireResult::from_script_code(&result.code)
.ok_or_else(|| config_error("批量触发返回未知状态码"))?;
*outcome.fire_results.entry(fire_result).or_default() += 1;
match fire_result {
JobFireResult::Fired | JobFireResult::Adopted => {
outcome.fired = outcome.fired.saturating_add(1);
}
JobFireResult::NeedRecompute => need_recompute = true,
_ => {}
}
}
if need_recompute {
break;
}
}
if !need_recompute {
return Ok(outcome);
}
}
Ok(outcome)
}
fn fire_requests<'a>(
&self,
definition: &'a JobDefinition,
expected: i64,
redis_now: i64,
) -> Result<Vec<FireDueBatchItem<'a>>> {
let missed =
redis_now.saturating_sub(expected) > self.config.schedule_rtt_allowance_ms as i64;
if definition.schedule_type() == JobScheduleType::FixedDelay {
if missed && definition.misfire() == JobMisfire::DoNothing {
return Ok(vec![item(
definition,
expected,
self.next_after_now(definition, expected, redis_now)?,
true,
true,
true,
)]);
}
return Ok(vec![item(definition, expected, 0, false, missed, false)]);
}
if !missed {
return Ok(vec![item(
definition,
expected,
next_fire_at(definition, expected)?,
false,
false,
true,
)]);
}
match definition.misfire() {
JobMisfire::DoNothing => Ok(vec![item(
definition,
expected,
self.next_after_now(definition, expected, redis_now)?,
true,
true,
true,
)]),
JobMisfire::FireOnceNow => Ok(vec![item(
definition,
expected,
self.next_after_now(definition, expected, redis_now)?,
false,
true,
true,
)]),
JobMisfire::CatchUp => self.catch_up_requests(definition, expected, redis_now),
}
}
fn catch_up_requests<'a>(
&self,
definition: &'a JobDefinition,
expected: i64,
redis_now: i64,
) -> Result<Vec<FireDueBatchItem<'a>>> {
let cutoff = redis_now
.saturating_sub(self.config.max_catch_up_window_ms as i64)
.max(0);
let first = self.first_at_or_after(definition, expected, cutoff)?;
let limit = self.config.max_catch_up_runs as usize;
let mut selected = VecDeque::with_capacity(limit);
let cursor =
if definition.schedule_type() == JobScheduleType::FixedRate && first <= redis_now {
let interval = definition.interval_ms() as i64;
let total = (redis_now - first) / interval + 1;
let retained = total.min(self.config.max_catch_up_runs as i64);
let selected_first = checked_add_mul(first, total - retained, interval)?;
for index in 0..retained {
selected.push_back(checked_add_mul(selected_first, index, interval)?);
}
checked_add_mul(first, total, interval)?
} else {
let mut next = first;
let mut advanced = 0;
while next <= redis_now {
if selected.len() == limit {
selected.pop_front();
}
selected.push_back(next);
next = next_fire_at(definition, next)?;
advanced += 1;
if advanced > CRON_ADVANCE_LIMIT {
return Err(config_error("CATCH_UP 推进次数超过安全上限"));
}
}
next
};
if selected.is_empty() {
return Ok(vec![item(definition, expected, cursor, true, true, true)]);
}
let mut requests = Vec::with_capacity(selected.len() + 1);
let first_selected = *selected.front().expect("selected 已确认非空");
if first_selected != expected {
requests.push(item(
definition,
expected,
first_selected,
true,
true,
false,
));
}
let times: Vec<i64> = selected.into_iter().collect();
for (index, current) in times.iter().copied().enumerate() {
let next = times.get(index + 1).copied().unwrap_or(cursor);
requests.push(item(
definition,
current,
next,
false,
true,
index + 1 == times.len(),
));
}
Ok(requests)
}
fn next_after_now(
&self,
definition: &JobDefinition,
logical_fire_at: i64,
redis_now: i64,
) -> Result<i64> {
first_fire_at_after(definition, logical_fire_at, redis_now)
}
fn first_at_or_after(
&self,
definition: &JobDefinition,
expected: i64,
cutoff: i64,
) -> Result<i64> {
if expected >= cutoff {
return Ok(expected);
}
if definition.schedule_type() == JobScheduleType::FixedRate {
let interval = definition.interval_ms() as i64;
let distance = cutoff - expected;
let steps = distance
.checked_add(interval - 1)
.ok_or_else(|| config_error("固定速率补偿距离溢出"))?
/ interval;
return checked_add_mul(expected, steps, interval);
}
let mut cursor = expected;
for _ in 0..CRON_ADVANCE_LIMIT {
if cursor >= cutoff {
return Ok(cursor);
}
cursor = next_fire_at(definition, cursor)?;
}
Err(config_error("Cron 无法在推进预算内进入补偿窗口"))
}
}
fn item(
definition: &JobDefinition,
logical_fire_at: i64,
proposed_next_fire_at: i64,
skip_run: bool,
misfire: bool,
must_end_in_future: bool,
) -> FireDueBatchItem<'_> {
FireDueBatchItem {
definition,
logical_fire_at,
proposed_next_fire_at,
skip_run,
misfire,
must_end_in_future,
}
}
fn checked_add_mul(base: i64, count: i64, interval: i64) -> Result<i64> {
let delta = count
.checked_mul(interval)
.ok_or_else(|| config_error("固定速率补偿乘法溢出"))?;
base.checked_add(delta)
.ok_or_else(|| config_error("固定速率补偿时刻溢出"))
}
fn config_error(message: &str) -> NasaRedisError {
crate::job::JobError::Config(format!("scanner {message}")).into()
}