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>,
}

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>

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 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.