File Coverage

blib/lib/SyslogScan/Summary.pm

Criterion	Covered	Total	%
statement	10	13	76.9
branch			n/a
condition			n/a
subroutine	4	5	80.0
pod			n/a
total	14	18	77.7

package SyslogScan::Summary;

$VERSION = 0.20;
sub Version { $VERSION };

use SyslogScan::Usage;
use SyslogScan::Volume;
use SyslogScan::Delivery;
use SyslogScan::DeliveryIterator;
use SyslogScan::FilterUser;
use Carp;
use strict;

my $HEADER = "Summary v1";
my $EMPTY_FILTER = new SyslogScan::FilterUser();

sub new
{
    my $type = shift;
    my @iterList = @_;

    my $self = {};
    bless ($self,$type);

    $self -> registerAllInIterators('','',
				    @iterList);

    return $self;
}

sub registerAllInIterators
{
    my $self = shift;
    my $selfPattern = shift;
    my $otherPattern = shift;
    my @iterList = @_;

    # check for developer error, since this is counter-intuitive usage.
    defined($otherPattern)
	or die "bad usage of registerAllInIterators function";

    my $iter;
    foreach $iter (@iterList)
    {
	my $delivery;
	while ($delivery = $iter -> next)
	{
	    $self -> registerDelivery($delivery,$selfPattern, $otherPattern);
	}
    }
}

sub registerDelivery
{
    my $self = shift;
    my $delivery = shift;
    my $selfPattern = shift;  # undefined means match everything
    my $otherPattern = shift; # undefined means match everything

    my $filter;
    if (defined $selfPattern)
    {
	$filter = new SyslogScan::FilterUser($selfPattern, $otherPattern);
    }
    else
    {
	# let everything through
	$filter = $EMPTY_FILTER;
    }

    my $size = $$delivery{Size};
    my $sender = $$delivery{Sender};
    my $paReceiverList = $$delivery{ReceiverList};
    ref($paReceiverList) eq 'ARRAY' or die "$paReceiverList not array ref";

    my $gotThroughFilter = 0;
    my $receiver;
    foreach $receiver (@$paReceiverList)
    {
	if ($filter -> matchesFilter($sender,$receiver))
	{
	    $gotThroughFilter++;
	    $self -> _registerUsage($sender,"Sender",$size);
	}
	if ($filter -> matchesFilter($receiver,$sender))
	{
	    $self -> _registerUsage($receiver,"Receive",$size);
	}
    }

    $gotThroughFilter and $$delivery{Instance} eq 1 and
	$self -> _registerUsage($sender,"Broadcast",$size);
}

sub persist
{
    my $self = shift;
    my $outFH = shift;

    print $outFH "$HEADER start\n";
    my $address;
    foreach $address (keys %$self)
    {
	next unless defined $$self{$address};  # skip deleted

	$address =~ /\n/ and
	    die "address $address contains embedded newline, cannot persist";
	print $outFH "address=$address\n";
	$$self{$address} -> persist($outFH);
    }
    print $outFH "$HEADER end\n";
}

sub restore
{
    my $type = shift;
    my $inFH = shift;

    defined $inFH or croak "filehandle not defined";

    my $line = <$inFH>;
    if ($line ne "$HEADER start\n")
    {
	$line or return undef;   # at eof

	# not at eof; something is fishy
	die "expected $HEADER start, got $line";
    }

    my $self = {};
    bless ($self, $type);

    my $headerLine;
    while (defined($headerLine = <$inFH>))
    {
	if (! ($headerLine =~ /^address\=(.*)/))
	{
	    return $self if $headerLine eq "$HEADER end\n";
	    die "expected address= or $HEADER end, got $headerLine";
	}
	my $address = $1;

	defined($$self{$address}) and
	    die "address $address seen multiple times, stopped";
	$$self{$address} = SyslogScan::Usage -> restore($inFH);
    }
    die "never saw $HEADER end line";
}

sub dump
{
    my $self = shift;
    my $retString;

    my $address;
    foreach $address (sort keys %$self)
    {
	$retString .= "$address:\n";
	$retString .= $$self{$address} -> dump();
    }
    return $retString;
}

sub _registerUsage
{
    my $self = shift;

    my $address = shift;
    my $role = shift;
    my $size = shift;

    defined $$self{$address} or
	$$self{$address} = new SyslogScan::Usage;

    if ($role eq 'Receive')
    {
	$$self{$address} -> registerReceive($size);
    }
    elsif ($role eq 'Sender')
    {
	$$self{$address} -> registerSend($size);
    }
    elsif ($role eq 'Broadcast')
    {
	$$self{$address} -> registerBroadcast($size);
    }
    else
    {
	die "illegal role: $role";
    }
    return 0;
}

sub addSummary
{
    my $self = shift;
    my $other = shift;

    my $address;
    foreach $address (keys %$other)
    {
	if (! $$self{$address})
	{
	    $$self{$address} = new SyslogScan::Usage();
	}
	$$self{$address} -> addUsage($$other{$address});
    }
}

__END__