File Coverage

blib/lib/Footprintless/Mixins.pm

Criterion	Covered	Total	%
statement	61	98	62.2
branch	10	38	26.3
condition	5	12	41.6
subroutine	18	26	69.2
pod			n/a
total	94	174	54.0

use strict;
use warnings;

package Footprintless::Mixins;
$Footprintless::Mixins::VERSION = '1.29';
# ABSTRACT: A utility package for mixins for standard object
# PODNAME: Footprintless::Mixins

use Carp;
use Exporter qw(import);
use File::Path qw(
    make_path
);
use Footprintless::Command qw(
    cp_command
);
use Footprintless::Util qw(
    clean
    dumper
    extract
    invalid_entity
    rebase
    temp_dir
);
use Log::Any;

our @EXPORT_OK = qw(
    _clean
    _command_options
    _deployment
    _download
    _entity
    _extract_resource
    _is_local
    _local_template
    _overlay
    _push_resource_to_destination
    _push_to_destination
    _resource
    _run
    _run_or_die
    _service
    _sub_coordinate
    _sub_entity
    _verify_required_entities
);

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

sub _clean {
    my ( $self, %options ) = @_;
    my $clean = _sub_entity( $self, 'clean' );
    if ($clean) {
        clean(
            $clean,
            command_runner  => $self->{factory}->command_runner(),
            command_options => _command_options($self),
            rebase          => $options{rebase}
        );
    }
}

sub _command_options {
    my ( $self, $sub_coordinate ) = @_;
    my $entity =
        $sub_coordinate
        ? _sub_entity( $self, $sub_coordinate )
        : _entity( $self, $self->{coordinate} );
    return $self->{factory}->command_options(%$entity);
}

sub _deployment {
    my ( $self, $sub_coordinate, $name ) = @_;
    my $deployment = $name ? $self->{$name} : undef;
    unless ($deployment) {
        $deployment = $self->{factory}->deployment( _sub_coordinate( $self, $sub_coordinate ) );
        $self->{$name} = $deployment if ($name);
    }
    return $deployment;
}

sub _download {
    my ( $self, $resource, $to ) = @_;
    my @options =
           $to
        && ref($resource)
        && $resource->{as}
        ? ( to => File::Spec->catfile( $to, $resource->{as} ) )
        : ( to => $to );

    my $path = $self->{factory}->resource_manager()->download( $resource, @options );
    die( "$path did not exist after _download of " . dumper($resource) ) unless ( -e $path );
    $logger->debugf( 'Successfully downloaded resource %s to %s', $resource, $path );
    return $path;

    # return $self->{factory}->resource_manager()->download($resource, @options);
}

sub _entity {
    my ( $self, $coordinate, $required ) = @_;
    my $entity = $self->{factory}->entities()->get_entity($coordinate);
    invalid_entity( $coordinate, "does not exist" )
        if ( $required && !$entity );
    return $entity;
}

sub _extract_resource {
    my ( $self, $resource, $to_dir ) = @_;
    extract( _download( $self, $resource ), to => $to_dir );
}

sub _is_local {
    my ( $self, $hostname_sub_coordinate ) = @_;
    return $self->{factory}->localhost()
        ->is_alias( _sub_entity( $self, $hostname_sub_coordinate ) );
}

sub _local_template {
    my ( $self, $local_work, %options ) = @_;
    my $destination_dir = $options{destination_dir}
        || _sub_entity( $self, 'to_dir', 1 );

    my ( $is_local, $to_dir );
    if ( $options{rebase} ) {
        $to_dir = rebase( $destination_dir, $options{rebase} );
        $is_local = 1;
    }
    else {
        $is_local = _is_local( $self, 'hostname' );
        $to_dir = $is_local ? $destination_dir : temp_dir();
    }

    &$local_work($to_dir);

    _push_to_destination( $self, $to_dir, $destination_dir ) unless ($is_local);
}

sub _overlay {
    my ( $self, $sub_coordinate, $name ) = @_;
    my $overlay = $name ? $self->{$name} : undef;
    unless ($overlay) {
        $overlay = $self->{factory}->overlay( _sub_coordinate( $self, $sub_coordinate ) );
        $self->{$name} = $overlay if ($name);
    }
    return $overlay;
}

sub _push_resource_to_destination {
    my ( $self, $resource, $destination_dir, %options ) = @_;

    my $temp_dir = temp_dir();
    if ( $options{extract} ) {
        _extract_resource( $self, $resource, $temp_dir );
    }
    else {
        _download( $self, $resource, $temp_dir );
    }

    _push_to_destination( $self, $temp_dir, $destination_dir, %options );
}

sub _push_to_destination {
    my ( $self, $source_dir, $destination_dir, %options ) = @_;

    my %copy_options   = ();
    my %runner_options = ();

    if ( $options{status} ) {
        $copy_options{status}       = $options{status};
        $runner_options{err_handle} = \*STDERR;
    }

    _run_or_die(
        $self,
        cp_command(
            $source_dir, $destination_dir,
            $options{command_options} || _command_options($self), %copy_options
        ),
        \%runner_options
    );
}

sub _resource {
    my ( $self, $resource ) = @_;
    return $self->{factory}->resource_manager()->resource($resource);
}

sub _run {
    my ( $self, $command, @runner_options ) = @_;
    return $self->{factory}->command_runner()->run( $command, @runner_options );
}

sub _run_or_die {
    my ( $self, $command, @runner_options ) = @_;
    return $self->{factory}->command_runner()->run_or_die( $command, @runner_options );
}

sub _service {
    my ( $self, $sub_coordinate, $name ) = @_;
    my $service = $name ? $self->{$name} : undef;
    unless ($service) {
        $service = $self->{factory}->service( _sub_coordinate( $self, $sub_coordinate ) );
        $self->{$name} = $service if ($name);
    }
    return $service;
}

sub _sub_coordinate {
    my ( $self, $sub_coordinate ) = @_;
    return "$self->{coordinate}.$sub_coordinate";
}

sub _sub_entity {
    my ( $self, $sub_coordinate, $required ) = @_;
    return _entity( $self, _sub_coordinate( $self, $sub_coordinate ), $required );
}

sub _verify_required_entities {
    my ( $self, @sub_coordinates ) = @_;
    _sub_entity( $self, $_, 1 ) foreach @sub_coordinates;
}

1;

__END__