Selective build clobbering feature (compile.py).

scripts/slave/compile.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """A tool to build chrome, executed by buildbot.
 
   When this is run, the current directory (cwd) should be the outer build
   directory (e.g., chrome-release/build/).
 
@@ skipping 417 matching lines @@
     if (not options.solution or
         os.path.splitext(options.solution)[1] != '.xcodeproj'):
       options.solution = 'all.xcodeproj'
     command.extend(['-project', options.solution])
 
   if options.xcode_target:
     command.extend(['-target', options.xcode_target])
 
   # Note: this clobbers all targets, not just Debug or Release.
   if options.clobber:
-    build_output_dir = os.path.join(os.path.dirname(options.build_dir),
-        'xcodebuild')
-    print('Removing %s' % build_output_dir)
+    clobber_dir = os.path.dirname(options.target_output_dir)
+    print('Removing %s' % clobber_dir)
     # Deleting output_dir would also delete all the .ninja files. iOS builds
     # generates ninja configuration inside the xcodebuild directory to be able
     # to run sub builds. crbug.com/138950 is tracking this issue.
     # Moreover clobbering should run before runhooks (which creates
     # .ninja files). For now, only delete all non-.ninja files.
     # TODO(thakis): Make "clobber" a step that runs before "runhooks". Once the
     # master has been restarted, remove all clobber handling from compile.py.
-    ninja_clobber(build_output_dir)
+    ninja_clobber(clobber_dir)
 
   common_xcode_settings(command, options, env, options.compiler)
 
   # Add on any remaining args
   command.extend(args)
 
   # Set up the filter before changing directories so the raw build log can
   # be recorded.
   # Support a local file blocking filters (for debugging).  Also check the
   # Xcode version to make sure it is 3.2, as that is what the filter is coded
@@ skipping 94 matching lines @@
     print 'using', compiler
     if compiler == 'goma':
       assert options.goma_dir
       env['CC'] = 'gcc'
       env['CXX'] = 'g++'
       env['PATH'] = ':'.join([options.goma_dir, env['PATH']])
     elif compiler == 'goma-clang':
       assert options.goma_dir
       env['CC'] = 'clang'
       env['CXX'] = 'clang++'
-      clang_dir = os.path.abspath(os.path.join(
-          slave_utils.SlaveBaseDir(options.build_dir), 'build', 'src',
-          'third_party', 'llvm-build', 'Release+Asserts', 'bin'))
+      clang_dir = os.path.join(options.src_dir,
+        'third_party', 'llvm-build', 'Release+Asserts', 'bin')
       env['PATH'] = ':'.join([options.goma_dir, clang_dir, env['PATH']])
     else:  # jsonclang
       env['CC'] = os.path.join(SLAVE_SCRIPTS_DIR, 'chromium', 'jsonclang')
       env['CXX'] = os.path.join(SLAVE_SCRIPTS_DIR, 'chromium', 'jsonclang++')
       command.append('-r')
       command.append('-k')
       # 'jsonclang' assumes the clang binary is in the path.
-      clang_dir = os.path.abspath(os.path.join(
-          slave_utils.SlaveBaseDir(options.build_dir), 'build', 'src',
-          'third_party', 'llvm-build', 'Release+Asserts', 'bin'))
+      clang_dir = os.path.join(options.src_dir,
+        'third_party', 'llvm-build', 'Release+Asserts', 'bin')
       if options.goma_dir:
         env['PATH'] = ':'.join([options.goma_dir, clang_dir, env['PATH']])
       else:
         env['PATH'] = ':'.join([clang_dir, env['PATH']])
 
     command.append('CC.host=' + env['CC'])
     command.append('CXX.host=' + env['CXX'])
 
     if chromium_utils.IsMac():
       # The default process limit on 10.6 is 266 (`sysctl kern.maxprocperuid`),
       # and about 100 processes are used by the system. The webkit bindings
       # generation scripts open a preprocessor child process, so building at
       # -j100 runs into the process limit. For now, just build with -j50.
       goma_jobs = 50
       if options.clobber:
         # Disable compiles on local machine.  When the goma server-side object
         # file cache is warm, this can speed up clobber builds by up to 30%.
         env['GOMA_USE_LOCAL'] = '0'
     else:
       goma_jobs = 100
     if jobs < goma_jobs:
       jobs = goma_jobs
     command.append('-j%d' % jobs)
     return
 
   if compiler == 'clang':
-    clang_dir = os.path.abspath(os.path.join(
-        slave_utils.SlaveBaseDir(options.build_dir), 'build', 'src',
-        'third_party', 'llvm-build', 'Release+Asserts', 'bin'))
+    clang_dir = os.path.join(options.src_dir,
+        'third_party', 'llvm-build', 'Release+Asserts', 'bin')
     env['CC'] = os.path.join(clang_dir, 'clang')
     env['CXX'] = os.path.join(clang_dir, 'clang++')
     command.append('CC.host=' + env['CC'])
     command.append('CXX.host=' + env['CXX'])
     command.append('-r')
 
   if compiler == 'tsan_gcc':
     # See
     # http://dev.chromium.org/developers/how-tos/using-valgrind/threadsanitizer/gcc-tsan
     # for build instructions.
-    tsan_base = os.path.abspath(os.path.join(
-        slave_utils.SlaveBaseDir(options.build_dir), 'build', 'src',
-        'third_party', 'compiler-tsan'))
+    tsan_base = os.path.join(options.src_dir, 'third_party', 'compiler-tsan')
 
     tsan_gcc_bin = os.path.abspath(os.path.join(
         tsan_base, 'gcc-tsan', 'scripts'))
     gcctsan_gcc_dir = os.path.abspath(os.path.join(
         tsan_base, 'gcc-current'))
 
     if not os.path.isdir(gcctsan_gcc_dir):
       # Extract gcc from the tarball.
       extract_gcc_sh = os.path.abspath(os.path.join(
           tsan_base, 'extract_gcc.sh'))
       assert(os.path.exists(extract_gcc_sh))
       chromium_utils.RunCommand([extract_gcc_sh])
       assert(os.path.isdir(gcctsan_gcc_dir))
 
     env['CC'] = os.path.join(tsan_gcc_bin, 'gcc')
     env['CXX'] = os.path.join(tsan_gcc_bin, 'g++')
     env['LD'] = os.path.join(tsan_gcc_bin, 'ld')
     # GCCTSAN_GCC_DIR and GCCTSAN_GCC_VER point to the symlinks to the current
     # versions of the compiler and the instrumentation plugin created by
     # extract_gcc.sh
     env['GCCTSAN_GCC_DIR'] = gcctsan_gcc_dir
     env['GCCTSAN_GCC_VER'] = 'current'
-    env['GCCTSAN_IGNORE'] = os.path.abspath(os.path.join(
-        slave_utils.SlaveBaseDir(options.build_dir),
-        'build', 'src', 'tools', 'valgrind', 'tsan', 'ignores.txt'))
+    env['GCCTSAN_IGNORE'] = os.path.join(
+        options.src_dir, 'tools', 'valgrind', 'tsan', 'ignores.txt')
     env['GCCTSAN_ARGS'] = (
         '-DADDRESS_SANITIZER -DWTF_USE_DYNAMIC_ANNOTATIONS=1 '
         '-DWTF_USE_DYNAMIC_ANNOTATIONS_NOIMPL=1' )
     command.append('CC=' + env['CC'])
     command.append('CXX=' + env['CXX'])
     command.append('LD=' + env['LD'])
     command.append('-r')
 
   command.append('-j%d' % jobs)
 
 
 def main_make(options, args):
   """Interprets options, clobbers object files, and calls make.
   """
 
   env = EchoDict(os.environ)
   goma_ready = goma_setup(options, env)
   if not goma_ready:
     assert options.compiler not in ('goma', 'goma-clang')
     assert options.goma_dir is None
 
   options.build_dir = os.path.abspath(options.build_dir)
-  src_dir = os.path.join(slave_utils.SlaveBaseDir(options.build_dir), 'build',
-                         'src')
   # TODO(mmoss) Temporary hack to ignore the Windows --solution flag that is
   # passed to all builders. This can be taken out once the master scripts are
   # updated to only pass platform-appropriate --solution values.
   if options.solution and os.path.splitext(options.solution)[1] != '.Makefile':
     options.solution = None
 
   command = ['make']
   if options.solution:
     command.extend(['-f', options.solution])
     working_dir = options.build_dir
   else:
     # If no solution file (i.e. sub-project *.Makefile) is specified, try to
     # build from <build_dir>/Makefile, or if that doesn't exist, from
     # the top-level Makefile.
     if os.path.isfile(os.path.join(options.build_dir, 'Makefile')):
       working_dir = options.build_dir
     else:
-      working_dir = src_dir
+      working_dir = options.src_dir
 
   # Lots of test-execution scripts hard-code 'sconsbuild' as the output
   # directory.  Accomodate them.
   # TODO:  remove when build_dir is properly parameterized in tests.
   sconsbuild = os.path.join(working_dir, 'sconsbuild')
   if os.path.islink(sconsbuild):
     if os.readlink(sconsbuild) != 'out':
       os.remove(sconsbuild)
   elif os.path.exists(sconsbuild):
     dead = sconsbuild + '.dead'
@@ skipping 11 matching lines @@
 
   # V=1 prints the actual executed command
   if options.verbose:
     command.extend(['V=1'])
   command.extend(options.build_args + args)
 
   # Run the build.
   env.print_overrides()
   result = 0
 
-  def clobber(target):
-    build_output_dir = os.path.join(working_dir, 'out', target)
-    print('Removing %s' % build_output_dir)
-    chromium_utils.RemoveDirectory(build_output_dir)
+  def clobber():
+    print('Removing %s' % options.target_output_dir)
+    chromium_utils.RemoveDirectory(options.target_output_dir)
 
-  for target in options.target.split(','):
-    if options.clobber:
-      clobber(target)
+  assert ',' not in options.target, (
+   'Used to allow multiple comma-separated targets for make. This should not be'
+   ' in use any more. Asserting from orbit. It\'s the only way to be sure')

[Michael Starzinger, 2012/11/14 08:57:05]

Yes, we (the V8 waterfall) are using this feature and jkummerow@ explicitly
introduced that when we switched to the GYP build. Our builders just turned red.
I propose to revert this part of the change (didn't look at the rest).

http://build.chromium.org/p/client.v8/console

 
-    target_command = command + ['BUILDTYPE=' + target]
-    this_result = chromium_utils.RunCommand(target_command, env=env)
-    if this_result and not options.clobber:
-      clobber(target)
-    # Keep the first non-zero return code as overall result.
-    if this_result and not result:
-      result = this_result
+  if options.clobber:
+    clobber()
+
+  target_command = command + ['BUILDTYPE=' + options.target]
+  result = chromium_utils.RunCommand(target_command, env=env)
+  if result and not options.clobber:
+    clobber()
 
   goma_teardown(options, env)
 
   return result
 
 
 def main_ninja(options, args):
   """Interprets options, clobbers object files, and calls ninja."""
 
   # Prepare environment.
   env = EchoDict(os.environ)
   orig_compiler = options.compiler
   goma_ready = goma_setup(options, env)
   if not goma_ready:
     assert options.compiler not in ('goma', 'goma-clang')
     assert options.goma_dir is None
 
   # ninja is different from all the other build systems in that it requires
   # most configuration to be done at gyp time. This is why this function does
   # less than the other comparable functions in this file.
-  src_dir = os.path.join(
-      slave_utils.SlaveBaseDir(os.path.abspath(options.build_dir)),
-      'build',
-      'src')
-  print 'chdir to %s' % src_dir
-  os.chdir(src_dir)
+  print 'chdir to %s' % options.src_dir
+  os.chdir(options.src_dir)
 
-  output_dir = os.path.join('out', options.target)
-  command = ['ninja', '-C', output_dir]
+  command = ['ninja', '-C', options.target_output_dir]
 
   if options.clobber:
-    print('Removing %s' % output_dir)
+    print('Removing %s' % options.target_output_dir)
     # Deleting output_dir would also delete all the .ninja files necessary to
     # build. Clobbering should run before runhooks (which creates .ninja files).
     # For now, only delete all non-.ninja files. TODO(thakis): Make "clobber" a
     # step that runs before "runhooks". Once the master has been restarted,
     # remove all clobber handling from compile.py.
-    ninja_clobber(output_dir)
+    ninja_clobber(options.target_output_dir)
 
   if options.verbose:
     command.append('-v')
   command.extend(options.build_args)
   command.extend(args)
 
   if chromium_utils.IsMac() and options.disable_aslr:
     # Disallow dyld to randomize the load addresses of executables.
     # If any of them is compiled with ASan it will hang otherwise.
     env['DYLD_NO_PIE'] = '1'
@@ skipping 12 matching lines @@
       # under ninja -t msvc. (PATH is just ignored. Note PATH set/used
       # in compile.py doesn't include MSVC's path).
       # Hence, we'll got
       # "CreateProcess failed: The system cannot find the file specified."
       #
       # So, rewrite cc, cxx line to "$goma_dir/gomacc cl".
       #
       # Note that, on other platform, ninja doesn't use ninja -t msvc
       # (it just simply run $cc/$cxx), so modifying PATH can work to run
       # gomacc without this hack.
-      if os.path.exists(os.path.join(output_dir, 'build.ninja.orig')):
-        os.remove(os.path.join(output_dir, 'build.ninja.orig'))
-      os.rename(os.path.join(output_dir, 'build.ninja'),
-                os.path.join(output_dir, 'build.ninja.orig'))
+      manifest = os.path.join(options.target_output_dir, 'build.ninja')
+      orig_manifest = manifest + '.orig'
+      if os.path.exists(orig_manifest):
+        os.remove(orig_manifest)
+      os.rename(manifest, orig_manifest)
       cc_line_pattern = re.compile(r'(cc|cxx|cc_host|cxx_host) = (.*)')
       goma_repl = '\\1 = %s \\2' % (
           os.path.join(options.goma_dir, 'gomacc.exe').replace('\\', '\\\\'))
-      with open(os.path.join(output_dir, 'build.ninja.orig')) as orig_build:
-        with open(os.path.join(output_dir, 'build.ninja'), 'w') as new_build:
+      with open(orig_manifest) as orig_build:
+        with open(manifest, 'w') as new_build:
           for line in orig_build:
             new_build.write(cc_line_pattern.sub(goma_repl, line))
 
     # CC and CXX are set at gyp time for ninja. PATH still needs to be adjusted.
     print 'using', options.compiler
     if options.compiler == 'goma':
       env['PATH'] = os.pathsep.join([options.goma_dir, env['PATH']])
     elif options.compiler == 'goma-clang':
       clang_dir = os.path.abspath(os.path.join(
           'third_party', 'llvm-build', 'Release+Asserts', 'bin'))
@@ skipping 28 matching lines @@
 
   goma_teardown(options, env)
   return result
 
 
 def main_scons(options, args):
   """Interprets options, clobbers object files, and calls scons.
   """
   options.build_dir = os.path.abspath(options.build_dir)
   if options.clobber:
-    build_output_dir = os.path.join(os.path.dirname(options.build_dir),
-                                    'sconsbuild', options.target)
-    print('Removing %s' % build_output_dir)
-    chromium_utils.RemoveDirectory(build_output_dir)
+    print('Removing %s' % options.target_output_dir)
+    chromium_utils.RemoveDirectory(options.target_output_dir)
 
   os.chdir(options.build_dir)
 
   if sys.platform == 'win32':
     command = ['hammer.bat']
   else:
     command = ['hammer']
 
   env = EchoDict(os.environ)
   if sys.platform == 'linux2':
@@ skipping 68 matching lines @@
   else:
     tool = devenv
     if options.arch == 'x64':
       tool_options = ['/Build', '%s|x64' % options.target]
     else:
       tool_options = ['/Build', options.target]
     if options.project:
       tool_options.extend(['/Project', options.project])
 
   options.build_dir = os.path.abspath(options.build_dir)
-  build_output_dir = os.path.join(options.build_dir, options.target)
 
   def clobber():
-    print('Removing %s' % build_output_dir)
-    chromium_utils.RemoveDirectory(build_output_dir)
+    print('Removing %s' % options.target_output_dir)
+    chromium_utils.RemoveDirectory(options.target_output_dir)
 
   if options.clobber:
     clobber()
   else:
     # Remove the log file so it doesn't grow without limit,
-    chromium_utils.RemoveFile(build_output_dir, 'debug.log')
+    chromium_utils.RemoveFile(options.target_output_dir, 'debug.log')
     # Remove the chrome.dll version resource so it picks up the new svn
     # revision, unless user explicitly asked not to remove it. See
     # Bug 1064677 for more details.
     if not options.keep_version_file:
-      chromium_utils.RemoveFile(build_output_dir, 'obj', 'chrome_dll',
+      chromium_utils.RemoveFile(options.target_output_dir, 'obj', 'chrome_dll',
                                 'chrome_dll_version.rc')
 
   env = EchoDict(os.environ)
 
   # no goma support yet for this build tool.
   assert options.compiler != 'goma'
 
   if options.mode == 'google_chrome' or options.mode == 'official':
     env['CHROMIUM_BUILD'] = '_google_chrome'
 
@@ skipping 80 matching lines @@
       if known_line in line:
         errors.append(line)
         break
 
   env.print_overrides()
   result = chromium_utils.RunCommand(
       command, parser_func=scan, env=env, universal_newlines=True)
   if errors:
     print('\n\nRetrying a clobber build because of:')
     print('\n'.join(('  ' + l for l in errors)))
-    print('Removing %s' % build_output_dir)
+    print('Removing %s' % options.target_output_dir)
     for _ in range(3):
       try:
-        chromium_utils.RemoveDirectory(build_output_dir)
+        chromium_utils.RemoveDirectory(options.target_output_dir)
         break
       except OSError, e:
         print(e)
         print('\nSleeping 15 seconds. Lovely windows file locks.')
         time.sleep(15)
     else:
       print('Failed to delete a file 3 times in a row, aborting.')
       return 1
     result = chromium_utils.RunCommand(command, env=env)
 
   # TODO(maruel): As soon as the try server is restarted, replace with:
   # if result and not options.clobber and options.clobber_post_fail:
   if result and not options.clobber:
     clobber()
 
   return result
 
 
+def landmines_triggered(build_dir):
+  trigger_file = os.path.join(build_dir, '.landmines_triggered')
+  if os.path.exists(trigger_file):
+    print 'Setting clobber due to triggered landmines:'
+    with open(trigger_file) as f:
+      print f.read()
+    return True
+  return False
+
+
+def get_target_build_dir(build_tool, src_dir, target, is_iphone=False):
+  """Keep this function in sync with src/build/landmines.py"""
+  ret = None
+  if build_tool == 'xcode':
+    ret = os.path.join(src_dir, 'xcodebuild',
+        target + ('-iphoneos' if is_iphone else ''))
+  elif build_tool == 'make':
+    ret = os.path.join(src_dir, 'out', target)
+  elif build_tool == 'ninja':
+    ret = os.path.join(src_dir, 'out', target)
+  elif build_tool == 'msvs':
+    ret = os.path.join(src_dir, 'build', target)
+  elif build_tool == 'scons':
+    ret = os.path.join(src_dir, 'sconsbuild', target)
+  else:
+    raise NotImplementedError()

[Jakob Kummerow, 2012/11/14 09:12:05]

This gets hit by V8 Win builders:
http://build.chromium.org/p/client.v8/builders/V8%20Win32/builds/4630/steps/c...
We're setting --build_tool=vs as is required by the build_tool_map in line 1172
below.

+  return os.path.abspath(ret)
+
+
 def real_main():
   option_parser = optparse.OptionParser()
   option_parser.add_option('', '--clobber', action='store_true', default=False,
                            help='delete the output directory before compiling')
   option_parser.add_option('', '--clobber-post-fail', action='store_true',
                            default=False,
                            help='delete the output directory after compiling '
                                 'only if it failed. Do not affect ninja.')
   option_parser.add_option('', '--keep-version-file', action='store_true',
                            default=False,
@@ skipping 38 matching lines @@
   option_parser.add_option('', '--goma-dir',
                            default=os.path.join(BUILD_DIR, 'goma'),
                            help='specify goma directory')
   option_parser.add_option('--verbose', action='store_true')
 
   options, args = option_parser.parse_args()
 
   if options.build_tool is None:
     if chromium_utils.IsWindows():
       main = main_win
+      options.build_tool = 'msvs'
     elif chromium_utils.IsMac():
       main = main_xcode
+      options.build_tool = 'xcode'
     elif chromium_utils.IsLinux():
       main = main_make
+      options.build_tool = 'make'
     else:
       print('Please specify --build-tool.')
       return 1
   else:
     build_tool_map = {
         'ib' : main_win,
         'vs' : main_win,
         'make' : main_make,
         'ninja' : main_ninja,
         'scons' : main_scons,
         'xcode' : main_xcode,
     }
     main = build_tool_map.get(options.build_tool)
     if not main:
       sys.stderr.write('Unknown build tool %s.\n' % repr(options.build_tool))
       return 2
 
+  options.build_dir = os.path.abspath(options.build_dir)
+  options.src_dir = os.path.join(slave_utils.SlaveBaseDir(
+      os.path.abspath(options.build_dir)), 'build', 'src')
+  options.target_output_dir = get_target_build_dir(options.build_tool,
+      options.src_dir, options.target, 'iphoneos' in args)
+  options.clobber = (options.clobber or
+      landmines_triggered(options.target_output_dir))
+
   return main(options, args)
 
 
 if '__main__' == __name__:
   sys.exit(real_main())