Rev 201 | Blame | Last modification | View Log | Download | RSS feed
#!/usr/bin/env perl
# v1.2.0 20161022 RWR
# moved makeConfig here so it is usable by install and configure
#
# v1.3.0 20190108 RWR
# added UUID and set defaults for config file
#
# v1.4.0 20190204 RWR
# added autoconvert from v1.2 configuration file to v1.3
# using dumper to set configuration file
#
# version 2.0 20190330 RWR
# changed it so all configs are YAML
#
# version 2.1 20191101 RWR
# changed --name-- tag to name
#
# version 2.2 20191105 RWR
# fixed where dmidecode missing caused exception
#
# version 2.2.1 20191112 RWR
# added timeStamp
#
# version 2.3.0 20220609 RWR
# moved loadConfigurationFile and timeStamp here
package sysinfoconf;
our $VERSION = '2.3.0';
use warnings;
use strict;
#use Data::Dumper;
use YAML::Tiny;
use File::Basename;
use Exporter;
our @ISA = qw( Exporter );
our @EXPORT = qw( $clientName $serialNumber $hostname
$transports $sysinfo3 $binDir $moduleDir
$scriptDir $confDir $binName $confName $configurationFile
@confFileSearchPath @moduleDirs @scriptDirs
%sendTypes
&showConf &transportsToConfig &getAnswer &yesno
&writeConfig &processParameters $TESTING
&setDryRun &enableModules &makeConfig &findConf &timeStamp
&loadConfigurationFile &logIt &findFile
);
our $TESTING = 0;
our $dryRun;
our $clientName = '';
our $serialNumber = '';
our $hostname = '';
# paths to search for configuration file
my @confFileSearchPath = ( '.', '/etc/camp/sysinfo-client', '/etc/camp', '/usr/local/etc/camp/sysinfo-client' );
my $configurationFile = 'sysinfo-client.yaml'; # name of the configuration file
my @installDirs = ( '/opt/camp/sysinfo-client', '/usr/local/opt/camp/sysinfo-client' );
my @confDirs = ( '/etc/camp/sysinfo-client', '/usr/local/etc/camp/sysinfo-client' );
our @moduleDirs = ( '/opt/camp/sysinfo-client/modules', '/etc/camp/sysinfo-client/modules' );
our @scriptDirs = ( '/opt/camp/sysinfo-client/scripts', '/etc/camp/sysinfo-client/scripts' );
our $transports = {}; # holds transportation mechanisms
our $sysinfo3 = 'sysinfo-client.yaml';
our $binDir = '/opt/camp/sysinfo-client';
our $moduleDir = $binDir . '/modules';
our $scriptDir = $binDir . '/scripts';
our $confDir = '/etc/camp/sysinfo-client';
our $binName = 'sysinfo-client';
our $confName = 'sysinfo-client.yaml';
sub setDryRun {
$dryRun = shift;
}
our %sendTypes = (
'SendEmail' => { 'sendScript' => 'sendEmailScript',
'keys' =>
[
'mailTo',
'mailSubject',
'mailCC',
'mailBCC',
'mailServer',
'mailFrom',
'logFile',
'otherCLParams',
'tls',
'smtpUser',
'smtpPass',
'sendEmailScriptLocation'
],
},
'HTTP Upload' => { 'sendScript' => 'upload_http',
'keys' =>
[
'URL',
'key for report',
'key for date',
'key for hostname',
'key for client',
'key for serial number'
]
},
'Save Local' => { 'sendScript' => 'save_local',
'keys' =>
[
'output directory'
]
}
);
#######################################################
#
# timeStamp
#
# return current system date as YYYY-MM-DD HH:MM:SS
#
#######################################################
sub timeStamp {
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);
return sprintf "%4d-%02d-%02d %02d:%02d:%02d",$year+1900,$mon+1,$mday,$hour,$min,$sec;
}
sub enableModules {
my $moduleDir = shift;
my %modules;
if ( opendir( my $dh, "$moduleDir" ) ) {
%modules = map{ $_ => { 'enabled' => -x "$moduleDir/$_" } }
grep { ! /^\./ }
readdir $dh;
closedir( $dh );
foreach my $filename ( keys %modules ) {
if ( open FILE,"<$moduleDir/$_" ) {
my @descript = grep{ /^# Description: (.*)/ } <FILE>;
close FILE;
chomp @descript;
$modules{$filename}{'description'} = $descript[0];
} # if
} # foreach
} # if
} # enableModules
sub showConf {
my $configuration = shift;
$configuration = Dump($configuration);
return $configuration;
}
sub transportsToConfig {
my $transports = shift;
my $config;
foreach my $priority ( sort { $a <=> $b } keys %$transports ) {
my $name = $$transports{ $priority }{'name'};
$config .= "# Tranport $name at priority $priority\n";
my $thisOne = $$transports{ $priority };
foreach my $key ( sort keys %$thisOne ) {
$config .= "\$\$transports{$priority}{'$key'} = '$$thisOne{$key}';\n";
} # foreach
} # foreach
return $config;
} # transportsToConfig
# read the configuration file passed in and return a reference to it
# to the calling routine
sub readConfig {
my $filename = shift;
my $config;
return $config unless -e $filename;
if ( open CONF,"<$filename" ) {
my $contents = join( '', <CONF> );
close CONF;
# now, look to see what kind of file this is.
if ( $contents =~ m/^---(\s*#.*)?$/m ) {
print "Reading $filename as YAML\n";
#print "Contents are:\n\n=====================$contents\n=====================\n";
# this is a yaml file
#$contents = YAML::Tiny->read( $config );
# try to load the contents into $config, and warn if there is a problem.
eval( $config = Load( $contents ) ); warn $@ if $@;
} elsif ( $contents =~ m/\$clientName/ ) {
# this is old style
print "Reading $filename as old school file\n";
my $clientName = '';
my $serialNumber = '';
my $hostname = '';
my @moduleDirs;
my @scriptDirs;
my $UUID = '';
my $transports;
# now, eval the information we just read.
# NOTE: we must turn off strict while doing this, and we die if something breaks.
no strict "vars";
eval( $contents );
use strict "vars";
die "Error during eval: $@\n" if $@;
$config->{'clientName'} = $clientName if $clientName;
$config->{'serialNumber'} = $serialNumber if $serialNumber;
$config->{'UUID'} = $UUID unless $config->{'UUID'};
$config->{'hostname'} = $hostname if $hostname;
$config->{'moduleDirs'} = [ @moduleDirs ] if @moduleDirs;
$config->{'scriptDirs'} = [ @scriptDirs ] if @scriptDirs;
$config->{'transports'} = $transports if $transports;
foreach my $trans ( keys %{$config->{'transports'}} ) {
if ( exists ( $config->{'transports'}->{$trans}->{'-name-'} ) ) {
$config->{'transports'}->{$trans}->{'name'} = $config->{'transports'}->{$trans}->{'-name-'};
delete( $config->{'transports'}->{$trans}->{'-name-'} );
}
}
}
} else {
warn "Could not read config file $filename, skipped: $!\n";
}
return $config;
}
sub makeConfig {
my @configFileNames = @_;
my %config;
foreach my $config ( @configFileNames ) {
my $thisConfig = &readConfig( $config ) if $config && -e $config;
# add the new config to %config, overwriting any existing keys which are duplicated
@config{keys %$thisConfig} = values %$thisConfig;
}
# now, ensure the correct values are loaded in some areas
unless ( $config{'hostname'} ) {
$hostname = `hostname -f`;
chomp $hostname;
$config{'hostname'} = $hostname;
}
unless ( $config{'serialNumber'} ) {
$serialNumber = `dmidecode -t 1 | grep 'Serial Number' | cut -d':' -f2` if `which dmidecode`;
chomp $serialNumber;
$serialNumber =~ s/\s//gi;
$config{'serialNumber'} = $serialNumber;
}
unless ( $config{'UUID'} ) {
my $UUID = `which dmidecode` ? `dmidecode -t 1 | grep -i uuid | cut -d':' -f2` : '';
$UUID =~ s/\s//gi;
$config{'UUID'} = $UUID;
}
# ensure we have the default SaveLocal transport defined
unless ( defined $config{'transports'}{'99'} ) {
$config{'transports'}{'99'} = {
'name'=> 'SaveLocal',
'output directory' => '/tmp',
'sendScript' => 'save_local'
};
}
return \%config;
}
# prompt the user for a response, then allow them to enter it
# the first response is considered the default and is printed
# in all caps if more than one exists
# first answer is used if they simply press the Enter
# key. The response is returned all lower case if more than one
# exists.
# it is assumed
sub getAnswer {
my ( $prompt, @answers ) = @_;
$answers[0] = '' unless defined( $answers[0] );
my $default = $answers[0];
my $onlyOneAnswer = scalar( @answers ) == 1;
print $prompt . '[ ';
$answers[0] = uc $answers[0] unless $onlyOneAnswer;
print join( ' | ', @answers ) . ' ]: ';
my $thisAnswer = <>;
chomp $thisAnswer;
$thisAnswer = $default unless $thisAnswer;
return $thisAnswer;
}
sub yesno {
my ( $prompt, $default ) = @_;
$default = 'yes' unless $default;
my $answer = &getAnswer( $prompt, $default eq 'yes' ? ('yes','no' ) : ('no', 'yes') );
return lc( substr( $answer, 0, 1 ) ) eq 'y';
}
sub writeConfig {
use File::Temp qw / tempfile /;
my ( $filename,$content ) = @_;
if ( $filename ) { # they sent us a filename
my $path;
($filename, $path ) = fileparse( $filename );
`mkdir -p $path` unless -d $path;
$filename = $path . '/' . $filename;
`cp $filename $filename.bak` if ( -e $filename );
unless ( $dryRun ) {
open CONF,">$filename" or die "Could not write to $filename: $!\n";
print CONF $content;
close CONF;
`chmod 600 $filename`;
}
} else { # no path provided, so just create a temp file
# we will create a temporary file and return the name
# it is the calling programs responsiblity to remove the file
my $fh;
($fh,$filename) = tempfile( UNLINK => 0 );
print $fh $content;
close $fh
}
return $filename;
}
sub processParameters {
while ( my $parameter = shift ) {
if ( $parameter eq '-v' ) {
print "$VERSION\n";
exit;
}
} # while
}
sub findConf {
my $confName = shift;
for ( my $i = 0; $i < @confDirs; $i++ ) {
if ( -d $confDirs[ $i ] ) {
return ( $confDirs[$i], $confName );
}
}
return ( '', $confName );
}
#######################################################
#
# findFile( $filename, @directories )
#
# Locates a file by searching sequentially in one or more
# directories, returning the first one found
#
# Returns '' if not found
#
#######################################################
sub findFile {
my ( $filename, $directories ) = @_;
&logIt( 3, "Looking for $filename in findFile" );
for ( my $i = 0; $i < scalar( @{$directories} ); $i++ ) {
my $confFile = $$directories[$i] . '/' . $filename;
&logIt( 4, "Looking for $filename in $confFile" );
return $confFile if ( -f $confFile );
}
return '';
}
#######################################################
#
# loadConfigurationFile($confFile)
#
# Loads configuration file defined by $configurationFile, and dies if not available
# This is a YAML file containing serialized contents of
# Parameters:
# $$fileName - name of file to look for (reference)
# @searchPath - array of paths to find $filename
#
#######################################################
sub loadConfigurationFile {
my ( $fileName, @searchPath ) = @_;
$$fileName = $configurationFile unless $$fileName;
@searchPath = @confFileSearchPath unless @searchPath;
&logIt( 2, "Looking for config file $$fileName in " . join( ', ', @searchPath ) );
my $confFile;
if ( $confFile = &findFile( $$fileName, \@searchPath ) ) {
&logIt( 3, "Opening configuration from $confFile" );
my $yaml = YAML::Tiny->read( $confFile );
&logIt( 4, "Configuration file contents\n$yaml" );
$$fileName = $confFile;
return $yaml->[0];
}
die "Can not find $fileName in any of " . join( "\n\t", @searchPath ) . "\n";
}
#######################################################
# function to simply log things
# first parameter is the priority, if <= $logDef->{'log level'} will print
# all subsequent parameters assumed to be strings to sent to the log
# returns 0 on failure
# 1 on success
# 2 if priority > log level
# -1 if $logDef is unset
# currently, only logs to a file
#######################################################
sub logIt {
my $priority = shift;
# turn off variable checking so it doesn't blow up on lack of %configuration file
no strict 'vars';
return -1 unless exists $configuration{'logging'};
return 2 unless $priority <= $configuration{'logging'}{'log level'};
if ( $configuration{'logging'}{'log type'} eq 'cache' ) {
push @{ $configuration{'logging'}{'cache'} }, @_;
return;
} elsif ( defined( $configuration{'logging'}{'cache'} ) ) {
unshift @_, @{ $configuration{'logging'}{'cache'} };
delete $configuration{'logging'}{'cache'};
}
if ( $configuration{'logging'}{'log type'} eq 'file' ) {
if ( open LOG, '>>' . $configuration{'logging'}{'log path'} ) {
while ( my $t = shift ) {
print LOG &timeStamp() . "\t$t\n";
}
close LOG;
}
} elsif ( $configuration{'logging'}{'log type'} eq 'syslog' ) {
use Sys::Syslog; # all except setlogsock()
use Sys::Syslog qw(:standard :macros); # standard functions & macros
my $syslogName = 'sysinfo-client';
my $logopt = 'nofatal';
my $facility = 'LOG_LOCAL0';
my $priority = 'LOG_NOTICE';
openlog( $syslogName, $logopt, $facility);
syslog($priority, '%s', @_ );
closelog();
} else {
warn "Log type $configuration{'logging'} incorrectly configured\n";
return 0;
}
return 1;
}
1;