Background jobs for Rust

use bullmq::{Queue, QueueOptions, JobOptions};

let queue = Queue::new("Paint", QueueOptions::default()).await?;
queue
    .add(
        "cars",
        serde_json::json!({"color": "blue"}),
        Some(JobOptions {
            delay: Some(30_000),
            ..Default::default()
        }),
    )
    .await?;

use bullmq::{Worker, WorkerOptions, Job};
use std::sync::Arc;

let worker = Worker::new(
    "Paint",
    Arc::new(|job: Job, _token| {
        Box::pin(async move {
            if job.name() == "cars" {
                paint_car(job.data()["color"].as_str().unwrap()).await;
            }
            Ok(serde_json::json!({"painted": true}))
        })
    }),
    WorkerOptions {
        concurrency: 100,
        ..Default::default()
    },
)
.await?;

use bullmq::{QueueEvent, QueueEvents, QueueEventsOptions};

let events = QueueEvents::new(
    "Paint",
    QueueEventsOptions::default(),
)
.await?;

while let Some(entry) = events.next_event().await {
    match entry.event {
        QueueEvent::Completed { job_id, .. } => {
            println!("Job {job_id} completed");
        }
        QueueEvent::Failed { job_id, failed_reason, .. } => {
            println!("Job {job_id} failed: {failed_reason}");
        }
        _ => {}
    }
}

use bullmq::job_scheduler::RepeatOptions;
use bullmq::{Queue, QueueOptions};

let queue = Queue::new("Paint", QueueOptions::default()).await?;

// Repeat job once every day at 3:15 (am)
queue
    .upsert_job_scheduler(
        "daily-submarine",
        RepeatOptions {
            pattern: Some("0 15 3 * * *".into()),
            ..Default::default()
        },
        Some("submarine"),
        Some(serde_json::json!({"color": "yellow"})),
        None,
    )
    .await?;

use bullmq::{Job, RateLimiterOptions, Worker, WorkerOptions};
use std::sync::Arc;

let worker = Worker::new(
    "Paint",
    Arc::new(|job: Job, _token| {
        Box::pin(async move {
            paint_car(&job).await;
            Ok(serde_json::Value::Null)
        })
    }),
    WorkerOptions {
        limiter: Some(RateLimiterOptions {
            max: 10,
            duration: 1000,
        }),
        ..Default::default()
    },
)
.await?;

use bullmq::{Queue, QueueOptions, JobOptions};
use bullmq::types::BackoffStrategy;

let queue = Queue::new("Paint", QueueOptions::default()).await?;

queue
    .add(
        "car",
        serde_json::json!({"color": "pink"}),
        Some(JobOptions {
            attempts: Some(3),
            backoff: Some(BackoffStrategy::Exponential(1000)),
            ..Default::default()
        }),
    )
    .await?;

use bullmq::{FlowJob, FlowProducer, FlowProducerOptions};

let flow = FlowProducer::new(FlowProducerOptions::default()).await?;

flow.add(FlowJob {
    name: "Renovate".into(),
    queue_name: "cars".into(),
    data: serde_json::json!({}),
    opts: None,
    prefix: None,
    children: Some(
        ["paint", "engine", "wheels"]
            .into_iter()
            .map(|name| FlowJob {
                name: name.into(),
                queue_name: "steps".into(),
                data: serde_json::json!({}),
                opts: None,
                prefix: None,
                children: None,
            })
            .collect(),
    ),
})
.await?;