[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.1 and 1.6

version 1.1, 2006/07/27 01:02:43 version 1.6, 2009/11/09 17:58:29
Line 1 
Line 1 
 #!/usr/bin/perl -T  #!/usr/bin/perl -T
 # $RedRiver$  # $RedRiver: check_bioctl,v 1.5 2009/11/09 17:57:32 andrew Exp $
 ########################################################################  ########################################################################
 # check_bioctl *** A nagios check for OpenBSD bioctl  # check_bioctl *** A nagios check for OpenBSD bioctl
 #  #
Line 11 
Line 11 
 use strict;  use strict;
 use warnings;  use warnings;
   
 #use Data::Dumper;  
   
 %ENV = ();  %ENV = ();
   
 use constant NAGIOS_OUTPUT => 1;  use constant NAGIOS_OUTPUT => 1;
Line 27 
Line 25 
 my $PROGNAME = "check_bioctl";  my $PROGNAME = "check_bioctl";
 my $BIOCTL = '/sbin/bioctl';  my $BIOCTL = '/sbin/bioctl';
   
   # This maps the status we get from bioctl to something nagios can use
 my %Status_Map = (  my %Status_Map = (
         Online      => 'OK',          Online      => 'OK',
         Offline     => 'WARNING',          Offline     => 'CRITICAL',
         Degraded    => 'CRITICAL',          Degraded    => 'CRITICAL',
         Failed      => 'CRITICAL',          Failed      => 'CRITICAL',
         Building    => 'WARNING',          Building    => 'WARNING',
Line 43 
Line 42 
   
 my $state = 'UNKNOWN'; # tells whether the it is warning, critical, or OK  my $state = 'UNKNOWN'; # tells whether the it is warning, critical, or OK
 my %states; # This stores the count of states;  my %states; # This stores the count of states;
 my $device;  my @devices;
 my $opt_h;  my $opt_h;
 my $opt_V;  my $opt_V;
   
Line 51 
Line 50 
 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"   => \$device,          "device|d=s"   => \@devices,
 );  );
   
 if ($status == 0) {  if ($status == 0) {
Line 64 
Line 63 
         exit $ERRORS{'OK'};          exit $ERRORS{'OK'};
 }  }
   
 if ($opt_h || not $device) {  if ($opt_h || not @devices) {
         print_help();          print_help();
         exit $ERRORS{'OK'};          exit $ERRORS{'OK'};
 }  }
   
 my %DISKS;  
 my %VOLUMES;  my %VOLUMES;
 open my $bioctl, "-|", $BIOCTL, $device or die "Couldn't open bioctl: $!";  foreach my $device (@devices) {
 my $volume_id;          open my $bioctl, "-|", $BIOCTL, $device or die "Couldn't open bioctl: $!";
 while (<$bioctl>) {          my $volume_id;
         chomp;  
         # Do these by columns cuZ that is the easiest for now  
         # Volume  Status     Size           Device  
         my @o = unpack("A6 A1 A11 A15 A7 A9 A*",  $_);  
         next if $o[0] eq 'Volume';  
   
         foreach (@o) {          while (<$bioctl>) {
                 s/^\s+//;                  chomp;
                 s/\s+$//;                  # Do these by columns cuZ that is the easiest for now
         }                  my @o = unpack("A6 A1 A11 A15 A7 A9 A*",  $_);
                   next if $o[0] eq 'Volume';
   
         #print Dumper \@o;                  foreach (@o) {
                           s/^\s+//;
                           s/\s+$//;
                   }
   
         my ($controller, $id, $status, $size, $dev, $details, $name) = @o;                  my ($controller, $id, $status, $size, $dev, $details, $name) = @o;
                   my $index = $id;
                   if ($controller) {
                           $volume_id  = $id;
                   } else {
                           $index = "$volume_id.$id";
                   }
   
         if ($controller) {                  $VOLUMES{$device}{$index} = {
                 $volume_id = $id;                          type       => 'volume',
   
                 $VOLUMES{$volume_id} = {  
                         controller => $controller,                          controller => $controller,
                         id         => $volume_id,                          id         => $id,
                         status     => $status,                          status     => $status,
                         size       => $size,                          size       => $size,
                         device     => $dev,                          device     => $dev,
                         details    => $details,                          details    => $details,
                         name       => $name,                          name       => $name,
                   };
   
                   if ($dev =~ /^\d+:\d+/) {
                           $VOLUMES{$device}{$index}{'volume'} =
                                   $VOLUMES{$device}{$volume_id};
                 }                  }
         }  
   
         if ($dev =~ /^\d+:\d+/) {  
                 $DISKS{$volume_id}{$id} = {  
                         volume      => $VOLUMES{$volume_id},  
                         id          => $id,  
                         status      => $status,  
                         size        => $size,  
                         device      => $dev,  
                         details     => $details,  
                         name        => $name,  
                 };  
         }          }
           close $bioctl;
 }  }
 close $bioctl;  
   
 #print Dumper \%VOLUMES, \%DISKS;  foreach my $device (sort keys %VOLUMES) {
           foreach my $index (sort keys %{ $VOLUMES{$device} }) {
 foreach my $volume (sort keys %VOLUMES) {                  my $cur_state = $Status_Map{ $VOLUMES{$device}{$index}{'status'} } ?
         next if $VOLUMES{$volume}{'device'} =~ /^\d+:\d+/;                          $Status_Map{ $VOLUMES{$device}{$index}{'status'} } :
         my $cur_state = $Status_Map{ $VOLUMES{$volume}{'status'} } ?  
                 $Status_Map{ $VOLUMES{$volume}{'status'} } :  
                 'UNKNOWN';  
         push @{ $states{$cur_state} }, sprintf("%5s %-7s %s",  
                 $VOLUMES{$volume}{'controller'},  
                 $VOLUMES{$volume}{'device'},  
                 $VOLUMES{$volume}{'status'}  
         );  
 }  
   
 foreach my $volume (sort keys %DISKS) {  
         foreach my $disk (sort keys %{ $DISKS{$volume} }) {  
                 my $cur_state = $Status_Map{ $DISKS{$volume}{$disk}{'status'} } ?  
                         $Status_Map{ $DISKS{$volume}{$disk}{'status'} } :  
                         'UNKNOWN';                          'UNKNOWN';
                 push @{ $states{$cur_state} }, sprintf("%5s %-7s %-11s %s",  
                         $DISKS{$volume}{$disk}{'volume'}{'controller'},                  if ($VOLUMES{$device}{$index}{'device'} =~ /^\d+:\d/) {
                         $DISKS{$volume}{$disk}{'device'},                          push @{ $states{$cur_state} }, sprintf("%5s %-7s %-11s %s",
                         $DISKS{$volume}{$disk}{'status'},                                  $VOLUMES{$device}{$index}{'volume'}{'controller'},
                         $DISKS{$volume}{$disk}{'name'}                                  $VOLUMES{$device}{$index}{'device'},
                 );                                  $VOLUMES{$device}{$index}{'status'},
                                   $VOLUMES{$device}{$index}{'name'}
                           );
                   } else {
                           push @{ $states{$cur_state} }, sprintf("%5s %-7s %s",
                                   $VOLUMES{$device}{$index}{'controller'},
                                   $VOLUMES{$device}{$index}{'device'},
                                   $VOLUMES{$device}{$index}{'status'}
                           );
                   }
         }          }
 }  }
   
 #print Dumper \%states;  
   
 $state = 'OK';  
 my $have_results = 0;  my $have_results = 0;
 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}) {
                   $have_results++;
           $state = $error if $ERRORS{$state} < $ERRORS{$error};
   
                 if (NAGIOS_OUTPUT) {                  if (NAGIOS_OUTPUT) {
                         print "$error (" . scalar(@{ $states{ $error } }) . ")";                          print "$error (" . scalar(@{ $states{ $error } }) . ")";
                         unless ($error eq 'OK') {                          unless ($error eq 'OK') {
Line 178 
Line 161 
 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>      $PROGNAME -d <device> [ -d <device2> [ -d ... ] ]
   
 Usage:  Usage:
     -d, --device=DEVICE      -d, --device=DEVICE
         DEVICE to check.  Can either be a disk, as in sd0          DEVICE to check.  Can be any device that bioctl(8) accepts
                 or a raid card like ami0  
     -h (--help)       usage help      -h (--help)       usage help
         -V (--version)    version information          -V (--version)    version information
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.6
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>