Subversion Repositories DevTools

#! perl
########################################################################
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
#
# Module name   : jats.sh
# Module type   : Makefile system
# Compiler(s)   : n/a
# Environment(s): jats
#
# Description   : Process a hijacked file(s)
#                 Check it in on a branch
#
# Usage:
#
# Version   Who      Date        Description
#
#......................................................................#

require 5.006_001;
use strict;
use warnings;
#use Data::Dumper;
use Getopt::Long;
use Pod::Usage;                         # required for help support

#
#   Config items
#
my $branch  = "ddp_test_branch";        # Branch to checkout the file in
                                        # Use one name for lots of work

my $opt_verbose = 0;                    # Verbosity
my $opt_help = 0;
my $opt_manual;
my $pname = "HIJACK_CI";                # Utility name for display messages
my $VERSION = "1.0.0";

#
#   Globals
#
my @error_list;
my $last_result;

#-------------------------------------------------------------------------------
# Function        : Main Entry
#
# Description     : This small program will process hijacked files in a
#                   static view. It will create a branch for the file and then
#                   check the file in on the branch
#
#
# Inputs          : None
#
# Returns         : Even less.
#

my $result = GetOptions (
                "help+"     => \$opt_help,          # flag, multiple use allowed
                "manual"    => \$opt_manual,        # flag
                "verbose+"  => \$opt_verbose,       # flag
                );

#
#   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_manual || ($opt_help > 2));

error ("No files to process")
    unless ( $#ARGV >= 0  );

#
#   Process files one by one
#
foreach  ( @ARGV )
{
    process_file( $_ );
}
exit;


#-------------------------------------------------------------------------------
# Function        : process_file
#
# Description     : Process one file
#
# Inputs          : A single file
#
# Returns         :
#
sub process_file
{
    my ($file) = @_;
    #
    #   Sanity test
    #
    unless ( -f $file )
    {
        Warning ("File not found: $file");
        return 1;
    }

    #
    #   Ensure that the file is hijacked
    #
    ClearCmd( "ls  $file" );
    error ("Program Terminated") if ( @error_list );

    unless ( $last_result =~ m~\[.*hijacked.*\]~ )
    {
        Warning ("File is not hijacked: $file");
        return 1;
    }

    #
    #   remove any .keep file
    #   Its easier than trying to detect which file ClearCase will create
    #
    if ( -f "$file.keep"  )
    {
        unlink ( "$file.keep" ) || error ("Cannot delete $file.keep");
    }

    #
    #   Status the version of the file in the view
    #   Use to determine vital file info
    #
    ClearCmd( "ls  -short $file" );
    error ("Program Terminated") if ( @error_list );

    $last_result =~ tr~\\/~/~s;
    my $full_path = $last_result;

    my $branch_path = $last_result;
       $branch_path =~ s~[/][^/]*$~~;

    my $root_branch = $branch_path;
       $root_branch =~ s~.*@/~~;

    my $is_on_branch = 0;
       $is_on_branch = 1 if ( $root_branch =~ m~/$branch~  ) ;

    my $target_branch = $is_on_branch ? $root_branch : "$root_branch/$branch";

    vprint ("Full Path        : $full_path");
    vprint ("BranchPath       : $branch_path");
    vprint ("RootPath         : $root_branch");
    vprint ("TgtBranch        : $target_branch");
    vprint ("Is Branched      : $is_on_branch");

    #
    #   Branch the file if it has not been branched
    #
    unless ( $is_on_branch )
    {

        #
        #   Ensure that the required branch exists in this VOB
        #
        ClearCmd ("lstype -short brtype:$branch" );
        if ( $last_result ne $branch )
        {
            vprint ("Create the branch in this VOB" );
            ClearCmd ("mkbrtype -c \"A development branch\" $branch" );
            error ("Program Terminated") if ( @error_list );
        }

        vprint ("Test. Has the file been branched" );
        if ( ClearCmd( "describe -short ${branch_path}/${branch}/0" ) )
        {
            vprint ("Create the initial branch point" );
            ClearCmd( "mkbranch -nco -nc -nwarn $branch $full_path" );
        }
    }

    #
    #   Checkout the file on the branch
    #   Don't checkout any data - its not needed
    #   Since its a hijacked file the file will be renamed to a .keep file
    #
    vprint ("Checkout the file on a branch" );
    ClearCmd ("co -nc -nq -ndata -nwarn -branch \"$target_branch\" $full_path");
    error ("Program Terminated") if ( @error_list );

    #
    #   Checkin the hijacked file
    #   Checkin the .keep file directly
    #
    ClearCmd ("ci -c \"Hijacked file check in\" -identical -from \"$file.keep\" \"$file\"");
    error ("Program Terminated") if ( @error_list );
}

#-------------------------------------------------------------------------------
# Function        : ClearCmd
#
# Description     : Similar to the system command
#                   Does allow standard output and standard error to be captured
#                   to a log file
#
#                   Used since I was having problems with calling other programs
#                   and control-C. It could hang the terminal session.
#
# Inputs          :
#
# Returns         :
#
sub ClearCmd
{
    my( $cmd ) = @_;
    vprint2( "cleartool $cmd" );

        @error_list = ();
        open(CMD, "cleartool $cmd  2>&1 |")    || error( "can't run command: $!" );
        while (<CMD>)
        {
            chomp;
            $last_result = $_;
            $last_result =~ tr~\\/~/~s;
            vprint ( "cleartool resp:" . $_);
            push @error_list, $_ if ( m~Error:~ );
        }
        close(CMD);

    vprint2( "Exit Status: $?" );
    return $? / 256;
}

#-------------------------------------------------------------------------------
# FUNCTION        : error
#
# DESCRIPTION     : Display an error message and exit
#
# INPUTS          : Arguments to be displayed
#
# RETURNS         : This function does not return
#
sub error
{
    print STDERR "[$pname] ERROR: @_\n" ;
    foreach ( @error_list )
    {
        print "$_\n";
    }
    exit 1;
}

sub Warning
{
    print STDERR "[$pname] WARNING: @_\n" ;
}


#-------------------------------------------------------------------------------
# Function        : vprint
#
# Description     : Print if verbose mode is enabled
#
# Inputs          :
#
# Returns         :
#

sub vprint
{
    print STDERR "[$pname] @_\n"
        if ( $opt_verbose );
}
sub vprint2
{
    print STDERR "[$pname] @_\n"
        if ( $opt_verbose > 1 );
}


#-------------------------------------------------------------------------------
#   Documentation
#

=pod

=head1 NAME

xxxxx - Save a hijacked file on a private branch

=head1 SYNOPSIS

  xxxxxx [options] files...

 Options:
    -help               - brief help message
    -help -help         - Detailed help message
    -man                - Full documentation
    -verbose            - Verbose operation

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

Increases program output. This option may be specified mutiple times

=back

=head1 DESCRIPTION

This small program will process hijacked files in a static view. It will create
a branch for the file and then check the file in on the branch

=cut