WebSVN – camp_sysinfo_client_3 – Diff – /install.pl

    use lib File::Spec->catdir($FindBin::Bin);
+}
 use sysinfoconf;
 use File::Basename;
+use Getopt::Long;
+Getopt::Long::Configure ("bundling"); # allow -vd --os='debian'
 use Data::Dumper;
-# $TESTING can have the following values
+# $verbose can have the following values
 # 0 - do everything
 # 1 - Do everything except the install, display what would be done
 # 2 - Be verbose to STDERR
 # 3 - Be very verbose
-my $TESTING = 1; # if test mode, simply show what would be done
+my $verbose = 0; # if test mode, simply show what would be done
+my $dryRun = 0;
+my $os;
+my $help = 0;
+my $version = 0;
 my $status; # exit status of the processes
 my $sourceDir = File::Spec->catdir($FindBin::Bin);
 my $installType;
 my %install = (  'bindir' => '/opt/camp/sysinfo-client',
                  'confdir' => '/etc/camp/sysinfo-client',
                  'application name' => 'sysinfo client',
+                 'configuration' => {
+                          'configurator' => '<bindir>/configure.pl',
+                          'configuration file' => '<confdir>/sysinfo-client.conf',
+                          'configuration seed file' => 'sysinfo-client.seed',
+                          'permission' => '700',
+                          'owner'      => 'root',
+                          'target'     => '<confdir>'
+                            },
                  'files' => {
                            'configure.pl' => {
                                  'type' => 'file',
                                  'permission' => '700',
                                  'owner' => 'root:root',
                                  'permission' => '700',
                                  'owner' => 'root:root',
                                  'target' =>  '<bindir>',
                                  'action' => 'chmod 700 *'
                               },
-                              'sysinfo-client.conf' => {
-                                 'type' => 'file',
-                                 'create' => '<bindir>/configure.pl',
-                                 'permission' => '700',
-                                 'owner'      => 'root',
-                                 'target'     => '<confdir>'
-                              }
+                     }
                   );
 # hash to set up os specific rules
 my %operatingSystems = (
                   'debian' => {
                      'bindir' => '/opt/camp/sysinfo-client',
                      'confdir' => '/etc/camp/sysinfo-client',
-                     'crontab' => '/etc/cron.daily/sysinfo-client',
+                     'crontab' => 'ln -s <bindir>/sysinfo-client /etc/cron.daily/sysinfo-client',
                      'modules' => '/^((dpkg)|(unix)|(ipmi))/',
                   },
                   'ipfire' => {
                      'bindir' => '/opt/camp/sysinfo-client',
                      'confdir' => '/etc/camp/sysinfo-client',
-                     'crontab' => '/etc/fcron.daily/sysinfo-client.fcron',
+                     'crontab' => 'ln -s <bindir>sysinfo-client /etc/fcron.daily/sysinfo-client.fcron',
                      'modules' => '/^((ipfire)|(unix))/',
+                  }
                   );
 # attempt to locate the operating system.
 # if found, will set some defaults for it.
 sub getOS {
-   my ( $install, $operatingSystems ) = @_;
+   my ( $install, $operatingSystems, $os ) = @_;
+   if ( ! $os ) { # we don't know, so we must try to figure it out
-   my $osString = `uname -a`;
+      my $osString = `uname -a`;
-   foreach my $osType ( keys %$operatingSystems ) {
+      foreach my $osType ( keys %$operatingSystems ) {
-      print "Checking if OS is $osType in $osString\n" if $TESTING > 2;
+         print "Checking if OS is $osType in $osString\n" if $verbose > 2;
-      next unless $osString =~ m/$osType/i;
+         next unless $osString =~ m/$osType/i;
-      print "Yes, it is $osType\n" if $TESTING > 2;
+         print "Yes, it is $osType\n" if $verbose > 2;
-      # We found the OS, set up some defaults
+         # We found the OS, set up some defaults
-      $$install{'os'} = $osType;
+         $os = $osType;
-      print "Setting keys for operating system\n" if $TESTING > 2;
-      for my $key ( keys $$operatingSystems{ $osType } ) {
-         $$install{$key} = $operatingSystems{ $osType }{$key};
-      } # if it is a known OS
-      return 1;
+      } # foreach
+   }
+   if ( $os ) {
+      $$install{'os'} = $os;
+      print "Setting keys for operating system\n" if $verbose > 2;
+      foreach my $key ( keys $$operatingSystems{ $os } ) {
+         $$install{$key} = $operatingSystems{ $os }{$key};
+      } # if it is a known OS
+   } # if
-   return 0;
+   return $os;
 } # getOperatingSystem
 # get some input from the user and decide how to install/upgrade/remove/whatever
 sub getInstallActions {
    my $install = shift;
    if ( ! &yesno( "This looks like a $$install{'os'} machine, correct?" ) ) {
       die "User Aborted\n" if &yesno( "If we continue, I will set this up like a $$install{'os'} system. Abort?" );
+   }
    if ( -d $$install{'confdir'} ) {
       $$install{'action'} = &getAnswer( "It looks like $$install{'application name'} is already installed, what do you want to do?",
                             ( "upgrade","remove", "overwrite" )
                           );
          die "Can not continue at this time: Do not understand your system\n";
+      }
+   }
    $$install{'build config'} = &yesno( "Edit config file when done?" );
    $$install{'setup cron'} = &yesno( "Set up for automatic running via crontab?" );
-   &showWork( $install );
-   die unless &yesno( "Ready to run? Select No to abort." );
+}
 sub showWork {
    my $install = shift;
    print Dumper( \%install );
+}
+sub doPlaceholderSubstitution {
+   my ($hash, $placeholder) = @_;
+   return if ref $hash ne 'HASH';
+   foreach my $key ( keys %$hash ) {
+      if ( ref( $$hash{$key} ) ) {
+         &doPlaceholderSubstitution( $$hash{$key}, $placeholder );
+      } else {
+         foreach my $place ( keys %$placeholder ) {
+            $$hash{$key} =~ s/$place/$$placeholder{$place}/;
+         } # foreach
+      } # if..else
+   } # foreach
+   return;
+}
 # This will go through and first, see if anything is a directory, in
 # which case, we'll create new entries for all files in there.
 # then, it will do keyword substitution of <bindir> and <confdir>
 # to populate the target.
 # When this is done, each file should have a source and target that is
 # a fully qualified path and filename
 sub populateSourceDir {
    my ( $install, $sourceDir ) = @_;
+   my %placeHolders =
+      (
-   my $bindir = $$install{'bindir'};
+        '<bindir>' => $$install{'bindir'},
-   my $confdir = $$install{'confdir'};
+        '<confdir>' => $$install{'confdir'}
+      );
    my $allFiles = $$install{'files'};
+   # find all directory entries and load files in that directory into $$install{'files'}
    foreach my $dir ( keys %$allFiles ) {
       if ( defined( $$allFiles{$dir}{'type'} ) && $$allFiles{$dir}{'type'} eq 'directory' ) {
-         print "Found directory $dir\n" if $TESTING > 2;
+         print "Found directory $dir\n" if $verbose > 2;
          if ( opendir( my $dh, "$sourceDir/$dir" ) ) {
             my @files = map{ $dir . '/' . $_ } grep { ! /^\./ && -f "$sourceDir/$dir/$_" } readdir( $dh );
-            print "\tFound files " . join( ' ', @files ) . "\n" if $TESTING > 2;
+            print "\tFound files " . join( ' ', @files ) . "\n" if $verbose > 2;
             foreach my $file ( @files ) {
                $$allFiles{ $file }{'type'} = 'file';
                $$allFiles{ $file }{'permission'} = $$allFiles{ $dir }{'permission'};
                $$allFiles{ $file }{'owner'} = $$allFiles{ $dir }{'owner'};
                $$allFiles{ $file }{'target'} = $$allFiles{ $dir }{'target'};
             } # foreach
             closedir $dh;
          } # if opendir
       } # if it is a directory
    } # foreach
-   print Dumper( $install ) if $TESTING > 2;
+   # find all files, and set the source directory, and add the filename to
+   # the target
    foreach my $file ( keys %$allFiles ) {
-      print STDERR "$file\t$bindir\t$$allFiles{$file}{'target'}\n" if $TESTING > 1;
       $$allFiles{$file}{'source'} = "$sourceDir/$file";
-      $$allFiles{$file}{'target'} =~ s/<bindir>/$bindir/gi;
-      $$allFiles{$file}{'target'} =~ s/<confdir>/$confdir/gi;
       $$allFiles{$file}{'target'} .= "/$file";
-      if ( $$allFiles{$file}{'create'} ) {
-         $$allFiles{$file}{'create'} =~ s/<bindir>/$bindir/gi;
-         $$allFiles{$file}{'create'} =~ s/<confdir>/$confdir/gi;
-         $$allFiles{$file}{'create'} .= "/file";
-      }
    } # foreach
+   # finally, do place holder substitution. This recursively replaces all keys
+   # in  %placeHolders with the values.
+   &doPlaceholderSubstitution( $install, \%placeHolders );
+   print Dumper( $install ) if $verbose > 2;
    return 1;
 } # populateSourceDir
 # there is a file named VERSIONS. We get the values out of the install
 # directory and (if it exists) the target so we can decide what needs
    if ( open FILE,"<$currentVersionFile" ) {
       while ( my $line = <FILE> ) {
          chomp $line;
          my ( $filename, $version, $checksum ) = split( "\t", $line );
          $$install{'files'}{$filename}{'installed version'} = $version ? $version : '';
-#         $$install{'files'}{$filename}{'installed checksum'} = $checksum ? $checksum : '';
+      }
       close FILE;
+   }
    if ( open FILE,"<$newVersionFile" ) {
       while ( my $line = <FILE> ) {
          chomp $line;
          my ( $filename, $version, $checksum ) = split( "\t", $line );
          $$install{'files'}{$filename}{'new version'} = $version ? $version : '';
-#         $$install{'files'}{$filename}{'new checksum'} = $checksum ? $checksum : '';
+      }
       close FILE;
+   }
    return 1;
 } # getVersions
-# runs a system command. Also, if in testing mode, simply shows what
-# would have been done.
-sub runCommand {
-   while ( my $command = shift ) {
-      if ( $TESTING ) {
-         print "$command\n";
-      } else {
-         `$command`;
-      }
-   }
-   return 1;
-} # runCommand
-# checks if a directory exists and, if not, creates it
-my %directories; # holds list of directories already created so no need to do an I/O
-sub checkDirectoryExists {
-   my ( $filename,$mod,$owner ) = @_;
-   $mod = "0700" unless $mod;
-   $owner = "root:root" unless $owner;
-   print "Checking Directory for $filename with $mod and $owner\n" if $TESTING > 2;
-   my ($fn, $dirname) = fileparse( $filename );
-   print "\tParsing out $dirname and $filename\n" if $TESTING > 2;
-   return '' if exists $directories{$dirname};
-   if ( -d $dirname ) {
-      $directories{$dirname} = 1;
-      return '';
-   }
-   if ( &runCommand( "mkdir -p $dirname", "chmod $mod $dirname", "chown $owner $dirname" ) ) {
-      $directories{$dirname} = 1;
-   }
-   return '';
-}
 # this actually does the installation, except for the configuration
 sub doInstall {
    my $install = shift;
    my $fileList = $$install{'files'};
             );
    } # foreach file
    return 1;
+}
+sub postInstall {
+   my $install = shift;
-# parse the flags to decide the actions:
+   # set up crontab, if necessary
+   # run configurator, if needed
+   my %config;
+   my $seedFile = $install{'configuration'}{'configuration seed file'};
+   my $confFile = $install{'configuration'}{'configuration file'};
+   my $content;
-# install - assumes is a new install, overwrites everything
+   if ( -f $seedFile  && &yesno( 'Add installation seed file? ' ) ) {
+      my $clientName;
+      my $serialNumber;
+      my $hostname;
+      my @moduleDirs;
+      my @scriptDirs;
+      my $transports = {};
-# upgrade - Checks for new files and overwrites only them
+      print "Loading seed file $seedFile\n";
+      open SEED, "<$seedFile" or die "Could not open $seedFile: $!\n";
-# uninstall - Removes everything
+      $content = join( '', <SEED> );
+      close SEED;
-# reinstall - overwrites everything with fresh copy
+      # 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( $content ); use strict "vars"; die "Error during eval: $@\n" if $@;
+      if (  -f $confFile  ) {
+         print "Loading configuration file $confFile\n";
+         open SEED, "<$confFile" or die "Could not open $confFile: $!\n";
+         $content = join( '', <SEED> );
-################
+         close SEED;
-# check for the configuration file!!!
+         # 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( $content ); use strict "vars"; die "Error during eval: $@\n" if $@;
+      }
+      $config{'clientName'} = $clientName;
+      $config{'serialNumber'} = $serialNumber;
+      $config{'hostname'} = $hostname;
+      $config{'moduleDirs'} = [ @moduleDirs ];
+      $config{'scriptDirs'} = [ @scriptDirs ];
+      $config{'transports'} = $transports;
+      $content = &showConf( \%config );
-################
+      print $content;
+      print &writeConfig( $install{'configuration'}{'configuration file'} , $content ) . "\n"
+         if ( &yesno( "Write the above configuration to $install{'configuration'}{'configuration file'}?" ) );
+   }
+   if ( ( -x $install{'configuration'}{'configurator'} ) && $install{'build config'} ) {
+      exec( $install{'configuration'}{'configurator'} );
+   }
+}
+sub help {
+   my $oses = join( ' ', keys %operatingSystems );
+   print <<END
+$0 --verbose=x --os="osname" --dryrun --help --version
+--os      - osname is one of [$oses]
+--dryrun  - do not actually do anything, just tell you what I'd do
+--verbose - x is 0 (normal) to 3 (horrible)
+END
+}
+##########################################
+# Main Loop
+##########################################
+# handle any command line parameters that may have been passed in
+GetOptions (
+            "verbose|v=i" => \$verbose, # verbosity level, 0-9
+            "os|o=s"      => \$os,      # pass in the operating system
+            "dryrun|n"    => \$dryRun,  # do NOT actually do anything
+            'help|h'      => \$help,
+            'version|V'   => \$version
+            ) or die "Error parsing command line\n";
+if ( $help ) { &help() ; exit; }
+if ( $version ) { print "$0 version $VERSION\n"; exit; }
+&setDryRun( $dryRun ); # tell the library whether this is a dry run or not
 # figure out if we know our operating system
-$status = &getOS( \%install, \%operatingSystems );
+$os = &getOS( \%install, \%operatingSystems, $os );
-$installType = getInstallActions( \%install );
+$installType = &getInstallActions( \%install );
 # based on the defaults, flesh out the install hash
 $status = &populateSourceDir( \%install, $sourceDir );
 $status = &getVersions( \%install );
+&showWork( \%install );
+die unless &yesno( "Ready to run? Select No to abort." );
 $status = &doInstall( \%install );
+$status = &postInstall( \%install );
-print Dumper( \%install ) if $TESTING > 2;
+;

Subversion Repositories camp_sysinfo_client_3

(root)/install.pl @ 35 – Rev 34 → 35