1Minion::Backend::Pg(3)User Contributed Perl DocumentationMinion::Backend::Pg(3)
2
6 Minion::Backend::Pg - PostgreSQL backend
7
9 use Minion::Backend::Pg;
10 my $backend = Minion::Backend::Pg->new('postgresql://postgres@/test');
12
14 Minion::Backend::Pg is a backend for Minion based on Mojo::Pg. All
15 necessary tables will be created automatically with a set of migrations
16 named "minion". Note that this backend uses many bleeding edge
17 features, so only the latest, stable version of PostgreSQL is fully
18 supported.
19
21 Minion::Backend::Pg inherits all attributes from Minion::Backend and
22 implements the following new ones.
23 pg
25 my $pg = $backend->pg;
26 $backend = $backend->pg(Mojo::Pg->new);
27 Mojo::Pg object used to store all data.
29
31 Minion::Backend::Pg inherits all methods from Minion::Backend and
32 implements the following new ones.
33 broadcast
35 my $bool = $backend->broadcast('some_command');
36 my $bool = $backend->broadcast('some_command', [@args]);
37 my $bool = $backend->broadcast('some_command', [@args], [$id1, $id2, $id3]);
38 Broadcast remote control command to one or more workers.
40 dequeue
42 my $job_info = $backend->dequeue($worker_id, 0.5);
43 my $job_info = $backend->dequeue($worker_id, 0.5, {queues => ['important']});
44 Wait a given amount of time in seconds for a job, dequeue it and
46 transition from "inactive" to "active" state, or return "undef" if
47 queues were empty.
48 These options are currently available:
50 id
52 id => '10023'
53 Dequeue a specific job.
55 queues
57 queues => ['important']
58 One or more queues to dequeue jobs from, defaults to "default".
60 These fields are currently available:
62 args
64 args => ['foo', 'bar']
65 Job arguments.
67 id
69 id => '10023'
70 Job ID.
72 retries
74 retries => 3
75 Number of times job has been retried.
77 task
79 task => 'foo'
80 Task name.
82 enqueue
84 my $job_id = $backend->enqueue('foo');
85 my $job_id = $backend->enqueue(foo => [@args]);
86 my $job_id = $backend->enqueue(foo => [@args] => {priority => 1});
87 Enqueue a new job with "inactive" state.
89 These options are currently available:
91 attempts
93 attempts => 25
94 Number of times performing this job will be attempted, with a delay
96 based on "backoff" in Minion after the first attempt, defaults to 1.
97 delay
99 delay => 10
100 Delay job for this many seconds (from now), defaults to 0.
102 notes
104 notes => {foo => 'bar', baz => [1, 2, 3]}
105 Hash reference with arbitrary metadata for this job.
107 parents
109 parents => [$id1, $id2, $id3]
110 One or more existing jobs this job depends on, and that need to have
112 transitioned to the state "finished" before it can be processed.
113 priority
115 priority => 5
116 Job priority, defaults to 0. Jobs with a higher priority get
118 performed first.
119 queue
121 queue => 'important'
122 Queue to put job in, defaults to "default".
124 fail_job
126 my $bool = $backend->fail_job($job_id, $retries);
127 my $bool = $backend->fail_job($job_id, $retries, 'Something went wrong!');
128 my $bool = $backend->fail_job(
129 $job_id, $retries, {whatever => 'Something went wrong!'});
130 Transition from "active" to "failed" state, and if there are attempts
132 remaining, transition back to "inactive" with a delay based on
133 "backoff" in Minion.
134 finish_job
136 my $bool = $backend->finish_job($job_id, $retries);
137 my $bool = $backend->finish_job($job_id, $retries, 'All went well!');
138 my $bool = $backend->finish_job(
139 $job_id, $retries, {whatever => 'All went well!'});
140 Transition from "active" to "finished" state.
142 history
144 my $history = $backend->history;
145 Get history information for job queue. Note that this method is
147 EXPERIMENTAL and might change without warning!
148 These fields are currently available:
150 daily
152 daily => [{epoch => 12345, finished_jobs => 95, failed_jobs => 2}, ...]
153 Hourly counts for processed jobs from the past day.
155 list_jobs
157 my $results = $backend->list_jobs($offset, $limit);
158 my $results = $backend->list_jobs($offset, $limit, {states => ['inactive']});
159 Returns the information about jobs in batches.
161 # Check job state
163 my $results = $backend->list_jobs(0, 1, {ids => [$job_id]});
164 my $state = $results->{jobs}[0]{state};
165 # Get job result
167 my $results = $backend->list_jobs(0, 1, {ids => [$job_id]});
168 my $result = $results->{jobs}[0]{result};
169 These options are currently available:
171 ids
173 ids => ['23', '24']
174 List only jobs with these ids.
176 queues
178 queues => ['important', 'unimportant']
179 List only jobs in these queues.
181 states
183 states => ['inactive', 'active']
184 List only jobs in these states.
186 tasks
188 tasks => ['foo', 'bar']
189 List only jobs for these tasks.
191 These fields are currently available:
193 args
195 args => ['foo', 'bar']
196 Job arguments.
198 attempts
200 attempts => 25
201 Number of times performing this job will be attempted.
203 children
205 children => ['10026', '10027', '10028']
206 Jobs depending on this job.
208 created
210 created => 784111777
211 Epoch time job was created.
213 delayed
215 delayed => 784111777
216 Epoch time job was delayed to.
218 finished
220 finished => 784111777
221 Epoch time job was finished.
223 notes
225 notes => {foo => 'bar', baz => [1, 2, 3]}
226 Hash reference with arbitrary metadata for this job.
228 parents
230 parents => ['10023', '10024', '10025']
231 Jobs this job depends on.
233 priority
235 priority => 3
236 Job priority.
238 queue
240 queue => 'important'
241 Queue name.
243 result
245 result => 'All went well!'
246 Job result.
248 retried
250 retried => 784111777
251 Epoch time job has been retried.
253 retries
255 retries => 3
256 Number of times job has been retried.
258 started
260 started => 784111777
261 Epoch time job was started.
263 state
265 state => 'inactive'
266 Current job state, usually "active", "failed", "finished" or
268 "inactive".
269 task
271 task => 'foo'
272 Task name.
274 worker
276 worker => '154'
277 Id of worker that is processing the job.
279 list_locks
281 my $results = $backend->list_locks($offset, $limit);
282 my $results = $backend->list_locks($offset, $limit, {names => ['foo']});
283 Returns information about locks in batches.
285 # Check expiration time
287 my $results = $backend->list_locks(0, 1, {names => ['foo']});
288 my $expires = $results->{locks}[0]{expires};
289 These options are currently available:
291 names
293 names => ['foo', 'bar']
294 List only locks with these names.
296 These fields are currently available:
298 expires
300 expires => 784111777
301 Epoch time this lock will expire.
303 name
305 name => 'foo'
306 Lock name.
308 list_workers
310 my $results = $backend->list_workers($offset, $limit);
311 my $results = $backend->list_workers($offset, $limit, {ids => [23]});
312 Returns information about workers in batches.
314 # Check worker host
316 my $results = $backend->list_workers(0, 1, {ids => [$worker_id]});
317 my $host = $results->{workers}[0]{host};
318 These options are currently available:
320 ids
322 ids => ['23', '24']
323 List only workers with these ids.
325 These fields are currently available:
327 host
329 host => 'localhost'
330 Worker host.
332 jobs
334 jobs => ['10023', '10024', '10025', '10029']
335 Ids of jobs the worker is currently processing.
337 notified
339 notified => 784111777
340 Epoch time worker sent the last heartbeat.
342 pid
344 pid => 12345
345 Process id of worker.
347 started
349 started => 784111777
350 Epoch time worker was started.
352 status
354 status => {queues => ['default', 'important']}
355 Hash reference with whatever status information the worker would like
357 to share.
358 lock
360 my $bool = $backend->lock('foo', 3600);
361 my $bool = $backend->lock('foo', 3600, {limit => 20});
362 Try to acquire a named lock that will expire automatically after the
364 given amount of time in seconds. An expiration time of 0 can be used to
365 check if a named lock already exists without creating one.
366 These options are currently available:
368 limit
370 limit => 20
371 Number of shared locks with the same name that can be active at the
373 same time, defaults to 1.
374 new
376 my $backend = Minion::Backend::Pg->new('postgresql://postgres@/test');
377 my $backend = Minion::Backend::Pg->new(Mojo::Pg->new);
378 Construct a new Minion::Backend::Pg object.
380 note
382 my $bool = $backend->note($job_id, {mojo => 'rocks', minion => 'too'});
383 Change one or more metadata fields for a job.
385 receive
387 my $commands = $backend->receive($worker_id);
388 Receive remote control commands for worker.
390 register_worker
392 my $worker_id = $backend->register_worker;
393 my $worker_id = $backend->register_worker($worker_id);
394 my $worker_id = $backend->register_worker(
395 $worker_id, {status => {queues => ['default', 'important']}});
396 Register worker or send heartbeat to show that this worker is still
398 alive.
399 These options are currently available:
401 status
403 status => {queues => ['default', 'important']}
404 Hash reference with whatever status information the worker would like
406 to share.
407 remove_job
409 my $bool = $backend->remove_job($job_id);
410 Remove "failed", "finished" or "inactive" job from queue.
412 repair
414 $backend->repair;
415 Repair worker registry and job queue if necessary.
417 reset
419 $backend->reset;
420 Reset job queue.
422 retry_job
424 my $bool = $backend->retry_job($job_id, $retries);
425 my $bool = $backend->retry_job($job_id, $retries, {delay => 10});
426 Transition job back to "inactive" state, already "inactive" jobs may
428 also be retried to change options.
429 These options are currently available:
431 attempts
433 attempts => 25
434 Number of times performing this job will be attempted.
436 delay
438 delay => 10
439 Delay job for this many seconds (from now), defaults to 0.
441 parents
443 parents => [$id1, $id2, $id3]
444 Jobs this job depends on.
446 priority
448 priority => 5
449 Job priority.
451 queue
453 queue => 'important'
454 Queue to put job in.
456 stats
458 my $stats = $backend->stats;
459 Get statistics for the job queue.
461 These fields are currently available:
463 active_jobs
465 active_jobs => 100
466 Number of jobs in "active" state.
468 active_locks
470 active_locks => 100
471 Number of active named locks.
473 active_workers
475 active_workers => 100
476 Number of workers that are currently processing a job.
478 delayed_jobs
480 delayed_jobs => 100
481 Number of jobs in "inactive" state that are scheduled to run at
483 specific time in the future. Note that this field is EXPERIMENTAL and
484 might change without warning!
485 enqueued_jobs
487 enqueued_jobs => 100000
488 Rough estimate of how many jobs have ever been enqueued. Note that
490 this field is EXPERIMENTAL and might change without warning!
491 failed_jobs
493 failed_jobs => 100
494 Number of jobs in "failed" state.
496 finished_jobs
498 finished_jobs => 100
499 Number of jobs in "finished" state.
501 inactive_jobs
503 inactive_jobs => 100
504 Number of jobs in "inactive" state.
506 inactive_workers
508 inactive_workers => 100
509 Number of workers that are currently not processing a job.
511 uptime
513 uptime => 1000
514 Uptime in seconds.
516 unlock
518 my $bool = $backend->unlock('foo');
519 Release a named lock.
521 unregister_worker
523 $backend->unregister_worker($worker_id);
524 Unregister worker.
526
528 Minion, Mojolicious::Guides, <http://mojolicious.org>.
529perl v5.28.0 2018-04-19 Minion::Backend::Pg(3)