File Coverage

blib/lib/Footprintless/Service.pm

Criterion	Covered	Total	%
statement	66	66	100.0
branch	15	20	75.0
condition	4	8	50.0
subroutine	18	18	100.0
pod	5	5	100.0
total	108	117	92.3

use strict;
use warnings;

package Footprintless::Service;
$Footprintless::Service::VERSION = '1.28';
# ABSTRACT: Performs an action on a service.
# PODNAME: Footprintless::Service

use parent qw(Footprintless::MixableBase);

use Carp;
use Footprintless::Command qw(
    batch_command
    command
);
use Footprintless::CommandOptionsFactory;
use Footprintless::InvalidEntityException;
use Footprintless::Localhost;
use Footprintless::Mixins qw(
    _command_options
    _entity
    _run_or_die
);
use Footprintless::Util qw(
    invalid_entity
);
use Log::Any;

my $logger = Log::Any->get_logger();

sub kill {
    my ( $self, %options ) = @_;
    $self->execute( 'kill', %options );
}

sub _command {
    my ( $self, $action ) = @_;
    my $command      = $self->{spec}{command};
    my $actions_spec = $self->{spec}{actions}{$action};
    if ($actions_spec) {
        if ( $actions_spec->{command} ) {
            return $actions_spec->{command};
        }
        elsif ( $actions_spec->{command_args} ) {
            $action = $actions_spec->{command_args};
        }
        elsif ( $actions_spec->{use_pid} ) {
            invalid_entity( $self->{coordinate},
                "pid_file or pid_command required for [$action]" )
                unless ( $self->{spec}{pid_file} || $self->{spec}{pid_command} );

            my $pid_file = $self->{spec}{pid_file};
            my $pid_command =
                $pid_file
                ? command(
                "cat $pid_file",
                $self->{command_options}->clone(
                    hostname     => undef,
                    ssh          => undef,
                    ssh_username => undef,
                )
                )
                : $self->{spec}{pid_command};
            if ( $action eq 'kill' ) {
                return "kill -KILL \$($pid_command)";
            }
            elsif ( $action eq 'status' ) {
                my $command_name = $actions_spec->{command_name} || $command || 'command';
                return command( "kill -0 \$($pid_command) 2> /dev/null "
                        . "&& echo '$command_name is running' "
                        . "|| echo '$command_name is stopped'" );
            }
            else {
                invalid_entity( $self->{coordinate}, "use_pid not supported for [$action]" );
            }
        }
    }

    invalid_entity( $self->{coordinate}, "no command specified for [$action]" )
        unless ($command);
    return "$command $action";
}

sub execute {
    my ( $self, $action, %options ) = @_;

    my $runner_options =
          %options && $options{runner_options}
        ? $options{runner_options}
        : { out_handle => \*STDOUT };

    $self->_run_or_die( command( $self->_command($action), $self->{command_options} ),
        $runner_options );
}

sub _init {
    my ( $self, %options ) = @_;

    $self->{entity}          = $self->{factory}->entities();
    $self->{spec}            = $self->_entity( $self->{coordinate}, 1 );
    $self->{command_options} = $self->_command_options();

    return $self;
}

sub start {
    my ( $self, %options ) = @_;
    $self->execute( 'start', %options );
}

sub status {
    my ( $self, %options ) = @_;
    $self->execute( 'status', %options );
}

sub stop {
    my ( $self, %options ) = @_;
    $self->execute( 'stop', %options );
}

1;

__END__