File Coverage

blib/lib/Beam/Minion/Util.pm

Criterion	Covered	Total	%
statement	61	63	96.8
branch	8	12	66.6
condition			n/a
subroutine	14	14	100.0
pod	3	3	100.0
total	86	92	93.4

package Beam::Minion::Util;
our $VERSION = '0.016';
# ABSTRACT: Utility functions for Beam::Minion

#pod =head1 SYNOPSIS
#pod
#pod     use Beam::Minion::Util qw( minion );
#pod
#pod     my $minion = minion();
#pod     my %attrs = minion_attrs();
#pod
#pod =head1 DESCRIPTION
#pod
#pod This module contains helper routines for L.
#pod
#pod =head1 SEE ALSO
#pod
#pod L
#pod
#pod =cut

use strict;
use warnings;
use Exporter qw( import );
use Minion;
use Beam::Runner::Util qw( find_containers );
use Scalar::Util qw( weaken );
use Mojolicious;
use Mojo::Log;
use Beam::Wire;


our @EXPORT_OK = qw( minion_init_args minion build_mojo_app );

our %BACKEND = (
    sqlite => 'SQLite',
    postgres => 'Pg',
    mongodb => 'MongoDB',
    mysql => 'mysql',
);

#pod =sub minion_init_args
#pod
#pod     my %args = minion_init_args();
#pod
#pod Get the arguments needed to initialize a new Minion instance by parsing
#pod the C environment variable.
#pod
#pod This environment variable can take a few forms:
#pod
#pod =over
#pod
#pod =item
#pod
#pod A simple backend URL like C,
#pod C, C, or
#pod C. The following backends are supported:
#pod L, L,
#pod L, L.
#pod
#pod =item +
#pod
#pod A backend name and arguments, separated by C<+>, like
#pod C. Any backend may be used this way.
#pod
#pod If your backend requires more arguments, you can separate them with
#pod C<+>:
#pod
#pod     # Configure the MySQL backend with a DBI DSN
#pod     BEAM_MINION=mysql+dsn+dbi:mysql:minion
#pod
#pod =back
#pod
#pod =cut

sub minion_init_args {
    die "You must set the BEAM_MINION environment variable to the Minion database URL.\n"
        . "See `perldoc Beam::Minion` for getting started instructions.\n"
        unless $ENV{BEAM_MINION};
    my ( $backend, $url );
    if ( $ENV{BEAM_MINION} =~ /^[^+:]+\+/ ) {
        my @args = split /\+/, $ENV{BEAM_MINION};
        return @args;
    }
    my ( $schema ) = $ENV{BEAM_MINION} =~ /^([^:]+)/;
    return $BACKEND{ $schema }, $ENV{BEAM_MINION};
}

#pod =sub minion
#pod
#pod     my $minion = minion();
#pod
#pod Get a L instance as configured by the C environment
#pod variable (parsed by L).
#pod
#pod =cut

sub minion {
    return Minion->new( minion_init_args );
}

#pod =sub build_mojo_app
#pod
#pod Build the L app that contains the L plugin
#pod (L) and tasks. This can then be given to
#pod one of the L classes to execute commands.
#pod
#pod =cut

sub build_mojo_app {
    my $app = Mojolicious->new(
        log => Mojo::Log->new, # Log to STDERR
    );

    push @{$app->commands->namespaces}, 'Minion::Command';

    my $minion = minion();
    $app->helper(minion => sub {$minion});

    my %container = find_containers();
    for my $container_name ( keys %container ) {
        my $path = $container{ $container_name };
        my $wire = Beam::Wire->new( file => $path );
        my $config = $wire->config;
        for my $service_name ( keys %$config ) {
            next unless $wire->is_meta( $config->{ $service_name }, 1 );
            $minion->add_task( "$container_name:$service_name" => sub {
                my ( $job, @args ) = @_;
                my $wire = Beam::Wire->new( file => $path );

                my $obj = eval { $wire->get( $service_name, lifecycle => 'factory' ) };
                if ( $@ ) {
                    return $job->fail( { error => $@ } );
                }

                my $exit = eval { $obj->run( @args ) };
                if ( my $err = $@ ) {
                    return $job->fail( { error => $err } );
                }

                my $method = $exit ? 'fail' : 'finish';
                $job->$method( { exit => $exit } );
            } );
        }
        undef $wire;
    }

    return $app;
}

1;

__END__