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

+#
 # 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
+# adding logging with priority. logging is a hash inside of %configuration which contains the following
 # $configuration{ 'logging' } = {
 #    'log type'  => 'string',
 #    'log level' => #,
 #    'other params' => something,
 # };
+#
 # Version 3.7.2 20240601 RWR
 # Added code to undefine &doit if it is already defined, ie if one transport fails and we want to try another one,
 # we were getting a "can not redefine doit" and the transports would fail. The line added is
 # undef &doit if exists &doit;
+#
+# Version 4.0.0 20250331 RWR
+# Adding support for MS Windows
+# Removed requirement for modules to be executable
 # find our location and use it for searching for libraries
 BEGIN {
    use FindBin;
    use File::Spec;
 # contains the directory our script is in
 my $sourceDir = dirname( abs_path( __FILE__ ) );
 # define the version number
 # see https://metacpan.org/pod/release/JPEACOCK/version-0.97/lib/version.pod
-use version;
-our $VERSION = version->declare("v3.7.2");
+use version 0.77; our $VERSION = version->declare("v4.0.0");
-our $DATA_VERSION = version->declare( 'v3.7.0' ); # used in sending the data file. sets version of XML/YAML data file
+our $DATA_VERSION = version->declare( 'v3.7.2' ); # used in sending the data file. sets version of XML/YAML data file
 # see https://perldoc.perl.org/Getopt/Long.html
 use Getopt::Long;
 # allow -vvn (ie, --verbose --verbose --dryrun)
 Getopt::Long::Configure ("bundling");
 # would then be sent via e-mail to an administrative account, possibly root
+#
 #######################################################
 sub sendResults {
    my ( $globals, $transports, $message, $scriptDirectory ) = @_;
-   &logIt( 3, "Entering sendResults" );
+   &logIt( \%configuration,  3, "Entering sendResults" );
    foreach my $key ( sort { $a <=> $b } %$transports ) {
       if ( $transports->{$key}->{'sendScript'} ) {
-         &logIt( 3, "Trying to find file " . $transports->{$key}->{'sendScript'} . " in " . join( "\n\t", @{$scriptDirectory} ) );
+         &logIt( \%configuration,  3, "Trying to find file " . $transports->{$key}->{'sendScript'} . " in " . join( "\n\t", @{$scriptDirectory} ) );
          my $sendScript = &findFile( $transports->{$key}->{'sendScript'}, $scriptDirectory );
          if ( $sendScript ) {
             # check if we have doit defined from previous iteration and, if so, undefine it
             undef &doit if exists &doit;
             # load the chosen script into memory
             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}} ) {
-               &logIt( 4, "$thisOne" );
+               &logIt( \%configuration,  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
-            &logIt( 3, $message );
+            &logIt( \%configuration,  3, $message );
             my $return = &doit( $transports->{$key}, $message );
             return $return if ( $return == 1 );
          } else {
-            &logIt( 0,"Could not find " . $$transports[$key]{'sendScript'} . ", trying next transport" );
+            &logIt( \%configuration,  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" );
+   &logIt( \%configuration,  0, 'Error, reached ' . __LINE__ . " which should not happen, message was\n$message" );
    print $message;
    return 1;
+}
 #######################################################
+#
 # return hostname from hostname -f
+#
 #######################################################
 sub getHostName {
-   &logIt( 3, "Entering getHostName" );
+   &logIt( \%configuration,  3, "Entering getHostName" );
    my $hostname = lc $^O eq 'mswin32' ? `hostname` : `hostname -f`;
    chomp $hostname;
    return $hostname;
+}
+#
+#
 #######################################################
 sub tabDelimitedToHash {
    my ($hashRef, $tabdelim) = @_;
-   &logIt( 3, "Entering tabDelimitedToHash" );
+   &logIt( \%configuration,  3, "Entering tabDelimitedToHash" );
    utf8::encode( $tabdelim ); # ensure this is all utf8, convert if necessary
    foreach my $line ( split( "\n", $tabdelim ) ) { # split on newlines, then process each line in turn
       $line =~ s/'/\\'/gi; # escape single quotes
+#
 #######################################################
 sub validatePermission {
    my $file = shift;
+   # on Windows system, we can not look for ownership and exect status
+   return '' if lc $^O eq 'mswin32';
-   &logIt( 3, "Entering validatePermission with $file" );
+   &logIt( \%configuration,  3, "Entering validatePermission with $file" );
+   return "$file - Not a file" unless -f $file;
+   # in test mode, do not check permissions
+   return '' if $TESTING;
    my $return;
    # must be owned by root
    my $owner = (stat($file))[4];
+   # print "\tOwner = $owner\n";
    $return .= " - Bad Owner [$owner]" if $owner;
    # must not have any permissions for group or world
    # ie, 0700 or less
-   my $mode = (stat($file))[2];
+   my $mode = sprintf( '%04o', (stat($file))[2] & 07777 );
-   $mode = sprintf( '%04o', $mode & 07777 );
+   # print "\tMode = $mode\n";
    $return .= " - Bad Permission [$mode]" unless $mode =~ m/0.00/;
    return $return ? $file . $return : '';
+}
+sub getModulesFromDir {
+   my $moduleDir = shift;
+   $moduleDir .= '/' unless substr( $moduleDir, -1 ) eq '/';
+   # 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 nothing but alpha-numerics and underscores (must begin with alpha-numeric)
+   # ignore anything else, including directories
+   # then, prepend the directory name (map), then validate they are ready to be used (validatePermissions)
+   my @modules = grep{ ! &validatePermission( $_ ) } map { "$moduleDir$_" } grep { /^[a-zA-Z0-9][a-zA-Z0-9_]*$/ } readdir( $dh );
+   closedir $dh;
+   return \@modules;
+}
 #######################################################
+#
 # ProcessModules ( $system, $moduleDir )
+#
 # Processes all modules in $moduleDir, adding result to $system hash
 # 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" );
+   &logIt( \%configuration,  3, "Entering processModules" );
+   foreach my $modFile ( sort @{ &getModulesFromDir( $moduleDir ) } ) { # for each valid script
-   # open the module directory
+      next unless -f $modFile; # skip any directories, symbolic links, etc...
-   return unless -d $moduleDir;
+      my $output = do $modFile;
-   opendir( my $dh, $moduleDir ) || die "Module Directory $moduleDir can not be opened: $!\n";
+      &logIt( \%configuration, 4, "Output of module $modFile is\n$output\n" );
+      if ( defined $output && $output ) {
-   # and get all files which are executable and contain nothing but alpha-numerics and underscores (must begin with alpha-numeric)
+         if ( substr( $output, 1,6) eq 'error:' ) { # we have an error
-   my @modules = grep { /^[a-zA-Z0-9][a-zA-Z0-9_]+$/ && -x "$moduleDir/$_" } readdir( $dh );
+            &logIt( \%configuration,  1, $output );
-   closedir $dh;
+         } else {
-   foreach my $modFile ( sort @modules ) { # for each valid script
-      if ( my $error = &validatePermission( "$moduleDir$modFile" ) ) {
+            &tabDelimitedToHash( $system, $output );
-         print STDERR "Not Processed: $error\n";
+         }
-         next;
+      } else {
+         print "Script $modFile failed to compile with error\n$@\n";
+      }
-      &logIt( 3, "Processing module $moduleDir$modFile");
+      &logIt( \%configuration,  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
    &tabDelimitedToHash( $system, "software\tsysinfo-client\tversion\t$main::VERSION\n" );
+}
+}
 # simple display if --help is passed
 sub help {
    use File::Basename;
-   print basename($0) . " $VERSION\n";
+   print basename($0) . " $VERSION (data $DATA_VERSION)\n";
    print <<END
 $0 [options]
 Options:
    -i,
    --interactive    - do not read configuration file
    -m,
    --modules=/path/ - override path to modules
    --scripts=/path/ - override path to scripts
    -p,
    --periodic       - runs modules designed to be run only weekly, monthly, etc...
+   -t,
+   --test           - If non-zero, runs but places output in /tmp
 END
+}
 # handle any command line parameters that may have been passed in
             'test|t=s'      => \$TESTING
             ) or die "Error parsing command line\n";
 if ( $help ) { &help() ; exit; }
-if ( $version ) { use File::Basename; print basename($0) . " $VERSION\n"; exit; }
+if ( $version ) { use File::Basename; print basename($0) . " $VERSION (data $DATA_VERSION)\n"; exit; }
 if ( $interactive ) {
    %configuration = %{ &interactiveConfig( \%configuration ) };
 } else {
    # load the configuration file
 # 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( \%configuration,  0, 'Starting sysinfo Run' );
-&logIt( 3, "Configuration is\n" . Data::Dumper->Dump( [\%configuration], [ qw($configuration) ] ) );
+&logIt( \%configuration,  3, "Configuration is\n" . Data::Dumper->Dump( [\%configuration], [ qw($configuration) ] ) );
 $TESTING = $configuration{'TESTING'} if defined $configuration{'TESTING'};
-&logIt( 0, "Testing => $TESTING" ) if $TESTING;
+&logIt( \%configuration,  0, "Testing => $TESTING" ) if $TESTING;
 # hash reference that will store all info we are going to send to the server
 my $System = &initReport( \%configuration );
-&logIt( 3, "Initial System\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
+&logIt( \%configuration,  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" );
+   &logIt( \%configuration,  3, "Processing modules from $moduleDir" );
    &ProcessModules( $System, "$moduleDir/" );
+}
-&logIt( 4, "After processing modules\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
+&logIt( \%configuration,  4, "After processing modules\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
-my $out =  sprintf( "#sysinfo: %s YAML\n", $VERSION->normal ) . &Dump( $System );
+my $out =  sprintf( "#sysinfo: %s (data: %s) YAML\n", $VERSION, $DATA_VERSION ) . &Dump( $System );
-&logIt( 4, 'At line number ' . __LINE__ . "\n" . Data::Dumper->Dump([$System],[qw($System)]) );
+&logIt( \%configuration,  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 = {
       'upload_type'  => 'sysinfo',
       'data version' => $DATA_VERSION->normal,
       'host name'    => $configuration{'hostname'},
       'serial number'=> $configuration{'serialNumber'},
       'UUID'         => $configuration{'UUID'}
       };
-&logIt( 4, "Globals initialized\n" . Data::Dumper->Dump([$globals],[qw($globals)]) );
+&logIt( \%configuration,  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
    if ( my $success = &sendResults( $globals, $configuration{'transports'}, $out, $configuration{'scriptDirs'} ) != 1 ) {
-      &logIt( 0, "Error $success while sending report from $configuration{'hostname'}" );
+      &logIt( \%configuration,  0, "Error $success while sending report from $configuration{'hostname'}" );
+   }
+}
 unlink ( $periodicOverrideFile ) if -e $periodicOverrideFile;
-&logIt( 0, 'Ending sysinfo Run' );
+&logIt( \%configuration,  0, 'Ending sysinfo Run' );
 if ( $configuration{'postRunScript'}{'script name'} ) {
    my $script = $sourceDir . '/' . $configuration{'postRunScript'}{'script name'};
    exec ( "$script $configurationFile" ) if -x $script;
+}

Subversion Repositories camp_sysinfo_client_3

(root)/trunk/sysinfo-client – Rev 252 → 256