Subversion Repositories DevTools

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

# Copyright (C) 1998-2012 Vix Technology, All rights reserved

#

# Module name   : ReleasedPackageReport.pl

# Module type   : Makefile system

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : Script to create a daily report to track new packages

#                 released into dpkg_archive

#

#                 Script should be run once a day

#

# Usage:

#

# Version   Who      Date        Description

#

#......................................................................#

require 5.008_002;

use strict;

use warnings;

use Pod::Usage;

use Getopt::Long;

use File::Temp qw/ tempfile tempdir /;

use JatsError;

use JatsRmApi;

use JatsSystem;

#

#   Global data

#

my $logbase = '/home/releasem/logs/';

my @logData;

my %RevData;

my $RM_DB;

my $logfile;

my $datafile;

my $dataname;

my @mailList = (qw (

    David.Purdie@vixtechnology.com

    ));

my @alsoMail = (qw(John.Rowling@vixtechnology.com));

#-------------------------------------------------------------------------------

# Function        : Main

#

# Description     : Main entry point

#

# Inputs          : 

#

# Returns         : 

#

#

#   Program may run under cron

#   Extend the path

#

my $PATH = $ENV{PATH};

my $HOME = $ENV{HOME};

if ( $HOME )

{

    $PATH = "$HOME/bin:$HOME/cron:$PATH";

    $ENV{PATH} = $PATH;

}

#

#   Program will call itself to do hard work

#   If the 1st arg is INVOKE, then generate report and exit

#       This will create

#

#

if ( $ARGV[0] && $ARGV[0] eq 'INVOKE' )

{

    generateReport($ARGV[1], $ARGV[2]);

    exit 0

}

#

#   Determine report details

#   Determine yesterdays report

#

my $logname;

if ( $ARGV[0] )

{

    $logname = $ARGV[0];

}

else

{

    my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time - 24*60*60);

    $logname = sprintf("release.%4.4d.%2.2d.%2.2d.log", $year+1900, $mon +1, $mday);

}

Error ("Bad format for argument" ) unless( $logname =~ m~\.log$~ );

$dataname = $logname;

$dataname =~ s~\.log$~.csv~;

#

#   Create a temp file to capture the output of the report generation

#   This will include all errors

#

(undef,$logfile) = tempfile();

$datafile = '/tmp/' . $dataname;

#print "Temp file: $logfile\n";

#print "logname  : $logname\n";

#print "Data file: $datafile\n";

open STDOUT, '>', $logfile  or die "Can't redirect STDOUT: $!";

open STDERR, ">&STDOUT"         or die "Can't dup STDOUT: $!";

#

#   Invoke myself again to create the body of the report

#

my $rv = JatsCmd ('eprog', __FILE__, 'INVOKE', $logname, $datafile );

#print ("Rv: $rv\n");

#

#   Mail the report

#

my @mailAttachments;

push (@mailAttachments, '-a', $datafile ) if ( -f $datafile );

System ('sendEmail.pl'

            , '-f', 'buildadm@vixtechnology.com'

            , '-t',  join(',', @mailList)

            , '-u', 'Release Package Report: ' . $logname

            , '-o', "message-file=$logfile"

            , '-o', 'message-content-type=html'

            , '-q'

            , @mailAttachments

            );

unlink $logfile;

unlink $datafile;

print "All Done\n";

exit $rv;

#-------------------------------------------------------------------------------

# Function        : generateReport

#

# Description     : 

#

# Inputs          : $logname                    - Logfile name

#

# Returns         : 

#

sub generateReport

{

    my ($logname, $datafile) = @_;

#    $logname = "release.2012.03.28.log";

    Message ("logname: $logname");

    #

    #   Read and parse the log file

    #

    my $logfile = $logbase . $logname;

    my $fileError;

    open (my $log, '<', $logfile ) || ($fileError = 1);

    if ( $fileError )

    {

        Error "Cannot open log file: $logfile\n";

        exit 1;

    }

    while ( <$log> )

    {

        s~\s+$~~;

        next unless ( m~ make_release_changed ~ );

#print "$_\n";

        my %data;

        while ( m~(\w+)=("(.*?)"|(\d+))~ )

        {

            my $mb = $-[0];                     # Match begin offset

            my $me = $+[0];                     # Match end

            $data{$1} = $3 || $4;

    #print "$1 ---- $data{$1}\n";

            substr( $_, $mb, $me - $mb, '');

        }

        push @logData, \%data;

    }

    #

    #   Query the release manager database for info

    #

    foreach my $entry ( @logData )

    {

        getPkgDetailsByPVID ( $entry->{pv_id}, $entry );

    }

    #DebugDumpData("RevData", \%RevData );

    #

    #   Generate some nice data

    #   Sort by name

    #

    my %summary;

    open ( DATA, '>', $datafile ) || Error ("Cannot open $datafile");

    {

        my @data;

        push @data,'CodeReview','CodeStriker','AutoTest','ManualTest','OtherTest','PackageName','PackageVersion';

        print DATA join(',', @data), "\n";

    }

    print "<h1>Released Package Report</h1>\n";

    print "<pre style=\"font-size: medium\">\n";

    foreach my $entry ( sort {lc($a->{pkg_name}) cmp lc($b->{pkg_name}) } @logData )

    {

        my $pvid = $entry->{pv_id};

        $summary{PackagesReleased}++;

        my $crm = exists $RevData{$pvid}{CodeReview} ? 'M' : '-';

        my $crs = exists $RevData{$pvid}{CodeStriker} ? 'S' : '-';

        $summary{CodeReview}++ if exists $RevData{$pvid}{CodeReview};

        $summary{CodeStriker}++ if exists $RevData{$pvid}{CodeStriker};

        my $utestauto = '.';

        my $utestmanual = '.';

        my $testOther = '.';

        my $utest= $RevData{$pvid}{UnitTest};

        if ( defined $utest )

        {

            if ( $utest == 7  ) {

                $utestauto='A';

                $summary{AutoTest}++;

            } elsif ( $utest == 6  ) {

                $utestmanual = 'I';

                $summary{ManualTest}++;

            } else {

                $testOther = 'O';

                $summary{OtherTest}++;

            }

        }

        print "$crm$crs $utestauto$utestmanual$testOther $entry->{pkg_name}, $entry->{pkg_version}";

        print "\n";

        #

        #   Generate Data file too

        #

        my @data;

        push @data,$crm,$crs,$utestauto,$utestmanual,$testOther,$entry->{pkg_name},$entry->{pkg_version};

        print DATA join(',', @data), "\n";

    }

    close DATA;

    print "\n<hr>";

    print "<h2>Ledgend</h2>";

    print "Column-1: M: Package has a manual code review entry\n";

    print "Column-2: S: Package has a code striker review entry\n";

    print "\n";

    print "Column-4: A: Automated unit test performed with build\n";

    print "Column-5: I: Package marked as having an interactive test (often misused)\n";

    print "Column-6: O: Package marked as having some other form of test\n";

    print "<h2>Summary</h2>";

    print "Generated at            : ",scalar localtime() ,"\n";

    print "Logfile                 : $logname\n";

    print "Total Packages Released : ", $summary{PackagesReleased} || 0,"\n";

    print "With Code Review        : ", $summary{CodeReview}       || 0 ,"\n";

    print "With CodeStriker Entry  : ", $summary{CodeStriker}      || 0 ,"\n";

    print "With build test         : ", $summary{AutoTest}         || 0 ,"\n";

    print "Marked with Manual Test : ", $summary{ManualTest}       || 0 ,"\n";

    print "Marked with other Test  : ", $summary{OtherTest}        || 0 ,"\n";

    print "</pre>\n";

}

exit 0;

#-------------------------------------------------------------------------------

# Function        : getPkgDetailsByPVID

#

# Description     : Get Package Details

#

# Inputs          : 

#

# Returns         : 

#

sub getPkgDetailsByPVID

{

    my ($PVID, $entry) = @_;

    my (@row);

#print "---processing: $PVID\n";

    return unless ( $PVID );

    $RevData{$PVID}{ProcCount}++;

    $RevData{$PVID}{Entry} = $entry;

    # if we are not or cannot connect then return 0 as we have not found anything

    connectRM(\$RM_DB) unless ( $RM_DB );

    # First get details from pv_id

    my $m_sqlstr = "SELECT crev.PV_ID, crev.DATE_OF_REVIEW" .

                   " FROM release_manager.CODE_REVIEWS crev" .

                   " WHERE crev.PV_ID = $PVID";

    my $sth = $RM_DB->prepare($m_sqlstr);

    if ( defined($sth) )

    {

        if ( $sth->execute( ) )

        {

            if ( $sth->rows )

            {

                while ( @row = $sth->fetchrow_array )

                {

#                    print "@row\n";

                    $RevData{$PVID}{CodeReview} = 1;

                }

            }

            $sth->finish();

        }

    }

    else

    {

        Error("Prepare failure" );

    }

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

    $m_sqlstr = "SELECT curl.PV_ID, curl.CR_ID" .

                   " FROM release_manager.CODE_REVIEW_URL curl" .

                   " WHERE curl.PV_ID = $PVID";

    $sth = $RM_DB->prepare($m_sqlstr);

    if ( defined($sth) )

    {

        if ( $sth->execute( ) )

        {

            if ( $sth->rows )

            {

                while ( @row = $sth->fetchrow_array )

                {

#                    print "@row\n";

                    $RevData{$PVID}{CodeStriker} = 1;

                }

            }

            $sth->finish();

        }

    }

    else

    {

        Error("Prepare failure" );

    }

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

    # TEST_TYPES_FK values

    #

    #   1	Not Done

    #   2	Coverage

    #   3	Performance

    #   4	Memory

    #   5	Automatic Unit Test

    #   6	Interactive Unit Test

    #   7	Autobuild UTF

    #

    $m_sqlstr = "SELECT utest.PV_ID, utest.TEST_TYPES_FK" .

                   " FROM release_manager.UNIT_TESTS utest" .

                   " WHERE utest.PV_ID = $PVID and utest.TEST_TYPES_FK  != 1";

    $sth = $RM_DB->prepare($m_sqlstr);

    if ( defined($sth) )

    {

        if ( $sth->execute( ) )

        {

            if ( $sth->rows )

            {

                while ( @row = $sth->fetchrow_array )

                {

#                    print "@row\n";

                    $RevData{$PVID}{UnitTest} = $row[1];

                }

            }

            $sth->finish();

        }

    }

    else

    {

        Error("Prepare failure" );

    }

}