File Coverage

blib/lib/Rex/CMDB/TOML.pm

Criterion	Covered	Total	%
statement	26	132	19.7
branch	0	44	0.0
condition	0	9	0.0
subroutine	9	21	42.8
pod	0	2	0.0
total	35	208	16.8

#
# (c) Jan Gehring
# (c) Zane C. Bowers-Hadley

package Rex::CMDB::TOML;

use 5.010001;
use strict;
use warnings;

our $VERSION = '0.0.1';    # VERSION

use base qw(Rex::CMDB::Base);

use Rex::Commands -no => [qw/get/];
use Rex::Logger;
use TOML qw(from_toml);
use Data::Dumper;
use Hash::Merge qw/merge/;

require Rex::Commands::File;

sub new {
	my $that  = shift;
	my $proto = ref($that) || $that;
	my $self  = {@_};

	$self->{merger} = Hash::Merge->new();

	if ( !defined $self->{merge_behavior} ) {
		$self->{merger}->specify_behavior(
			{
				SCALAR => {
					SCALAR => sub { $_[0] },
					ARRAY  => sub { $_[0] },
					HASH   => sub { $_[0] },
				},
				ARRAY => {
					SCALAR => sub { $_[0] },
					ARRAY  => sub { $_[0] },
					HASH   => sub { $_[0] },
				},
				HASH => {
					SCALAR => sub { $_[0] },
					ARRAY  => sub { $_[0] },
					HASH   => sub { Hash::Merge::_merge_hashes( $_[0], $_[1] ) },
				},
			},
			'REX_DEFAULT',
		);    # first found value always wins

		$self->{merger}->set_behavior('REX_DEFAULT');
	}
	else {
		if ( ref $self->{merge_behavior} eq 'HASH' ) {
			$self->{merger}->specify_behavior( $self->{merge_behavior}, 'USER_DEFINED' );
			$self->{merger}->set_behavior('USER_DEFINED');
		}
		else {
			$self->{merger}->set_behavior( $self->{merge_behavior} );
		}
	}

	bless( $self, $proto );

	# turn roles off by default
	if ( !defined( $self->{use_roles} ) ) {
		$self->{use_roles} = 0;
	}

	# set the default role path ro 'cmdb/roles'
	if ( !defined( $self->{roles_path} ) ) {
		$self->{roles_path} = 'cmdb/roles';
	}

	# if parsing failure should be fatal
	# default true
	if ( !defined( $self->{parse_error_fatal} ) ) {
		$self->{parse_error_fatal} = 1;
	}

	# die if the role does not exist
	# default true
	if ( !defined( $self->{missing_role_fatal} ) ) {
		$self->{missing_role_fatal} = 1;
	}

	# default to false, config overwrites role settings
	if ( !defined( $self->{roles_merge_after} ) ) {
		$self->{roles_merge_after} = 0;
	}

	return $self;
}

sub get {
	my ( $self, $item, $server ) = @_;

	$server = $self->__get_hostname_for($server);

	my $result = {};

	# keep this out here so generated when the files are loaded
	# keep it around later for role processing
	my %template_vars;

	if ( $self->__cache->valid( $self->__cache_key() ) ) {
		$result = $self->__cache->get( $self->__cache_key() );
	}
	else {

		my @files = $self->_get_cmdb_files( $item, $server );

		Rex::Logger::debug( Dumper( \@files ) );

		# configuration variables
		my $config_values = Rex::Config->get_all;
		for my $key ( keys %{$config_values} ) {
			if ( !exists $template_vars{$key} ) {
				$template_vars{$key} = $config_values->{$key};
			}
		}
		$template_vars{environment} = Rex::Commands::environment();

		for my $file (@files) {
			Rex::Logger::debug("CMDB - Opening $file");
			if ( -f $file ) {

				my $content = eval { local ( @ARGV, $/ ) = ($file); <>; };
				my $t       = Rex::Config->get_template_function();
				$content .= "\n";    # for safety
				$content = $t->( $content, \%template_vars );

				my ( $ref, $parse_error ) = from_toml($content);

				# only merge it if we have a actual result
				if ( defined($ref) ) {
					$result = $self->{merger}->merge( $result, $ref );
				}
				else {
					my $error = 'Failed to parse TOML config file "' . $file . '" with error... ' . $parse_error;
					if ( $self->{parse_error_fatal} ) {
						die($error);
					}
					else {
						warn($error);
					}
				}
			}
		}
	}

	# if use_roles is true, process the roles variablesif set
	# the item has roles and that the roles is a array
	if (   $self->{use_roles}
		&& ( defined( $result->{roles} ) )
		&& ( ref( $result->{roles} ) eq 'ARRAY' ) )
	{
		Rex::Logger::debug("CMDB - Starting role processing");

		# load each role
		foreach my $role ( @{ $result->{roles} } ) {
			Rex::Logger::debug( "CMDB - Processing role '" . $role . "'" );
			my $role_file = File::Spec->join( $self->{roles_path}, $role . '.toml' );

			# if the file exists, load it
			if ( -f $role_file ) {
				my $content = eval { local ( @ARGV, $/ ) = ($role_file); <>; };
				my $t       = Rex::Config->get_template_function();
				$content .= "\n";    # for safety
				$content = $t->( $content, \%template_vars );

				my ( $ref, $parse_error ) = from_toml($content);

				# only merge it if we have a actual result
				# undef causes the merge feature to wipe it all out
				# that and it did error... so we need to handle the error
				if ( defined($ref) ) {

					# don't let host variables override the role if
					# roles_merge_after is true
					if ( $self->{roles_merge_after} ) {
						$result = $self->{merger}->merge( $ref, $result );
					}
					else {
						$result = $self->{merger}->merge( $result, $ref );
					}
				}
				else {
					my $error = 'Failed to parse TOML role file "' . $role_file . '" with error... ' . $parse_error;
					if ( $self->{parse_error_fatal} ) {
						die($error);
					}
					else {
						warn($error);
					}
				}
			}
			else {
				my $error = "The role '" . $role . "' is specified by the file '" . $role_file . "' does not eixst";
				if ( $self->{missing_role_fatal} ) {
					die($error);
				}
				else {
					warn($error);
				}
			}
		}
	}

	if ( defined $item ) {
		return $result->{$item};
	}
	return $result;
}

sub _get_cmdb_files {
	my ( $self, $item, $server ) = @_;

	$server = $self->__get_hostname_for($server);

	my @files;

	if ( !ref $self->{path} ) {
		my $env          = Rex::Commands::environment();
		my $server_file  = "$server.toml";
		my $default_file = 'default.toml';
		@files = (
			File::Spec->join( $self->{path}, $env, $server_file ),
			File::Spec->join( $self->{path}, $env, $default_file ),
			File::Spec->join( $self->{path}, $server_file ),
			File::Spec->join( $self->{path}, $default_file ),
		);
	}
	elsif ( ref $self->{path} eq "CODE" ) {
		@files = $self->{path}->( $self, $item, $server );
	}
	elsif ( ref $self->{path} eq "ARRAY" ) {
		@files = @{ $self->{path} };
	}

	my $os = Rex::Hardware::Host->get_operating_system();

	@files = map { $self->_parse_path( $_, { hostname => $server, operatingsystem => $os, } ) } @files;

	return @files;
}

1;

__END__