File Coverage

blib/lib/Footprintless/Log.pm

Criterion	Covered	Total	%
statement	77	98	78.5
branch	23	48	47.9
condition	1	3	33.3
subroutine	19	21	90.4
pod	5	5	100.0
total	125	175	71.4

use strict;
use warnings;

package Footprintless::Log;
$Footprintless::Log::VERSION = '1.28';
# ABSTRACT: A log manager
# PODNAME: Footprintless::Log

use parent qw(Footprintless::MixableBase);

use Carp;
use Footprintless::Command qw(
    command
    tail_command
);
use Footprintless::CommandOptionsFactory;
use Footprintless::Localhost;
use Footprintless::Mixins qw(
    _entity
);
use Footprintless::Util qw(
    dumper
    invalid_entity
);
use Log::Any;

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

sub _action_args {
    my ($args) = @_;
    return '' unless ($args);

    my $ref = ref($args);
    return "$args " unless ($ref);

    croak("unsupported ref type [$ref] for action options")
        unless ( $ref eq 'ARRAY' );

    return scalar(@$args)
        ? join( ' ', @$args, '' )
        : '';
}

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

    my $action_args = _action_args( $options{args} );

    return $self->{command_runner}
        ->run_or_die( command( "cat $action_args$self->{log_file}", $self->{command_options} ),
        $self->_runner_options( $options{runner_options} ) );
}

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

    eval {
        $self->{command_runner}->run_or_die(
            tail_command( $self->{log_file}, follow => 1, $self->{command_options} ),
            $self->_runner_options( $options{runner_options}, $options{until} )
        );
    };
    if ($@) {
        my $exception = $self->{command_runner}->get_exception();
        croak($@) unless ( $exception && $exception =~ /^until found .*$/ );
    }
}

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

    my $action_args = _action_args( $options{args} );

    return $self->{command_runner}
        ->run_or_die( command( "grep $action_args$self->{log_file}", $self->{command_options} ),
        $self->_runner_options( $options{runner_options} ) );
}

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

    my $action_args = _action_args( $options{args} );

    return $self->{command_runner}
        ->run_or_die( command( "head $action_args$self->{log_file}", $self->{command_options} ),
        $self->_runner_options( $options{runner_options} ) );
}

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

    $self->{spec} = $self->_entity( $self->{coordinate}, 1 );

    # Allow string, hashref with file key, or object
    my $ref = ref( $self->{spec} );
    if ($ref) {
        if ( $ref eq 'HASH' ) {
            if ( $self->{spec}{file} ) {
                $self->{log_file} = $self->{spec}{file};
            }
            else {
                invalid_entity( $self->{coordinate}, "must be file, or hashref with 'file' key" );
            }
        }
        elsif ( $ref eq 'SCALAR' ) {
            $self->{log_file} = $self->{spec};
        }
        else {
            invalid_entity( $self->{coordinate}, "must be file, or hashref with 'file' key" );
        }
    }
    else {
        $self->{log_file} = $self->{spec};
    }

    $self->{command_runner}  = $self->{factory}->command_runner();
    $self->{command_options} = $self->{factory}->command_options(
        %{  $self->{factory}->entities()->fill(
                $self->{coordinate},
                {   hostname      => undef,
                    ssh           => undef,
                    ssh_username  => undef,
                    sudo_command  => undef,
                    sudo_username => undef
                },
                ancestry => 1
            )
        }
    );

    return $self;
}

sub _runner_options {
    my ( $self, $runner_options, $until ) = @_;

    $runner_options = {} unless ($runner_options);

    my $options = {};
    if ($until) {
        if ( $runner_options->{out_buffer} ) {
            $options->{out_callback} = sub {
                my ($line) = @_;
                ${ $runner_options->{out_buffer} } .= "$line\n";
                die('until found') if ( $line =~ $until );
            };
        }
        elsif ( $runner_options->{out_callback} ) {
            $options->{out_callback} = sub {
                my ($line) = @_;
                &{ $runner_options->{out_callback} }($line);
                die('until found') if ( $line =~ $until );
            };
        }
        else {
            my $handle = $runner_options->{out_handle};
            $options->{out_callback} = sub {
                my ($line) = @_;
                print( $handle "$line\n" ) if ($handle);
                die('until found') if ( $line =~ $until );
            };
        }
    }
    else {
        if ( exists( $runner_options->{out_buffer} ) ) {
            $options->{out_buffer} = $runner_options->{out_buffer};
        }
        elsif ( exists( $runner_options->{out_callback} ) ) {
            $options->{out_callback} = $runner_options->{out_callback};
        }
        elsif ( exists( $runner_options->{out_handle} ) ) {
            $options->{out_handle} = $runner_options->{out_handle};
        }
    }

    if ( exists( $runner_options->{err_buffer} ) ) {
        $options->{err_buffer} = $runner_options->{err_buffer};
    }
    elsif ( exists( $runner_options->{err_callback} ) ) {
        $options->{err_callback} = $runner_options->{err_callback};
    }
    elsif ( exists( $runner_options->{err_handle} ) ) {
        $options->{err_handle} = $runner_options->{err_handle};
    }

    return $options;
}

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

    my $action_args = _action_args( $options{args} );

    return $self->{command_runner}
        ->run_or_die( command( "tail $action_args$self->{log_file}", $self->{command_options} ),
        $self->_runner_options( $options{runner_options} ) );
}

1;

__END__