NAME

   Minion::Backend::SQLite - SQLite backend for Minion job queue

SYNOPSIS

     use Minion::Backend::SQLite;
     my $backend = Minion::Backend::SQLite->new('sqlite:test.db');

     # Minion
     use Minion;
     my $minion = Minion->new(SQLite => 'sqlite:test.db');

     # Mojolicious (via Mojolicious::Plugin::Minion)
     $self->plugin(Minion => { SQLite => 'sqlite:test.db' });

     # Mojolicious::Lite (via Mojolicious::Plugin::Minion)
     plugin Minion => { SQLite => 'sqlite:test.db' };

     # Share the database connection cache
     helper sqlite => sub { state $sqlite = Mojo::SQLite->new('sqlite:test.db') };
     plugin Minion => { SQLite => app->sqlite };

DESCRIPTION

   Minion::Backend::SQLite is a backend for Minion based on Mojo::SQLite.
   All necessary tables will be created automatically with a set of
   migrations named minion. If no connection string or :temp: is provided,
   the database will be created in a temporary directory.

ATTRIBUTES

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

dequeue_interval

     my $seconds = $backend->dequeue_interval;
     $backend    = $backend->dequeue_interval($seconds);

   Interval in seconds between "dequeue" attempts. Defaults to 0.5.

sqlite

     my $sqlite = $backend->sqlite;
     $backend   = $backend->sqlite(Mojo::SQLite->new);

   Mojo::SQLite object used to store all data.

METHODS

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

new

     my $backend = Minion::Backend::SQLite->new;
     my $backend = Minion::Backend::SQLite->new(':temp:');
     my $backend = Minion::Backend::SQLite->new('sqlite:test.db');
     my $backend = Minion::Backend::SQLite->new->tap(sub { $_->sqlite->from_filename('C:\\foo\\bar.db') });
     my $backend = Minion::Backend::SQLite->new(Mojo::SQLite->new);

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

broadcast

     my $bool = $backend->broadcast('some_command');
     my $bool = $backend->broadcast('some_command', [@args]);
     my $bool = $backend->broadcast('some_command', [@args], [$id1, $id2, $id3]);

   Broadcast remote control command to one or more workers.

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. Jobs will be checked for in intervals defined by
   "dequeue_interval" until the timeout is reached.

   These options are currently available:

   id

       id => '10023'

     Dequeue a specific job.

   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).

   notes

       notes => {foo => 'bar', baz => [1, 2, 3]}

     Hash reference with arbitrary metadata for this job.

   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. Jobs with a higher priority get
     performed first.

   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 => '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 an
   exponentially increasing 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 with or without a result.

history

     my $history = $backend->history;

   Get history information for job queue.

   These fields are currently available:

   daily

       daily => [{epoch => 12345, finished_jobs => 95, failed_jobs => 2}, ...]

     Hourly counts for processed jobs from the past day.

list_jobs

     my $results = $backend->list_jobs($offset, $limit);
     my $results = $backend->list_jobs($offset, $limit, {states => ['inactive']});

   Returns the information about jobs in batches.

     # Get the total number of results (without limit)
     my $num = $backend->list_jobs(0, 100, {queues => ['important']})->{total};

     # Check job state
     my $results = $backend->list_jobs(0, 1, {ids => [$job_id]});
     my $state = $results->{jobs}[0]{state};

     # Get job result
     my $results = $backend->list_jobs(0, 1, {ids => [$job_id]});
     my $result = $results->{jobs}[0]{result};

   These options are currently available:

   before

       before => 23

     List only jobs before this id.

   ids

       ids => ['23', '24']

     List only jobs with these ids.

   queues

       queues => ['important', 'unimportant']

     List only jobs in these queues.

   states

       states => ['inactive', 'active']

     List only jobs in these states.

   tasks

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

     List only jobs for these tasks.

   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.

   id

       id => 10025

     Job id.

   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 => 78411177

     Current time.

   worker

       worker => '154'

     Id of worker that is processing the job.

list_locks

     my $results = $backend->list_locks($offset, $limit);
     my $results = $backend->list_locks($offset, $limit, {names => ['foo']});

   Returns information about locks in batches.

     # Get the total number of results (without limit)
     my $num = $backend->list_locks(0, 100, {names => ['bar']})->{total};

     # Check expiration time
     my $results = $backend->list_locks(0, 1, {names => ['foo']});
     my $expires = $results->{locks}[0]{expires};

   These options are currently available:

   names

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

     List only locks with these names.

   These fields are currently available:

   expires

       expires => 784111777

     Epoch time this lock will expire.

   name

       name => 'foo'

     Lock name.

list_workers

     my $results = $backend->list_workers($offset, $limit);
     my $results = $backend->list_workers($offset, $limit, {ids => [23]});

   Returns information about workers in batches.

     # Get the total number of results (without limit)
     my $num = $backend->list_workers(0, 100)->{total};

     # Check worker host
     my $results = $backend->list_workers(0, 1, {ids => [$worker_id]});
     my $host    = $results->{workers}[0]{host};

   These options are currently available:

   before

       before => 23

     List only workers before this id.

   ids

       ids => ['23', '24']

     List only workers with these ids.

   These fields are currently available:

   id

       id => 22

     Worker id.

   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.

lock

     my $bool = $backend->lock('foo', 3600);
     my $bool = $backend->lock('foo', 3600, {limit => 20});

   Try to acquire a named lock that will expire automatically after the
   given amount of time in seconds. An expiration time of 0 can be used to
   check if a named lock already exists without creating one.

   These options are currently available:

   limit

       limit => 20

     Number of shared locks with the same name that can be active at the
     same time, defaults to 1.

note

     my $bool = $backend->note($job_id, {mojo => 'rocks', minion => 'too'});

   Change one or more metadata fields for a job. Setting a value to undef
   will remove the field. It is currently an error to attempt to set a
   metadata field with a name containing the characters ., [, or ].

receive

     my $commands = $backend->receive($worker_id);

   Receive remote control commands for worker.

register_worker

     my $worker_id = $backend->register_worker;
     my $worker_id = $backend->register_worker($worker_id);
     my $worker_id = $backend->register_worker(
       $worker_id, {status => {queues => ['default', 'important']}});

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

   These options are currently available:

   status

       status => {queues => ['default', 'important']}

     Hash reference with whatever status information the worker would like
     to share.

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({all => 1});

   Reset job queue.

   These options are currently available:

   all

       all => 1

     Reset everything.

   locks

       locks => 1

     Reset only locks.

retry_job

     my $bool = $backend->retry_job($job_id, $retries);
     my $bool = $backend->retry_job($job_id, $retries, {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).

   parents

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

     Jobs this job depends on.

   priority

       priority => 5

     Job priority.

   queue

       queue => 'important'

     Queue to put job in.

stats

     my $stats = $backend->stats;

   Get statistics for the job queue.

   These fields are currently available:

   active_jobs

       active_jobs => 100

     Number of jobs in active state.

   active_locks

       active_locks => 100

     Number of active named locks.

   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.

   enqueued_jobs

       enqueued_jobs => 100000

     Rough estimate of how many jobs have ever been enqueued.

   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.

   uptime

       uptime => undef

     Uptime in seconds. Always undefined for SQLite.

unlock

     my $bool = $backend->unlock('foo');

   Release a named lock.

unregister_worker

     $backend->unregister_worker($worker_id);

   Unregister worker.

BUGS

   Report any issues on the public bugtracker.

AUTHOR

   Dan Book <[email protected]>

COPYRIGHT AND LICENSE

   This software is Copyright (c) 2015 by Dan Book.

   This is free software, licensed under:

     The Artistic License 2.0 (GPL Compatible)

SEE ALSO

   Minion, Mojo::SQLite

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.