/ 
Minion-Backend-Storable-5.082
River stage zero No dependents
/ Minion::Backend::Storable

NAME

Minion::Backend::Storable - File backend for Minion job queues.

SYNOPSIS

use Minion::Backend::Storable;

my $backend = Minion::Backend::Storable->new('/some/path/minion.data');

DESCRIPTION

Minion::Backend::Storable is a highly portable file-based backend for Minion.

ATTRIBUTES

Minion::Backend::Storable inherits all attributes from Minion::Backend and implements the following new ones.

deserialize

my $cb   = $backend->deserialize;
$backend = $backend->deserialize(sub {...});

A callback used to deserialize data, defaults to using Storable with gzip compression.

$backend->deserialize(sub {
  my $bytes = shift;
  return {};
});

file

my $file = $backend->file;
$backend = $backend->file('/some/path/minion.data');

File all data is stored in.

serialize

my $cb   = $backend->serialize;
$backend = $backend->serialize(sub {...});

A callback used to serialize data, defaults to using Storable with gzip compression.

$backend->serialize(sub {
  my $hash = shift;
  return '';
});

METHODS

Minion::Backend::Storable inherits all methods from Minion::Backend and implements the following new ones.

dequeue

my $job_info = $backend->dequeue($worker_id, 0.5);
my $job_info = $backend->dequeue($worker_id, 0.5, {queues => ['important']});

Wait a given amount of time in seconds for a job, dequeue it and transition from inactive to active state, or return undef if queues were empty.

These options are currently available:

queues
queues => ['important']

One or more queues to dequeue jobs from, defaults to default.

These fields are currently available:

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

Job arguments.

id
id => '10023'

Job id.

retries
retries => 3

Number of times job has been retried.

task
task => 'foo'

Task name.

enqueue

my $job_id = $backend->enqueue('foo');
my $job_id = $backend->enqueue(foo => [@args]);
my $job_id = $backend->enqueue(foo => [@args] => {priority => 1});

Enqueue a new job with inactive state.

These options are currently available:

attempts
attempts => 25

Number of times performing this job will be attempted, with a delay based on "backoff" in Minion after the first attempt, defaults to 1.

delay
delay => 10

Delay job for this many seconds (from now).

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

One or more existing jobs this job depends on, and that need to have transitioned to the state finished before it can be processed.

priority
priority => 5

Job priority, defaults to 0.

queue
queue => 'important'

Queue to put job in, defaults to default.

fail_job

my $bool = $backend->fail_job($job_id, $retries);
my $bool = $backend->fail_job($job_id, $retries, 'Something went wrong!');
my $bool = $backend->fail_job($job_id, $retries, {msg => 'Wrong, wrong!'});

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

finish_job

my $bool = $backend->finish_job($job_id, $retries);
my $bool = $backend->finish_job($job_id, $retries, 'All went well!');
my $bool = $backend->finish_job($job_id, $retries, {msg => 'All went well!'});

Transition from active to finished state.

job_info

my $job_info = $backend->job_info($job_id);

Get information about a job, or return undef if job does not exist.

# Check job state
my $state = $backend->job_info($job_id)->{state};

# Get job result
my $result = $backend->job_info($job_id)->{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.

finished
finished => 784111777

Epoch time job was finished.

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 inactive, active, failed, or finished.

task
task => 'foo'

Task name.

worker
worker => '154'

Id of worker that is processing the job.

list_jobs

my $batch = $backend->list_jobs($offset, $limit);
my $batch = $backend->list_jobs($offset, $limit, {state => 'inactive'});

Returns the same information as "job_info" but in batches.

These options are currently available:

queue
queue => 'important'

List only jobs in this queue.

state
state => 'inactive'

List only jobs in this state.

task
task => 'test'

List only jobs for this task.

list_workers

my $batch = $backend->list_workers($offset, $limit);

Returns the same information as "worker_info" but in batches.

new

my $backend = Minion::Backend::Storable->new('/some/path/minion.data');

Construct a new Minion::Backend::Storable object.

register_worker

my $worker_id = $backend->register_worker;
my $worker_id = $backend->register_worker($worker_id);

Register worker or send heartbeat to show that this worker is still alive.

remove_job

my $bool = $backend->remove_job($job_id);

Remove failed, finished or inactive job from queue.

repair

$backend->repair;

Repair worker registry and job queue if necessary.

reset

$backend->reset;

Reset job queue.

retry_job

my $bool = $backend->retry_job($job_id, $retries);
my $bool = $backend->retry_job($job_id, $retries, {delay => 10});

Transition from failed or finished state back to inactive, already inactive jobs may also be retried to change options.

These options are currently available:

delay
delay => 10

Delay job for this many seconds (from now).

priority
priority => 5

Job priority.

queue
queue => 'important'

Queue to put job in.

stats

my $stats = $backend->stats;

Get statistics for jobs and workers.

These fields are currently available:

active_jobs
active_jobs => 100

Number of jobs in active state.

active_workers
active_workers => 100

Number of workers that are currently processing a job.

delayed_jobs
delayed_jobs => 100

Number of jobs in inactive state that are scheduled to run at specific time in the future or have unresolved dependencies. Note that this field is EXPERIMENTAL and might change without warning!

failed_jobs
failed_jobs => 100

Number of jobs in failed state.

finished_jobs
finished_jobs => 100

Number of jobs in finished state.

inactive_jobs
inactive_jobs => 100

Number of jobs in inactive state.

inactive_workers
inactive_workers => 100

Number of workers that are currently not processing a job.

unregister_worker

$backend->unregister_worker($worker_id);

Unregister worker.

worker_info

my $worker_info = $backend->worker_info($worker_id);

Get information about a worker, or return undef if worker does not exist.

# Check worker host
my $host = $backend->worker_info($worker_id)->{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.

COPYRIGHT AND LICENCE

Copyright (c) 2014 Sebastian Riedel. Copyright (c) 2015--2016 Sebastian Riedel & Nic Sandfield.

This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0.

SEE ALSO

Minion, Minion::Backend::Pg, Minion::Backend::SQLite.