Minion::Job - Minion job
package MyApp::Task::Foo; use Mojo::Base 'Minion::Job', -signatures; sub run ($self, @args) { # Magic here! :) }
Minion::Job is a container for Minion jobs.
Minion::Job inherits all events from Mojo::EventEmitter and can emit the following new ones.
$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"); });
$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.
failed
$job->on(failed => sub ($job, $err) { say "Something went wrong: $err"; });
$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"}); });
$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.
finished
$job->on(finished => sub ($job, $result) { my $id = $job->id; say "Job $id is finished."; });
$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"; });
$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"; });
$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; });
Minion::Job implements the following attributes.
my $args = $job->args; $job = $job->args([]);
Arguments passed to task.
my $id = $job->id; $job = $job->id($id);
Job id.
my $minion = $job->minion; $job = $job->minion(Minion->new);
Minion object this job belongs to.
my $retries = $job->retries; $job = $job->retries(5);
Number of times job has been retried.
my $task = $job->task; $job = $job->task('foo');
Task name.
Minion::Job inherits all methods from Mojo::EventEmitter and implements the following new ones.
my $app = $job->app;
Get application from "app" in Minion.
# Longer version my $app = $job->minion->app;
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.
undef
# Perform job in foreground if (my $err = $job->execute) { $job->fail($err) } else { $job->finish }
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.
active
inactive
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.
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 => ['foo', 'bar']
Job arguments.
attempts => 25
Number of times performing this job will be attempted.
children => ['10026', '10027', '10028']
Jobs depending on this job.
created => 784111777
Epoch time job was created.
delayed => 784111777
Epoch time job was delayed to.
expires => 784111777
Epoch time job is valid until before it expires.
finished => 784111777
Epoch time job was finished.
lax => 0
Existing jobs this job depends on may also have failed to allow for it to be processed.
notes => {foo => 'bar', baz => [1, 2, 3]}
Hash reference with arbitrary metadata for this job.
parents => ['10023', '10024', '10025']
Jobs this job depends on.
priority => 3
Job priority.
queue => 'important'
Queue name.
result => 'All went well!'
Job result.
retried => 784111777
Epoch time job has been retried.
retries => 3
started => 784111777
Epoch time job was started.
state => 'inactive'
Current job state, usually active, failed, finished or inactive.
task => 'foo'
time => 784111777
Server time.
worker => '154'
Id of worker that is processing the job.
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.
$job->kill('INT');
Send a signal to job performed with "start". Note that this method should only be used to implement custom workers.
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'});
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}"; }
$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.
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.
my $bool = $job->remove;
Remove failed, finished or inactive job from queue.
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:
delay => 10
Delay job for this many seconds (from now), defaults to 0.
0
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!
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. Note that this option is EXPERIMENTAL and might change without warning!
false
parents => [$id1, $id2, $id3]
priority => 5
Queue to put job in.
$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!
$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;
$job->stop;
Stop job performed with "start" immediately. Note that this method should only be used to implement custom workers.
Minion, https://minion.pm, Mojolicious::Guides, https://mojolicious.org.
To install Minion, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Minion
CPAN shell
perl -MCPAN -e shell install Minion
For more information on module installation, please visit the detailed CPAN module installation guide.