Struct Job 

pub struct Job {

    pub id: String,
    pub job_type: String,
    pub payload: HashMap<String, Value>,
    pub priority: JobPriority,
    pub status: JobStatus,
    pub max_retries: u32,
    pub retry_count: u32,
    pub created_at: DateTime<Utc>,
    pub scheduled_at: Option<DateTime<Utc>>,
    pub started_at: Option<DateTime<Utc>>,
    pub completed_at: Option<DateTime<Utc>>,
    pub timeout_seconds: Option<u64>,
    pub last_heartbeat: u64,
    pub lease_duration: u64,
}

A durable background job

Represents a unit of work that can be queued, scheduled, retried, and tracked. Jobs are persisted to disk and survive restarts. Use the builder pattern to configure job properties.

Examples

use aurora_db::workers::{Job, JobPriority};
use serde_json::json;

// Simple job
let job = Job::new("send_email")
    .add_field("to", json!("user@example.com"))
    .add_field("subject", json!("Welcome!"));

// Job with all options
let job = Job::new("process_video")
    .add_field("video_id", json!("vid-123"))
    .add_field("resolution", json!("1080p"))
    .with_priority(JobPriority::High)
    .with_max_retries(5)
    .with_timeout(600) // 10 minutes
    .scheduled_at(chrono::Utc::now() + chrono::Duration::hours(1));

Fields

id: String

job_type: String

payload: HashMap<String, Value>

priority: JobPriority

status: JobStatus

max_retries: u32

retry_count: u32

created_at: DateTime<Utc>

scheduled_at: Option<DateTime<Utc>>

started_at: Option<DateTime<Utc>>

completed_at: Option<DateTime<Utc>>

timeout_seconds: Option<u64>

last_heartbeat: u64

Unix timestamp of last “I’m alive” signal from worker (for Reaper)

lease_duration: u64

Seconds before worker is considered dead (default: 30)

Implementations

impl Job

pub fn new(job_type: impl Into<String>) -> Self

Create a new job

Creates a job with default settings:

• Priority: Normal
• Max retries: 3
• Timeout: 5 minutes
• Status: Pending

Arguments

• job_type - Type identifier for routing to the correct handler

Examples

// Create different job types let email = Job::new(“send_email”); let image = Job::new(“resize_image”); let report = Job::new(“generate_report”);

pub fn with_payload(self, payload: HashMap<String, Value>) -> Self

Set job payload from a HashMap

Replaces the entire payload with the provided HashMap. For adding individual fields, use add_field() instead.

Examples

use std::collections::HashMap; use serde_json::json;

let mut payload = HashMap::new(); payload.insert(“user_id”.to_string(), json!(“123”)); payload.insert(“amount”.to_string(), json!(99.99));

let job = Job::new(“process_payment”) .with_payload(payload);

pub fn add_field(self, key: impl Into<String>, value: Value) -> Self

Add a single field to the job payload

Use this for building the payload incrementally. Can be chained multiple times.

Examples

use serde_json::json;

let job = Job::new(“send_email”) .add_field(“to”, json!(“user@example.com”)) .add_field(“subject”, json!(“Welcome!”)) .add_field(“template”, json!(“welcome_email”)) .add_field(“vars”, json!({“name”: “Alice”}));

pub fn with_priority(self, priority: JobPriority) -> Self

Set job priority

Higher priority jobs are executed before lower priority ones. Default is JobPriority::Normal.

Examples

// Critical - payments, security operations let payment = Job::new(“charge_card”) .with_priority(JobPriority::Critical);

// High - user-facing operations let notification = Job::new(“push_notification”) .with_priority(JobPriority::High);

// Low - background cleanup, analytics let cleanup = Job::new(“clean_old_logs”) .with_priority(JobPriority::Low);

pub fn with_max_retries(self, max_retries: u32) -> Self

Set maximum retry attempts

If a job fails, it will be retried up to this many times with exponential backoff. Default is 3 retries.

Examples

// Network operation - retry more let api_call = Job::new(“fetch_api_data”) .with_max_retries(5);

// Critical operation - don’t retry let one_time = Job::new(“send_invoice”) .with_max_retries(0);

// Flaky operation - retry extensively let external = Job::new(“third_party_webhook”) .with_max_retries(10);

pub fn scheduled_at(self, at: DateTime<Utc>) -> Self

Schedule job for later execution

Job will not be executed until the specified time. Useful for reminders, scheduled reports, delayed notifications.

Examples

use chrono::{Utc, Duration};

// Run in 1 hour let reminder = Job::new(“send_reminder”) .add_field(“message”, json!(“Meeting starts soon”)) .scheduled_at(Utc::now() + Duration::hours(1));

// Run at specific time let report = Job::new(“daily_report”) .scheduled_at(Utc::now().date_naive().and_hms_opt(9, 0, 0).unwrap());

// Delayed retry pattern let retry = Job::new(“retry_failed_upload”) .scheduled_at(Utc::now() + Duration::minutes(30));

pub fn with_timeout(self, seconds: u64) -> Self

Set job execution timeout

Job will be terminated if it runs longer than this. Default is 300 seconds (5 minutes).

Examples

// Quick task let quick = Job::new(“send_sms”) .with_timeout(30); // 30 seconds

// Long-running task let video = Job::new(“transcode_video”) .with_timeout(3600); // 1 hour

// Very long task let batch = Job::new(“process_millions_of_records”) .with_timeout(7200); // 2 hours

pub fn should_run(&self) -> bool

Check if job should be executed (based on schedule)

pub fn mark_running(&mut self)

Mark job as running

pub fn touch(&mut self)

Update heartbeat timestamp to “now”

Workers should call this periodically while processing a job. The Reaper uses this to detect dead workers.

pub fn is_heartbeat_expired(&self) -> bool

Check if job’s heartbeat has expired (worker presumed dead)

pub fn with_lease_duration(self, seconds: u64) -> Self

Set custom lease duration

pub fn mark_completed(&mut self)

Mark job as completed

pub fn mark_failed(&mut self, error: String)

Mark job as failed

pub fn next_retry_delay(&self) -> Duration

Calculate next retry delay (exponential backoff)

Trait Implementations

impl Clone for Job

fn clone(&self) -> Job

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Job

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Job

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Job

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

where __S: Serializer,

Serialize this value into the given Serde serializer.