File Coverage

blib/lib/Footprintless.pm

Criterion	Covered	Total	%
statement	71	90	78.8
branch	19	30	63.3
condition			n/a
subroutine	17	22	77.2
pod	13	13	100.0
total	120	155	77.4

use strict;
use warnings;

package Footprintless;
$Footprintless::VERSION = '1.26';
# ABSTRACT: A utility for managing systems with minimal installs
# PODNAME: Footprintless

use Carp;
use Config::Entities;
use Footprintless::Util qw(factory);
use Log::Any;

our $AUTOLOAD;

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

sub new {
    return bless( {}, shift )->_init(@_);
}

sub agent {
    my ( $self, @options ) = @_;
    $self->{factory}->agent(@options);
}

sub AUTOLOAD {
    my ( $self, @args ) = @_;
    my $method = $AUTOLOAD;
    $method =~ s/.*:://;
    $self->{factory}->$method(@args) if ( $self->{factory} );
}

sub command_options_factory {
    my ( $self, @args ) = @_;
    $self->{factory}->command_options_factory(@args);
}

sub command_runner {
    my ( $self, @args ) = @_;
    $self->{factory}->command_runner(@args);
}

sub deployment {
    my ( $self, @args ) = @_;
    $self->{factory}->deployment(@args);
}

sub entities {
    my ( $self, @args ) = @_;
    $self->{factory}->entities(@args);
}

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

    $logger->debugf( 'creating new Footprintless: %s', \%options );

    if ( $options{factory} ) {
        $self->{factory} = $options{factory};
    }
    else {
        my $entities;
        if ( $options{entities} ) {
            if ( ref( $options{entities} ) eq 'HASH' ) {
                $entities = Config::Entities->new( { entity => $options{entities} } );
            }
            elsif ( $options{entities}->isa('Config::Entities') ) {
                $entities = $options{entities};
            }
            else {
                croak('illegal entities, must be hashref, or Config::Entities');
            }
        }
        else {
            my $fpl_home;
            if ( $options{fpl_home} ) {
                $fpl_home = $options{fpl_home};
            }
            elsif ( $ENV{FPL_HOME} ) {
                $fpl_home = $ENV{FPL_HOME};
            }
            else {
                $fpl_home = File::Spec->catdir( $ENV{HOME}, '.footprintless' );
            }

            my @config_dirs = ();
            if ( $options{config_dirs} ) {
                @config_dirs =
                    ref( $options{config_dirs} ) eq 'ARRAY'
                    ? @{ $options{config_dirs} }
                    : ( $options{config_dirs} );
            }
            elsif ( $ENV{FPL_CONFIG_DIRS} ) {
                @config_dirs = _split_dirs( $ENV{FPL_CONFIG_DIRS} );
            }
            else {
                my $default = File::Spec->catdir( $fpl_home, 'config' );
                if ( -d $default ) {
                    @config_dirs = ($default);
                }
            }

            my @config_options = ();
            if ( $options{config_properties} ) {
                push( @config_options, properties_file => $options{config_properties} );
            }
            elsif ( $ENV{FPL_CONFIG_PROPS} ) {
                my @properties = _split_dirs( $ENV{FPL_CONFIG_PROPS} );
                push( @config_options, properties_file => \@properties );
            }
            else {
                my $default = File::Spec->catdir( $fpl_home, 'properties.pl' );
                if ( -f $default ) {
                    push( @config_options, properties_file => $default );
                }
            }

            $logger->tracef(
                "constructing entities with\n\tconfig_dirs: %s\n\tconfig_options: %s)",
                \@config_dirs, {@config_options} );
            $entities = Config::Entities->new( @config_dirs, {@config_options} );
        }

        $self->{factory} = factory($entities);
    }

    return $self;
}

sub localhost {
    my ( $self, @args ) = @_;
    $self->{factory}->localhost(@args);
}

sub log {
    my ( $self, @args ) = @_;
    $self->{factory}->log(@args);
}

sub plugins {
    my ($self) = @_;
    $self->{factory}->plugins();
}

sub overlay {
    my ( $self, @args ) = @_;
    $self->{factory}->overlay(@args);
}

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

sub service {
    my ( $self, @args ) = @_;
    $self->{factory}->service(@args);
}

sub tunnel {
    my ( $self, @args ) = @_;
    $self->{factory}->tunnel(@args);
}

sub _split_dirs {
    my ($dirs_string) = @_;

    my @dirs = ();
    my $separator = ( $^O eq 'MSWin32' ) ? ';' : ':';
    foreach my $dir ( split( /$separator/, $dirs_string ) ) {
        $dir =~ s/^\s+//;
        $dir =~ s/\s+$//;
        push( @dirs, $dir );
    }

    return @dirs;
}

1;

__END__