← Back to branch summary

~ubuntu-branches/ubuntu/precise/nagios-plugins/precise-proposed

« back to all changes in this revision

Viewing changes to contrib/check_remote_nagios_status.pl

  • Committer: Bazaar Package Importer
  • Author(s): Guido Trotter
  • Date: 2004-06-15 15:37:48 UTC
  • Revision ID: james.westby@ubuntu.com-20040615153748-pq7702qdzghqfcns
Tags: upstream-1.3.1.0
Import upstream version 1.3.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/check_remote_nagios_status.pl
 
1
#!/usr/bin/perl -w
 
2
 
 
3
# check_status.pl Nagios Plugin - Version 1.3
 
4
# Last Updated: 1/9/2003
 
5
#
 
6
# Report any bugs/questions to Russell Scibetti at russell@quadrix.com
 
7
#
 
8
# check_status Change Log:
 
9
#
 
10
# To do for 1.4
 
11
# - Better help and documentation (separate doc?)
 
12
# - Take argument (patterns to match) from a separate spec file
 
13
#
 
14
# New Addition to 1.3
 
15
# - Added ChangeLog information and updated --help output
 
16
# - hostdown (hd) argument for how a service check should respond
 
17
#   when its host is Down/Unreachable
 
18
#   (--hostdown="ok|warning|critical|unknown")
 
19
# - Changed name from check_state to check_status
 
20
# - Set hostdown to default to OK when the argument isn't specified
 
21
# - Number of Hosts checked is now output in OK result
 
22
#
 
23
# Version 1.2 additions:
 
24
#
 
25
# - Added ability to handle ack'd and downtimed services differently 
 
26
#   depending on argument provided 
 
27
#   (--ack="ok|warning|critical|unknown|down|unreachable" 
 
28
#    --dt="ok|warning|critical|unknown|down|unreachable")
 
29
#
 
30
# Version 1.1 additions:
 
31
#
 
32
# - Added --host=<regex>, --servhost=<regex> to allow for specific field
 
33
#   matching (host for matching hostname in host checks, servhost for
 
34
#   matching the hostname in service checks, service for matching the 
 
35
#   service name in service checks)
 
36
# - Output the number of OK services for an OK output
 
37
#
 
38
# Version 1.0 features:
 
39
#
 
40
# - Freshness check of status.log (timestamp) 
 
41
# - Match service or host checks
 
42
# - Can ignore acknowledged or downtimes services/hosts (--ack, --dt)
 
43
# - Can output different levels of detail dependent on # of problems
 
44
# - Can check for number of critical, warning, or unknowns
 
45
#
 
46
#############################################################
 
47
 
 
48
use Getopt::Long;
 
49
use File::stat;
 
50
 
 
51
Getopt::Long::Configure('bundling');
 
52
 
 
53
GetOptions
 
54
        ("V"   => \$version,    "version"       => \$version,
 
55
         "h"   => \$help,       "help"          => \$help,
 
56
         "v"   => \$verbose,    "verbose"       => \$verbose,
 
57
         "w=s" => \$warning,    "warning=s"     => \$warning,
 
58
         "c=s" => \$critical,   "critical=s"    => \$critical,
 
59
         "u=s" => \$unknown,    "unknown=s"     => \$unknown,
 
60
         "p=s" => \$pattern,    "pattern=s"     => \$pattern,
 
61
         "S:s" => \$service,    "service:s"     => \$service,
 
62
         "s=s" => \$status,     "status=s"      => \$status,
 
63
         "d=s" => \$dir,        "dir=s"         => \$dir,
 
64
         "D=s" => \$details,    "details=s"     => \$details,
 
65
         "H:s" => \$host,       "host:s"        => \$host,
 
66
         "f=s" => \$freshness,  "freshness=s"   => \$freshness,
 
67
                                "servhost=s"    => \$servhost,
 
68
         "a:s" => \$ack,        "ack:s"         => \$ack,
 
69
         "dt:s"=> \$dt,         "downtime:s"    => \$dt,
 
70
         "hd:s"=> \$hdown,      "hostdown:s"    => \$hdown,
 
71
                                "ok"            => \$ok);
 
72
 
 
73
#Constants:
 
74
my $OK       = 0;
 
75
my $WARNING  = 1;
 
76
my $CRITICAL = 2;
 
77
my $UNKNOWN  = 3;
 
78
 
 
79
my $crit="CRITICAL";
 
80
my $warn="WARNING";
 
81
my $unk="UNKNOWN";
 
82
my $down="DOWN";
 
83
my $unreach="UNREACHABLE";
 
84
 
 
85
# Print out Help information
 
86
if ($help) {
 
87
  printVersion();
 
88
  printHelp();
 
89
  exitcheck($UNKNOWN);
 
90
}
 
91
 
 
92
# Print out version information
 
93
if ($version) {
 
94
  printVersion();
 
95
  exitcheck($UNKNOWN);
 
96
}
 
97
 
 
98
# Check for status log or directory argument or print usage
 
99
if (!$status) {
 
100
  if (!$dir) {
 
101
    print "Usage: $0 -s <status file> | -d <Nagios log dir>\n";
 
102
    print "Use the --help option for full list of arguments\n";
 
103
    exitcheck($UNKNOWN);
 
104
  }
 
105
  elsif ($dir =~ m#[^/]/$#) {
 
106
    $status = $dir . "status.log";
 
107
  }
 
108
  else {
 
109
    $status = $dir . "/status.log";
 
110
  }
 
111
}
 
112
 
 
113
if (defined $host) {
 
114
  if (!$host) {
 
115
    $host="[^\\s]*";
 
116
  }
 
117
}
 
118
 
 
119
if (!$host && !$servhost) {
 
120
  $servhost="[^\\s]*";
 
121
}
 
122
 
 
123
if (!$host && !$service) {
 
124
  $service="[^\\s]*";
 
125
}
 
126
 
 
127
if (defined $ack) {
 
128
  if (!$ack) {
 
129
    $ack="ok";
 
130
  }
 
131
  elsif (!($ack =~ "ok|critical|warning|unknown|down|unreachable")) {
 
132
    print "Invalid value for ack\n";
 
133
    exitcheck($UNKNOWN);
 
134
  }
 
135
}
 
136
 
 
137
if (defined $dt) {
 
138
  if (!$dt) {
 
139
    $dt="ok";
 
140
  }
 
141
  elsif (!($dt =~ "ok|critical|warning|unknown|down|unreachable")) {
 
142
    print "Invalid value for dt\n";
 
143
    exitcheck($UNKNOWN);
 
144
  }
 
145
}
 
146
 
 
147
if (defined $hdown) {
 
148
  if (!$hdown) {
 
149
    $hdown="ok";
 
150
  }
 
151
  elsif (!($hdown =~ "ok|critical|warning|unknown|down|unreachable")) {
 
152
    print "Invalid value for hostdown\n";
 
153
    exitcheck($UNKNOWN);
 
154
  }
 
155
}
 
156
 
 
157
my $much_details = 0;
 
158
 
 
159
my $ServiceNotOK = "CRITICAL|WARNING|UNKNOWN";
 
160
my $HostNotOK    = "DOWN|UNREACHABLE";
 
161
 
 
162
my %numprob = ("WARNING",0,"CRITICAL",0,"UNKNOWN",0,"DOWN",0,"UNREACHABLE",0);
 
163
 
 
164
my $CritOnly = 0;
 
165
my $WarnOnly = 0;
 
166
my $UnkOnly  = 0;
 
167
 
 
168
my @wlev;
 
169
my @clev;
 
170
my @ulev;
 
171
my %warnlevel = ("WARNING",0,"CRITICAL",0,"UNKNOWN",0);
 
172
my %critlevel = ("WARNING",0,"CRITICAL",0,"UNKNOWN",0);
 
173
my %unklevel = ("WARNING",0,"CRITICAL",0,"UNKNOWN",0);
 
174
my %hostlevel = ("DOWN",0,"UNREACHABLE",0);
 
175
 
 
176
# Store Hosts in downtime
 
177
my @hostdowntime;
 
178
my $numdowntime = 0;
 
179
 
 
180
# Store Hosts in a Down/Unreachable state
 
181
my @hostdown;
 
182
my $numdown = 0;
 
183
 
 
184
# Hash for storing state-change to OK times for hosts:
 
185
my %hostoktimes;
 
186
 
 
187
# Number of matches in parsing
 
188
my $nummatch = 0;
 
189
 
 
190
if ($warning) {
 
191
  if ($warning =~ /,/) {
 
192
    @wlev = split /,/,$warning;
 
193
    $warnlevel{"WARNING"} = $wlev[0];
 
194
    $warnlevel{"CRITICAL"} = $wlev[1];
 
195
    if ($wlev[2] ) {
 
196
      $warnlevel{"UNKNOWN"} = $wlev[2];
 
197
    }
 
198
  }
 
199
  else {
 
200
    $WarnOnly = $warning;
 
201
  }
 
202
}
 
203
else {
 
204
  $WarnOnly = 1;
 
205
}
 
206
 
 
207
if ($critical) {
 
208
  if ($critical =~ /,/) {
 
209
    @clev = split /,/,$critical;
 
210
    $critlevel{"WARNING"} = $clev[0];
 
211
    $critlevel{"CRITICAL"} = $clev[1];
 
212
    if ($clev[2] ) {
 
213
      $critlevel{"UNKNOWN"} = $clev[2];
 
214
    }
 
215
  }
 
216
  else {
 
217
    $CritOnly = $critical;
 
218
  }
 
219
}
 
220
else {
 
221
  $CritOnly = 1;
 
222
}
 
223
  
 
224
if ($unknown) {
 
225
  if ($unknown =~ /,/) {
 
226
    @ulev = split /,/,$unknown;
 
227
    $unklevel{"WARNING"} = $ulev[0];
 
228
    $unklevel{"CRITICAL"} = $ulev[1];
 
229
    if ($ulev[2] ) {
 
230
      $unklevel{"UNKNOWN"} = $ulev[2];
 
231
    }
 
232
  }
 
233
  else {
 
234
    $UnkOnly = $unknown;
 
235
  }
 
236
}
 
237
else {
 
238
  $UnkOnly = 1;
 
239
}
 
240
 
 
241
 
 
242
if (!$freshness) {
 
243
  $freshness = 30 * 60;
 
244
}
 
245
else {
 
246
  $freshness = $freshness * 60;
 
247
}
 
248
 
 
249
my %ct = ("CRITICAL",0,"WARNING",0,"UNKNOWN",0,"DOWN",0,"UNREACHABLE",0);
 
250
my %much_ct = ("CRITICAL",0,"WARNING",0,"UNKNOWN",0,"DOWN",0,"UNREACHABLE",0);
 
251
 
 
252
my %output = ("CRITICAL","","WARNING","","UNKNOWN","","DOWN","","UNREACHABLE","");
 
253
my %much_output = ("CRITICAL","","WARNING","","UNKNOWN","","DOWN","","UNREACHABLE","");
 
254
 
 
255
if ($details) {
 
256
  if ($details =~ /,/) {
 
257
    my @tempv = split /,/,$details;
 
258
    $much_details = $tempv[0];
 
259
    $details = $tempv[1]; 
 
260
  }
 
261
}
 
262
 
 
263
open("sta","$status") || die "Cannot open status file $status!";
 
264
 
 
265
$curr_time = time;
 
266
$file_time = stat($status)->mtime;
 
267
 
 
268
if ($curr_time - $file_time > $freshness) {
 
269
  printf "State CRITICAL - Status file is stale!!!\n";
 
270
  exitcheck($CRITICAL);
 
271
}
 
272
 
 
273
while(<sta>) {
 
274
  chomp;
 
275
  if (/^[^\s]+[\s]+HOST;/) {
 
276
    @hdata = split /;/,$_;
 
277
    
 
278
# If you care about matching hosts (not services):
 
279
    if ($host && $hdata[1] =~ /$host/) {
 
280
      $nummatch++;
 
281
      if ( $hdata[2] =~ /$HostNotOK/ ) {
 
282
        addproblem($_,$hdata[2]);
 
283
      }
 
284
    }
 
285
 
 
286
# If you are matching services, gather host information:
 
287
    else {
 
288
      if ( $hdata[2] =~ /$HostNotOK/ ) {
 
289
        $hostdown[$numdown] = $hdata[1];
 
290
        $numdown++;
 
291
      }
 
292
      else {
 
293
        $hostoktimes{$hdata[1]} = $hdata[4];
 
294
      }
 
295
      if ( $hdata[17] ne "0" ) {
 
296
        $hostdowntime[$numdowntime] = $hdata[1];
 
297
        $numdowntime++;
 
298
      }
 
299
    }
 
300
  }
 
301
  elsif (!$host && /^[^\s]+[\s]+SERVICE;/) {
 
302
    @servdata = split /;/,$_;
 
303
    if ( ( $pattern                     && ($_ =~ /$pattern/)) ||
 
304
         (($servdata[1] =~ /$servhost/) && ($servdata[2] =~ /$service/)) ){
 
305
      $nummatch++;
 
306
      if (($servdata[5] eq "HARD") && ($servdata[3] =~ /$ServiceNotOK/)) {
 
307
        addproblem($_,$servdata[3]);
 
308
      }
 
309
    }
 
310
  }
 
311
}
 
312
 
 
313
close("sta");
 
314
 
 
315
if ($nummatch==0) {
 
316
  print "Nothing Matches your criteria!\n";
 
317
  exitcheck($UNKNOWN);
 
318
}
 
319
 
 
320
# Count the number of problems (for reference):
 
321
if ($host) {
 
322
  $total = $numprob{"DOWN"} + $numprob{"UNREACHABLE"};
 
323
} 
 
324
else {
 
325
  $total = $numprob{"WARNING"} + $numprob{"CRITICAL"} +  $numprob{"UNKNOWN"};
 
326
}
 
327
 
 
328
my $numok = $nummatch - $total;
 
329
 
 
330
# If this is a host state check:
 
331
if ($host) {
 
332
  if ($numprob{"DOWN"}>0 || $numprob{"UNREACHABLE"}>0 ) {
 
333
    if  ($details && ($total <= $details)) {
 
334
      print "State CRITICAL - $total Host Problems: $output{$down} $output{$unreach}\n";
 
335
      exitcheck($CRITICAL);
 
336
    }
 
337
    else {
 
338
      print "State CRITICAL - $numprob{$down} Hosts Down, $numprob{$unreach} Hosts Unreachable\n";
 
339
      exitcheck($CRITICAL);
 
340
    }
 
341
  }
 
342
  else {
 
343
    print "State OK - $numok Hosts Up, $total Problems\n";
 
344
    exitcheck($OK);
 
345
  }
 
346
}
 
347
 
 
348
#If you only defined a Critical level in terms of # of criticals...
 
349
elsif ($CritOnly && ($numprob{"CRITICAL"} >= $CritOnly)) {
 
350
  countAndPrint($crit,$numprob{$crit},0);
 
351
  exitcheck($CRITICAL);
 
352
}    
 
353
 
 
354
#Critical in terms on # criticals and # warnings...
 
355
elsif (!$CritOnly && ($numprob{"WARNING"}  >= $critlevel{"WARNING"}  || 
 
356
                      $numprob{"CRITICAL"} >= $critlevel{"CRITICAL"} ||
 
357
                      $numprob{"UNKNOWN"}  >= $critlevel{"UNKNOWN"} )) {
 
358
  countAndPrint($crit,$total,1);
 
359
  exitcheck($CRITICAL);
 
360
}
 
361
 
 
362
#Warning in terms of # warnings only...
 
363
elsif ($WarnOnly && ($numprob{"WARNING"} >= $WarnOnly)) {
 
364
  countAndPrint($warn,$numprob{$warn},0);
 
365
  exitcheck($WARNING);
 
366
}
 
367
 
 
368
#Warning in terms of # warnings and # criticals...
 
369
elsif (!$WarnOnly && ($numprob{"WARNING"}  >= $warnlevel{"WARNING"} || 
 
370
                      $numprob{"CRITICAL"} >= $warnlevel{"CRITICAL"} ||
 
371
                      $numprob{"UNKNOWN"}  >= $warnlevel{"UNKNOWN"})) {
 
372
  countAndPrint($warn,$total,1);
 
373
  exitcheck($WARNING);
 
374
}
 
375
 
 
376
#Unknown in terms on # unknown only...
 
377
elsif ( $UnkOnly && ($numprob{"UNKNOWN"}>=$UnkOnly) ) {
 
378
  countAndPrint($unk,$numprob{$unk},0);
 
379
  exitcheck($UNKNOWN);
 
380
}
 
381
 
 
382
#Unknown in terms of # warning, critical, and unknown...
 
383
elsif (!$UnkOnly && ($numprob{"WARNING"}  >= $unklevel{"WARNING"} ||
 
384
                     $numprob{"CRITICAL"} >= $unklevel{"CRITICAL"} ||
 
385
                     $numprob{"UNKNOWN"}  >= $unklevel{"UNKNOWN"})) {
 
386
  countAndPrint($unk,$total,1);
 
387
  exitcheck($UNKNOWN);
 
388
}
 
389
 
 
390
# Everything is OK!
 
391
else {
 
392
  print "State OK -  $numok OK, $total problems\n";
 
393
  exitcheck($OK);
 
394
}
 
395
 
 
396
 
 
397
 
 
398
############################
 
399
# Subroutines
 
400
############################
 
401
 
 
402
# Return the proper exit code for Critical, Warning, Unknown, or OK
 
403
sub exitcheck {
 
404
  if ($ok) {
 
405
    exit 0;
 
406
  }
 
407
  else {
 
408
    exit $_[0];
 
409
  }
 
410
} 
 
411
 
 
412
# Decide what to print for services:
 
413
sub countAndPrint {
 
414
  my $state = $_[0];
 
415
  my $count = $_[1];
 
416
  my $alltypes = $_[2];
 
417
  my $output = "State $state - ";
 
418
 
 
419
  if ($details) {
 
420
    if ($count<=$much_details) {
 
421
      if ($alltypes) {
 
422
        $output .= "$count problems: $much_output{$crit} $much_output{$warn} $much_output{$unk}";
 
423
      }
 
424
      else {
 
425
        $output .= "$count \L$state\E: $much_output{$state}";
 
426
      }
 
427
    }
 
428
    elsif ($count<=$details) {
 
429
      if ($alltypes) {
 
430
        $output .= "$count problems: $output{$crit} $output{$warn} $output{$unk}";
 
431
      }
 
432
      else {
 
433
        $output .= "$count \L$state\E: $output{$state}";
 
434
      }
 
435
    }
 
436
    else {
 
437
      if ($alltypes) {
 
438
        $output .= "$numprob{$crit} critical, $numprob{$warn} warning, $numprob{$unk} unknown";
 
439
      }
 
440
      else {
 
441
        $output .= "$count \L$state\E"; 
 
442
      }
 
443
    }
 
444
  }
 
445
  else {
 
446
    $output .= "$count problems";
 
447
  }
 
448
 
 
449
  print "$output\n";
 
450
}
 
451
  
 
452
 
 
453
# Add-in the problem found in the status log
 
454
sub addproblem {
 
455
 
 
456
  $test = 1;
 
457
  $type = $_[1];
 
458
  my $diffout = "";
 
459
 
 
460
  my @values = split /;/,$_[0];
 
461
 
 
462
  if (!$host) {
 
463
    my $namehold = $values[1];
 
464
    if ($ack && ($values[13] eq "1")) {
 
465
      if ($ack =~ "ok") {
 
466
        $test = 0;
 
467
      }
 
468
      else {
 
469
        $type = "\U$ack";
 
470
      }
 
471
    }
 
472
    elsif ($hdown && grep /$namehold/, @hostdown) {
 
473
      if ($hdown =~ "ok") {
 
474
        $test = 0;
 
475
      }
 
476
      else {
 
477
        $type = "\U$hdown";
 
478
        $diffout = "$values[1] is down";
 
479
      }
 
480
    }
 
481
    elsif ($dt && (($values[27] ne "0") || (grep /$namehold/, @hostdowntime))){
 
482
      if ($dt =~ "ok") {
 
483
        $test = 0;
 
484
      }
 
485
      else {
 
486
        $type = "\U$dt";
 
487
      }
 
488
    }
 
489
    elsif (exists $hostoktimes{$namehold}) {
 
490
      # If the state change time of the host is more recent than the last
 
491
      # service check, must wait until the next service check runs!
 
492
      if ($hostoktimes{$namehold} > $values[6]) {
 
493
        $test = 0;
 
494
      }
 
495
    }
 
496
  }
 
497
  else {
 
498
    if ($ack && $values[5]) { 
 
499
      if ($ack =~ "ok") {
 
500
        $test = 0;
 
501
      }
 
502
      else {
 
503
        $type = "\U$ack";
 
504
      }
 
505
    }
 
506
    elsif ($dt && ($values[17] ne "0")) {
 
507
      if ($dt =~ "ok") {
 
508
        $test = 0;
 
509
      }
 
510
      else {
 
511
        $type = "\U$dt";
 
512
      }
 
513
    }
 
514
  }
 
515
 
 
516
  if ($details && $test) {
 
517
    if (!$host) {
 
518
      if ($diffout) {
 
519
        $much_output{$type} .= " $diffout;";
 
520
        $output{$type} .= "$diffout;";
 
521
        $much_ct{$type}++;
 
522
        $ct{$type}++;
 
523
      }
 
524
      else {
 
525
        if ($much_details && $much_ct{$type}<$much_details) {
 
526
          $much_output{$type} .= " $values[2] on $values[1] $values[31];";
 
527
          $much_ct{$type}++;
 
528
        }
 
529
        if ($ct{$type} < $details) {
 
530
          $output{$type} .= " $values[2] on $values[1];";
 
531
          $ct{$type}++;
 
532
        }
 
533
      }
 
534
    }  
 
535
    else {
 
536
        $much_output{$type} .= " $values[1] $_[1] $values[20],";
 
537
        $much_ct{type}++;
 
538
        $output{$type} .= " $values[1] HOST $_[1],";
 
539
        $ct{$type}++;
 
540
    }
 
541
  }
 
542
  if ($test) {
 
543
    $numprob{$type}++;
 
544
  }
 
545
}
 
546
 
 
547
################################
 
548
#
 
549
# Version and Help Information
 
550
#
 
551
################################
 
552
 
 
553
sub printVersion {
 
554
  printf <<EndVersion;
 
555
$0 (nagios-plugins) 1.3
 
556
The nagios plugins come with ABSOLUTELY NO WARRANTY. You may redistribute
 
557
copies of the plugins under the terms of the GNU General Public License.
 
558
For more information about these matters, see the file named COPYING.
 
559
EndVersion
 
560
}
 
561
 
 
562
sub printHelp {
 
563
  printf <<EOF;
 
564
 
 
565
This plugin parses through the Nagios status log and will return a 
 
566
Critical, Warning, or Unknown state depending on the number of 
 
567
Critical, Warning, and/or Unknown services found in the log
 
568
(or Down/Unreachable hosts when matching against hosts)  
 
569
 
 
570
Usage: $0 -s <Status File> | -d <Nagios Log Directory> 
 
571
        [-w #[,#][,#]] [-c #[,#][,#]] [-u #[,#][,#]]
 
572
        [--service=<RegEx> | --servhost=<RegEx> | --pattern=<RegEx> |
 
573
         --host            | --host=<RegEx>]
 
574
        [--ack[=string]]  [--dt[=string]]  [--hostdown[=string]]
 
575
        [-D #[,#]]  [--ok]  [-f <Log freshness in # minutes>]
 
576
       $0 --help
 
577
       $0 --version
 
578
NOTE: One of -s and -d must be specified
 
579
 
 
580
Options:
 
581
 -s, --status=FILE_NAME
 
582
   Location and name of status log (e.g. /usr/local/nagios/var/status.log)
 
583
 -d, --dir=DIRECTORY_NAME
 
584
   Directory that contains the nagios logs (e.g. /usr/local/nagios/var/)
 
585
 -w, --warning=INTEGER[,INTEGER][,INTEGER]
 
586
   #:     Number of warnings to result in a WARNING state
 
587
          OR
 
588
   #,#:   Warning,Criticals to result in a WARNING state
 
589
          OR
 
590
   #,#,#: Warning,Critical,Unknown to result in a WARNING state 
 
591
   Default: -w=1
 
592
 -c, --critical=INTEGER[,INTEGER][,INTEGER]
 
593
   #:     Number of criticals to result in a CRITICAL state
 
594
          OR
 
595
   #,#:   Warning,Criticals to result in a CRITICAL state
 
596
          OR
 
597
   #,#,#: Warning,Critical,Unknown to result in a CRITICAL state
 
598
   Default: -c=1
 
599
 -u, --unknown=INTEGER[,INTEGER][,INTEGER]
 
600
   #:     Number of unknowns to result in a UNKNOWN state
 
601
          OR
 
602
   #,#:   Warning,Criticals to result in a UNKNOWN state
 
603
          OR
 
604
   #,#,#: Warning,Critical,Unknown to result in a UNKNOWN state
 
605
   Default: -u=1
 
606
 -r, --service[=REGEX]
 
607
   Only match services [that match the RegEx]
 
608
   (--service is default setting if no other matching arguments provided)
 
609
 --servhost=REGEX
 
610
   Only match services whose host match the RegEx
 
611
 -p, --pattern=REGEX
 
612
   Only parse for this regular expression (services only, not hosts)
 
613
 --host[=REGEX]
 
614
   Report on the state of hosts (whose name matches the RegEx if provided)
 
615
 -a, --ack[=ok|warning|critical|unknown|down|unreachable]
 
616
   Handle Acknowledged problems [--ack defaults to ok]
 
617
 --dt, --downtime[=ok|warning|critical|unknown|down|unreachable]
 
618
   Handle problems in scheduled downtime [--dt defaults to ok]
 
619
 --hd, --hostdown[=ok|warning|critical|unknown|down|unreachable]
 
620
   Handle services whose Host is down [--hd defaults to ok]
 
621
 -D, --details=INTEGER[,INTEGER]
 
622
   Amount of verbosity to output
 
623
   If # problems: 
 
624
    <= 1st integer, return full details (each plugin's output) 
 
625
    <= 2nd integer, return some details (list each service host pair)
 
626
    >  2nd integer, return the # of problems
 
627
 -f, --freshness=INTEGER
 
628
   Number of minutes old the log can be to make sure Nagios is running
 
629
   (Default = 30 minutes)
 
630
 --ok
 
631
   Return an OK exit code, regardless of number of problems found
 
632
 -h, --help
 
633
   Print detailed help screen
 
634
 -V, --version
 
635
   Print version information 
 
636
 
 
637
For service checking (use --service and/or --servhost): 
 
638
1.  The values of warning, critical, and unknown default to 1, i.e.
 
639
$0 will return CRITICAL if there is at least 1 critical service, 
 
640
WARNING if there is at least 1 warning service, and UNKNOWN if there is
 
641
at least one unknown service.
 
642
 
 
643
2.  If a service's host is DOWN or UNREACHABLE, $0 will use the 
 
644
value of --hostdown to determine how to treat the service.  Without that
 
645
argument, $0 will count the service as OK.
 
646
 
 
647
3.  If a service's host is OK, but the last host-state change occurred more 
 
648
recently than the last service check, $0 will ignore that service
 
649
(want to wait until the service has been checked after a host has recovered
 
650
or you may get service alert for services that still need to be checked)
 
651
 
 
652
4.  If the --dt, --ack, or --hd tags are used, $0 will use the value
 
653
of the arguments to determine how to handle services in downtime, acknowledged,
 
654
or with down hosts (default=OK). For service checks, --dt will also check
 
655
if the service's host is in a downtime.
 
656
 
 
657
For host checking (use --host):
 
658
1.  Using the --host argument, $0 will look for DOWN and UNREACHABLE
 
659
hosts.  If any are found, $0 will return a CRITICAL.  You can provide
 
660
an REGEX for --host to only check hosts with matching host names. 
 
661
 
 
662
2.  If the --dt or --ack tags are used, $0 will use the value of the
 
663
--dt/--ack arguments to determine the state of the host (default is OK)
 
664
 
 
665
EOF
 
666
}