Struct Queue 

pub struct Queue { /* private fields */ }

Dispatches jobs and wakes the workers of this process.

Implementations

impl Queue

pub async fn stats(&self) -> Result<QueueStats>

Counts for monitoring (the dashboard shows them).

pub async fn recent_batches(&self, limit: u32) -> Result<Vec<BatchStatus>>

The most recent batches, newest first.

impl Queue

pub async fn dispatch<J: Job>(&self, job: J) -> Result<i64>

Queues a job to run as soon as a worker is free; returns its id.

pub async fn dispatch_after<J: Job>( &self, job: J, delay: Duration, ) -> Result<i64>

Queues a job to run after delay; returns its id.

pub async fn dispatch_on<J: Job>(&self, queue: &str, job: J) -> Result<i64>

Queues a job on queue instead of its Job::QUEUE.

pub async fn dispatch_in<J: Job>( &self, tx: &mut Transaction, job: J, ) -> Result<i64>

Queues a job inside tx, so it only exists if the transaction commits; workers pick it up within a second of the commit. Use it instead of dispatch while a transaction is open: on SQLite, which writes one transaction at a time, dispatch would wait for tx.

let mut tx = state.db.begin().await?;
let order_id: i64 = renox::db::sql("INSERT INTO orders (total) VALUES (?) RETURNING id")
    .bind(75_000)
    .scalar(&mut tx)
    .await?;
state.queue.dispatch_in(&mut tx, SendReceipt { order_id }).await?;
tx.commit().await?; // no order, no receipt

pub fn chain(&self) -> Chain

Jobs that run one after another: the next is queued when the one before succeeds, and a job that fails for good stops the chain (queue:retry resumes it).

pub fn batch(&self, name: &str) -> Batch

Jobs that run side by side, tracked together; see Batch.

pub async fn batch_status(&self, id: i64) -> Result<Option<BatchStatus>>

How a batch is doing; None if there’s no such batch.

pub async fn cancel_batch(&self, id: i64) -> Result<bool>

Cancels a batch: its jobs that haven’t run are skipped.

pub async fn pending(&self) -> Result<i64>

Jobs waiting or running.

pub async fn failed(&self) -> Result<Vec<FailedJob>>

Jobs that failed for good, oldest first.

pub async fn retry(&self, id: i64) -> Result<bool>

Puts the failed job id back on its queue with fresh attempts (and its chain and batch); returns whether there was such a job.

pub async fn retry_all(&self) -> Result<u64>

Puts every failed job back on its queue; returns how many.

pub async fn forget_failed(&self, id: i64) -> Result<bool>

Deletes one failed job; returns whether it existed.

pub async fn prune_failed(&self, age: Duration) -> Result<u64>

Deletes failed jobs older than age; returns how many.

pub async fn prune_batches(&self, age: Duration) -> Result<u64>

Deletes batches that finished (or were cancelled) more than age ago.

pub async fn flush_failed(&self) -> Result<u64>

Deletes failed jobs.

Trait Implementations

impl Clone for Queue

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.