use crate::error::{NasaRedisError, Result};
use crate::idempotent::wire::framed_digest;
use crate::job::identifiers::worker_key;
use crate::job::model::{
JobConcurrency, JobFanoutFailurePolicy, JobMisfire, JobScheduleType, JobTrigger, JobWireCodec,
};
use crate::job::names::require_name;
use crate::job::trigger::validate_cron_compatibility;
#[derive(Debug, Clone)]
pub struct JobDefinition {
qualifier: String,
name: String,
worker_name: String,
trigger: JobTrigger,
schedule_type: JobScheduleType,
cron: String,
zone: String,
interval_ms: u64,
concurrency: JobConcurrency,
misfire: JobMisfire,
timeout_ms: u64,
max_attempts: u32,
retry_delay_ms: u64,
contract_revision: i64,
schema_id: String,
codecs: Vec<JobWireCodec>,
fanout_receipt_timeout_ms: u64,
fanout_receipt_max_retries: u32,
fanout_failure_policy: JobFanoutFailurePolicy,
definition_revision: i64,
worker_key: String,
wire_codecs: String,
definition_digest: String,
}
impl JobDefinition {
pub fn builder(name: impl Into<String>) -> JobDefinitionBuilder {
JobDefinitionBuilder::new(name.into())
}
pub fn qualifier(&self) -> &str {
&self.qualifier
}
pub fn name(&self) -> &str {
&self.name
}
pub fn worker_name(&self) -> &str {
&self.worker_name
}
pub fn trigger(&self) -> JobTrigger {
self.trigger
}
pub fn schedule_type(&self) -> JobScheduleType {
self.schedule_type
}
pub fn cron(&self) -> &str {
&self.cron
}
pub fn zone(&self) -> &str {
&self.zone
}
pub fn interval_ms(&self) -> u64 {
self.interval_ms
}
pub fn concurrency(&self) -> JobConcurrency {
self.concurrency
}
pub fn misfire(&self) -> JobMisfire {
self.misfire
}
pub fn timeout_ms(&self) -> u64 {
self.timeout_ms
}
pub fn max_attempts(&self) -> u32 {
self.max_attempts
}
pub fn retry_delay_ms(&self) -> u64 {
self.retry_delay_ms
}
pub fn contract_revision(&self) -> i64 {
self.contract_revision
}
pub fn schema_id(&self) -> &str {
&self.schema_id
}
pub fn codecs(&self) -> &[JobWireCodec] {
&self.codecs
}
pub fn fanout_receipt_timeout_ms(&self) -> u64 {
self.fanout_receipt_timeout_ms
}
pub fn fanout_receipt_max_retries(&self) -> u32 {
self.fanout_receipt_max_retries
}
pub fn fanout_failure_policy(&self) -> JobFanoutFailurePolicy {
self.fanout_failure_policy
}
pub fn definition_revision(&self) -> i64 {
self.definition_revision
}
pub fn worker_key(&self) -> &str {
&self.worker_key
}
pub fn wire_codecs(&self) -> &str {
&self.wire_codecs
}
pub fn definition_digest(&self) -> &str {
&self.definition_digest
}
}
#[derive(Debug, Clone)]
pub struct JobDefinitionBuilder {
qualifier: String,
name: String,
worker_name: Option<String>,
trigger: JobTrigger,
cron: String,
zone: String,
fixed_rate_ms: u64,
fixed_delay_ms: u64,
concurrency: JobConcurrency,
misfire: JobMisfire,
timeout_ms: u64,
max_attempts: u32,
retry_delay_ms: u64,
contract_revision: i64,
schema_id: String,
codecs: Vec<JobWireCodec>,
fanout_receipt_timeout_ms: u64,
fanout_receipt_max_retries: u32,
fanout_failure_policy: JobFanoutFailurePolicy,
definition_revision: i64,
}
impl JobDefinitionBuilder {
fn new(name: String) -> Self {
Self {
qualifier: "primary".to_owned(),
name,
worker_name: None,
trigger: JobTrigger::Scheduled,
cron: String::new(),
zone: "UTC".to_owned(),
fixed_rate_ms: 0,
fixed_delay_ms: 0,
concurrency: JobConcurrency::SerialQueue,
misfire: JobMisfire::FireOnceNow,
timeout_ms: 120_000,
max_attempts: 3,
retry_delay_ms: 10_000,
contract_revision: 1,
schema_id: String::new(),
codecs: vec![JobWireCodec::Json],
fanout_receipt_timeout_ms: 2_000,
fanout_receipt_max_retries: 3,
fanout_failure_policy: JobFanoutFailurePolicy::ReassignOnFailure,
definition_revision: 1,
}
}
pub fn qualifier(mut self, qualifier: impl Into<String>) -> Self {
self.qualifier = qualifier.into();
self
}
pub fn worker_name(mut self, worker_name: impl Into<String>) -> Self {
self.worker_name = Some(worker_name.into());
self
}
pub fn cron(mut self, cron: impl Into<String>, zone: impl Into<String>) -> Result<Self> {
let cron = cron.into();
let zone = zone.into();
validate_cron_compatibility(cron.trim(), zone.trim())?;
self.cron = cron.trim().to_owned();
self.zone = zone.trim().to_owned();
Ok(self)
}
pub fn manual(mut self) -> Self {
self.trigger = JobTrigger::Scheduled;
self.cron.clear();
self.fixed_rate_ms = 0;
self.fixed_delay_ms = 0;
self
}
pub fn fanout_only(mut self) -> Self {
self.trigger = JobTrigger::FanoutOnly;
self.cron.clear();
self.fixed_rate_ms = 0;
self.fixed_delay_ms = 0;
self
}
pub fn fixed_rate_ms(mut self, interval_ms: u64) -> Self {
self.fixed_rate_ms = interval_ms;
self
}
pub fn fixed_delay_ms(mut self, interval_ms: u64) -> Self {
self.fixed_delay_ms = interval_ms;
self
}
pub fn trigger(mut self, trigger: JobTrigger) -> Self {
self.trigger = trigger;
self
}
pub fn concurrency(mut self, concurrency: JobConcurrency) -> Self {
self.concurrency = concurrency;
self
}
pub fn misfire(mut self, misfire: JobMisfire) -> Self {
self.misfire = misfire;
self
}
pub fn timeout_ms(mut self, timeout_ms: u64) -> Self {
self.timeout_ms = timeout_ms;
self
}
pub fn max_attempts(mut self, max_attempts: u32) -> Self {
self.max_attempts = max_attempts;
self
}
pub fn retry_delay_ms(mut self, retry_delay_ms: u64) -> Self {
self.retry_delay_ms = retry_delay_ms;
self
}
pub fn contract_revision(mut self, contract_revision: i64) -> Self {
self.contract_revision = contract_revision;
self
}
pub fn schema_id(mut self, schema_id: impl Into<String>) -> Self {
self.schema_id = schema_id.into();
self
}
pub fn codecs(mut self, codecs: impl IntoIterator<Item = JobWireCodec>) -> Self {
self.codecs = codecs.into_iter().collect();
self
}
pub fn fanout_receipt(mut self, timeout_ms: u64, max_retries: u32) -> Self {
self.fanout_receipt_timeout_ms = timeout_ms;
self.fanout_receipt_max_retries = max_retries;
self
}
pub fn fanout_failure_policy(mut self, policy: JobFanoutFailurePolicy) -> Self {
self.fanout_failure_policy = policy;
self
}
pub fn definition_revision(mut self, revision: i64) -> Self {
self.definition_revision = revision;
self
}
pub fn build(self) -> Result<JobDefinition> {
let qualifier_source = if self.qualifier.trim().is_empty() {
"primary"
} else {
self.qualifier.trim()
};
let qualifier = require_name(qualifier_source, "qualifier")?;
if qualifier.contains(':') {
return Err(cfg("qualifier 不得包含 ':'"));
}
let name = require_name(&self.name, "name")?;
let worker_source = if self.trigger == JobTrigger::FanoutOnly
|| self
.worker_name
.as_deref()
.is_none_or(|w| w.trim().is_empty())
{
name.clone()
} else {
self.worker_name.clone().unwrap()
};
let worker_name = require_name(&worker_source, "worker_name")?;
let schedule_type = resolve_schedule_type(&self)?;
let cron = self.cron.trim().to_owned();
let interval_ms = match schedule_type {
JobScheduleType::FixedRate => self.fixed_rate_ms,
JobScheduleType::FixedDelay => self.fixed_delay_ms,
_ => 0,
};
if interval_ms > i64::MAX as u64 {
return Err(cfg("固定调度间隔超出 Redis 毫秒时间范围"));
}
let schema_id = if self.schema_id.trim().is_empty() {
worker_name.clone()
} else {
self.schema_id.trim().to_owned()
};
if self.codecs.is_empty() {
return Err(cfg("codecs 不能为空"));
}
let mut codec_names: Vec<&'static str> =
self.codecs.iter().map(|c| c.wire_name()).collect();
codec_names.sort_unstable();
codec_names.dedup();
let mut codecs: Vec<JobWireCodec> = codec_names
.iter()
.map(|n| JobWireCodec::parse(n).expect("wire_name 恒可解析"))
.collect();
codecs.dedup();
require_positive_u64(self.timeout_ms, "timeout_ms")?;
require_positive_u32(self.max_attempts, "max_attempts")?;
require_positive_u64(self.retry_delay_ms, "retry_delay_ms")?;
require_positive_i64(self.contract_revision, "contract_revision")?;
require_positive_u64(self.fanout_receipt_timeout_ms, "fanout_receipt_timeout_ms")?;
require_positive_i64(self.definition_revision, "definition_revision")?;
let wire_codecs = codec_names.join(",");
let worker_key = worker_key(&worker_name);
let definition_digest = compute_digest(
&name,
&worker_name,
self.trigger,
schedule_type,
&cron,
&self.zone,
interval_ms,
self.concurrency,
self.misfire,
self.timeout_ms,
self.max_attempts,
self.retry_delay_ms,
self.contract_revision,
&schema_id,
&codec_names,
self.fanout_receipt_timeout_ms,
self.fanout_receipt_max_retries,
self.fanout_failure_policy,
);
Ok(JobDefinition {
qualifier,
name,
worker_name,
trigger: self.trigger,
schedule_type,
cron,
zone: self.zone,
interval_ms,
concurrency: self.concurrency,
misfire: self.misfire,
timeout_ms: self.timeout_ms,
max_attempts: self.max_attempts,
retry_delay_ms: self.retry_delay_ms,
contract_revision: self.contract_revision,
schema_id,
codecs,
fanout_receipt_timeout_ms: self.fanout_receipt_timeout_ms,
fanout_receipt_max_retries: self.fanout_receipt_max_retries,
fanout_failure_policy: self.fanout_failure_policy,
definition_revision: self.definition_revision,
worker_key,
wire_codecs,
definition_digest,
})
}
}
fn resolve_schedule_type(builder: &JobDefinitionBuilder) -> Result<JobScheduleType> {
let has_cron = !builder.cron.trim().is_empty();
if builder.trigger == JobTrigger::FanoutOnly {
if has_cron || builder.fixed_rate_ms > 0 || builder.fixed_delay_ms > 0 {
return Err(cfg("FANOUT_ONLY 任务不能声明调度"));
}
return Ok(JobScheduleType::FanoutOnly);
}
let configured = u32::from(has_cron)
+ u32::from(builder.fixed_rate_ms > 0)
+ u32::from(builder.fixed_delay_ms > 0);
if configured > 1 {
return Err(cfg("cron、fixed_rate 与 fixed_delay 互斥"));
}
if configured == 0 {
return Ok(JobScheduleType::Manual);
}
if has_cron {
return Ok(JobScheduleType::Cron);
}
Ok(if builder.fixed_rate_ms > 0 {
JobScheduleType::FixedRate
} else {
JobScheduleType::FixedDelay
})
}
#[allow(clippy::too_many_arguments)]
fn compute_digest(
name: &str,
worker_name: &str,
trigger: JobTrigger,
schedule_type: JobScheduleType,
cron: &str,
zone: &str,
interval_ms: u64,
concurrency: JobConcurrency,
misfire: JobMisfire,
timeout_ms: u64,
max_attempts: u32,
retry_delay_ms: u64,
contract_revision: i64,
schema_id: &str,
codec_names: &[&str],
fanout_receipt_timeout_ms: u64,
fanout_receipt_max_retries: u32,
fanout_failure_policy: JobFanoutFailurePolicy,
) -> String {
let mut codec_field = String::new();
for codec in codec_names {
codec_field.push(',');
codec_field.push_str(codec);
}
let interval = interval_ms.to_string();
let timeout = timeout_ms.to_string();
let attempts = max_attempts.to_string();
let retry = retry_delay_ms.to_string();
let contract = contract_revision.to_string();
let receipt_timeout = fanout_receipt_timeout_ms.to_string();
let receipt_retries = fanout_receipt_max_retries.to_string();
let fields: [&str; 18] = [
name,
worker_name,
trigger.wire_name(),
schedule_type.wire_name(),
cron,
zone,
&interval,
concurrency.wire_name(),
misfire.wire_name(),
&timeout,
&attempts,
&retry,
&contract,
schema_id,
&codec_field,
&receipt_timeout,
&receipt_retries,
fanout_failure_policy.wire_name(),
];
hex::encode(framed_digest(
&fields.iter().map(|f| f.as_bytes()).collect::<Vec<_>>(),
))
}
fn require_positive_u64(value: u64, name: &str) -> Result<()> {
if value == 0 {
return Err(cfg(&format!("{name} 必须大于 0")));
}
Ok(())
}
fn require_positive_u32(value: u32, name: &str) -> Result<()> {
if value == 0 {
return Err(cfg(&format!("{name} 必须大于 0")));
}
Ok(())
}
fn require_positive_i64(value: i64, name: &str) -> Result<()> {
if value <= 0 {
return Err(cfg(&format!("{name} 必须大于 0")));
}
Ok(())
}
fn cfg(message: &str) -> NasaRedisError {
crate::job::JobError::Config(format!("definition {message}")).into()
}