Subversion Repositories DevTools

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

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

#

# Module name   : jats_ccrelease.pl

# Module type   : Makefile system

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : A script to build a package from a clearcase element

#                 The script will:

#                   Create a clearcase view

#                   Checkout the files

#                   Locate the build file

#                   Build the packages

#                   Install packages

#                   Remove the view

#

#               The script can do a lot of other things too.

#

#

#               Kludged up version pf cc_release to create a dynamic view

#

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

require 5.008_002;

use strict;

use warnings;

use JatsError;

use JatsSystem;

use FileUtils;

use JatsBuildFiles;

use ArrayHashUtils;

use Pod::Usage;                             # required for help support

use Getopt::Long;

use File::Find;

use File::Copy;

use File::Path;

use Cwd;

my $VERSION = "1.6.0";                      # Update this

#

#   Options

#

my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug

my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose

my $opt_help = 0;                           # User help level

my @opt_spec;                               # Labels used as a base for the view

my $opt_vob;                                # Hint: which VOB to use

my $opt_dpkg = 1;                           # Transfer built package to dpkg_archive

my $opt_copy = 0;                           # Copy built package to user

my $opt_reuse = 0;                          # Re-user view if it exists

my $opt_viewname;                           # View Name

my $opt_extract;                            # Just create a static view

my $opt_extract_files;                      # Just extract files to user - no view

my $opt_delete;                             # Just delete the view

my @opt_build;                              # build files to use (kludge)

my $opt_test;                               # Test the build process - no copy

my $opt_cache;                              # Cache external packages

my $opt_keep = 0;                           # Keep view if successful

my $opt_lock = 0;                           # Lock label before release

my $opt_beta;                               # Create beta release

my $opt_merge;                              # Merge release

my $opt_path;                               # Path for view spec

my $opt_runtests = 1;                       # Run unit tests after build

my $opt_latest_root;                        # Modify config spec with rule (kludge)

my $opt_branch;                             # Create config spec with branch

my $opt_debug_build = 0;                    # Build Debug Only

my $opt_prod_build = 0;                     # Build ion Only

my $opt_config_spec;                        # User provided config spec

my $opt_prefix = 1;                         # Prefix the view tag with user-name

my $opt_tag;                                # View tag insert (build or export or user)

#

#   Globals - Provided by the JATS environment

#

my $USER            = $ENV{'USER'};

my $UNIX            = $ENV{'GBE_UNIX'};

my $GBE_ABT         = $ENV{'GBE_ABT'} || '0';

my $MACHINENAME     = $ENV{'GBE_HOSTNAME'};

my $GBE_VIEWBASE    = $ENV{'GBE_VIEWBASE'};   # Root of the view

#

#   Globals

#

my $VIEWDIR_ROOT;                           # Root of the static view

my $VIEWTAG;                                # The view tag

my $VIEWDIR;                                # Absolute path to the view

my $VIEWPATH;                               # Path relative to clearcase

my $user_cwd;

my $error = 0;

my $label_count = 0;                        # Number of labels to create the view

my @label_not_locked;                       # List of unlocked labels

my @label_locked;                           # List of labels I locked

my @error_list;                             # ClearCmd detected errors

my $UNIX_VOB_PREFIX = '/vobs';

my $VOB_PREFIX = $UNIX ? $UNIX_VOB_PREFIX : '';

my $UNIX_VIEW_PREFIX = '/view/';            # Don't know how to determine this value

my $WIN32_VIEW_PREFIX = 'o:/';              # Don't know how to determine this value

my $VIEW_PREFIX = $UNIX ? $UNIX_VIEW_PREFIX : $WIN32_VIEW_PREFIX ;

my $VOB_SEP         = $UNIX ? '/' : '\\';

my $view_prefix     = "${USER}_";

#

#   ROOT_VOBS is a list of VOBS too look in first

#   If a label is not found in these vobs, then the program will

#   look in all vobs. This list is a hint to speed up searching

#

my $ROOT_VOB;

my $root_vob_spec;

my @ROOT_VOBS = qw( /LMOS /DPG_SWBase /DPG_SWCode /ProjectCD /MASS_Dev_Bus

                    /MASS_Dev_Infra /MOS /MASS_Dataman /MASS_Dev /MASS_Dev_Dataman

                    /COTS /GMPTE2005 /GMPTE2005_obe /MPR /MOS );

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

# Function        : Mainline Entry Point

#

# Description     :

#

# Inputs          :

#

#

#   Parse the user options

#

my $result = GetOptions (

                "help+"         => \$opt_help,              # flag, multiple use allowed

                "manual:3"      => \$opt_help,              # flag

                "v|verbose:+"     => \$opt_verbose,           # flag, multiple use allowed

                "label=s"       => \@opt_spec,              # Array of build specs

                "spec=s"        => \@opt_spec,              # Array of build specs

                "config=s"      => \$opt_config_spec,       # String

                "view=s"        => \$opt_viewname,          # String

                "vob=s"         => \$opt_vob,               # String

                "dpkg!"         => \$opt_dpkg,              # [no]flag

                "copy!"         => \$opt_copy,              # [no]flag

                "reuse!"        => \$opt_reuse,             # [no]flag

                "extract"       => \$opt_extract,           # flag

                "extractfiles"  => \$opt_extract_files,     # flag

                "delete:+"      => \$opt_delete,            # flag

                "build=s"       => \@opt_build,             # An array of build

                "test!"         => \$opt_test,              # [no]flag

                "cache"         => \$opt_cache,             # flag

                "keep!"         => \$opt_keep,              # [no]flag

                "lock!"         => \$opt_lock,              # [no]flag

                "beta!"         => \$opt_beta,              # [no]flag

                "merge"         => \$opt_merge,             # [no]flag

                "path=s"        => \$opt_path,              # string

                "runtests!"     => \$opt_runtests,          # [no]flag

                "latestroot=s"  => \$opt_latest_root,       # String

                "branch=s"      => \$opt_branch,            # String

                "mkbranch=s"    => \$opt_branch,            # String

                "prodOnly"      => \$opt_prod_build,        # flag

                "debugOnly"     => \$opt_debug_build,       # flag

                "root=s"        => \$GBE_VIEWBASE,          # string

                "prefix!"       => \$opt_prefix,            # flag

                "tag=s"         => \$opt_tag,               # string

                );

                #

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

InitFileUtils();

#

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

#

ErrorConfig( 'name'    => 'RELEASE',

             'verbose' => $opt_verbose );

#

#   Validate user options

#   Use either -label or one command line argument

#

Error ("Unexpected command line arguments present.","Cannot mix -label and command line label" )

    if ( $#opt_spec >= 0 && $#ARGV >= 0);

push @opt_spec, @ARGV;

if ( $opt_config_spec )

{

    Error("Cannot use -path with -config")      if($opt_path);

    Error("Cannot use -branch with -config")    if($opt_branch);

    Error("Cannot use -vob with -config")       if($opt_vob);

    Error("Cannot use a label with -config")    if( @opt_spec);

    Error("Config spec file not found: $opt_config_spec") unless ( -f $opt_config_spec );

    unless ( $opt_viewname )

    {

        $opt_viewname = StripDirExt($opt_config_spec);

        $opt_viewname =~ s~[\.:/\\]~_~g;

    }

    $opt_vob = "";

    #

    #   Convert file in an absolute file name

    #   Will be needed as we change directory

    #

    $opt_config_spec = FullPath($opt_config_spec);

}

unless(  @opt_spec || $opt_config_spec  )

{

    Error ("Need a view or a label. -help for options") if ( $opt_delete  && ! $opt_viewname );

    Error ("Need a label or config_spec. -help for options") unless $opt_delete;

}

#

#   Convert label with embedded VCS information into a 'normal' form.

#   Form:

#       CC::label

#       CC::path::label

#       CC::::label

#

foreach ( @opt_spec )

{

    if ( $_ =~ m~^(.+?)::(.*?)(::(.+))?$~ )

    {

        Error ("Label contains invalid Version Control Identifier($1): $_")

            if ( $1 ne 'CC' );

        my $ll = $2;

        my $path;

        if ( $3 )

        {

            $path = $2;

            $ll = $4;

            if ( $path  )

            {

                Error ("Multiple conflicting Embedded source paths",

                       "Path: $opt_path",

                     "VCS Spec: $_" ) if ( $opt_path && $path ne $opt_path );

                $opt_path = $path;

            }

        }

        $_ = $ll;

    }

    Verbose ("Clean URL: $_");

}

#

#   User has specified both debug and production

#   Then set both to 0 : ie default

#

if ( $opt_debug_build + $opt_prod_build > 1 )

{

    $opt_debug_build = 0;

    $opt_prod_build = 0;

}

#

#   User has requested test mode

#       - Don't copy

#       - Don't packgae

#

if ( $opt_test )

{

    $opt_dpkg = 0;

    $opt_copy = 0;

}

#

#   Determine the machine type

#

Verbose ("Machine Type: UNIX=$UNIX");

Error ("Machine Name not determined")

    unless ( $MACHINENAME );

$user_cwd = getcwd;

Error ("USER name not determined" )

    unless ( $USER );

#

#   Ensure that the 'cleartool' program can be located

#

Verbose ("Locate clearcase utility in users path");

Error ("Cannot locate the 'cleartool' utility in the users PATH")

    unless ( LocateProgInPath('cleartool', '--All') );

#

#   Clean up the view root directory

#

$VIEWDIR_ROOT = Realpath($GBE_VIEWBASE) || $GBE_VIEWBASE;

Verbose ("Viewpath: $VIEWDIR_ROOT");

Error ("Cannot locate view root directory: $VIEWDIR_ROOT" ) unless (-d $VIEWDIR_ROOT);

#

#   Remove any user name from the front of the view name

#   Simplifies the deletion process as the user can provide

#   the directory name

#

$view_prefix = "" unless ( $opt_prefix );

#

#   Setup user specified viewname

#   Include the user name to ensure that the view name is unique-ish

#   Keep the name as short as possible as some compilers display a fixed

#   length filename in error messages and this name is part of the path

#

#   Base the viewname on the view label. This will simplify the creation

#   of multiple views and reduce the risk of unexpected deletion

#

$opt_viewname = $opt_spec[0] unless ( defined $opt_viewname );

$opt_viewname =~ s~^$view_prefix~~ if (defined($opt_viewname) && $view_prefix && $opt_delete );

#

#   Create the view tag

#   Attempt to make this globally unique

#   Include USER name, MACHINE name, the view name

#   Optionally include a user 'tag'. Provided to allow the ABT to maintain

#   multiple instances of a view.

#

unless ( $opt_tag )

{

    $opt_tag = 'dynamic';

}

$VIEWTAG = "${USER}_${MACHINENAME}_${opt_tag}_${opt_viewname}";

#

#   Create a clearcase view to be used for the view

#

$VIEWPATH = "$view_prefix$opt_viewname";

$VIEWDIR = "$VIEWDIR_ROOT/$VIEWPATH";

$VIEWDIR =~ tr~\\/~/~s;

Verbose( "Hostname: $MACHINENAME" );

Verbose( "Viewtag: $VIEWTAG" );

Verbose( "Viewpath: $VIEWPATH" );

Verbose( "Viewdir : $VIEWDIR" );

#

#   If the user has specified a "source path", then we can extract the VOB

#   from that path. It will be the first directory

#

Verbose("Locate Source VOB");

if ( $opt_path )

{

    $opt_path =~ tr~\\/~/~s;

    $opt_path =~ s~/+$~~;

    Error( "Source Path needs leading '/'") unless ( $opt_path =~ m~^/~ );

    Error( "Source Path is a UNC" ) if ( $opt_path =~ m~^//~ );

    Error( "Source Path has drive specifier" ) if ( $opt_path =~ m~^[A-Za-z]\:~ );

    #

    #   Extract the VOB from the path

    #

    unless ( $opt_vob )

    {

        my $vob = $opt_path;

        $vob =~ s~^/~~g;

        $vob =~ s~/.*~~g;

        $opt_vob = $vob;

        Verbose ("Extract VOB from path: $vob" );

    }

}

#

#   If the view currently exists then it will be deleted if allowed

#

delete_view();

#

#   If the user is simply deleting the view then all has been done

#

exit 0

    if ( $opt_delete );

#

#   Setup user specified VOB

#

if ( defined($opt_vob) )

{

    $ROOT_VOB = "/$opt_vob";

    $ROOT_VOB =~ s~//~/~g;

    @ROOT_VOBS = $ROOT_VOB;

}

else

{

    #

    #   Extend the list of ROOT_VOBS with all the known vobs

    #   The initial ROOT_VOBS are treated as a "hint" to assist searching

    #

        my $cmd = ClearToolCmd ('lsvob', '-short');

        open(CMD, "$cmd 2>&1 |") || Error( "can't run command: $!");

        while (<CMD>)

        {

            #

            #   Filter output from the user

            #

            chomp;

            s~^$UNIX_VOB_PREFIX~~ if ($UNIX);

            Verbose2("lsvob: $_");

            tr~\\/~/~s;

            push @ROOT_VOBS, $_;

        }

        close(CMD);

}

#

#   Ensure that the label is present within the specified VOB

#   Hunt for the user specified label in a number of well known VOBs

#

if ( @opt_spec )

{

    Verbose("Ensure Label is found in a VOB");

    my $found = 0;

    my $spec = $opt_spec[0];

    foreach my $vob ( @ROOT_VOBS )

    {

        $vob = $UNIX_VOB_PREFIX . $vob if ( $UNIX );

        (my $vob_name = $vob) =~ s~/~$VOB_SEP~g;

        Verbose2 ("Examine label $spec in vob: $vob" );

        my $cmd = ClearToolCmd ('lstype', "lbtype:$spec\@$vob_name");

        my $cmd_done = 0;

        open(CMD, "$cmd 2>&1 |") || Error( "can't run command: $!");

        while (<CMD>)

        {

            #

            #   Filter output from the user

            #   Stay in loop to avoid Broken Pipe message

            #

            chomp;

            Verbose2("lstype: $_");

            next if ( $cmd_done );

            next if ( m~Error~ );

            next unless ( m~label type~ );

            push @label_not_locked, $spec unless( m~\(locked\)~ );

            $label_count++;

            $found = $vob;

            $cmd_done = 1;

        }

        close(CMD);

        last if ( $found );

    }

    Error ("Label $spec not found in @ROOT_VOBS")

        unless ( $found );

    Verbose ("Label $spec found in vob: $found" );

    $ROOT_VOB = $found;

    #

    #   Create a VOB spec extension

    #

    $root_vob_spec = '@' . $ROOT_VOB;

    $root_vob_spec =~ s~/~$VOB_SEP~g;

    #

    #   Ensure that all labels are found in the VOB

    #

    foreach my $spec ( @opt_spec[1..$#opt_spec] )

    {

        $label_count++;

        Verbose ("Testing label $spec in vob: $ROOT_VOB" );

        my $data = qx( cleartool lstype lbtype:$spec$root_vob_spec );

        Verbose ( "lstype: $data" );

        Error ("Label $spec not found in $ROOT_VOB. All labels must be in the same VOB")

            if ( ! $data );

        push @label_not_locked, $spec unless( $data =~ m~\(locked\)~ );

    }

    #

    #   Ensure that the branch is found in the VOB

    #

}

#

#   Extracting files then ...

#

extract_files_from_view();

Message ("End program");

exit 0;

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

# Function        : delete_view

#

# Description     : Delete a dynamic view

#

# Inputs          : None

#                   $VIEWTAG - name of the view

#                   $VIEWDIR - path of the view

#

# Returns         :

#

sub delete_view

{

        if ( -l $VIEWDIR )

        {

            Message("Remove extracted files: $VIEWTAG");

            RmDirTree( $VIEWDIR );

        }

    #

    #   Remove the view

    #   Simply remove the dynamic view tag

    #

    ClearCmd ( 'rmview', '-tag', $VIEWTAG );

    Message ("View deleted");

}

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

# Function        : ClearTool

#

# Description     : Issue a cleartool command

#                   Filter out many of the stupid messages

#

# Inputs          : Options and Command line

#                   Options:

#                       --Quiet     - Supress all command output

#

# Returns         : Error code

#

sub ClearTool

{

    my $quiet;

    #

    #   Scan for initial options

    #       --Quiet

    #

    if ( $_[0] eq '--Quiet' )

    {

        $quiet = 1;

        shift;

    }

    my $cmd = ClearToolCmd(@_);

    open(CMD, "$cmd 2>&1 |") || Error "can't run command: $!";

    while (<CMD>)

    {

        #

        #   Filter output from the user

        #

        next if ( $quiet );

        unless ( $opt_verbose )

        {

            next if ( m~Making dir~ );

            next if ( m~End dir~ );

            next if ( m~Processing dir~ );

            next if ( m~Error~ );

        }

        print $_;

    }

    close(CMD);

    Verbose2 "ClearTool Exit Status: $?";

    return $? / 256;

}

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

# Function        : ClearCmd

#

# Description     : Execute a cleartool command

#                   Capture error messages only

#

# Inputs          : Command to execute

#                   Takes an array of command argumeents and will quote them

#

# Returns         : Exit code

#                   Also the global @error_list

#

sub ClearCmd

{

    @error_list = ();

    my $cmd = ClearToolCmd(@_);

    open(CMD, "$cmd  2>&1 |")    || Error "can't run command: $!";

    while (<CMD>)

    {

        chomp;

        Verbose ($_);

        push @error_list, $_ if ( m~Error:~ );

    }

    close(CMD);

    Verbose2 "Exit Status: $?";

    return $? / 256;

}

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

# Function        : ClearToolCmd

#

# Description     : Create a nice escaped cleartool command

#

# Inputs          : An array of cleartool command line arguments

#

# Returns         : A string that has been quoted

#

sub ClearToolCmd

{

    my $cmd = 'cleartool ' . QuoteCommand( @_);

    Verbose2 $cmd;

    return $cmd;

}

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

# Function        : extract_files_from_view

#

# Description     : This function will

#                       Create a dynamic view

#                       Copy all the files out of the view

#                       Delete the view

#

#                   Its used in the creation of escrow directories

#

# Inputs          : None

#                   All done via globals

#

# Returns         : 

#

sub extract_files_from_view

{

    my $vob_mounted = 1;

    my $vob_name;

    #

    #   Which config spec

    #   Create config spec in local dir

    #

    my $config;

    $config = $opt_config_spec;

    unless ( $opt_config_spec )

    {

        $config = create_config_spec( "config_spec.txt" );

    }

    #

    #   Create the view and insert the config spec

    #

    ClearCmd ( 'rmview', '-tag', $VIEWTAG );

    ClearCmd ( 'mkview', '-tag', $VIEWTAG, '-stgloc', '-auto' );

    ClearCmd ( 'setcs',  '-tag', $VIEWTAG, $config );

    #

    #   Ensure that the base VOB has been 'mounted'

    #   Dynamic views require vobs to be mounted

    #

    ($vob_name = $ROOT_VOB) =~ s~/~$VOB_SEP~g;

    $vob_mounted = ClearCmd ('mount', $vob_name);

    #

    #   Calculate where the dynmaic view will be

    #   This differ between UNIX/WINDOWS

    #

    my $vpath = $VIEW_PREFIX . $VIEWTAG . $VOB_PREFIX;

    my $cpath = $vpath;

       $cpath .= $opt_path if ( $opt_path );

    #

    #   Is the view where we expect it to be

    #

    Error ("Cannot locate dynamic view",

            "Looking in: $vpath" ) unless -d $vpath;

    Message ("Dynamic view path: $vpath" );

    Message ("Dynamic view path: $cpath" );

    Message ("Dynamic view tag : $VIEWTAG" );

    #

    #   Create a soft link

    #

    symlink ($vpath, $VIEWDIR) || Error ("Cannot create VIEWDIR link: $vpath, $VIEWDIR, $!");

    Message ("ViewDir : $VIEWDIR" );

}

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

# Function        : create_config_spec

#

# Description     : Creates a config spec

#

# Inputs          : $config     - Path to the config file

#

# Returns         : Path to the config spec

#

sub create_config_spec

{

    my ($config_file) = @_;

    #

    #   Calc the path to a directory in the view which we really want to

    #   consider as the base. Only want to see folders above this base.

    #   Don't want to add elements above the base

    #

    my $basepath = ($opt_path) ? "\"${VOB_PREFIX}${opt_path}\""     : $ROOT_VOB;

    my $elroot   = ($opt_path) ? "\"${VOB_PREFIX}${opt_path}/...\"" : '*';

    my $elpath   = ($opt_path) ? $opt_path : '';

    #

    #   Create a config spec to be used to populate the view

    #       Do not branch directories

    #       Do not extract files from lost+found

    #

    Verbose( "Create config spec");

    my @config;

    push @config, "element * CHECKEDOUT";

    push @config, "element .../lost+found -none";

    #

    #   Insert rules to prevent branching above the load path

    #   This will be the root of the package

    #

    if ( $opt_path )

    {

        my $fulldir = $VOB_PREFIX;

        my @parts = split ('/', $opt_path);

        shift @parts;                                   # Skip first as its empty

        pop @parts;                                     # Skip last as its the package

        foreach my $dir ( @parts )

        {

            $fulldir .= "/$dir";

            foreach (@opt_spec)

            {

                push @config, "element -dir \"$fulldir\" $_ -nocheckout";

            }

        }

    }

    else

    {

        foreach (@opt_spec)

        {

            push @config, "element -dir \"$ROOT_VOB\" $_ -nocheckout";

        }

    }

    #

    #   General branching rules

    #   Rule will apply to all following directives

    #

    if ( $opt_branch )

    {

        push @config, "element $elroot .../$opt_branch/LATEST";

        push @config, "mkbranch $opt_branch";

    }

    #

    #   Rules to extract elements within the load path

    #

    foreach (@opt_spec)

    {

        push @config, "element $elroot $_";

    }

    #

    #   KLUDGE ALERT

    #   Packages SHOULD be labled to the root.

    #   Do not extend this list fix the package - fix the labels in the VOB.

    #

    if ( $opt_latest_root )

    {

        push @config, "element -dir $ROOT_VOB .../$opt_latest_root/LATEST";

        push @config, "element -dir $ROOT_VOB .../mass_dev2/LATEST";

        push @config, "element -dir $ROOT_VOB .../mass_dev/LATEST";

        push @config, "element -dir $ROOT_VOB /main/LATEST";

    }

    #

    #   Handle file(directory) addition

    #   Need a rule to allow /main/0 to be visible

    #   Need to ensure that we don't "see" the entire VOB, just below the load path

    #

    unless ($GBE_ABT)

    {

        #

        #   Ensure that we have more than just the VOB root

        #   If we only have the VOB root then we will get all top level entries

        #   in the vob - and this is not good.

        #

        #   Comment out the rule so that the user can use if they must

        #

        my $count = ($elpath =~ tr~/~~);

        my $prefix = ( $count <= 1 ) ? '# ' : '';

        Verbose2 ("Config Spec: Suppress /main/0. Path too short)") if $prefix;

        #

        #   Ensure that element-0 is visible (unless autobuilder)

        #   Note: mkbranch rule will modify this rule

        #

        push @config, $prefix . "element $elroot /main/0";

    }

    #

    #   Load rule

    #   Quote the path so that spaces will be correcly handled

    #

    push @config, "load $basepath";

    Message ("Config Spec", @config )

        if ( IsVerbose(1) );

    FileCreate ($config_file, \@config);

    return $config_file;

}

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

#   Documentation

#

=pod

=for htmltoc    GENERAL::ClearCase::

=head1 NAME

jats_ccrelease - Build a package given a clearcase label

=head1 SYNOPSIS

  jats ccrelease [options] [-label=]label | -config=config_spec

 Options:

    -help              - brief help message

    -help -help        - Detailed help message

    -man               - Full documentation

    -label=xxx         - Clearcase label

    -spec=xxx          - Same as -label=xxx

    -path=xxx          - Source Path

    -view=xxx          - Modify the name of the created view

    -vob=vobname       - VOB name

    -build=xxx         - Package Name to build

    -root=xxx          - Root directory for generated view

    -latestroot=xxx    - Use the LATEST rootlevel directory 'xxx'

    -[mk]branch=xxx    - Will create a view with a branch rule

    -config=xxx        - Create a view with the provided config spec

    -tag=xxx           - Alternate tag used with in the ViewTag

    -extract           - Extract the view and exit

    -extractfiles      - Extract files, without a view

    -cache             - Refresh local dpkg_archive cache

    -delete            - Remove any existing view and exit

    -debugOnly         - Make only the debug version

    -prodOnly          - Make only the production version

    -[no]dpkg          - Transfer package into dpkg_archive

    -[no]copy          - Transfer pkg directory to the current user directory

    -[no]reuse         - Reuse the view

    -[no]test          - Test package build. Implies nocopy and nodpkg

    -[no]keep          - Keep the view after the build

    -[no]lock          - Lock labels

    -[no]beta          - Release a beta package

    -[no]merge         - Merge packages into dpkg_archive

    -[no]runtests      - Run units tests. Default is runtests

    -[no]prefix        - Supress user prefix in view name. Default prefix is USER

=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.

=item B<-man>

Prints the manual page and exits.

=item B<-label> or B<-spec>

The ClearCase label to use as the base for the view.

Eg: daf_utils_math_3.2.1

=item B<-view name>

Specified an alternate view name and tag to be used. This option does not provide the

full name of the view.

The view tag will be : "${USER}_${MACHINENAME}_${TAG}_${NAME}"

The view path will be: "${USER}_${NAME}"

The default "NAME" is the first label specified.

The default "TAG" is build. See B<-tag=tagname>.

If the user provides a view "name" that is prefixed with their user name

('${USER}_'), then the username will be stripped of for internal processing.

This allows a user to provide a view path when deleting a view.

=item B<-path=xxx>

Specifies the source path to the root of the extracted file tree. This option has several uses:

=over 8

=item   *

Provide a sanity test of the "Source Path" item within Release Manager

=item   *

Specify the VOB that contains the source. The VOB name will be extracted and

used as the B<-vob> parameter.

=item   *

Limit the work to do in extracting the file tree.

=back

=item B<-vob=xxx>

Specifies the Clearcase VOB in which the clearcase label will be located.

This is used as the basis for locating and loading the files within the view.

By default this utility will examine all the VOBs for the label.

=item B<-build=xxx>

This option allows the user to specify the packages to be built and the

order in which the packages are to be built.

This is useful if the extracted view contains multiple build files

This option may be used multiple times.

There are two forms in which the build target can be specified. It can be

specified as a full package name and vesrion, or as a package name and the

project suffix.

By default the program will assume that there is only one build file in the

view and will not build if multiple files are present, unless the package to be

built can be resolved.

The location mechanism operates for both JATS and ANT build files.

Example: -build=jats-api.1.0.0000.cr

This will locate the build file that builds version 1.0.0000.cr of the jats-api

package. The version numbers must match exactly.

Example: -build=jats-api.cr -build=jats-lib.cr

This will located the build files that build the jats_api (cr) package and the

jats-lib (cr) package. The version of the packages will not be considered.

=item B<-root=xxx>

This option allows the location of the generated view to be specified on the

command line. It overides the value of GBE_VIEWBASE.

If the comamnd is invoked within a development sandbox, then the default

location will be the root directory of the development sandbox.

=item B<-latestroot=xxx>

This option enables a work around for a bad-labelling practice that has existed

in the past. This LATEST version of the named (xxx) branch will be added to

the config spec used to create the view.

This is a work around for a problem where the top-level directory in the VOB has

not been labelled. This can result in unreproducible builds.

This option allows the utility to construct a view, but the user SHOULD label

the root level directory to correct the problem.

The use of this switch will add the following lines to the config spec:

    element -directory /DPG_SWBase /main/xxxx/LATEST

=item B<-branch=xxx or -mkbranch=xxx>

This option will create a view such that files that are checked out will be

checked out on the named branch. This is intended to facilitate the maintenance

of existing packages - the creation of a patch.

The named branch must exist within the VOB containing the label. The script will

check for its existence.

The use of this switch will add the following lines to the config spec:

    element * .../xxx/LATEST

    element * label -mkbranch xxx

    element * /main/0 -mkbranch xxx

=item B<-config=config_spec>

This option is an alternate mechanism to create a static view. The view will be

based on the provided configuration spec. This view cannot be used to release a package.

The option is intended to simplify development.

This option is incompatibale with:

    -release

    -label

    -branch

    -path

    -vob