quasar_jobs - v0.2.0

quasar_jobs/store

Store port for durable state. Implementations provide atomic transitions. Resource ownership remains with the application that opened the Store.

Types

Completion

</> 
pub type Completion {
  Completion(token: job.ExecutionToken, completed_at: Int)
}

Constructors

Error

</> 
pub type Error {
  Unavailable
  Timeout
  NotFound
  InvalidTransition(job.TransitionError)
  StaleExecution
}

Constructors

Failure

</> 
pub type Failure {
  Failure(
    token: job.ExecutionToken,
    error: job.JobError,
    available_at: Int,
  )
}

Constructors

Store

opaque </> 
pub opaque type Store

Values

cancel

</> 
pub fn cancel(
  store: Store,
  id: job.JobId,
) -> Result(job.Job, Error)

claim

</> 
pub fn claim(
  store: Store,
  queue: String,
  limit: Int,
  owner: String,
  now: Int,
  lease_ms: Int,
) -> Result(List(job.Job), Error)

The owner argument is a diagnostic prefix. Each call adds a fresh nonce; adapters must preserve it and atomically match owner AND attempt for every execution mutation. This also fences attempts after a manual retry reset.

close

</> 
pub fn close(store: Store) -> Result(Nil, Error)

Releases only resources created by this adapter. Borrowed resources (such as a Pog pool passed to quasar_postgres.new) are never stopped. Quasar never invokes close: the application calls it after all runtimes and commands using this Store have finished.

complete

</> 
pub fn complete(
  store: Store,
  token: job.ExecutionToken,
  now: Int,
) -> Result(job.Job, Error)

complete_many

</> 
pub fn complete_many(
  store: Store,
  completions: List(Completion),
) -> Result(List(job.Job), Error)

completion_time

</> 
pub fn completion_time(completion: Completion) -> Int

completion_token

</> 
pub fn completion_token(
  completion: Completion,
) -> job.ExecutionToken

fail

</> 
pub fn fail(
  store: Store,
  token: job.ExecutionToken,
  error: job.JobError,
  available_at: Int,
) -> Result(job.Job, Error)

fail_many

</> 
pub fn fail_many(
  store: Store,
  failures: List(Failure),
) -> Result(List(job.Job), Error)

failure_available_at

</> 
pub fn failure_available_at(failure: Failure) -> Int

failure_error

</> 
pub fn failure_error(failure: Failure) -> job.JobError

failure_token

</> 
pub fn failure_token(failure: Failure) -> job.ExecutionToken

from_operations

</> 
pub fn from_operations(
  insert insert: fn(job.NewJob, String, Int, Int) -> Result(
    job.JobId,
    Error,
  ),
  get get: fn(job.JobId) -> Result(job.Job, Error),
  claim claim: fn(String, Int, String, Int, Int) -> Result(
    List(job.Job),
    Error,
  ),
  complete complete: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  fail fail: fn(job.ExecutionToken, job.JobError, Int) -> Result(
    job.Job,
    Error,
  ),
  cancel cancel: fn(job.JobId) -> Result(job.Job, Error),
  retry retry: fn(job.JobId, Int) -> Result(job.Job, Error),
  renew_lease renew_lease: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  close close: fn() -> Result(Nil, Error),
) -> Store

from_operations_with_all_batches

</> 
pub fn from_operations_with_all_batches(
  insert insert: fn(job.NewJob, String, Int, Int) -> Result(
    job.JobId,
    Error,
  ),
  insert_many insert_many: fn(List(job.NewJob), String, Int, Int) -> Result(
    List(job.JobId),
    Error,
  ),
  get get: fn(job.JobId) -> Result(job.Job, Error),
  claim claim: fn(String, Int, String, Int, Int) -> Result(
    List(job.Job),
    Error,
  ),
  complete complete: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  complete_many complete_many: fn(List(Completion)) -> Result(
    List(job.Job),
    Error,
  ),
  fail fail: fn(job.ExecutionToken, job.JobError, Int) -> Result(
    job.Job,
    Error,
  ),
  fail_many fail_many: fn(List(Failure)) -> Result(
    List(job.Job),
    Error,
  ),
  cancel cancel: fn(job.JobId) -> Result(job.Job, Error),
  retry retry: fn(job.JobId, Int) -> Result(job.Job, Error),
  renew_lease renew_lease: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  close close: fn() -> Result(Nil, Error),
) -> Store

from_operations_with_batch

</> 
pub fn from_operations_with_batch(
  insert insert: fn(job.NewJob, String, Int, Int) -> Result(
    job.JobId,
    Error,
  ),
  get get: fn(job.JobId) -> Result(job.Job, Error),
  claim claim: fn(String, Int, String, Int, Int) -> Result(
    List(job.Job),
    Error,
  ),
  complete complete: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  complete_many complete_many: fn(List(Completion)) -> Result(
    List(job.Job),
    Error,
  ),
  fail fail: fn(job.ExecutionToken, job.JobError, Int) -> Result(
    job.Job,
    Error,
  ),
  fail_many fail_many: fn(List(Failure)) -> Result(
    List(job.Job),
    Error,
  ),
  cancel cancel: fn(job.JobId) -> Result(job.Job, Error),
  retry retry: fn(job.JobId, Int) -> Result(job.Job, Error),
  renew_lease renew_lease: fn(job.ExecutionToken, Int) -> Result(
    job.Job,
    Error,
  ),
  close close: fn() -> Result(Nil, Error),
) -> Store

get

</> 
pub fn get(store: Store, id: job.JobId) -> Result(job.Job, Error)

insert

</> 
pub fn insert(
  store: Store,
  new_job: job.NewJob,
  queue: String,
  available_at: Int,
  now: Int,
) -> Result(job.JobId, Error)

insert_many

</> 
pub fn insert_many(
  store: Store,
  jobs: List(job.NewJob),
  queue: String,
  available_at: Int,
  now: Int,
) -> Result(List(job.JobId), Error)

renew_lease

</> 
pub fn renew_lease(
  store: Store,
  token: job.ExecutionToken,
  expires_at: Int,
) -> Result(job.Job, Error)

retry

</> 
pub fn retry(
  store: Store,
  id: job.JobId,
  now: Int,
) -> Result(job.Job, Error)
✨ Search Document