File Coverage

blib/lib/App/Notifier/Service.pm

Criterion	Covered	Total	%
statement	26	37	70.2
branch	0	6	0.0
condition	0	5	0.0
subroutine	9	11	81.8
pod			n/a
total	35	59	59.3

package App::Notifier::Service;
$App::Notifier::Service::VERSION = '0.0901';
use 5.014;

use Mojolicious::Lite -signatures;
use Plack::Builder;

use File::Spec ();
use JSON::MaybeXS qw( decode_json );
use YAML::XS qw( LoadFile );
use List::MoreUtils qw();

use POSIX ":sys_wait_h";
use Errno;

sub _REAPER
{
    local $!;    # don't let waitpid() overwrite current error
    while ( ( my $pid = waitpid( -1, WNOHANG ) ) > 0 && WIFEXITED($?) )
    {
    }
    $SIG{CHLD} = \&_REAPER;    # loathe SysV
}

# $SIG{CHLD} = \&_REAPER;

my $config_fn = ( $ENV{'NOTIFIER_CONFIG'}
        || File::Spec->catfile( $ENV{HOME}, '.app_notifier.yml' ) );

my $config;

sub _process_cmd_line_arg
{
    my ( $arg, $text_params ) = @_;

    if ( ref($arg) eq '' )
    {
        return $arg;
    }
    elsif ( ref($arg) eq 'HASH' )
    {
        if ( $arg->{type} eq 'text_param' )
        {
            return ( $text_params->{ $arg->{param_name} } // '' );
        }
        else
        {
            die +{ msg => "Unknown special argument type $arg->{type}", };
        }
    }
    else
    {
        die +{ msg =>
"Unhandled perl type for argument in command line template (should be string or hash.",
        };
    }

    return;
}

get '/notify' => sub {
    my $c = shift;

    $config ||= LoadFile($config_fn);

    my $cmd_id      = ( $c->req->param('cmd_id') || 'default' );
    my $text_params = {};
    if ( defined( my $text_params_as_json = $c->req->param('text_params') ) )
    {
        $text_params = decode_json($text_params_as_json);
        if ( ref($text_params) ne 'HASH' )
        {
            return "Invalid text_params - should be a JSON hash.\n";
        }
        elsif ( List::MoreUtils::any { ref($_) ne '' } values(%$text_params) )
        {
            return "Invalid text_params - all values must be strings.\n";
        }
    }
    my $cmd = $config->{commands}->{$cmd_id};

    if ( defined($cmd) )
    {
        my @before_cmd_line = ( ( ref($cmd) eq 'ARRAY' ) ? @$cmd : $cmd );

        my @cmd_line = eval {
            map { _process_cmd_line_arg( $_, $text_params ); } @before_cmd_line;
        };

        if ( my $Err = $@ )
        {
            if ( ref($Err) eq 'HASH' and ( exists( $Err->{msg} ) ) )
            {
                return ( $Err->{msg} . "\n" );
            }
            else
            {
                die $Err;
            }
        }

        my $pid;
        if ( !defined( $pid = fork() ) )
        {
            die "Cannot fork: $!";
        }
        elsif ( !$pid )
        {
            # I'm the child.
            if ( fork() eq 0 )
            {
                # I'm the grandchild.
                system { $cmd_line[0] } @cmd_line;
            }
            POSIX::_exit(0);
        }
        else
        {
            waitpid( $pid, 0 );
        }
        $c->render( text => "Success.\n" );
    }
    else
    {
        $c->log("Unknown Command ID '$cmd_id'.");
        return "Unknown Command ID.\n";
    }
};

get '/' => sub {
    my $c = shift;
    $c->render( text => "OK\n" );
};

builder
{
    # enable 'Deflater';
    app->start;
};

# "true";

# start;

__END__