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

Diff for /nagios/check_openbgpd/check_openbgpd between version 1.3 and 1.13

version 1.3, 2009/11/19 19:52:51 version 1.13, 2024/06/10 00:09:20
Line 1 
Line 1 
 #!/usr/bin/perl -T  #!/usr/bin/perl -T
 # $RedRiver: check_openbgpd,v 1.2 2009/11/13 22:23:24 andrew Exp $  # $AFresh1: check_openbgpd,v 1.12 2024/06/09 23:02:37 afresh1 Exp $
 ########################################################################  ########################################################################
 # check_openbgpd *** A nagios check for OpenBSD bgpd  # check_openbgpd *** A nagios check for OpenBSD bgpd
 #  #
Line 9 
Line 9 
 use warnings;  use warnings;
   
 use 5.010;  use 5.010;
   use if $] >= 5.016, experimental => 'switch';
   
 local %ENV = ();  local %ENV = ();
   
 my $NAGIOS_OUTPUT = 1;  my $NAGIOS_OUTPUT = 1;
   
 my $LICENSE = <<'EOL';  my $LICENSE = <<'EOL';
 Copyright (c) 2009 Andrew Fresh <andrew@afresh1.com>  Copyright (c) 2009-2024 Andrew Fresh <andrew@afresh1.com>
 Permission to use, copy, modify, and distribute this software for any  Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above  purpose with or without fee is hereby granted, provided that the above
 copyright notice and this permission notice appear in all copies.  copyright notice and this permission notice appear in all copies.
Line 56 
Line 57 
     exit $ERRORS{'OK'};      exit $ERRORS{'OK'};
 }  }
   
 my @STATUS = read_status();  my @STATUS = read_status( $CHECKS{_SOCKET} );
 my %STATES = check_status( \@STATUS, \%CHECKS );  my %STATES = check_status( \@STATUS, \%CHECKS );
   
 my $have_results = 0;  my $have_results = 0;
Line 89 
Line 90 
 exit $ERRORS{$state};  exit $ERRORS{$state};
   
 sub read_status {  sub read_status {
     my ($status) = @_;      my ($socket) = @_;
     my @S;      my @S;
   
     #open my $fh, '<', 'output'    # XXX      my @cmd = ($BGPCTL);
     open my $fh, '-|', $BGPCTL, 'show', 'summary'      if ($socket) {
         or die "Couldn't open bgpctl: $!\n";          push @cmd, '-s', $socket;
       }
       push @cmd, 'show', 'summary';
   
       #open my $fh, '<', 'output' or die $!; # XXX
       open my $fh, '-|', @cmd or die "Couldn't open bgpctl: $!\n";
     while (<$fh>) {      while (<$fh>) {
         chomp;          chomp;
         push @S, parse_line($_);          push @S, parse_line($_);
Line 128 
Line 134 
 sub parse_check {  sub parse_check {
     my $check = shift;      my $check = shift;
   
     return { match => [] } unless $check;      unless ($check) {
           print_help();
           exit $ERRORS{'OK'}
       }
   
     my @values = split /,\s*/xms, $check;      my @values = split /,\s*/xms, $check;
   
     my %c = ( match => [] );      my %c = ( match => [] );
Line 157 
Line 167 
     my ( $S, $C ) = @_;      my ( $S, $C ) = @_;
   
     my %states;      my %states;
     my %neighbors;      my %neighbors = map { $_ => $C->{$_} } qw( _SOCKET _UNKNOWN );
 STATE: foreach my $s ( @{$S} ) {  STATE: foreach my $s ( @{$S} ) {
         my $n = $s->{neighbor};          my $n = $s->{neighbor};
         $neighbors{$n} = $s;          $neighbors{$n} = $s;
   
         my $result;          my $result;
   
         if ( my $c = $C->{$n} ) {          if ( my $c = $C->{$n} || $C->{_UNKNOWN} ) {
         CODE: foreach my $code ( 'CRITICAL', 'WARNING' ) {          CODE: foreach my $code ( 'CRITICAL', 'WARNING' ) {
                 next CODE if ( ref $c->{$code} ne 'HASH' );                  next CODE if ( ref $c->{$code} ne 'HASH' );
                 my $data = $s->{state};                  my $data = $s->{state};
Line 215 
Line 225 
             return 'State (' . $d . ') is not numeric';              return 'State (' . $d . ') is not numeric';
         }          }
   
     DIRECTION: foreach my $dir qw( low high ) {      DIRECTION: foreach my $dir (qw( low high )) {
             if ( !$c->{$dir} ) { next DIRECTION; }              if ( !$c->{$dir} ) { next DIRECTION; }
   
             my $check = $c->{$dir};              my $check = $c->{$dir};
Line 258 
Line 268 
         state( $w, $c );          state( $w, $c );
   
         my $opt = shift @argv;          my $opt = shift @argv;
         given ($opt) {          for ($opt) {
             when ( '-V' || '--version' ) {              if ( $_ eq '-V' || $_ eq '--version' ) {
                 print_revision( $PROGNAME, '$Revision$ ' );                  print_revision( $PROGNAME, '$Revision$ ' );
                 exit $ERRORS{'OK'}                  exit $ERRORS{'OK'}
             }              }
             when (/^-?-h(?:elp)?/xms)     { print_help(); exit $ERRORS{'OK'} }              elsif (/^-?-h(?:elp)?\Z/xms) { print_help(); exit $ERRORS{'OK'} }
             when (/^-?-w(?:arning)?/xms)  { $w = parse_check( shift @argv ) }              elsif (/^-?-s(?:ocket)?\Z/xms) {
             when (/^-?-c(?:ritical)?/xms) { $c = parse_check( shift @argv ) }                  $checks{_SOCKET} = shift @argv
             when (/^-?-n(?:eighbor)?/xms) {                      || do { print_help(); exit $ERRORS{'OK'} }
               }
               elsif (/^-?-w(?:arning)?\Z/xms)  { $w = parse_check( shift @argv ) }
               elsif (/^-?-c(?:ritical)?\Z/xms) { $c = parse_check( shift @argv ) }
               elsif (/^-?-u(?:nknown)?\Z/xms) {
                   $checks{_UNKNOWN} = {
                       WARNING  => $w,
                       CRITICAL => $c,
                   };
               }
               elsif (/^-?-n(?:eighbor)?\Z/xms) {
                 while ( @argv && $argv[0] !~ /^-/xms ) {                  while ( @argv && $argv[0] !~ /^-/xms ) {
                     $checks{ shift @argv } = {                      $checks{ shift @argv } = {
                         WARNING      => $w,                          WARNING  => $w,
                             CRITICAL => $c                          CRITICAL => $c,
                     }                      };
                 }                  }
             }              }
             default { print_help(); exit $ERRORS{'UNKNOWN'} }              else { print_help(); exit $ERRORS{'UNKNOWN'} }
         }          }
     }      }
     return %checks;      return %checks;
Line 283 
Line 303 
 sub print_help {  sub print_help {
     print <<"EOL";      print <<"EOL";
 $PROGNAME - checks status of OpenBGPd peers  $PROGNAME - checks status of OpenBGPd peers
     $PROGNAME [ -w ENTRY ][ -c ENTRY ][ -n NEIGHBOR [ NEIGHBOR2 ] ]      $PROGNAME [ -s SOCKET ][ -w ENTRY ][ -c ENTRY ]( -u | -n NEIGHBOR )
   
 Usage:  Usage:
       -s, --socket SOCKET
           Path to bgpd socket to use. See -r in bgpd(8).
     -w, --warning RANGE or single ENTRY      -w, --warning RANGE or single ENTRY
         Exit with WARNING status if outside of RANGE or if != ENTRY          Exit with WARNING status if outside of RANGE or if != ENTRY
           May be entered multiple times.
     -c, --critical RANGE or single ENTRY      -c, --critical RANGE or single ENTRY
         Exit with CRITICAL status if outside of RANGE or if != ENTRY          Exit with CRITICAL status if outside of RANGE or if != ENTRY
           May be entered multiple times.
     -n, --neighbor NEIGHBOR      -n, --neighbor NEIGHBOR
         The name of the Neighbor          The name of the Neighbor, can be a space separated list of neighbors.
           May be entered multiple times.
       -u, --unknown
           As if you specified -n for all unknown neighbors
   
 ENTRY is a comma separated list of items to match against.  Each item can be  ENTRY is a comma separated list of items to match against.  Each item can be
 a RANGE or it will just be matched against the status.  a RANGE or it will just be matched against the status.
Line 312 
Line 339 
 the output causes a CRITICAL result.  the output causes a CRITICAL result.
   
 Any time a NEIGHBOR that is NOT specified on the command line shows up in the  Any time a NEIGHBOR that is NOT specified on the command line shows up in the
 output causes a CRITICAL result.  output causes a CRITICAL result.  If -u is specified, it treats NEIGHBOR as if
   it were specified at that position.
   
   
 $PROGNAME -w 10:300 -c 10:500 -n P1 P2 -n P3  
   
 CRITICAL  
     If any of P1, P2, P3 are below 10, above 500 or any non-numeric value.  
   
 WARNING  
     If any of P1, P2, P3 are above 300.  
   
   
 $PROGNAME -c Idle -n P1 -c 1:1 -n P2 -w 200:300 -c Active,10: -n P3  $PROGNAME -c Idle -n P1 -c 1:1 -n P2 -w 200:300 -c Active,10: -n P3
   
 CRITICAL  CRITICAL
Line 335 
Line 354 
     If P3 is above 10 and below 200 or above 300.      If P3 is above 10 and below 200 or above 300.
   
   
 $PROGNAME -n P1 -w 50%:70% -c 10%:90% -n P2 P3  $PROGNAME -u -w 50%:70% -c 10%:90% -n P2 P3
   
 No checks on P1  No checks of unknown neighbors.
   
 CRITICAL  CRITICAL
     If P2 or P3 do not have max-prefix set or if they do but learned prefixes      If P2 or P3 do not have max-prefix set or if they do but learned prefixes
     are below 10% or above 90% of max-prefix.      are below 10% or above 90% of max-prefix or any non-numeric value.
   
 WARNING  WARNING
     If P2 or P3 have learned prefixes below 50% or above 90% of max-prefix.      If P2 or P3 have learned prefixes below 50% or above 70% of max-prefix.
   
   
   $PROGNAME -w 50%:70% -c 10%:90% -u
   
   CRITICAL
       If any neighbor does not have max-prefix set or if they do but learned
       prefixes are below 10% or above 90% of max-prefix or any non-numeric value.
   
   WARNING
       If any neighbor have learned prefixes below 50% or above 70% of max-prefix.
   
 EOL  EOL
   
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.13
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>