File Coverage

blib/lib/App/PerlWatcher/Watcher/GenericExecutor.pm

Criterion	Covered	Total	%
statement	70	80	87.5
branch	3	6	50.0
condition			n/a
subroutine	18	18	100.0
pod	0	2	0.0
total	91	106	85.8

package App::PerlWatcher::Watcher::GenericExecutor;
{
  $App::PerlWatcher::Watcher::GenericExecutor::VERSION = '0.20';
}
# ABSTRACT: Watches for the output of execution of arbitrary command.

use 5.12.0;
use strict;
use warnings;

use AnyEvent;
use AnyEvent::Util;
use Smart::Comments -ENV;
use IPC::Cmd qw/run/;
use Moo;
use POSIX qw(SIGKILL);

use App::PerlWatcher::Levels qw/get_by_description LEVEL_NOTICE/;
use aliased qw/App::PerlWatcher::EventItem/;
use aliased qw/App::PerlWatcher::Status/;

with qw/App::PerlWatcher::Watcher/;




has 'command' => ( is => 'ro', required => 1 );


has 'arguments' => (is => 'ro', default => sub{ []; } );


has 'frequency' => (is => 'ro', defalut => sub{ 600; } );


has 'timeout' => (is => 'ro', defalut => sub{ []; } );


has 'filter' => (is => 'ro', default => sub{ sub{ 1; };  } );


has 'beautifyer' => (is => 'ro', default => sub{ sub{ shift;}; });


has 'rules' => (is => 'ro', default => sub { []; });


sub description {
    my $self = shift;
    return "GenericExectuor [" . $self->command . "]";
}

sub _get_level {
    my ($self, @lines) = @_;
    my $rules = $self->rules;
    for (my $i =0; $i < @$rules; $i+=2 ) {
        my $level_string = $rules->[$i];
        my $rule         = $rules->[$i+1];
        return get_by_description($level_string)
            if ($rule->(@lines));
    }
    return LEVEL_NOTICE;
}


has 'callback_proxy' => (is => 'lazy');

sub _build_callback_proxy {
    my $self = shift;
    return sub {
        my $success = shift;
        unless ($success) {
            my $reason = shift;
            return $self->callback->(
                Status->new(
                    watcher     => $self,
                    level       => LEVEL_NOTICE,
                    description => sub { $self->description . " : $reason" },
                    items       => sub { [] },
                )
            );
        }
        my $output = shift;
        my @lines = split("\n", $output);
        @lines =
            map  {$self->beautifyer->($_)}
            grep { $self->filter->($_) }
            @lines;
        my $level = $self->_get_level(@lines);
        my @items = map {
            EventItem->new(
                content => $_,
            );
        } @lines;
        $self->callback->(
            Status->new(
                watcher     => $self,
                level       => $level,
                description => sub { $self->description; },
                items       => sub { \@items, },
            )
        );
    };
}


sub build_watcher_guard {
    my $self = shift;
    my $guard = AnyEvent->timer(
        after    => 0,
        interval => $self->frequency,
        cb       => sub {
            $self->poll_callback->($self);
            my $output;
            my $timeout = $self->timeout;
            my $cv_cmd; $cv_cmd = fork_call {
				my ($success, $buffer);
				eval {
					$success = run(
						command => [$self->command, @{ $self->arguments }],
						timeout => $timeout,
						buffer  => \$buffer);
				};
				($success, $success ? $buffer : $@);
			} sub {
				my ($success, $output) = @_;
				undef $cv_cmd;
				$self->callback_proxy->($success, $output);
			};
        });
    return $guard;
};

1;

__END__