Subversion Repositories DevTools

#                 This utility will:

#                   +   Assume the CWD is the root-dir of a package

#                       within a versioned control view

#                   +   Save the build file in the view

#                   +   Label the resultant view

# Note          : Intended to be backward compatible wth old (simple)

use JatsBuildFiles;

use JatsSystem;

use JatsProperties;

use Cwd;

my $opt_infofile;

my $opt_pname;

my $opt_pversion;

my $opt_wiplabel;

my $opt_locate;

my $root_dir;

my $pkg_label;

my $tag_label;

my $label_created;

#

#   Configuration options

#

                "infofile=s"    => \$opt_infofile,          # string

                "pname=s"       => \$opt_pname,             # string

                "pversion=s"    => \$opt_pversion,          # string

                "wiplabel=s"    => \$opt_wiplabel,          # string

                "locatepkg=s"   => \$opt_locate,            # string

                #

                #   Update documentation at the end of the file

                #

#   If $opt_label has been provided, then operate in a backwardly

#   compatible manner. Only perform the build file save. Do not perform

#   any of the advanced label operations.

#

unless ( $opt_label )

{

    Error ("Package Name not provided")

        unless ( $opt_pname );

    Error ("Package Version not provided")

        unless ( $opt_pversion );

    Warning("Path to info file not provided")

        unless ( $opt_infofile );

    unlink ($opt_infofile) if $opt_infofile;

}

else

{

    #

    #   Ensure none of the 'new' options are used

    #

    Error ("Option not compatible with -label: locatepkg")

        if ( $opt_locate );

    Error ("Option not compatible with -label: wiplabel")

        if ( $opt_wiplabel );

    Error ("Option not compatible with -label: infofile")

        if ( $opt_infofile );

}

#

#   Locate the build directory and chdir to that directory

#

locate_build_directory();

#

#   Have changed to the directory with build files

#   Continue with user argument sanity check

#

Error ("Input file not found: $opt_infile" )

    unless ( -f $opt_infile );

Error ("Output file not found: $opt_ofile" )

    unless ( -f $opt_ofile );

#

#

determine_package_label();

#   Ensure that the specified package label exists

#   Determine if it is locked too

#   

Verbose ("Checking package label: $pkg_label");

Verbose ("Checking branch existence: $opt_branch");

    Verbose ("Unlocking branch: $opt_branch");

    Verbose ("Create new branch: $opt_branch");

Verbose ("Checking for locked file: $opt_ofile");

    Verbose ("Unlocking file: $opt_ofile");

    Verbose ("Unlocking branch: $target_branch");

Verbose ("Checkout file: $opt_ofile" );

if ( $was_locked )

{

    Verbose ("Relocking label: $pkg_label");

}

    Verbose ("Creating Hyperlink" );

Verbose ("Check in build file: $opt_ofile" );

#

#   Label the view

#

label_build_view();

# Function        : locate_build_directory

#

# Description     : Locate the build directory that contains the build files

#                   In an ANT build, this will e the root of the package

#                   Otherwise the build files may not be in the root directory

#

#

# Inputs          : Globals

#

# Returns         : Globals

#

sub locate_build_directory

{

    return unless ( $opt_locate );

    my $bscanner = BuildFileScanner ( '.', $opt_infile );

    my $count = $bscanner->locate();

    Error ("Autolocate. Build file not found: $opt_infile" )

        if ( $count <= 0 );

    #

    #   If multiple build files have been found

    #   Scan the buildfiles and determine the names of the packages that will

    #   be built. This can be used to generate nice error messages

    if ( $count > 1 )

    {

        $bscanner->scan();

        $count = $bscanner->match( $opt_locate );

        my $errmess;

        if ( $count <= 0 ) {

            $errmess = "None found that build package: $opt_locate";

        } elsif ( $count > 1 ) {

            $errmess = "Multiple build files build the required package: $opt_locate";

        }

        #

        #   Pretty error display

        #   Display build directory and the package name (mangled)

        #

        if ( $errmess )

        {

            Error ("Autolocate. Multiple build files found.",

                   $errmess,

                   "Build files found in:", $bscanner->formatData() );

        }

    }

    #

    #   Extract the required build file directory

    #

    my $dir = $bscanner->getMatchDir() || '';

    Verbose ("Autolocate. Found $count build files: $dir");

    #

    #   Select the one true build directory

    #

    if ( $dir ne '.' )

    {

        #

        #   Save the current directory for later

        #

        $root_dir = getcwd();

        chdir $dir || Error ("Cannot change directory: $dir");

    }

}

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

# Function        : determine_package_label

#

# Description     : Determine the label that is to be applied to the package

#                   There are several cases to consider

#                       1) Compatability mode: User provides label

#                       2) WIP Mode. Determine name of label to ise in rename

#                       3) Create a new label

#

# Inputs          : Globals

#

# Returns         : Globals

#                       $pkg_label

#

sub determine_package_label

{

    #

    #   Compatability mode

    #

    if ( $opt_label )

    {

        $pkg_label = $opt_label;

        return;

    }

    #

    #   Determine the desired label for the package

    #   This is a function of the package name and the package version

    #   The two are joined with a '.'

    #

    $tag_label = $opt_pname . '.' . $opt_pversion;

    #

    #   Ensure that desired label is "free", if not then hunt for a new one

    #   Determine the name of a 'new' label

    #

    my $base_label = $tag_label;

    my $index = 0;

    while ( ++$index )

    {

        if ( $index > 20 )

        {

            Error ("Cannot determine new label. Retry limit exceeded");

        }

        Verbose2 ("Trying $tag_label");

        unless (ClearCmd ('describe', '-short', "lbtype:$tag_label" ) )

        {

            #

            #   Label found - so try another

            #

            Verbose2("Label found. Try another");

            $tag_label = $base_label . '.' . $index;

            next;

        }

        #

        #   Warn about non standard label

        #

        Verbose ("Package will be labeled: $tag_label");

        Warning ("Labeling with a non-standard label: $tag_label" )

            if ( $index > 1 );

        last;

    }

    #

    #   Free label has been found

    #   Create it now, unless we are processing a WIP

    #

    unless ( $opt_wiplabel )

    {

        Verbose ("Creating new label: $tag_label");

        ClearCmd ('mklbtype', '-c', 'Autobuild Created', $tag_label );

        Error ("Cannot create new label: $tag_label" ) if ( @error_list );

        #

        #   Mark as created by this utility

        #   Label should be deleted on error

        #

        $label_created = $tag_label;

        $pkg_label = $tag_label;

    }

    else

    {

        $pkg_label = $opt_wiplabel;

    }

}

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

# Function        : label_build_view

#

# Description     : Label the view

#

#                   Either:

#                       Rename the WIP label to required name

#                       Label all files in the view

#                   

#                   Use JATS to do the hard work

#

#

# Inputs          : Globals

#

# Returns         : 

#

sub label_build_view

{

    #

    #   In compatability mode - do nothing

    #

    return if ( $opt_label );

    if ( $opt_wiplabel )

    {

        Verbose ("Rename label: From $opt_wiplabel to $tag_label");

        JatsCmd( 'label', '-unlock', $opt_wiplabel, '-rename', $tag_label, '-lock' );

    }

    else

    {

        Verbose ("Apply new label to package: $tag_label");

        #

        #   Need to return to the root directory to label the entire

        #   package, but only if we moved away from the root directory

        #

        if ( $root_dir )

        {

            chdir ( $root_dir ) || Error ("Cannot chdir to starting directory", $root_dir);

        }

        JatsCmd( 'label', '-label', $tag_label, '-replace', '-lock' );

    }

    #

    #   Write the label out to the specified file so that the user

    #   can do something with it

    #

    if ( $opt_infofile )

    {

        my $data = JatsProperties::New();

        $data->setProperty('Label', $tag_label);

        $data->setProperty('WipLabel', $opt_wiplabel ) if $opt_wiplabel;

        $data->setProperty('PackageName', $opt_pname);

        $data->setProperty('PackageVersion', $opt_pversion);

        $data->setProperty('clearcase.branch', $opt_branch);

        $data->Dump('InfoFile') if ($opt_verbose);

        $data->store( $opt_infofile );

    }

}

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

    -infofile=path      - Save label information in 'path'

    -pname=name         - Name of the package

    -pversion=text      - Package version

    -locatepkg=text     - Package locator string

    -wiplabel=text      - Current package WIP label

The verbosity of the help text can be controlled by setting the help level to a

number in the range of 1 to 3, or by invoking the option multiple times.

=item B<-man[=n]>

Without a numeric argument this is the same as -help=3. Full help will be

displayed.

With a numeric argument, this option is the same as -help=n.

This option will increase the level of verbosity of the utility.

If an argument is provided, then it will be used to set the level, otherwise the

existing level will be incremented. This option may be specified multiple times.

=item B<-infile=xxxx>

This option specifies the name of the generated build configuration file that

will be used as a data-source for the check-in build file.

The default file name is 'auto.pl'.

=item B<-outfile=xxxx>

This option specifies the name of the target build configuration file that

will be checked in to version-control. Data from from file specifies with '-

infile' will be used to update the file.

This option is provided for backward compatability. If present then much of the

functionality of this utility will be supressed. The utility will only check-

in the modified build files. It will not:

=over 8

=item   Locate the build files

=item   Determine an available label

=item   Create the label

=item   Label the view

=item   Generate the information file

=back

=item B<-branch=xxxx>

This options specifies the root name of the target branch that will be sued to

contain the checked-in build file. If the branch does not exist it will be

created.

The default branch will be based on "AutoBuilder".

=item B<-infofile=path>

This option specifies a file that this utility will use to communicate with a

user script. It will write the new label text into the file.

The file path is relative to the current working directory.

The file will be deleted, and only created if the utility is successful.

=item B<-pname=name>

This option specifies the package name. It will be used to construct a new

label for the package.

=item B<-pversion=xxx>

This option specifies the package version. It will be used to construct a new

label for the package.

=item B<-locatepkg=text>

This option specifies a name, by which the package's build files may be located.

This is only needed for JATS builds and will only be used to resolve the

location of build files when a package contains multiple build files.

=item B<-wiplabel=text>

This option controls the manner in which this utility will label the build view.

If present, the label specifies a 'Work In Progress' label. The label will be

renamed.

If not present, then the view will be labeled with a new label.

=over 8

=item * Determine a suitable label for the package

The label is constructed from the package name and the package version. The

use an alternate form of the label.

=item * Determine a suitable branch name for the build files

The modified build file is placed on a file-branch.

=item * Locate the build files within the package

JATS build files do not need to be at the root of the package. The utility

=item * Update the build files and save them into the version control system

secondary configuration file.

branch so as not to affect dynamic views.

If the build file is sourced from a different branch then a Merge arrow

will be created to indicate where the file and its label was taken from.   

=item * Ensure that the package is labeled

The build view will be labeled.

If a WIP label is provided then the label will be applied to the modified

build file and then the label will be renamed.

If a WIP label is not provided, then the entire package will be labeled with a

suitable label.

=item * Return the label to the user

The label used to label the package will be returned to the user in an 'info'

file. This is a 'properties' file. The following properties are defined:

=over 8

=item   1) Label - The label used to tag the file

=item   3) WipLabel - The WIP label provided (optional)

=item   4) PackageName - The package name

=item   5) PackageVersion - The package version

=back

=back