/ 
Minion-10.12
River stage two • 21 direct dependents • 30 total dependents
/ Minion::Job

NAME

Minion::Job - Minion job

SYNOPSIS

package MyApp::Task::Foo;
use Mojo::Base 'Minion::Job';

sub run {
  my ($self, @args) = @_;

  # Magic here! :)
}

DESCRIPTION

Minion::Job is a container for Minion jobs.

EVENTS

Minion::Job inherits all events from Mojo::EventEmitter and can emit the following new ones.

cleanup

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

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

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

failed

$job->on(failed => sub {
  my ($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 {
  my ($job, $err) = @_;
  say "Something went wrong: $err";
});

finish

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

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

$job->on(finish => sub {
  my $job  = shift;
  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 {
  my ($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 {
  my ($job, $result) = @_;
  my $id = $job->id;
  say "Job $id is finished.";
});

reap

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

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

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

spawn

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

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

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

start

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

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

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

ATTRIBUTES

Minion::Job implements the following attributes.

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.

METHODS

Minion::Job inherits all methods from Mojo::EventEmitter and implements the following new ones.

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.

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'});

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. Note that this option is EXPERIMENTAL and might change without warning!

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.

SEE ALSO

Minion, Mojolicious::Guides, https://mojolicious.org.