Struct RepeatableSpec 

pub struct RepeatableSpec<T> {
    pub key: String,
    pub job_name: String,
    pub pattern: RepeatPattern,
    pub payload: T,
    pub limit: Option<u64>,
    pub start_after_ms: Option<u64>,
    pub end_before_ms: Option<u64>,
    pub missed_fires: MissedFiresPolicy,
}

A recurring job spec.

T is the payload type — same constraint as Producer<T>. Stored on Redis as msgpack inside the {chasqui:<queue>}:repeat:spec:<key> hash under field spec.

Catch-up after scheduler downtime is governed by RepeatableSpec::missed_fires; see MissedFiresPolicy for the three options. The default (MissedFiresPolicy::Skip) drops missed windows and resumes on the first future fire — safe for any payload, no thundering herd on restart.

Fields

key: String

Stable identifier. Auto-derived from job_name::pattern_signature if left empty. See module docs for the divergence from BullMQ’s hashing scheme.

job_name: String

User-facing job name carried into each fired Job<T>.

pattern: RepeatPattern

What schedules the next fire time.

payload: T

The payload that every fire of this spec emits. Cloned and re-encoded per fire (the spec itself is encoded once at upsert).

limit: Option<u64>

Maximum number of fires; None means unlimited. Decremented in the same Lua tick that schedules the next fire.

start_after_ms: Option<u64>

Earliest fire time in epoch milliseconds. Fires before this are skipped.

end_before_ms: Option<u64>

Latest fire time in epoch milliseconds. Once next_fire_ms > end_before_ms the spec is removed from the repeat ZSET.

missed_fires: MissedFiresPolicy

What to do with windows that elapsed while the scheduler was down. Defaults to MissedFiresPolicy::Skip — drop missed windows and resume on the first future fire. See MissedFiresPolicy for the other options.

Trailing optional with skip_serializing_if so the field is omitted from the encoded msgpack when set to the default — pre-existing stored specs (no missed_fires field on the wire) continue to decode unchanged into the new shape with Skip.

Implementations

impl<T> RepeatableSpec<T>

pub fn new( job_name: impl Into<String>, pattern: RepeatPattern, payload: T, ) -> Self

Construct a new spec with sensible defaults — the recommended construction path going forward. Pair with the chainable with_key / with_limit / with_start_after_ms / with_end_before_ms / with_missed_fires setters to override individual fields.

Defaults:

• key: empty (auto-derived from job_name::pattern_signature — see resolved_key).
• limit: None (unlimited fires).
• start_after_ms / end_before_ms: None (no time window).
• missed_fires: MissedFiresPolicy::Skip (drop missed windows on scheduler restart — safe default, no thundering herd).

The struct fields remain pub for back-compat with callers that destructure or use field-by-field literals; the constructor is an additional path that survives future field additions without breaking call sites.

pub fn with_key(self, key: impl Into<String>) -> Self

Set a stable identifier for this spec. Empty (the default) means auto-derive from job_name::pattern_signature.

pub fn with_limit(self, limit: u64) -> Self

Cap the total number of fires this spec emits before the scheduler removes it.

pub fn with_start_after_ms(self, ms: u64) -> Self

Earliest fire time in epoch ms; fires before this are skipped.

pub fn with_end_before_ms(self, ms: u64) -> Self

Latest fire time in epoch ms; once next_fire_ms > end_before_ms, the scheduler removes the spec.

pub fn with_missed_fires(self, policy: MissedFiresPolicy) -> Self

Override the catch-up policy for missed windows. See MissedFiresPolicy.

pub fn resolved_key(&self) -> String

Resolve the effective key for this spec, deriving a default if the user supplied an empty string.

Trait Implementations

impl<T: Clone> Clone for RepeatableSpec<T>

fn clone(&self) -> RepeatableSpec<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for RepeatableSpec<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for RepeatableSpec<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for RepeatableSpec<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.