App-Ikaros

 view release on metacpan or  search on metacpan

lib/App/Ikaros.pm  view on Meta::CPAN

sub new {
    my ($class, $options) = @_;

    my $loaded_conf = App::Ikaros::Config::Loader->new({
        config         => $options->{config},
        config_type    => $options->{config_type},
        config_options => $options->{config_options}
    })->load;

    my $ikaros = $class->SUPER::new({
        config   => $loaded_conf,
        hosts    => [],
        verbose  => $options->{verbose},
        enable_profile  => $options->{enable_profile},
        output_filename => $options->{output_filename}
    });

    $ikaros->__setup_landing_points;
    $ikaros->__planning;
    return $ikaros;

lib/App/Ikaros/Builder.pm  view on Meta::CPAN

use Coro::Select;
use Capture::Tiny ':all';
use App::Ikaros::Util qw/run_command_on_remote/;
use App::Ikaros::Installer;
use constant { DEBUG => 0 };

__PACKAGE__->mk_accessors(qw/installer/);

sub new {
    my ($class) = @_;
    return $class->SUPER::new({
        installer => App::Ikaros::Installer->new
    });
}

sub rsync {
    my ($self, $hosts, $rsync_params) = @_;
    return unless $rsync_params;

    my @coros;
    foreach my $host (@$hosts) {

lib/App/Ikaros/Installer.pm  view on Meta::CPAN

    App/Prove.pm
    App/ForkProve.pm
    XML/Simple.pm
    TAP/Harness/JUnit.pm
    IPC/Run.pm
};

sub new {
    my ($class) = @_;
    my $code = do { local $/; <DATA> };
    return $class->SUPER::new({ code => $code });
}

sub install_all {
    my ($self, $host) = @_;
    $self->__install_libraries($host);
    $self->__install_devel_cover($host) if ($host->coverage);
    $self->__install_trigger_script($host);
}

sub __install_libraries {

lib/App/Ikaros/LandingPoint.pm  view on Meta::CPAN

    my @ssh_opt = ($key) ? (key_path => $key) : ();

    my $ssh = Net::OpenSSH->new($user . '@' . $hostname, @ssh_opt);
    $ssh->error and die 'unable to connect to remote host: ' . $ssh->error;
    my $trigger_filename = __unique_name($workdir, $hostname, 'build_kicker.pl');
    my $output_filename  = __unique_name($workdir, $hostname, 'output.xml');
    my $dot_prove_filename  = __unique_name($workdir, $hostname, 'dot_prove.yaml');
    my $cover_db_name    = __unique_name($workdir, $hostname, 'cover_db');

    return $class->SUPER::new({
        user       => $user,
        hostname   => $hostname,
        connection => $ssh,
        workdir    => $workdir,
        runner     => $runner,
        coverage   => $coverage,
        perlbrew   => $perlbrew,
        trigger_filename => $trigger_filename,
        output_filename  => $output_filename,
        dot_prove_filename => $dot_prove_filename,

lib/App/Ikaros/Planner.pm  view on Meta::CPAN

    forkprove_tests
    saved_tests
    sorted_tests
/);

sub new {
    my ($class, $hosts, $args) = @_;
    unless ($args->{prove_tests} || $args->{forkprove_tests}) {
        die "must be set 'prove_tests' and 'forkprove_tests(optional)'";
    }
    my $self = $class->SUPER::new({ %$args });
    $self->__load_prove_state([ @{$args->{prove_tests}}, @{$args->{forkprove_tests}} ])
        if (-f PROVE_STATE_FILE);
    $self->__setup_testing_cluster($hosts);
    return $self;
}

sub planning {
    my ($self, $host, $args) = @_;
    my $commands = $self->__make_command($args, $host);
    $host->plan($commands);

lib/App/Ikaros/Reporter.pm  view on Meta::CPAN

    recovery_testing_command
    enable_profile
    profiler
    output_filename
    verbose
    tests
/);

sub new {
    my ($class, $options) = @_;
    my $reporter = $class->SUPER::new({
        recovery_testing_command => $options->{recovery_testing_command},
        enable_profile  => $options->{enable_profile} || 0,
        profiler        => App::Ikaros::Profiler->new,
        output_filename => $options->{output_filename} || 'ikaros_output.xml',
        verbose  => $options->{verbose} || 0,
        tests    => +{}
    });
    $reporter->__setup_mangled_name_for_junit($options->{tests});
    return $reporter;
}