--- name: "Minion::Worker" section: "3pm" platform: "linux" package: "libminion-perl" version: "10.31+dfsg-2" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/Minion::Worker" --- # Minion::Worker(3pm) Minion worker ## NAME Minion::Worker - Minion worker ## SYNOPSIS ``` use Minion::Worker; my $worker = Minion::Worker->new(minion => $minion); ``` ## DESCRIPTION Minion::Worker performs jobs for Minion. ## WORKER SIGNALS The Minion::Worker process can be controlled at runtime with the following signals. ### INT, TERM Stop gracefully after finishing the current jobs. ### QUIT Stop immediately without finishing the current jobs. ## JOB SIGNALS The job processes spawned by the Minion::Worker process can be controlled at runtime with the following signals. ### INT, TERM This signal starts out with the operating system default and allows for jobs to install a custom signal handler to stop gracefully. ### USR1, USR2 These signals start out being ignored and allow for jobs to install custom signal handlers. ## EVENTS Minion::Worker inherits all events from Mojo::EventEmitter and can emit the following new ones. ### busy ``` $worker->on(busy => sub ($worker) { ... }); ``` Emitted in the worker process when it is performing the maximum number of jobs in parallel. ``` $worker->on(busy => sub ($worker) { my $max = $worker->status->{jobs}; say "Performing $max jobs."; }); ``` ### dequeue ``` $worker->on(dequeue => sub ($worker, $job) { ... }); ``` Emitted in the worker process after a job has been dequeued. ``` $worker->on(dequeue => sub ($worker, $job) { my $id = $job->id; say "Job $id has been dequeued."; }); ``` ### wait ``` $worker->on(wait => sub ($worker) { ... }); ``` Emitted in the worker process before it tries to dequeue a job. ``` $worker->on(wait => sub ($worker) { my $max = $worker->status->{dequeue_timeout}; say "Waiting up to $max seconds for a new job."; }); ``` ## ATTRIBUTES Minion::Worker implements the following attributes. ### commands ``` my $commands = $worker->commands; $worker = $worker->commands({jobs => sub {...}}); ``` Registered worker remote control commands. ### id ``` my $id = $worker->id; $worker = $worker->id($id); ``` Worker id. ### minion ``` my $minion = $worker->minion; $worker = $worker->minion(Minion->new); ``` Minion object this worker belongs to. ### status ``` my $status = $worker->status; $worker = $worker->status({queues => ['default', 'important']); ``` Status information to configure workers started with "run" and to share every time "register" is called. ## METHODS Minion::Worker inherits all methods from Mojo::EventEmitter and implements the following new ones. ### add\_command ``` $worker = $worker->add_command(jobs => sub {...}); ``` Register a worker remote control command. ``` $worker->add_command(foo => sub ($worker, @args) { ... }); ``` ### dequeue ``` my $job = $worker->dequeue(0.5); my $job = $worker->dequeue(0.5 => {queues => ['important']}); ``` Wait a given amount of time in seconds for a job, dequeue Minion::Job object and transition from `"inactive"` to `"active"` state, or return `"undef"` if queues were empty. These options are currently available: - id ``` id => '10023' ``` Dequeue a specific job. - min\_priority ``` min_priority => 3 ``` Do not dequeue jobs with a lower priority. - queues ``` queues => ['important'] ``` One or more queues to dequeue jobs from, defaults to `"default"`. ### info ``` my $info = $worker->info; ``` Get worker information. ``` # Check worker host my $host = $worker->info->{host}; ``` These fields are currently available: - host ``` host => 'localhost' ``` Worker host. - jobs ``` jobs => ['10023', '10024', '10025', '10029'] ``` Ids of jobs the worker is currently processing. - notified ``` notified => 784111777 ``` Epoch time worker sent the last heartbeat. - pid ``` pid => 12345 ``` Process id of worker. - started ``` started => 784111777 ``` Epoch time worker was started. - status ``` status => {queues => ['default', 'important']} ``` Hash reference with whatever status information the worker would like to share. ### new ``` my $worker = Minion::Worker->new; my $worker = Minion::Worker->new(status => {foo => 'bar'}); my $worker = Minion::Worker->new({status => {foo => 'bar'}}); ``` Construct a new Minion::Worker object and subscribe to "busy" event with default handler that sleeps for one second. ### process\_commands ``` $worker = $worker->process_commands; ``` Process worker remote control commands. ### register ``` $worker = $worker->register; ``` Register worker or send heartbeat to show that this worker is still alive. ### run ``` $worker->run; ``` Run worker and wait for "WORKER SIGNALS". ``` # Start a worker for a special named queue my $worker = $minion->worker; $worker->status->{queues} = ['important']; $worker->run; ``` These "status" options are currently available: - command\_interval ``` command_interval => 20 ``` Worker remote control command interval, defaults to `10`. - dequeue\_timeout ``` dequeue_timeout => 5 ``` Maximum amount time in seconds to wait for a job, defaults to `5`. - heartbeat\_interval ``` heartbeat_interval => 60 ``` Heartbeat interval, defaults to `300`. - jobs ``` jobs => 12 ``` Maximum number of jobs to perform parallel in forked worker processes (not including spare processes), defaults to `4`. - queues ``` queues => ['test'] ``` One or more queues to get jobs from, defaults to `"default"`. - repair\_interval ``` repair_interval => 3600 ``` Repair interval, up to half of this value can be subtracted randomly to make sure not all workers repair at the same time, defaults to `21600` (6 hours). - spare ``` spare => 2 ``` Number of spare worker processes to reserve for high priority jobs, defaults to `1`. - spare\_min\_priority ``` spare_min_priority => 7 ``` Minimum priority of jobs to use spare worker processes for, defaults to `1`. These remote control "commands" are currently available: - jobs ``` $minion->broadcast('jobs', [10]); $minion->broadcast('jobs', [10], [$worker_id]); ``` Instruct one or more workers to change the number of jobs to perform concurrently. Setting this value to `0` will effectively pause the worker. That means all current jobs will be finished, but no new ones accepted, until the number is increased again. - kill ``` $minion->broadcast('kill', ['INT', 10025]); $minion->broadcast('kill', ['INT', 10025], [$worker_id]); ``` Instruct one or more workers to send a signal to a job that is currently being performed. This command will be ignored by workers that do not have a job matching the id. That means it is safe to broadcast this command to all workers. - stop ``` $minion->broadcast('stop', [10025]); $minion->broadcast('stop', [10025], [$worker_id]); ``` Instruct one or more workers to stop a job that is currently being performed immediately. This command will be ignored by workers that do not have a job matching the id. That means it is safe to broadcast this command to all workers. ### unregister ``` $worker = $worker->unregister; ``` Unregister worker. ## SEE ALSO Minion, Minion::Guide, \, Mojolicious::Guides, \.