File Coverage

blib/lib/App/Prove/Elasticsearch/Utils.pm

Criterion	Covered	Total	%
statement	85	89	95.5
branch	15	20	75.0
condition	4	6	66.6
subroutine	17	17	100.0
pod	12	12	100.0
total	133	144	92.3

# PODNAME: App::Prove::Elasticsearch::Utils
# ABSTRACT: common functions used by multiple modules in the distribution.

package App::Prove::Elasticsearch::Utils;
$App::Prove::Elasticsearch::Utils::VERSION = '0.001';
use strict;
use warnings;

use Config::Simple();
use File::HomeDir();

sub process_configuration {
    my $args = shift;
    my $conf = {};

    my $homedir = File::HomeDir::my_home() || '.';
    if (-e $homedir) {
        unless (Config::Simple->import_from("$homedir/elastest.conf", $conf)) {
            warn Config::Simple->error() if -e "$homedir/elastest.conf";
        }
    }

    my @kvp = ();
    my ($key, $value);
    foreach my $arg (@$args) {
        @kvp = split(/=/, $arg);
        if (scalar(@kvp) < 2) {
            print
              "Unrecognized Argument '$arg' to App::Prove::Plugin::Elasticsearch, ignoring\n";
            next;
        }
        $key          = shift @kvp;
        $value        = join('', @kvp);
        $conf->{$key} = $value;
    }

    #Set ENV for use by harness
    foreach my $key (keys(%$conf)) {
        my $km = uc($key);
        $km =~ s/\./_/g;
        $ENV{$km} = $conf->{$key};
    }

    return $conf;
}

sub require_indexer {
    my $conf = shift;
    my $index_suffix =
      $conf->{'client.indexer'} ? "::" . $conf->{'client.indexer'} : '';
    my $indexer = "App::Prove::Elasticsearch::Indexer$index_suffix";

    eval "require $indexer";
    die $@ if $@;

    #Set ENV for use by harness
    $ENV{CLIENT_INDEXER} = $indexer;
    return $indexer;
}

sub require_searcher {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Searcher',
        'client.autodiscover',
        'CLIENT_AUTODISCOVER'
    );
}

sub require_blamer {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Blamer',
        'client.blamer',
        'CLIENT_BLAMER'
    );
}

sub require_planner {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Planner',
        'client.planner',
        'CLIENT_PLANNER'
    );
}

sub require_platformer {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Platformer',
        'client.platformer',
        'CLIENT_PLATFORMER'
    );
}

sub require_queue {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Queue',
        'client.queue',
        'CLIENT_QUEUE'
    );
}

sub require_versioner {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Versioner',
        'client.versioner',
        'CLIENT_VERSIONER'
    );
}

sub require_runner {
    my $conf = shift;
    return _require_generic(
        $conf,
        'App::Prove::Elasticsearch::Runner',
        'client.runner',
        'CLIENT_RUNNER'
    );
}

sub require_provisioner {
    my $module = shift;
    $module //= 'Default';
    my $module_full = "App::Prove::Elasticsearch::Provisioner::$module";
    eval "require $module_full";
    die $@ if $@;

    #Set ENV for use by harness
    if ($ENV{CLIENT_PROVISIONERS}) {
        $ENV{CLIENT_PROVISIONERS} .= ":$module_full";
    } else {
        $ENV{CLIENT_PROVISIONERS} = "$module_full";
    }
    return $module_full;
}

sub _require_generic {
    my ($conf, $prefix, $suffix_key, $envvar) = @_;
    my $suffix = $conf->{$suffix_key} // 'Default';
    my $module = "${prefix}::$suffix";

    eval "require $module";
    die $@ if $@;

    #Set ENV for use by harness
    $ENV{$envvar} = $suffix;
    return $module;
}

sub get_last_index {
    my ($e, $index) = @_;

    my $res = $e->search(
        index => $index,
        body  => {
            query => {match_all => {}},
            sort  => {id        => {order => "desc"}},
            size => 1
        }
    );

    my $hits = $res->{hits}->{hits};
    return 0 unless scalar(@$hits);

    return $res->{hits}->{total};
}

sub do_paginated_query {
    my ($e, $max_query_size, %q) = @_;
    my $offset     = 0;
    my $hits       = [];
    my $hitcounter = $max_query_size;
    while ($hitcounter == $max_query_size) {
        $q{size} = $max_query_size;
        $q{from} = ($max_query_size * $offset);
        my $res = $e->search(%q);
        push(@$hits, @{$res->{hits}->{hits}});
        $hitcounter = scalar(@{$res->{hits}->{hits}});
        $offset++;
    }
    return $hits;
}

1;

__END__