# Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

# summarise an automated build log

use strict;

use Getopt::Long;

use HTML::Entities;

use Carp;

use FindBin;		# for FindBin::Bin

# Add the directory contain this perl script into the path to find modules

use lib $FindBin::Bin;

use Scanlog;

# For Date calculations

use lib "$FindBin::Bin/../lib"; # For running in source

use lib "$FindBin::Bin/build/lib"; # For running in epoc32\tools

use Date::Manip;

# Set TimeZone because Date:Manip needs it set and then tell it to IGNORE the TimeZone

&Date_Init("TZ=GMT","ConvTZ=IGNORE");

# Variables

my $line;

my $iSlurp;

my $PhaseStartTime;

my %Phases;

my %Components;

my %Commands;

my $component;

my $command;

my $phase;

my $match_phase='';

my %errors;

my %warnings;

my %remarks;

my %migrationNotes;

my %AdvisoryNotes;

my %CmdErrors;

my %CmdWarnings;

my %CmdRemarks;

my %CmdMigrationNotes;

my %CmdAdvisoryNotes;

my %missing;

my %not_built;

my $starttime;

my $duration;

my $warningcount;

my $errorcount;

my $remarkcount;

my $migrationNoteCount;

my $AdvisoryNoteCount;

my ($iStatus, $iName);

my %htmlColours=(

"errors" =>"#ff0000",

"warnings" =>"#fff000",

"remarks" =>"#ffccff",

"migrationNotes" =>"#ffcc99",

"AdvisoryNotes" => "#ffa500"

);

# Hires Timer Variables

my %HiResComponents;

my %HiResCommands;

my $HiResStartTime;

my $HiResErrorFlag; #True if one of the Clients has not reported HiRes timing info

my $Dsec;

# History Variables

my ($hostname) = "N/A";

my ($EndTime);

# Main section

my ($iOutput, $iTitle, $iVerbose, $iDiff, $iWhat, $iHistory, $iClass, @iLogs) =&ProcessCommandLine();

# Open Output file

  open (HTML, ">$iOutput") or die "Couldn't open $iOutput for writing: $!\n";

# Open Diff file if specified

if ($iDiff ne '')

{

  open (DIFF, ">$iDiff") or die "Couldn't open $iDiff for writing: $!\n";

}

# Print HTML Header

&PrintHTMLHeader($iTitle);

# Parse each log File

foreach my $iLog (@iLogs) # parses through all logs 

{

  # Open the Log file for reading

  unless (open (LOG, "< $iLog"))

    {   # On error, warn rather than die. Then record a "pseudo-error", which will appear in summary output file.

        $line = "Couldn't open $iLog for reading: $!";

        warn "$line\n";

        $command = 'HTMLScanLog';

        $component = 'Log Summaries';

        $Commands{$command} = 0;            # Need to define these! So assume zero seconds 

        $HiResCommands{$command} = 0;       # duration for each of four variables.

        $Components{$component} = 0;        # The fact the relevant time(s) are defined

        $HiResComponents{$component} = 0;   # triggers inclusion in the applicable table. 

        do_error($iLog);

        next;

    }

  # Chop $iLog just to the filename

  $iLog =~ s/^.*\\//;

  # Process the logs

  &ProcessLog($iLog);

  close LOG;

}

&PrintResults($iTitle);

# Print HTML Footer

&PrintHTMLFooter();

# Handle the History file

if (defined $iHistory)

{

  # Work out the class

  my ($mclass) = "N/A";

  open (MC, "< $iClass");

  while (<MC>)

  {

    chomp;

    my (@columns) = split(/,/);

    $mclass = $columns[0] if ($columns[1] eq $hostname);

  }

  close (MC);

  # Open and Lock the csv file

  open(FH, "+< $iHistory")                or die "can't open $iHistory: $!";

  flock(FH, 2)                        or die "can't flock iHistory: $!";

  # Read the file

  # Reader the headers

  my $cline = <FH>;

  chomp($cline);

  my (@headers) = split(/,/,$cline);

  # Read the data

  my (@csvdata);

  @csvdata = <FH>;

  # Return to the begining

  seek(FH,0,0)                        or die "Seeking: $!";

  # Print the old and new data

  # Work if new headers are needed

  # Use LowRes component names because they are always available

  foreach my $component (sort {lc $a cmp lc $b} keys %Components)

	{

    my $compexist = 0;

    # Itterate through the header array to see if it already exists

    foreach my $header (@headers)

    {

      if ($component eq $header)

      {

        $compexist = 1;

      }

    }

    # This component not found in the headers

    # put the new header at the end of the header array

    push @headers, $component if ($compexist == 0);

  }

  # Print the headers back out

  print FH join(',',@headers)."\n";

  # Print the original data

  print FH @csvdata;

  # Print the new data

  foreach my $header (@headers)

  {

    if ($header eq 'Machine Class')

    {

      print FH "$mclass";

    } elsif ($header eq 'Machine Name') {

      print FH "$hostname";

    } elsif ($header eq 'Title') {

      print FH "$iTitle";

    } elsif ($header eq 'End Time') {

      print FH "$EndTime";

    } elsif ($header eq 'Total Time') {

      print FH &ConvertSeconds($duration);

    } else {

      # If there is a complete set of HiRes data then use that instead of the LowRes data

      if ((defined %HiResComponents) && !$HiResErrorFlag)

      {

        if (exists $HiResComponents{$header})

        {

          print FH &ConvertSeconds($HiResComponents{$header});

        } else {

          print FH "";

        }

      } else {

        if (exists $Components{$header})

        {

          print FH &ConvertSeconds($Components{$header});

        } else {

          print FH "";

        }

      }

    }

    # Print the , for next entry

    print FH ",";

  }

  # End the entry

  print FH "\n";

  # truncate just in case the file is shorter

  truncate(FH,tell(FH))               or die "Truncating: $!";

  close(FH)                           or die "Closing: $!";

}

# DiffLog

#

# Inputs

#

# Outputs

#

# Description

# This function Outputs lines to the diff log

sub DiffLog()

{

    # Write the line to diff file if specified and not a line with Build Time dependent infomation

    if ($iDiff ne '')

    {

       # Check the line for Build Time dependent infomation

       unless (($line =~ /^=== .+ started/) || ($line =~ /^=== .+ finished/) || ($line =~ /^---/) || ($line =~ /^\+\+/))

       {

          print DIFF $line;

       }

    }

}

# ProcessLog

#

# Inputs

# $iLog - Logfile name

#

# Outputs

#

# Description

# This function processes the commandline

sub ProcessLog()

{

  my ($iLog) = @_;

  print "Processing: $iLog\n";

  while ($line=<LOG>)

    {

    &DiffLog;

    # Hostname is

    # capture the hostname if available

    if ($line =~ /^Hostname is (.*)$/)

    {

      $hostname = $1;

    }

    # ===-------------------------------------------------

    # === Stage=1

    # ===-------------------------------------------------

    # === Stage=1 started Wed Apr 30 23:09:38 2003

    if ($line =~ /^===------/)

    {

      $line=<LOG>;

          &DiffLog;

      $line=<LOG>;

          &DiffLog;

      $line = <LOG>;

          &DiffLog;

      $line =~ /^=== (.+) started (.*)/;

      $phase = $1;

      $PhaseStartTime =$2;

      $match_phase=$phase;

      $match_phase=~s-\\-\\\\-go;

      next;

    }

    # === bldfiles finished Sat Jul 24 01:38:56 1999.

    if ($line =~ /^=== $match_phase finished (.*)/)

    {

      my ($TempTime) = $1;

      # Calculate the difference in Date/Time and Total up for Phase

      $Phases{$phase} += &DiffDateTime($PhaseStartTime, $TempTime) ;

      # The check to see if phase end is later than current EndTime

      my $err;

      # The first time a phase end is seen set $EndTime

      if (!defined $EndTime)

      {

        $EndTime = $TempTime;

      } else {

        # Check the delta to previous EndTime value is positive

        # Need due to multiple log file processing might not be in time order

        my ($delta) = &DateCalc($EndTime,$TempTime,\$err);

        die "Date Manip error" if ($err);

        # If the delta starts with a + symbol $TempTime is later or the same as the last EndTime so set the new EndTime.

        if ($delta =~ /^\+/)

        {

          $EndTime = $TempTime;

        }

      }

      next;

    }

    # === resource == gdtran 036

    if ($line =~ /=== $match_phase == (.*)$/)

    {

      $component = $1;

      next;

    }

    # Find Command

    # -- bldmake bldfiles -keepgoing

    if ($line =~ /^-- (.*)/)

    {

      $command = $1;

      next;

    }

    # Find the Command's Start time

    # ++ Started at Sat May 03 21:09:07 2003

    if ($line =~ /^\+\+ Started at (.*)/)

    {

      $starttime = $1;

      next;

    }

    # Find the Command's End time

    # ++ Started at Sat May 03 21:09:07 2003

    if ($line =~ /^\+\+ Finished at (.*)/)

    {

      # Calculate the difference in Date/Time and Total up for Command

      $Dsec = &DiffDateTime($starttime, $1);

      $Commands{$command} += $Dsec;

      # Calculate the difference in Date/Time and Total up for Component

      $Components{$component} += $Dsec;

      next;

    }

    # Act on a HiRes Timer unavailable statement in the log

    # +++ HiRes Time Unavailable

    if (($line =~ /^\+\+\+ HiRes Time Unavailable/) && !$HiResErrorFlag)

    {

      $HiResErrorFlag = 1;

          print "Warning one of the clients is not sending HiRes timer Data\n";

          print "No HiRes timings will be available\n";

          print "Reverting to LowRes timing Data\n";

      # Clear out Current HiRes Data

      undef %HiResCommands;

      undef %HiResComponents;

      next;

    }

    # Find the Command's HiRes Start time

    # +++ HiRes Start 1051993130.602050

    if (($line =~ /^\+\+\+ HiRes Start (\S+)/) && !$HiResErrorFlag)

    {

      $HiResStartTime = $1;

      next;

    }

    # Find the Command's HiRes End time

    # +++ HiRes End 1051993193.829650

    if (($line =~ /^\+\+\+ HiRes End (\S+)/) && !$HiResErrorFlag)

    {

      # Calculate the difference in Date/Time and Total up for Command

      $HiResCommands{$command} += ($1 - $HiResStartTime);

      # Calculate the difference in Date/Time and Total up for Component

      $HiResComponents{$component} += ($1 - $HiResStartTime);

      next;

    }

    # Lines to Ignore

    ($iStatus) =&Scanlog::CheckForIgnore($line);

    if($iStatus)

    {

      next;

    }

    # Advisory Notes

    ($iStatus) =&Scanlog::CheckForAdvisoryNotes($line);

    if ($iStatus)

    {

       do_AdvisoryNotes($iLog);

       do_slurp($iSlurp);

      next;

    }

    # Migration Notes

    ($iStatus) = &Scanlog::CheckForMigrationNotes($line);

    if ($iStatus)

      {

      do_migrationNotes($iLog);

      next;

      }

    # Remarks

    ($iStatus, $iSlurp) =&Scanlog::CheckForRemarks($line);

    if ($iStatus)

    {

      do_remarks($iLog);

      do_slurp($iSlurp);

      next;

    }

    # Errors

    ($iStatus) =&Scanlog::CheckForErrors($line);

    if ($iStatus)

    {

      do_error($iLog);

      next;

    }

    # Warnings

    ($iStatus) =&Scanlog::CheckForWarnings($line);

    if ($iStatus)

    {

      do_warning($iLog);

      next;

    }

    # Things Not Built

    ($iStatus, $iName) =&Scanlog::CheckForNotBuilt($line);

    if ($iStatus)

    {

      do_error($iLog); # record these along with the errors

      $not_built{$iName} = "$component";

      next;

    }

    # Things missing

    ($iStatus, $iName) =&Scanlog::CheckForMissing($line);

    if ($iStatus)

    {

      do_error($iLog);

      $missing{$iName} += 1;

      next;

    }

	}

}

# PrintResults

#

# Inputs

# $iTitle (Title for Log file)

#

# Outputs

#

# Description

# This function prints all the data as HTML

sub PrintResults

{

  my ($iTitle) = @_;

  my $title;

  # Print Heading of Log File

  my $heading ="Overall";

  print HTML qq{<h1>$iTitle</h1>\n};

  print HTML qq{<h2>$heading</h2>\n};

  # Calculate the total number of remarks messages

	$remarkcount = 0;

	foreach $component (sort {lc $a cmp lc $b} keys %remarks)

		{

		$remarkcount += scalar(@{$remarks{$component}});

		}

  # Calculate the Total number of errors

  	$errorcount = 0;

	foreach $component (sort {lc $a cmp lc $b} keys %errors)

		{

		$errorcount += scalar(@{$errors{$component}});

		}

  # Calculate the total number of warnings

	$warningcount = 0;

	foreach $component (sort {lc $a cmp lc $b} keys %warnings)

		{

		$warningcount += scalar(@{$warnings{$component}});

		}

  # Calculate the total number of migration notes

        $migrationNoteCount=0;

        foreach $component (sort {lc $a cmp lc $b} keys %migrationNotes)

                {

                $migrationNoteCount += scalar(@{$migrationNotes{$component}});

                }

  # Calculate the total number of Advisory notes

        $AdvisoryNoteCount=0;

        foreach $component (sort {lc $a cmp lc $b} keys %AdvisoryNotes)

                {

                $AdvisoryNoteCount += scalar(@{$AdvisoryNotes{$component}});

                }

  # Calculate the Total Duration from Phase Data

	$duration = 0;

	foreach $phase (sort {lc $a cmp lc $b} keys %Phases)

		{

		  $duration += $Phases{$phase};

		}

  # Start the Table

  &StartHTMLTable();

  # Print the Totals

  &HTMLTableRow($heading,"Total", $duration, $errorcount, $warningcount, $AdvisoryNoteCount, $remarkcount, $migrationNoteCount);

  # End the Table