Struct Job 

pub struct Job {

    pub id: String,
    pub kind: String,
    pub dedup_key: String,
    pub payload: Value,
    pub status: String,
    pub run_at: i64,
    pub attempts: i64,
    pub max_attempts: i64,
    pub deadline: Option<i64>,
    pub lease_until: Option<i64>,
    pub lease_owner: Option<String>,
    pub last_error: Option<String>,
    pub created_at: i64,
    pub updated_at: i64,
}

One stored job row.

status and kind come back as the strings they were stored as, for the reason crate::sqlite::audit::AuditEntry keeps event a String: an older binary meeting a row a newer one wrote should render it, not refuse to load. The runner never claims a kind its registry does not hold, so an unrecognised one is simply left alone.

Fields

id: String

kind: String

dedup_key: String

payload: Value

status: String

run_at: i64

attempts: i64

max_attempts: i64

deadline: Option<i64>

lease_until: Option<i64>

lease_owner: Option<String>

last_error: Option<String>

created_at: i64

updated_at: i64

Implementations

impl Job

pub async fn enqueue( row: NewJob<'_>, database: &Database, ) -> Result<bool, Error>

Queues one job, unless a live one already holds (kind, dedup_key).

Ok(false) is “already queued”, not an error: it is what two racing callers must both be able to survive, and the partial unique index is what decides which of them won. A job that already reached done or failed releases the identity, so the same key can be queued again — which is what makes a retried order and a periodic sweep both expressible without a second table.

pub async fn claim_next( runner_id: &str, kinds: &[&str], lease_until: i64, now: i64, database: &Database, ) -> Result<Option<Self>, Error>

Claims the oldest eligible job of one of kinds, or None.

One statement, and that is the point: the subselect picks a candidate and the outer AND status = 'ready' is what makes the pick binding, so two runners choosing the same row end with exactly one write. None collapses “the queue was empty” and “somebody else won” — which is correct, because the caller does the same thing either way.

attempts increments here rather than at completion: a job that reliably kills the process must still exhaust its budget, and nothing reports back from a process that died.

deadline is deliberately not filtered here. Skipping a dead row would leave it ready and re-read on every tick for ever; the runner claims it and retires it on the spot.

pub async fn complete( id: &str, runner_id: &str, database: &Database, ) -> Result<bool, Error>

Marks a claimed job finished. Ok(false) means the lease was lost.

pub async fn retry( id: &str, runner_id: &str, run_at: i64, error: &str, database: &Database, ) -> Result<bool, Error>

Returns a claimed job to the queue, to run again at run_at.

pub async fn reschedule( id: &str, runner_id: &str, run_at: i64, database: &Database, ) -> Result<bool, Error>

Returns a claimed job to the queue as a fresh occurrence: the attempt counter goes back to zero and the last error is cleared.

That reset is what separates a periodic job from a retried one. A sweep that runs every day for a year must not accumulate 365 attempts and retire itself, and a successful occurrence must not leave the previous failure’s text sitting on the row as though it were current.

pub async fn abandon( id: &str, runner_id: &str, error: &str, database: &Database, ) -> Result<bool, Error>

Retires a claimed job permanently, recording why.

pub async fn reclaim_expired( now: i64, database: &Database, ) -> Result<u64, Error>

Returns to the queue every job whose runner died holding its lease.

attempts is deliberately left alone: the attempt really was spent, and a counter rewritten to look better would let a job that crashes the process loop for ever.

pub async fn release_owned( runner_id: &str, database: &Database, ) -> Result<u64, Error>

Releases every lease this runner holds, without settling the jobs.

What a graceful shutdown runs, so a restart re-claims its own work immediately instead of waiting out a full lease.

pub async fn find_by_id( id: &str, database: &Database, ) -> Result<Option<Self>, Error>

One row by id.

pub async fn find_live( kind: &str, dedup_key: &str, database: &Database, ) -> Result<Option<Self>, Error>

The live job holding (kind, dedup_key), if there is one.

pub async fn count_live(kind: &str, database: &Database) -> Result<i64, Error>

How many live jobs of kind are queued or running.

The kind-wide counterpart to Self::find_live, for the callers that want “is there work of this sort outstanding?” without naming a dedup_key — a notify_deliver key is a per-occurrence uuid, so there is no single key to ask about.

pub async fn cleanup(cutoff: i64, database: &Database) -> Result<u64, Error>

Deletes terminal rows settled before cutoff, returning how many went.

Only terminal ones: a ready job scheduled far in the future is not old, however long ago it was written, and a running one is somebody’s work.

Trait Implementations

impl Clone for Job

fn clone(&self) -> Job

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Job

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

Formats the value using the given formatter.