Subversion Repositories DevTools

use JatsRmApi;

use DBI;

my $opt_rtag_id;

my $opt_package_name;

my $opt_patch;

my $RM_DB;                      # Database interface

my $package_name;               # Selected package name.

my $package_ver;                # Selected package version.

my $package_vcs;                # Selected package VCS tag.

my $package_vcs_base;           # Selected package base path.

my $package_release_branch;     # Selected package release branch or nul if released on trunk.

                "rtagid|rtag_id=s"  => \$opt_rtag_id,           # Release tag needed for release extractions

                "package=s"         => \$opt_package_name,      # Name of the package to query

                'patch:s'           => \$opt_patch,             # Generate a patch file ( for FeCru )

#

#   Sanity testing of user options

#   

Error ("Options -check and -patch cannot be combined")

    if ( $opt_md5check && defined($opt_patch) );

Error ("Options -diff and -patch cannot be combined")

    if ( $opt_diff && defined($opt_patch) );

    $DiffProg =~ tr~\\~/~;

#   Validate the users patch directory

if (defined($opt_patch))

{

    # Set deafult patch file name, if none is provided

    $opt_patch = 'vcsdiff.patch' if (length $opt_patch == 0);

    my $patchDir = StripFileExt($opt_patch);

    Error ("Directory does not exist: $patchDir") if length($patchDir) > 0;

    RmDirTree ($opt_patch);

}

#

#   Translate special label names.

#

$opt_old_label = translateSpecialLabelName( "old", $opt_old_label );

$opt_new_label = translateSpecialLabelName( "new", $opt_new_label );

Message ("  old = $opt_old_label" );

Message ("  new = $opt_new_label" );

if ( defined($opt_patch))

{

    Verbose ("Creating a Patch File");

    Verbose ("Diff Utility: $DiffProg");

    @DiffArgs = qw(-U10000 -uNr -x.svn -x.git);

    my $rv = System ( '--Shell', $DiffProg, @DiffArgs, split(/,/, join (',', @opt_options)), $path1, $path2, '>', $opt_patch );

    #

    #   Warn if the patch file cannot be found

    if ( -f $opt_patch) {

        Message("Created patch: $opt_patch");

    } else {

        Error ("Expected patch file not found : $opt_patch");

    }

    exit $rv;

}

    shift @user_path if $user_path[0] eq '';

# Function        : findReleaseManagerPackage

#

# Description     : Find the package information by looking up its existing in 

#                   a given release.

#

# Inputs          : label_name

#                   label_value

#                   rtag_id

#                   package_name

#

# Returns         : 

#

sub findReleaseManagerPackage

{

    my ($label_name, $label_value) = @_;

    my (@row);

    my $found=0;

    if ( !$opt_rtag_id || !$opt_package_name )

    {

        Error( "Must specify -rtagid and -package options when the '$label_name' tag has the value '$label_value'" );

    }

    if ( !$package_vcs )

    {

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

        # First get details from pv_id; split the package version and extension.

        my $pkg_ext;

        my $pkg_name;

        if ( $opt_package_name =~ m/(.*)\.(\w*)$/ )

        {

            $pkg_name = $1;

            $pkg_ext = $2;

        }

        else

        {

            $pkg_name = $opt_package_name;

        }

        my $m_sqlstr = "SELECT pv.PV_ID, pv.PKG_VERSION, release_manager.PK_RMAPI.return_vcs_tag(pv.PV_ID)".

                       " FROM RELEASE_MANAGER.RELEASE_CONTENT rc, RELEASE_MANAGER.PACKAGE_VERSIONS pv, RELEASE_MANAGER.PACKAGES pkg" .

                       " WHERE rc.RTAG_ID = $opt_rtag_id AND rc.PV_ID = pv.PV_ID AND pv.PKG_ID = pkg.PKG_ID AND pkg.PKG_NAME = '$pkg_name'";

        if ( $pkg_ext )

        {

            $m_sqlstr .= " AND pv.V_EXT='.$pkg_ext'";

        }

        Verbose2( $m_sqlstr );

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

        if ( defined($sth) )

        {

            if ( $sth->execute( ) )

            {

                if ( $sth->rows )

                {

                    while ( @row = $sth->fetchrow_array )

                    {

                        my $pv_id = $row[0];

                        my $ver = $row[1];

                        my $vcs = $row[2];

                        Verbose( "findReleaseManagerPackage: [$opt_rtag_id, $opt_package_name] ==> [ $pv_id, $ver, $vcs]" );

                        $package_name = $opt_package_name;

                        $package_ver  = $ver;

                        $package_vcs  = $vcs;

                        # Most packages are released of trunk...

                        my $match = '^(SVN::.*)\/trunk::.*$';

                        if ( $package_vcs =~ m/$match/ )

                        {

                            $package_vcs_base = $1;

                            Verbose( "findReleaseManagerPackage: base on trunk ==> $package_vcs_base" );

                        }

                        else

                        {

                            # ...but some are released of branches.

                            $match = '^(SVN::.*)\/branches\/([^:]+)::.*$';

                            if ( $package_vcs =~ m/$match/ )

                            {

                                $package_vcs_base = $1;

                                $package_release_branch = $2;

                                Verbose( "findReleaseManagerPackage: base on branch $package_release_branch ==> $package_vcs_base" );

                            }

                            else

                            {

                                Error ( "Unable to determine base path from VCS: $package_vcs" );

                            }

                        }

                        $found++;

                    }

                }

                $sth->finish();

            }

        }

        else

        {

            Error( "findReleaseManagerPackage:Prepare failure" );

        }

        if ( $found == 0 )

        {

            Error( "No package named $opt_package_name found in the release with rtag ID $opt_rtag_id" );

        }

        elsif ( $found > 1 )

        {

            Error( "Multiple packages named $opt_package_name found in the release with rtag ID $opt_rtag_id" );

        }

    }

}

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

# Function        : translateSpecialLabelName

#

# Description     : Translates the name of a label (-old or -new argument) 

#                   if it is one of the special values.

#

# Inputs          : label_name

#                   label_value

#

# Returns         : new label_value

#

sub translateSpecialLabelName

{

    my ($label_name, $label_value) = @_;

    if ( $label_value eq "released" )

    {

        #

        #   Get the exact version released in Release Manager.

        #

        findReleaseManagerPackage( $label_name, $label_value );

        return $package_vcs;

    }

    elsif ( $label_value eq "head" )

    {

        #

        #   Get the 'head' of the released branch in release manager; this is the trunk

        #   if the package is released off trunk or a branch if the package is getting

        #   released from a branch in this release area.

        #

        findReleaseManagerPackage( $label_name, $label_value );

        if ( $package_release_branch )

        {

            return $package_vcs_base . '/branches/' . $package_release_branch;

        }

        else

        {

            return $package_vcs_base . '/trunk'

        }

    }

    elsif ( $label_value =~ m/^branch=(.*)/ )

    {

        #

        #   Get a named branch for this package.

        #

        my $branch_name = $1;

        findReleaseManagerPackage( $label_name, $label_value );

        return $package_vcs_base . '/branches/' . $branch_name;

    }

    elsif ( $label_value eq "trunk" )

    {

        #

        #   Get the true trunk of this package.

        #

        findReleaseManagerPackage( $label_name, $label_value );

        return $package_vcs_base . '/trunk';

    }

    return $label_value;

}

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

    -patch[=name]       - Create a patch file for the views

    -rtagid=xxx         - Specify the Release to process

    -package=xxx        - Specify the package to query from Release Manager

=item B<-patch[=name]>

This option controls the mode in which the program will operate. If enabled the program

will generate a 'patch' file between the two views.

The patch file can be used to perform a 'Pre-commit' Code Review in tools such as Fisheye/Crucible.

If the name of the patch is not provided, the patch will be written to a faile called vcsdiff.patch otherwise

the user specified name will be used. The named patch can be created in a directory that exists.

The patch creation process will exclude directories called '.svn' and '.git'.

If using a development directory then it is recommended that all build files and artifactes be removed before the

patch is created. This can often be done with a 'jats clobber'.

Additional tag values are available when generating differences against packages

that are released in Release Manager.  In order to do this specific -rtagid and

-package to specify the Release Manager package version.  Once

these are specified the following tags can be used:

=over 4

=item * released

Use the current released package version in Release Manager.

=item * head

Use the Subversion HEAD of the Release Manager release path.

=item * trunk

Use the HEAD of the Subversion trunk.

=item * branch=xxx

Use the HEAD of the Subversion branch named xxx.

=back

=item B<-rtagid=xxx>

The RTAG_ID uniquely identifies a Release. The value can be read from the URL

used to view the release. ie:

 https://auawsaweb005/ManagerSuite/Release_Manager/dependencies.asp?rtag_id=17223

Specifies the name of the package to query from Release Manager.  This can be

in the form of <package_name> or alternatly <package_name>.<ext> where <ext>

is the project-specific extension for that package.  The <package_name>.<ext>

variant is required when there is more than one package with the same name

in the release given by -rtagid.

Then the tag will be treated as a directory and will be used for one side

of the comparison.

If a Vcs Tag is of the form:

=over 8

=item * released

=item * branch=xxx

The following command will compare the release version of the ct-spa package from Pulse 2.7.0 with the current head of that package

    jats vcsdiff -rtagid=38970 -package=ct-spa released head

The following command will create a 'patch' file between the specified version of the crc package and the version in the 

directory named 'crc'.

    ats vcsdiff SVN::AUPERASVN01/COTS/crc/tags/crc_26.4.0000.cr dir=crc -patch