run_build

   1 #!/usr/bin/env perl
   2
   3 =comment
   4
   5 Copyright (c) 2003-2010, Andrew Dunstan
   6
   7 See accompanying License file for license details
   8
   9 =cut
  10
  11 ####################################################
  12
  13 =comment
  14
  15  NAME: run_build - script to run exim buildfarm
  16
  17  SYNOPSIS:
  18
  19   run_build [option ...] [branchname]
  20
  21  AUTHOR: Andrew Dunstan
  22
  23  DOCUMENTATION:
  24
  25   See http://wiki.exim.org/wiki/PostgreSQL_Buildfarm_Howto
  26
  27  REPOSITORY:
  28
  29   https://github.com/EximBuildFarm/client-code
  30
  31 =cut
  32
  33 ###################################################
  34
  35 our $VERSION = 'REL_0.1';
  36
  37 use strict;
  38 use warnings;
  39 use Config;
  40 use Fcntl qw(:flock :seek);
  41 use File::Path;
  42 use File::Copy;
  43 use File::Basename;
  44 use File::Temp;
  45 use File::Spec;
  46 use FindBin qw'$Bin';
  47 use IO::Handle;
  48 use POSIX qw(:signal_h strftime);
  49 use Data::Dumper;
  50 use Cwd qw(abs_path getcwd);
  51 use File::Find ();
  52
  53 # save a copy of the original enviroment for reporting
  54 # save it early to reduce the risk of prior mangling
  55 use vars qw($orig_env);
  56
  57 BEGIN
  58 {
  59     $orig_env = {};
  60     while (my ($k,$v) = each %ENV)
  61     {
  62
  63         # report all the keys but only values for whitelisted settings
  64         # this is to stop leaking of things like passwords
  65         $orig_env->{$k} =(
  66             (
  67                     $k =~ /^PG(?!PASSWORD)|MAKE|CC|CPP|FLAG|LIBRAR|INCLUDE/
  68                   ||$k =~/^(HOME|LOGNAME|USER|PATH|SHELL)$/
  69             )
  70             ? $v
  71             : 'xxxxxx'
  72         );
  73     }
  74 }
  75
  76 use EximBuild::SCM;
  77 use EximBuild::Options;
  78 use EximBuild::WebTxn;
  79
  80 if ($0 =~ /(.*)\.pl$/) {
  81     die "$0: Please use `@{[join ' ' => $1, @ARGV]}' instead.\n"
  82         if -t;
  83     exec $1, @ARGV;
  84 }
  85
  86 die "$0: please use an umask of 022\n"
  87     if umask > 022;
  88
  89 my %module_hooks;
  90 my $orig_dir = getcwd();
  91 push @INC, $orig_dir;
  92
  93 umask 022;
  94
  95 # make sure we exit nicely on any normal interrupt
  96 # so the cleanup handler gets called.
  97 # that lets us stop the db if it's running and
  98 # remove the inst and exim directories
  99 # so the next run can start clean.
 100
 101 foreach my $sig (qw(INT TERM HUP QUIT))
 102 {
 103     $SIG{$sig}=\&interrupt_exit;
 104 }
 105
 106 # copy command line before processing - so we can later report it
 107 # unmunged
 108
 109 my @invocation_args = (@ARGV);
 110
 111 # process the command line
 112 EximBuild::Options::fetch_options();
 113
 114 die "only one of --from-source and --from-source-clean allowed"
 115   if ($from_source && $from_source_clean);
 116
 117 die "only one of --skip-steps and --only-steps allowed"
 118   if ($skip_steps && $only_steps);
 119
 120 $verbose=1 if (defined($verbose) && $verbose==0);
 121 $verbose ||= 0; # stop complaints about undefined var in numeric comparison
 122
 123 if ($testmode)
 124 {
 125     $verbose=1 unless $verbose;
 126     $forcerun = 1;
 127     $nostatus = 1;
 128     $nosend = 1;
 129
 130 }
 131
 132 use vars qw(%skip_steps %only_steps);
 133 $skip_steps ||= "";
 134 if ($skip_steps =~ /\S/)
 135 {
 136     %skip_steps = map {$_ => 1} split(/\s+/,$skip_steps);
 137 }
 138 $only_steps ||= "";
 139 if ($only_steps =~ /\S/)
 140 {
 141     %only_steps = map {$_ => 1} split(/(\s+|[:,])/,$only_steps);
 142 }
 143
 144 # Currently only specifying a branch is actually used.
 145 # Specifying a different repo is just a wishlist item .
 146 use vars qw($branch $repo);
 147 my ($arg1,$arg2) = (shift,shift);
 148 $branch = $arg2 ? $arg2 :
 149           $arg1 ? $arg1 :
 150           'HEAD';
 151 $repo = $arg2 ? $arg1 : 'exim';
 152 my $explicit_branch = $branch;
 153
 154 print_help() if ($help);
 155
 156 #
 157 # process config file
 158 #
 159 require $buildconf;
 160 #use Data::Dumper;
 161 #die Dumper \%EximBuild::conf;
 162
 163
 164 # Does not seem to be necessary
 165 #die "$0: permissions on '$EximBuild::conf{build_root}' should be >= 0775\n"
 166 #    if -d $EximBuild::conf{build_root}
 167 #      and ((stat $EximBuild::conf{build_root})[2] & 0775) != 0775;
 168
 169
 170 # get the config data into some local variables
 171 my (
 172     $buildroot,$target,$animal, $print_success,
 173     $aux_path,$trigger_exclude,$trigger_include,$secret,
 174     $keep_errs,$force_every, $make, $optional_steps,
 175     $use_vpath,$tar_log_cmd, $using_msvc, $extra_config,
 176     $make_jobs, $core_file_glob
 177   )
 178   =@EximBuild::conf{
 179     qw(build_root target animal print_success aux_path trigger_exclude
 180       trigger_include secret keep_error_builds force_every make optional_steps
 181       use_vpath tar_log_cmd using_msvc extra_config make_jobs core_file_glob)
 182   };
 183
 184 #default is no parallel build
 185 $make_jobs ||= 1;
 186
 187 # default core file pattern is Linux, which used to be hardcoded
 188 $core_file_glob ||= 'core*';
 189
 190 # legacy name
 191 if (defined($EximBuild::conf{trigger_filter}))
 192 {
 193     $trigger_exclude = $EximBuild::conf{trigger_filter};
 194 }
 195
 196 my  $scm_timeout_secs = $EximBuild::conf{scm_timeout_secs}
 197   || $EximBuild::conf{cvs_timeout_secs};
 198
 199 print scalar(localtime()),": buildfarm run for $animal:$branch starting\n"
 200   if $verbose;
 201
 202 # Allow commandline overrides of conf variables
 203 foreach my $arg ( @{$EximBuild::Options::overrides} )
 204 {
 205   if (my ($key,$val) = split '=', $arg)
 206   {
 207     $EximBuild::conf{$key} = $val;
 208     printf "Commandline override: '$key' = '%s'\n", $EximBuild::conf{$key}
 209       if $verbose;
 210   }
 211 }
 212
 213 if (ref($force_every) eq 'HASH')
 214 {
 215     $force_every = $force_every->{$branch} || $force_every->{default};
 216 }
 217
 218 my $scm = new EximBuild::SCM \%EximBuild::conf;
 219
 220 my $buildport;
 221
 222 if (exists $EximBuild::conf{base_port})
 223 {
 224     $buildport = $EximBuild::conf{base_port};
 225     if ($branch =~ /REL(\d+)_(\d+)/)
 226     {
 227         $buildport += (10 * ($1 - 7)) + $2;
 228     }
 229 }
 230 else
 231 {
 232
 233     # support for legacy config style
 234     $buildport = $EximBuild::conf{branch_ports}->{$branch} || 5999;
 235 }
 236
 237 $ENV{EXTRA_REGRESS_OPTS} = "--port=$buildport";
 238
 239 $tar_log_cmd ||= "tar -z -cf runlogs.tgz *.log";
 240
 241 my $logdirname = "lastrun-logs";
 242
 243 if ($from_source || $from_source_clean)
 244 {
 245     $from_source ||= $from_source_clean;
 246     die "sourceroot $from_source not absolute"
 247       unless $from_source =~ m!^/!;
 248
 249     # we need to know where the lock should go, so unless the path
 250     # contains HEAD we require it to be specified.
 251     die "must specify branch explicitly with from_source"
 252       unless ($explicit_branch || $from_source =~ m!/HEAD/!);
 253     $verbose ||= 1;
 254     $nosend=1;
 255     $nostatus=1;
 256     $use_vpath = undef;
 257     $logdirname = "fromsource-logs";
 258 }
 259
 260 my @locales;
 261 if ($branch eq 'HEAD' || $branch ge 'REL8_4')
 262 {
 263
 264     # non-C locales are not regression-safe before 8.4
 265     @locales = @{$EximBuild::conf{locales}} if exists $EximBuild::conf{locales};
 266 }
 267 unshift(@locales,'C') unless grep {$_ eq "C"} @locales;
 268
 269 # sanity checks
 270 # several people have run into these
 271
 272 if ( `uname -s 2>&1 ` =~ /CYGWIN/i )
 273 {
 274     my @procs = `ps -ef`;
 275     die "cygserver not running" unless(grep {/cygserver/} @procs);
 276 }
 277 my $ccachedir;
 278 if ( $ccachedir = $EximBuild::conf{build_env}->{CCACHE_DIR} )
 279 {
 280
 281     # ccache is smart enough to create what you tell it is the cache dir, but
 282     # not smart enough to build the whole path. mkpath croaks on error, so
 283     # we just let it.
 284
 285     mkpath $ccachedir;
 286     $ccachedir = abs_path($ccachedir);
 287 }
 288
 289 if ($^V lt v5.8.0)
 290 {
 291     die "no aux_path in config file" unless $aux_path;
 292 }
 293
 294 die "cannot run as root/Administrator" unless ($using_msvc or $> > 0);
 295
 296 my $devnull = $using_msvc ? "nul" : "/dev/null";
 297
 298 if (!$from_source)
 299 {
 300     $scm->check_access($using_msvc);
 301 }
 302
 303 my $st_prefix = "$animal.";
 304
 305 my $exim = $from_source  || $scm->get_build_path($use_vpath);
 306
 307 # set environment from config
 308 while (my ($envkey,$envval) = each %{$EximBuild::conf{build_env}})
 309 {
 310     $ENV{$envkey}=$envval;
 311 }
 312
 313 # change to buildroot for this branch or die
 314 die "no buildroot" unless $buildroot;
 315
 316 unless ($buildroot =~ m!^/!
 317     or($using_msvc and $buildroot =~ m![a-z]:[/\\]!i ))
 318 {
 319     die "buildroot $buildroot not absolute";
 320 }
 321
 322 die "$buildroot does not exist or is not a directory" unless -d $buildroot;
 323
 324 chdir $buildroot || die "chdir to $buildroot: $!";
 325
 326 mkdir $branch unless -d $branch;
 327 chdir $branch || die "chdir to $buildroot/$branch";
 328
 329 # rename legacy status files/directories
 330 foreach my $oldfile (glob("last*"))
 331 {
 332     move $oldfile, "$st_prefix$oldfile";
 333 }
 334
 335 my $branch_root = getcwd();
 336
 337 # Normally we would require GNU Make, but allow farm
 338 # configuration to override this
 339 die "$make is not GNU Make - please fix config file"
 340   unless check_make();
 341
 342 # set up modules
 343 foreach my $module (@{$EximBuild::conf{modules}})
 344 {
 345
 346     # fill in the name of the module here, so use double quotes
 347     # so everything BUT the module name needs to be escaped
 348     my $str = qq!
 349          require EximBuild::Modules::$module;
 350          EximBuild::Modules::${module}::setup(
 351               \$buildroot,
 352               \$branch,
 353               \\\%EximBuild::conf,
 354               \$exim);
 355     !;
 356     eval $str;
 357
 358     # make errors fatal
 359     die $@ if $@;
 360 }
 361
 362 # acquire the lock
 363
 364 my $lockfile;
 365 my $have_lock;
 366
 367 open($lockfile, ">builder.LCK") || die "opening lockfile: $!";
 368
 369 # only one builder at a time allowed per branch
 370 # having another build running is not a failure, and so we do not output
 371 # a failure message under this condition.
 372 if ($from_source)
 373 {
 374     die "acquiring lock in $buildroot/$branch/builder.LCK"
 375       unless flock($lockfile,LOCK_EX|LOCK_NB);
 376 }
 377 elsif ( !flock($lockfile,LOCK_EX|LOCK_NB) )
 378 {
 379     print "Another process holds the lock on "
 380       ."$buildroot/$branch/builder.LCK. Exiting."
 381       if ($verbose);
 382     exit(0);
 383 }
 384
 385 die "$buildroot/$branch has $exim or inst directories!"
 386   if ((!$from_source && -d $exim) || -d "inst");
 387
 388 # we are OK to run if we get here
 389 $have_lock = 1;
 390
 391 # check if file present for forced run
 392 my $forcefile = $st_prefix . "force-one-run";
 393 if (-e $forcefile)
 394 {
 395     $forcerun = 1;
 396     unlink $forcefile;
 397 }
 398
 399 # try to allow core files to be produced.
 400 # another way would be for the calling environment
 401 # to call ulimit. We do this in an eval so failure is
 402 # not fatal.
 403 eval{
 404     require BSD::Resource;
 405     BSD::Resource->import();
 406
 407     # explicit sub calls here. using & keeps compiler happy
 408     my $coreok = setrlimit(&RLIMIT_CORE,&RLIM_INFINITY,&RLIM_INFINITY);
 409     die "setrlimit" unless $coreok;
 410 };
 411 warn "failed to unlimit core size: $@" if $@ && $verbose > 1;
 412
 413 # the time we take the snapshot
 414 my $now=time;
 415 my $installdir = "$buildroot/$branch/inst";
 416 my $dbstarted;
 417
 418 my $extraconf;
 419
 420 # cleanup handler for all exits
 421 END
 422 {
 423
 424     # clean up temp file
 425     unlink $ENV{TEMP_CONFIG} if $extraconf;
 426
 427     # if we have the lock we must already be in the build root, so
 428     # removing things there should be safe.
 429     # there should only be anything to cleanup if we didn't have
 430     # success.
 431     if ( $have_lock && -d "$exim")
 432     {
 433         if ($dbstarted)
 434         {
 435             chdir $installdir;
 436             system(qq{"bin/pg_ctl" -D data stop >$devnull 2>&1});
 437             foreach my $loc (@locales)
 438             {
 439                 next unless -d "data-$loc";
 440                 system(qq{"bin/pg_ctl" -D "data-$loc" stop >$devnull 2>&1});
 441             }
 442             chdir $branch_root;
 443         }
 444         if ( !$from_source && $keep_errs)
 445         {
 446             print "moving kept error trees\n" if $verbose;
 447             my $timestr = strftime "%Y-%m-%d_%H-%M-%S", localtime($now);
 448             unless (move("$exim", "eximkeep.$timestr"))
 449             {
 450                 print "error renaming '$exim' to 'eximkeep.$timestr': $!";
 451             }
 452             if (-d "inst")
 453             {
 454                 unless(move("inst", "instkeep.$timestr"))
 455                 {
 456                     print "error renaming 'inst' to 'instkeep.$timestr': $!";
 457                 }
 458             }
 459         }
 460         else
 461         {
 462             rmtree("inst") unless $keepall;
 463             rmtree("$exim") unless ($from_source || $keepall);
 464         }
 465
 466         # only keep the cache in cases of success
 467         rmtree("$ccachedir") if $ccachedir;
 468     }
 469
 470     # get the modules to clean up after themselves
 471     process_module_hooks('cleanup');
 472
 473     if ($have_lock)
 474     {
 475         if ($use_vpath)
 476         {
 477
 478             # vpath builds leave some stuff lying around in the
 479             # source dir, unfortunately. This should clean it up.
 480             $scm->cleanup();
 481         }
 482         close($lockfile);
 483         unlink("builder.LCK");
 484     }
 485 }
 486
 487 # Prepend the DEFAULT settings (if any) to any settings for the
 488 # branch. Since we're mangling this, deep clone $extra_config
 489 # so the config object is kept as given. This is done using
 490 # Dumper() because the MSys DTK perl doesn't have Storable. This
 491 # is less efficient but it hardly matters here for this shallow
 492 # structure.
 493
 494 $extra_config = eval Dumper($extra_config);
 495
 496 if ($extra_config &&  $extra_config->{DEFAULT})
 497 {
 498     if (!exists  $extra_config->{$branch})
 499     {
 500         $extra_config->{$branch} =      $extra_config->{DEFAULT};
 501     }
 502     else
 503     {
 504         unshift(@{$extra_config->{$branch}}, @{$extra_config->{DEFAULT}});
 505     }
 506 }
 507
 508 if ($extra_config && $extra_config->{$branch})
 509 {
 510     my $tmpname;
 511     ($extraconf,$tmpname) =File::Temp::tempfile(
 512         'buildfarm-XXXXXX',
 513         DIR => File::Spec->tmpdir(),
 514         UNLINK => 1
 515     );
 516     die 'no $tmpname!' unless $tmpname;
 517     $ENV{TEMP_CONFIG} = $tmpname;
 518     foreach my $line (@{$extra_config->{$branch}})
 519     {
 520         print $extraconf "$line\n";
 521     }
 522     autoflush $extraconf 1;
 523 }
 524
 525 use vars qw($steps_completed);
 526 $steps_completed = "";
 527
 528 my @changed_files;
 529 my @changed_since_success;
 530 my $last_config;
 531 my $last_status;
 532 my $last_run_snap;
 533 my $last_success_snap;
 534 my $current_config;
 535 my $current_snap;
 536 my @filtered_files;
 537 my $savescmlog = "";
 538
 539 if ($from_source_clean)
 540 {
 541     print time_str(),"cleaning source in $exim ...\n";
 542     clean_from_source();
 543 }
 544 elsif (!$from_source)
 545 {
 546
 547     # see if we need to run the tests (i.e. if either something has changed or
 548     # we have gone over the force_every heartbeat time)
 549
 550     print time_str(),"checking out source ...\n" if $verbose;
 551
 552     my $timeout_pid;
 553
 554     $timeout_pid = spawn(\&scm_timeout,$scm_timeout_secs)
 555       if $scm_timeout_secs;
 556
 557     $savescmlog = $scm->checkout($branch);
 558     $steps_completed = "SCM-checkout";
 559
 560     process_module_hooks('checkout',$savescmlog);
 561
 562     if ($timeout_pid)
 563     {
 564
 565         # don't kill me, I finished in time
 566         if (kill(SIGTERM, $timeout_pid))
 567         {
 568
 569             # reap the zombie
 570             waitpid($timeout_pid,0);
 571         }
 572     }
 573
 574     print time_str(),"checking if build run needed ...\n" if $verbose;
 575
 576     # transition to new time processing
 577     unlink "last.success";
 578
 579     # get the timestamp data
 580     $last_config = find_last('config') || 0;
 581     $last_status = find_last('status') || 0;
 582     $last_run_snap = find_last('run.snap');
 583     $last_success_snap = find_last('success.snap');
 584     $forcerun = 1 unless (defined($last_run_snap));
 585
 586     # If config file changed, force a rebuild
 587     ($current_config) = (stat $orig_dir.'/'.$buildconf)[9];
 588     if (defined $current_config && $current_config > $last_config)
 589     {
 590       $last_status = 0;
 591       set_last('config',$current_config) unless $nostatus;
 592     }
 593
 594     # updated by find_changed to last mtime of any file in the repo
 595     $current_snap=0;
 596
 597     # see if we need to force a build
 598     $last_status = 0
 599       if ( $last_status
 600         && $force_every
 601         &&$last_status+($force_every*3600) < $now);
 602     $last_status = 0 if $forcerun;
 603
 604     # see what's changed since the last time we did work
 605     $scm->find_changed(\$current_snap,$last_run_snap, $last_success_snap,
 606         \@changed_files,\@changed_since_success);
 607
 608     #ignore changes to files specified by the trigger exclude filter, if any
 609     if (defined($trigger_exclude))
 610     {
 611         @filtered_files = grep { !m[$trigger_exclude] } @changed_files;
 612     }
 613     else
 614     {
 615         @filtered_files = @changed_files;
 616     }
 617
 618     #ignore changes to files NOT specified by the trigger include filter, if any
 619     if (defined($trigger_include))
 620     {
 621         @filtered_files = grep { m[$trigger_include] } @filtered_files;
 622     }
 623
 624     my $modules_need_run;
 625
 626     process_module_hooks('need-run',\$modules_need_run);
 627
 628     # if no build required do nothing
 629     if ($last_status && !@filtered_files && !$modules_need_run)
 630     {
 631         print time_str(),
 632           "No build required: last status = ",scalar(gmtime($last_status)),
 633           " GMT, current snapshot = ",scalar(gmtime($current_snap))," GMT,",
 634           " changed files = ",scalar(@filtered_files),"\n"
 635           if $verbose;
 636         rmtree("$exim");
 637         exit 0;
 638     }
 639
 640     # get version info on both changed files sets
 641     # XXX modules support?
 642
 643     $scm->get_versions(\@changed_files);
 644     $scm->get_versions(\@changed_since_success);
 645
 646 } # end of unless ($from_source)
 647
 648 cleanlogs();
 649
 650 writelog('SCM-checkout',$savescmlog) unless $from_source;
 651 $scm->log_id() unless $from_source;
 652
 653 # copy/create according to vpath/scm settings
 654
 655 if ($use_vpath)
 656 {
 657     print time_str(),"creating vpath build dir $exim ...\n" if $verbose;
 658     mkdir $exim || die "making $exim: $!";
 659 }
 660 elsif (!$from_source && $scm->copy_source_required())
 661 {
 662     print time_str(),"copying source to $exim ...\n" if $verbose;
 663
 664     $scm->copy_source($using_msvc);
 665 }
 666
 667 process_module_hooks('setup-target');
 668
 669 # start working
 670
 671 set_last('status',$now) unless $nostatus;
 672 set_last('run.snap',$current_snap) unless $nostatus;
 673
 674 my $started_times = 0;
 675 print time_str(),"running configure ...\n" if $verbose;
 676
 677 # each of these routines will call send_result, which calls exit,
 678 # on any error, so each step depends on success in the previous
 679 # steps.
 680 configure();
 681
 682 make();
 683
 684 display_features();
 685
 686 make_test() if (check_optional_step('test'));
 687
 688 make_doc() if (check_optional_step('make-doc'));
 689
 690 ##check_port_is_ok($buildport,'Post');
 691
 692 # if we get here everything went fine ...
 693
 694 my $saved_config = get_config_summary();
 695
 696 rmtree("inst"); # only keep failures
 697 rmtree("$exim") unless ($from_source || $keepall);
 698
 699 print(time_str(),"OK\n") if $verbose;
 700
 701 send_result("OK");
 702
 703 exit;
 704
 705 ############## end of main program ###########################
 706
 707 sub print_help
 708 {
 709     print qq!
 710 usage: $0 [options] [branch]
 711
 712  where options are one or more of:
 713
 714   --nosend                  = don't send results
 715   --nostatus                = don't set status files
 716   --force                   = force a build run (ignore status files)
 717   --from-source=/path       = use source in path, not from SCM
 718   or
 719   --from-source-clean=/path = same as --from-source, run make distclean first
 720   --config=/path/to/file    = alternative location for config file
 721   --keepall                 = keep directories if an error occurs
 722   --verbose[=n]             = verbosity (default 1) 2 or more = huge output.
 723   --quiet                   = suppress normal error message
 724   --test                    = short for --nosend --nostatus --verbose --force
 725   --skip-steps=list         = skip certain steps
 726   --only-steps=list         = only do certain steps, not allowed with skip-steps
 727                               lists can be comma, colon, or space separated
 728
 729 Default branch is HEAD. Usually only the --config option should be necessary.
 730
 731 !;
 732     exit(0);
 733 }
 734
 735 sub time_str
 736 {
 737     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
 738     return sprintf("[%.2d:%.2d:%.2d] ",$hour, $min, $sec);
 739 }
 740
 741 sub step_wanted
 742 {
 743     my $step = shift;
 744     return $only_steps{$step} if $only_steps;
 745     return !$skip_steps{$step} if $skip_steps;
 746     return 1; # default is everything is wanted
 747 }
 748
 749 sub register_module_hooks
 750 {
 751     my $who = shift;
 752     my $what = shift;
 753     while (my ($hook,$func) = each %$what)
 754     {
 755         $module_hooks{$hook} ||= [];
 756         push(@{$module_hooks{$hook}},[$func,$who]);
 757     }
 758 }
 759
 760 sub process_module_hooks
 761 {
 762     my $hook = shift;
 763
 764     # pass remaining args (if any) to module func
 765     foreach my $module (@{$module_hooks{$hook}})
 766     {
 767         my ($func,$module_instance) = @$module;
 768         &$func($module_instance, @_);
 769     }
 770 }
 771
 772 sub check_optional_step
 773 {
 774     my $step = shift;
 775     my $oconf;
 776     my $shandle;
 777
 778     return undef unless ref($oconf = $optional_steps->{$step});
 779     if ($oconf->{branches})
 780     {
 781         return undef unless grep {$_ eq $branch} @{$oconf->{branches}};
 782     }
 783
 784     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =localtime(time);
 785     return undef if (exists $oconf->{min_hour} &&  $hour < $oconf->{min_hour});
 786     return undef if (exists $oconf->{max_hour} &&  $hour > $oconf->{max_hour});
 787     return undef if (exists $oconf->{dow}
 788         &&grep {$_ eq $wday} @{$oconf->{dow}});
 789
 790     my $last_step = $last_status = find_last("$step") || 0;
 791     ## If made it *to* these optional steps, we just run them and reset last time
 792     #return undef unless ($forcerun ||
 793     #                     time >$last_step + (3600 * $oconf->{min_hours_since}));
 794     set_last("$step") unless $nostatus;
 795
 796     return 1;
 797 }
 798
 799 sub clean_from_source
 800 {
 801     if (-e "$exim/GNUmakefile")
 802     {
 803
 804         # fixme for MSVC
 805         my @makeout = `cd $exim && $make distclean 2>&1`;
 806         my $status = $? >>8;
 807         writelog('distclean',\@makeout);
 808         print "======== distclean log ===========\n",@makeout if ($verbose > 1);
 809         send_result('distclean',$status,\@makeout) if $status;
 810     }
 811 }
 812
 813 sub interrupt_exit
 814 {
 815     my $signame = shift;
 816     print "Exiting on signal $signame\n";
 817     exit(1);
 818 }
 819
 820 sub cleanlogs
 821 {
 822     my $lrname = $st_prefix . $logdirname;
 823     rmtree("$lrname");
 824     mkdir "$lrname" || die "can't make $lrname dir: $!";
 825 }
 826
 827 sub writelog
 828 {
 829     my $stage = shift;
 830     my $loglines = shift;
 831     my $handle;
 832     my $lrname = $st_prefix . $logdirname;
 833     open($handle,">$lrname/$stage.log") || die $!;
 834     print $handle @$loglines;
 835     close($handle);
 836 }
 837
 838 sub display_features
 839 {
 840     return unless step_wanted('features');
 841     my @out = `cd $exim
 842                src/build-*/exim -C test/confs/0000 -bV `;
 843     my $status = $? >>8;
 844     writelog('features',\@out);
 845     print "======== features log ===========\n",@out if ($verbose > 1);
 846     send_result('Features',$status,\@out) if $status;
 847     $steps_completed .= " Features";
 848 }
 849
 850 sub check_make
 851 {
 852     # Allow farm member to configure non-GNU make
 853     my $non_gnu_make = $EximBuild::conf{non_gnu_make};
 854     if (!defined $non_gnu_make ||
 855         (defined $non_gnu_make && $non_gnu_make == 1)) {
 856       return 'OK';
 857     }
 858     my @out = `$make -v 2>&1`;
 859     return undef unless ($? == 0 && grep {/GNU Make/} @out);
 860     return 'OK';
 861 }
 862
 863 sub make
 864 {
 865     return unless step_wanted('make');
 866     print time_str(),"running make ...\n" if $verbose;
 867     my $make_args = join(' ',$EximBuild::conf{make_args});
 868     my (@makeout);
 869     my $make_cmd = $make;
 870     $make_cmd = "$make -j $make_jobs"
 871       if ($make_jobs > 1 && ($branch eq 'HEAD' || $branch ge 'REL9_1'));
 872     @makeout = `cd $exim/src && $make_cmd $make_args 2>&1`;
 873     my $status = $? >>8;
 874     writelog('make',\@makeout);
 875     print "======== make log ===========\n",@makeout if ($verbose > 1);
 876     send_result('Make',$status,\@makeout) if $status;
 877     $steps_completed .= " Make";
 878 }
 879
 880 sub make_doc
 881 {
 882     return unless step_wanted('make-doc');
 883     print time_str(),"running make doc ...\n" if $verbose;
 884
 885     my (@makeout);
 886     @makeout = `cd $exim/doc/doc-docbook/ && \
 887                 EXIM_VER="4.82" $make everything 2>&1`;
 888     my $status = $? >>8;
 889     writelog('make-doc',\@makeout);
 890     print "======== make doc log ===========\n",@makeout if ($verbose > 1);
 891     send_result('Doc',$status,\@makeout) if $status;
 892     $steps_completed .= " Doc";
 893 }
 894
 895 sub get_stack_trace
 896 {
 897     my $bindir = shift;
 898     my $pgdata = shift;
 899
 900     # no core = no result
 901     my @cores = glob("$pgdata/$core_file_glob");
 902     return () unless @cores;
 903
 904     # no gdb = no result
 905     system "gdb --version > $devnull 2>&1";
 906     my $status = $? >>8;
 907     return () if $status;
 908
 909     my $cmdfile = "./gdbcmd";
 910     my $handle;
 911     open($handle, ">$cmdfile");
 912     print $handle "bt\n";
 913     close($handle);
 914
 915     my @trace;
 916
 917     foreach my $core (@cores)
 918     {
 919         my @onetrace = `gdb -x $cmdfile --batch $bindir/exim $core 2>&1`;
 920         push(@trace,
 921             "\n\n================== stack trace: $core ==================\n",
 922             @onetrace);
 923     }
 924
 925     unlink $cmdfile;
 926
 927     return @trace;
 928 }
 929
 930 sub make_install_check
 931 {
 932     my $locale = shift;
 933     return unless step_wanted('install-check');
 934     print time_str(),"running make installcheck ($locale)...\n" if $verbose;
 935
 936     my @checklog;
 937     unless ($using_msvc)
 938     {
 939         @checklog = `cd $exim/src/test/regress && $make installcheck 2>&1`;
 940     }
 941     else
 942     {
 943         chdir "$exim/src/tools/msvc";
 944         @checklog = `perl vcregress.pl installcheck 2>&1`;
 945         chdir $branch_root;
 946     }
 947     my $status = $? >>8;
 948     my @logfiles =
 949       ("$exim/src/test/regress/regression.diffs","$installdir/logfile");
 950     foreach my $logfile(@logfiles)
 951     {
 952         next unless (-e $logfile );
 953         push(@checklog,"\n\n================== $logfile ==================\n");
 954         my $handle;
 955         open($handle,$logfile);
 956         while(<$handle>)
 957         {
 958             push(@checklog,$_);
 959         }
 960         close($handle);
 961     }
 962     if ($status)
 963     {
 964         my @trace =
 965           get_stack_trace("$installdir/bin","$installdir/data-$locale");
 966         push(@checklog,@trace);
 967     }
 968     writelog("install-check-$locale",\@checklog);
 969     print "======== make installcheck log ===========\n",@checklog
 970       if ($verbose > 1);
 971     send_result("InstallCheck-$locale",$status,\@checklog) if $status;
 972     $steps_completed .= " InstallCheck-$locale";
 973 }
 974
 975 sub make_isolation_check
 976 {
 977     my $locale = shift;
 978     return unless step_wanted('isolation-check');
 979     my @makeout;
 980     unless ($using_msvc)
 981     {
 982         my $cmd =
 983           "cd $exim/src/test/isolation && $make NO_LOCALE=1 installcheck";
 984         @makeout = `$cmd 2>&1`;
 985     }
 986     else
 987     {
 988         chdir "$exim/src/tools/msvc";
 989         @makeout = `perl vcregress.pl isolationcheck 2>&1`;
 990         chdir $branch_root;
 991     }
 992
 993     my $status = $? >>8;
 994
 995     # get the log files and the regression diffs
 996     my @logs = glob("$exim/src/test/isolation/log/*.log");
 997     push(@logs,"$installdir/logfile");
 998     unshift(@logs,"$exim/src/test/isolation/regression.diffs")
 999       if (-e "$exim/src/test/isolation/regression.diffs");
1000     foreach my $logfile (@logs)
1001     {
1002         push(@makeout,"\n\n================== $logfile ===================\n");
1003         my $handle;
1004         open($handle,$logfile);
1005         while(<$handle>)
1006         {
1007             push(@makeout,$_);
1008         }
1009         close($handle);
1010     }
1011     if ($status)
1012     {
1013         my @trace =
1014           get_stack_trace("$installdir/bin","$installdir/data-$locale");
1015         push(@makeout,@trace);
1016     }
1017     writelog('isolation-check',\@makeout);
1018     print "======== make isolation check logs ===========\n",@makeout
1019       if ($verbose > 1);
1020
1021     send_result('IsolationCheck',$status,\@makeout) if $status;
1022     $steps_completed .= " IsolationCheck";
1023 }
1024
1025 sub make_test
1026 {
1027     return unless step_wanted('test');
1028     print time_str(),"running make test ...\n" if $verbose;
1029     my $tests_range = $EximBuild::conf{range_num_tests} || "1 4";
1030     my @makeout;
1031     @makeout =`(cd $exim/test
1032                 autoconf && ./configure && $make )2>&1 `;
1033     my $status = $? >>8;
1034     unless($status)
1035     {
1036       my @tmp = `(WORKDIR=\$PWD
1037                   cd $exim/test
1038                   ./runtest \$WORKDIR/$exim/src/build-*/exim -CONTINUE $tests_range )2>&1`;
1039       $status = $? >>8;
1040       push @makeout, @tmp;
1041       # Prepend the failed summary log outputs for ease of reading
1042       my $fail_summary = "$exim/test/failed-summary.log";
1043       if (-f $fail_summary)
1044       {
1045         @tmp = `cat $fail_summary`;
1046         push @tmp, "\n";
1047         unshift @makeout, @tmp;
1048         unshift @makeout, "Summary of failed tests:\n";
1049       }
1050     }
1051     writelog('test',\@makeout);
1052     print "======== make test logs ===========\n",@makeout
1053       if ($verbose > 1);
1054
1055     send_result('Test',$status,\@makeout) if $status;
1056     $steps_completed .= " Test";
1057 }
1058
1059 sub make_ecpg_check
1060 {
1061     return unless step_wanted('ecpg-check');
1062     my @makeout;
1063     my $ecpg_dir = "$exim/src/interfaces/ecpg";
1064     if ($using_msvc)
1065     {
1066         chdir "$exim/src/tools/msvc";
1067         @makeout = `perl vcregress.pl ecpgcheck 2>&1`;
1068         chdir $branch_root;
1069     }
1070     else
1071     {
1072         @makeout = `cd  $ecpg_dir && $make NO_LOCALE=1 check 2>&1`;
1073     }
1074     my $status = $? >>8;
1075
1076     # get the log files and the regression diffs
1077     my @logs = glob("$ecpg_dir/test/log/*.log");
1078     unshift(@logs,"$ecpg_dir/test/regression.diffs")
1079       if (-e "$ecpg_dir/test/regression.diffs");
1080     foreach my $logfile (@logs)
1081     {
1082         push(@makeout,"\n\n================== $logfile ===================\n");
1083         my $handle;
1084         open($handle,$logfile);
1085         while(<$handle>)
1086         {
1087             push(@makeout,$_);
1088         }
1089         close($handle);
1090     }
1091     if ($status)
1092     {
1093         my $base = "$ecpg_dir/test/regress/tmp_check";
1094         my @trace =
1095           get_stack_trace("$base/install$installdir/bin",       "$base/data");
1096         push(@makeout,@trace);
1097     }
1098     writelog('ecpg-check',\@makeout);
1099     print "======== make ecpg check logs ===========\n",@makeout
1100       if ($verbose > 1);
1101
1102     send_result('ECPG-Check',$status,\@makeout) if $status;
1103     $steps_completed .= " ECPG-Check";
1104 }
1105
1106 sub configure
1107 {
1108     return unless step_wanted('configure');
1109     print time_str(),"creating configuration ...\n" if $verbose;
1110
1111     my $env = $EximBuild::conf{makefile_set};
1112     my $add = $EximBuild::conf{makefile_add};
1113     my $features = $EximBuild::conf{makefile_regex};
1114
1115     my $envstr = "";
1116     while (my ($key,$val) = each %$env)
1117     {
1118         $envstr .= "$key='$val'\n";
1119     }
1120     while (my ($key,$val) = each %$add)
1121     {
1122         $envstr .= "$key+='$val'\n";
1123     }
1124
1125     my $conf_path = "src/src/EDITME";
1126     my $local_conf = "src/Local/Makefile";
1127     my @confout = `cd $exim; mkdir -p src/Local 2>&1`;
1128     my @tmp = `cd $exim && cp $conf_path $local_conf 2>&1`;
1129     my $status = $? >> 8;
1130     push @confout, @tmp;
1131     if ($status == 0)
1132     {
1133         # First, let's display some directory permissions in case
1134         # permissions are causing problems.
1135         my @dir = split('/',`pwd`);
1136         chomp(@dir);
1137         my $count = scalar @dir;
1138         my $loop = 1;
1139         my $dirs = '';
1140         while ($loop < $count)
1141         {
1142           my $dir = "";
1143           foreach my $i (0 .. $loop)
1144           {
1145             $dir .= $dir[$i].'/';
1146           }
1147           $dirs .= " $dir";
1148           $loop++;
1149         }
1150         @tmp = `echo "Verify Directory Permissions"
1151                 ls -ld $dirs`;
1152         push @confout, @tmp;
1153         # Build the config file from the EDITME template
1154         @tmp = `cd $exim && echo '$envstr' >> $local_conf`;
1155         push @confout, @tmp;
1156         my $exim_user = $EximBuild::conf{master_exim_user} || 'exim';
1157         @tmp = `echo "Hardcoded Exim user info:"; id $exim_user
1158           cd $exim && perl -pi -e 's/^EXIM_USER=.*/EXIM_USER=$exim_user/' $local_conf`;
1159         push @confout, @tmp;
1160         my $me = `whoami`; chomp $me;
1161         @tmp = `echo "Build Farm user info:"; id $me
1162           cd $exim && perl -pi -e 's/^# CONFIGURE_OWNER=\$/CONFIGURE_OWNER=$me/' $local_conf`;
1163         push @confout, @tmp;
1164         my $testdir = `cd $exim && /bin/pwd`; chomp $testdir; $testdir .= "/test";
1165         my $trcf = "$testdir/trusted-configs";
1166         my $tecf = "$testdir/test-config";
1167         @tmp = `cd $exim && perl -pi -e "s%^# TRUSTED_CONFIG_LIST=.*%TRUSTED_CONFIG_LIST=$trcf%" $local_conf`;
1168         push @confout, @tmp;
1169         @tmp = `cd $exim && perl -pi -e 's/^# WHITELIST_D_MACROS=.*/WHITELIST_D_MACROS=DIR:EXIM_PATH:AA:ACL:ACLRCPT:ACL_MAIL:ACL_PREDATA:ACL_RCPT:AFFIX:ALLOW:ARG1:ARG2:AUTHF:AUTHS:AUTH_ID_DOMAIN:BAD:BANNER:BB:BR:BRB:CERT:COM:COMMAND_USER:CONNECTCOND:CONTROL:CREQCIP:CREQMAC:CRL:CSS:D6:DATA:DCF:DDF:DEFAULTDWC:DELAY:DETAILS:DRATELIMIT:DYNAMIC_OPTION:ELI:ERROR_DETAILS:ERT:FAKE:FALLBACK:FILTER:FILTER_PREPEND_HOME:FORBID:FORBID_SMTP_CODE:FUSER:HAI:HAP:HARDLIMIT:HEADER_LINE_MAXSIZE:HEADER_MAXSIZE:HELO_MSG:HL:HOSTS:HOSTS_AVOID_TLS:HOSTS_MAX_TRY:HVH:IFACE:IGNORE_QUOTA:INC:INSERT:IP1:IP2:LAST:LDAPSERVERS:LENCHECK:LIMIT:LIST:LOG_SELECTOR:LS:MAXNM:MESSAGE_LOGS:MSIZE:NOTDAEMON:ONCE:ONLY:OPT:OPTION:ORDER:PAH:PEX:PORT:PTBC:QDG:QOLL:QUOTA:QUOTA_FILECOUNT:QWM:RCPT_MSG:REMEMBER:REQUIRE:RETRY:RETRY1:RETRY2:RETURN:RETURN_ERROR_DETAILS:REWRITE:ROUTE_DATA:RRATELIMIT:RT:S:SELECTOR:SELF:SERVER:SERVERS:SREQCIP:SREQMAC:SRV:STD:STRICT:SUB:SUBMISSION_OPTIONS:TIMEOUTDEFER:TIMES:TRUSTED:TRYCLEAR:UL:USE_SENDER:UTF8:VALUE:WMF:X:Y/' $local_conf`;
1170         push @confout, @tmp;
1171         @tmp = `cd $exim && perl -pi -e 's/^EXIM_MONITOR=(.*)/# EXIM_MONITOR=\$1/' $local_conf`;
1172         push @confout, @tmp;
1173         for my $regex ( @$features )
1174         {
1175             @tmp = `cd $exim
1176                     perl -pi -e '$regex' $local_conf 2>&1
1177                     echo "Used regex: $regex" `;
1178             push @confout, @tmp;
1179         }
1180         # Add the final build file to the display output
1181         @tmp = `cd $exim
1182                 echo
1183                 echo "Contents of Local/Makefile:"
1184                 egrep '^[^#]' $local_conf `;
1185         push @confout, @tmp;
1186         # Build the config_opts array to send to the server
1187         chomp @tmp;
1188         my @config_opts = grep s/(?:LOOKUP_|EXPERIMENTAL_|USE_)(\S+)=.*/$1/,
1189                           @tmp;
1190         push @config_opts, grep s/^(?:EXIM_)(PERL|PYTHON)=.*/$1/,
1191                            @tmp;
1192         # OpenSSL doesn't have a specific USE flag
1193         push @config_opts, grep s/^(TLS_LIBS.*-l(ssl|crypto)).*/OPENSSL/,
1194                            @tmp;
1195         $EximBuild::conf{config_opts} = \@config_opts;
1196
1197         # Does not matter what the Exim version is, as long as it is valid.
1198         my $exim_ver = $EximBuild::conf{exim_test_version} || '4.82';
1199         `cd $exim
1200          echo 'EXIM_RELEASE_VERSION="$exim_ver"' > src/src/version.sh
1201          echo 'EXIM_VARIANT_VERSION=""' >> src/src/version.sh
1202          echo 'EXIM_COMPILE_NUMBER="0"' >> src/src/version.sh`;
1203
1204         # Create a trusted-configs list file
1205         @tmp = `cd $exim && echo "$tecf" > "$trcf"`;
1206         push @confout, @tmp;
1207     }
1208
1209     print "======== configure output ===========\n",@confout
1210       if ($verbose > 1);
1211
1212     writelog('configure',\@confout);
1213
1214     if ($status)
1215     {
1216         send_result('Configure',$status,\@confout);
1217     }
1218
1219     $steps_completed .= " Configure";
1220 }
1221
1222 sub find_last
1223 {
1224     my $which = shift;
1225     my $stname = $st_prefix . "last.$which";
1226     my $handle;
1227     open($handle,$stname) or return undef;
1228     my $time = <$handle>;
1229     close($handle);
1230     chomp $time;
1231     return $time + 0;
1232 }
1233
1234 sub set_last
1235 {
1236     my $which = shift;
1237     my $stname = $st_prefix . "last.$which";
1238     my $st_now = shift || time;
1239     my $handle;
1240     open($handle,">$stname") or die "opening $stname: $!";
1241     print $handle "$st_now\n";
1242     close($handle);
1243 }
1244
1245 sub send_result
1246 {
1247
1248     # clean up temp file
1249     $extraconf = undef;
1250
1251     my $stage = shift;
1252
1253     my $ts = $now || time;
1254     my $status=shift || 0;
1255     my $log = shift || [];
1256     print "======== log passed to send_result ===========\n",@$log
1257       if ($verbose > 1);
1258
1259     unshift(@$log,
1260         "Last file mtime in snapshot: ",
1261         scalar(gmtime($current_snap)),
1262         " GMT\n","===================================================\n")
1263       unless ($from_source || !$current_snap);
1264
1265     my $log_data = join("",@$log);
1266     my $confsum = "";
1267     my $changed_this_run = "";
1268     my $changed_since_success = "";
1269     $changed_this_run = join("!",@changed_files)
1270       if @changed_files;
1271     $changed_since_success = join("!",@changed_since_success)
1272       if ($stage ne 'OK' && @changed_since_success);
1273
1274     if ($stage eq 'OK')
1275     {
1276         $confsum= $saved_config;
1277     }
1278     elsif ($stage !~ /CVS|Git|SCM/ )
1279     {
1280         $confsum = get_config_summary();
1281     }
1282     else
1283     {
1284         $confsum = get_script_config_dump();
1285     }
1286
1287     my $savedata = Data::Dumper->Dump(
1288         [
1289             $changed_this_run, $changed_since_success, $branch, $status,$stage,
1290             $animal, $ts,$log_data, $confsum, $target, $verbose, $secret
1291         ],
1292         [
1293             qw(changed_this_run changed_since_success branch status stage
1294               animal ts log_data confsum target verbose secret)
1295         ]
1296     );
1297
1298     my $lrname = $st_prefix . $logdirname;
1299
1300     # might happen if there is a CVS failure and have never got further
1301     mkdir $lrname unless -d $lrname;
1302
1303     my $txfname = "$lrname/web-txn.data";
1304     my $txdhandle;
1305     open($txdhandle,">$txfname");
1306     print $txdhandle $savedata;
1307     close($txdhandle);
1308
1309     if ($nosend || $stage eq 'CVS' || $stage eq 'CVS-status' )
1310     {
1311         print "Branch: $branch\n";
1312         if ($stage eq 'OK')
1313         {
1314             print "All stages succeeded\n";
1315             set_last('success.snap',$current_snap) unless $nostatus;
1316             exit(0);
1317         }
1318         else
1319         {
1320             print "Stage $stage failed with status $status\n";
1321             exit(1);
1322         }
1323     }
1324
1325     if ($stage !~ /CVS|Git|SCM|Pre-run-port-check/ )
1326     {
1327
1328         my @logfiles = glob("$lrname/*.log");
1329         my %mtimes = map { $_ => (stat $_)[9] } @logfiles;
1330         @logfiles =
1331           map { basename $_ }( sort { $mtimes{$a} <=> $mtimes{$b} } @logfiles );
1332         my $logfiles = join(' ',@logfiles);
1333         $tar_log_cmd =~ s/\*\.log/$logfiles/;
1334         chdir($lrname);
1335         system("$tar_log_cmd 2>&1 ");
1336         chdir($branch_root);
1337
1338     }
1339     else
1340     {
1341
1342         # these would be from an earlier run, since we
1343         # do cleanlogs() after the cvs stage
1344         # so don't send them.
1345         unlink "$lrname/runlogs.tgz";
1346     }
1347
1348     my $txstatus;
1349
1350     # this should now only apply to older Msys installs. All others should
1351     # be running with perl >= 5.8 since that's required to build exim
1352     # anyway
1353     if (!$^V or $^V lt v5.8.0)
1354     {
1355
1356         unless (-x "$aux_path/run_web_txn.pl")
1357         {
1358             print "Could not locate $aux_path/run_web_txn.pl\n";
1359             exit(1);
1360         }
1361
1362         system("$aux_path/run_web_txn.pl $lrname");
1363         $txstatus = $? >> 8;
1364     }
1365     else
1366     {
1367         $txstatus = EximBuild::WebTxn::run_web_txn($lrname) ? 0 : 1;
1368
1369     }
1370
1371     if ($txstatus)
1372     {
1373         print "Web txn failed with status: $txstatus\n";
1374
1375         # if the web txn fails, restore the timestamps
1376         # so we try again the next time.
1377         set_last('status',$last_status) unless $nostatus;
1378         set_last('run.snap',$last_run_snap) unless $nostatus;
1379         exit($txstatus);
1380     }
1381
1382     unless ($stage eq 'OK' || $quiet)
1383     {
1384         print "BuildFarm member $animal failed on $branch stage $stage\n";
1385     }
1386
1387     #   print "Success!\n",$response->content
1388     #           if $print_success;
1389
1390     set_last('success.snap',$current_snap) if ($stage eq 'OK' && !$nostatus);
1391
1392     exit 0;
1393 }
1394
1395 sub get_config_summary
1396 {
1397     my $handle;
1398     my $config = "";
1399     # unless ($using_msvc)
1400     # {
1401     #     open($handle,"$exim/config.log") || return undef;
1402     #     my $start = undef;
1403     #     while (<$handle>)
1404     #     {
1405     #         if (!$start && /created by PostgreSQL configure/)
1406     #         {
1407     #             $start=1;
1408     #             s/It was/This file was/;
1409     #         }
1410     #         next unless $start;
1411     #         last if /Core tests/;
1412     #         next if /^\#/;
1413     #         next if /= <?unknown>?/;
1414
1415     #         # split up long configure line
1416     #         if (m!\$.*configure.*--with! && length > 70)
1417     #         {
1418     #             my $pos = index($_," ",70);
1419     #             substr($_,$pos+1,0,"\\\n        ") if ($pos > 0);
1420     #             $pos = index($_," ",140);
1421     #             substr($_,$pos+1,0,"\\\n        ") if ($pos > 0);
1422     #             $pos = index($_," ",210);
1423     #             substr($_,$pos+1,0,"\\\n        ") if ($pos > 0);
1424     #         }
1425     #         $config .= $_;
1426     #     }
1427     #     close($handle);
1428     #     $config .=
1429     #       "\n========================================================\n";
1430     # }
1431     $config .= get_script_config_dump();
1432     return $config;
1433 }
1434
1435 sub get_script_config_dump
1436 {
1437     my $conf = {
1438         %EximBuild::conf,  # shallow copy
1439         script_version => $VERSION,
1440         invocation_args => \@invocation_args,
1441         steps_completed => $steps_completed,
1442         orig_env => $orig_env,
1443     };
1444     delete $conf->{secret};
1445
1446     if ($conf->{scm} eq 'git') {
1447         chomp($conf->{farm}{revision} = `git -C $Bin describe --tags --always --dirty=+`);
1448         $conf->{farm}{cwd} = getcwd();
1449         $conf->{farm}{bindir} = $Bin;
1450     }
1451
1452     $Data::Dumper::Sortkeys = 1;
1453     return  Data::Dumper->Dump([$conf],['Script_Config']);
1454 }
1455
1456 sub scm_timeout
1457 {
1458     my $wait_time = shift;
1459     my $who_to_kill = getpgrp(0);
1460     my $sig = SIGTERM;
1461     $sig = -$sig;
1462     print "waiting $wait_time secs to time out process $who_to_kill\n"
1463       if $verbose;
1464     foreach my $sig (qw(INT TERM HUP QUIT))
1465     {
1466         $SIG{$sig}='DEFAULT';
1467     }
1468     sleep($wait_time);
1469     $SIG{TERM} = 'IGNORE'; # so we don't kill ourself, we're exiting anyway
1470     # kill the whole process group
1471     unless (kill $sig,$who_to_kill)
1472     {
1473         print "scm timeout kill failed\n";
1474     }
1475 }
1476
1477 sub spawn
1478 {
1479     my $coderef = shift;
1480     my $pid = fork;
1481     if (defined($pid) && $pid == 0)
1482     {
1483         exit &$coderef(@_);
1484     }
1485     return $pid;
1486 }
1487