Crate armature_queue 

Job queue and background processing for Armature framework.

Provides a robust job queue system with:

• 📦 Redis-backed persistence
• 🔄 Automatic retries with exponential backoff
• ⭐ Job priorities
• ⏰ Delayed/scheduled jobs
• 💀 Dead letter queue
• 📊 Job progress tracking
• 🎯 Multiple queues
• 👷 Worker pools

Quick Start - Job Creation

use armature_queue::{Job, JobData, JobPriority};
use serde_json::json;

let job = Job::new(
    "emails",
    "send_welcome",
    json!({"to": "user@example.com"})
);

assert_eq!(job.queue, "emails");
assert_eq!(job.job_type, "send_welcome");
assert_eq!(job.priority, JobPriority::Normal);

Job Priorities

use armature_queue::{Job, JobData, JobPriority};
use serde_json::json;

// Create high priority job
let urgent = Job::new(
    "tasks",
    "urgent_task",
    json!({})
).with_priority(JobPriority::High);

// Create low priority job
let background = Job::new(
    "tasks",
    "cleanup",
    json!({})
).with_priority(JobPriority::Low);

assert_eq!(urgent.priority, JobPriority::High);
assert_eq!(background.priority, JobPriority::Low);
assert!(urgent.priority > background.priority);

Delayed Jobs

use armature_queue::Job;
use serde_json::json;
use chrono::Duration;

// Schedule job to run in 1 hour
let scheduled = Job::new(
    "emails",
    "reminder",
    json!({"message": "Don't forget!"})
).schedule_after(Duration::hours(1));

assert!(scheduled.scheduled_at.is_some());

Queue Configuration

use armature_queue::QueueConfig;
use std::time::Duration;

let config = QueueConfig::new("redis://localhost:6379", "emails")
    .with_key_prefix("myapp:queue:emails")
    .with_max_size(10000)
    .with_retention_time(Duration::from_secs(86400));

assert_eq!(config.queue_name, "emails");
assert_eq!(config.max_size, 10000);
assert_eq!(config.retention_time, Duration::from_secs(86400));

Complete Example

use armature_queue::*;

#[tokio::main]
async fn main() -> Result<(), QueueError> {
    // Create a queue
    let queue = Queue::new("redis://localhost:6379", "default").await?;

    // Enqueue a job
    let job_id = queue.enqueue(
        "send_email",
        serde_json::json!({
            "to": "user@example.com",
            "subject": "Hello"
        })
    ).await?;

    // Process jobs
    let mut worker = Worker::new(queue);
    worker.register_handler("send_email", |job| async move {
        // Send email logic
        Ok(())
    });

    worker.start().await?;

    Ok(())
}

Re-exports

pub use error::QueueError;

pub use error::QueueResult;

pub use job::Job;

pub use job::JobData;

pub use job::JobId;

pub use job::JobPriority;

pub use job::JobState;

pub use job::JobStatus;

pub use queue::Queue;

pub use queue::QueueConfig;

pub use worker::JobHandler;

pub use worker::Worker;

pub use worker::WorkerConfig;

Modules

error

Error types for queue operations.

job

Job definition and state management.

prelude

Re-export commonly used types

queue

Queue implementation with Redis backend.

worker

Worker implementation for processing jobs.