File Coverage

blib/lib/App/Unix/RPasswd.pm

Criterion	Covered	Total	%
statement	18	73	24.6
branch	0	22	0.0
condition	0	6	0.0
subroutine	6	10	60.0
pod	0	2	0.0
total	24	113	21.2

package App::Unix::RPasswd;

use 5.010000;
use feature ':5.10';
use Moo;
use Parallel::ForkManager;
use App::Unix::RPasswd::Connection;
use App::Unix::RPasswd::SaltedPasswd;

our $VERSION = '0.53';
our $AUTHOR  = 'Claudio Ramirez ';

has 'args' => (
    is       => 'ro',
    #isa      => 'HashRef',
    required => 1,
);

has '_connection_obj' => (
    is      => 'ro',
    does    => 'App::Unix::RPasswd::Connection',
    default => sub {
        my $self = shift;
        App::Unix::RPasswd::Connection->new(
            user     => $self->args->{user},
            ssh_args => $self->args->{ssh},
        );
    },
    lazy     => 1,
    init_arg => undef,
);

has '_saltedpasswd_obj' => (
    is      => 'ro',
    does    => 'App::Unix::RPasswd::SaltedPasswd',
    default => sub {
        my $self = shift;
        App::Unix::RPasswd::SaltedPasswd->new( salt => $self->args->{base} );
    },
    lazy     => 1,
    init_arg => undef,
);

sub ask_key {
    my ( $self, $key ) = @_;
    my $ckeys = $key;
    $ckeys =~ s/(\w)(.+)/\U$1\E$2s/;    # key -> Keys
    my @msg =
      ( "Please introduce the $key: ", "\nPlease re-introduce the $key: " );
    my $counter    = 0;
    my $first_time = 1;
    print $msg[$counter];
    my @input;
    system( '/bin/stty', '-echo' );

    while () {
        chomp;
        $input[$counter] = $_;
        if ( $counter == 1 ) {
            if ( $input[0] eq $input[1] ) { last }
            else {
                say "\n$ckeys are not the same...";
                $counter = 0;
            }
        }
        else { $counter++; $first_time = 0; }

        print $msg[$counter] unless $first_time;
    }
    system '/bin/stty echo';
    say '';
    return $input[0];
}

sub pexec {
    my $self    = shift;
    my @servers = @_;
    state $run++;
    my @errors;

    # Setup forks
    my $pfm = Parallel::ForkManager->new( $self->args->{sessions} );

    # Retrieve status
    $pfm->run_on_finish(
        sub {
            my ( undef, undef, undef, undef, undef, $dataref ) = @_;
            if ( defined $dataref and defined $$dataref ) {
                push @errors, $$dataref;
            }
        }
    );

    for my $server (@servers) {
        if (@servers) {
            $pfm->start() and next;
            my $error;
            if ( defined $self->args->{base} ) {
                $self->args->{password} =
                  $self->_saltedpasswd_obj->generate(
                    $server . $self->args->{date} . $server );
            }

            if ( $self->args->{generate_only} ) {
                say $self->args->{password} . " ($server)";
            }
            else {
                my $msg =
                  ( $self->args->{debug} )
                  ? 'Running on '
                  . $server
                  . ' with password \''
                  . $self->args->{password} . '\'...'
                  : "Running on $server...";
                say $msg;
                my $status = eval {
                    local $SIG{ALRM} = sub {
                        say "Timeout exceeded for $server.";
                        die "Timeout exceeded\n";    # NB: \n required
                    };
                    alarm $self->args->{timeout};
                    return $self->_connection_obj->run(
                        $server,
                        $self->args->{password},
                        $self->args->{debug}
                    );
                    alarm 0;
                };
                if ( !$status ) { $error = $server; }
            }
            $pfm->finish( 0, \$error );
        }
    }
    $pfm->wait_all_children;
    say "\nRun $run done.\n";
    return ( scalar @errors and $run <= $self->args->{reruns} )
      ? $self->pexec(@errors)
      : @errors;    # recursive
}

1;
__END__