cleanup¶

  $job->on(cleanup => sub ($job) {
    ...
  });

Emitted in the process performing this job right before the process will exit.

  $job->on(cleanup => sub ($job) {
    $job->app->log->debug("Process $$ is about to exit");
  });

failed¶

  $job->on(failed => sub ($job, $err) {
    ...
  });

Emitted in the worker process managing this job or the process performing it, after it has transitioned to the "failed" state.

  $job->on(failed => sub ($job, $err) {
    say "Something went wrong: $err";
  });

finish¶

  $job->on(finish => sub ($job) {
    ...
  });

Emitted in the process performing this job if the task was successful.

  $job->on(finish => sub ($job) {
    my $id   = $job->id;
    my $task = $job->task;
    $job->app->log->debug(qq{Job "$id" was performed with task "$task"});
  });

finished¶

  $job->on(finished => sub ($job, $result) {
    ...
  });

Emitted in the worker process managing this job or the process performing it, after it has transitioned to the "finished" state.

  $job->on(finished => sub ($job, $result) {
    my $id = $job->id;
    say "Job $id is finished.";
  });

reap¶

  $job->on(reap => sub ($job, $pid) {
    ...
  });

Emitted in the worker process managing this job, after the process performing it has exited.

  $job->on(reap => sub ($job, $pid) {
    my $id = $job->id;
    say "Job $id ran in process $pid";
  });

spawn¶

  $job->on(spawn => sub ($job, $pid) {
    ...
  });

Emitted in the worker process managing this job, after a new process has been spawned for processing.

  $job->on(spawn => sub ($job, $pid) {
    my $id = $job->id;
    say "Job $id running in process $pid";
  });

start¶

  $job->on(start => sub ($job) {
    ...
  });

Emitted in the process performing this job, after it has been spawned.

  $job->on(start => sub ($job) {
    $0 = $job->id;
  });

args¶

  my $args = $job->args;
  $job     = $job->args([]);

Arguments passed to task.

id¶

  my $id = $job->id;
  $job   = $job->id($id);

Job id.

minion¶

  my $minion = $job->minion;
  $job       = $job->minion(Minion->new);

Minion object this job belongs to.

retries¶

  my $retries = $job->retries;
  $job        = $job->retries(5);

Number of times job has been retried.

task¶

  my $task = $job->task;
  $job     = $job->task('foo');

Task name.

app¶

  my $app = $job->app;

Get application from "app" in Minion.

  # Longer version
  my $app = $job->minion->app;

execute¶

  my $err = $job->execute;

Perform job in this process and return "undef" if the task was successful or an exception otherwise. Note that this method should only be used to implement custom workers.

  # Perform job in foreground
  if (my $err = $job->execute) { $job->fail($err) }
  else                         { $job->finish }

fail¶

  my $bool = $job->fail;
  my $bool = $job->fail('Something went wrong!');
  my $bool = $job->fail({whatever => 'Something went wrong!'});

Transition from "active" to "failed" state with or without a result, and if there are attempts remaining, transition back to "inactive" with a delay based on "backoff" in Minion.

finish¶

  my $bool = $job->finish;
  my $bool = $job->finish('All went well!');
  my $bool = $job->finish({whatever => 'All went well!'});

Transition from "active" to "finished" state with or without a result.

info¶

  my $info = $job->info;

Get job information.

  # Check job state
  my $state = $job->info->{state};
  # Get job metadata
  my $progress = $job->info->{notes}{progress};
  # Get job result
  my $result = $job->info->{result};

These fields are currently available:

args

  args => ['foo', 'bar']
    

Job arguments.

attempts

  attempts => 25
    

Number of times performing this job will be attempted.

children

  children => ['10026', '10027', '10028']
    

Jobs depending on this job.

created

  created => 784111777
    

Epoch time job was created.

delayed

  delayed => 784111777
    

Epoch time job was delayed to.

expires

  expires => 784111777
    

Epoch time job is valid until before it expires.

finished

  finished => 784111777
    

Epoch time job was finished.

lax

  lax => 0
    

Existing jobs this job depends on may also have failed to allow for it to be processed.

notes

  notes => {foo => 'bar', baz => [1, 2, 3]}
    

Hash reference with arbitrary metadata for this job.

parents

  parents => ['10023', '10024', '10025']
    

Jobs this job depends on.

priority

  priority => 3
    

Job priority.

queue

  queue => 'important'
    

Queue name.

result

  result => 'All went well!'
    

Job result.

retried

  retried => 784111777
    

Epoch time job has been retried.

retries

  retries => 3
    

Number of times job has been retried.

started

  started => 784111777
    

Epoch time job was started.

state

  state => 'inactive'
    

Current job state, usually "active", "failed", "finished" or "inactive".

task

  task => 'foo'
    

Task name.

time

  time => 784111777
    

Server time.

worker

  worker => '154'
    

Id of worker that is processing the job.

is_finished¶

  my $bool = $job->is_finished;

Check if job performed with "start" is finished. Note that this method should only be used to implement custom workers.

kill¶

  $job->kill('INT');

Send a signal to job performed with "start". Note that this method should only be used to implement custom workers.

note¶

  my $bool = $job->note(mojo => 'rocks', minion => 'too');

Change one or more metadata fields for this job. Setting a value to "undef" will remove the field. The new values will get serialized by "backend" in Minion (often with Mojo::JSON), so you shouldn't send objects and be careful with binary data, nested data structures with hash and array references are fine though.

  # Share progress information
  $job->note(progress => 95);
  # Share stats
  $job->note(stats => {utime => '0.012628', stime => '0.002429'});

parents¶

  my $parents = $job->parents;

Return a Mojo::Collection object containing all jobs this job depends on as Minion::Job objects.

  # Check parent state
  for my $parent ($job->parents->each) {
    my $info = $parent->info;
    say "$info->{id}: $info->{state}";
  }

perform¶

  $job->perform;

Perform job in new process and wait for it to finish. Note that this method should only be used to implement custom workers.

pid¶

  my $pid = $job->pid;

Process id of the process spawned by "start" if available. Note that this method should only be used to implement custom workers.

remove¶

  my $bool = $job->remove;

Remove "failed", "finished" or "inactive" job from queue.

retry¶

  my $bool = $job->retry;
  my $bool = $job->retry({delay => 10});

Transition job back to "inactive" state, already "inactive" jobs may also be retried to change options.

These options are currently available:

attempts

  attempts => 25
    

Number of times performing this job will be attempted.

delay

  delay => 10
    

Delay job for this many seconds (from now), defaults to 0.

expire

  expire => 300
    

Job is valid for this many seconds (from now) before it expires.

lax

  lax => 1
    

Existing jobs this job depends on may also have transitioned to the "failed" state to allow for it to be processed, defaults to "false".

parents

  parents => [$id1, $id2, $id3]
    

Jobs this job depends on.

priority

  priority => 5
    

Job priority.

queue

  queue => 'important'
    

Queue to put job in.

run¶

  $job->run(@args);

Task to perform by this job. Meant to be overloaded in a subclass to create a custom task class. Note that this method is EXPERIMENTAL and might change without warning!

start¶

  $job = $job->start;

Perform job in new process, but do not wait for it to finish. Note that this method should only be used to implement custom workers.

  # Perform two jobs concurrently
  $job1->start;
  $job2->start;
  my ($first, $second);
  sleep 1
    until $first ||= $job1->is_finished and $second ||= $job2->is_finished;

stop¶

  $job->stop;

Stop job performed with "start" immediately. Note that this method should only be used to implement custom workers.