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

 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.

    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.

    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.

 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.

    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, foo => 'bar');

    Change a metadata field for a job. 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;

    Reset job queue.

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

    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!

    enqueued_jobs

        enqueued_jobs => 100000

      Rough estimate of how many jobs have ever been enqueued. 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.

 unlock

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

    Release a named lock.

 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.

    status

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

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

BUGS

    Report any issues on the public bugtracker.

AUTHOR

    Dan Book <dbook@cpan.org>

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

