tools/build_bootleg_linux.pl

   1 #! /usr/bin/perl
   2 # ======================================================================
   3 # ======================================================================
   4
   5 use warnings;
   6 use strict;
   7 use Socket;
   8 use Getopt::Long;
   9 use File::Copy;
  10
  11 # ======================================================================
  12 # Constants
  13 # ======================================================================
  14
  15 use constant START_BOOTLEG_TEST => "A";
  16 use constant END_COMMUNICATION => "B";
  17 use constant SUCCESSFUL_TEST => "C";
  18 use constant UNSUCCESSFUL_TEST => "D";
  19 use constant SERVER_READY => "E";
  20 use constant BOOTLEG_MISMATCH => "F";
  21 use constant CLIENT_KILL => "G";
  22 use constant CLIENT_OK => "H";
  23 use constant GOT_BUILD_CLUSTER_VERSION => "I";
  24 use constant FAILED_GETTING_BUILD_CLUSTER_VERSION => "J";
  25 use constant START_UPKEEP => "K";
  26 use constant START_BOOTLEG_SEND => "L";
  27 use constant BOOTLEG_SEND_DIRECTORY => "M";
  28 use constant BOOTLEG_SEND_FILE => "N";
  29 use constant END_BOOTLEG_SEND => "O";
  30 use constant START_EMAIL => "P";
  31
  32 # ======================================================================
  33 # Globals
  34 # ======================================================================
  35
  36 my $name = $0;
  37 $name =~ s/^(.*)\\//;
  38
  39 my $depotdir = "/swg";
  40 my $bootlegdir = "/swg/bootlegs";
  41 my $logfile = "build_bootleg.log";
  42 my $win32machine = "64.37.133.173";
  43 my $port = "21498";
  44 my $emailRecipients = "vthakkar\@soe.sony.com";
  45
  46 my $waittime = "180";
  47 my $branch = "";
  48 my $oldbootleg = "";
  49 my $newbootleg = "";
  50 my $loginpid;
  51 my $taskpid;
  52
  53 my @steps = (0, 0, 0, 0, 0, 0, 0, 0);
  54
  55 # ======================================================================
  56 # Subroutines
  57 # ======================================================================
  58
  59 sub usage
  60 {
  61         print "\n\t$name <optional parameters> <branch>\n\n".
  62                 "\tOptional parameters:\n\n".
  63                 "\t\t--no_script\t: Don't do a script recompile\n".
  64                 "\t\t--no_build\t: Don't build a new bootleg\n".
  65                 "\t\t--no_patch\t: Don't create a patchtree file\n".
  66                 "\t\t--no_send\t: Don't send build / patch results to win32 machine\n".
  67                 "\t\t--no_install\t: Don't install newest bootleg\n".
  68                 "\t\t--no_test\t: Don't perform test on bootleg\n".
  69                 "\t\t--no_email\t: Don't send email about results\n".
  70                 "\t\t--no_upkeep\t: Don't perform upkeep on bootleg directories\n".
  71                 "\n\tWarning: Some options depend on others, some combinations may not work.\n";
  72         die "\n";
  73
  74 }
  75
  76 sub writelog
  77 {
  78         my $message = shift @_;
  79         chomp $message;
  80         my ($sec, $min, $hr, $day, $mon, $yr) = localtime time;
  81         my $timestamp = sprintf "%4s-%02s-%02s\t%02s:%02s:%02s", ($yr + 1900), ($mon + 1), $day, $hr, $min, $sec;
  82
  83         print LOG join("\t", $timestamp, $message), "\n";
  84 }
  85
  86 sub fatal
  87 {
  88         my $message = shift @_;
  89         print "Fatal error running: $message\n";
  90         writelog("Fatal error running: $message");
  91         close(LOG);
  92         die;
  93 }
  94
  95 sub unbuffer
  96 {
  97         my $oldSelect = select($_[0]);
  98         $| = 1;
  99         select($oldSelect);
 100 }
 101
 102 sub unbufferReadline
 103 {
 104         my ($fh) = @_;
 105         my $buffer;
 106         my $return = "";
 107         while(sysread($fh, $buffer, 1))
 108         {
 109                 $return .= $buffer;
 110                 last if($buffer eq "\n");
 111         }
 112         return $return;
 113 }
 114
 115 sub perforceWhere
 116 {
 117         local $_;
 118
 119         # find out where a perforce file resides on the local machine
 120         my $result;
 121         {
 122                 open(P4, "p4 where $_[0] |");
 123                         $_ = <P4>;
 124                         chomp;
 125                         my @where = split;
 126                         $result = $where[2];
 127                 close(P4);
 128         }
 129
 130         return $result;
 131 }
 132
 133
 134 sub openClientSocket
 135 {
 136         socket(SOCKET, PF_INET, SOCK_STREAM, getprotobyname('tcp')) || closeServer("socket failed\n");
 137         {
 138                 my $destination = inet_aton($win32machine) || closeServer("inet_aton failed\n");
 139                 my $paddr = sockaddr_in($port, $destination);
 140                 connect(SOCKET, $paddr) || closeServer("connect failed\n");
 141
 142                 # unbuffer the socket
 143                 my $oldSelect = select(SOCKET);
 144                 $| = 1;
 145                 select($oldSelect);
 146
 147                 # put the socket into binary mode
 148                 binmode SOCKET;
 149         }
 150 }
 151
 152 sub buildBootleg
 153 {
 154         my $win32complete = 0;
 155         my $linuxcomplete = 0;
 156
 157         print "Building bootleg...\n";
 158         writelog("Building bootleg");
 159         open(LINUXBUILD, "perl ${depotdir}/swg/current/tools/build_script_linux_new.pl $branch -bootleg -incrediBuild 2>&1 |") or fatal "Error running build_script_linux.pl\n";
 160
 161         while(<LINUXBUILD>)
 162         {
 163                 print;
 164                 writelog($_);
 165                 $newbootleg = $1 if(/^Syncing to $branch\@(\d+)/);
 166                 $win32complete = 1 if(/^Windows build returned 0/);
 167                 $linuxcomplete = 1 if(/^Linux build returned 0/);
 168         }
 169
 170         close(LINUXBUILD);
 171
 172         print "linux build incomplete\n" if(!$linuxcomplete);
 173         print "windows build incomplete\n" if(!$win32complete);
 174         print "Completed building bootleg $newbootleg.\n\n" if($win32complete && $linuxcomplete);
 175
 176         writelog("Bootleg: $newbootleg, Linux complete: $linuxcomplete, Windows complete: $win32complete");
 177         ($win32complete && $linuxcomplete) ? return 1 : return 0;
 178 }
 179
 180 sub buildPatchTree
 181 {
 182         my $patch_tree_complete = 0;
 183         my $patch_changelist = 0;
 184
 185         print "Building patch tree...\n";
 186         writelog("Building patch tree");
 187         mkdir "$bootlegdir/$branch/$newbootleg/patch" || fatal "mkdir for patchtree failed";
 188
 189         open(PATCHTREE, "perl ${depotdir}/swg/current/tools/CheckPatchTreeSize.pl --sync --changelist=$newbootleg --save_treefile=$bootlegdir/$branch/$newbootleg/patch/bootlegpatch.tre |") or fatal "Error running CheckPatchTreeSize.pl\n";
 190         while(<PATCHTREE>)
 191         {
 192                 print;
 193                 writelog($_);
 194                 $patch_changelist = $1 if(/^Most recent final manifest at revision \d+, patch \d+, changelist (\d+)/);
 195                 $patch_tree_complete = 1 if(/^Size of \.tre is: \d+$/);
 196         }
 197         close(PATCHTREE);
 198
 199         move "$bootlegdir/$branch/$newbootleg/patch/bootlegpatch.tre", "$bootlegdir/$branch/$newbootleg/patch/bootleg_${patch_changelist}_${newbootleg}.tre";
 200
 201         print "Patch tree build incomplete.\n\n" if(!$patch_tree_complete);
 202         print "Patch tree build complete.\n\n" if($patch_tree_complete);
 203
 204         writelog("Patch Tree complete: $patch_tree_complete");
 205         return $patch_tree_complete;
 206 }
 207
 208 sub sendBootleg
 209 {
 210         print "Sending bootleg / patch to win32 machine...\n";
 211         writelog("Sending bootleg / patch to win32 machine...");
 212
 213         openClientSocket();
 214
 215         print SOCKET START_BOOTLEG_SEND;
 216         print SOCKET pack("N", length $branch);
 217         print SOCKET $branch;
 218         print SOCKET pack("N", $newbootleg);
 219
 220         # Build an array of what directories to send over
 221         my @directories;
 222         push @directories, "patch" if(-d "$bootlegdir/$branch/$newbootleg/patch");
 223         push @directories, "servers" if(-d "$bootlegdir/$branch/$newbootleg/servers");
 224
 225         while(@directories = sort @directories)
 226         {
 227                 my $dir = shift @directories;
 228
 229                 # Tell the windows machine to get a new directory
 230                 print SOCKET BOOTLEG_SEND_DIRECTORY;
 231                 print SOCKET pack("N", length $dir);
 232                 print SOCKET $dir;
 233
 234                 opendir DH, "$bootlegdir/$branch/$newbootleg/$dir" || die "could not open directory\n";
 235                 foreach my $fileName (sort readdir DH)
 236                 {
 237                         next if($fileName eq "." || $fileName eq "..");
 238                         push @directories, "$dir/$fileName" if(-d "$bootlegdir/$branch/$newbootleg/$dir/$fileName");
 239                         next if(!-f "$bootlegdir/$branch/$newbootleg/$dir/$fileName");
 240
 241                         my $fileSize = -s "$bootlegdir/$branch/$newbootleg/$dir/$fileName";
 242                         print "Sending file $fileName ($fileSize bytes)\n";
 243                         writelog("Sending file $fileName ($fileSize bytes)");
 244                         print SOCKET BOOTLEG_SEND_FILE;
 245                         print SOCKET pack("NN", length $fileName, $fileSize);
 246                         print SOCKET $fileName;
 247                         open(F, "<$bootlegdir/$branch/$newbootleg/$dir/$fileName");
 248                                 binmode(F);
 249                                 while ($fileSize)
 250                                 {
 251                                         my $buffer;
 252                                         my $readSize = 16 * 1024;
 253                                         $readSize = $fileSize if ($fileSize < $readSize);
 254                                         my $readResult = read(F, $buffer, $readSize);
 255                                         die "unexpected end of file" if (!defined($readResult));
 256                                         die "did not read what we expected to" if ($readResult != $readSize);
 257                                         print SOCKET $buffer;
 258                                         $fileSize -= $readResult;
 259                                 }
 260                                 die "copied all the bytes but not at EOF" if (!eof(F));
 261                         close(F);
 262                 }
 263                 closedir DH;
 264         }
 265
 266         print SOCKET END_BOOTLEG_SEND;
 267         print "Finished sending to win32 machine.\n";
 268         writelog("Finished sending to win32 machine.");
 269         close(SOCKET);
 270
 271         return 1;
 272 }
 273
 274 sub installBootleg
 275 {
 276         print "Installing bootleg...\n";
 277         writelog("Installing bootleg");
 278
 279         open(INSTALL, "perl " . perforceWhere("//depot/swg/current/tools/InstallBootleg.pl") . " --list --force_newest --server_only --install_as_build_cluster $branch |") or fatal "Error running InstallBootleg.pl\n";
 280
 281         my $complete = 0;
 282
 283         while(<INSTALL>)
 284         {
 285                 print;
 286                 writelog($_);
 287                 $complete = 1 if(/^Update complete\./);
 288                 $oldbootleg = $1 if($oldbootleg eq "" && /^\d+\s+(\d+)\s+blessed/);
 289                 $newbootleg = $1 if(/^Updating to build: (\d+)/);
 290         }
 291
 292         close(INSTALL);
 293
 294         print "Bootleg installation incomplete\n" if(!$complete);
 295         print "Completed installing bootleg.\n\n" if($complete);
 296         writelog("OldBootleg: $oldbootleg, InstallBootleg complete: $complete");
 297
 298         return $complete;
 299 }
 300
 301 sub closeServer
 302 {
 303         print "Fatal Error: Killing forked processes\n";
 304         endServer();
 305         fatal $_[0];
 306 }
 307
 308 sub startServer
 309 {
 310         my $loginServer = "debug/LoginServer";
 311         my $taskManager = "debug/TaskManager";
 312
 313         writelog("Starting Server");
 314         my $serverdir = perforceWhere("//depot/swg/$branch/bootleg/linux/fakefile");
 315         $serverdir =~ s/fakefile$//;
 316         chdir($serverdir) || fatal "Cannot change directory to $serverdir\n";
 317
 318         print "Starting up server...\n";
 319         $loginpid = open(LOGINSERVER, "$loginServer -- \@loginServer.cfg 2>&1 |") or closeServer("Can't open LoginServer\n");
 320         binmode LOGINSERVER;
 321
 322         while(<LOGINSERVER>)
 323         {
 324                 writelog("LoginServer: $_") if(/\S+/);
 325                 last if(/^Log observer setup/);
 326         }
 327
 328         $taskpid = open(TASKMANAGER, "$taskManager -- \@taskmanager.cfg 2>&1 |") or closeServer("Can't open TaskManager\n");
 329         binmode TASKMANAGER;
 330
 331         while(<TASKMANAGER>)
 332         {
 333                 writelog("TaskManager: $_") if(/\S+/);
 334                 last if(/^Preload finished on all planets/);
 335         }
 336 }
 337
 338 sub endServer
 339 {
 340         writelog("Ending Server");
 341         print "Shutting down server.\n";
 342         kill 1, $taskpid if(defined $taskpid);
 343         kill 1, $loginpid if(defined $loginpid);
 344         system("killall CommoditiesServer");
 345         system("killall ChatServer");
 346         close(TASKMANAGER);
 347         close(LOGINSERVER);
 348 }
 349
 350 sub startClient
 351 {
 352         writelog("Starting Client");
 353         print "Starting up client...\n";
 354
 355         openClientSocket();
 356
 357         print SOCKET START_BOOTLEG_TEST;
 358         print SOCKET pack("N", length $branch);
 359         print SOCKET $branch;
 360 }
 361
 362 sub endClient
 363 {
 364         writelog("Ending Client");
 365         print SOCKET CLIENT_KILL;
 366         print "Shutting down client.\n";
 367         close(SOCKET);
 368 }
 369
 370 sub checkResponses
 371 {
 372         writelog("Verifying server and client responses");
 373         my $loginsuccess = 0;
 374         my $tasksuccess = 0;
 375         my $buffer;
 376
 377         print "Verifying client and server have same bootleg installation.\n";
 378         read(SOCKET, $buffer, 4) == 4 or fatal "Error reading from win32 machine\n";
 379         my $clientbootleg = unpack("N", $buffer);
 380
 381         if($clientbootleg ne $newbootleg)
 382         {
 383                 writelog("Mismatch in client / server bootlegs - client: $clientbootleg, server: $newbootleg");
 384                 print "Mismatch in client / server bootlegs - client: $clientbootleg, server: $newbootleg\n";
 385                 print SOCKET BOOTLEG_MISMATCH;
 386                 return 0;
 387         }
 388         print "Both client and server have bootleg $newbootleg installed\n";
 389         writelog("Both client and server have bootleg $newbootleg installed");
 390
 391         print SOCKET SERVER_READY;
 392
 393         my $starttime = time;
 394         writelog("Beginning test with client - timeout of $waittime seconds");
 395
 396         # used to create non-blocking reading of both filehandles
 397         while(1)
 398         {
 399                 my $rin = '';
 400                 my $rout;
 401                 my $line;
 402                 vec($rin, fileno(LOGINSERVER), 1) = 1;
 403                 vec($rin, fileno(TASKMANAGER), 1) = 1;
 404
 405                 if(select($rout=$rin, undef, undef, 0))
 406                 {
 407                         if (vec($rout, fileno(LOGINSERVER), 1))
 408                         {
 409                                 $line = unbufferReadline(\*LOGINSERVER);
 410                                 if(defined $line)
 411                                 {
 412                                         writelog("LoginServer: $line") if($line =~ /\S+/);
 413                                         ++$loginsuccess if($loginsuccess == 0 && $line =~ /^connection opened for service on port \d+/);
 414                                         ++$loginsuccess if($loginsuccess == 1 && $line =~ /^Encrypting with key:/);
 415                                         ++$loginsuccess if($loginsuccess == 2 && $line =~ /^Client connected\.  Station Id:  \d+, Username: bootleg/);
 416                                         ++$loginsuccess if($loginsuccess == 3 && $line =~ /^Client \d+ disconnected/);
 417
 418                                         last if ($line =~ /ERROR/ or $line =~ /FATAL/);
 419                                 }
 420                         }
 421                         if (vec($rout, fileno(TASKMANAGER), 1))
 422                         {
 423                                 $line = unbufferReadline(\*TASKMANAGER);
 424                                 if(defined $line)
 425                                 {
 426                                         writelog("TaskManager: $line") if($line =~ /\S+/);
 427                                         ++$tasksuccess if($tasksuccess == 0 && $line =~ /^connection opened for service on port \d+/);
 428                                         ++$tasksuccess if($tasksuccess == 1 && $line =~ /^Opened connection with client/);
 429                                         ++$tasksuccess if($tasksuccess == 2 && $line =~ /^Recieved ClientIdMsg/);
 430                                         ++$tasksuccess if($tasksuccess == 3 && $line =~ /^Decrypting with key: /);
 431                                         ++$tasksuccess if($tasksuccess == 4 && $line =~ /^succeeded/);
 432                                         ++$tasksuccess if($tasksuccess == 5 && $line =~ /^ValidateAccountMessage/);
 433                                         ++$tasksuccess if($tasksuccess == 6 && $line =~ /^ValidateAccountReplyMessage/);
 434                                         ++$tasksuccess if($tasksuccess == 7 && $line =~ /^Permissions for \d+:/);
 435                                         ++$tasksuccess if($tasksuccess == 8 && $line =~ /canLogin/);
 436                                         ++$tasksuccess if($tasksuccess == 9 && $line =~ /canCreateRegularCharacter/);
 437                                         ++$tasksuccess if($tasksuccess == 10 && $line =~  /^Recvd SelectCharacter message for \d+/);
 438                                         ++$tasksuccess if($tasksuccess == 11 && $line =~  /^Got ValidateCharacterForLoginMessage acct \d+, character \d+/);
 439                                         ++$tasksuccess if($tasksuccess == 12 && $line =~  /^Pending character \d+ is logging in or dropping/);
 440
 441                                         last if ($line =~ /ERROR/ or $line =~ /FATAL/);
 442                                 }
 443                         }
 444                 }
 445
 446                 return 0 if((time - $starttime) > $waittime);
 447                 last if($loginsuccess == 4 && $tasksuccess == 13);
 448         }
 449
 450         writelog("LoginServer success: $loginsuccess/4, Taskmanager success: $tasksuccess/13");
 451         return 0 if($loginsuccess != 4 || $tasksuccess != 13);
 452
 453         # Tell win32 machine that the client is ok (don't need to kill it)
 454         print SOCKET CLIENT_OK;
 455
 456         read(SOCKET, $buffer, 1) == 1 or fatal "Error reading from win32 machine\n";
 457
 458         my $clientsuccess = 0;
 459         $clientsuccess = 1 if($buffer eq SUCCESSFUL_TEST);
 460
 461         writelog("Client success: $clientsuccess/1");
 462         return 0 if($clientsuccess != 1);
 463
 464         return 1;
 465 }
 466
 467 sub testBootleg
 468 {
 469         print "Testing bootleg...\n";
 470         writelog("Testing bootleg");
 471         my $test = 0;
 472
 473         startServer();
 474         startClient();
 475
 476         $test = checkResponses();
 477
 478         endServer();
 479         endClient();
 480
 481         fatal "Test for bootleg $newbootleg unsuccessful\n" if(!$test);
 482         print "Testing successful.\n\n";
 483         writelog("Test for bootleg successful: $test");
 484         open(BLESS, ">$bootlegdir/$branch/$newbootleg/blessed.txt");
 485         close(BLESS);
 486
 487         return 1;
 488 }
 489
 490 sub email
 491 {
 492         return 0 if($newbootleg eq "");
 493
 494         # Get old bootleg if we don't know it
 495         if($oldbootleg eq "")
 496         {
 497                 openClientSocket();
 498
 499                 print SOCKET START_EMAIL;
 500                 # Tell the client which bootleg to ignore
 501                 print SOCKET pack("N", length $newbootleg);
 502                 print SOCKET $newbootleg;
 503
 504                 my $buffer;
 505                 return 0 if(read(SOCKET, $buffer, 4) != 4);
 506                 my $oldBootlegLength = unpack("N", $buffer);
 507                 return 0 if($oldBootlegLength == 0);
 508                 return 0 if(read(SOCKET, $oldbootleg, $oldBootlegLength) != $oldBootlegLength);
 509
 510                 close(SOCKET);
 511         }
 512
 513         print "Emailing about changes from bootleg $oldbootleg to $newbootleg...\n";
 514         writelog("Emailing changes from $oldbootleg to $newbootleg");
 515         return 0 if($oldbootleg eq "");
 516         open(EMAIL, "| mail -s \"[bootleg] $branch.$newbootleg.0 is up\" $emailRecipients");
 517
 518         print EMAIL "${bootlegdir}/\n".
 519             "\n-Vijay\n\n";
 520
 521         print EMAIL "Changes between $oldbootleg and $newbootleg\n";
 522
 523         open(CHANGES, "perl ${depotdir}/swg/current/tools/BuildChanges.pl -i //depot/swg/$branch/... $oldbootleg $newbootleg |");
 524         while(<CHANGES>)
 525         {
 526                 next if(/^Change (\d+) on/ || /^\[(public|internal)\]/ || /^\n/ || /.?none.?/i || /n(\/|\.)a/i || /^---/ || /ignoring script recompile/i);
 527                 s/^\s*-?\s*//;
 528                 print EMAIL "\t- $_";
 529         }
 530         close(CHANGES);
 531         print "Completed emailing.\n\n";
 532         writelog("Completed emailing.");
 533
 534         return 1;
 535 }
 536
 537 sub upkeep
 538 {
 539         my $buffer;
 540
 541         print "Performing upkeep on bootleg directory for $branch...\n";
 542         writelog("Performing upkeep on bootleg directory for $branch...");
 543
 544         openClientSocket();
 545
 546         print SOCKET START_UPKEEP;
 547         print SOCKET pack("N", length $branch);
 548         print SOCKET $branch;
 549
 550         return 0 if(read(SOCKET, $buffer, 1) != 1);
 551
 552         if($buffer eq FAILED_GETTING_BUILD_CLUSTER_VERSION)
 553         {
 554                 print "Failed getting build cluster version\n";
 555                 writelog("Failed getting build cluster version");
 556                 return 0;
 557         }
 558         elsif($buffer eq GOT_BUILD_CLUSTER_VERSION)
 559         {
 560                 return 0 if(read(SOCKET, $buffer, 4) != 4);
 561                 my $buildClusterBootleg = unpack("N", $buffer);
 562                 print "Build cluster bootleg version is $buildClusterBootleg\n";
 563                 writelog("Build cluster bootleg version is $buildClusterBootleg");
 564         }
 565         else
 566         {
 567                 print "Got incorrect return from win32 machine\n";
 568                 writelog("Got incorrect return from win32 machine.");
 569                 return 0;
 570         }
 571
 572         while(1)
 573         {
 574                 return 0 if(read(SOCKET, $buffer, 4) != 4);
 575                 my $bootlegVer = unpack("N", $buffer);
 576                 last if($bootlegVer == 0);
 577                 print "Removed bootleg $branch/$bootlegVer.\n";
 578                 writelog("Removed bootleg $branch/$bootlegVer.");
 579         }
 580
 581         while(1)
 582         {
 583                 return 0 if(read(SOCKET, $buffer, 4) != 4);
 584                 my $pdbFileLength = unpack("N", $buffer);
 585                 last if($pdbFileLength == 0);
 586                 return 0 if(read(SOCKET, $buffer, $pdbFileLength) != $pdbFileLength);
 587                 print "Removed pdb file $buffer.\n";
 588                 writelog("Removed pdb file $buffer.");
 589         }
 590
 591         close(SOCKET);
 592 }
 593
 594 sub submitOpenFiles
 595 {
 596         local $_;
 597         my @files;
 598         open(P4, "p4 -ztag opened -c default |");
 599
 600                 while (<P4>)
 601                 {
 602                         chomp;
 603                         push (@files, $_) if (s/^\.\.\. depotFile //);
 604                 }
 605
 606         close(P4);
 607
 608         my $tmpfile = "submit.tmp";
 609
 610         # submit all the open files
 611         open(TMP, ">" . $tmpfile);
 612
 613                 print TMP "Change:\tnew\n";
 614                 print TMP "\nDescription:\n";
 615
 616                 foreach (@_)
 617                 {
 618                         print TMP "\t", $_, "\n";
 619                 }
 620
 621                 print TMP "\nFiles:\n";
 622                 foreach (@files)
 623                 {
 624                         print TMP "\t", $_, "\n";
 625                 }
 626
 627         close(TMP);
 628
 629         my $result = system("p4 submit -i < $tmpfile");
 630         fatal "p4 submit failed" if ($result != 0);
 631         unlink($tmpfile);
 632 }
 633
 634 sub scriptRecompile
 635 {
 636         print "Recompiling scripts...\n";
 637
 638         writelog("Syncing perforce for script recompile...");
 639         system("p4 sync //depot/swg/$branch/...") == 0 || return 0;
 640         writelog("Sync perforce complete.");
 641         writelog("Recompiling scripts...");
 642
 643         my $result = system("perl ${depotdir}/swg/current/tools/recompileAllScripts.pl $branch");
 644
 645         writelog("Recompile scripts returned $result (success = 0)");
 646
 647         if ($result != 0)
 648         {
 649                 my $attach = "";
 650                 $attach .= " -a pythonPreprocessorStderr.log" if (-s "pythonPreprocessorStderr.log");
 651                 $attach .= " -a javac.log" if (-s "javac.log");
 652                 system("mutt -s \"[BUILDLOG $branch] script recompile failed, errors attached\" $attach $emailRecipients < /dev/null");
 653                 system("p4 revert -c default //depot/... > /dev/null");
 654                 return 0;
 655         }
 656
 657         system("p4 revert -a > /dev/null");
 658         submitOpenFiles("[automated]", "Script recompile for bootleg build");
 659
 660         print "Recompile scripts successful.\n";
 661         return 1;
 662 }
 663
 664 # ======================================================================
 665 # Main
 666 # ======================================================================
 667
 668 usage() if(!GetOptions('no_script' => \$steps[0], 'no_build' => \$steps[1], 'no_patch' => \$steps[2], 'no_send' => \$steps[3], 'no_install' => \$steps[4], 'no_test' => \$steps[5], 'no_email' => \$steps[6], 'no_upkeep' => \$steps[7]));
 669 usage() if(@ARGV != 1);
 670
 671 # open the log file
 672 open(LOG, ">>$logfile") || die "Could not open $logfile\n";
 673 unbuffer(\*LOG);
 674
 675 $branch = shift;
 676 print "Beginning bootleg build for branch $branch\n";
 677 writelog("Beginning bootleg build for branch $branch");
 678
 679 scriptRecompile() || fatal "scriptRecompile" if(!$steps[0]);
 680 buildBootleg() || fatal "build" if(!$steps[1]);
 681 buildPatchTree() || fatal "buildPatchTree" if(!$steps[2]);
 682 sendBootleg() || fatal "sendBootleg" if(!$steps[3]);
 683 installBootleg() || fatal "installBootleg" if(!$steps[4]);
 684 testBootleg() || fatal "testBootleg" if(!$steps[5]);
 685 email() || fatal "email" if(!$steps[6]);
 686 upkeep() || fatal "upkeep" if(!$steps[7]);
 687
 688 print "Build of bootleg $newbootleg complete.\n";
 689 writelog("Build of bootleg $newbootleg complete");
 690
 691 close(LOG);