Struct QueueManager 

pub struct QueueManager { /* private fields */ }

Dispatches jobs onto the configured queue.

The accessor behind the Queue facade.

Implementations

impl QueueManager

pub fn new(queue: Arc<dyn Queue>, registry: Arc<JobRegistry>) -> QueueManager

Dispatch onto queue.

pub fn with_locks(self, locks: LockManager) -> QueueManager

Enforce Job::unique_id with locks taken from locks.

Without this a job that declares a unique_id is dispatched normally. That is the deliberate choice: quietly not deduplicating is a bug you find in production, and quietly deduplicating against a per-process cache is the same bug wearing a hat. Wiring it is one line, and Rainier::boot does it.

A warning is logged the first time a unique job is dispatched without one, so the gap is visible rather than silent.

pub fn fake() -> QueueManager

A manager that records dispatches instead of performing them.

The test-double form of Queue::fake(): a test can assert that an action queued the right job without a worker ever running it.

pub fn is_faking(&self) -> bool

Whether this manager is recording instead of dispatching.

pub fn queue(&self) -> &Arc<dyn Queue>

The underlying queue.

pub fn registry(&self) -> &Arc<JobRegistry>

The job registry.

pub async fn dispatch<J>(&self, job: J) -> Result<Option<String>, Error>

where J: Job,

Queue job with its declared defaults.

pub async fn release_uniqueness(&self, key: &str) -> Result<bool, Error>

Release the uniqueness lock for a job that has finished.

Called by the worker. Releasing on completion rather than on dispatch is what makes the guarantee “one pending or running at a time” rather than “one every UNIQUE_FOR”.

A force_release rather than a token-checked one, and this is the one place that is right: the acquirer was the dispatching process, which is long gone and never handed its token over. Nothing else takes this key — dispatch is its only other user — and the job it belonged to is over.

pub fn pending<J>(&self, job: J) -> Result<PendingDispatch<'_>, Error>

where J: Job,

Start a dispatch that can be configured before sending.

queue.pending(SendInvoice { id })?.on_queue("billing").delay(TEN_MINUTES).send().await?;

pub async fn dispatch_on<J>( &self, queue: impl Into<String>, job: J, ) -> Result<Option<String>, Error>

where J: Job,

Queue job on a named queue.

pub async fn dispatch_after<J>( &self, delay: Duration, job: J, ) -> Result<Option<String>, Error>

where J: Job,

Queue job, held back for delay.

pub async fn dispatch_now<J>( &self, job: J, container: Arc<Container>, ) -> Result<(), Error>

where J: Job,

Run job right now instead of queueing it.

Bypasses the queue entirely, so failures surface to the caller. For a job the caller genuinely needs to have finished.

pub fn pushed<J>(&self) -> Vec<QueuedJob>

where J: Job,

Every recorded dispatch of J. Always empty unless faking.

pub fn all_pushed(&self) -> Vec<QueuedJob>

Every recorded dispatch, of any type.

pub fn assert_pushed<J>(&self)

where J: Job,

Panic unless a J was dispatched.

Panics

If none was, or the manager is not faking — which would otherwise make every assertion pass vacuously.

pub fn assert_pushed_times<J>(&self, times: usize)

where J: Job,

Panic unless exactly times J jobs were dispatched.

Panics

If the count differs, or the manager is not faking.

pub fn assert_not_pushed<J>(&self)

where J: Job,

Panic if any J was dispatched.

Panics

If one was, or the manager is not faking.

pub fn assert_pushed_on<J>(&self, queue: &str)

where J: Job,

Panic unless a J was dispatched onto queue.

Panics

If none was, or the manager is not faking.

Trait Implementations

impl Debug for QueueManager

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

Formats the value using the given formatter.