Add more cbuild options, revise configs

bin/cbuildbot.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """CBuildbot is wrapper around the build process used by the pre-flight queue"""
 
 import errno
 import heapq
@@ skipping 305 matching lines @@
              url, '-b',
              '%s' % branch[-1]], cwd=buildroot, input='\n\ny\n')
   RepoSync(buildroot, retries)
 
 
 def _IncrementalCheckout(buildroot, retries=_DEFAULT_RETRIES):
   """Performs a checkout without clobbering previous checkout."""
   RepoSync(buildroot, retries)
 
 
-def _MakeChroot(buildroot):
+def _MakeChroot(buildroot, replace=False):
   """Wrapper around make_chroot."""
   cwd = os.path.join(buildroot, 'src', 'scripts')
-  RunCommand(['./make_chroot', '--fast'], cwd=cwd)
+  
+  cmd = ['./make_chroot', '--fast']
+  
+  if replace:
+    cmd.append('--replace')
+  
+  RunCommand(cmd, cwd=cwd)
 
 
 def _GetPortageEnvVar(buildroot, board, envvar):
   """Get a portage environment variable for the specified board, if any.
 
   buildroot: The root directory where the build occurs. Must be an absolute
              path.
   board: Board type that was built on this machine. E.g. x86-generic. If this
          is None, get the env var from the host.
   envvar: The environment variable to get. E.g. 'PORTAGE_BINHOST'.
@@ skipping 11 matching lines @@
   return binhost.rstrip('\n')
 
 
 def _SetupBoard(buildroot, board='x86-generic'):
   """Wrapper around setup_board."""
   cwd = os.path.join(buildroot, 'src', 'scripts')
   RunCommand(['./setup_board', '--fast', '--default', '--board=%s' % board],
              cwd=cwd, enter_chroot=True)
 
 
-def _Build(buildroot, emptytree):
+def _Build(buildroot, emptytree, build_autotest=True, usepkg=True):
   """Wrapper around build_packages."""
   cwd = os.path.join(buildroot, 'src', 'scripts')
   if emptytree:
     cmd = ['sh', '-c', 'EXTRA_BOARD_FLAGS=--emptytree ./build_packages']
   else:
     cmd = ['./build_packages']
 
+  if not build_autotest:
+    cmd.append('--nowithautotest')
+  
+  if not usepkg:
+    cmd.append('--nousepkg')
+
   RunCommand(cmd, cwd=cwd, enter_chroot=True)
 
 
 def _EnableLocalAccount(buildroot):
   cwd = os.path.join(buildroot, 'src', 'scripts')
   # Set local account for test images.
   RunCommand(['./enable_localaccount.sh',
              'chronos'],
              print_cmd=False, cwd=cwd)
 
@@ skipping 173 matching lines @@
                               'latest', image_name)
     RunCommand(['gzip', '-f', '--fast', image_path])
     RunCommand([gsutil, 'cp', image_path + '.gz', archive_dir],
                num_retries=num_gsutil_retries)
   except Exception, e:
     Warning('Could not archive test results (error=%s)' % str(e))
 
 
 def _GetConfig(config_name):
   """Gets the configuration for the build"""
-  default = config['default']
   buildconfig = {}
   if not config.has_key(config_name):
     Warning('Non-existent configuration specified.')
     Warning('Please specify one of:')
     config_names = config.keys()
     config_names.sort()
     for name in config_names:
       Warning('  %s' % name)
     sys.exit(1)
 
-  buildconfig = config[config_name]
-
-  for key in default.iterkeys():
-    if not buildconfig.has_key(key):
-      buildconfig[key] = default[key]
-
-  return buildconfig
+  return config[config_name]
 
 
 def _ResolveOverlays(buildroot, overlays):
   """Return the list of overlays to use for a given buildbot.
 
   Args:
     buildroot: The root directory where the build occurs. Must be an absolute
                path.
     overlays: A string describing which overlays you want.
               'private': Just the private overlay.
@@ skipping 47 matching lines @@
 
   RunCommand(cmd, cwd=cwd)
 
 
 def main():
   # Parse options
   usage = "usage: %prog [options] cbuildbot_config"
   parser = optparse.OptionParser(usage=usage)
   parser.add_option('-a', '--acl', default='private',
                     help='ACL to set on GSD archives')
-  parser.add_option('--archive_build', action='store_true', default=False,
-                    help='Run the archive_build script.')
   parser.add_option('-r', '--buildroot',
                     help='root directory where build occurs', default=".")
   parser.add_option('-n', '--buildnumber',
                     help='build number', type='int', default=0)
   parser.add_option('--chrome_rev', default=None, type='string',
                     dest='chrome_rev',
                     help=('Chrome_rev of type [tot|latest_release|'
                           'sticky_release]'))
   parser.add_option('-g', '--gsutil', default='', help='Location of gsutil')
   parser.add_option('-c', '--gsutil_archive', default='',
@@ skipping 64 matching lines @@
 
     new_binhost = _GetPortageEnvVar(buildroot, board, _FULL_BINHOST)
     emptytree = (old_binhost and old_binhost != new_binhost)
 
     # Check that all overlays can be found.
     for path in rev_overlays:
       if not os.path.isdir(path):
         Die('Missing overlay: %s' % path)
 
     if not os.path.isdir(chroot_path):
-      _MakeChroot(buildroot)
+      _MakeChroot(buildroot, buildconfig['chroot_replace'])
 
     if not os.path.isdir(boardpath):
       _SetupBoard(buildroot, board=buildconfig['board'])
 
     # Perform uprev.  If chrome_uprev is set, rev Chrome ebuilds.
     if options.chrome_rev:
       chrome_atom_to_build = _MarkChromeAsStable(buildroot, tracking_branch,
                                                  options.chrome_rev, board)
       # If we found nothing to rev, we're done here.
       if not chrome_atom_to_build:
         return
 
     elif buildconfig['uprev']:
       _UprevPackages(buildroot, tracking_branch, revisionfile,
                      buildconfig['board'], rev_overlays)
 
     _EnableLocalAccount(buildroot)
 
     if options.build:
-      _Build(buildroot, emptytree)
+      _Build(buildroot,
+             emptytree,
+             build_autotest=(buildconfig['vm_tests'] and options.tests),
+             usepkg=buildconfig['usepkg'])
 
       if buildconfig['unittests'] and options.tests:
         _RunUnitTests(buildroot)
 
       _BuildImage(buildroot)
 
-    if buildconfig['tests'] and options.tests:
+    if buildconfig['vm_tests'] and options.tests:
       _BuildVMImageForTesting(buildroot)
       test_results_dir = '/tmp/run_remote_tests.%s' % options.buildnumber
       try:
         _RunSmokeSuite(buildroot, test_results_dir)
         _RunAUTest(buildroot, buildconfig['board'])
       finally:
         if not options.debug:
           archive_full_path = os.path.join(options.gsutil_archive,
                                            str(options.buildnumber))
           _ArchiveTestResults(buildroot, buildconfig['board'],
@@ skipping 13 matching lines @@
           _UprevPush(buildroot, tracking_branch, buildconfig['board'],
                      push_overlays, options.debug)
         else:
           Die('CBUILDBOT - One of the slaves has failed!!!')
 
       else:
         # Publish my status to the master if its expecting it.
         if buildconfig['important'] and not options.debug:
           cbuildbot_comm.PublishStatus(cbuildbot_comm.STATUS_BUILD_COMPLETE)
 
-    if options.archive_build:
+    if buildconfig['archive_build']:
       _LegacyArchiveBuild(bot_id,
                           buildconfig,
                           options.buildnumber,
                           options.debug)
   except:
     # Send failure to master bot.
     if not buildconfig['master'] and buildconfig['important']:
       cbuildbot_comm.PublishStatus(cbuildbot_comm.STATUS_BUILD_FAILED)
 
     raise
 
 
 if __name__ == '__main__':
     main()