Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/preaction/minion-backend-mysql

MySQL backend for the 🐙 Minion job runner
https://github.com/preaction/minion-backend-mysql

Last synced: about 1 year ago
JSON representation

MySQL backend for the 🐙 Minion job runner

Awesome Lists containing this project

README 

          
[![Build Status](https://travis-ci.org/preaction/Minion-Backend-mysql.svg?branch=master)](https://travis-ci.org/preaction/Minion-Backend-mysql)

[![Coverage Status](https://coveralls.io/repos/preaction/Minion-Backend-mysql/badge.svg?branch=master)](https://coveralls.io/r/preaction/Minion-Backend-mysql?branch=master)



# NAME



Minion::Backend::mysql



# VERSION



version 1.006



# SYNOPSIS



    use Mojolicious::Lite;



    plugin Minion => {mysql => 'mysql://user@127.0.0.1/minion_jobs'};



    # Slow task

    app->minion->add_task(poke_mojo => sub {

      my $job = shift;

      $job->app->ua->get('mojolicio.us');

      $job->app->log->debug('We have poked mojolicio.us for a visitor');

    });



    # Perform job in a background worker process

    get '/' => sub {

      my $c = shift;

      $c->minion->enqueue('poke_mojo');

      $c->render(text => 'We will poke mojolicio.us for you soon.');

    };



    app->start;



# DESCRIPTION



[Minion::Backend::mysql](https://metacpan.org/pod/Minion::Backend::mysql) is a backend for [Minion](https://metacpan.org/pod/Minion) based on [Mojo::mysql](https://metacpan.org/pod/Mojo::mysql). All

necessary tables will be created automatically with a set of migrations named

`minion`. This backend requires at least v5.6.5 of MySQL.



# NAME



Minion::Backend::mysql - MySQL backend



# ATTRIBUTES



[Minion::Backend::mysql](https://metacpan.org/pod/Minion::Backend::mysql) inherits all attributes from [Minion::Backend](https://metacpan.org/pod/Minion::Backend) and

implements the following new ones.



## mysql



    my $mysql   = $backend->mysql;

    $backend = $backend->mysql(Mojo::mysql->new);



[Mojo::mysql](https://metacpan.org/pod/Mojo::mysql) object used to store all data.



## no\_txn



If true, will not make a transaction around the ["enqueue"](#enqueue) insertions

when a job has parent jobs. Without a transaction, the job could be

dequeued before its parent relationships are written to the database.

However, since MySQL does not support nested transactions (despite

supporting something almost exactly like them...), you can disable

transactions for testing by setting this attribute (if you perform your

tests in a transaction so they can be rolled back when the test is

complete).



# METHODS



[Minion::Backend::mysql](https://metacpan.org/pod/Minion::Backend::mysql) inherits all methods from [Minion::Backend](https://metacpan.org/pod/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 for 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:



- delay



        delay => 10



    Delay job for this many seconds (from now).



- 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 => 'Something went wrong!'});



Transition from `active` to `failed` state.



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



- created



        created => 784111777



    Time job was created.



- delayed



        delayed => 784111777



    Time job was delayed to.



- finished



        finished => 784111777



    Time job was finished.



- priority



        priority => 3



    Job priority.



- queue



        queue => 'important'



    Queue name.



- result



        result => 'All went well!'



    Job result.



- retried



        retried => 784111777



    Time job has been retried.



- retries



        retries => 3



    Number of times job has been retried.



- started



        started => 784111777



    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, {states => 'inactive'});



Returns the same information as ["job\_info"](#job_info) but in batches.



These options are currently available:



- 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"](#worker_info) but in batches.



## new



    my $backend = Minion::Backend::mysql->new('mysql://mysql@/test');



Construct a new [Minion::Backend::mysql](https://metacpan.org/pod/Minion::Backend::mysql) 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`.



These options are currently available:



- 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 jobs and workers.



## 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



    Last time worker sent a heartbeat.



- pid



        pid => 12345



    Process id of worker.



- started



        started => 784111777



    Time worker was started.



# ERRORS



## DBD::mysql::st execute failed: Table '\*.minion\_workers' doesn't exist



This may happen when the SQL create/upgrade scripts fail to run

completely due to permission errors. Re-running with the environment

variable `MOJO_MIGRATIONS_DEBUG=1` should produce the error message

returned by the database.



A common reason for the database install to fail on MySQL >= 8 is that

the user installing the database does not have `SUPER` privileges

needed to create functions when binlogs are enabled: (`DBD::mysql::st

execute failed: You do not have the SUPER privilege and binary logging

is enabled`). See [the MySQL documentation for Stored Program Binary

Logging](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html)

for more information about this problem and how to correct it.



# SEE ALSO



[Minion](https://metacpan.org/pod/Minion), [Mojolicious::Guides](https://metacpan.org/pod/Mojolicious::Guides), [http://mojolicio.us](http://mojolicio.us).



# AUTHORS



- Brian Medley 

- Doug Bell 



# CONTRIBUTORS



- a-leelan <40534142+a-leelan@users.noreply.github.com>

- Alexander Nalobin 

- Dmitry Krylov 

- Hu Yin 

- Jason A. Crome 

- Larry Leszczynski 

- Larry Leszczynski 

- Olaf Alders 

- Paul Cochrane 

- Peter Joh 

- Sergey Andreev <40195653+saintserge@users.noreply.github.com>

- Zoffix Znet 



# COPYRIGHT AND LICENSE



This software is copyright (c) 2021 by Doug Bell and Brian Medley.



This is free software; you can redistribute it and/or modify it under

the same terms as the Perl 5 programming language system itself.