WebSVN – camp_sysinfo_client_3 – Diff – //trunk/sysinfo-client

 # Finally got a semi-stable version of this running. Fixed a bunch of bugs
 # and appears to be working correctly.
+#
 # Version 3.3.0 20190419 RWR
 # Converted to use YAML config file
+#
+# Version 3.4.0 20191111 RWR
+# adding logging with priority. logging is a hash inside of %cvonfiguration which contains the following
+# $configuration{ 'logging' } = {
+#    'log type'  => 'string',
+#    'log level' => #,
+#    'other params' => something,
+# };
+# Currently, the only log type is 'file', which has one other additional parameter, 'log path' which
+# points to the actual log to be created. The log is NOT limited in size, so use something else to
+# do that.
+# log level is an integer which is compared the a priority passed to the logging function. The
+# higher log level is set, the more verbose the log.
+# 0 - Normal, basically logs when the program starts and ends, and any warnings.
+# 1 - a little more information about flow
+# 2 - Gives ending information on structures
+# 3 - Gives a lot of info about structures when they are initialized and at the end
+# 4 - Crazy. Dumps just about every structure every time they are changed
+#
+# $TESTING has been set to a binary. If true, the report is not sent via the transports, but is dumped to /tmp/sysinfo.testing.yaml
 # find our location and use it for searching for libraries
 BEGIN {
    use FindBin;
    use File::Spec;
 use YAML::Tiny;
 # Following are global variables overridden if configuration file exists
-my $TESTING = 0; # level's 0 (none) to 4 defined and increase verbosity while decreasing functionality
+my $TESTING = 0; # if set to 1, will do everything, but will dump output to /tmp/sysinfo.testing.yaml
-our $VERSION = '3.3.0';
-my $indentLevel = 2; # number of spaces to indent per level in XML or YAML
+our $VERSION = '3.4.0';
-$indentLevel = 3 if $TESTING;
+my $indentLevel = 2; # number of spaces to indent per level in XML or YAML
-if ($TESTING) {
-   use Data::Dumper;
-}
 # 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 $reportDate = &getReportDate; # set report date
+my $reportDate = &timeStamp(); # set report date
 my %configuration = (
+   'logging' => [],    # if set, will point to logging
    'moduleDirs' => [], # search paths for modules
    'scriptDirs' => [], # search paths for scripts
    'clientName' => '',  # Required!! Must be set in conf file (no defaults)
    'serialNumber' => '', # serial number of machine
    'UUID'         => '', # UUID of machine
+;
 my $DATA_VERSION = '3.0.0'; # used in sending the data file. sets version of XML/YAML data file
+# function to simply 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;
+   return -1 unless exists $configuration{'logging'};
+   return 2 unless $priority <= $configuration{'logging'}{'log level'};
+   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;
+      }
+   } else {
+      warn "Log type $configuration{'logging'} incorrectly configured\n";
+      return 0;
+   }
+   return 1;
+}
 #######################################################
+#
 # findFile( $filename, @directories )
+#
 # Parameters: configuration file fully path/file name
 # NOTE: conf file must be a valid Perl file
+#
 #######################################################
 sub loadConfigurationFile {
    my ( $fileName, @searchPath ) = @_;
    my $confFile;
    if ( $confFile = &findFile( $fileName, \@searchPath ) ) {
-      print "Opening configuration from $confFile\n" if $TESTING > 2;
+      &logIt( 2, "Opening configuration from $confFile" );
       my $yaml = YAML::Tiny->read( $confFile );
+      &logIt( 4, "Opening configuration from $confFile" );
       return $yaml->[0];
+   }
    die "Can not find $fileName in any of " . join( "\n\t", @searchPath ) . "\n";
+}
 # would then be sent via e-mail to an administrative account, possibly root
+#
 #######################################################
 sub sendResults {
    my ( $globals, $transports, $message, $scriptDirectory ) = @_;
-#   die Dumper( $transports );
+   &logIt( 3, "Entering sendResults" );
    foreach my $key ( sort { $a <=> $b } %$transports ) {
       if ( $transports->{$key}->{'sendScript'} ) {
-         print "Trying to find file " . $transports->{$key}->{'sendScript'} . " in " . join( "\n\t", @{$scriptDirectory} ) . "\n" if $TESTING > 2;;
+         &logIt( 3, "Trying to find file " . $transports->{$key}->{'sendScript'} . " in " . join( "\n\t", @{$scriptDirectory} ) );
          my $sendScript = &findFile( $transports->{$key}->{'sendScript'}, $scriptDirectory );
          if ( $sendScript ) {
             # load the chosen script into memory
             require $sendScript;
             # merge the globals in
             while ( my ( $gkey, $value ) = each %$globals ) {
                $transports->{$key}->{$gkey} = $value;
+            }
             # do variable substitution for any values which need it
             foreach my $thisOne ( keys %{$transports->{$key}} ) {
-               print "$thisOne\n" if $TESTING > 3;
+               &logIt( 4, "$thisOne" );
                if ( $transports->{$key}->{$thisOne} =~ m/(\$configuration\{'hostname'\})|(\$reportDate)|(\$configuration\{'clientName'\})|(\$configuration\{'serialNumber'\})/ ) {
                   $transports->{$key}->{$thisOne} = eval "\"$transports->{$key}->{$thisOne}\"";
+               }
+            }
             #%$transports{$key}{keys %$globals} = values %$globals;
             #print Dumper( $$transports[$key] );
             #next;
             # execute the "doit" sub from that script
-            if ( $TESTING > 3 ) {
-               print $message;
+            &logIt( 3, $message );
-            } else {
-               my $return = &doit( $transports->{$key}, $message );
+            my $return = &doit( $transports->{$key}, $message );
-               return $return if ( $return == 1 );
+            return $return if ( $return == 1 );
-            }
          } else {
-            print "Could not find " . $$transports[$key]{'sendScript'} . ", trying next transport\n";
+            &logIt( 0,"Could not find " . $$transports[$key]{'sendScript'} . ", trying next transport" );
          } # if..else
       } # if
    } # foreach
    # if we made it here, we have not sent the report, so just return it to the user
    # if called from a cron job, it will (hopefully) be sent to root
+   &logIt( 0, 'Error, reached ' . __LINE__ . " which should not happen, message was\n$message" );
    print $message;
    return 1;
+}
 #######################################################
+#
-# getReportDate
-#
-# return current system date as YYYY-MM-DD HH:MM:SS
-#
-#######################################################
-sub getReportDate {
-   my ($second, $minute, $hour, $dayOfMonth, $month, $year) = localtime();
-   return sprintf( "%4u-%02u-%02u %02u:%02u:%02u", $year+1900, $month+1, $dayOfMonth, $hour, $minute, $second );
-}
-#######################################################
-#
 # getHostName
+#
 # return hostname from hostname -f
+#
 #######################################################
 sub getHostName {
+   &logIt( 3, "Entering getHostName" );
    my $hostname = `hostname -f`;
    chomp $hostname;
    return $hostname;
+}
+#
+#
 #######################################################
 sub tabDelimitedToHash {
    my ($hashRef, $tabdelim) = @_;
+   &logIt( 3, "Entering tabDelimitedToHash" );
    foreach my $line ( split( "\n", $tabdelim ) ) { # split on newlines, then process each line in turn
       $line =~ s/'/\\'/gi; # escape single quotes
       my @fields = split( / *\t */, $line ); # get all the field values into array
       my $theValue = pop @fields; # the last one is the value, so save it
       # now, we build a Perl statement that would create the assignment. The goal is
+#
 #######################################################
 sub validatePermission {
    my $file = shift;
+   &logIt( 3, "Entering validatePermission with $file" );
    my $return;
    # must be owned by root
    my $owner = (stat($file))[4];
    $return .= " - Bad Owner [$owner]" if $owner;
    # must not have any permissions for group or world
 # on failure, the returned output of the script is assumed to be an error message
 # and is displayed on STDERR
 #######################################################
 sub ProcessModules {
    my ( $system, $moduleDir ) = @_;
+   &logIt( 3, "Entering processModules" );
    # open the module directory
    return unless -d $moduleDir;
    opendir( my $dh, $moduleDir ) || die "Module Directory $moduleDir can not be opened: $!\n";
    # and get all files which are executable and contain nothing but alpha-numerics and underscores (must begin with alpha-numeric)
    my @modules = grep { /^[a-zA-Z0-9][a-zA-Z0-9_]+$/ && -x "$moduleDir/$_" } readdir( $dh );
    foreach my $modFile ( sort @modules ) { # for each valid script
       if ( my $error = &validatePermission( "$moduleDir$modFile" ) ) {
          print STDERR "Not Processed: $error\n";
          next;
+      }
-      print "Processing module $moduleDir$modFile\n" if $TESTING > 2;
+      &logIt( 3, "Processing module $moduleDir$modFile");
       my $output = qx/$moduleDir$modFile $moduleDir/; # execute it and grab the output
       my $exitCode = $? >> 8; # process the exitCode
       # exitCode 0 - processed normally
       # exitCode 1 - not applicable to this machine
       if ( $exitCode && $exitCode > 1) { # if non-zero, error, so show an error message
          warn "Error in $moduleDir$modFile, [$output]\n";
+         &logIt( 0, "Error in $moduleDir$modFile, [$output]" );
       } else { # otherwise, call tabDelimitedToHash to save the data
          &tabDelimitedToHash( $system, $output );
       } # if
    } # foreach
    # add sysinfo-client (me) to the software list, since we're obviously installed
+}
 &processParameters( @ARGV );
 # load the configuration file
-#die "Searching for $configurationFile in = \n" . join( "\n", @confFileSearchPath ) . "\n";
 %configuration = %{ &loadConfigurationFile( $configurationFile, @confFileSearchPath) };
-#eval ( &loadConfigurationFile( $configurationFile, @confFileSearchPath) ) or die "Could not load config: $@\n";
-die Dumper( \%configuration ) . "\n" if $TESTING > 4;
 # user did not define a serial number, so make something up
 $configuration{'serialNumber'} = '' unless $configuration{'serialNumber'};
 # oops, no client name (required) so tell them and exit
 die "No client name defined in $configurationFile" unless $configuration{'clientName'};
+&logIt( 0, 'Starting sysinfo Run' );
+&logIt( 3, "Configuration is\n" . Data::Dumper->Dump( [\%configuration], [ qw($configuration) ] ) );
 $TESTING = $configuration{'TESTING'} if defined $configuration{'TESTING'};
-print "Testing => $TESTING\n" if $TESTING;
+&logIt( 0, "Testing => $TESTING" ) if $TESTING;
 my $System; # hash reference that will store all info we are going to send to the server
 # some defaults.
-$$System{'report'}{'version'} = $DATA_VERSION;
+$System->{'report'}->{'version'} = $DATA_VERSION;
-$$System{'report'}{'date'} = $reportDate;
+$System->{'report'}->{'date'} = $reportDate;
-$$System{'report'}{'client'} = $configuration{'clientName'};
+$System->{'report'}->{'client'} = $configuration{'clientName'};
-$$System{'system'}{'hostname'} = $configuration{'hostname'};
+$System->{'system'}->{'hostname'} = $configuration{'hostname'};
-$$System{'system'}{'serial'} = $configuration{'serialNumber'};
+$System->{'system'}->{'serial'} = $configuration{'serialNumber'};
-$$System{'system'}{'UUID'} = $configuration{'UUID'};
+$System->{'system'}->{'UUID'} = $configuration{'UUID'};
+&logIt( 3, "Initial System\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
 # process any modules in the system
 foreach my $moduleDir ( @{$configuration{'moduleDirs'}} ) {
+   &logIt( 3, "Processing modules from $moduleDir" );
    &ProcessModules( $System, "$moduleDir/" );
+}
+&logIt( 4, "After processing modules\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
 # now, everything ins in $System, so convert it to the proper output format
 #my $out = "#sysinfo: $VERSION YAML\n---\n" . &hashToYAML( $System ) . "...\n";
 my $out =  "#sysinfo: $VERSION YAML\n" . Dump( $System );
-#print Data::Dumper->Dump([$System],['System']) if $TESTING>2;
+&logIt( 4, 'At line number ' . __LINE__ . "\n" . Data::Dumper->Dump([$System],[qw($System)]) );
 # load some global values for use in the script, if required
 my $globals = {
       'data version' => $DATA_VERSION,
       'report date'  => $reportDate,
       'host name'    => $configuration{'hostname'},
       'serial number'=> $configuration{'serialNumber'},
       'UUID'         => $configuration{'UUID'}
       };
+&logIt( 4, "Globals initialized\n" . Data::Dumper->Dump([$globals],[qw($globals)]) );
+if ( $TESTING ) {
+   open DATA, ">/tmp/sysinfo.testing.yaml" or die "Could not write to /tmp/sysinfo.testing.yaml: $!\n";
+   print DATA $out;
+   close DATA;
+} else {
-# and send the results to the server
+   # and send the results to the server
-if ( my $success = &sendResults( $globals, $configuration{'transports'}, $out, $configuration{'scriptDirs'} ) != 1 ) {
+   if ( my $success = &sendResults( $globals, $configuration{'transports'}, $out, $configuration{'scriptDirs'} ) != 1 ) {
-   print "Error $success while sending report from $configuration{'hostname'}\n";
+      &logIt( 0, "Error $success while sending report from $configuration{'hostname'}" );
+   }
+}
+&logIt( 0, 'Ending sysinfo Run' );
 ;

Subversion Repositories camp_sysinfo_client_3

(root)//trunk/sysinfo-client – Rev 113 → 135