File Coverage

lib/Nagios/Cmd.pm

Criterion	Covered	Total	%
statement	51	67	76.1
branch	13	26	50.0
condition	2	6	33.3
subroutine	12	14	85.7
pod	5	8	62.5
total	83	121	68.6

###########################################################################
#                                                                         #
# Nagios::Cmd                                                             #
# Written by Albert Tobey                                #
# Copyright 2003, Albert P Tobey                                          #
#                                                                         #
# This program is free software; you can redistribute it and/or modify it #
# under the terms of the GNU General Public License as published by the   #
# Free Software Foundation; either version 2, or (at your option) any     #
# later version.                                                          #
#                                                                         #
# This program is distributed in the hope that it will be useful, but     #
# WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       #
# General Public License for more details.                                #
#                                                                         #
###########################################################################
package Nagios::Cmd;
use vars qw( $AUTOLOAD $debug %commands );
use Fcntl qw( :flock SEEK_END O_WRONLY );
use Symbol;
use Carp;
$debug = undef;

%commands = (
    ADD_HOST_COMMENT => [qw(host persistent author comment)],
    ADD_SVC_COMMENT => [qw(host service persistent author comment)],
    DEL_HOST_COMMENT => [qw(comment_id)],
    DEL_ALL_HOST_COMMENTS => [qw(host)],
    DEL_SVC_COMMENT => [qw(comment_id)],
    DEL_ALL_SVC_COMMENTS => [qw(host service)],
    DELAY_HOST_NOTIFICATION => [qw(host next_notification_time)],
    DELAY_SVC_NOTIFICATION => [qw(host service next_check_time)],
    SCHEDULE_HOST_SVC_CHECKS => [qw(host next_check_time)],
    ENABLE_SVC_CHECKS => [qw(host service)],
    DISABLE_SVC_CHECKS => [qw(host service)],
    ENABLE_SVC_NOTIFICATIONS => [qw(host service)],
    DISABLE_SVC_NOTIFICATIONS => [qw(host service)],
    ENABLE_HOST_SVC_NOTIFICATIONS => [qw(host)],
    DISABLE_HOST_SVC_NOTIFICATIONS => [qw(host)],
    ENABLE_HOST_SVC_CHECKS => [qw(host)],
    DISABLE_HOST_SVC_CHECKS => [qw(host)],
    ENABLE_HOST_NOTIFICATIONS => [qw(host)],
    DISABLE_HOST_NOTIFICATIONS => [qw(host)],
    ENABLE_ALL_NOTIFICATIONS_BEYOND_HOST  => [qw(host)],
    DISABLE_ALL_NOTIFICATIONS_BEYOND_HOST => [qw(host)],
    ENABLE_NOTIFICATIONS => [qw(time)],
    DISABLE_NOTIFICATIONS => [qw(time)],
    SHUTDOWN_PROGRAM => [qw(time)],
    RESTART_PROGRAM => [qw(time)],
    PROCESS_SERVICE_CHECK_RESULT => [qw(host service return_code plugin_output)],
    PROCESS_HOST_CHECK_RESULT => [qw(host return_code plugin_output)],
    SAVE_STATE_INFORMATION => [qw(time)],
    READ_STATE_INFORMATION => [qw(time)],
    START_EXECUTING_SVC_CHECKS => undef,
    STOP_EXECUTING_SVC_CHECKS => undef,
    START_ACCEPTING_PASSIVE_SVC_CHECKS => undef,
    STOP_ACCEPTING_PASSIVE_SVC_CHECKS => undef,
    ENABLE_PASSIVE_SVC_CHECKS => [qw(host service)],
    DISABLE_PASSIVE_SV_CHECKS => [qw(host service)],
    ACKNOWLEDGE_SVC_PROBLEM => [qw(host service persistent comment)],
    ACKNOWLEDGE_HOST_PROBLEM => [qw(host persistent comment)]
);

sub nagios_cmd {
    my( $self, $cmd ) = @_;

    # there can be only one "\n" and this function is used for passing through
    # custom commands, too
    chomp( $cmd );

    my $fh = gensym;
    # cannot open in append mode, since that causes a seek
    sysopen( $fh, $$self, O_WRONLY )
        || croak "could not sysopen $$self for writing: $!";

    flock $fh, LOCK_EX;
    # only seek to end of file on regular files
    seek( $fh, 0, SEEK_END ) if ( -f $$self );
    print $fh "$cmd\n";
    flock $fh, LOCK_UN;
    close $fh;
}

sub new {
    my( $type, $cmdfile ) = @_;
    croak "$cmdfile does not exist!" unless ( -e $cmdfile );
    croak "$cmdfile is not a pipe!"  unless ( -p $cmdfile );
    return bless \$cmdfile, $type;
}

# allow use of any file instead of a fifo (great for testing)
sub new_anyfile {
    my( $type, $cmdfile ) = @_;
    return bless \$cmdfile, $type;
}

# host service return_code plugin_output
sub service_check {
    shift->nagios_cmd( "[".time()."] ". join(";", process_args('PROCESS_SERVICE_CHECK_RESULT',@_)) );
}

# host return_code plugin_output
sub host_check {
    shift->nagios_cmd( "[".time()."] ". join(";", process_args('PROCESS_HOST_CHECK_RESULT',@_)) );
}

sub DESTROY { 1 }

sub AUTOLOAD {
    my $self = shift;

    $AUTOLOAD =~ m/Nagios::Cmd::(\w+)$/;
    my $method = $1;

    print "method $method called with arguments: '", join(', ', @_), "'\n"
        if ( $debug );

    confess "invalid method call '$method'"
        unless ( exists($commands{$method}) );

    # process method arguments to allow hash, hashref, or list
    my @command = process_args( $method, @_ );

    # get the current time for the command's timestamp
    my $time = '[' . time() . '] ';

    print "writing '", $time, join(';', @command), "' to command file ...\n"
        if ( $debug );

    # write to the command pipe
    $self->nagios_cmd( $time . join(';', @command) );
}

sub process_args {
    my( $method, @input ) = @_;
    my @command = ();

    # a few commands take no arguments, so skip this block of code in that case
    if ( defined($commands{$method}) ) {
        # get the list of expected argument keys
        my @parts = @{ $commands{$method} };

        # call to method used named parameters - put them into a hashref
        # and use the hashref parsing to do the rest
        if ( @input > @parts && @input % 2 == 0 ) {
            my %tmp = @input;
            @input = ( \%tmp );
        }

	    # process hashed arguments
	    if ( ref($input[0]) eq 'HASH' ) {
	        my $args = shift(@input);
	        for ( my $i=0; $i<=$#parts; $i++ ) {
	            if ( !exists($args->{$parts[$i]}) ) {
	                croak "insufficient arguments to $method - '$parts[$i]' argument is missing";
                }
	            else {
	                $command[$i + 1] = $args->{$parts[$i]};
	            }
	        }
	    }

	    # user sent us a list (presumably) already in the right order
	    else {
            splice( @command, @command, 0, @input );
	    }
    }

    # run through and resolve Nagios::Object objects into their textual names
    # name() is a Nagios::Object specific method for doing polymorphic stuff
    # like this
    foreach ( @command ) {
        if ( ref $_ =~ /^Nagios::/ && $_->can('name') ) {
            $_ = $_->name;
        }
    }

    unshift( @command, $method );
    return @command;
}

sub Help {
    my $func = shift;

    if ( !$func ) {
        foreach my $cmd ( keys(%commands) ) {
            print "$cmd(", join(', ', @{$commands{$cmd}}), ")\n";
        }
    }
    else {
        print "$func(", join(', ', @{$commands{$func}}), ")\n";
    }
}

sub Commands {
    return \%commands;
}

1;

__END__