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

 #! /usr/bin/env perl
+# Copyright (c) 2025, R. W. Rodolico
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 use warnings;
 use strict;
 use open ':std', ':encoding(utf8)' ; # force all I/O, including disk and STD?, to use utf-8
 use utf8;                            # Source code encoded using UTF-8, used to ensure output from modules is UTF-8, see tabDelimitedToHash
 # On freeBSD systems, was looking in wrong place for configuration file
+#
 # Version 3.2.0 20180320 RWR
 # Major change in the configuration file format; All entries are loaded into
 # hash %configuration, so clientname is no longer $clientname, but is now
-# $configuration{'clientname'}
+# $config{'clientname'}
 # NOT backwards compatible
 # changed configuration to be loaded into hash (vs directly loaded into variables)
 # added UUID to configuration file
+#
 # Version 3.2.1 20180424 RWR
 # 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 %configuration which contains the following
-# $configuration{ 'logging' } = {
+# $config{ 'logging' } = {
 #    'log type'  => 'string',
 #    'log level' => #,
 #    'other params' => something,
 # };
+#
 # 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 0.77;
-use version 0.77; our $VERSION = version->declare("v4.0.0");
+our $VERSION = version->declare("v4.0.0");
 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)
 my $indentLevel = 2; # number of spaces to indent per level in XML or YAML
 my $reportDate = &timeStamp(); # set report date
-my $interactive = 0; # if set to 1, will go into interactive mode and output to local file
 my $periodicOverrideFile = '/tmp/sysinfo.firstrun'; # if this file exists, library.pm will tell all periodic modules to run anyway
 my $periodic = 0; # if set to 1, will do modules which are only supposed to run weekly, monthly, etc...
 my $version;
 my $help;
+my $configFile; # optional path to configuration file specified via command line
+my $configType; # optional config file type: yaml, json, or datatransport
+my $outputType; # optional output type: yaml, json, datatransport
-my %configuration = (
+my $config = {
    'logging' => { 'log type' => 'cache', 'log level' => 0 },    # if set, will point to logging
    'moduleDirs' => ["$sourceDir/modules"], # search paths for modules
    'scriptDirs' => ["$sourceDir/scripts"], # search paths for scripts
    'clientName' => '',  # Required!! Must be set in conf file (no defaults)
    'serialNumber' => '', # serial number of machine
    'UUID'         => '', # UUID of machine
    'transports'   => {'3' => { '-name-' => 'saveLocal', 'sendScript' => 'save_local', 'output directory' => "$sourceDir/reports" }  }, # hash with various transports
    'hostname' => &getHostName() # fully qualified host name of machine
-);
+};
 #######################################################
+#
 # would then be sent via e-mail to an administrative account, possibly root
+#
 #######################################################
 sub sendResults {
    my ( $globals, $transports, $message, $scriptDirectory ) = @_;
-   &logIt( \%configuration,  3, "Entering sendResults" );
+   &logIt( $config,  3, "Entering sendResults" );
    foreach my $key ( sort { $a <=> $b } %$transports ) {
       if ( $transports->{$key}->{'sendScript'} ) {
-         &logIt( \%configuration,  3, "Trying to find file " . $transports->{$key}->{'sendScript'} . " in " . join( "\n\t", @{$scriptDirectory} ) );
+         &logIt( $config,  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( \%configuration,  4, "$thisOne" );
+               &logIt( $config,  4, "$thisOne" );
-               if ( $transports->{$key}->{$thisOne} =~ m/(\$configuration\{'hostname'\})|(\$reportDate)|(\$configuration\{'clientName'\})|(\$configuration\{'serialNumber'\})/ ) {
+               if ( $transports->{$key}->{$thisOne} =~ m/(\$config\{'hostname'\})|(\$reportDate)|(\$config\{'clientName'\})|(\$config\{'serialNumber'\})/ ) {
                   $transports->{$key}->{$thisOne} = eval "\"$transports->{$key}->{$thisOne}\"";
+               }
+            }
+            # add all global keys/values into transport hash
-            #%$transports{$key}{keys %$globals} = values %$globals;
+            $transports->{$key}->{keys %$globals} = values %$globals;
             #print Dumper( $$transports[$key] );
             #next;
             # execute the "doit" sub from that script
-            &logIt( \%configuration,  3, $message );
+            &logIt( $config,  3, $message );
             my $return = &doit( $transports->{$key}, $message );
             return $return if ( $return == 1 );
          } else {
-            &logIt( \%configuration,  0,"Could not find " . $$transports[$key]{'sendScript'} . ", trying next transport" );
+            &logIt( $config,  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( \%configuration,  0, 'Error, reached ' . __LINE__ . " which should not happen, message was\n$message" );
+   &logIt( $config,  0, 'Error, reached ' . __LINE__ . " which should not happen, message was\n$message" );
    print $message;
    return 1;
+}
 #######################################################
+#
 # return hostname from hostname -f
+#
 #######################################################
 sub getHostName {
-   &logIt( \%configuration,  3, "Entering getHostName" );
+   &logIt( $config,  3, "Entering getHostName" );
    my $hostname = lc $^O eq 'mswin32' ? `hostname` : `hostname -f`;
    chomp $hostname;
    return $hostname;
+}
 #######################################################
+#
-# escapeForYAML
-#
-# Escapes values put into YAML report
+# validatePermission ( $file )
+#
+# Checks that file is owned by root, and has permission
+# 0700 or less
+#
-# DEPRECATED AS OF VERSION 3.3.0
+# Returns empty string on success, error message
-# uses YAML::Tiny
+# on failure
+#
 #######################################################
-#sub escapeForYAML {
-#   my $value = shift;
-#   $value =~ s/'/\\'/gi; # escape single quotes
-#   $value =~ s/"/\\"/gi; # escape double quotes
-#   # pound sign indicates start of a comment and thus loses part
-#   # of strings. Surrounding it by double quotes in next statement
-#   # allows
-#   $value = '"' . $value . '"' if ( $value =~ m/[#:]/ );
-#   return $value;
-#}
-#######################################################
-#
-# hashToYAML( $hashRef, $indent )
-#
-# Converts a hash to a YAML string
-#
-# NOTE: This routine recursively calls itself for every level
-#       in the hash
-#
-# Parameters
-#     $hashref - reference (address) of a hash
-#     $indent  - current indent level, defaults to 0
-#
-# Even though there are some very good libraries that do this
-# I chose to hand-code it so sysinfo can be run with no libraries
-# loaded. I chose to NOT do a full implementation, so special chars
-# that would normally be escaped are not in here.
-# However, I followed all the RFC for the values that were given, so
-# assume any YAML reader can parse this
-# NOTE: YAML appears to give a resulting file 1/3 smaller than the above
-#       XML, and compresses down in like manner
-#
-# DEPRECATED AS OF VERSION 3.3.0
-# uses YAML::Tiny
-#
-#######################################################
-#sub hashToYAML {
-#   my ($hashRef, $indent) = @_;
-#   $indent = 0 unless $indent; # default to 0 if not defined
-#
-#   my $output; # where the output is stored
-#   foreach my $key ( keys %$hashRef ) { # for each key in the current reference
-#      print "Looking at $key\n" if $TESTING > 3;
-#      # see http://www.perlmonks.org/?node_id=175651 for isa function
-#      if ( UNIVERSAL::isa( $$hashRef{$key}, 'HASH' ) ) { # is the value another hash?
-#            # NOTE: unlike xml, indentation is NOT optional in YAML, so the following line verifies $indentlevel is non-zero
-#            #       and, if it is, uses a default 3 character indentation
-#            $output .= (' ' x $indent ) . &escapeForYAML($key) . ":\n" . # key, plus colon, plus newline
-#                    &hashToYAML( $$hashRef{$key}, $indent+($indentLevel ? $indentLevel : 3) ) . # add results of recursive call
-#                    "\n";
-#      } elsif ( UNIVERSAL::isa( $$hashRef{$key}, 'ARRAY' ) ) { # is it an array? ignore it
-#      } else { # it is a scalar, so just do <key>value</key>
-#         $output .= (' ' x $indent ) . &escapeForYAML($key) . ': ' . &escapeForYAML($$hashRef{$key}) . "\n";
-#      }
-#   }
-#   return $output;
-#}
+sub validatePermission {
+   my $file = shift;
+   # on Windows system, we can not look for ownership and exect status
+   return '' if lc $^O eq 'mswin32';
+   &logIt( $config,  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 = sprintf( '%04o', (stat($file))[2] & 07777 );
+   # print "\tMode = $mode\n";
+   $return .= " - Bad Permission [$mode]" unless $mode =~ m/0.00/;
+   &logIt( $config, 4, "validatePermission: $file permissions check result: " . ($return ? $return : "OK") );
+   return $return ? $file . $return : '';
+}
 #######################################################
+#
 # tabDelimitedToHash ($hashRef, $tabdelim)
+#
+#
+#
 #######################################################
 sub tabDelimitedToHash {
    my ($hashRef, $tabdelim) = @_;
-   &logIt( \%configuration,  3, "Entering tabDelimitedToHash" );
+   &logIt( $config, 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
       #print STDERR "$command\n";
       eval $command; # eval the string to make the actual assignment
+   }
+}
 #######################################################
+#
-# validatePermission ( $file )
+# getModulesFromDir( $moduleDir )
+#
-# Checks that file is owned by root, and has permission
+# Retrieves a list of valid module files from the specified
+# module directory
+#
-# 0700 or less
+# Parameters
+#     $moduleDir - full path to directory containing modules
 #
+# Returns
-# Returns empty string on success, error message
+#     Reference to an array of valid module file paths
+#
-# on failure
+# Module files must:
+#   - Have names consisting only of alphanumerics and underscores
+#   - Begin with an alphanumeric character
+#   - Pass permission validation (owned by root, 0700 or less)
+#
 #######################################################
-sub validatePermission {
-   my $file = shift;
-   # on Windows system, we can not look for ownership and exect status
-   return '' if lc $^O eq 'mswin32';
-   &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 = sprintf( '%04o', (stat($file))[2] & 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;
    # 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;
+   &logIt( $config, 4, "getModulesFromDir: Modules found in $moduleDir: " . join(", ", @modules) );
    return \@modules;
+}
 #######################################################
 # 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( \%configuration,  3, "Entering processModules" );
+   &logIt( $config,  3, "Entering processModules using $moduleDir" );
    foreach my $modFile ( sort @{ &getModulesFromDir( $moduleDir ) } ) { # for each valid script
       next unless -f $modFile; # skip any directories, symbolic links, etc...
       my $output = do $modFile;
-      &logIt( \%configuration, 4, "Output of module $modFile is\n$output\n" );
+      &logIt( $config, 4, "Output of module $modFile is\n$output\n" );
       if ( defined $output && $output ) {
          if ( substr( $output, 1,6) eq 'error:' ) { # we have an error
-            &logIt( \%configuration,  1, $output );
+            &logIt( $config,  1, $output );
          } else {
             &tabDelimitedToHash( $system, $output );
+         }
       } else {
          print "Script $modFile failed to compile with error\n$@\n";
+      }
-      &logIt( \%configuration,  3, "Processing module $moduleDir$modFile");
+      &logIt( $config,  3, "Processing module $moduleDir$modFile");
    } # foreach
    # add sysinfo-client (me) to the software list, since we're obviously installed
    &tabDelimitedToHash( $system, "software\tsysinfo-client\tversion\t$main::VERSION\n" );
+}
-sub getDMIDecode {
-   my ( $key, $type ) = @_;
-   my $command = 'dmidecode ';
-   $command .= "-t $type " if $type;
+#######################################################
-   $command .= " | grep -i '$key'";
-   my $value = `$command`;
+# initReport( $config )
-   chomp $value;
-   if ( $value =~ m/:\s*(.*)\s*$/ ) {
-      return $1;
-   } else {
-      return '';
-   }
-}
+#
+# Initialize the report structure with configuration data
+#
-sub interactiveConfig {
+# Parameters
-   my $config = shift;
-   $config->{'moduleDirs'} = $config->{'moduleDirs'}[0];
-   $config->{'scriptDirs'} = $config->{'scriptDirs'}[0];
+#     $config - reference to configuration hash
-   $config->{'UUID'} = getDMIDecode( 'uuid', 'system' ) unless $config->{'UUID'};
-   $config->{'serialNumber'} = getDMIDecode( 'serial number', 'system' ) unless $config->{'serialNumber'};
+#
-   my %menu = (
+# Returns
-=> {'prompt' => 'Host Name', 'key' => 'hostname' },
-=> {'prompt' => 'Client Name', 'key' => 'clientName' },
-=> {'prompt' => 'Serial Number', 'key' => 'serialNumber' },
-=> {'prompt' => 'UUID', 'key' => 'UUID' },
+#     Reference to initialized report hash
-=> {'prompt' => 'Modules Directory', 'key' => 'moduleDirs' },
-=> {'prompt' => 'Scripts Directory', 'key' => 'scriptDirs' }
-   );
+#
-   my $choice = 'quit';
-   while ( $choice ) {
-      foreach my $menuItem ( sort keys %menu ) {
+# Creates the initial report structure with:
-         print "$menuItem\. " . $menu{$menuItem}{'prompt'} . ': ' . $config->{$menu{$menuItem}{'key'}} . "\n";
-      }
-      print "Enter Menu Item to change, or press Enter to proceed ";
+#   - Report metadata (version, date, client)
-      $choice = <>;
-      chomp $choice;
-      last unless $choice;
-      print $menu{$choice}{'prompt'} . ' [' . $config->{$menu{$choice}{'key'}} . '] : ';
-      my $value = <>;
-      chomp $value;
-      $config->{$menu{$choice}{'key'}} = $value if ($value);
+#   - System information (hostname, serial, UUID)
-   }
-   $config->{'moduleDirs'} = [ $config->{'moduleDirs'} ];
+#   - Additional configuration values (excluding moduleDirs,
-   $config->{'scriptDirs'} = [ $config->{'scriptDirs'} ];
+#     transports, scriptDirs, and logging)
-   return $config;
-}
+#
-# Initialize the report with some stuff from the program itself and the configuration file
+#######################################################
 sub initReport {
    my $config = shift;
    my %ignore = ( # list of config keys to ignore. Using hash for fast lookup
          'moduleDirs' => 1,
          'transports' => 1,
       $report->{'system'}->{$key} = $config->{$key}; # simply copy to the system part of the report
+   }
    return $report;
+}
+#######################################################
+#
+# detectConfigType( $filename )
+#
+# Detects the configuration file type by examining content
+# json and DataTransport have unique starting lines
+# yaml will usually start with --- or key: value, but may be
+# comments in the first few lines, so checks up to 5 lines
+#
+# Parameters:
+#   $lines - array reference containing lines of configuration content
+#
+# Returns:
+#   'yaml', 'json', 'datatransport', or undef
+#
+#######################################################
+sub detectConfigType {
+   my $lines = shift;
+   # first look at first line for unique identifiers. First line comments
+   # may contain type info
+   if ( $lines->[0] =~ m/^.*(yaml|datatransport).*/i ) {
+      &logIt( $config,  3, "Configuration file type hint found in first line comment" );
+      return lc $1;
+   }
+   # look through first five lines, there should be some indicator
+   for ( my $line = 0; $line < 5 && $lines->[$line]; $line++ ) {
+      return 'yaml' if $lines->[$line] =~ /^#.*YAML/;
+      return 'yaml' if $lines->[$line] =~ /^---/;  # YAML document start
+      return 'yaml' if $lines->[$line] =~ /^\s*\w+:\s*/;  # YAML key: value
+      return 'json' if $lines->[$line] =~ /^#.*JSON/;  # skip comments
+      return 'json' if $lines->[$line] =~ /^\s*[{\[]/;  # JSON starts with { or [
+   }
+   return undef;
+}
+#######################################################
+#
+# loadConfig( $confStr, $type )
+#
+# Load configuration file based on specified or detected type
+# adds 'dataType' key to returned hashref indicating type used
+#
+# Parameters:
+#   $confStr - configuration content as an arrayref of string
+#   $type     - optional type: 'yaml', 'json', 'datatransport'
+#
+# Returns:
+#   hashref of configuration
+#
+#######################################################
+sub loadConfig {
+   my ($confStr, $type) = @_;
+   my $return = {};
-# simple display if --help is passed
+   # Auto-detect if type not specified
+   $type = &detectConfigType($confStr) unless $type;
+   die "Cannot determine configuration file type\n" unless $type;
+   $type = lc($type);  # normalize to lowercase
+   $confStr = join("\n", @$confStr); # join arrayref into single string for processing
+   if ($type eq 'datatransport') {
+      # Try to load DataTransport module
+      eval { require DataTransport; };
+      if ($@) {
+         die "DataTransport module not available: $@\n";
+      }
+      my $dt = DataTransport->new();
+      $return = $dt->decode($confStr);
+      die "Failed to read DataTransport content\n" unless $return;
+   } elsif ($type eq 'json') {
+      # Try to load JSON module
+      eval { require JSON; };
+      if ($@) {
+         die "JSON module not available: $@\n";
+      }
+      $return = JSON::decode_json($confStr);
+   } elsif ($type eq 'yaml') {
+      # Use YAML::Tiny directly for single file loading
+      eval { require YAML::Tiny; };
+      if ($@) {
+         die "YAML::Tiny module not available: $@\n";
+      }
+      $return = YAML::Tiny->read_string($confStr);
+      die "Failed to read YAML content\n" unless $return;
+      $return = $return->[0]; # only return the first document
+   } else {
+      die "Unknown configuration type: $type\n";
+   }
+   $return->{'dataType'} = $type; # store the type used
+   return $return;
+}
+########################################################
+# hashToReportString( $report, $outputType )
+#
+# Converts report hash to specified output format string
+## Parameters:
+#   $report - reference to report hash
+#   $outputType - output format: 'yaml', 'json', 'datatransport'
+# Returns:
+#   string containing report in specified format
+########################################################
+sub hashToReportString {
+   my ( $report, $outputType ) = @_;
+   &logIt( $config,  3, "Entering hashToReportString with outputType $outputType" );
+   my $output;
+   if ( $outputType eq 'yaml' ) {
+      eval { require YAML::Tiny; };
+      if ($@) {
+         die "YAML::Tiny module not available: $@\n";
+      }
+      $output = YAML::Tiny->new( $report )->write_string();
+   } elsif ( $outputType eq 'json' ) {
+      eval { require JSON; };
+      if ($@) {
+         die "JSON module not available: $@\n";
+      }
+      $output = JSON::encode_json( $report );
+   } elsif ( $outputType eq 'datatransport' ) {
+      eval { require DataTransport; };
+      if ($@) {
+         die "DataTransport module not available: $@\n";
+      }
+      my $dt = DataTransport->new();
+      $output = $dt->encode( $report );
+   } else {
+      die "Unknown output type: $outputType\n";
+   }
+   return $output;
+}
+#######################################################
+#
+# help()
+#
+# Display help message showing command-line options
+#
+# Parameters
+#     None
+#
+# Returns
+#     None (prints to STDOUT)
+#
+# Shows program version and available command-line options:
+#   -f, --config       : Specify configuration file path
+#   --configtype       : Specify config format (yaml/json/datatransport)
+#   --version          : Display version
+#   --help             : Display help message
+#   -p, --periodic     : Run periodic modules
+#   -t, --test         : Test mode (output to /tmp)
+#
+# Note: For interactive configuration, use sysinfo-client-interactive
+#
+#######################################################
 sub help {
    use File::Basename;
    print basename($0) . " $VERSION (data $DATA_VERSION)\n";
    print <<END
 $0 [options]
+For interactive configuration, use sysinfo-client-interactive instead.
 Options:
-   -i,
-   --interactive    - do not read configuration file
    --version        - display version and exit
-   -c,
-   --client='xxx'   - Client name for interactive mode
+   --help           - display this help message
-   -s,
+   -f,
-   --serial='xxx'   - Serial Number for interactive mode
-   -h,
-   --hostname='xxx' - override hostname
-   -m,
-   --modules=/path/ - override path to modules
+   --config=/path/  - path to configuration file (overrides default search)
-   --scripts=/path/ - override path to scripts
+   --configtype=xxx - config file type: yaml, json, or datatransport (autodetects if not specified)
    -p,
    --periodic       - runs modules designed to be run only weekly, monthly, etc...
    -t,
-   --test           - If non-zero, runs but places output in /tmp
+   --test           - If set, runs but places output in /tmp
 END
+}
-# handle any command line parameters that may have been passed in
+# Process command line options
 GetOptions (
-            'interactive|i' => \$interactive, # ask questions instead of using config file
             'periodic|p'    => \$periodic,    # will do modules which are marked as periodic
+            'config|f=s'    => \$configFile,  # path to configuration file
+            'configtype=s'  => \$configType,  # config file type: yaml, json, datatransport
+            'outputType|o=s' => \$outputType,  # output type: xml, yaml
-            'help|h'        => \$help,
+            'help'          => \$help,
             'version'       => \$version,
-            'client|c=s'    => \$configuration{clientName},
-            'serial|s=s'    => \$configuration{serialNumber},
-            'hostname=s'    => \$configuration{hostname},
-            'modules|m=s'   => \$configuration{moduleDirs},
-            'scripts=s'     => \$configuration{scriptDirs},
-            'test|t=s'      => \$TESTING
+            'test|t'      => \$TESTING
             ) or die "Error parsing command line\n";
 if ( $help ) { &help() ; 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
+# if periodic flag set, create the override file
-   %configuration = %{ &loadConfigurationFile( \$configurationFile, @confFileSearchPath) };
-}
 `touch $periodicOverrideFile` if $periodic; # tells periodic modules to run
-#die Dumper (\%configuration );
+$configFile //= 'sysinfo-client.yaml'; # default configuration file name
+# load the configuration file. Note, loadConfigurationFile returns an arrayref of lines
-# user did not define a serial number, so make something up
+# then loadConfig processes that based on type
-$configuration{'serialNumber'} = '' unless $configuration{'serialNumber'};
+$config = loadConfig( loadConfigurationFile( $configFile ), $configType);
 # oops, no client name (required) so tell them and exit
-die "No client name defined in $configurationFile" unless $configuration{'clientName'};
+die "No client name defined in $configFile" unless $config->{'clientName'};
-&logIt( \%configuration,  0, 'Starting sysinfo Run' );
+# clean up some missing values
-&logIt( \%configuration,  3, "Configuration is\n" . Data::Dumper->Dump( [\%configuration], [ qw($configuration) ] ) );
+# output type is either what user passed on command line, or what is in config file, or defaults to yaml
+# the config->{'dataType'} is set by loadConfig, so we can use that as last resort
+$config->{'outputType'} //= $outputType //= $config->{'dataType'} //= 'yaml'; # default to yaml output
+# user did not define a serial number, so make something up. Just take an md5sum of hostname-clientname
+$config->{'serialNumber'} //= $config->{UUID} ? $config->{UUID} : `echo \`$config->{'hostname'}\`-$config->{'clientName'} | md5sum | awk '{print \$1}'`;
+chomp $config->{'serialNumber'};
+&logIt( $config,  0, 'Starting sysinfo Run' );
-$TESTING = $configuration{'TESTING'} if defined $configuration{'TESTING'};
+&logIt( $config,  3, "Configuration is\n" . Data::Dumper->Dump( [$config], [ qw($config) ] ) );
+$TESTING //= $config->{'TESTING'} //= 0; # default to 0 if not defined
-&logIt( \%configuration,  0, "Testing => $TESTING" ) if $TESTING;
+&logIt( $config,  0, "Testing => $TESTING" ) if $TESTING;
 # hash reference that will store all info we are going to send to the server
+# initialize it with some basic info from configuration file
-my $System = &initReport( \%configuration );
+my $report = &initReport( $config );
-&logIt( \%configuration,  3, "Initial System\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
+&logIt( $config,  3, "Initial System\n" . Data::Dumper->Dump( [$report], [qw( $report )] ) );
 # process any modules in the system
-foreach my $moduleDir ( @{$configuration{'moduleDirs'}} ) {
+foreach my $moduleDir ( @{$config->{'moduleDirs'}} ) {
-   &logIt( \%configuration,  3, "Processing modules from $moduleDir" );
+   &logIt( $config,  3, "Processing modules from $moduleDir" );
-   &ProcessModules( $System, "$moduleDir/" );
+   &ProcessModules( $report, "$moduleDir/" );
 }
-&logIt( \%configuration,  4, "After processing modules\n" . Data::Dumper->Dump( [$System], [qw( $System )] ) );
+&logIt( $config,  4, "After processing modules\n" . Data::Dumper->Dump( [$report], [qw( $report )] ) );
-my $out =  sprintf( "#sysinfo: %s (data: %s) YAML\n", $VERSION, $DATA_VERSION ) . &Dump( $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
+# convert the report hash to the desired output type
-my $globals = {
-      'upload_type'  => 'sysinfo',
-      'data version' => $DATA_VERSION->normal,
-      'report date'  => $reportDate,
-      'client name'  => $configuration{'clientName'},
+my $out = hashToReportString( $report, $config->{'outputType'} ); # test if we can convert to output type
-      'host name'    => $configuration{'hostname'},
+# add comment to top of file except for json
-      'serial number'=> $configuration{'serialNumber'},
+$out = "# sysinfo " . $VERSION->normal . " (data " . $DATA_VERSION->normal . ") $config->{outputType}\n" . $out unless $config->{'outputType'} eq 'json';
-      'UUID'         => $configuration{'UUID'}
-      };
-&logIt( \%configuration,  4, "Globals initialized\n" . Data::Dumper->Dump([$globals],[qw($globals)]) );
+&logIt( $config,  4, 'At line number ' . __LINE__ . "\n" . $out );
+# actually writing the report
 if ( $TESTING ) {
-   &logIt( \%configuration, 0, "Sending report to sysinfo.testing.yaml" );
+   &logIt( $config, 0, "Sending report to sysinfo.testing.yaml" );
    open DATA, ">/tmp/sysinfo.testing.yaml" or die "Could not write to /tmp/sysinfo.testing.yaml: $!\n";
    print DATA $out;
    close DATA;
 } else {
+   # load some global values for use in the script, if required
+   my $globals = {
+         'upload_type'  => 'sysinfo',
+         'data version' => $DATA_VERSION->normal,
-   # and send the results to the server
+         'report date'  => $reportDate,
+         'client name'  => $config->{'clientName'},
+         'host name'    => $config->{'hostname'},
+         'serial number'=> $config->{'serialNumber'},
+         'UUID'         => $config->{'UUID'},
+         'fileType'     => $config->{'outputType'}
+         };
+   &logIt( $config,  4, "Globals initialized\n" . Data::Dumper->Dump([$globals],[qw($globals)]) );
-   &logIt( \%configuration, 0, "Sending report to remote transport" );
+   &logIt( $config, 0, "Sending report to remote transport" );
-   if ( my $success = &sendResults( $globals, $configuration{'transports'}, $out, $configuration{'scriptDirs'} ) != 1 ) {
+   if ( my $success = &sendResults( $globals, $config->{'transports'}, $out, $config->{'scriptDirs'} ) != 1 ) {
-      &logIt( \%configuration,  0, "Error $success while sending report from $configuration{'hostname'}" );
+      &logIt( $config,  0, "Error $success while sending report from $config->{'hostname'}" );
+   }
+}
 unlink ( $periodicOverrideFile ) if -e $periodicOverrideFile;
-&logIt( \%configuration,  0, 'Ending sysinfo Run' );
+&logIt( $config,  0, 'Ending sysinfo Run' );
-if ( $configuration{'postRunScript'}{'script name'} ) {
+if ( $config->{'postRunScript'}{'script name'} ) {
-   my $script = $sourceDir . '/' . $configuration{'postRunScript'}{'script name'};
+   my $script = $sourceDir . '/' . $config->{'postRunScript'}{'script name'};
-   exec ( "$script $configurationFile" ) if -x $script;
+   exec ( "$script $configFile" ) if -x $script;
+}
 ;

Subversion Repositories camp_sysinfo_client_3

(root)/trunk/sysinfo-client – Rev 257 → 258