Current File : //lib64/nagios/plugins/nccustom/check_raid_perc
#!/usr/bin/perl -w
# =============================================================================
# check_raid_perc: Nagios/Icinga plugin to check PERC Raid Controller status
# -----------------------------------------------------------------------------
# Created as part of a semester project at the University of Applied Sciences
# Hagenberg (http://www.fh-ooe.at/en/hagenberg-campus/)
#
# Copyright (c) 2013-2016:
# Georg Schoenberger (gschoenberger@thomas-krenn.com)
# Grubhofer Martin (s1110239013@students.fh-hagenberg.at)
# Scheipner Alexander (s1110239032@students.fh-hagenberg.at)
# Werner Sebastian (s1110239038@students.fh-hagenberg.at)
# Jonas Meurer (jmeurer@inet.de)
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 3 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, see <http://www.gnu.org/licenses/>.
# ==============================================================================
#
# Modified by Bogdan Kukharskiy, NameCheap Inc. <bogdan.kukharskiy@namecheap.com>
#
# Added GasGauge ignore functionality
# Modified to work when there is no enclosures (sub getPhysicalDevices)
# Added: CasGauge checking is disabled while Battery is in Learning State
use strict;
use warnings;
use Getopt::Long qw(:config no_ignore_case);
use File::Which;
our $VERBOSITY = 0;
our $VERSION = "2.5";
our $NAME = "check_PERC_raid: Nagios/Icinga plugin to check PERC Raid Controller status";
our $C_TEMP_WARNING = 85;
our $C_TEMP_CRITICAL = 95;
our $C_MEM_CORRECTABLE_WARNING = 0;
our $C_MEM_CORRECTABLE_CRITICAL = 0;
our $PD_TEMP_WARNING = 45;
our $PD_TEMP_CRITICAL = 50;
our $BBU_TEMP_WARNING = 55;
our $BBU_TEMP_CRITICAL = 60;
our $CV_TEMP_WARNING = 70;
our $CV_TEMP_CRITICAL = 85;
our ($IGNERR_M, $IGNERR_O, $IGNERR_P, $IGNERR_S, $IGNERR_B) = (0, 0, 0, 0, 0);
our $NOENCLOSURES = 0;
our $CONTROLLER = 0;
use constant {
STATE_OK => 0,
STATE_WARNING => 1,
STATE_CRITICAL => 2,
STATE_UNKNOWN => 3,
};
# Header maps to parse logical and physical devices
our $LDMAP;
our @map_a = ('DG/VD','TYPE','State','Access','Consist','Cache','sCC','Size');
our @map_cc_a = ('DG/VD','TYPE','State','Access','Consist','Cache','Cac','sCC','Size');
our @pdmap_a = ('EID:Slt','DID','State','DG','Size','Intf','Med','SED','PI','SeSz','Model','Sp');
# Print command line usage to stdout.
sub displayUsage {
print "Usage: \n";
print " [ -h | --help ]
Display this help page\n";
print " [ -v | -vv | -vvv | --verbose ]
Sets the verbosity level.
No -v is the normal single line output for Nagios/Icinga, -v is a
more detailed version but still usable in Nagios. -vv is a
multiline output for debugging configuration errors or more
detailed information. -vvv is for plugin problem diagnosis.
For further information please visit:
http://nagiosplug.sourceforge.net/developer-guidelines.html#AEN39\n";
print " [ -V --version ]
Displays the plugin and, if available, the version of StorCLI.\n";
print " [ -C <num> | --controller <num> ]
Specifies a controller number, defaults to 0.\n";
print " [ -EID <ids> | --enclosure <ids> ]
Specifies one or more enclosure numbers, per default all enclosures. Takes either
an integer as additional argument or a commaseperated list,
e.g. '0,1,2'. With --noenclosures enclosures can be disabled.\n";
print " [ -LD <ids> | --logicaldevice <ids>]
Specifies one or more logical devices, defaults to all. Takes either an
integer as additional argument or a comma seperated list e.g. '0,1,2'.\n";
print " [ -PD <ids> | --physicaldevice <ids> ]
Specifies one or more physical devices, defaults to all. Takes either an
integer as additional argument or a comma seperated list e.g. '0,1,2'.\n";
print " [ -Tw <temp> | --temperature-warn <temp> ]
Specifies the RAID controller temperature warning threshold, the default
threshold is ${C_TEMP_WARNING}C.\n";
print " [ -Tc <temp> | --temperature-critical <temp> ]
Specifies the RAID controller temperature critical threshold, the default
threshold is ${C_TEMP_CRITICAL}C.\n";
print " [ -PDTw <temp> | --physicaldevicetemperature-warn <temp> ]
Specifies the disk temperature warning threshold, the default threshold
is ${PD_TEMP_WARNING}C.\n";
print " [ -PDTc <temp> | --physicaldevicetemperature-critical <temp> ]
Specifies the disk temperature critical threshold, the default threshold
is ${PD_TEMP_CRITICAL}C.\n";
print " [ -BBUTw <temp> | --bbutemperature-warning <temp> ]
Specifies the BBU temperature warning threshold, default threshold
is ${BBU_TEMP_WARNING}C.\n";
print " [ -BBUTc <temp> | --bbutemperature-critical <temp> ]
Specifies the BBU temperature critical threshold, default threshold
is ${BBU_TEMP_CRITICAL}C.\n";
print " [ -CVTw <temp> | --cvtemperature-warning <temp> ]
Specifies the CV temperature warning threshold, default threshold
is ${CV_TEMP_WARNING}C.\n";
print " [ -CVTc <temp> | --cvtemperature-critical <temp> ]
Specifies the CV temperature critical threshold, default threshold
is ${CV_TEMP_CRITICAL}C.\n";
print " [ -Im <count> | --ignore-media-errors <count> ]
Specifies the warning threshold for media errors per disk, the default
threshold is $IGNERR_M.\n";
print " [ -Io <count> | --ignore-other-errors <count> ]
Specifies the warning threshold for media errors per disk, the default
threshold is $IGNERR_O.\n";
print " [ -Ip <count> | --ignore-predictive-fail-count <count> ]
Specifies the warning threshold for media errors per disk, the default
threshold is $IGNERR_P.\n";
print " [ -Is <count> | --ignore-shield-counter <count> ]
Specifies the warning threshold for media errors per disk, the default
threshold is $IGNERR_S.\n";
print " [ -Ib <count> | --ignore-bbm-counter <count> ]
Specifies the warning threshold for bbm errors per disk, the default
threshold is $IGNERR_B.\n";
print " [ -p <path> | --path <path>]
Specifies the path to StorCLI, per default uses the tool 'which' to get
the StorCLI path and also checks for binaries in /opt/MegaRAID/storcli.\n";
print " [ -b <0/1> | --BBU <0/1> ]
Check if a BBU or a CacheVault module is present. One must be present unless
'-b 0' is defined. This ensures that for a given controller a BBU/CV must be
present per default.\n";
print " [ -gg <0/1> | --GasGauge <0/1> ]
Specifies if GasGaugeStatus should be checked.\n";
print " [ --noenclosures <0/1> ]
Specifies if enclosures are present or not. 0 means enclosures are
present (default), 1 states no enclosures are used (no 'eall' in
storcli commands).\n";
print " [ --nosudo ]
Turn off using sudo.\n";
print " [ --nocleanlogs ]
Do not clean storcli logs after running storcli commands.\n";
}
# Displays a short Help text for the user
sub displayHelp {
print $NAME."\n";
print "Pulgin version: " . $VERSION ."\n";
print "Copyright (C) 2013-2015 Thomas-Krenn.AG\n";
print "Current updates available at
https://github.com/thomas-krenn/check_lsi_raid.git\n";
print "This Nagios/Icinga Plugin checks PERC RAID controllers for controller,
physical device, logical device, BBU and CV warnings and errors.\n";
print "In order for this plugin to work properly you need to add the nagios
user to your sudoers file (or create a new one in /etc/sudoers.d/).\n";
displayUsage();
print "Further information about this plugin can be found at:
http://www.thomas-krenn.com/de/wiki/LSI_RAID_Monitoring_Plugin and
http://www.thomas-krenn.com/de/wiki/LSI_RAID_Monitoring_Plugin
Please send an email to the tk-monitoring plugin-user mailing list:
tk-monitoring-plugins-user\@lists.thomas-krenn.com
if you have questions regarding use of this software, to submit patches, or
suggest improvements.
Example usage:
* If StorCli can be found with 'which' or in /opt/MegaRAID/storcli
* check_lsi_raid
* check_lsi_raid -p /opt/MegaRAID/storcli/storcli64
* check_lsi_raid -p /opt/MegaRAID/storcli/storcli64 -C 1\n";
exit(STATE_UNKNOWN);
}
# Prints the name and the version of check_lsi_raid. If storcli is available,
# the version of it is printed also.
# @param storcli The path to storcli command utility
sub displayVersion {
my $storcli = shift;
if(defined($storcli)){
my @storcliVersion = `$storcli -v`;
foreach my $line (@storcliVersion){
if($line =~ /^\s+StorCli.*/) {
$line =~ s/^\s+|\s+$//g;
print $line;
}
}
print "\n";
}
exit(STATE_OK);
}
# Checks if a storcli call was successfull, i.e. if the line 'Status = Sucess'
# is present in the command output.
# @param output The output of the storcli command as array
# @return 1 on success, 0 if not
sub checkCommandStatus{
my @output = @{(shift)};
foreach my $line (@output){
if($line =~ /^Status/){
if($line eq "Status = Success\n"){
return 1;
}
elsif (grep { /Fail(ed|ure)\s+46/i } @output){
# Return 46 means a drive is not attached, this is a valid failure
return 1;
}
else{
return 0;
}
}
}
}
# Shows the time the controller is using. Can be used to check if the
# controller number is a correct one.
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @return 1 on success, 0 if not
sub getControllerTime{
my $storcli = shift;
my @output = `$storcli show time`;
return (checkCommandStatus(\@output));
}
# Get the status of the raid controller
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @param logDevices If given, a list of desired logical device numbers
# @param commands_a An array to push the used command to
# @return A hash, each key a value of the raid controller info
sub getControllerInfo{
my $storcli = shift;
my $writelogs = shift;
my $commands_a = shift;
my $command = '';
$storcli =~ /^(.*)\/c[0-9]+/;
if(!defined($writelogs)){
$command = $1.'adpallinfo a'.$CONTROLLER.' -NoLog';
}
else{
$command = $1.'adpallinfo a'.$CONTROLLER;
}
push @{$commands_a}, $command;
my @output = `$command`;
if($? >> 8 != 0){
print "Invalid StorCLI command! ($command)\n";
exit(STATE_UNKNOWN);
}
my %foundController_h;
foreach my $line(@output){
if($line =~ /\:/){
my @lineVals = split(':', $line);
$lineVals[0] =~ s/^\s+|\s+$//g;
$lineVals[1] =~ s/^\s+|\s+$//g;
$foundController_h{$lineVals[0]} = $lineVals[1];
}
}
return \%foundController_h;
}
# Checks the status of the raid controller
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors.
# @param foundController The hash of controller infos, created by getControllerInfo
sub getControllerStatus{
my @statusLevel_a = @{(shift)};
my %foundController = %{(shift)};
my $status = '';
foreach my $key (%foundController){
if($key eq 'ROC temperature'){
$foundController{$key} =~ /^([0-9]+\.?[0-9]+).*$/;
if(defined($1)){
if(!(checkThreshs($1, $C_TEMP_CRITICAL))){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'ROC_Temperature';
}
elsif(!(checkThreshs($1, $C_TEMP_WARNING))){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'ROC_Temperature';
}
$statusLevel_a[3]->{'ROC_Temperature'} = $1;
}
}
elsif($key eq 'Degraded'){
if($foundController{$key} != 0){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'CTR_Degraded_drives';
$statusLevel_a[3]->{'CTR_Degraded_drives'} = $foundController{$key};
}
}
elsif($key eq 'Offline'){
if($foundController{$key} != 0){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'CTR_Offline_drives';
$statusLevel_a[3]->{'CTR_Offline_drives'} = $foundController{$key};
}
}
elsif($key eq 'Critical Disks'){
if($foundController{$key} != 0){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'CTR_Critical_disks';
$statusLevel_a[3]->{'CTR_Critical_disks'} = $foundController{$key};
}
}
elsif($key eq 'Failed Disks'){
if($foundController{$key} != 0){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'CTR_Failed_disks';
$statusLevel_a[3]->{'CTR_Failed_disks'} = $foundController{$key};
}
}
elsif($key eq 'Memory Correctable Errors'){
if($foundController{$key} != 0){
if(!(checkThreshs($foundController{$key}, $C_MEM_CORRECTABLE_CRITICAL))){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'CTR_Memory_correctable_errors';
}
elsif(!(checkThreshs($foundController{$key}, $C_MEM_CORRECTABLE_WARNING))){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'CTR_Memory_correctable_errors';
}
$statusLevel_a[3]->{'CTR_Memory_correctable_errors'} = $foundController{$key};
}
}
elsif($key eq 'Memory Uncorrectable Errors'){
if($foundController{$key} != 0){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'CTR_Memory_Uncorrectable_errors';
$statusLevel_a[3]->{'CTR_Memory_Uncorrectable_errors'} = $foundController{$key};
}
}
}
if($status ne ''){
if($status eq 'Warning'){
if(${$statusLevel_a[0]} ne 'Critical'){
${$statusLevel_a[0]} = 'Warning';
}
}
else{
${$statusLevel_a[0]} = 'Critical';
}
$statusLevel_a[3]->{'CTR_Status'} = $status;
}
else{
$statusLevel_a[3]->{'CTR_Status'} = 'OK';
}
}
# Checks which logical devices are present for the given controller and parses
# the logical devices to a list of hashes. Each hash represents a logical device
# with its values from the output.
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @param logDevices If given, a list of desired logical device numbers
# @param action The storcli action to check, 'all' or 'init'
# @param commands_a An array to push the used command to
# @return A list of hashes, each hash is one logical device. Check ldmap_a for valid
# hash keys.
sub getLogicalDevices{
my $storcli = shift;
my @logDevices = @{(shift)};
my $action = shift;
my $commands_a = shift;
my $command = $storcli;
if(scalar(@logDevices) == 0) { $command .= "/vall"; }
elsif(scalar(@logDevices) == 1) { $command .= "/v$logDevices[0]"; }
else { $command .= "/v".join(",", @logDevices); }
$command .= " show $action";
push @{$commands_a}, $command;
my @output = `$command`;
my @foundDevs;
if(checkCommandStatus(\@output)) {
if($action eq "all") {
my $currBlock;
foreach my $line(@output){
my @splittedLine;
if($line =~ /^\/(c[0-9]*\/v[0-9]*).*/){
$currBlock = $1;
next;
}
if(defined($currBlock)){
if($line =~ /^DG\/VD TYPE.*/){
@splittedLine = split(' ', $line);
if(scalar(@splittedLine)== 9){
$LDMAP = \@map_a;
}
if(scalar(@splittedLine)== 10){
$LDMAP = \@map_cc_a;
}
}
if($line =~ /^\d+\/\d+\s+\w+\d\s+\w+.*/){
@splittedLine = map { s/^\s*//; s/\s*$//; $_; } split(/\s+/,$line);
my %lineValues_h;
# The current block is the c0/v0 name
$lineValues_h{'ld'} = $currBlock;
for(my $i = 0; $i < @{$LDMAP}; $i++){
$lineValues_h{$LDMAP->[$i]} = $splittedLine[$i];
}
push @foundDevs, \%lineValues_h;
}
}
}
}
elsif($action eq "init") {
foreach my $line(@output){
$line =~ s/^\s+|\s+$//g;#trim line
if($line =~ /^([0-9]+)\s+INIT.*$/){
my $vdNum = 'c'.$CONTROLLER.'/v'.$1;
if($line !~ /Not in progress/i){
my %lineValues_h;
my @vals = split('\s+',$line);
$lineValues_h{'ld'} = $vdNum;
$lineValues_h{'init'} = $vals[2];
push @foundDevs, \%lineValues_h;
}
}
}
}
}
else {
print "Invalid StorCLI command! ($command)\n";
exit(STATE_UNKNOWN);
}
return \@foundDevs;
}
# Checks the status of the logical devices.
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors.
# @param foundLDs The array of logical devices, created by getLogicalDevices
sub getLDStatus{
my @statusLevel_a = @{(shift)};
my @foundLDs = @{(shift)};
my $status = '';
foreach my $LD (@foundLDs){
if(exists($LD->{'State'})){
if($LD->{'State'} ne 'Optl'){
$status = 'Critical';
push @{$statusLevel_a[2]}, $LD->{'ld'}.'_State';
$statusLevel_a[3]->{$LD->{'ld'}.'_State'} = $LD->{'State'};
}
}
if(exists($LD->{'Consist'})){
if($LD->{'Consist'} ne 'Yes' && $LD->{'TYPE'} ne 'Cac1'){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $LD->{'ld'}.'_Consist';
$statusLevel_a[3]->{$LD->{'ld'}.'_Consist'} = $LD->{'Consist'};
}
}
if(exists($LD->{'init'})){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $LD->{'ld'}.'_Init';
$statusLevel_a[3]->{$LD->{'ld'}.'_Init'} = $LD->{'init'};
}
}
if($status ne ''){
if($status eq 'Warning'){
if(${$statusLevel_a[0]} ne 'Critical'){
${$statusLevel_a[0]} = 'Warning';
}
}
else{
${$statusLevel_a[0]} = 'Critical';
}
$statusLevel_a[3]->{'LD_Status'} = $status;
}
else{
if(!exists($statusLevel_a[3]->{'LD_Status'})){
$statusLevel_a[3]->{'LD_Status'} = 'OK';
}
}
}
# Checks which physical devices are present for the given controller and parses
# the physical devices to a list of hashes. Each hash represents a physical device
# with its values from the output.
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @param physDevices If given, a list of desired physical device numbers
# @param action The storcli action to check, 'all', 'initialization' or 'rebuild'
# @param commands_a An array to push the used command to
# @return A list of hashes, each hash is one physical device. Check pdmap_a for valid
# hash keys.
sub getPhysicalDevices{
my $storcli = shift;
my @enclosures = @{(shift)};
my @physDevices = @{(shift)};
my $action = shift;
my $commands_a = shift;
my $command = $storcli;
if(!$NOENCLOSURES){
if(scalar(@enclosures) == 0) { $command .= "/eall"; }
elsif(scalar(@enclosures) == 1) { $command .= "/e$enclosures[0]"; }
else { $command .= "/e".join(",", @enclosures); }
}
if(scalar(@physDevices) == 0) { $command .= "/sall"; }
elsif(scalar(@physDevices) == 1) { $command .= "/s$physDevices[0]"; }
else { $command .= "/s".join(",", @physDevices); }
$command .= " show $action";
push @{$commands_a}, $command;
my @output = `$command`;
my @foundDevs;
if(checkCommandStatus(\@output)){
if($action eq "all") {
my $currBlock;
my $line_ref;
foreach my $line(@output){
# modified to work when there is no enclosures
if(!$NOENCLOSURES){
if($line =~ /^Drive \/(c[0-9]*\/e[0-9]*\/s[0-9]*) \:$/){
$currBlock = $1;
$line_ref = {};
next;
}
}
else{
if($line =~ /^Drive \/(c[0-9]*\/s[0-9]*) \:$/){
$currBlock = $1;
$line_ref = {};
next;
}
}
my @splittedLine;
if(defined($currBlock)){
# If a drive is not in a group, a - is at the DG column
# modified to work when there is no enclosures
if($line =~ /^\s{0,2}\d*\:\d+\s+\d+\s+\w+\s+[0-9-F]+.*/){
# modified to work when there is no enclosures
if($NOENCLOSURES){ $line =~ s/^\s+//; }
@splittedLine = map { s/^\s*//; s/\s*$//; $_; } split(/\s+/,$line);
# The current block is the c0/e252/s0 name
$line_ref->{'pd'} = $currBlock;
my $j = 0;
for(my $i = 0; $i < @pdmap_a; $i++){
if($pdmap_a[$i] eq 'Size'){
my $size = $splittedLine[$j];
if($splittedLine[$j+1] eq 'GB' || $splittedLine[$j+1] eq 'TB'){
$size .= ''.$splittedLine[$j+1];
$j++;
}
$line_ref->{$pdmap_a[$i]} = $size;
$j++;
}
elsif($pdmap_a[$i] eq 'Model'){
my $model = $splittedLine[$j];
# Model should be the next last element, j starts at 0
if(($j+2) != scalar(@splittedLine)){
$model .= ' '.$splittedLine[$j+1];
$j++;
}
$line_ref->{$pdmap_a[$i]} = $model;
$j++;
}
else{
$line_ref->{$pdmap_a[$i]} = $splittedLine[$j];
$j++;
}
}
}
if($line =~ /^(Shield Counter|Media Error Count|Other Error Count|BBM Error Count|Drive Temperature|Predictive Failure Count|S\.M\.A\.R\.T alert flagged by drive)\s\=\s+(.*)$/){
$line_ref->{$1} = $2;
}
# If the last value is parsed, set up for the next device
if(exists($line_ref->{'S.M.A.R.T alert flagged by drive'})){
push @foundDevs, $line_ref;
undef $currBlock;
undef $line_ref;
}
}
}
}
elsif($action eq 'rebuild' || $action eq 'initialization') {
foreach my $line(@output){
$line =~ s/^\s+|\s+$//g;#trim line
if($line =~ /^\/c$CONTROLLER\/.*/){
if($line !~ /Not in progress/i){
my %lineValues_h;
my @vals = split('\s+',$line);
my $key;
if($action eq 'rebuild'){ $key = 'rebuild'; }
if($action eq 'initialization'){ $key = 'init'; }
$lineValues_h{'pd'} = substr($vals[0], 1);
$lineValues_h{$key} = $vals[1];
push @foundDevs, \%lineValues_h;
}
}
}
}
# Now we check if a drive is not attached, error code 46
my $failed_pattern;
# modified to work when there is no enclosures
if(!$NOENCLOSURES){ $failed_pattern = 'c[0-9]*\/e[0-9]*\/s[0-9]*\s+Failure\s+46'; }
else{ $failed_pattern = 'c[0-9]*\/s[0-9]*\s+Failure\s+46'; }
if(my @match = grep { /$failed_pattern/ } @output){
# modified to work when there is no enclosures
if(!$NOENCLOSURES){ $match[0] =~ /(c[0-9]*\/e[0-9]*\/s[0-9]*)/; }
else{ $match[0] =~ /(c[0-9]*\/s[0-9]*)/; }
my $dev = {};
$dev->{'pd'} = $1;
$dev->{'Detailed Status'} = 'Failure-46';
push @foundDevs, $dev;
}
}
else {
if(grep { /No drive found/i } @output){
print "Warning (CTR Warn) [No storage attached] ($command)\n";
exit(STATE_WARNING);
}
print "Invalid StorCLI command! ($command)\n";
exit(STATE_UNKNOWN);
}
return \@foundDevs;
}
# Checks the status of the physical devices.
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the vebose
# information for the sensors.
# @param foundPDs The array of physical devices, created by getPhysicalDevices
sub getPDStatus{
my @statusLevel_a = @{(shift)};
my @foundPDs = @{(shift)};
my $status = '';
foreach my $PD (@foundPDs){
if(exists($PD->{'State'})){
if($PD->{'State'} ne 'Onln' && $PD->{'State'} ne 'UGood' && $PD->{'State'} ne 'GHS' && $PD->{'State'} ne 'DHS' && $PD->{'State'} ne 'JBOD'){
$status = 'Critical';
push @{$statusLevel_a[2]}, $PD->{'pd'}.'_State';
$statusLevel_a[3]->{$PD->{'pd'}.'_State'} = $PD->{'State'};
}
}
if(exists($PD->{'Shield Counter'})){
if($PD->{'Shield Counter'} > $IGNERR_S){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Shield_counter';
$statusLevel_a[3]->{$PD->{'pd'}.'_Shield_counter'} = $PD->{'Shield Counter'};
}
}
if(exists($PD->{'Media Error Count'})){
if($PD->{'Media Error Count'} > $IGNERR_M){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Media_error_count';
$statusLevel_a[3]->{$PD->{'pd'}.'_Media_error_count'} = $PD->{'Media Error Count'};
}
}
if(exists($PD->{'Other Error Count'})){
if(($IGNERR_O != -1) && ($PD->{'Other Error Count'} > $IGNERR_O)){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Other_error_count';
$statusLevel_a[3]->{$PD->{'pd'}.'_Other_error_count'} = $PD->{'Other Error Count'};
}
}
if(exists($PD->{'BBM Error Count'})){
if($PD->{'BBM Error Count'} > $IGNERR_B){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_BBM_error_count';
$statusLevel_a[3]->{$PD->{'pd'}.'_BBM_error_count'} = $PD->{'BBM Error Count'};
}
}
if(exists($PD->{'Predictive Failure Count'})){
if($PD->{'Predictive Failure Count'} > $IGNERR_P){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Predictive_failure_count';
$statusLevel_a[3]->{$PD->{'pd'}.'_Predictive_failure_count'} = $PD->{'Predictive Failure Count'};
}
}
if(exists($PD->{'S.M.A.R.T alert flagged by drive'})){
if($PD->{'S.M.A.R.T alert flagged by drive'} ne 'No'){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_SMART_flag';
}
}
if(exists($PD->{'Detailed Status'})){
if($PD->{'Detailed Status'} eq 'Failure-46'){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Detailed_status';
}
}
if(exists($PD->{'DG'})){
if($PD->{'DG'} eq 'F'){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_DG';
$statusLevel_a[3]->{$PD->{'pd'}.'_DG'} = $PD->{'DG'};
}
}
if(exists($PD->{'Drive Temperature'})){
my $temp = $PD->{'Drive Temperature'};
if($temp ne 'N/A' && $temp ne '0C (32.00 F)'){
$temp =~ /^([0-9]+)C/;
if(!(checkThreshs($1, $PD_TEMP_CRITICAL))){
$status = 'Critical';
push @{$statusLevel_a[2]}, $PD->{'pd'}.'_Drive_Temperature';
}
elsif(!(checkThreshs($1, $PD_TEMP_WARNING))){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Drive_Temperature';
}
$statusLevel_a[3]->{$PD->{'pd'}.'_Drive_Temperature'} = $1;
}
}
if(exists($PD->{'init'})){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Init';
$statusLevel_a[3]->{$PD->{'pd'}.'_Init'} = $PD->{'init'};
}
if(exists($PD->{'rebuild'})){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, $PD->{'pd'}.'_Rebuild';
$statusLevel_a[3]->{$PD->{'pd'}.'_Rebuild'} = $PD->{'rebuild'};
}
}
if($status ne ''){
if($status eq 'Warning'){
if(${$statusLevel_a[0]} ne 'Critical'){
${$statusLevel_a[0]} = 'Warning';
}
}
else{
${$statusLevel_a[0]} = 'Critical';
}
$statusLevel_a[3]->{'PD_Status'} = $status;
}
else{
if(!exists($statusLevel_a[3]->{'PD_Status'})){
$statusLevel_a[3]->{'PD_Status'} = 'OK';
}
}
}
# Checks the status of the BBU, parses 'bbu show status' for the given controller.
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors.
# @param commands_a An array to push the used command to
sub getBBUStatus {
my $storcli = shift;
my @statusLevel_a = @{(shift)};
my $commands_a = shift;
my $gasg = shift;
my $command = "$storcli /bbu show status";
push @{$commands_a}, $command;
my $status = '';
my @output = `$command`;
if(checkCommandStatus(\@output)) {
my $currBlock;
foreach my $line (@output) {
if($line =~ /^(BBU_Info|BBU_Firmware_Status|GasGaugeStatus)/){
$currBlock = $1;
next;
}
if(defined($currBlock)){
$line =~ s/^\s+|\s+$//g;#trim line
if($currBlock eq 'BBU_Info'){
if ($line =~ /^Battery State/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne 'Optimal'){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'BBU_State';
$statusLevel_a[3]->{'BBU_State'} = $1
}
}
elsif($line =~ /^Temperature/){
$line =~ /([0-9]+) C$/;
if(!(checkThreshs($1, $BBU_TEMP_CRITICAL))){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'BBU_Temperature';
}
elsif(!(checkThreshs($1, $BBU_TEMP_WARNING))){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'BBU_Temperature';
}
$statusLevel_a[3]->{'BBU_Temperature'} = $1;
}
}
elsif($currBlock eq 'BBU_Firmware_Status'){
if($line =~ /^Temperature/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "OK") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_Firmware_temperature';
$statusLevel_a[3]->{'BBU_Firmware_temperature'} = $1;
}
}
elsif($line =~ /^Voltage/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "OK") {
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]},'BBU_Voltage';
$statusLevel_a[3]->{'BBU_Voltage'} = $1;
}
}
# disabling checking GasGauge while Learn Cycle is Active
elsif($line =~ /^Learn Cycle Active/){
$line =~ /([a-zA-Z]*)$/;
if($1 eq "Yes") {
$gasg = 0;
}
}
elsif($line =~ /^I2C Errors Detected/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "No") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_Firmware_I2C_errors';
$statusLevel_a[3]->{'BBU_Firmware_I2C_Errors'} = $1;
}
}
elsif($line =~ /^Battery Pack Missing/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "No") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_Pack_missing';
$statusLevel_a[3]->{'BBU_Pack_missing'} = $1;
}
}
elsif($line =~ /^Replacement required/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "No") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_Replacement_required';
$statusLevel_a[3]->{'BBU_Replacement_required'} = $1;
}
}
elsif($line =~ /^Remaining Capacity Low/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "No") {
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]},'BBU_Remaining_capacity_low';
$statusLevel_a[3]->{'BBU_Remaining_capacity_low'} = $1;
}
}
elsif($line =~ /^Pack is about to fail \& should be replaced/){
$line =~ /([a-zA-Z]*)$/;
if($1 ne "No") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_Should_be_replaced';
$statusLevel_a[3]->{'BBU_Should_be_replaced'} = $1;
}
}
}
elsif($currBlock eq 'GasGaugeStatus' && $gasg ne 0){
if($line =~ /^Fully Discharged/){
$line =~ /([a-zA-Z\/]*)$/;
if($1 ne "No" && $1 ne "N/A") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_GasGauge_discharged';
$statusLevel_a[3]->{'BBU_GasGauge_discharged'} = $1;
}
}
elsif($line =~ /^Over Temperature/){
$line =~ /([a-zA-Z\/]*)$/;
if($1 ne "No" && $1 ne "N/A") {
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]},'BBU_GasGauge_over_temperature';
$statusLevel_a[3]->{'BBU_GasGauge_over_temperature'} = $1;
}
}
elsif($line =~ /^Over Charged/){
$line =~ /([a-zA-Z\/]*)$/;
if($1 ne "No" && $1 ne "N/A") {
$status = 'Critical';
push @{$statusLevel_a[2]},'BBU_GasGauge_over_charged';
$statusLevel_a[3]->{'BBU_GasGauge_over_charged'} = $1;
}
}
}
}
if($status ne ''){
if($status eq 'Warning'){
if(${$statusLevel_a[0]} ne 'Critical'){
${$statusLevel_a[0]} = 'Warning';
}
}
else{
${$statusLevel_a[0]} = 'Critical';
}
$statusLevel_a[3]->{'BBU_Status'} = $status;
}
else{
$statusLevel_a[3]->{'BBU_Status'} = 'OK';
}
}
}
else {
print "Invalid StorCLI command! ($command)\n";
exit(STATE_UNKNOWN);
}
}
# Checks the status of the CV module, parses 'cv show status' for the given
# controller.
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors.
# @param commands_a An array to push the used command to
sub getCVStatus {
my $storcli = shift;
my @statusLevel_a = @{(shift)};
my $commands_a = shift;
my $command = "$storcli /cv show status";
push @{$commands_a}, $command;
my $status = '';
my @output = `$command`;
if(checkCommandStatus(\@output)) {
my $currBlock;
foreach my $line (@output) {
if($line =~ /^(Cachevault_Info|Firmware_Status)/){
$currBlock = $1;
next;
}
if(defined($currBlock)){
$line =~ s/^\s+|\s+$//g;#trim line
if($currBlock eq 'Cachevault_Info' && $line =~ /^State/){
my @vals = split('\s{2,}',$line);
if($vals[1] ne "Optimal") {
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'CV_State';
$statusLevel_a[3]->{'CV_State'} = $vals[1]
}
}
elsif($currBlock eq 'Cachevault_Info' && $line =~ /^Temperature/){
$line =~ /([0-9]+) C$/;
if(!(checkThreshs($1, $CV_TEMP_CRITICAL))){
$status = 'Critical';
push @{$statusLevel_a[2]}, 'CV_Temperature';
}
elsif(!(checkThreshs($1, $CV_TEMP_WARNING))){
$status = 'Warning' unless $status eq 'Critical';
push @{$statusLevel_a[1]}, 'CV_Temperature';
}
$statusLevel_a[3]->{'CV_Temperature'} = $1;
}
elsif($currBlock eq 'Firmware_Status' && $line =~ /^Replacement required/){
$line =~ /([a-zA-Z0-9]*)$/;
if($1 ne "No") {
$status = 'Critical';
push @{$statusLevel_a[2]},'CV_Replacement_required';
}
$statusLevel_a[3]->{'CV_Replacement_required'} = $1;
}
}
if($status ne ''){
if($status eq 'Warning'){
if(${$statusLevel_a[0]} ne 'Critical'){
${$statusLevel_a[0]} = 'Warning';
}
}
else{
${$statusLevel_a[0]} = 'Critical';
}
$statusLevel_a[3]->{'CV_Status'} = $status;
}
else{
$statusLevel_a[3]->{'CV_Status'} = 'OK';
}
}
}
else {
print "Invalid StorCLI command! ($command)\n";
exit(STATE_UNKNOWN);
}
}
# Checks if wheter BBU or CV is present
# @param storcli The path to storcli command utility, followed by the controller
# number, e.g. 'storcli64 /c0'.
# @return A tuple, e.g. (0,0), where 0 means module is not present, 1 present
sub checkBBUorCVIsPresent{
my $storcli = shift;
my ($bbu,$cv);
my @output = `$storcli /bbu show`;
if(checkCommandStatus(\@output)){ $bbu = 1; }
else{ $bbu = 0 };
@output = `$storcli /cv show`;
if(checkCommandStatus(\@output)) { $cv = 1; }
else{ $cv = 0 };
return ($bbu, $cv);
}
# Checks if a given value is in a specified range, the range must follow the
# nagios development guidelines:
# http://nagiosplug.sourceforge.net/developer-guidelines.html#THRESHOLDFORMAT
# @param value The given value to check the pattern for
# @param pattern The pattern specifying the threshold range, e.g. '10:', '@10:20'
# @return 0 if the value is outside the range, 1 if the value satisfies the range
sub checkThreshs{
my $value = shift;
my $pattern = shift;
if($pattern =~ /(^[0-9]+$)/){
if($value < 0 || $value > $1){
return 0;
}
}
elsif($pattern =~ /(^[0-9]+)\:$/){
if($value < $1){
return 0;
}
}
elsif($pattern =~ /^\~\:([0-9]+)$/){
if($value > $1){
return 0;
}
}
elsif($pattern =~ /^([0-9]+)\:([0-9]+)$/){
if($value < $1 || $value > $2){
return 0;
}
}
elsif($pattern =~ /^\@([0-9]+)\:([0-9]+)$/){
if($value >= $1 and $value <= $2){
return 0;
}
}
else{
print "Invalid temperature parameter! ($pattern)\n";
exit(STATE_UNKNOWN);
}
return 1;
}
# Get the status string as plugin output
# @param level The desired level to get the status string for. Either 'Warning'
# or 'Critical'.
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors, elem 4 the used storcli commands.
# @return The created status string
sub getStatusString{
my $level = shift;
my @statusLevel_a = @{(shift)};
my @sensors_a;
my $status_str = "";
if($level eq "Warning"){
@sensors_a = @{$statusLevel_a[1]};
}
if($level eq "Critical"){
@sensors_a = @{$statusLevel_a[2]};
}
# Add the controller parts only once
my $parts = '';
# level comes from the method call, not the real status level
if($level eq "Critical"){
my @keys = ('CTR_Status','LD_Status','PD_Status','BBU_Status','CV_Status');
# Check which parts where checked
foreach my $key (@keys){
$key =~ /^([A-Z]+)\_.*$/;
my $part = $1;
if(${$statusLevel_a[0]} eq 'OK'){
if(exists($statusLevel_a[3]->{$key}) && $statusLevel_a[3]->{$key} eq 'OK'){
$parts .= ", " unless $parts eq '';
$parts .= $part;
}
}
else{
if(exists($statusLevel_a[3]->{$key}) && $statusLevel_a[3]->{$key} ne 'OK'){
$parts .= ", " unless $parts eq '';
$parts .= $part;
$parts .= ' '.substr($statusLevel_a[3]->{$key}, 0, 4);
}
}
}
$status_str.= '(';
$status_str .= $parts unless !defined($parts);
$status_str.= ')';
}
if($level eq 'Critical'){
$status_str.= ' ' unless !(@sensors_a);
}
if($level eq 'Warning' && !@{$statusLevel_a[2]}){
$status_str.= ' ' unless !(@sensors_a);
}
if($level eq "Warning" || $level eq "Critical"){
if(@sensors_a){
# Print which sensors are Warn or Crit
foreach my $sensor (@sensors_a){
$status_str .= "[".$sensor." = ".$level;
if($VERBOSITY){
if(exists($statusLevel_a[3]->{$sensor})){
$status_str .= " (".$statusLevel_a[3]->{$sensor}.")";
}
}
$status_str .= "]";
}
}
}
return $status_str;
}
# Get the verbose string if a higher verbose level is used
# @param statusLevel_a The status level array, elem 0 is the current status,
# elem 1 the warning sensors, elem 2 the critical sensors, elem 3 the verbose
# information for the sensors, elem 4 the used storcli commands.
# @param controllerToCheck Controller parsed by getControllerInfo
# @param LDDevicesToCheck LDs parsed by getLogicalDevices
# @param LDInitToCheck LDs parsed by getLogicalDevices init
# @param PDDevicesToCheck PDs parsed by getPhysicalDevices
# @param PDInitToCheck PDs parsed by getPhysicalDevices init
# @param PDRebuildToCheck PDs parsed by getPhysicalDevices rebuild
# @return The created verbosity string
sub getVerboseString{
my @statusLevel_a = @{(shift)};
my %controllerToCheck = %{(shift)};
my @LDDevicesToCheck = @{(shift)};
my @LDInitToCheck = @{(shift)};
my @PDDevicesToCheck = @{(shift)};
my @PDInitToCheck = @{(shift)};
my @PDRebuildToCheck = @{(shift)};
my @sensors_a;
my $verb_str;
$verb_str .= "Used storcli commands:\n";
foreach my $cmd (@{$statusLevel_a[4]}){
$verb_str .= '- '.$cmd."\n";
}
if(${$statusLevel_a[0]} eq 'Critical'){
$verb_str .= "Critical sensors:\n";
foreach my $sensor (@{$statusLevel_a[2]}){
$verb_str .= "\t- ".$sensor;
if(exists($statusLevel_a[3]->{$sensor})){
$verb_str .= ' ('.$statusLevel_a[3]->{$sensor}.')';
}
$verb_str .= "\n";
}
}
if( ${$statusLevel_a[0]} ne 'OK'){
$verb_str .= "Warning sensors:\n";
foreach my $sensor (@{$statusLevel_a[1]}){
$verb_str .= "\t- ".$sensor;
if(exists($statusLevel_a[3]->{$sensor})){
$verb_str .= ' ('.$statusLevel_a[3]->{$sensor}.')';
}
$verb_str .= "\n";
}
}
if($VERBOSITY == 3){
$verb_str .= "CTR information:\n";
$verb_str .= "\t- ".$controllerToCheck{'Product Name'}.":\n";
$verb_str .= "\t\t- ".'Serial No='.$controllerToCheck{'Serial No'}."\n";
$verb_str .= "\t\t- ".'FW Package Build='.$controllerToCheck{'FW Package Build'}."\n";
$verb_str .= "\t\t- ".'Mfg. Date='.$controllerToCheck{'Mfg. Date'}."\n";
$verb_str .= "\t\t- ".'Revision No='.$controllerToCheck{'Revision No'}."\n";
$verb_str .= "\t\t- ".'BIOS Version='.$controllerToCheck{'BIOS Version'}."\n";
$verb_str .= "\t\t- ".'FW Version='.$controllerToCheck{'FW Version'}."\n";
if(exists($controllerToCheck{'ROC temperature'})){
$verb_str .= "\t\t- ".'ROC temperature='.$controllerToCheck{'ROC temperature'}."\n";
}
$verb_str .= "LD information:\n";
foreach my $LD (@LDDevicesToCheck){
$verb_str .= "\t- ".$LD->{'ld'}.":\n";
foreach my $key (sort (keys(%{$LD}))){
$verb_str .= "\t\t- ".$key.'='.$LD->{$key}."\n";
}
foreach my $LDinit (@LDInitToCheck){
if($LDinit->{'ld'} eq $LD->{'ld'}){
$verb_str .= "\t\t- init=".$LDinit->{'init'}."\n";
}
}
}
$verb_str .= "PD information:\n";
foreach my $PD (@PDDevicesToCheck){
$verb_str .= "\t- ".$PD->{'pd'}.":\n";
foreach my $key (sort (keys(%{$PD}))){
$verb_str .= "\t\t- ".$key.'='.$PD->{$key}."\n";
}
foreach my $PDinit (@PDInitToCheck){
if($PDinit->{'pd'} eq $PD->{'pd'}){
$verb_str .= "\t\t- init=".$PDinit->{'init'}."\n";
}
}
foreach my $PDrebuild (@PDRebuildToCheck){
if($PDrebuild->{'pd'} eq $PD->{'pd'}){
$verb_str .= "\t\t- rebuild=".$PDrebuild->{'rebuild'}."\n";
}
}
}
my @keys = ('BBU_Status','CV_Status');
foreach my $key(@keys){
if(exists($statusLevel_a[3]->{$key})){
$key =~ /^(\w+)_\w+$/;
my $type = $1;
$verb_str .= $type." information:\n";
foreach my $stat (sort (keys(%{$statusLevel_a[3]}))){
if($stat =~ /^$type.+$/){
$verb_str .= "\t\t- $stat=".$statusLevel_a[3]->{$stat}."\n";
}
}
}
}
}
return $verb_str;
}
# Get the performance string for the current check. The values are taken from
# the varbose hash in the status level array.
# @param statusLevel_a The current status level array
# @return The created performance string
sub getPerfString{
my @statusLevel_a = @{(shift)};
my %verboseValues_h = %{$statusLevel_a[3]};
my $perf_str;
foreach my $key (sort (keys(%verboseValues_h))){
if($key =~ /temperature/i){
$perf_str .= ' ' unless !defined($perf_str);
$perf_str .= $key.'='.$verboseValues_h{$key};
}
if($key =~ /ROC_Temperature$/){
$perf_str .= ';'.$C_TEMP_WARNING.';'.$C_TEMP_CRITICAL;
}
elsif($key =~ /Drive_Temperature$/){
$perf_str .= ';'.$PD_TEMP_WARNING.';'.$PD_TEMP_CRITICAL;
}
elsif($key eq 'BBU_Temperature'){
$perf_str .= ';'.$BBU_TEMP_WARNING.';'.$BBU_TEMP_CRITICAL;
}
elsif($key eq 'CV_Temperature'){
$perf_str .= ';'.$CV_TEMP_WARNING.';'.$CV_TEMP_CRITICAL;
}
}
return $perf_str;
}
MAIN: {
my ($storcli, $sudo, $noSudo, $noCleanlogs, $version, $exitCode);
# Create default sensor arrays and push them to status level
my @statusLevel_a ;
my $status_str = 'OK';
my $warnings_a = [];
my $criticals_a = [];
my $verboseValues_h = {};
my $verboseCommands_a = [];
push @statusLevel_a, \$status_str;
push @statusLevel_a, $warnings_a;
push @statusLevel_a, $criticals_a;
push @statusLevel_a, $verboseValues_h;
push @statusLevel_a, $verboseCommands_a;
# Per default use a BBU
my $bbu = 1;
my $gasg = 1;
my @enclosures;
my @logDevices;
my @physDevices;
my $platform = $^O;
if( !(GetOptions(
'h|help' => sub {displayHelp();},
'v|verbose' => sub {$VERBOSITY = 1 },
'vv' => sub {$VERBOSITY = 2},
'vvv' => sub {$VERBOSITY = 3},
'V|version' => \$version,
'C|controller=i' => \$CONTROLLER,
'EID|enclosure=s' => \@enclosures,
'LD|logicaldevice=s' => \@logDevices,
'PD|physicaldevice=s' => \@physDevices,
'Tw|temperature-warn=s' => \$C_TEMP_WARNING,
'Tc|temperature-critical=s' => \$C_TEMP_CRITICAL,
'Mcw|mem-correctable-warn=s' => \$C_MEM_CORRECTABLE_WARNING,
'Mcc|mem-correctable-critical=s' => \$C_MEM_CORRECTABLE_CRITICAL,
'PDTw|physicaldevicetemperature-warn=s' => \$PD_TEMP_WARNING,
'PDTc|physicaldevicetemperature-critical=s' => \$PD_TEMP_CRITICAL,
'BBUTw|bbutemperature-warning=s' => \$BBU_TEMP_WARNING,
'BBUTc|bbutemperature-critical=s' => \$BBU_TEMP_CRITICAL,
'CVTw|cvtemperature-warning=s' => \$CV_TEMP_WARNING,
'CVTc|cvtemperature-critical=s' => \$CV_TEMP_CRITICAL,
'Im|ignore-media-errors=i' => \$IGNERR_M,
'Io|ignore-other-errors=i' => \$IGNERR_O,
'Ip|ignore-predictive-fail-count=i' => \$IGNERR_P,
'Is|ignore-shield-counter=i' => \$IGNERR_S,
'Ib|ignore-bbm-counter=i' => \$IGNERR_B,
'p|path=s' => \$storcli,
'b|BBU=i' => \$bbu,
'gg|GasGauge=i' => \$gasg,
'noenclosures=i' => \$NOENCLOSURES,
'nosudo' => \$noSudo,
'nocleanlogs' => \$noCleanlogs
))){
print $NAME . " Version: " . $VERSION ."\n";
displayUsage();
exit(STATE_UNKNOWN);
}
if(defined($version)){ print $NAME . "\nVersion: ". $VERSION . "\n"; }
# Check storcli tool
if(!defined($storcli)){
if($platform eq 'linux' || $platform eq 'solaris'){
$storcli = which('storcli');
if(!defined($storcli)){
$storcli = which('storcli64');
}
if(!defined($storcli)){
if(-x '/opt/MegaRAID/storcli/storcli64'){
$storcli = '/opt/MegaRAID/storcli/storcli64';
}
}
if(!defined($storcli)){
if(-x '/opt/MegaRAID/storcli/storcli'){
$storcli = '/opt/MegaRAID/storcli/storcli';
}
}
}
else{
$storcli = which('storcli.exe');
if(!defined($storcli)){
$storcli = which('storcli64.exe');
}
}
}
if(!defined($storcli)){
print "Error: cannot find storcli executable.\n";
print "Ensure storcli is in your path, or use the '-p <storcli path>' switch!\n";
exit(STATE_UNKNOWN);
}
if($platform eq 'linux' || $platform eq 'solaris') {
if(!defined($noSudo)){
my $sudo;
chomp($sudo = `which sudo`);
if(!defined($sudo)){
print "Error: cannot find sudo executable.\n";
exit(STATE_UNKNOWN);
}
if($> != 0){
$storcli = $sudo.' '.$storcli;
}
}
}
# Print storcli version if available
if(defined($version)){ displayVersion($storcli) }
# Prepare storcli command
$storcli .= " /c$CONTROLLER";
# Check if the controller number can be used
if(!getControllerTime($storcli)){
print "Error: invalid controller number, controller not found!\n";
exit(STATE_UNKNOWN);
}
# Prepare command line arrays
@enclosures = split(/,/,join(',', @enclosures));
@logDevices = split(/,/,join(',', @logDevices));
@physDevices = split(/,/,join(',', @physDevices));
# Check if the BBU param is correct
if(($bbu != 1) && ($bbu != 0)) {
print "Error: invalid BBU/CV parameter, must be 0 or 1!\n";
exit(STATE_UNKNOWN);
}
# Check if the GasGauge param is correct
if(($gasg != 1) && ($gasg != 0)) {
print "Error: invalid GasGauge parameter, must be 0 or 1!\n";
exit(STATE_UNKNOWN);
}
my ($bbuPresent,$cvPresent) = (0,0);
if($bbu == 1){
($bbuPresent,$cvPresent) = checkBBUorCVIsPresent($storcli);
if($bbuPresent == 0 && $cvPresent == 0){
${$statusLevel_a[0]} = 'Critical';
push @{$criticals_a}, 'BBU/CV_Present';
$statusLevel_a[3]->{'BBU_Status'} = 'Critical';
$statusLevel_a[3]->{'CV_Status'} = 'Critical';
}
}
if($bbuPresent == 1){getBBUStatus($storcli, \@statusLevel_a, $verboseCommands_a, $gasg); }
if($cvPresent == 1){ getCVStatus($storcli, \@statusLevel_a, $verboseCommands_a); }
my $controllerToCheck = getControllerInfo($storcli, $noCleanlogs, $verboseCommands_a);
my $LDDevicesToCheck = getLogicalDevices($storcli, \@logDevices, 'all', $verboseCommands_a);
my $LDInitToCheck = getLogicalDevices($storcli, \@logDevices, 'init', $verboseCommands_a);
my $PDDevicesToCheck = getPhysicalDevices($storcli, \@enclosures, \@physDevices, 'all', $verboseCommands_a);
my $PDInitToCheck = getPhysicalDevices($storcli, \@enclosures, \@physDevices, 'initialization', $verboseCommands_a);
my $PDRebuildToCheck = getPhysicalDevices($storcli, \@enclosures, \@physDevices, 'rebuild', $verboseCommands_a);
getControllerStatus(\@statusLevel_a, $controllerToCheck);
getLDStatus(\@statusLevel_a, $LDDevicesToCheck);
getLDStatus(\@statusLevel_a, $LDInitToCheck);
getPDStatus(\@statusLevel_a, $PDDevicesToCheck);
getPDStatus(\@statusLevel_a, $PDInitToCheck);
getPDStatus(\@statusLevel_a, $PDRebuildToCheck);
# If desired, clean up the logs created by storcli
# This is done per default
if(!defined($noCleanlogs)){
if(-f 'MegaSAS.log'){ unlink 'MegaSAS.log'}
if(-f 'CmdTool.log'){ unlink 'CmdTool.log'}
}
print ${$statusLevel_a[0]}." ";
print getStatusString("Critical",\@statusLevel_a);
print getStatusString("Warning",\@statusLevel_a);
my $perf_str = getPerfString(\@statusLevel_a);
if($perf_str){
print "|".$perf_str;
}
print "\n";
if($VERBOSITY == 2 || $VERBOSITY == 3){
print "\n".getVerboseString(\@statusLevel_a, $controllerToCheck, $LDDevicesToCheck, $LDInitToCheck,
$PDDevicesToCheck, $PDInitToCheck, $PDRebuildToCheck)
}
$exitCode = STATE_OK;
if(${$statusLevel_a[0]} eq "Critical"){
$exitCode = STATE_CRITICAL;
}
if(${$statusLevel_a[0]} eq "Warning"){
$exitCode = STATE_WARNING;
}
exit($exitCode);
}