File Coverage

blib/lib/Monitoring/Plugin.pm

Criterion	Covered	Total	%
statement	90	97	92.7
branch	28	32	87.5
condition	13	17	76.4
subroutine	21	25	84.0
pod	14	16	87.5
total	166	187	88.7

package Monitoring::Plugin;

use Monitoring::Plugin::Functions qw(:codes %ERRORS %STATUS_TEXT @STATUS_CODES);
use Params::Validate qw(:all);

use 5.006;
use strict;
use warnings;

use Carp;
use base qw(Class::Accessor::Fast);

Monitoring::Plugin->mk_accessors(qw(
								shortname
								perfdata
								messages
								opts
								threshold
								));

use Exporter;
our @ISA = qw(Exporter);
our @EXPORT = (@STATUS_CODES);
our @EXPORT_OK = qw(%ERRORS %STATUS_TEXT);

# CPAN stupidly won't index this module without a literal $VERSION here,
#   so we're forced to duplicate it explicitly
# Make sure you update $Monitoring::Plugin::Functions::VERSION too
our $VERSION = "0.38";

sub new {
	my $class = shift;
#	my %args = @_;

	my %args = validate( @_,
		{
			shortname => 0,
			usage     => 0,
			version   => 0,
			url       => 0,
			plugin    => 0,
			blurb     => 0,
			extra     => 0,
			license   => 0,
			timeout   => 0
		},
	);

	my $shortname = Monitoring::Plugin::Functions::get_shortname(\%args);
	delete $args{shortname} if (exists $args{shortname});
	my $self = {
		shortname => $shortname,
		perfdata  => [],           # to be added later
		messages  => {
			warning  => [],
			critical => [],
			ok       => []
		},
		opts      => undef,        # see below
		threshold => undef,        # defined later
	};
	bless $self, $class;
	if (exists $args{usage}) {
		require Monitoring::Plugin::Getopt;
		$self->opts( new Monitoring::Plugin::Getopt(%args) );
	}
	return $self;
}

sub add_perfdata {
    my ($self, %args) = @_;
    require Monitoring::Plugin::Performance;
    my $perf = Monitoring::Plugin::Performance->new(%args);
    push @{$self->perfdata}, $perf;
}
sub all_perfoutput {
    my $self = shift;
    return join(" ", map {$_->perfoutput} (@{$self->perfdata}));
}

sub set_thresholds {
    my $self = shift;
    require Monitoring::Plugin::Threshold;
    return $self->threshold( Monitoring::Plugin::Threshold->set_thresholds(@_));
}

# MP::Functions wrappers
sub plugin_exit {
    my $self = shift;
    Monitoring::Plugin::Functions::plugin_exit(@_, { plugin => $self });
}
sub plugin_die {
    my $self = shift;
    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
}
sub nagios_exit {
    my $self = shift;
    Monitoring::Plugin::Functions::plugin_exit(@_, { plugin => $self });
}
sub nagios_die {
    my $self = shift;
    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
}
sub die {
    my $self = shift;
    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
}
sub max_state {
    Monitoring::Plugin::Functions::max_state(@_);
}
sub max_state_alt {
    Monitoring::Plugin::Functions::max_state_alt(@_);
}

# top level interface to Monitoring::Plugin::Threshold
sub check_threshold {
	my $self = shift;

	my %args;

	if ( $#_ == 0 && (! ref $_[0] || ref $_[0] eq "ARRAY" )) {  # one positional param
		%args = (check => shift);
	}
	else {
		%args = validate ( @_, {  # named params
			check => 1,
			warning => 0,
			critical => 0,
		} );
	}

	# in order of preference, get warning and critical from
	#  1.  explicit arguments to check_threshold
	#  2.  previously explicitly set threshold object
	#  3.  implicit options from Getopts object
	if ( exists $args{warning} || exists $args{critical} ) {
		$self->set_thresholds(
			warning  => $args{warning},
			critical => $args{critical},
		);
	}
	elsif ( defined $self->threshold ) {
		# noop
	}
	elsif ( defined $self->opts ) {
		$self->set_thresholds(
			warning  => $self->opts->warning,
			critical => $self->opts->critical,
		);
	}
	else {
		return UNKNOWN;
	}

	return $self->threshold->get_status($args{check});
}

# top level interface to my Monitoring::Plugin::Getopt object
sub add_arg {
    my $self = shift;
	$self->opts->arg(@_) if $self->_check_for_opts;
}
sub getopts {
    my $self = shift;
	$self->opts->getopts(@_) if $self->_check_for_opts;
}

sub _check_for_opts {
	my $self = shift;
	croak
		"You have to supply a 'usage' param to Monitoring::Plugin::new() if you want to use Getopts from your Monitoring::Plugin object."
			unless ref $self->opts() eq 'Monitoring::Plugin::Getopt';
	return $self;
}



# -------------------------------------------------------------------------
# MP::Functions::check_messages helpers and wrappers

sub add_message {
    my $self = shift;
    my ($code, @messages) = @_;

    croak "Invalid error code '$code'"
        unless defined($ERRORS{uc $code}) || defined($STATUS_TEXT{$code});

    # Store messages using strings rather than numeric codes
    $code = $STATUS_TEXT{$code} if $STATUS_TEXT{$code};
    $code = lc $code;
    croak "Error code '$code' not supported by add_message"
        if $code eq 'unknown' || $code eq 'dependent';

    $self->messages($code, []) unless $self->messages->{$code};
    push @{$self->messages->{$code}}, @messages;
}

sub check_messages {
    my $self = shift;
    my %args = @_;

    # Add object messages to any passed in as args
    for my $code (qw(critical warning ok)) {
        my $messages = $self->messages->{$code} || [];
        if ($args{$code}) {
            unless (ref $args{$code} eq 'ARRAY') {
                if ($code eq 'ok') {
                    $args{$code} = [ $args{$code} ];
                } else {
                    croak "Invalid argument '$code'"
                }
            }
            push @{$args{$code}}, @$messages;
        }
        else {
            $args{$code} = $messages;
        }
    }

    Monitoring::Plugin::Functions::check_messages(%args);
}

# -------------------------------------------------------------------------

1;

#vim:et:sw=4

__END__