byob #4

#!/usr/local/bin/perl

# clone project databases


use Getopt::Long;

unless($result=GetOptions("h",
			  "source=s", "target=s", "force", "from=s", "nointeg")){
    die "Illegal Input Options, -h for help\n";
}

($prog = $0) =~ s,.*/,,;

$HELP="Usage: $prog -source <source_rev> -target <target_rev>";

unless($opt_source && $opt_target) {
    print "$HELP\n";
    exit(1);
}


if($opt_h) {
    print "$HELP\n";
    exit(0);
}

umask(002);

$project=$ENV{"PROJECT"};

if (!defined($project)) {
	print "$prog: must set env variable PROJECT first\n";
	exit(1);
}

$cmd = "p4 client -o cdsp4_integ | grep '^Root' > /dev/null 2>&1";
system($cmd);

if ($? != 0) {
	print "$prog: dummy integration client cdsp4_integ does not exist!\nContact your cdsp4 administrator; cannot proceed with branch building.\n";
	exit(1);
}

(@pdata)=split('/',$project);

$proj=$pdata[3];

if (!defined($proj)) {
	print "$prog: env variable PROJECT is not correctly set\n";
	exit(1);
}

$tempfile="/tmp/byob.$$";

print "Building physical tree for $proj\n";

print "Log file is $tempfile\n";

# Check for validity of source and target

# expand source and target to follow physical syntax

$sbranch=$opt_source;
$tbranch=$opt_target;

print "Source branch is $sbranch, target is $tbranch\n";

# Check to see if source branch exists

$cmd="p4 branches | grep $sbranch > /dev/null";
system($cmd);

if($? ne 0) {
    print "Error: couldn't locate the source branch\n";
    exit(1);
}
# Don't overwrite a target branch

$cmd="p4 branches | grep $tbranch > /dev/null";
system($cmd);

if($? eq 0 && !$opt_force) {
    print "Error: target branch already exists\n";
    exit(1);
}

# Define the location of the file relative to the tree root (site dependent variable)

$blocation="";

# need to find the root of the branch client to begin

$bclient=$sbranch."_client";
$cmd="p4 client -o $bclient | grep '^Root'";

open(CMD,"$cmd|") || die "error $cmd\n";

while(<CMD>) {
     chomp;
    ($ig,$broot)=split;
}

print "Source branch root is $broot\n";

if ($blocation eq "") {
	$oldbdir = $broot;
} else {
	$oldbdir="$broot/$blocation";
}

($newbdir = $oldbdir) =~ s/$sbranch/$tbranch/;

# Check for existing and writable new branch directory

if (! -d "$newbdir" || ! -w "$newbdir") {
	die "New branch root directory $newbdir does not exist or is not writable\n";
}

# Check for opened files in the source branch
print "Getting check out status for $opt_source\n";

$cmd="(p4 opened -a //depot/$sbranch/... | grep '#' ) > /dev/null 2>&1";
system($cmd);

if($? eq 0) {
  if (!$opt_force) {
    system("cdscheckouts -bname $sbranch");
    print "\n\nError: *** Aborting byob build due to checkouts in $sbranch\n\n";
    print "Suggestion: *** IF you know what you are doing, you can use the -force flag\n";
    print "\t\tto force the creation of your target branch, but this is potentially\n";
    print "\t\tvery dangerous. You have been warned.\n";
    exit;
  } else {
    print "Detected checkouts in source branch...\n";
    print "*** Force option activated ***\n";
    print "Please confirm this operation (accept_knowingly/no):";
    $line = <STDIN>;
    chomp $line;
    if($line ne "accept_knowingly") {
	print "byob aborted by user request\n";
	exit;
    } 
  }
}

# Feeling emboldened, let's do the integrate

print "Integrating the data...\n";

if($opt_nointeg) {
    print "No integrations will be performed\n";
} else {

if($opt_from) {
    print "Changenumber source is $opt_from\n";
    $cmd="p4 -c cdsp4_integ integ -v //depot/$sbranch/...\@$opt_from //depot/$tbranch/... >> $tempfile";
} else {
    $cmd="p4 -c cdsp4_integ integ -v //depot/$sbranch/... //depot/$tbranch/... >> $tempfile";
}


print "$cmd\n";
system($cmd);

print "Submitting the change, please wait, this can take some time due to sheer volume of data...\n";

# First check if there are any pending file to avoid null submits
$cmd="p4 -c cdsp4_integ change -o | grep \\^Files > /dev/null";
system($cmd);

if($? eq 0) {

$cmd="p4 -c cdsp4_integ change -o | sed 's/<enter description here>/Branch submit by byob ($tbranch $opt_from)/g' | p4 -c cdsp4_integ submit -i >> $tempfile";
system($cmd); 
} else {
    print "All revisions appear to be up to date...\n";
}
}

# Now let's do the Cadence stuff

# Need to clone the clients using the clientmapper script
print "Syncing Cadence databases, please wait...\n";

$cmd="projclientmapper $proj $opt_source $proj $opt_target >> $tempfile";
print "$cmd\n";
system($cmd);

# Now, build the branch cds.lib and cds.p4clients file
# and the .branchrc file

$oldcdslib="$oldbdir/cds.lib";
$newcdslib="$newbdir/cds.lib";

$cmd="sed 's/$sbranch/$tbranch/g' < $oldcdslib > $newcdslib";
system($cmd);

#
# Make sure each INCLUDEd file in cds.lib with a pointer into the
# branch actually exists here.  Copy it from the source branch if not.
#

if (!open(C, "<$newcdslib")) {
    print "$prog: couldn't open the new cds.lib we just built!\n";
}
else {
    while(<C>) {
	split($_);
	if ($_[0] eq "INCLUDE" && $_[1] =~ /$newbdir/) {
	    if (! -f $_[1]) {
		($src_file = $_[1]) =~ s/$newbdir/$oldbdir/;
		if (! -f $src_file) {
		    print "$prog: WARNING: need to copy INCLUDEd file $src_file into the new branch directory, but source file does not exist.  Is something wrong with the cds.lib?\n";
		}
		else {
		    print "$prog: INFO: copying cds.lib's INCLUDE file $_[1] from the source branch directory\n";
		    $cmd = "cp $src_file $newbdir";
		    system($cmd);
		}
	    }
	}
    }
    close(C);
}

# cds.p4client

$oldcdsp4="$oldbdir/cds.p4client";
$newcdsp4="$newbdir/cds.p4client";

$cmd="sed 's/$sbranch/$tbranch/g' < $oldcdsp4 > $newcdsp4";
system($cmd);

# .branchrc.il

$branchrc="$newbdir/.branchrc.il";
open(BF,">$branchrc") || die "Could not write $branchrc\n";

print BF "setShellEnvVar(\"PROJECT_BRANCH=$tbranch\")\n";
close(BF);



# build the branch spec to drive addnewbranch
$desc="Created by byob";
$dspec_source="//depot/$sbranch/...";
$dspec_target="//depot/$tbranch/...";
&build_branch($tbranch,$desc,$dspec_source, $dspec_target);
# build the branch client too
# Spec it out
$cname=$tbranch."_client";
$dspec="//depot/$tbranch/... //$cname/...\n\t-//depot/$tbranch/cadence/... //$cname/cadence/...\n";

$root=$broot;
$root=~s/$sbranch/$tbranch/g;
$desc="$tbranch client";
# Call it
&build_client($cname,$root,$desc,$dspec);
# sync it
print "Syncing the branch client...\n";
$cmd="p4 -c $cname sync >> $tempfile 2>&1";
#print "$cmd\n";
system($cmd);

print "byob is done...\n";

exit(0);

# Begin subroutine declarations

sub build_branch() {

    my $bname=shift;
    my $desc=shift;
    my $dspec_s=shift;
    my $dspec_t=shift;
    
    print "Building branch $bname\n";
    my $tmpfile="/tmp/byob.bf.$$";

    open(CF, ">$tmpfile") || die "Couldn't write temp branch file\n";

    print CF "Branch: $bname\n";
    print CF "Description:\n\t$desc\n";
    # accept default options
    print CF "View:\n\t$dspec_s $dspec_t\n";
    close(CF);
    system("p4 branch -i < $tmpfile");
    system("rm $tmpfile");
    
}


sub build_client() {

    my $cname=shift;
    my $root=shift;
    my $desc=shift;
    my $dspec=shift;

    print "Building client $cname\n";
    my $tmpfile="/tmp/byob.cf.$$";

    open(CF, ">$tmpfile") || die "Couldn't write temp client file\n";

    print CF "Client: $cname\n";
    print CF "Description:\n\t$desc\n";
    print CF "Root: $root\n";
    # accept default options
    print CF "View:\n\t$dspec\n";
    close(CF);
    system("p4 client -i < $tmpfile");
    system("rm $tmpfile");
}