[BACK]Return to check_hw_sensors CVS log [TXT][DIR] Up to [local] / nagios / check_hw_sensors

Diff for /nagios/check_hw_sensors/check_hw_sensors between version 1.4 and 1.11

version 1.4, 2006/05/02 16:54:42 version 1.11, 2006/05/03 21:01:09
Line 1 
Line 1 
 #!/usr/bin/perl  #!/usr/bin/perl
 # $RedRiver: check_hw_sensors,v 1.3 2006/05/02 01:39:23 andrew Exp $  # $RedRiver: check_hw_sensors,v 1.10 2006/05/03 03:31:22 andrew Exp $
 ########################################################################  ########################################################################
 # check_hw_sensors *** A nagios check for OpenBSD hw.sensors  # check_hw_sensors *** A nagios check for OpenBSD hw.sensors
 #  #
Line 14 
Line 14 
 use strict;  use strict;
 use warnings;  use warnings;
   
 #use Data::Dumper;  use Data::Dumper;
   
 use constant NAGIOS_OUTPUT => 1;  use constant NAGIOS_OUTPUT => 0;
   
 use POSIX;  use POSIX;
 use lib "/usr/local/libexec/nagios";  use lib "/usr/local/libexec/nagios";
 #use lib $ENV{'HOME'};  
 use utils qw($TIMEOUT %ERRORS &print_revision &support);  use utils qw($TIMEOUT %ERRORS &print_revision &support);
   
 use Getopt::Long;  use Getopt::Long;
Line 39 
Line 38 
 my $sensor;  my $sensor;
 my $warning;  my $warning;
 my $critical;  my $critical;
 my $opt_h ;  my $opt_h;
 my $opt_V ;  my $opt_V;
   
 my $CHECK_SENSOR = $BASE;  my $CHECK_SENSOR = $BASE;
 my %CHECKS;  my %CHECKS;
Line 75 
Line 74 
 }  }
   
 unless ( (  unless ( (
                 defined $filename ||                  defined $filename ||
                 (defined $sensor && ($warning || $critical))                  (defined $sensor && ($warning || $critical))
          ) &&           ) &&
                 ( (!defined $filename) || (!defined $sensor) )           ( (!defined $filename) || (!defined $sensor) )
 ) {  ) {
         print_help();          print_help();
         exit $ERRORS{'OK'};          exit $ERRORS{'OK'};
Line 140 
Line 139 
                 push @{ $states{ $r } },                  push @{ $states{ $r } },
                         $check . '=' . $SENSORS{$check}{'output'};                          $check . '=' . $SENSORS{$check}{'output'};
         } else {          } else {
                 # XXX Error missing sensor  
                 push @{ $states{'UNKNOWN'} }, $check . '=No sensor with this id';                  push @{ $states{'UNKNOWN'} }, $check . '=No sensor with this id';
         }          }
 }  }
Line 148 
Line 146 
 #print Dumper \%states;  #print Dumper \%states;
   
 $state = 'OK';  $state = 'OK';
 if (NAGIOS_OUTPUT) {  my $have_results = 0;
         print '<ul>';  foreach my $error (sort { $ERRORS{$a} <=> $ERRORS{$b} } keys %ERRORS) {
           if (exists $states{$error}) {
                   $have_results++;
                   $state = $error;
           }
 }  }
 foreach my $error (sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS) {  foreach my $error (sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS) {
         if (exists $states{$error}) {          if (exists $states{$error}) {
                 if (NAGIOS_OUTPUT) {                  if (NAGIOS_OUTPUT) {
                         print "<li>$error (" . scalar(@{ $states{ $error } }) . "):<ul>";                          print "$error (" . scalar(@{ $states{ $error } }) . ")";
                         foreach (@{ $states{ $error } }) {                          unless ($error eq 'OK') {
                                 print "<li>$_</li>";                                  print '<br>';
                                   print map { " - $_<br>" } @{ $states{ $error } };
                         }                          }
                         print "</ul></li>"  
                 } else {                  } else {
                         print "$error (" . scalar(@{ $states{ $error } }) . "):\n";                          print "$error (" . scalar(@{ $states{ $error } }) . "):\n";
                         foreach (@{ $states{ $error } }) {                          foreach (@{ $states{ $error } }) {
Line 167 
Line 169 
                 }                  }
         }          }
 }  }
 if (NAGIOS_OUTPUT) {  if ($have_results == 0) {
         print '</ul>' . "\n";          print "No results found\n";
 }  }
 foreach my $error (sort { $ERRORS{$a} <=> $ERRORS{$b} } keys %ERRORS) {  
         if (exists $states{$error}) {  
                 $state = $error;  
         }  
 }  
 exit $ERRORS{$state};  exit $ERRORS{$state};
   
   
Line 201 
Line 198 
         my $type  = shift;          my $type  = shift;
         my $check = shift;          my $check = shift;
   
         if (defined $check->{'warn'} && $check->{'warn'} =~ /:/) {          foreach my $code ('crit', 'warn') {
                 if (my ($low, $high) = split /:/, $check->{'warn'}) {                  if (defined $check->{$code} && $check->{$code} =~ /:/) {
                         $check->{'warn.low'}  = $low;                          if (my ($low, $high) = split /:/, $check->{$code}) {
                         $check->{'warn.high'} = $high;                                  $check->{$code . '.low'}  = $low;
                                   $check->{$code . '.high'} = $high;
                           }
                           delete $check->{$code};
                 }                  }
                 delete $check->{'warn'};  
         }                  foreach my $severity ('low', 'high') {
         if (defined $check->{'crit'} && $check->{'crit'} =~ /:/) {                          if (defined $check->{$severity}) {
                 if (my ($low, $high) = split /:/, $check->{'crit'}) {                                  $check->{ $code . '.' . $severity } = $check->{$severity}
                         $check->{'crit.low'}  = $low;                                          unless defined $check->{ $code . '.' . $severity };
                         $check->{'crit.high'} = $high;                          }
                 }                  }
                 delete $check->{'crit'};                  no warnings 'uninitialized';
                   $check->{$code} = [ split /,\s*/, $check->{$code} ];
         }          }
   
         if (defined $check->{'low'}) {  
                 $check->{'warn.low'} = $check->{'low'}  
                         unless defined $check->{'warn.low'};  
                 $check->{'crit.low'} = $check->{'low'}  
                         unless defined $check->{'crit.low'};  
         }  
         if (defined $check->{'high'}) {  
                 $check->{'warn.high'} = $check->{'high'}  
                         unless defined $check->{'warn.high'};  
                 $check->{'crit.high'} = $check->{'high'}  
                         unless defined $check->{'crit.high'};  
         }  
   
         no warnings 'uninitialized';  
         $check->{'warn'} = [ split /,\s*/, $check->{'warn'} ];  
         $check->{'crit'} = [ split /,\s*/, $check->{'crit'} ];  
   
         return $check;          return $check;
 }  }
   
Line 294 
Line 278 
                                         $result = $errors{$code}                                          $result = $errors{$code}
                                                 if ($c <= $data);                                                  if ($c <= $data);
                                 }                                  }
                         } elsif (defined $check->{$code}) {                          } elsif (@{ $check->{$code} }) {
                                 my $matched = 0;                                  my $matched = 0;
                                 foreach my $c (@{ $check->{$code} }) {                                  foreach my $c (@{ $check->{$code} }) {
                                         $c =~ s/[^\d\.]//g;                                          $c =~ s/[^\d\.]//g;
                                         unless (length $c) {                                          unless (length $c) {
                                                 warn "INVALID CHECK (" . $check->{$code} .                                                  warn "INVALID CHECK (" . $c .
                                                       ") for '$sensor->{'id'}:$code'";                                                        ") for '$sensor->{'id'}:$code'";
                                                 next;                                                  next;
                                         }                                          }
Line 362 
Line 346 
                                         $result = $errors{$code}                                          $result = $errors{$code}
                                                 if ($c <= $data);                                                  if ($c <= $data);
                                 }                                  }
                         } elsif (defined $check->{$code}) {                          } elsif (@{ $check->{$code} }) {
   
                                 my $matched = 0;                                  my $matched = 0;
                                 foreach my $c (@{ $check->{$code} }) {                                  foreach my $c (@{ $check->{$code} }) {
Line 377 
Line 361 
   
                                         $c =~ s/[^\d\.]//g;                                          $c =~ s/[^\d\.]//g;
                                         unless (length $c) {                                          unless (length $c) {
                                                 warn "INVALID CHECK (" . $check->{$code} .                                                  warn "INVALID CHECK (" . $c .
                                                          ") for '$sensor->{'id'}':$code";                                                           ") for '$sensor->{'id'}':$code";
                                                 next;                                                  next;
                                         }                                          }
Line 394 
Line 378 
                         $sensor->{'type'} eq 'drive' ||                          $sensor->{'type'} eq 'drive' ||
                         $sensor->{'type'} eq 'indicator'                          $sensor->{'type'} eq 'indicator'
                 ) {                  ) {
                         if (defined $check->{$code}) {                          if (@{ $check->{$code} }) {
                                 my $matched = 0;                                  my $matched = 0;
                                 foreach (@{ $check->{$code} }) {                                  foreach (@{ $check->{$code} }) {
                                         if ($_ eq $sensor->{'data'}) {                                          if ($_ eq $sensor->{'data'}) {
Line 435 
Line 419 
         low, high, crit, warn, crit.low, crit.high, warn.low, warn.high          low, high, crit, warn, crit.low, crit.high, warn.low, warn.high
   
 An ENTRY depends on the type.  The descriptions in sensorsd.conf(5) can be used when appropriate, or you can use the following:  An ENTRY depends on the type.  The descriptions in sensorsd.conf(5) can be used when appropriate, or you can use the following:
         volts_dc, fanrpm or raw - Anything that includes digits.  Anything that isn't a digit or period is stripped from the entry and the sensor output and they are compared.          volts_dc, fanrpm or raw - Anything that includes digits.  Both the value of the check and the value of the sensor response that are not either a digit or period are stripped and then the two resultant values are compared.
         temp - Can be as above, but if the entry has an F in it, it compares farenheit, otherwise it uses celcius.          temp - Can be as above, but if the entry has an F in it, it compares farenheit, otherwise it uses celcius.
         indicator or drive - does a case sensitive match of each entry in the comma separated list and if it does not match any of the entries, it matches the status.          indicator or drive - does a case sensitive match of each entry in the comma separated list and if it does not match any of the entries, it matches the status.
   
 The entries 'crit' or 'warn' (or the -c or -w on the command line) may be a RANGE or a comma separated list of acceptable values.  The comma separated list of values contains a list of things that will NOT cause the status.  This is possibly counterintuitive, but you are more likely to know good values than bad values.  The entries 'crit' or 'warn' (or the -c or -w on the command line) may be a RANGE or a comma separated list of acceptable values.  The comma separated list of values contains a list of things that will NOT cause the status.  This is possibly counterintuitive, but you are more likely to know good values than bad values.
   
 A RANGE is a low ENTRY and a high ENTRY separated by a colon (:).  A RANGE is a low ENTRY and a high ENTRY separated by a colon (:).  It can also be low: or :high with the other side left blank to only make the single check..
   
 EOL  EOL
   
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.11
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>