File Coverage

blib/lib/Notify/NoticePool.pm

Criterion	Covered	Total	%
statement	33	156	21.1
branch	3	56	5.3
condition	1	9	11.1
subroutine	8	22	36.3
pod	0	16	0.0
total	45	259	17.3

package Notify::NoticePool;

require 5.00503;
use strict;
use Carp;
use Notify::Notice;
use Tie::Persistent;

require Exporter;

our @ISA = qw( Exporter );
our %EXPORT_TAGS = ( 'all' => [ qw( DEFAULT_RESEND_INTERVAL DEFAULT_MAX_RETRIES ) ] );
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
our @EXPORT = qw( );
#our $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
our $VERSION = '0.0.1';

# Set our notification constants
use constant DEFAULT_RESEND_INTERVAL => 300;
use constant DEFAULT_MAX_RETRIES     => 5;
our $resend_interval = DEFAULT_RESEND_INTERVAL;
our $max_retries     = DEFAULT_MAX_RETRIES;

sub new {

	my ($self, $options) = @_;
	my $class = ref($self) || $self;
	my $this = {};
	bless $this, $class;

	confess "Error creating Notice Pool: No file store given."
		unless exists $options->{'file_store'};

	$this->{'__NOTICE_FILE'} = $options->{'file_store'};
	$this->{'__TRANSPORT'} = (exists $options->{'transport'})
		? $options->{'transport'} : { };

	$this->updateOutstanding ()
		unless exists $options->{'no_implicit_update'};

	return $this;

} #end sub new

sub setResendInterval {

	my ($self, $interval) = @_;

	confess "Error setting resend interval: No interval given."
		unless $interval;

	$resend_interval = $interval;

} #end sub setResendInterval

sub getResendInterval {

	my ($self) = @_;
	return $resend_interval;

} #end getResendInterval

sub setMaxRetries {

	my ($self, $retries) = @_;

	confess "Error setting number of max retries: No maximum given."
		unless $retries;

	$max_retries = $retries;

} #end sub setMaxRetries

sub getMaxRetries {

	my ($self) = @_;
	return $max_retries;

} #end sub getMaxRetries

sub addTransport {

	my ($self, $entries) = @_;

	foreach (keys %$entries) {

		confess "Error adding transport entry for type $_. Invalid transport object."
			unless defined $entries->{$_}->send and defined $entries->{$_}->receive;

		$self->{'__TRANSPORT'}->{$_} = $entries->{$_};

	}

} #end sub addTransport

sub getUniqueID {

	my ($self) = @_;
	my %tied;

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';
	my $lastid = $tied{'__LAST_ID'} + 1;
	while (exists $tied{ $lastid }) { $lastid++; }
	untie %tied;

	return $lastid;

} #end sub getUniqueID

sub exists {

	my ($self, $id) = @_;
	my %tied;

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';
	my $result = exists $tied{$id};
	untie %tied;

	return $result;

} #end sub exists

sub addNotice {

	my ($self, $notice) = @_;
	my %tied;

	confess "Error adding notice: No notice given."
		unless $notice;

	my $notice_attribs = $notice->getNotice ();

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';

	unless (exists $tied{ $notice_attribs->{'id'} }) {

		$notice_attribs->{'time_created'} = $notice_attribs->{'time_updated'} = time ();
		$tied{ $notice_attribs->{'id'} } = $notice_attribs;

		# Update the last used ID
		$tied{'__LAST_ID'} = $notice_attribs->{'id'};

	}
	else {
		return undef;
	}

	untie %tied;

	my $new_notice = new Notify::Notice ($notice_attribs);
	my $updated = $self->sendIfAppropriate ($new_notice);

	return ($updated) ? $updated : $new_notice;

} #end sub addNotice

sub sendIfAppropriate {

	my ($self, $notice) = @_;
	my $attribs = $notice->getNotice ();
	my %tied;

	# Try to send the notice immediate with an updated object
	# and update the persistent object on disk. Note that we
	# had to untie before trying the send in order to have
	# guaranteed messaging.

	if ($attribs->{'status'} == OUTGOING_PENDING) {

		if ($self->sendNotice ($notice)) {
			$attribs->{'status'} = WAITING_RESPONSE;
		}
		else {
			$attribs->{'attempts'}++;
		}

		tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';
		$tied{ $attribs->{'id'} } = $attribs;
		untie %tied;

		return new Notify::Notice ($attribs);

	}
	else {
		return undef;
	}

} #end sub sendIfAppropriate

sub resolveNotice {

	my ($self, $notice) = @_;
	my %tied;

	confess "Error resolving notice: No notice given."
		unless $notice;

	my $notice_attribs = $notice->getNotice ();

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';
	return undef unless exists $tied{ $notice_attribs->{'id'} };
	delete $tied{ $notice_attribs->{'id'} };
	untie %tied;

	return 1;

} #end sub resolveNotice

sub retrieveNotice {

	my ($self, $notice) = @_;
	my %tied;
	my ($notice_attribs, $db_attribs);

	$notice_attribs = $notice->getNotice ();

	confess "Error retrieving notice: No notice given."
		unless $notice;

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'r';
	if (exists $tied{ $notice_attribs->{'id'} }) {
		$db_attribs = $tied{ $notice_attribs->{'id'} };
	}
	else {
		return undef;
	}
	untie %tied;

	if ($db_attribs->{'status'} == WAITING_PROCESSING) {

		# Mark that the notification is transaction is considered
		# done unless the application updated the notification
		# back to OUTGOING_PENDING
		$db_attribs->{'status'} = DONE;
		tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';
		$tied{ $db_attribs->{'id'} } = $db_attribs;
		untie %tied;

	}

	return new Notify::Notice ($db_attribs);

} #end sub retreiveNotice

sub updateNotice {

	my ($self, $notice) = @_;
	my %tied;
	my ($new_attribs, $old_attribs);

	confess "Error updating notice: No notice given."
		unless $notice;

	$new_attribs = $notice->getNotice ();

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';

	return undef unless exists $tied{ $new_attribs->{'id'} };
	$old_attribs = $tied{$new_attribs->{'id'}};
	push @{ $new_attribs->{'history'} }, $old_attribs->{'message'};
	$new_attribs->{'time_updated'} = time ();
	$tied{ $new_attribs->{'id'} } = $new_attribs;

	untie %tied;

	my $new_notice = new Notify::Notice ($new_attribs);
	my $updated = $self->sendIfAppropriate ($new_notice);

	return ($updated) ? $updated : $new_notice;

} #end sub updateNotice

sub updateOutstanding {

	my ($self) = @_;
	my %tied;

	tie %tied, 'Tie::Persistent', $self->{'__NOTICE_FILE'}, 'rw';

	foreach my $key (keys %tied) {

		# Skip the special LASTID key
		next if $key =~ /^__LAST_ID$/;

		my $notice_attribs = $tied{$key};

		if ($notice_attribs->{'status'} == OUTGOING_PENDING) {

			# Check to see if we are within the send interval
			next unless $notice_attribs->{'attempts'} and
			            (time () - $notice_attribs->{'time_updated'} > $resend_interval);

			my $outgoing = new Notify::Notice ($notice_attribs);

			if ($self->sendNotice ($outgoing)) {

				$notice_attribs->{'status'} = WAITING_RESPONSE;
				$notice_attribs->{'time_updated'} = time ();

			}
			else {

				$notice_attribs->{'attempts'}++;

				if ($notice_attribs->{'attempts'} > $max_retries) {
					$notice_attribs->{'status'} = FAILURE;
				}

			}

		}
		elsif ($notice_attribs->{'status'} == WAITING_RESPONSE) {

			my $incoming = new Notify::Notice ($notice_attribs);
			my $response = $self->getNoticeResponse ($incoming);

			if ($response) {

				push @{ $notice_attribs->{'history'} }, $notice_attribs->{'message'};
				$notice_attribs->{'message'} = $response;
				$notice_attribs->{'status'} = WAITING_PROCESSING;
				$notice_attribs->{'time_updated'} = time ();

			}

		}

		# Assign the copy to the persistent DB
		$tied{$key} = $notice_attribs;

	}

	untie %tied;

	return 1;

} #end sub updateOutstanding

sub sendNotice {

	my ($self, $notice) = @_;
	my $attribs = $notice->getNotice ();

	confess "Error: Attempted to send notice to undefined transport type."
		unless exists $self->{'__TRANSPORT'}->{ $attribs->{'transport'} };

	return $self->{'__TRANSPORT'}->{ $attribs->{'transport'} }->send ($notice);

} #end sub sendNotice

sub getNoticeResponse {

	my ($self, $notice) = @_;
	my $attribs = $notice->getNotice ();

	confess "Error: Attempted to retrieve notice from undefined transport type."
		unless exists $self->{'__TRANSPORT'}->{ $attribs->{'transport'} };

	return $self->{'__TRANSPORT'}->{ $attribs->{'transport'} }->receive ($notice);

} #end sub getNoticeResponse

1;

__END__