File Coverage

blib/lib/Net/RDEP.pm

Criterion	Covered	Total	%
statement	44	241	18.2
branch	7	100	7.0
condition	2	45	4.4
subroutine	11	23	47.8
pod	11	11	100.0
total	75	420	17.8

# Net::RDEP.pm
#
# $Id: RDEP.pm,v 1.1 2004/12/23 12:05:58 jminieri Exp $
#
# Copyright (c) 2004 Joe Minieri  and OpenService (www.open.com).
# All rights reserved.
# This program is free software; you can redistribute it and/or modify it under the same
# terms as Perl itself.
#

package Net::RDEP;

use 5.006001;
use strict;
use warnings;

use MIME::Base64;
use LWP::UserAgent;

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

our $VERSION = '0.03';

my %_eventTypes = (
        'evError',              1,
        'evAlert',              1,
        'evStatus',             1,
        'evLogTransaction',     1,
        'evShunRqst',           1
);

my %_alertSeverities = (
        'informational',        1,
        'low',                  1,
        'medium',               1,
        'high',                 1
);

my %_errorSeverities = (
        'warning',      1,
        'error',        1,
        'fatal',        1
);

##########################################################################################
#
# AUTOLOAD get/set methods when they're generic
#
use vars '$AUTOLOAD';
sub AUTOLOAD {
        no strict 'refs';
        my ($self, $value) = @_;

        my $key =($AUTOLOAD =~ /.*::([_\w]+)$/)[0];

        unless(defined($key) and exists($self->{ $key })) {
                $self->error(1);
                $self->errorString("No such parameter $key");
                return undef;
        }

        # set this up for next time
        *{$AUTOLOAD} = sub {
		my ($self, $value) = @_;
                if (defined($value)) {
                        return $self->{ $key } = $value;
                } else {
                        return defined($self->{ $key })?$self->{ $key }:undef;
                }
        };

        # go ahead and execute it this time
        if ( defined( $value )) {
                # set operation
                return $self->{ $key } = $value;
        } else {
                # get operation
                return defined($self->{ $key })?$self->{ $key }:undef;
        }
}

##########################################################################################
#
# Helper methods
#
sub _make_uri {
	my $self = shift;

	my $URI = URI->new();
	$URI->scheme('https');
	$URI->host( $self->Server );
	$URI->port( $self->Port );
	$URI->path( $self->Path );

	return $URI->as_string;
}

##########################################################################################
#
# Non-generic get/set methods
#
sub _processTraits {
	my $self = shift;
	my $whichTraits = shift;

	$self->error(undef);
	$self->errorString(undef);

	unless(defined($whichTraits) and exists($self->{ $whichTraits })) {
		$self->error(1);
		$self->errorString("No such trait attribute: $whichTraits");
		return undef;
	}

	# the spec for this parameter isn't clear -- I'm going to assume this
	# goes from 0-15 instead of 1-16.

	my @traits;
	foreach my $trait ( @_ ) {
		if( $trait =~ /^\d+$/ and $trait <16 and $trait >-1 ) {
			# individual trait
			push(@traits, $trait);
		} elsif ( $trait =~ /^(\d+)-(\d+)$/ and
				$1 <16 and $1>-1 and
				$2 <16 and $2>-1 and
				$1 < $2 ) {
			# trait range
			push(@traits, $trait);
		}
	}

	if($#traits > -1) {
		# note -- the spec shows examines with a ',' separating the traits
		# and specifies a '+' between them.  I'm going with the example.
		return $self->{ $whichTraits } = join(',', @traits);
	} else {
		$self->error(1);
		$self->errorString("No valid alarm traits: " . join(',', @_));
		return undef;
	}
}

sub mustHaveAlarmTraits {
	my $self = shift;

	unless(defined($_[0])) {
		# if no parameter, the treat as "get" method
		return $self->{ 'mustHaveAlarmTraits' };
	}

	return $self->_processTraits('mustHaveAlarmTraits', @_);
}

sub mustNotHaveAlarmTraits {
	my $self = shift;

	unless(defined($_[0])) {
		# if no parameter, the treat as "get" method
		return $self->{ 'mustNotHaveAlarmTraits' };
	}

	return $self->_processTraits('mustNotHaveAlarmTraits', @_);
}


sub errorSeverities {
	my $self = shift;
	my $error = shift;

	$self->error(undef);
	$self->errorString(undef);

	unless(defined($error)) {
		# if no parameter, the treat as "get" method
		return $self->{ 'errorSeverities' };
	}

	$error = lc($error);
	if(exists($_errorSeverities{ $error })) {
		return $self->{ 'errorSeverities' } = $error
	} else {
		$self->error(1);
		$self->errorString("Invalid error severity: $error");

		return undef;
	}
}

sub alertSeverities {
	my $self = shift;

	$self->error(undef);
	$self->errorString(undef);

	unless(defined($_[0])) {
		# if no parameter, the treat as "get" method
		return $self->{ 'alertSeverities' };
	}

	my @alertseverities;
	foreach my $s ( @_ ) {
		my $severity = lc($s);
		if(exists($_alertSeverities{ $severity })) {
			push(@alertseverities, $severity);
		}
	}

	if($#alertseverities > -1) {
		return $self->{ 'alertSeverities' } = join('+', @alertseverities);
	} else {
		$self->error(1);
		$self->errorString("No valid alert severities: " . join(',', @_));
		return undef;
	}
}

sub events {
	my $self = shift;

	unless(defined($_[0])) {
		# if no parameter, the treat as "get" method
		return $self->{ 'events' };
	}

	$self->error(undef);
	$self->errorString(undef);

	my @eventList;

	my %dedup;
	foreach my $eventtype ( grep( !$dedup{ $_ }++, @_ ) ) {
		if(exists($_eventTypes{ $eventtype })) {
			push(@eventList, $eventtype);
		}
	}

	if($#eventList > -1) {
		return $self->{ 'events' } = join('+', @eventList);
	} else {
		$self->error(1);
		$self->errorString("No valid event types: " . join(',', @_));
		return undef;
	}
}

sub confirm {
	my $self = shift;
	my $confirm = shift;

	unless(defined($confirm)) {
		# if no parameter, the treat as "get" method
		return $self->{ 'confirm' };
	}

	$self->error(undef);
	$self->errorString(undef);

	$confirm = lc($confirm);
	if($confirm eq 'no' or $confirm eq 'yes') {
		return $self->{ 'confirm' } = $confirm;
	} else {
		$self->error(1);
		$self->errorString("Invalid confirm value: $confirm");
		return undef;
	}
}

sub Type {
	my $self = shift;
	my $type = shift;

	unless(defined($type)) {
		# if no parameter, the treat as "get" method
		return $self->{ 'Type' };
	}

	$self->error(undef);
	$self->errorString(undef);

	$type = lc($type);
	if($type eq 'subscription' or $type eq 'query') {
		return $self->{ 'Type' } = $type;
	} else {
		$self->error(1);
		$self->errorString("Invalid RDEP connection type: $type");
		return undef;
	}
}

##########################################################################################
#
sub new {
        my $caller = shift;
        my %attr = @_;

	my $class = (ref($caller) or $caller);
        my $self = bless {
        	# connection parameters
        	'Server',		=> '127.0.0.1',
        	'Port',                 => 443,
        	'UserAgent',            => 'RDEP Client/4.0',
        	'Username',             => 'username',
        	'Password',             => 'password',
        	'Path',                 => '/cgi-bin/event-server',
        	'state',                => 'closed',
        	# subscription parameters
        	'Type',                 => 'subscription',
        	'Cookie',               => undef,
        	'Authorization',        => undef,
        	'subscriptionId',       => undef,
        	# retrieval parameters
        	'startTime',            => undef,
        	'stopTime',             => undef,  # only for queries
        	'events',               => 'evAlert',
        	'alertSeverities',      => undef,
        	'errorSeverities',      => undef,
        	'mustHaveAlarmTraits',  => undef,
        	'mustNotHaveAlarmTraits',       => undef,
        	'timeout',              => 1,
        	'maxNbrOfEvents',       => 20,     # set this just so we don't crush the box
        	'confirm',              => 'yes',
        	# results
        	'missedEvents', 	=> undef,
        	'error',        	=> undef,
        	'errorString',  	=> undef
	}, $class;

	foreach my $attribute ( keys %attr ) {
		$self->$attribute( $attr{ $attribute });
	}

	$self->state('closed');
	$self->missedEvents(undef);
	$self->error(undef);
	$self->errorString(undef);

        return $self;

}

sub open {
	my $self = shift;

	$self->error(undef);
	$self->errorString(undef);

	my $http_auth = $self->Username . ':' . $self->Password;
	$self->Authorization('Basic ' . MIME::Base64::encode( $http_auth, ''));

	my %headers = (
		'User-Agent'	=> $self->UserAgent,
		'Authorization'	=> $self->Authorization
	);

	# manditory parameters for subscription
	my %form_parameters = (
		events	=> $self->events
	);

	if ($self->Type eq 'subscription') {
		$form_parameters{ 'action' } = 'open';
		if (defined($self->timeout)) {
			$form_parameters{ 'timeout' } = $self->timeout;
		}
		if (defined($self->confirm)) {
			$form_parameters{ 'confirm' } = $self->confirm;
		}
	}

	if (defined($self->startTime)) {
		$form_parameters{ 'startTime' } = $self->startTime;
	}

	if (defined($self->maxNbrOfEvents)) {
		$form_parameters{ 'maxNbrOfEvents' } = $self->maxNbrOfEvents;
	}

	if (defined($self->mustHaveAlarmTraits)) {
		$form_parameters{ 'mustHaveAlarmTraits' } = $self->mustHaveAlarmTraits;
	}

	if (defined($self->mustNotHaveAlarmTraits)) {
		$form_parameters{ 'mustNotHaveAlarmTraits' } = $self->mustNotHaveAlarmTraits;
	}

	if (defined($self->alertSeverities)) {
		$form_parameters{ 'alertSeverities' } = $self->alertSeverities;
	}

	if (defined($self->errorSeverities)) {
		$form_parameters{ 'errorSeverities' } = $self->errorSeverities;
	}

	if ($self->Type eq 'query' and defined($self->stopTime)) {
		$form_parameters{ 'stopTime' } = $self->stopTime;
	}

	my $LWP = LWP::UserAgent->new();
	my $result = $LWP->post($self->_make_uri, \%form_parameters, %headers);

	if($result->is_success) {
		if($self->Type eq 'subscription' ) {
			if(my $cookie = $result->header('Set-Cookie')) {
				$self->Cookie((split(';', $cookie))[0]);
			} else {
				$self->error(1);
				$self->errorString( "No Cookie in header: " . $result->status_line);
				return undef;
			}

			if(my $parameter = $result->header('X-CISCO-RDEP-PARAMETERS')) {
				$self->subscriptionId((split('=',$parameter))[1]);
			} else {
				$self->error(1);
				$self->errorString( "No subscription ID in header: " . $result->status_line);
				return undef;
			}

			$self->state('opened');
		}
	} else {
		$self->error(1);
		$self->errorString( "Query failed: " . $result->status_line);
	}

	# on a subscription open, there is no content.  On a query, the content is the events
	return $result->content;
}

sub get {
	my $self = shift;

	$self->error(undef);
	$self->errorString(undef);

	# if we're just doing a query, return the "open";
	if( $self->Type eq 'query' ) { return $self->open() }

	# if we're doing a subscription, open first, the proceed
	if( $self->state eq 'closed' ) { $self->open() }

	#
	# only event subscriptions should be here
	my %headers = (
		'User-Agent'	=> $self->UserAgent,
		'Authorization'	=> $self->Authorization,
		'Cookie'	=> $self->Cookie
	);

	my %form_parameters = (
		'action'		=> 'get',
		'subscriptionId'	=> $self->subscriptionId
	);

	if (defined($self->timeout)) {
		$form_parameters{ 'timeout' } = $self->timeout;
	}

	if (defined($self->confirm)) {
		$form_parameters{ 'confirm' } = $self->confirm;
	}

	if (defined($self->maxNbrOfEvents)) {
		$form_parameters{ 'maxNbrOfEvents' } = $self->maxNbrOfEvents;
	}

	my $LWP = LWP::UserAgent->new();
	my $result = $LWP->post($self->_make_uri, \%form_parameters, %headers);

	if($result->is_success) {
		if(my $cookie = $result->header('Set-Cookie')) {
			$self->Cookie((split(';', $cookie))[0]);
		}

		if(my $parameter = $result->header('X-CISCO-RDEP-PARAMETERS')) {
			my ($name, $value) = split('=', $parameter);
			if($name eq 'missedEvents') {
				if($value eq 'true') {
					$self->missedEvents(1);
					$self->error(1);
					$self->errorString( "Events were dropped between polls");
				} else {
					$self->missedEvents(undef);
				}
			}
		}
		$self->state('opened');
		return $result->content;
	} else {
		$self->error(1);
		$self->errorString( "Query failed: " . $result->status_line);
		$self->state('closed');
		return undef;
	}
}

sub close {
	my $self = shift;

	$self->error(undef);
	$self->errorString(undef);

	return if( $self->state eq 'closed' or $self->Type eq 'query' );

	my %headers = (
		'User-Agent'	=> $self->UserAgent,
		'Authorization'	=> $self->Authorization,
		'Cookie' => $self->Cookie
	);

	# manditory parameters for subscription
	my %form_parameters = (
		action		=> 'close',
		subscriptionId	=> $self->subscriptionId
	);

	my $LWP = LWP::UserAgent->new();
	my $result = $LWP->post($self->_make_uri, \%form_parameters, %headers);

	$self->state('closed');
	if(defined($result) and $result->is_success) {
		return $result->content;
	} else {
		$self->error(1);
		$self->errorString( "Query failed: " . $result->status_line);
		return undef;
	}
}

#
# close connection, just in case we forgot to call close() properly
sub DESTROY {
	my $self = shift;

	if($self->state eq 'opened') { $self->close() }
}

#
##########################################################################################

1;
__END__