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

Diff for /nagios/check_bioctl/check_bioctl between version 1.6 and 1.15

version 1.6, 2009/11/09 17:58:29 version 1.15, 2009/11/23 22:24:45
Line 1 
Line 1 
 #!/usr/bin/perl -T  #!/usr/bin/perl -T
 # $RedRiver: check_bioctl,v 1.5 2009/11/09 17:57:32 andrew Exp $  # $RedRiver: check_bioctl,v 1.14 2009/11/23 21:58:04 andrew Exp $
 ########################################################################  ########################################################################
 # check_bioctl *** A nagios check for OpenBSD bioctl  # check_bioctl *** A nagios check for OpenBSD bioctl
 #  #
 # 2006.07.26 #*#*# andrew fresh <andrew@mad-techies.org>  # 2006.07.26 #*#*# andrew fresh <andrew@afresh1.com>
 ########################################################################  ########################################################################
 # TODO:  
 #   Really need real documentation.  
 ########################################################################  
 use strict;  use strict;
 use warnings;  use warnings;
   
 %ENV = ();  local %ENV = ();
   
 use constant NAGIOS_OUTPUT => 1;  my $NAGIOS_OUTPUT = 0;
   
   my $License = <<'EOL';
   Copyright (c) 2009 Andrew Fresh <andrew@afresh1.com>
   Permission to use, copy, modify, and distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.
   
   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   EOL
   
   my $PROGNAME = 'check_bioctl';
   my $BIOCTL   = '/sbin/bioctl';
   
 use POSIX;  use POSIX;
 use lib "/usr/local/libexec/nagios";  my $PREFIX;
 use utils qw($TIMEOUT %ERRORS &print_revision &support);  
   
   BEGIN {
       ## no critic 'warnings'
       no warnings 'uninitialized';
       $PREFIX = "${PREFIX}" || '/usr/local';    # Magic for OpenBSD ports tree
   }
   use lib $PREFIX . '/libexec/nagios';
   use utils qw($TIMEOUT %ERRORS &support);
   
   $SIG{'ALRM'} = sub {
       print "ERROR: $PROGNAME timeout\n";
       exit $ERRORS{'UNKNOWN'};
   };
   alarm($TIMEOUT);
   
 use Getopt::Long;  use Getopt::Long;
 Getopt::Long::Configure('bundling');  Getopt::Long::Configure('bundling');
   
 my $PROGNAME = "check_bioctl";  
 my $BIOCTL = '/sbin/bioctl';  
   
 # This maps the status we get from bioctl to something nagios can use  # This maps the status we get from bioctl to something nagios can use
 my %Status_Map = (  my %Status_Map = (
         Online      => 'OK',      Online      => 'OK',
         Offline     => 'CRITICAL',      Offline     => 'CRITICAL',
         Degraded    => 'CRITICAL',      Degraded    => 'CRITICAL',
         Failed      => 'CRITICAL',      Failed      => 'CRITICAL',
         Building    => 'WARNING',      Building    => 'WARNING',
         Rebuild     => 'WARNING',      Rebuild     => 'WARNING',
         'Hot spare' => 'OK',      'Hot spare' => 'OK',
         Unused      => 'OK',      Unused      => 'OK',
         Scrubbing   => 'WARNING',      Scrubbing   => 'WARNING',
         Invalid     => 'CRITICAL',      Invalid     => 'CRITICAL',
 );  );
   
   
 my $state = 'UNKNOWN'; # tells whether the it is warning, critical, or OK  
 my %states; # This stores the count of states;  
 my @devices;  my @devices;
 my $opt_h;  my $opt_h;
 my $opt_V;  my $opt_V;
   
 #Option checking  #Option checking
 my $status = GetOptions(  my $status = GetOptions(
         "version|V"    => \$opt_V,      "version|V"  => \$opt_V,
         "help|h"       => \$opt_h,      "help|h"     => \$opt_h,
         "device|d=s"   => \@devices,      "device|d=s" => \@devices,
 );  );
   
 if ($status == 0) {  if ( $status == 0 ) {
         print_help() ;      print_help();
         exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 if ($opt_V) {  if ($opt_V) {
         print_revision($PROGNAME,'$Revision$ ');      print_revision( $PROGNAME, '$Revision$ ' );
         exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 if ($opt_h || not @devices) {  if ( $opt_h || !@devices ) {
         print_help();      print_help();
         exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 my %VOLUMES;  my %VOLUMES = read_bioctl( \@devices );
 foreach my $device (@devices) {  my %STATES  = check_status( \%VOLUMES );
         open my $bioctl, "-|", $BIOCTL, $device or die "Couldn't open bioctl: $!";  
         my $volume_id;  
   
         while (<$bioctl>) {  my $have_results = 0;
                 chomp;  my $state        = 'OK';
                 # Do these by columns cuZ that is the easiest for now  foreach my $error ( sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS ) {
                 my @o = unpack("A6 A1 A11 A15 A7 A9 A*",  $_);      if ( exists $STATES{$error} ) {
                 next if $o[0] eq 'Volume';          $have_results++;
           $state = $error if $ERRORS{$state} < $ERRORS{$error};
   
                 foreach (@o) {          if ($NAGIOS_OUTPUT) {
                         s/^\s+//;              print "$error (" . scalar( @{ $STATES{$error} } ) . ")";
                         s/\s+$//;              if ( $error ne 'OK' ) {
                 }                  print '<br>';
                   print map {" - $_<br>"} @{ $STATES{$error} };
               }
           }
           else {
               print "$error (" . scalar( @{ $STATES{$error} } ) . "):\n";
               print map {"    $_\n"} @{ $STATES{$error} };
           }
       }
   }
   if ( $have_results == 0 ) {
       print "No results found\n";
   }
   exit $ERRORS{$state};
   
                 my ($controller, $id, $status, $size, $dev, $details, $name) = @o;  sub read_bioctl {
                 my $index = $id;      my ($devices) = @_;
                 if ($controller) {      my %volumes;
                         $volume_id  = $id;  
                 } else {  
                         $index = "$volume_id.$id";  
                 }  
   
                 $VOLUMES{$device}{$index} = {      foreach my $d ( @{$devices} ) {
                         type       => 'volume',          open my $bioctl, q{-|}, $BIOCTL, $d
                         controller => $controller,              or die "Couldn't open bioctl: $!\n";
                         id         => $id,      LINE: while ( my $line = <$bioctl> ) {
                         status     => $status,              my ( $i, $item ) = parse_bioctl_line($line);
                         size       => $size,              next LINE if !defined $i;
                         device     => $dev,              $volumes{$d}{$i} = $item;
                         details    => $details,          }
                         name       => $name,          ## no critic 'die'
                 };          close $bioctl
               or die $!
               ? "Error closing bioctl pipe: $!\n"
               : "Exit status $? from bioctl \n";
       }
   
                 if ($dev =~ /^\d+:\d+/) {      foreach my $d ( keys %volumes ) {
                         $VOLUMES{$device}{$index}{'volume'} =          foreach my $i ( keys %{ $volumes{$d} } ) {
                                 $VOLUMES{$device}{$volume_id};              my $item = $volumes{$d}{$i};
                 }              if ( $item->{device} =~ /^\d+:\d+/xms ) {
                   $item->{'volume'} = $volumes{$d}{ $item->{volume_id} };
               }
           }
       }
   
         }      return %volumes;
         close $bioctl;  
 }  }
   
 foreach my $device (sort keys %VOLUMES) {  {
         foreach my $index (sort keys %{ $VOLUMES{$device} }) {      my $vid;
                 my $cur_state = $Status_Map{ $VOLUMES{$device}{$index}{'status'} } ?      my $controller;
                         $Status_Map{ $VOLUMES{$device}{$index}{'status'} } :  
                         'UNKNOWN';  
   
                 if ($VOLUMES{$device}{$index}{'device'} =~ /^\d+:\d/) {      sub parse_bioctl_line {
                         push @{ $states{$cur_state} }, sprintf("%5s %-7s %-11s %s",          my ($line) = @_;
                                 $VOLUMES{$device}{$index}{'volume'}{'controller'},          chomp $line;
                                 $VOLUMES{$device}{$index}{'device'},  
                                 $VOLUMES{$device}{$index}{'status'},          # Do these by columns cuZ that is the easiest for now
                                 $VOLUMES{$device}{$index}{'name'}          my @o = unpack( "A6 A1 A11 A15 A7 A9 A*", $line );
                         );          return if $o[0] eq 'Volume';
                 } else {  
                         push @{ $states{$cur_state} }, sprintf("%5s %-7s %s",          foreach (@o) {
                                 $VOLUMES{$device}{$index}{'controller'},              s/^\s+//xms;
                                 $VOLUMES{$device}{$index}{'device'},              s/\s+$//xms;
                                 $VOLUMES{$device}{$index}{'status'}          }
                         );  
                 }          my ( $c, $id, $status, $size, $dev, $details, $name ) = @o;
         }          my $index = $id;
           if ($c) {
               $vid        = $id;
               $controller = $c;
           }
           else {
               $index = "$vid.$id";
           }
   
           return $index,
               {
               controller => $controller,
               id         => $id,
               status     => $status,
               size       => $size,
               device     => $dev,
               details    => $details,
               name       => $name,
               volume_id  => $vid,
               };
       }
 }  }
   
 my $have_results = 0;  sub check_status {
 foreach my $error (sort { $ERRORS{$b} <=> $ERRORS{$a} } keys %ERRORS) {      my ($volumes) = @_;
         if (exists $states{$error}) {  
                 $have_results++;  
         $state = $error if $ERRORS{$state} < $ERRORS{$error};  
   
                 if (NAGIOS_OUTPUT) {      my %states;
                         print "$error (" . scalar(@{ $states{ $error } }) . ")";      foreach my $d ( sort keys %{$volumes} ) {
                         unless ($error eq 'OK') {          foreach my $i ( sort { $a <=> $b } keys %{ $volumes->{$d} } ) {
                                 print '<br>';              my $volume = $volumes->{$d}->{$i};
                                 print map { " - $_<br>" } @{ $states{ $error } };              my $state = $Status_Map{ $volume->{'status'} } || 'UNKNOWN';
                         }  
                 } else {              push @{ $states{$state} },
                         print "$error (" . scalar(@{ $states{ $error } }) . "):\n";                  sprintf(
                         print map { "    $_\n" } @{ $states{ $error } };                  "%5s %-7s %-11s %s",
                 }                  $volume->{'controller'}, $volume->{'device'},
         }                  $volume->{'status'},     $volume->{'name'}
                   );
           }
       }
       return %states;
 }  }
 if ($have_results == 0) {  
         print "No results found\n";  
 }  
 exit $ERRORS{$state};  
   
 sub print_help {  sub print_help {
         print <<EOL;      print <<"EOL";
 $PROGNAME plugin for Nagios monitors bioctl on OpenBSD  $PROGNAME plugin for Nagios monitors bioctl on OpenBSD
     $PROGNAME -d <device> [ -d <device2> [ -d ... ] ]      $PROGNAME -d <device> [ -d <device2> [ -d ... ] ]
   
Line 170 
Line 222 
         -V (--version)    version information          -V (--version)    version information
   
 EOL  EOL
   
         print_revision($PROGNAME, '$Revision$');      print_revision( $PROGNAME, '$Revision$' );
   
       print $License;
   
       return 1;
 }  }
   
   sub print_revision {
       my ( $prog, $rev ) = @_;
       $rev =~ s/^\D+([\d\.]+)\D+$/v$1/xms;
   
       print "$prog $rev\n";
   
       return 1;
   }
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.15
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>