Struct JobCtx 

pub struct JobCtx<'a> {
    pub storage: &'a Storage,
    pub router: &'a (dyn Router + Send + Sync),
    pub rate_limit: &'a RateLimiter,
    pub job_id: JobId,
    pub process_id: &'a str,
    pub host_id: &'a str,
    pub cancel: CancellationToken,
}

Per-invocation context passed to a handler’s run.

Handlers should use ctx.enqueue(req) to chain follow-up work — it applies the runtime’s router so req.queue_name = None is resolved automatically.

Fields

storage: &'a Storage

The backend-agnostic storage bundle. Handlers usually only need storage.jobs for follow-up enqueues; the other Arcs are exposed for read-only inspection.

router: &'a (dyn Router + Send + Sync)

The router used to fill in queue_name on enqueues.

rate_limit: &'a RateLimiter

Cluster-wide rate-limit budget. Handlers that talk to an external API (acquire("slack"), acquire("gh")) gate every upstream call through this so a sibling pod doesn’t independently spend the same budget.

job_id: JobId

Id of the row being processed.

process_id: &'a str

Worker name ("{queue}-{slot}-{host_id}").

host_id: &'a str

Process-boot ULID so handlers can correlate logs with the originating process across restarts.

cancel: CancellationToken

Honor this if the handler can cooperatively shut down — the supervisor signals it when the queue is paused or the process is exiting.

Implementations

impl JobCtx<'_>

pub async fn enqueue(&self, req: EnqueueRequest) -> Result<EnqueueOutcome>

Enqueue a follow-up job from inside a handler. The router fills in queue_name when the request doesn’t pin one. Retries up to 3× on transient writer-lock conflicts so a handler doesn’t abort a long fan-out loop because of a momentary lock race against another worker.

pub async fn enqueue_bulk( &self, reqs: Vec<EnqueueRequest>, ) -> Result<Vec<EnqueueOutcome>>

Enqueue many follow-up jobs in a single transaction. Use this from bootstrap-style handlers that produce hundreds-to-thousands of sub-jobs in one go — otherwise we’d take and release the underlying writer lock N times and starve heartbeats. Same 3× transient-conflict retry as Self::enqueue.

Trait Implementations

impl Debug for JobCtx<'_>

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

Formats the value using the given formatter.