Subversion Repositories camp_sysinfo_client_3

#! /usr/bin/env perl

use strict;

use warnings;

# find our location and use it for searching for libraries

BEGIN {

   use FindBin;

   use File::Spec;

   # use libraries from the directory this script is in

   use lib File::Spec->catdir($FindBin::Bin);

   # and its parent

   use lib File::Spec->catdir( $FindBin::Bin . '/../' );

   eval( 'use YAML::Tiny' );

}

use Cwd qw(abs_path);

my $scriptDir = abs_path(File::Spec->catdir($FindBin::Bin) );

use Digest::MD5 qw(md5_hex);

use File::Copy;

# define the version number

# see https://metacpan.org/pod/release/JPEACOCK/version-0.97/lib/version.pod

use version;

our $VERSION = version->declare("v0.001.001");

use Data::Dumper;

use File::Basename;

use Getopt::Long;

# load the definitions from installer_config.pl

do "$scriptDir/installer_config.pl";

our %libraries;

our %install;

our %binaries;

use sysinfosetup;

Getopt::Long::Configure ("bundling"); # allow -vd --os='debian'

our $dryRun = 0;

my $os;

my $help = 0;

my $version = 0;

my $quiet = 0;

our $DEBUG = 0;

my %commands; # we will use this to track commands that are to be run

# simple display if --help is passed

sub help {

   use File::Basename;

   print basename($0) . " $VERSION\n";

   print <<END

$0 [options]

Options:

   --os|-o      - lower case name of operating system (debian, freebsd, etc...)

   --dryrun|-n  - do not actually do anything, just tell you what I'd do

   --version|-v - display version and exit

   --quiet|-q   - Do not ask questions, just do stuff

   --debug      - turn on debug mode (no short form). --nodebug turns off (default)

   --help|-h    - Show this screen

END

}

# validates the libraries needed exist

# simply eval's each library. If it doesn't exist, creates a list of

# commands to be executed to install it, and displays missing libraries

# offering to install them if possible.

sub validateLibraries {

   my ( $libraries, $os, $commands ) = @_;

   &logIt( 'Entering validateLibraries' );

   my %return;

   foreach my $lib ( keys %$libraries ) {

      &logIt( "Checking on library $lib" );

      eval( "use $lib;" );

      if ( $@ ) {

         print "Needing library $lib\n" if $DEBUG;

         $return{ $lib } = $libraries->{$lib}->{$os} ? $libraries->{$lib}->{$os} : 'UNK';

         push @{$commands->{$libraries->{$lib}->{$os}->{'command'}}}, $libraries->{$lib}->{$os}->{'parameter'}

      }

   }

   return \%return;

} # validateLibraries

# check for any required binaries

sub validateBinaries {

   my ( $binaries, $os, $commands ) = @_;

   &logIt( 'Entering validateBinaries' );

   my %return;

   foreach my $bin ( keys %$binaries ) {

      unless ( `which $bin` ) {

         print "Needing $bin\n" if $DEBUG;

         $return{$bin} = $binaries->{$bin}->{$os} ? $binaries->{$bin}->{$os} : 'UNK';

         push @{$commands->{$binaries->{$bin}->{$os}->{'command'}}}, $binaries->{$bin}->{$os}->{'parameter'}

      }

   }

   return \%return;

} # validateBinaries

################################################################

# validateCPAN

#

# some of the systems will need to run cpan to get some perl modules.

# this will go through each of them and see if command starts with cpan

# and, if so, will check that cpan is installed and configured for root.

#

# when cpan is installed, it requires one manual run as root from the cli

# to determine where to get the files. If that is not done, cpan can not

# be controlled by a program. We check to see if cpan is installed, then

# verify /root/.cpan has been created by the configuration tool

################################################################

sub validateCPAN {

   my $libraries = shift;

   my $needCPAN = 0;

   my $message = '';

   foreach my $app ( keys %$libraries ) {

      if ( $libraries->{$app}->{'command'} =~ m/^cpan/ ) {

         $needCPAN = 1;

         last;

      }

   }

   return $message unless $needCPAN;

   if ( `which cpan` ) {

      $message =  "****ERROR****\nWe need cpan, and it is installed, but not configured\nrun cpan as root one time to configure it\n" unless -d '/root/.cpan';

   } else {

      $message =  'In order to install on this OS, we need cpan, which should have been installed with perl.' .

          " Can not continue until cpan is installed and configured\n";

   }

   return $message;

}

################################################################

#               Main Code                                      #

################################################################

# handle any command line parameters that may have been passed in

GetOptions (

            "os|o=s"      => \$os,      # pass in the operating system

            "dryrun|n"    => \$dryRun,  # do NOT actually do anything

            'help|h'      => \$help,

            'version|v'   => \$version,

            'quiet|q'     => \$quiet,

            'debug!'      => \$DEBUG

            ) or die "Error parsing command line\n";

if ( $help ) { &help() ; exit; }

if ( $version ) { use File::Basename; print basename($0) . " $VERSION\n"; exit; }

die "Can not continue without operating system parameter (--os=)\n" unless $os;

&logIt( "Inside validateDependencies" );

print "Inside validateDependencies\n";

# check libraries necessary are loaded, and if not, track the ones we need

$install{'missing libraries'} = &validateLibraries( \%libraries, $os, \%commands );

&logIt( "Missing Libraries\n" . Dumper( $install{'missing libraries'} ) );

# Check that required binaries are installed and create list of the ones we need

$install{'missing binaries'} = &validateBinaries( \%binaries, $os, \%commands );

&logIt( "Missing binaries\n" . Dumper( $install{'missing binaries'} ) );

# if we need libraries and the os needs to use CPAN, validate CPAN

my $cpanMessage = &validateCPAN( $install{'missing libraries'} ) if ( $install{'missing libraries'} );

if ( %commands ) {

   print "We need the following libraries\n" . join( "\n", keys( %{ $install{'missing libraries'} } ) ) . "\n" if $install{'missing libraries'};

   print "We need the following binaries\n" . join( "\n", keys( %{ $install{'missing binaries'} } ) ) . "\n" if $install{'missing binaries'};

   print "I can install them with the following command(s)\n";

   my @commandList;

   foreach my $command ( keys %commands ) {

      push @commandList,  $command . ' ' . join( ' ', @{$commands{$command}} );

   }

   print join( "\n", @commandList ) . "\n";

   if ( $cpanMessage ) {

      print "However, $cpanMessage\nExiting\n";

      return 2;

   }

   if ( $quiet || &yesno( "Do you want me to run these commands?" ) ) {

      for ( my $i = 0; $i < @commandList; $i++ ) {

         &runCommand( $commandList[$i] ) || die "Error executing $commandList[$i]\n";

      }

   }

}

1;