File Coverage

blib/lib/App/Prove/Elasticsearch/Queue/Default.pm

Criterion	Covered	Total	%
statement	92	93	98.9
branch	14	16	87.5
condition	3	6	50.0
subroutine	11	11	100.0
pod	5	5	100.0
total	125	131	95.4

package App::Prove::Elasticsearch::Queue::Default;
$App::Prove::Elasticsearch::Queue::Default::VERSION = '0.001';

# PODNAME: App::Prove::Elasticsearch::Queue::Default;
# ABSTRACT: Coordinate the running of test plans across multiple forks.

use strict;
use warnings;

use List::Util 1.45 qw{shuffle uniq};
use App::Prove::Elasticsearch::Utils;

sub new {
    my ($class, $input) = @_;
    my $conf = App::Prove::Elasticsearch::Utils::process_configuration($input);

    my $planner = App::Prove::Elasticsearch::Utils::require_planner($conf);
    &{\&{$planner . "::check_index"}}($conf);

    return bless({config => $conf, planner => $planner}, $class);
}

sub get_jobs {
    my ($self, $jobspec) = @_;

    $self->_get_searcher();

    $jobspec->{searcher} = $self->{searcher};
    my $plans = &{\&{$self->{planner} . "::get_plans_needing_work"}}(%$jobspec);
    return () unless scalar(@$plans);

    my @tests;
    foreach my $plan (@$plans) {
        my @tmp_tests =
          ref $plan->{tests} eq 'ARRAY' ? @{$plan->{tests}} : ($plan->{tests});
        push(@tests, @tmp_tests);
    }
    @tests = shuffle($self->{searcher}->filter(uniq @tests));
    return @tests unless $self->{config}->{'queue.granularity'};
    @tests = splice(@tests, 0, $self->{config}->{'queue.granularity'});
    return @tests;
}

sub _get_indexer {
    my $self = shift;
    $self->{indexer} //=
      App::Prove::Elasticsearch::Utils::require_indexer($self->{config});
    return $self->{indexer};
}

sub _get_searcher {
    my $self = shift;
    return $self->{searcher} if $self->{searcher};
    my $searcher =
      App::Prove::Elasticsearch::Utils::require_searcher($self->{config});

    $self->{searcher} = &{\&{$searcher . "::new"}}
      ($searcher, $self->{config}, $self->_get_indexer());
    return $self->{searcher};
}

sub list_queues {
    my ($self, %matrix) = @_;
    my $pf = [];
    @$pf = grep { defined $_ } values(%{$matrix{cur_platforms}});
    push(@$pf, @{$matrix{unsatisfiable_platforms}});
    my %jobspec = (
        version   => $matrix{cur_version},
        platforms => $pf,
        searcher  => $self->_get_searcher(),
    );
    my $plans = &{\&{$self->{planner} . "::get_plans_needing_work"}}(%jobspec);
    return @$plans if @$plans;

    #construct iterator
    my @pigeonholes =
      map  { $matrix{platforms}{$_} }
      grep { scalar(@{$matrix{platforms}{$_}}) } keys(%{$matrix{platforms}});

    my @plots;
    my @iterator = @{$pigeonholes[0]};
    while (scalar(@iterator)) {
        my $subj = shift @iterator;

        #Handle initial elements
        $subj = [$subj] if ref $subj ne 'ARRAY';

        #Break out of the loop if we have no more possibilities to exploit
        if (scalar(@$subj) == scalar(@pigeonholes)) {
            push(@plots, $subj);
            next;
        }

        #Keep pushing partials on to the end of the iterator, until we run out of categories to add
        foreach my $element (@{$pigeonholes[ scalar(@$subj) ]}) {
            my @partial = @$subj;
            push(@partial,  $element);
            push(@iterator, \@partial);
        }
    }
    @plots = map { [ @$_, @{$matrix{'unsatisfiable_platforms'}} ] } @plots;

    #OK, now I have a list of potential platforms I can ask whether they exist
    foreach my $gambit (@plots) {
        $jobspec{platforms} = $gambit;
        $plans = &{\&{$self->{planner} . "::get_plans_needing_work"}}(%jobspec);
        return @$plans if (ref($plans) eq 'ARRAY') && @$plans;
    }
    return ();
}

sub queue_jobs {
    print "Queued local job.\n";
    return 0;
}

sub build_queue_name {
    my ($self, $jobspec) = @_;
    my $name = $jobspec->{version};
    $name .= join('', @{$jobspec->{platforms}});
    return $name;
}

1;

__END__