Oban v0.11.1 Oban.Job View Source

A Job is an Ecto schema used for asynchronous execution.

Job changesets are created by your application code and inserted into the database for asynchronous execution. Jobs can be inserted along with other application data as part of a transaction, which guarantees that jobs will only be triggered from a successful transaction.

Link to this section Summary

Functions

Construct a new job changeset ready for insertion into the database.

Convert a Job changeset into a map suitable for database insertion.

Link to this section Types

Link to this type

errors()

View Source
errors() :: [%{at: DateTime.t(), attempt: pos_integer(), error: binary()}]
Link to this type

option()

View Source
option() ::
  {:args, args()}
  | {:max_attempts, pos_integer()}
  | {:queue, atom() | binary()}
  | {:schedule_in, pos_integer()}
  | {:scheduled_at, DateTime.t()}
  | {:unique, [unique_option()]}
  | {:worker, atom() | binary()}
Link to this type

t()

View Source
t() :: %Oban.Job{
  __meta__: term(),
  args: args(),
  attempt: non_neg_integer(),
  attempted_at: DateTime.t(),
  attempted_by: [binary()],
  completed_at: DateTime.t(),
  errors: errors(),
  id: pos_integer(),
  inserted_at: DateTime.t(),
  max_attempts: pos_integer(),
  queue: binary(),
  scheduled_at: DateTime.t(),
  state: binary(),
  unique: %{
    fields: [unique_field()],
    period: pos_integer(),
    states: [unique_state()]
  },
  worker: binary()
}
Link to this type

unique_field()

View Source
unique_field() :: [:args | :queue | :worker]
Link to this type

unique_option()

View Source
unique_option() ::
  {:fields, [unique_field()]}
  | {:period, pos_integer()}
  | {:states, [unique_state()]}
Link to this type

unique_state()

View Source
unique_state() :: [
  :available | :scheduled | :executing | :retryable | :completed
]

Link to this section Functions

Link to this function

new(args, opts \\ [])

View Source (since 0.1.0)
new(args(), [option()]) :: Ecto.Changeset.t()

Construct a new job changeset ready for insertion into the database.

Options

  • :max_attempts — the maximum number of times a job can be retried if there are errors during execution
  • :queue — a named queue to push the job into. Jobs may be pushed into any queue, regardless of whether jobs are currently being processed for the queue.
  • :schedule_in - the number of seconds until the job should be executed
  • :scheduled_at - a time in the future after which the job should be executed
  • :worker — a module to execute the job in. The module must implement the Oban.Worker behaviour.
  • :unique — a keyword list of options specifying how uniqueness will be calculated. The options define which fields will be used, for how long, and for which states.

Examples

Insert a job with the :default queue:

%{id: 1, user_id: 2}
|> Oban.Job.new(queue: :default, worker: MyApp.Worker)
|> Oban.insert()

Generate a pre-configured job for MyApp.Worker and push it:

%{id: 1, user_id: 2} |> MyApp.Worker.new() |> Oban.insert()

Schedule a job to run in 5 seconds:

%{id: 1} |> MyApp.Worker.new(schedule_in: 5) |> Oban.insert()

Insert a job, ensuring that it is unique within the past minute:

%{id: 1} |> MyApp.Worker.new(unique: [period: 60]) |> Oban.insert()

Insert a unique job based only on the worker field, and within multiple states:

fields = [:worker]
states = [:available, :scheduled, :executing, :retryable, :completed]

%{id: 1}
|> MyApp.Worker.new(unique: [fields: fields, period: 60, states: states])
|> Oban.insert()
Link to this function

to_map(changeset)

View Source (since 0.9.0)
to_map(Ecto.Changeset.t(t())) :: map()

Convert a Job changeset into a map suitable for database insertion.

Examples

Convert a worker generated changeset into a plain map:

%{id: 123}
|> MyApp.Worker.new()
|> Oban.Job.to_map()