Fwctl::AcctReport - Generates reports from C<fwctl dump-acct> command.

    use Fwctl::AcctReport;

    my $report = new Fwctl::Report( options ... );

    my $r = $report->summary_report;

    foreach my $r ( @$src_alias_sum ) {
	print $r->{name}, " = ", $r->{bytes_sum}, "\n";
    }

    Ex. my $report = new Fwctl::AcctReport( start  => 'yesterday',
					    period => '1 day',
					    sample => '1d',
					    files  => [ 'log' ] );

    my $r = $report->summary_report();

    my $r = $report->sample_report();

#
#    Report.pm - Module that compiles accounting reports from the data dumped
#		 by the fwctl dump-acct command.
#
#    This file is part of Fwctl.
#
#    Author: Francis J. Lacoste <francis.lacoste@iNsu.COM>
#
#    Copyright (C) 2000 iNsu Innovations Inc.
#
#    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 of the License, or
#    (at your option) any later version.
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms same terms as perl itself.
#
package Fwctl::AcctReport;

use strict;

use vars qw( $VERSION @EXPORT @EXPORT_OK %EXPORT_TAGS @ISA );

use Math::BigInt;
use Symbol;
use Fwctl::Report;
use Exporter;

BEGIN {
    ($VERSION) = '$Revision: 1.4 $' =~ /(Revision: ([\d.]+))/;
    @ISA = qw( Exporter );

    @EXPORT = ();

    @EXPORT_OK = ();

    %EXPORT_TAGS = ( fields => [ qw(  TIME PACKETS BYTES NAME ) ],
		   );
}

BEGIN {
    # Create the necessary constant
    my $i = 0;
    for my $f ( @{$EXPORT_TAGS{fields}} ) {
	eval "use constant $f => $i;";
	$i++;
    }

    Exporter::export_ok_tags( 'fields' );
};

sub read_records {
    my $self = shift;

    # Read in the data
    my $records = [];
    push @{$self->{opts}{files}}, \*STDIN unless @{$self->{opts}{files}};
  FILE:
    foreach my $file ( @{$self->{opts}{files}} ) {
	my $fh;
	if ( ref $file ) {
	    $fh = $file;
	} elsif ( $file eq "-" ) {
	    $fh = \*STDIN;
	} else {
	    $fh = gensym;
	    open $fh, $file
	      or do { warn "can't open file $file\n"; next FILE };
	}

	# We subtract gives ourselves more records since the entries are
	# the amount between the current record timestamp and the one before
	# it.
	my $start = $self->{start};
	$start -=  2 * $self->{sample} if defined $start;

	my $end = $self->{end};
	$end += 2 * $self->{sample} if defined $end;

      LINE:
	while  ( my $line = <$fh>) {
	    chomp $line;
	    my @fields = (split /\s+/, $line)[0,2,3,4];

	    if ( ! defined $self->{start}) {
		$start = $self->{start} = $fields[TIME];
		$start -= 2 * $self->{sample};
		if ( defined $self->{period} ) {
		    $end = $self->{end} = $self->{start} + $self->{period};
		    $end += 2 * $self->{sample};
		}
	    }
	    # Skip fields outside the period
	    next unless $start <= $fields[TIME] && $end >= $fields[TIME];

	    if ( $self->{opts}{names} ) {
		foreach my $chain ( @{ $self->{opts}{names} } ) {
		    if ( $chain eq $fields[NAME] ) {
			push @$records, \@fields;
			next LINE;
		    }
		}
	    } else {
		push @$records, \@fields;
	    }
	}
    }

    # Records are sorted by time.
    $self->{records} = [ sort { $a->[TIME] <=> $b->[TIME] } @$records ];
}

sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;

    my $self = { opts	    => { @_ },
		 records    => undef,
		 start	    => undef,
		 end	    => undef,
		 period	    => undef,
		 sample	    => 3600, # One hour sample
		 sample_report  => undef,
		 summary_report => undef,
	       };

    # Determine start and end of the report;
    if ( $self->{opts}{start} ) {
	$self->{start} = Fwctl::Report::parse_date( $self->{opts}{start} )
	  or die "invalid start date format: $self->{opts}{start}\n";
    }

    if ( $self->{opts}{period} ) {
	$self->{period} = Fwctl::Report::parse_period( $self->{opts}{period} )
	  or die "invalid period delta: $self->{opts}{period}\n";
	if (  $self->{start} ) {
	    $self->{end} = $self->{start} + $self->{period};
	}
    } elsif ( $self->{opts}{end} ) {
	$self->{end} = Fwctl::Report::parse_date( $self->{opts}{end} ) 
	  or die "invalid end date format: $self->{opts}{end}\n";
    } else {
	$self->{end} = time;
    }

    if ( $self->{opts}{sample} ) {
	$self->{sample} = Fwctl::Report::parse_period( $self->{opts}{sample} )
	  or die "invalid sample period: $self->{opts}{sample}\n";
    }
    bless $self, $class;

    $self->read_records;

    $self;
}

sub start {
    $_[0]->{start};
}

sub end {
    $_[0]->{end};
}

sub period {
    $_[0]->{end} - $_[0]->{period};
}

sub sample {
    $_[0]->{sample};
}

sub records {
    # Copy the records
    [ @{$_[0]->{records}} ];
}

sub summary_report {
    my ( $self ) = shift;

    return $self->{summary_report} if defined $self->{summary_report};

    my %chains = ();
    my $sample_report = $self->sample_report;
    while ( my ( $chain, $samples ) = each %$sample_report ) {
	my $stats =  {
		      name	      => $chain,
		      packets_sum   => new Math::BigInt( 0 ),
		      bytes_sum     => new Math::BigInt( 0 ),
		      packets_avg   => 0,
		      bytes_avg     => 0,
		     };

	foreach my $r ( @$samples ) {
	    $stats->{packets_sum} += $r->{packets};
	    $stats->{bytes_sum} += $r->{bytes};
	}
	$stats->{packets_avg} = $stats->{packets_sum} / @$samples;
	$stats->{bytes_avg}   = $stats->{bytes_sum} / @$samples;

	# Replace samples by stats
	$chains{$chain} = $stats;
    }

    # Returns an array ref sorted by name
    return $self->{summary_report} = [ sort { $a->{name} cmp $b->{name} } values %chains ];
}

sub sample_report {
    my ( $self ) = shift;

    # Return cache
    return $self->{sample_report} if defined $self->{sample_report};

    my $start  = $self->{start};
    my $end    = $self->{end};
    my $sample = $self->{sample};
    my $num_samples = int( ($end - $start ) / $sample );
    $num_samples++ unless $num_samples * $sample + $start > $end;

    my %chains = ();
    # Sort records by chain, since records are ordered by time,
    # all chain's record are also ordered.
    foreach my $r ( @{ $self->{records} } ) {
	push @{$chains{$r->[NAME]}}, $r;
    }

    # Foreach chains build an array containing the number of bytes and packets
    # by sample period.
    while ( my ( $chain, $records ) = each %chains ) {
	# Initialize the samples array for that chain
	my @samples = ( ) x $num_samples;
	for ( my $i = 0 ; $i < $num_samples; ++$i ) {
	    $samples[$i] = {
			    start   => $start + $i * $sample,
			    packets => new Math::BigInt(0),
			    bytes   => new Math::BigInt(0),
			   };
	}

	my ($last_s_idx, $last_time) = ( -1, 0 );
      RECORD:
	foreach my $r ( @$records ) {
	    # Find sample in which this record falls
	    my $s_idx = int ( ( $r->[TIME] - $start ) / $sample );

	    # If this record is before the beginning of the
	    # period, save time for normalization and go to
	    # next record
	    if ( $s_idx < 0 ) {
		$last_time = $r->[TIME];
		next RECORD;
	    }

	    # Comparing to the last record, is it completely
	    # in this period.
	    if ( $last_s_idx == $s_idx ) {
		# Add bytes and packet counters
		$samples[$s_idx]{bytes}   += $r->[BYTES];
		$samples[$s_idx]{packets} += $r->[PACKETS];
	    } else {
		# Distribute pro rata
		my $this_sample_ratio = ($r->[TIME] - ($start + $s_idx * $sample) ) / $sample;
		my $last_sample_ratio = 1 - $this_sample_ratio;
		if ( $s_idx >= $num_samples ) {
		    # This is the last record
		    $samples[$last_s_idx]{bytes}   += int( $r->[BYTES]   * $last_sample_ratio );
		    $samples[$last_s_idx]{packets} += int( $r->[PACKETS] * $last_sample_ratio );
		    last RECORD;
		} elsif ( $s_idx == 0 ) {
		    # This is the first record
		    $samples[$s_idx]{bytes}   += int( $r->[BYTES] * $this_sample_ratio );
		    $samples[$s_idx]{packets} += int( $r->[PACKETS] * $this_sample_ratio );
		} else {
		    $samples[$last_s_idx]{bytes}   += int( $r->[BYTES] * $last_sample_ratio );
		    $samples[$last_s_idx]{packets} += int( $r->[PACKETS] * $last_sample_ratio );
		    $samples[$s_idx]{bytes}   += int( $r->[BYTES] * $this_sample_ratio );
		    $samples[$s_idx]{packets} += int( $r->[PACKETS] * $this_sample_ratio );
		}
		$last_s_idx = $s_idx;
	    }
	    $last_time = $r->[TIME];
	}
	# Replace records by sample stats
	$chains{$chain} = \@samples;
    }

    # Return an hash of array of hash.
    return $self->{sample_report} = \%chains;
}

1;

__END__