Subversion Repositories DevTools

########################################################################
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
#
# Module name   : rmMerge_suckRelease.pl
# Module type   : JATS Utility
# Compiler(s)   : Perl
# Environment(s): jats
#
# Description   : Extact package-version data from RM
#
# Usage         : See POD at the end of this file
#
#......................................................................#

require 5.008_002;
use strict;
use warnings;

use Pod::Usage;
use Getopt::Long;

use JatsError;
use JatsRmApi;
use JatsSystem;
use FileUtils;
use ConfigurationFile;
use File::Copy;
use DBI;
my $RM_DB;
my $VERSION = "1.0";
my $newRMCred = ['NEW', 'jdbc:oracle:thin:@auawsards002:1521:RELEASEM', 'RM_READONLY', 'Tp8WmmDKMq2Z'];

my $opt_reuse=1;
my $opt_help=0;
my $opt_verbose=0;
my $opt_debug=0;
my $opt_outfile;
my $opt_rtagId;

our %rmData;
my @keyFields = qw(PV_ID RTAG_ID PROJ_ID PKG_ID CREATOR_ID RELEASOR_ID PARENT_RTAG_ID OFFICIAL_ID BASE_VIEW_ID INSERTOR_ID RCON_ID BM_CON_ID ROOT_PV_ID VTREE_ID SDKTAG_ID GBE_ID BMCON_ID);

my %keyFields = map {$_ => 1} @keyFields;
my %keyFieldsData;


#-------------------------------------------------------------------------------
# Function        : Mainline Entry Point
#
# Description     :
#
# Inputs          :
#
my $result = GetOptions (
                "help:+"        => \$opt_help,
                "manual:3"      => \$opt_help,
                "verbose:+"     => \$opt_verbose,
                "debug:+"       => \$opt_debug,
                "reuse!"        => \$opt_reuse,
                "outfile:s"     => \$opt_outfile,
                "rtagid:i"      => \$opt_rtagId,
                );

                #
                #   UPDATE THE DOCUMENTATION AT THE END OF THIS FILE !!!
                #

#
#   Process help and manual options
#
pod2usage(-verbose => 0, -message => "Version: $VERSION") if ($opt_help == 1 || ! $result);
pod2usage(-verbose => 1) if ( $opt_help == 2 );
pod2usage(-verbose => 2) if ( $opt_help > 2 );
pod2usage(-verbose => 0, -message => "Version: $VERSION") if ( $#ARGV >= 0 );

#
#   Configure the error reporting rmMerge_process now that we have the user options
#
ErrorConfig( 'name'    =>'SUCKRELEASE',
             'verbose' => $opt_verbose,
             'debug' => $opt_debug,
            );

  
#   Generate the output filename
#
$opt_outfile = join('.', $opt_rtagId, 'releaseinfo', 'txt') unless ($opt_outfile);
my $localDataStore = $opt_outfile;
  
$ENV{GBE_RM_LOCATION} = $newRMCred->[1];
$ENV{GBE_RM_USERNAME} = $newRMCred->[2];
$ENV{GBE_RM_PASSWORD} = $newRMCred->[3];
connectRM(\$RM_DB) unless ( $RM_DB );

unless (GetRelease( $opt_rtagId)){
    Error ("Release not found for rtag_id: $opt_rtagId");
}
Message("Extacting: $opt_rtagId to $opt_outfile");

#
#   Insert some basic information
#   
$rmData{METADATA}{RTAG_ID} = $opt_rtagId;

GetTableData('RELEASE_TAGS');
GetTableData('RELEASE_CONTENT');
GetTableData('PEGGED_VERSIONS');
GetTableData('ADVISORY_RIPPLE');
GetTableData('RELEASE_CONFIG');

#
#   Have the basic data - don't know about blobs !!!!
#   Need to extract, as text, those fields that are used for linkage purposes
#   PV_IDs, PKG_IDS
#
GetXrefsUsers(qw(CREATOR_ID RELEASOR_ID OFFICIAL_ID INSERTOR_ID ));
GetXrefsPvid(qw(PV_ID ROOT_PV_ID));
#GetXrefsPkg(qw(PKG_ID));
GetXrefsRtagId(qw( RTAG_ID PARENT_RTAG_ID ));
GetXrefsProjId(qw( PROJ_ID ));
GetXrefsBaseViewId(qw( BASE_VIEW_ID ));
GetXrefsGbeId(qw(GBE_ID ));

GetXrefsIgnore(qw( RCON_ID BMCON_ID ));                 # Primary keys - ignore
GetXrefsIgnore(qw( VTREE_ID SDKTAG_ID));         # Assume these have not changed

disconnectRM(\$RM_DB);
ErrorDoExit();
saveLocalData();

my @unProcessed;
foreach my $tableName (keys %keyFieldsData) {
    foreach my $name ( keys %{$keyFieldsData{$tableName}}) {
        foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
            push @unProcessed, "$tableName, $name, $key";
        }
    }
}

if (@unProcessed) {
    Error("Some the key fields have not been rmMerge_processed", @unProcessed )
}

exit 0;


#-------------------------------------------------------------------------------
# Function        : GetXrefsCommon 
#
# Description     : Common code for getting cross reference data 
#
# Inputs          : $refFields      - Ref to fields to rmMerge_process
#                   $tag           - Tag base name
#                   $sql            - Sql fragment 
#
# Returns         : 
#
sub GetXrefsCommon
{
    my ($refFields, $tag, $sql) = @_;
    my %idList;

    foreach my $name (@$refFields) {
        $rmData{XREF_MAP}{$name} = $tag;
    }

    foreach my $tableName (keys %keyFieldsData) {
        foreach my $name (@$refFields) {
            foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
                $idList{ $key} = 1;
            }
        }
    }
    return unless %idList;

    #
    #   Get all the table data
    #
    my %xRef;   
    my $m_sqlstr = $sql . " in (". join(',',keys %idList) .")";
    my $data = getDataFromRm('GetXrefsCommon:'. $tag, $m_sqlstr, {dump => 0} );

    #
    #   Post rmMerge_process the data
    #
    foreach my $row ( @{$data} ){
        $xRef{$row->[0]} = $row->[1];
    }

    #
    #   Create data structures
    #
    foreach my $tableName (keys %keyFieldsData) {
        my $tName = $tableName . "_XREF";
        foreach my $name (@$refFields) {
            foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
                DebugDumpData("Xref", \%xRef) unless exists $xRef{$key};
                ReportError("Cannot locate cross ref for $tableName, $name, $key") unless exists $xRef{$key} ;
                $rmData{$tName}{$tag}{$key} = $xRef{$key};
            }
            delete $keyFieldsData{$tableName}{$name};
        }
    }
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsBaseViewId 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsBaseViewId
{
    GetXrefsCommon( \@_, 'VIEW_ID',"select view_id, view_name from views where view_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsGbeId 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsGbeId
{
    GetXrefsCommon( \@_, 'GBE_ID',"select gbe_id, gbe_value from release_manager.gbe_machtype where gbe_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsProjId 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsProjId
{
    GetXrefsCommon( \@_, 'PROJ_ID',"select proj_id, proj_name from projects where proj_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsRtagId 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsRtagId
{
    GetXrefsCommon( \@_, 'RTAG_ID',"select rtag_id, rtag_name from release_tags where rtag_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsIgnore 
#
# Description     : Ignore the cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsIgnore
{
    my (@refFields) = @_;
    foreach my $tableName (keys %keyFieldsData) {
        foreach my $name (@refFields) {
            delete $keyFieldsData{$tableName}{$name};
        }
    }
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsPkg 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsPkg
{
    GetXrefsCommon( \@_, 'PKG_ID',"select p.pkg_id, p.pkg_name from release_manager.packages p where pkg_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsPvid 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsPvid
{
    GetXrefsCommon( \@_, 'PV_ID',"select pv.pv_id, p.pkg_name ||'$;'|| pv.pkg_version from release_manager.packages p, release_manager.package_versions pv where p.pkg_id = pv.pkg_id and pv.pv_id");
}

#-------------------------------------------------------------------------------
# Function        : GetXrefsUsers 
#
# Description     : Get cross references to other entites     
#
# Inputs          : list of keyFieldData keys to rmMerge_process
#
# Returns         : 
#
sub GetXrefsUsers
{
    GetXrefsCommon( \@_, 'USER_ID',"select user_id, user_name from access_manager.users where user_id");
}

#-------------------------------------------------------------------------------
# Function        : GetRelease 
#
# Description     : Get Details of a Release
#
# Inputs          : rtagId
#
# Returns         : A hash of data
#
sub GetRelease
{
    my ($rtagId) = @_;

    my $m_sqlstr = "select rtag_id, rtag_name from release_tags where rtag_id = $rtagId";
    my $data = getDataFromRm('GetRelease', $m_sqlstr, {oneRow => 1});
    return $data;
}

#-------------------------------------------------------------------------------
# Function        : GetTableData 
#
# Description     : Get all data from a table for the package
#                   Its pretty dumb
#
# Inputs          : $tableName 
#
# Returns         : 
#
sub GetTableData
{
    my ($tableName) = @_;
    my (@row);
    my @names;
    Verbose ("GetTableData: $tableName");

    #
    #   Get the list of table names
    #
    my $names = GetColumnNames($tableName);
    $rmData{$tableName . '_NAMES'} = $names;

    #
    #   Scan the colums looking for key names
    #   
    my %xref;
    my $index = 0;
    foreach my $entry ( @{$names}) {
        my $fname = $entry->[0];
        if ( exists $keyFields{$fname}) {
            $xref{$index} = $fname;    
        } elsif ( $fname =~ m~_ID~ ) {
            Error("Consider $fname in $tableName");
        }
        $index++;
    }

    #
    #   Get all the table data
    #   
    my $m_sqlstr = "select * from release_manager.$tableName where rtag_id = $opt_rtagId";
    my $sth = $RM_DB->prepare($m_sqlstr);
    if ( defined($sth) )
    {
        if ( $sth->execute( ) )
        {
            if ( $sth->rows )
            {
                while ( @row = $sth->fetchrow_array )
                {
                    my @data = @row;
                    escapeRowData(\@data);
                    push @{$rmData{$tableName . '_DATA'}}, \@data;

                    #
                    #   Extract key linkage fields as we go
                    #
                    while (my($index, $fname) = each %xref) {
                        my $data = $row[$index];
                        next unless defined $data;
                        next if length($data) == 0;
                        $keyFieldsData{$tableName}{$fname}{$row[$index]} = 1;
                    }
                }
            }
            $sth->finish();
        }
        else
        {
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
        }
    }
    else
    {
        Error("Prepare failure" );
    }
}

#-------------------------------------------------------------------------------
# Function        : GetColumnNames 
#
# Description     : Get Database information
#
# Inputs          : table to rmMerge_process 
#
# Returns         : Ref to an array of data
#
sub GetColumnNames
{
    my ($tableName) = @_;
    my (@row);
    my $found;
    my @names;
    Verbose ("GetColumnNames: $tableName");

    my $m_sqlstr = "select COLUMN_NAME, data_type, NULLABLE, COLUMN_ID from ALL_TAB_COLUMNS where TABLE_NAME='$tableName'";
    my $sth = $RM_DB->prepare($m_sqlstr);
    if ( defined($sth) )
    {
        if ( $sth->execute( ) )
        {
            if ( $sth->rows )
            {
                while ( @row = $sth->fetchrow_array )
                {
                    my @data = @row;
                    $names[$row[3]-1] = \@data;
#                    print join(' ', @row), "\n";
                    $found = 1;
                }
            }
            $sth->finish();
        }
        else
        {
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
        }
    }
    else
    {
        Error("Prepare failure" );
    }

    Error("Internal. Table not found: $tableName") unless $found;
    return \@names;
}

#-------------------------------------------------------------------------------
# Function        : escapeRowData 
#
# Description     : Given an array of data items massage the data so that special characters
#                   can be serailaized and deserailised via perl
#                   
#                   Special chars include: tab,newline, return
#                   
#                   At the moment there is not cross ref to the type of field
#                   Assume that if it has narsy data init then its a string
#                   and we don't do much to those
#
# Inputs          : $row    - Ref to an array
#
# Returns         : Nothing. Data is rmMerge_processed in place 
#
sub escapeRowData
{
    my ($row) = @_;
    foreach my $value ( @$row) {

        $value =~ s/([\t\r\n%'])/"%" . uc(sprintf "%2.2x" , unpack("C", $1))/eg;
    }
}



#-------------------------------------------------------------------------------
# Function        : saveLocalData 
#
# Description     : Saves a hash of data to disk 
#
# Inputs          : 
#
# Returns         : 
#
sub saveLocalData
{
    #
    #   Dump out the configuration information
    #
    my $fh = ConfigurationFile::New( $localDataStore);

    $fh->DumpData( "\n# rmData\n#\n", "rmData", \%rmData );
    $fh->Close();

    #DebugDumpData("rmData", \%rmData);
}

#-------------------------------------------------------------------------------
# Function        : restoreLocalData 
#
# Description     : Read in the locally preserved data 
#
# Inputs          : 
#
# Returns         : 
#
sub restoreLocalData
{
    if (-f $localDataStore) {
        require ( $localDataStore );
    }
}

#-------------------------------------------------------------------------------
# Function        : getDataFromRm 
#
# Description     : Get an array of data from RM 
#
# Inputs          : $name           - Query Name
#                   $m_sqlstr       - Query
#                   $options        - Ref to a hash of options
#                                       sql     - show sql
#                                       data    - show data
#                                       dump    - show results
#                                       oneRow  - Only feth one row
#                                       error   - Must find data
#                                       
# Returns         : 
#
sub getDataFromRm
{
    my ($name,$m_sqlstr, $options ) = @_;
    my @row;
    my $data;

    if (ref $options ne 'HASH') {
        $options = {}; 
    }

    if ($options->{sql}) {
        Message("$name: $m_sqlstr")
    }
    my $sth = $RM_DB->prepare($m_sqlstr);
    if ( defined($sth) )
    {
        if ( $sth->execute( ) ) {
            if ( $sth->rows ) {
                while ( @row = $sth->fetchrow_array ) {
                    if ($options->{data}) {
                        Message ("$name: @row");
                    }
                    #Debug0("$name: @row");
                    push @{$data}, [@row];

                    last if $options->{oneRow};
                }
            }
            $sth->finish();
        } else {
            Error("Execute failure:$name: $m_sqlstr", $sth->errstr() );
        }
    } else {
        Error("Prepare failure:$name" );
    }

    if (!$data && $options->{error}) {
        Error( $options->{error} );
    }

    if ($data && $options->{oneRow}) {
        $data = $data->[0];
    }
 
    if ($options->{dump}) {
        DebugDumpData("$name", $data);
    }
    return $data;
}


#-------------------------------------------------------------------------------
#   Documentation
#

=pod

=for htmltoc    GENERAL::ClearCase::

=head1 NAME

rmMerge_suckRelease - Extract Release Information from RM

=head1 SYNOPSIS

jats rmMerge_suck [options] PackageName PackageVersion

 Options:
    -help              - brief help message
    -help -help        - Detailed help message
    -man               - Full documentation
    -outfile=name      - Name of the output file (optional)
    -rtagid=rtag       - Identify the release

=head1 OPTIONS

=over 8

=item B<-help>

Print a brief help message and exits.

=item B<-help -help>

Print a detailed help message with an explanation for each option.

=back

=head1 EXAMPLE

jats rmMerge_suckRelease -rtagId=xxxxx

=cut