Subversion Repositories DevTools

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

# Copyright (C) 1998-2008 ERG Limited, All rights reserved

#

# Module name   : jats_svnrelease.pl

# Module type   : Jats Utility

# Compiler(s)   : Perl

# Environment(s): Jats

#

# Description   : A script to build a package from a SubVersion

#                 The script will:

#                   Create a workspace

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

#

# Notes         : A lot of this code is common to jats_ccrelease.pl

#                 Will need to refactor if both are to be used

#

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

require 5.006_001;

use strict;

use warnings;

use JatsError;

use JatsSystem;

use FileUtils;

use JatsBuildFiles;

use ArrayHashUtils;

use JatsSvn;

use Pod::Usage;                             # required for help support

use Getopt::Long;

use File::Find;

use File::Copy;

use File::Path;

use Cwd;

my $VERSION = "1.0.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_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 = 0;                         # Just delete the view. 2 to force

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_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_branch;                             # Create config spec with branch

my $opt_debug_build = 0;                    # Build Debug Only

my $opt_prod_build = 0;                     # Build ion Only

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

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

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

my $bad_label_name = 0;                     # Badly formed label

#

#   Globals - Provided by the JATS environment

#

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

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

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

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 $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_pegged;                       # List of unpegged labels

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

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

# Function        : Mainline Entry Point

#

# Description     :

#

# Inputs          :

#

#

#   Alter some option defaults if we are creating a view within a sandbox

#

if ( $GBE_SANDBOX )

{

   $GBE_VIEWBASE = $GBE_SANDBOX;

   $opt_prefix = 0;

}

#

#   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

                "view=s"        => \$opt_viewname,          # 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

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

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

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

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

                "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'    => 'SVNRELEASE',

             '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;

unless(  @opt_spec  )

{

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

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

}

#

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

#   Form:

#       SVN::<URL>

#

foreach ( @opt_spec )

{

    s~^SVN::~~;

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

        if ( m~^(.+)::.+~ );

    Verbose ("Clean URL: $_");

}

#

#   Limit the user to ONE label/tag/

#   Reason: Under Subversion its not possible to 'pinch' files from another

#           package. Don't need to create a workspace with multiple labels

#

#           It was a bad practice under clearcase

#

#

if ( $#opt_spec >= 1 )

{

    Error ("Multiple labels not supported",

           "Use one label to describe a package" );

}

#

#   Check branch and tags names

#

if ( $opt_branch )

{

#    Error ("Branch Name cannot start with '-'") if ( $opt_branch =~ m/^-/ );

    $opt_branch = SvnIsaSimpleLabel($opt_branch);

}

#

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

#

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

#

#   Create a class to describe the complete SVN label

#   This will parse the label and create a number of nice elements

#

my $svn_label = NewSessionByUrl ( $opt_spec[0], 1 );

#

#   Setup user specified workspace

#   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

#

if ( $opt_viewname )

{

    Error ("View Name contains invalid characters" )

        unless ( $opt_viewname =~ m~^[0-9a-z]([-.:0-9a-z_]*[0-9a-z])?$~i )

}

else

{

    #

    #   Create a view name based on the provide 'label'

    #   Unless creating a branch. Branch name will be appended later

    #

    if ( $svn_label->Type )

    {

        $opt_viewname = $svn_label->Path;

        $opt_viewname .= '_' . ($svn_label->Version || 'trunk') unless $opt_branch;

        #

        #   Tags and Branches 'should' include the package name

        #   This will lead to a duplication of the package name

        #   ie: aaaaa/package/tags/package_version

        #   Attempt to remove these

        #

        if ( $opt_viewname =~ s~[_/]([\-.:0-9a-zA-Z]+)_\1_~_$1_~ )

        {

            Verbose ("Removed duplicate package name: $1 from $opt_viewname");

        }

    }

    else

    {

        $opt_viewname = $svn_label->Path;

        $bad_label_name = 1;

    }

    #

    #   If creating a branch, then insert the branch name

    #   into the workspace name

    #

    $opt_viewname .= '_' . $opt_branch if ( $opt_branch );

    #

    #   Create a simple dir name

    #       Remove path sep characters and replace with _

    #       Remove Peg marker (@) as this breaks svn

    #       Replace multiple _ with a single _

    #       Remove trailing _ - caused by URL with a trailing /

    #

    $opt_viewname =~ s~[^\-.:0-9a-zA-Z_]~_~g;

    $opt_viewname =~ tr~_~_~s;

    $opt_viewname =~ s~_+$~~;

}

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

#

#   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( "Viewpath: $VIEWPATH" );

Verbose( "Viewdir : $VIEWDIR" );

#

#   If the user has specified a "source path", then we must ensure that it is

#   valid. It will be used to create the WorkSpace

#

#   Ensure that the path is a defined variable. If used prepend a / to simplify

#   concatenation.

#

Verbose("Validate Source Path");

if ( $opt_path )

{

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

    $opt_path =~ s~/$~~;

    $opt_path =~ s~^/~~;

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

    $opt_path = '/'.$opt_path ;

}

else

{

    $opt_path = '';

}

#

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

#

delete_view()

    unless ( $opt_reuse );

#

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

#

exit 0

    if ( $opt_delete );

#

#   Ensure that the label is present within the specified VOB

#

Verbose("Ensure Labels can be found in a Repository");

Verbose ("Testing label: ". $svn_label->Full );

$label_count++;

$svn_label->SvnValidateTarget (

                    'cmd'    => 'SvnRelease',

                    'target' => $svn_label->Full,

                    'require' => 1,

                    );

#

#   Test for a pegged label

#

push @label_not_pegged, $svn_label->Full

    unless ( $svn_label->Peg );

#

#   If we are only extracting files then ...

#

if ( $opt_extract_files )

{

    extract_files_from_view();

    exit (0);

}

#

#   Create a new workspace

#

if (! -d $VIEWDIR || ! $opt_reuse )

{

    Message( "Create the workspace" . ($GBE_SANDBOX ? " in a SANDBOX" : ""));

    my $view_tag = $svn_label->Full;

    #

    #   If a branch is required ...

    #   If the branch exists, then use it

    #   If the branch does not exist, then create it

    #       Copy the source to the branch

    #       Check it out

    #

    if ( $opt_branch )

    {

        Verbose ("Test branch existence");

        #

        #   Create the name of the branch

        #   Will be based on the current package

        #

        my $branch = $svn_label->BranchName($opt_branch, 'branches' );

        my $rv = $svn_label->SvnValidateTarget (

                        'cmd'    => 'SvnRelease',

                        'target' => $branch,

                        'test' => 1,

                        );

        if ( $rv )

        {

            #

            #   The named branch exists

            #   Use it in place of the users named version

            #   This mimics the clearcase behaviour

            #   Assumes that it is a project branch

            #

            Warning ("Specified branch \"$opt_branch\" exists",

                     "It will be used as the base for this Workspace",

                     "The workspace will conatin the current HEAD of this branch");

            #

            #   Setup the base of the Workspace

            #   It will be based on the branch

            #

            $view_tag = $branch;

        }

        else

        {

            #

            #   Branch does not exist

            #   Create it be copying the base view

            #

            $view_tag = $svn_label->SvnCopy (

                            'old' => $view_tag,

                            'new' => $branch,

                            'comment' => 'Created by Jats SvnRelease branch request',

                            'replace' => 0 );

            $view_tag = SvnPath2Url($view_tag);

        }

    }

    #

    #   Create the workspace

    #

    $svn_label->SvnCo ( $view_tag, $VIEWDIR . $opt_path );

    Error ("Cannot locate the created Workspace")

        unless ( -d $VIEWDIR . $opt_path);

    #

    #   Create a local package archive

    #   May be needed for multipackage builds and it will prevent JATS from

    #   finding any outside the view

    #

    mkdir ( $VIEWDIR . '/local_dpkg_archive')

        unless ($GBE_SANDBOX);

}

#   Place a tag-file in the user-specified source path

#   This will be used by the build-tool to locate the 'source-path' of the

#   view, primarily for determining metrics.

#

#   Calculate where the dynmaic view will be

#   This differ between UNIX/WINDOWS

#

if ( $GBE_ABT)

{

    Message( "Create Build tagfile");

    my $cpath = $VIEWDIR . $opt_path;

    if ( -d $cpath )

    {

        TouchFile ( "$cpath/.jats.packageroot" );

    }

}

#

#   Locate the JATS build files within the populated view

#

chdir ($VIEWDIR) or Error( "Cannot chdir to $VIEWDIR");

Message( "Locating build files");

my $bscanner = BuildFileScanner( $VIEWDIR, 'build.pl', '--LocateAll' );

$bscanner->scan();

my @build_list = $bscanner->getInfo();

foreach my $be ( @build_list )

{

    Message( DisplayPath ("Build file: $be->{dir} Name: $be->{file}"));

}

#

#   If we are extracting the view then we are done

#   Display useful information for the user

#

if ( $opt_extract )

{

    Message  DisplayPath "View in: $VIEWDIR";

    Warning ("No build files found" )   if ( $#build_list < 0 );

    Warning( "Multiple build files found" )if ( $#build_list > 0 );

    Message ("Not all labels are pegged") if ( @label_not_pegged  );

    Message ("All labels are pegged") unless ( @label_not_pegged  );

    Message ("Badly formed label name" ) if ( $bad_label_name );

    Message ("Development Sandbox") if ( $GBE_SANDBOX );

    exit 0;

}

Error ("No build files found")  if ( $#build_list < 0 );

#

#   Determine the list of builds to perform

#   Ensure that the user-requested build files are present

#

#   The user specifies the build file, via the mangled package name

#   This is package_name . project extension (daf_utils.cr)

#

if ( $#opt_build  >= 0)

{

    Verbose( "Check and locate the build files");

    @build_list = ();

    foreach my $bentry ( @opt_build )

    {

        if ($bscanner->match( $bentry) )

        {

            UniquePush (\@build_list, $bscanner->getMatchList() );

            Verbose ("Found: $bentry");

        }

        else

        {

            Error ("Cannot locate requested build files for: $bentry")

        }

    }

}

#

#   Sanity test if we will transfer the generated package to dpkg_archive

#   There are some limits

#       1) Must have built from one label

#       2) That label must be locked

#       3) Only one build file

#       4) The view must not have been reused

#       5) The view has a branch rule

#       6) Cannot release from a sandbox

#

my @elist;

push @elist, "Package built from multiple labels" unless ( $label_count == 1 );

push @elist, "Package built from an unpegged label" if ( @label_not_pegged  );

push @elist, "Package built with multiple build files" if ( scalar @build_list > 1 );

push @elist, "Package from a reused view" if ( $opt_reuse && ! $opt_beta );

push @elist, "Package from a development sandbox" if ( $GBE_SANDBOX );

push @elist, "View contains a branch" if ( $opt_branch );

push @elist, "User has specified build files" if ( $#opt_build > 0 );

push @elist, "Badly formed label name" if ( $bad_label_name );

if ( @elist )

{

    Warning ("Cannot officially release the package.", @elist);

    Error ("Build terminated as it cannot be released") if ($opt_dpkg && ! $opt_beta);

}

Warning ("Beta Release") if $opt_beta;

#

#   Process each of the build files in the specified order

#

foreach my $be (@build_list)

{

    #

    #   We need to change to the build directory

    #   Moreover we need the local name of the build directory.

    #   Windows does not handle a UNC pathname to well (at all)

    #

    my $build_dir = $be->{dir};

    chdir ("$build_dir") or Error( "Cannot chdir to build directory: $build_dir");

    if ( $be->{file} =~ m/^build.pl$/ )

    {

        Message ("Using JATS: $build_dir");

        #

        #   Invoke JATS to build the package and make the package

        #

        my @build_args = qw(--expert --cache);

        push @build_args, '--cache' if $opt_cache;

        my $make_type = 'all';

        $make_type = 'all_prod'  if ( $opt_prod_build );

        $make_type = 'all_debug' if ( $opt_debug_build );

        JatsCmd('build', @build_args)               and Error("Package did not build");

        JatsCmd('make', $make_type, 'NODEPEND=1')   and Error("Package did not make");

        JatsCmd('install');

        if ( $opt_runtests )

        {

            JatsCmd('make', 'run_unit_tests')      and Error("Tests did not run correctly");

        }

    }

    else

    {

        #

        #   Ant build files

        #

        my $pname =  $be->{file};

        Message ("Using ANT: $build_dir, $pname");

        $pname =~ s~depends.xml$~.xml~;

        copy($be->{file}, "auto.xml");

        JatsCmd('-buildfile', $pname, 'ant', 'build')        and Error("Package did not build");

        JatsCmd('-buildfile', $pname, 'ant', 'make_package') and Error("Package did not make_package");

    }

}

#

#   Copy the generated packages

#       1) dpkg_archive

#       2) Users local directory

#

foreach my $be (@build_list)

{

    my $build_dir = $be->{dir};

    chdir ("$build_dir") or Error( "Cannot chdir to build directory: $build_dir");

    if ( $opt_dpkg )

    {

        Message ("Using: $build_dir");

        my @create_opts = "-o";

        push @create_opts ,"-m" if ( $opt_merge );

        JatsCmd('-here', 'create_dpkg', @create_opts, '-pname', $be->{name}, '-pversion', $be->{version}) and $error++;

    }

    if ( $opt_copy )

    {

        Message ("Copy package to $user_cwd");

        copy_directory( 'pkg', $user_cwd, '' );

    }

    #

    #   Test structure of the package

    #   Ensure that it has a descpkg file

    #   Validate the package name and version

    #   More important for ANT projects than JATS as JATS has a sanity test

    #

    if ( $opt_test )

    {

        JatsCmd('-here', 'create_dpkg', '-test', '-pname', $be->{name}, '-pversion', $be->{version}) and $error++;

    }

}

Error ("Package not transferred")

    if ( $error );

chdir ($user_cwd) or Error( "Cannot chdir to $$user_cwd");

#

#   Delete the view

#

if ( ! $opt_reuse && ! $error && ! $opt_keep )

{

    delete_view();

}

else

{

    Message( "View left in: $VIEWDIR" );

}

Message ("End program");

exit 0;

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

# Function        : delete_view

#

# Description     : Delete a view

#

# Inputs          : None

#                   $VIEWDIR - path of the view

#

# Returns         :

#

sub delete_view

{

    my $cofound = 0;

    my $uuid;

    #

    #   Simple delete

    #

    if ( $opt_extract_files )

    {

        if ( -d $VIEWDIR )

        {

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

            RmDirTree( $VIEWDIR );

        }

    }

    else

    {

        #

        #   If the view physically exists then attempt to phyically remove it

        #

        if ( -d $VIEWDIR )

        {

            #

            #   Determine if there are any checked out files in the view

            #

            Message("Remove the view: $VIEWDIR");

            Verbose("Look for checked out files");

            SvnRmView ('path'     => $VIEWDIR . $opt_path,

                       'force'    => $opt_delete > 1,

                       'modified' => [ 'local_dpkg_archive' ] );

        }

        Error ("View was not deleted. Will Delete view directory")

            if ( -d $VIEWDIR . $opt_path );

        RmDirTree( $VIEWDIR ) if $opt_path;

    }

    Error ("View was not deleted")

        if ( -d $VIEWDIR );

}

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

# Function        : copy_directory

#

# Description     : Copy a directory tree

#

# Inputs          : Source directory

#                   Target directory

#                   Strip

#

#                   Should be full pathnames

#

# Returns         :

#

my $copy_error;

my $copy_count;

sub copy_directory

{

    our ($src_dir, $dest_dir, $strip) = @_;

    our $slength = length ($strip);

    #

    #   Prevent File::Find from generating warnings

    #

    no warnings 'File::Find';

    #

    #   Helper routine to copy files

    #

    sub copy_file_wanted

    {

        #

        #   Do not copy directories

        #   Just make the directory entry. May result in empty directories

        #

        if ( -d $_ )

        {

            my $tdir = "$dest_dir/" . substr( $File::Find::dir, $slength);

            $tdir .= "/$_";

            File::Path::mkpath( $tdir )

                unless ( -d $tdir);

            return;

        }

        #

        #   When used to copy file from within a clearcase dynamic view the

        #   files may not actually exist. This will generate an error later

        #   so check for existance of file file now.

        #

        return unless ( -e $_ );

        #

        #   Have been chdir'ed to the source directory

        #   when invoked

        #

        my $tdir = "$dest_dir/" . substr( $File::Find::dir, $slength);

        my $tfile = "$tdir/$_";

        my $sfile = "$File::Find::dir/$_";

        Verbose ("Copy: $sfile -> $tfile");

        File::Path::mkpath( $tdir )

            unless ( -d $tdir);

        unlink ( $tfile )

            if ( -f $tfile );

        if( ! File::Copy::copy ( $_ , $tfile ) )

        {

            $copy_error++;

            Message "Error copying $sfile";

        }

        else

        {

            my $perm = (stat $_)[2] & 07777;

            chmod($perm, $tfile);

            $copy_count++;

        }

    }

    #

    #   Locate all files to copy

    #

    $copy_error = 0;

    $copy_count = 0;

    File::Find::find ( \&copy_file_wanted, $src_dir );

    return $copy_error;

}

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

# Function        : count_files

#

# Description     : Count files in a workspace

#                   Ignore .svn stuff

#

# Inputs          : Source directory

#

# Returns         :

#

sub count_files

{

    my ($src_dir) = @_;

    #

    #   Prevent File::Find from generating warnings

    #

    no warnings 'File::Find';

    #

    #   Helper routine to copy files

    #

    sub count_file_wanted

    {

        #

        #   Do not count dirs, only files

        #

        return if ( -d $_ );

        $copy_count++;

    }

    #

    #   Locate all files

    #

    $copy_count = 0;

    File::Find::find ( \&count_file_wanted, $src_dir );

}

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

# 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

{

    #

    #   Determine the target directory for the extracted files

    #       Delete the output subdir

    #       Create the config spec in that directory

    #

    Verbose("Extracting files into $VIEWDIR");

    if ( -d $VIEWDIR )

    {

        Verbose "Delete Directory: $VIEWDIR\n";

        RmDirTree( $VIEWDIR );

    }

    $svn_label->SvnCo ( $svn_label->Full, $VIEWDIR, '--Export', '--NoPrint' );

    #

    #   Count this files in the view

    #   Done so that its clear when we have a empty workspace

    #

    Verbose ("Examine View contents");

    count_files ( $VIEWDIR );

    Message ("View files in: $VIEWDIR, Files: $copy_count" );

}

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

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

#   Documentation

#

=pod

=for htmltoc    GENERAL::Subversion::

=head1 NAME

jats_svnrelease - Build a package given a SubVersion label

=head1 SYNOPSIS

  jats svnrelease [options] [-label=]label

 Options:

    -help              - brief help message

    -help -help        - Detailed help message

    -man               - Full documentation

    -label=xxx         - Subversion label

    -spec=xxx          - Same as -label=xxx

    -path=xxx          - Source Path

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

    -build=xxx         - Package Name to build

    -root=xxx          - Root directory for generated view

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

    -tag=xxx           - Compatability. Not used

    -extract           - Extract the view and exit

    -extractfiles      - Extract files, without a view

    -cache             - Refresh local dpkg_archive cache

    -delete[=n]        - 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]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 Subversion label to use as the base for the workspace.

Eg: DPG_SWBASE/daf_utils_math/tags/3.2.1@12345

=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 path will be: "${USER}_${NAME}"