NAME

    Minion::Backend::MongoDB - MongoDB backend for Minion

VERSION

    version 1.00

SYNOPSIS

      use Minion::Backend::MongoDB;
    
      my $backend = Minion::Backend::MongoDB->new('mongodb://127.0.0.1:27017');

DESCRIPTION

    Minion::Backend::MongoDB is a MongoDB backend for Minion derived from
    Minion::Backend::Pg and supports its methods and tests up to 9.11.

ATTRIBUTES

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

 mongodb

      my $mongodb = $backend->mongodb;
      $backend  = $backend->mongodb(MongoDB->new);

    MongoDB::Database object used to store collections.

 jobs

      my $jobs = $backend->jobs;
      $backend = $backend->jobs(MongoDB::Collection->new);

    MongoDB::Collection object for jobs collection, defaults to one based
    on "prefix".

 notifications

      my $notifications = $backend->notifications;
      $backend          = $backend->notifications(MongoDB::Collection->new);

    MongoDB::Collection object for notifications collection, defaults to
    one based on "prefix".

 prefix

      my $prefix = $backend->prefix;
      $backend   = $backend->prefix('foo');

    Prefix for collections, defaults to minion.

 workers

      my $workers = $backend->workers;
      $backend    = $backend->workers(MongoDB::Collection->new);

    MongoDB::Collection object for workers collection, defaults to one
    based on "prefix".

METHODS

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

 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 $info = $backend->dequeue($worker_id, 0.5);

    Wait for job, dequeue it and transition from inactive to active state
    or return undef if queue was empty.

 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:

    delay

        delay => 10

      Delay job for this many seconds from now.

    priority

        priority => 5

      Job priority, defaults to 0.

 fail_job

      my $bool = $backend->fail_job($job_id);
      my $bool = $backend->fail_job($job_id, 'Something went wrong!');

    Transition from active to failed state.

 finish_job

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

    Transition from active to finished state.

 job_info

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

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

 list_jobs

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

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

    These options are currently available:

    ids

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

      List only jobs with these ids.

    queues

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

      List only jobs in these queues.

    state

        state => 'inactive'

      List only jobs in this state.

    task

        task => 'test'

      List only jobs for this task.

    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

      Server 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:

    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.

 new

      my $backend = Minion::Backend::MongoDB->new('mongodb://127.0.0.1:27017');

    Construct a new Minion::Backend::MongoDB object. Required a connection
    string URI. Optional every other attributes will be pass to
    MongoDB::MongoClient costructor.

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

    Transition from failed or finished state back to inactive.

    These options are currently available:

    delay

        delay => 10

      Delay job for this many seconds (from now).

 stats

      my $stats = $backend->stats;

    Get statistics for jobs and workers.

 unregister_worker

      $backend->unregister_worker($worker_id);

    Unregister worker.

 worker_info

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

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

NOTES ABOUT USER

    User must have this roles

      "roles" : [
                    {
                            "role" : "dbAdmin",
                            "db" : "minion"
                    },
                    {
                            "role" : "clusterMonitor",
                            "db" : "admin"
                    },
                    {
                            "role" : "readWrite",
                            "db" : "minion"
                    }
            ]

SEE ALSO

    Minion, MongoDB, http://mojolicio.us.

AUTHOR

    Emiliano Bruni <info@ebruni.it>, Andrey Khozov <avkhozov@gmail.com>

COPYRIGHT AND LICENSE

    This software is Copyright (c) 2019 by Emiliano Bruni, Andrey Khozov.

    This is free software, licensed under:

      The GNU General Public License, Version 3, June 2007

