Subversion Repositories camp_sysinfo_client_3

#!/usr/bin/env perl
use warnings;
use strict;
use Data::Dumper;

# Description: Use smartctl to get disk information

our $VERSION = '2.0';

# R. W. Rodolico
# grabs smart readings from all drives in system
# note that in the case of some hardware RAID controller, will list the components of a "drive" and the drive itself,
# so you may have up to twice the number of entries than you have physical drives, for example, if you have a megaraid
# controller where each physical drive is also a single logical drive.

# find our location and use it for searching for libraries
BEGIN {
   use FindBin;
   use File::Spec;
   use lib File::Spec->catdir($FindBin::Bin);
   use library;
}

exit 0 unless checkDate( 'm' ); # run this only on first of month

my %ignoreDriveTypes = ( # a list of drive "types" used by virtuals that we just ignore.
         'VBOX HARDDISK' => 1,
         );


sub getSmartInformationReport {
   my ($drive, $type) = @_;
   $type = '' if ( $type =~ m/scsi/ );
   my @report = `smartctl -i $drive $type`;
   chomp @report;
   my %reportHash;
   for ( my $i = 0; $i < @report; $i++ ) {
      if ( $report[$i] =~ m/^(.*):(.*)$/ ) {
         $reportHash{$1} = trim($2);
      }
   }
   return \%reportHash;
} # getSmartInformationReport

sub getSmartAttributeReport {
   my ($drive, $type) = @_;
   $type = '' if ( $type =~ m/scsi/ );
   my @report = `smartctl -A $drive $type`;
   chomp @report;
   my %reportHash;
   my %headers;
   # bypass all the header information
   my $i;
   for ( $i = 0; $i < @report && $report[$i] !~ m/^ID#/; $i++ ) {}
   if ( $i < @report ) { # did we get an actual report? some drives will not give us one
      my $char = 0;
      while ( $char < length($report[$i]) ) {
         substr( $report[$i],$char ) =~ m/^([^ ]+\s*)/;
         my $header = $1;
         my $start = $char;
         my $length = length($header);
         if ( $header = &trim( $header ) ) {
            $headers{$header}{'start'} = $start;
            $headers{$header}{'length'} = $length-1;
         }
         $char += $length;
      }
      while ( ++$i < @report ) {
         last unless $report[$i];
         my $id = &trim(substr( $report[$i], $headers{'ID#'}{'start'}, $headers{'ID#'}{'length'} ));
         my $name = &trim(substr( $report[$i], $headers{'ATTRIBUTE_NAME'}{'start'}, $headers{'ATTRIBUTE_NAME'}{'length'} ));
         my $value = &trim(substr( $report[$i], $headers{'RAW_VALUE'}{'start'} ));
         $reportHash{$id}{'value'} = $value;
         $reportHash{$id}{'name'} = $name;
      }
   }
   #print Dumper( \%reportHash ); die;
   return \%reportHash;
}


sub getAttributes {
   my ($report,$sectorSize) = @_;
   my %reportHash;
   # first let's get total disk writes
   if ( defined( $report->{'241'} ) ) {
      $sectorSize =~ m/^(\d+)/;
      $reportHash{'writes'} = $report->{'241'} * $sectorSize;
   }
   # find total uptime
   if ( defined( $report->{'9'} ) ) {
      $report->{'9'}->{'value'} =~ m/^(\d+)/;
      $reportHash{'uptime'} = $1;
   }
   return \%reportHash;
}

sub getInformation {
   my $report = shift;
   my %info;
   my %keys = ( 
                  'Model Family'  => { 
                                          'tag' => 'Make',
                                          'regex' => '(.*)'
                                      },
                  'Device Model'  => { 
                                          'tag' => 'Model',
                                          'regex' => '(.*)'
                                      },
                  'Serial number' => { 
                                          'tag' => 'Serial',
                                          'regex' => '(.*)'
                                      },
                  'Serial Number' => { 
                                          'tag' => 'Serial',
                                          'regex' => '(.*)'
                                      },
                  'User Capacity' => { 
                                          'tag' => 'Capacity',
                                          'regex' => '([0-9,]+)'
                                      },
                  'Logical block size' =>{ 
                                          'tag' => 'Sector Size',
                                          'regex' => '(\d+)'
                                      },
                  'Sector Size'   => { 
                                          'tag' => 'Sector Size',
                                          'regex' => '(\d+)'
                                      },
                  'Rotation Rate' => { 
                                          'tag' => 'Rotation',
                                          'regex' => '(.*)'
                                      },
               );
   foreach my $key ( keys %keys ) {
      if ( defined( $report->{$key} ) && $report->{$key} =~ m/$keys{$key}->{'regex'}/ ) {
         $info{$keys{$key}->{'tag'}} = $1;
      }
   }
   # remove comma's from capacity
   $info{'Capacity'} =~ s/,//g if $info{'Capacity'};
   return \%info;
}



# category we will use for all values found
# see sysinfo for a list of valid categories
my $CATEGORY = 'attributes';

# run the commands necessary to do whatever you want to do
# The library entered above has some helper routines
# validCommandOnSystem -- passed a name, returns the fully qualified path or '' if it does not exist
# cleanUp - passed a delimiter and a string, does the following (delimiter can be '')
#           chomps the string (removes trailing newlines)
#           removes all text BEFORE the delimiter, the delimiter, and any whitespace
#           thus, the string 'xxI Am x  a weird string' with a newline will become
#           'a weird string' with no newline

# now, return the tab delimited output (to STDOUT). $CATEGORY is the first
# item, name as recognized by sysinfo is the second and the value is
# the last one. For multiple entries, place on separate lines (ie, newline separated)

# check for commands we want to run
my %commands = ( 
                  'smartctl' => '',
               );

# check the commands for validity
foreach my $command ( keys %commands ) {
   $commands{$command} = &validCommandOnSystem( $command );
}

# bail if we don't have the commands we need
exit 1 unless $commands{'smartctl'};

# Get all the drives on the system
my %allDrives = map { $_ =~ '(^[a-z0-9/]+)\s+(.*)\#'; ($1,$2) } `smartctl --scan`;

#foreach my $key ( keys %allDrives ) { print "$key\t$allDrives{$key}\n"; } die;

# output the drives and information as tab delimited,
foreach my $thisDrive ( sort keys %allDrives ) {
 #print "$thisDrive\n";
 print "$CATEGORY\t$thisDrive Type\t$allDrives{$thisDrive}\n";
 my $informationReport = &getSmartInformationReport( $thisDrive, $allDrives{$thisDrive} );
 my $info = &getInformation( $informationReport );
 # if this is not a virtual device, get smart attributes also
 if ( ! defined( $ignoreDriveTypes{ $info->{'Model'} } ) ) {
    #print Dumper( $info ); die;
    my $attributesReport = &getSmartAttributeReport( $thisDrive, $allDrives{$thisDrive} );
    my $attributes = &getAttributes( $attributesReport, $info->{'Sector Size'} );
    #print Dumper( $attributes ); die;
    $info = { %$info, %$attributes };
    #print Dumper( $info ); die;
 }
 foreach my $key ( keys %$info ) {
    print "$CATEGORY\t$thisDrive $key\t" . $info->{$key} . "\n";
 }
}

exit 0;