Subversion Repositories DevTools

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

# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

#

# Module name   : rmMerge_migrate_package.pl

# Module type   : JATS Utility

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : Migrate a package-version from the Pulse RM to the one-true RM (old)

#

# 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 JatsProperties;

use File::Copy;

use DBI;

my $RM_DB;

my $oldRMWrite = ['OLD', 'jdbc:oracle:thin:@auawsards001:1521:RELEASEM', 'RELEASE_MANAGER', 'ske2k0se'];

my $oldRMCred  = ['OLD', 'jdbc:oracle:thin:@auawsards001:1521:RELEASEM', 'RM_READONLY', 'RM_READONLY'];

my $newRMCred  = ['NEW', 'jdbc:oracle:thin:@auawsards002:1521:RELEASEM', 'RM_READONLY', 'Tp8WmmDKMq2Z'];

my $newDpkg = '/net/auawsaarc002/export/devl/dpkg_archive';

my $oldDpkg = '/export/devl/dpkg_archive';

my $VERSION = 1.0;

my $opt_help=0;

my $opt_verbose=0;

my $opt_debug=0;

my $opt_reuseRm;

my $opt_justRm;

my $opt_test = 0;

my $opt_history;

my $opt_nohistory;

my $opt_relabel;

my $opt_placekeeper;

my $opt_autoPlacekeeper;

my $opt_base=0;

my $opt_after;

my $pname;

my $pversion;

my $SplitPvid = 1150630;

my $newData;

my $oldData;

my $mergeData;

my $newView;

my $tipView;

my $newRmData;

my %newSvnData;

my %oldSvnData;

my $isaNewPackage;

my $afterPvid;

my $dirOut = 'migrate';

my $dirWork = catdir( $dirOut, 'work');

my $dirLog  = catdir ($dirOut, 'log');

mkdir ($dirOut);

mkdir ($dirWork);

mkdir ($dirLog);

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

# Function        : Mainline Entry Point

#

# Description     :

#

# Inputs          :

#

my $result = GetOptions (

                "help:+"        => \$opt_help,

                "manual:3"      => \$opt_help,

                "verbose:+"     => \$opt_verbose,

                "debug:+"       => \$opt_debug,

                "reuseRm!"      => \$opt_reuseRm,

                "justRm!"       => \$opt_justRm,

                "test:+"        => \$opt_test,

                "historyTo:s"   => \$opt_history,

                "nohistory"     => \$opt_nohistory,

                "relabel!"      => \$opt_relabel,

                "placekeeper!"  => \$opt_placekeeper,

                "autoplacekeeper!"  => \$opt_autoPlacekeeper,

                "base:+"         => \$opt_base,

                "after:s"       => \$opt_after,

                );

                #

                #   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 != 1 );

#

#   Configure the error reporting rmMerge_process now that we have the user options

#

ErrorConfig( 'name'    =>'MIGRATE',

             'verbose' => $opt_verbose,

             'debug' => $opt_debug,

             'on_exit' => \&cleanup

            );

$pname = $ARGV[0];  

$pversion = $ARGV[1];

InitFileUtils();

testPath($newDpkg);

testPath($oldDpkg);

Message ("Migrating: $pname $pversion");

MassageVersion();

#

#   Lots of sanity testing

#       Make sure it has not already been transferred

#       Locate the marked package merge point

#

$newData = checkVersion($newRMCred);

Error ("Package does not exist in Pulse RM ") unless $newData;

$oldData = checkVersion($oldRMCred);

Error ("Package already exist in Old RM ") if $oldData && !$opt_reuseRm;

Error ("Package does not exist in Old RM ") if ! $oldData && $opt_reuseRm;

if ($opt_after) {

    if ($opt_after eq $pversion) {

        Warning("Attempt to insert after myself - after option ignored");

        $opt_after = undef;

    } else {

        $afterPvid = checkVersionExists($oldRMCred, $pname, $opt_after);

        Error ("Named (after) version does not exist: $opt_after") unless $afterPvid;

    }

}

checkDependentPackages() unless $opt_placekeeper;

findMergePoint();

Error("Just testing the dependencies and insertion point") if ($opt_test == 1);

unless ($opt_reuseRm) {

    # Serialse the package data

    $newRmData = catfile( $dirLog, join('.', $pname, $pversion, 'rminfo', 'txt'));

    unlink $newRmData;

    Message ("Caputure Rm Data: $newRmData") ;

    my $rv = JatsCmd('eprog', 'rmMerge_suck.pl', $pname, $pversion, '-outfile', $newRmData);

    Error ("rmMerge_suck - failed") if $rv;

    Error ("Extracted data not found - $newRmData") unless -f $newRmData;

    # Insert new package into the old Release Manager

    Message("Create package in Release Manager");

    my @args;

    unless ($isaNewPackage) {

        Error("Internal: Merge Version not found") unless ( $mergeData->[3] );

        push @args, '-previous', $mergeData->[3];

    } else {

        push @args, '-newPackage';

    }

    push (@args ,'-placekeeper') if $opt_placekeeper;

    push (@args ,'-placekeeper') if $opt_placekeeper;

    push (@args, '-toHistory', $opt_history) if $opt_history;

    push (@args, $opt_nohistory ? '-noHistory' : '-history');

    $rv = JatsCmd('eprog', 'rmMerge_spit.pl', $pname, $pversion, '-infile', $newRmData, @args );

    Error("Package data not inserting into Release Manager") if $rv;

    # Add the package to a 'dummy' Release

    addToRelease();

}

Error("Stopped after RM import") if $opt_justRm;

# Now migrate the package into Subversion

#   Extract the new version - may already have been done

svnInsertNewPackage();

# Transfer the dpkg_archive objects

#

dpkgTransfer();

cleanup();

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

# Function        : MassageVersion 

#

# Description     : Massage the provided version number. MAy set it to the base ripple

#

# Inputs          : 

#

# Returns         : 

#

sub MassageVersion

{

    return unless $opt_base;

    if ($pversion =~ m~(.*)(\.\d+)(\d{3})(\.[\w]+)~) {

        my ($p1,$p2,$p3,$p4) = ($1,$2,$3,$4);

        $p3 = '000';

        $p2 = '.0' if $opt_base > 1;

        $pversion = $p1 . $p2 . '000' . $p4;

        Message ("Base Non Ripple: $pname $pversion");

    } else {

        Error ("Cannot massage: $pversion");

    }

}

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

# Function        : addToRelease 

#

# Description     : Add the package to a 'dummy' release

#                   The rtagId is 38670 - temp and will be deleted one day

#

# Inputs          : 

#

# Returns         : 

#

sub addToRelease 

{

    my $user = 3768;            # buildadm

    my $rtagId = 38670;         # Known Release 

    #

    #   Determine the PVID of the new package

    #

    $oldData = checkVersion($oldRMCred);

    Error("Internal: Can't find added package in Release Manager") unless $oldData;

    Message ("addToRelease");

    my $m_sqlstr =  "BEGIN RELEASE_MANAGER.PK_RELEASE.ADD_PACKAGE ( $oldData->[0], 1723, $rtagId, $user );   END;";

    getDataFromRm('addToRelease', $m_sqlstr, $oldRMWrite);

    #   Force the Release Icons to be rebuilt

    $m_sqlstr =  "BEGIN RELEASE_MANAGER.TOUCH_RELEASE ( $rtagId ); END;";

    getDataFromRm('addToRelease', $m_sqlstr, $oldRMWrite);

}

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

# Function        : dpkgTransfer 

#

# Description     : Transfer the generated package

#                   It may not exist 

#

# Inputs          : 

#

# Returns         : 

#

sub dpkgTransfer

{

    #

    #   Ensure the package exists in the 'pulse' dpkg_archive

    #

    my $srcDir = catdir($newDpkg, $pname, $pversion);

    unless (-d $srcDir) {

        Warning("Package not found in dpkg_archive", $srcDir);

        return;

    }

    my $dstDir = catdir ($oldDpkg, $pname);

    my $dstPkg = catdir ($oldDpkg, $pname, $pversion);

    Message("Source: $srcDir") ;

    Message("Target: $dstDir");

    Error ("Package already exists: $dstPkg ") if -x $dstPkg;

    if ( ! -d $dstDir) {

        Message ("Create Package directory: $pname, $dstDir");

        mkdir $dstDir;

    }

    testPath( $dstDir );

    System ('--Show','cp', '-a', $srcDir, $dstDir);

    Error("Package not copied") unless -d $dstPkg;

    #   Need to set the facl stuff - its not done by the 'cp' command 

    System('setfacl', '-R', '-x', 'user:releasem',$dstPkg);

    System('setfacl', '-R', '-x', 'user:buildadm',$dstPkg);

    System('setfacl', '-R', '-x', 'group:ccperdev',$dstPkg);

    System('setfacl', '-R', '-m', 'default:user:buildadm:rwx','-m','default:user::rwx','-m','mask::r-x',$dstPkg);

    System('setfacl', '-R', '-m', 'user::r-X,group::r-X,other::r-X',$dstPkg);

}

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

# Function        : testPath 

#

# Description     : Test that a directory exists

#

# Inputs          : $path

#

# Returns         : Returns PATH

#                   Will not return on error

#

sub testPath

{

    my ($path) = @_;

    Debug("Testing: $path");

    return $path if -d $path;

    Error ("Path not found: $path");

}

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

# Function        : svnInsertNewPackage 

#

# Description     : Insert the new package version into subversion

#

# Inputs          : 

#

# Returns         : 

#

sub svnInsertNewPackage

{

    my $rv;

    #

    #   Get data about the new version of the package

    #   The information has already been inserting into the RM database

    #

    getReleaseData(\%newSvnData, $newRMCred);

    getReleaseData(\%oldSvnData, $oldRMCred);

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

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

    #

    #   Extract the 'new' package files into a known area

    #   Don't need the .svn info - just the files

    #   This may have been done in previous step

    #       Locate is stored in $newView

    #

    checkoutNewPackage();

    Error ("Internal. Source package not found: $newView") unless ( $newView  && -d $newView) ;

    #

    #   Extract the 'old' package files into a known area

    #   Need svn info

    #   Need to massage the newVcs to extract the tip of the package in the old system

    #       Assume its in the same location

    #       Assume we are simply appending the new version to the tip of the old version

    #       

    my $tipName = join('_', $pname, $pversion, 'tip');

    my $tipVcs = $isaNewPackage ? $oldSvnData{VCS_TAG}: $mergeData->[4];

    $tipVcs =~ s~::AUPERASVN0X~::AUPERASVN01~;

    $tipVcs =~ s~\@.*~~;

    my $svnUrl = $tipVcs;

    $svnUrl =~ m~^SVN::(.*)::~;

    $svnUrl = $1;

    my $pkgBase = $svnUrl;

    $pkgBase =~ s~/[^/]*$~~;

    $pkgBase =~ s~/branches$~~;

    $tipView = catdir($dirWork,$tipName );

    #

    #   Determine if we need to branch this view

    #   Do this before we create the view

    #       If branching - then do an extact extract

    #       Else - do a tip extract

    #

    my $mustBranch = 0;   

    my $branchname;

    my $pkgext = $mergeData->[2];

    if ($pkgext =~ m~PulseImport.Branch.(.*)~) {

        $branchname = $1;

Debug0("Import to branch: $branchname");

        my $coBranch = 'trunk';

        if ($mergeData->[4] =~ m~/branches::(.*)~ ){

            $coBranch = $1;

            $coBranch =~ s~\@.*~~;

        }

Debug0("View is on: $coBranch");

       $mustBranch = ($branchname ne $coBranch);

    }

    RmDirTree($tipView);

    if ($isaNewPackage) {

        JatsToolPrint ( 'jats_svn', 'create', $pkgBase );

    }

    Message("Extract Tip: $tipVcs");

    JatsCmdPrint('-logfile', catfile($dirLog, $tipName.'.log'),'jats_vcsrelease.pl', '-extract', '-noprefix', 

                    '-root',$dirWork, 

                    '-view', $tipName ,

                    '-label', $tipVcs, 

                    $mustBranch ? '-devMode=Work' : '-devMode=Tip' );

    #

    #   Need to branch this view

    #       Check for branch existence - error if it doesnt exist

    #

    if ($mustBranch) {

        SystemConfig ('ExitOnError' => 0);

        $rv = JatsToolPrint ( 'jats_svnlabel', '-check', '-packagebase', $pkgBase, '-branch', $branchname );

        if ($rv) {

            Message ("Create Branch: $branchname");

            $rv  = JatsToolPrint ( 'jats_svn', 'branch', $branchname, '-path', AbsPath($tipView) );

            Error("Cannot create branch: $branchname") if $rv;

        } else {

            Message ("Switch to branch: $branchname");

            $rv  = JatsToolPrint ( 'jats_svn', 'switch', $branchname, '-path', AbsPath($tipView) );

            Error("Cannot switch to branch: $branchname") if $rv;

        }

        SystemConfig ('ExitOnError' => 1);

    }

    #

    #   Use the 'jats svn import' utility

    #       It will do most of the hard work as it was developed to support the ClearCase to Subversion migration

    #

    my $dataFile = catfile($dirLog, "${pname}_${pversion}.dat");

    my @args;

    #push (@args, '-replace') if $opt_replace;

    if ($oldSvnData{COMMENTS}) {

        push @args, '-log', $oldSvnData{COMMENTS}

    }

    if ($oldSvnData{MODIFIER_NAME}) {

        push @args, '-author', $oldSvnData{MODIFIER_NAME}

    }

    my $created = $oldSvnData{MODIFIED_STAMP};

    if ( $created )

    {

        $created =~ s~ ~T~;

        $created .= '00000Z';

        push @args, '-date', $created;

    }

    if ($opt_relabel) {

        push @args, '-replace';

    }

    Message("Subverion Merge Package");

    $rv = JatsCmdPrint ('-logfile', catfile($dirLog, "${pname}_${pversion}.import.log"), 'jats_svn', 'import', $pkgBase, '-reuse', '-workspace', $tipView,

                   '-dir' , $newView, '-datafile' ,  $dataFile, '-label', "${pname}_${pversion}", @args);

    Error ("Could not import package from OLD RM") if $rv;

    #

    #   Extract the Release Manager tag

    #   Needs to be inserted into the database

    #   

    my $data;

    if ( -f $dataFile  )

    {

        my $rmData = JatsProperties::New($dataFile);

        if ( $rmData->getProperty('subversion.tag') ) {

            $data->{rmRef} = 'SVN::' . $rmData->getProperty('subversion.tag');

        } else {

            Warning ("Property files has no subversion.tag");

        }

        $data->{fileCount}    = $rmData->getProperty('files.base', 0);

        $data->{filesRemoved} = $rmData->getProperty('files.removed',0);

        $data->{filesAdded}   = $rmData->getProperty('files.added',0);

    }

    unless ( $data->{rmRef}  )

    {

        $data->{errStr} = 'Failed to determine Rm Reference';

        Error ($data->{errStr});

    }

    intoReleaseManager( $oldSvnData{PV_ID}, "${pname}_${pversion}", $data->{rmRef}, $oldRMCred);

}

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

# Function        : JatsToolPrint

#

# Description     : Print and Execuate a JatsTool command

#

# Inputs          : 

#

# Returns         : 

#

sub JatsToolPrint

{

    Information ("Command: @_");

    return JatsTool @_;

}

sub JatsCmdPrint

{

    Information ("Command: @_");

    return JatsCmd @_;

}

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

# Function        : intoReleaseManager

#

# Description     : Update VCS tags in RM

#

# Inputs          : $pvid           - PVId

#                   $pvname         - Package Version (text)

#                   $tag            - New Tag

#

# Returns         : 

#

sub intoReleaseManager

{

    my ($pvid, $pvname, $new_tag, $rmRef ) = @_;

    my $user = 3768;            # buildadm

    Message ("Update SVN tag: $pvid, $pvname  - $new_tag");

    my $m_sqlstr =  "begin release_manager.PK_RMAPI.update_vcs_details($pvid, '$new_tag', $user); end;";

    getDataFromRm('intoReleaseManager', $m_sqlstr, $rmRef);

}

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

# Function        : getReleaseData 

#

# Description     : Get some essential data

#

# Inputs          : dataRef

#                   RmCredentails 

#

# Returns         : 

#

sub getReleaseData

{

    my ($dataRef, $rmRef) = @_;

    my $m_sqlstr = <<"SQL_END";

        SELECT

            pv.pv_id,

            pv.src_path,

            pv.pkg_label,

            release_manager.PK_RMAPI.return_vcs_tag(PV_ID) as vcsTag,

            pv.comments,

            u.user_name,

            pv.modified_stamp

        FROM

            package_versions pv,

            packages p,

            users u

        WHERE

            p.pkg_id = pv.pkg_id

            AND p.pkg_name = ':pname'

            AND pv.pkg_version = ':pversion'

            AND pv.modifier_id = u.user_id

SQL_END

    $m_sqlstr =~ s~:pname~$pname~g;

    $m_sqlstr =~ s~:pversion~$pversion~g;

    my $data = getDataFromRm('getReleaseData', $m_sqlstr, $rmRef, {oneRow => 1, error =>  "getReleaseData: No data found"  });

    $dataRef->{PV_ID}           = $data->[0]; 

    $dataRef->{SRC_PATH}        = $data->[1]; 

    $dataRef->{PKG_LABEL}       = $data->[2]; 

    $dataRef->{VCS_TAG}         = $data->[3]; 

    $dataRef->{COMMENTS}        = $data->[4]; 

    $dataRef->{MODIFIER_NAME}   = $data->[5]; 

    $dataRef->{MODIFIED_STAMP}  = $data->[6]; 

}

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

# Function        : checkDependentPackages 

#

# Description     : Check that ALL dependent packages of the 'new' version exist

#                   in the old Release Manager 

#

# Inputs          : 

#

# Returns         : Will not return if dependencies are missing 

#

sub checkDependentPackages

{

    #

    #   Determine the package dependencies

    #

    my $m_sqlstr = <<"END_SQL";

SELECT

    p2.pkg_name,

    pv2.pkg_version

FROM

    package_versions pv,

    package_versions pv2,

    packages p,

    packages p2,

    package_dependencies pd

WHERE

    p.pkg_id = pv.pkg_id

    AND p.pkg_name = '$pname'

    AND pv.pkg_version = '$pversion'

    and pv.pv_id = pd.pv_id

    and pd.dpkg_id = p2.pkg_id

    and pd.dpv_id = pv2.pv_id

END_SQL

    my $data = getDataFromRm('checkDependentPackages', $m_sqlstr, $newRMCred);

    return unless $data;

    #

    #   Examine each dependency

    #

    foreach my $entry ( @{$data}) {

        Verbose("Check for: $entry->[0], $entry->[1]");

        my $pvid = checkVersionExists($oldRMCred, $entry->[0], $entry->[1]);

        unless ($pvid) {

            if ($opt_autoPlacekeeper) {

                Warning("Required Dependency not found: $entry->[0], $entry->[1]", "Others not tested");

                $opt_placekeeper = 1;

                last;

            } else {

                ReportError("Required Dependency not found: $entry->[0], $entry->[1]");

            }

        }

    }

    ErrorDoExit();

}

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

# Function        : cleanup 

#

# Description     : Cleanup created stuff

#

# Inputs          : 

#

# Returns         : 

#

sub cleanup

{

    Message("Cleanup");

    #Debug0("Leaving: newView", $newView);

    #Debug0("Leaving: tipView", $tipView);

    RmDirTree($newView);

    RmDirTree($tipView);

}

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

# Function        : findMergePoint 

#

# Description     : Determine the point at which the package will be inserted into the old RM

#                   This may have been marked in the OLD rm database

#

# Inputs          : 

#

# Returns         : 

# 

sub findMergePoint

{

    my $m_sqlstr;

    #

    #   Use merge point specifed by 'after'

    #   

    if ($opt_after) {

        $m_sqlstr = <<"END_SQL";

    SELECT

        pv.pv_id,

        pv.pkg_id,

        pv.pkg_idext,

        pv.pkg_version,

        release_manager.PK_RMAPI.return_vcs_tag(PV_ID)

    FROM

        release_manager.package_versions pv,

        release_manager.packages p

    WHERE

      pv.pv_id = $afterPvid

END_SQL

        my $data = getDataFromRm('findMergePoint', $m_sqlstr, $oldRMCred, {oneRow => 1, error => "findMergePoint-After. No RMdata", sql => 0});

        $mergeData = $data;

        Message("Merge Point specified by user - after $opt_after");

        return;

    }

    #

    # Determine if a branchpoint has been marked on the package

    #

    $m_sqlstr = <<"END_SQL";

    SELECT * FROM (

        SELECT

            pv.pv_id,

            pv.pkg_id,

            pv.pkg_idext,

            pv.pkg_version,

            release_manager.PK_RMAPI.return_vcs_tag(PV_ID)

        FROM

            release_manager.package_versions pv,

            release_manager.packages p

        WHERE

            p.pkg_id = pv.pkg_id

            AND p.pkg_name = '$pname'

            AND pv.pkg_idext IS NOT NULL

        ORDER by pv.pv_id desc  )

    WHERE ROWNUM = 1

END_SQL

    my $data = getDataFromRm('findMergePoint', $m_sqlstr, $oldRMCred, {oneRow => 1, data => 0});

    if ($data) {

        $mergeData = $data;

        Message("Merge Point specified in Release Manager");

    } else {

        #

        #   Merge point has not been marked

        #       If the package name does not exist, then its a new package

        $m_sqlstr = <<"END_SQL";

    SELECT

        count(*)

    FROM

        release_manager.packages p, package_versions pv

    WHERE

        p.pkg_name = '$pname'

        and pv.pkg_id = p.pkg_id

        and pv.v_ext = '$newData->[5]'

END_SQL

       $data = getDataFromRm('findMergePoint', $m_sqlstr, $oldRMCred, {oneRow => 1, sql => 0});

       unless ($data && $data->[0] > 0 ) {

           #

           #   Package does not exist at all in Release Manager

           #   Flag new package creation

           #

           $isaNewPackage = 1;

           Message("New Package: $pname");

           $mergeData->[2] = '';

           $mergeData->[4] = '';

           return;

       }

        #   See if we can guess it.

        #       Get the most recent (non-ripple) package-version

        #       See how much it differs from the new version

        #

        $m_sqlstr = <<"END_SQL";

    SELECT

        pv.pv_id,

        pv.pkg_id,

        pv.pkg_idext,

        pv.pkg_version,

        release_manager.PK_RMAPI.return_vcs_tag(PV_ID)

    FROM

        release_manager.package_versions pv,

        release_manager.packages p

    WHERE

        p.pkg_id = pv.pkg_id

        AND p.pkg_name = '$pname'

        and pv.build_type = 'A'

    ORDER by pv.pv_id desc

END_SQL

        my $data = getDataFromRm('findMergePoint', $m_sqlstr, $oldRMCred, {oneRow => 1, error => "findMergePoint. No RMdata", sql => 0});

        #

        #   If the 'most recent' version is before the split, then nothing has changed in the old system

        #   We can determine the merge point.

        #

        if ($data->[0] < $SplitPvid ) {

            Message("Most Recent version is before split");

            if ( my $baseVersion = checkForBaseVersion( $data->[0], $data->[3]) ) {

                $data = $baseVersion;

            }

            $mergeData = $data;

        } else {

           if ( my $baseVersion = checkForBaseVersion( $data->[0], $data->[3]) ) {

               if ($baseVersion && $baseVersion->[0] < $SplitPvid ) {

                   $mergeData = $baseVersion;

               }

           }

           unless ($mergeData) {

               checkoutNewPackage();

               checkoutTipPackage($data);

               my $rv = checkPkgDiffs($newView, $tipView);

               if ($rv eq 'd') {

                   $mergeData = $data;

                }

           }

       }

    }

    Error("Cannot determine package merge point") unless $mergeData;

    Message ("Insert Package after: $mergeData->[3], $mergeData->[2], $mergeData->[4]")

#DebugDumpData("mergeData", $mergeData);

}

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

# Function        : checkForBaseVersion 

#

# Description     : Determine the previous non-ripple version of a package version

#                   Designed to backtrack to allow insertion at base of package

#

# Inputs          : $tpvid - pvid of test version

#                   $tversion   - Version to test

#

# Returns         : 

#

sub checkForBaseVersion

{

    my ($tpvid, $tversion) = @_;

    my $m_sqlstr = <<"END_SQL";

SELECT pv_id, pkg_version

 FROM ( SELECT * 

  FROM

    (SELECT pv.build_type,pv.last_pv_id AS raw_last_pvid ,pv_id,pv.pkg_version,DECODE(pv.pv_id, pv.last_pv_id, NULL, pv.last_pv_id) AS last_pv_id, comments, to_char(pv.modified_stamp, 'DD-MON-YYYY HH24:MM') as modified_stamp, u.user_name

    FROM release_manager.package_versions pv, users u

    WHERE u.user_id = pv.modifier_id and pv.PKG_ID IN (SELECT pkg_id FROM release_manager.package_versions pv WHERE pv.pv_id = $tpvid )

    )

    START WITH pv_id =  $tpvid

    CONNECT BY nocycle prior last_pv_id = pv_id

  ) WHERE build_type != 'Y'

END_SQL

       my $data = getDataFromRm('checkForBaseVersion', $m_sqlstr, $oldRMCred, {oneRow => 1, dump => 0});

       return undef unless $data;

       $m_sqlstr = <<"END_SQL";

       SELECT

           pv.pv_id,

           pv.pkg_id,

           pv.pkg_idext,

           pv.pkg_version,

           release_manager.PK_RMAPI.return_vcs_tag(PV_ID)

       FROM

           release_manager.package_versions pv

       WHERE

           pv.pv_id = $data->[0]

END_SQL

          $data = getDataFromRm('checkForBaseVersion', $m_sqlstr, $oldRMCred, {oneRow => 1, dump => 0});

          Message ("Base Version for $tversion is $data->[3]") if $data;

          return $data;

}

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

# Function        : checkPkgDiffs 

#

# Description     : Determine how different two package-versions are

#

# Inputs          : $newView

#                   $tipView    

#

# Returns         : d - Only build file diffs

#                   D - More than just build file diffs

#

sub checkPkgDiffs

{

    my $rCode;

    my ($newView, $tipView) = @_;

    my $rv = System('--Shell','diff', '-rq', '--exclude=build.pl', $newView, $tipView, '>/dev/null');

    if ($rv == 0) {

        $rCode = 'd';

    } else {

        $rCode = 'D';

    }

    print("TipBuildDiff: $rCode\n");

   return $rCode;

}

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

# Function        : checkoutNewPackage 

#

# Description     : Checkout the Pulse package 

#

# Inputs          : 

#

# Returns         : 

#

sub checkoutNewPackage

{

    return if $newView;

    my $newName = join('_', $pname, $pversion, 'new');

    my $newVcs = $newData->[4];

    $newView = catdir($dirWork,$newName );

    RmDirTree($newView);

    Message("Extract $pname $pversion, $newVcs, $newView");

    JatsCmd('-logfile', catfile($dirLog, $newName.'.log'),'jats_vcsrelease.pl', '-extractfiles', '-noprefix', '-root',$dirWork, '-view', $newName ,'-label', $newVcs );

}

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

# Function        : checkoutTipPackage 

#

# Description     : Checkout the Tip package from the old RM

#

# Inputs          : 

#

# Returns         : 

#

sub checkoutTipPackage

{

    my ($pkgData) = @_;

    my $tipName = join('_', $pname, $pversion, 'tip');

    my $tipVcs = $pkgData->[4];

    $tipView = catdir($dirWork,$tipName );

    RmDirTree($tipView);

    print("Extract $pname $pversion, $tipVcs, $tipView\n");

    JatsCmd('-logfile', catfile($dirLog, $tipName.'.log'),'jats_vcsrelease.pl', '-extractfiles', '-noprefix', '-root',$dirWork, '-view', $tipName ,'-label', $tipVcs, '-devMode=Tip' );

}

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

# Function        : checkVersion 

#

# Description     : Determine if the version exists in a RM instance 

#

# Inputs          : rmRef           - Ref to RM credentials 

#

# Returns         : Not found - undef

#                   Founf - nice data

#

sub checkVersion

{

    my ($rmRef) = @_;

    my $m_sqlstr = <<"END_SQL";

   SELECT

        pv.pv_id,

        pv.pkg_id,

        pv.pkg_idext,

        pv.pkg_version,

        release_manager.PK_RMAPI.return_vcs_tag(PV_ID),

        pv.v_ext

   FROM release_manager.package_versions pv, release_manager.packages p

        where p.pkg_id = pv.pkg_id

        and p.pkg_name = '$pname'

        and pv.pkg_version = '$pversion'

END_SQL

    my $data = getDataFromRm('checkVersion', $m_sqlstr, $rmRef, {oneRow => 1});

    return undef unless $data;

    return $data;

}

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

# Function        : checkVersionExists 

#

# Description     : Determine if the version exists in a RM instance 

#

# Inputs          : rmRef           - Ref to RM credentials 

#                   $pname

#                   $pversion

#

# Returns         : Not found - undef

#                   Found - pvid

#

sub checkVersionExists

{

    my ($rmRef, $pname, $pversion) = @_;

    my $m_sqlstr = <<"END_SQL";

   SELECT

        pv.pv_id

   FROM release_manager.package_versions pv, release_manager.packages p

        where p.pkg_id = pv.pkg_id

        and p.pkg_name = '$pname'

        and pv.pkg_version = '$pversion'

END_SQL

    my $data = getDataFromRm('checkVersionExists', $m_sqlstr, $rmRef, {oneRow => 1});

    return undef unless $data;

    return $data->[0];

}

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

# Function        : getDataFromRm 

#

# Description     : Get an array of data from RM 

#

# Inputs          : $name           - Query Name

#                   $m_sqlstr       - Query

#                   $rmRef          - Ref to RM

#                   $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, $rmRef, $options ) = @_;

    my @row;

    my $data;

    if (ref $options ne 'HASH') {

        $options = {}; 

    }

    $ENV{GBE_RM_LOCATION} = $rmRef->[1];

    $ENV{GBE_RM_USERNAME} = $rmRef->[2];

    $ENV{GBE_RM_PASSWORD} = $rmRef->[3];

    connectRM(\$RM_DB, $opt_verbose);

    if ($options->{sql}) {