recipe_modules/chromite: Use "build_type".

scripts/slave/recipe_modules/chromite/api.py

 # Copyright 2013 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.
 
 import cgi
 import re
 
 from recipe_engine import recipe_api
 
 
@@ skipping 59 matching lines @@
     if 'buildnumber' in self.m.properties:
       defaults['CBB_BUILD_NUMBER'] = int(self.m.properties['buildnumber'])
 
     buildbucket_props = self.m.buildbucket.properties
     if buildbucket_props:
       defaults['CBB_BUILDBUCKET_ID'] = buildbucket_props['build']['id']
 
     return defaults
 
   def _load_config_dump(self):
+    if self.using_old_chromite_layout or self.c.cbb.config_repo:
+      # Our method of loading the configuration from the JSON dump will not
+      # work on old Chromite layout repositories.
+      #
+      # We also don't support loading our configuration from an external config
+      # repo. If we wanted to support this in the future, we would need to
+      # check out that other config repo at the correct revision and load
+      # "config_dump.json" from its root.
+      return {}
+
     if not self._cached_config:
       config_path = self.m.path.join(self.chromite_path,
                                      'cbuildbot', 'config_dump.json')
       step_result = self.m.json.read('read chromite config', config_path,
                                      add_json_log=False)
       self._cached_config = step_result.json.output
     return self._cached_config
 
   def load_config(self, name):
     c = self._load_config_dump()
+    assert c is not None, 'Unable to load config dump'
+
     conf = c.get(name)
     if conf is None:
       return None
 
     layers = [conf]
     template = conf.get('_template')
     if template:
       layers.append(c['_templates'][template])
     default = c.get('_default')
     if default:
@@ skipping 145 matching lines @@
     master = properties['mastername']
     variant = properties.get('cbb_variant')
 
     # Set the master's base configuration.
     config_map = config_map.get(master, {})
     master_config = config_map.get('master_config')
     assert master_config, (
         "No 'master_config' configuration for '%s'" % (master,))
     self.set_config(master_config)
 
+    # If we have any specialized build type configurations for this master,
+    # load them.
+    self.c.build_type_configs = config_map.get('build_type_configs', {})
+
     # Apply any variant configurations.
+    # TODO(dnj): Deprecate variants in favor of build types once all recipes
+    # using them have moved off of them.
     if variant:
       for config_name in config_map.get('variants', {}).get(variant, ()):
         self.apply_config(config_name)
 
 
-    # If a config repo was specified, use it.
-    if 'config_repo' in properties:
-      self.c.cbb.config_repo = self.m.properties['config_repo']
+  def run_cbuildbot(self, args=[]):
+    """Performs a Chromite repository checkout, then runs cbuildbot.
 
-  def run_cbuildbot(self, args=[]):
+    Args:
+      args (list): Additional arguments to pass to `cbuildbot` invocation.
+    """
     self.checkout_chromite()
     self.run(args=args)
 
   def checkout_chromite(self):
     """Checks out the configured Chromite branch.
     """
     self.m.bot_update.ensure_checkout(
         gclient_config=self.gclient_config(),
         update_presentation=False)
 
     if self.c.chromite_branch and self.c.cbb.disable_bootstrap:
       # Chromite auto-detects which branch to build for based on its current
       # checkout. "bot_update" checks out remote branches, but Chromite requires
       # a local branch.
       #
       # Normally we'd bootstrap, but if we're disabling bootstrapping, we have
       # to checkout the local branch to let Chromite know which branch to build.
       self.m.git('checkout', self.c.chromite_branch,
           name=str('checkout chromite branch [%s]' % (self.c.chromite_branch)))
       self.m.git('pull',
           name=str('sync chromite branch [%s]' % (self.c.chromite_branch)))
     self._set_chromite_path(self.m.path['checkout'])
+
+    # If we are configured with build type configurations, we will need to load
+    # the Chromite configuration for this configuration target.
+    self._apply_build_type_config()
+
     return self.chromite_path
 
+  def _apply_build_type_config(self):
+    """Identify the "build_type" field for this config, and apply any additional
+    recipe configurations based on that value.
+
+    This is used to specialize builders based on the type of builder that they
+    are.
+
+    If no build type config is defined for this configuration's build type, or
+    if this configuration's build type could not be loaded, no additional
+    configuration will be applied.
+    """
+    if not self.c.build_type_configs:
+      # If no build type configs are defined, then there's no point doing the
+      # work of loading the configuration.
+      return
+
+    # Load our build type from the configuration JSON, if one is not already
+    # provided.
+    if not self.c.build_type:
+      assert self.c.cbb.config, 'No build configuration installed.'
+      config = self.load_config(self.c.cbb.config)
+      self.c.build_type = (config or {}).get('build_type')
+
+    # If we have a build type, and it has a configuration associated with it,
+    # apply that configuration.
+    if self.c.build_type and self.c.build_type in self.c.build_type_configs:
+      self.apply_config(self.c.build_type_configs[self.c.build_type])
+
   def run(self, args=[]):
     """Runs the configured 'cbuildbot' build.
 
     This workflow uses the registered configuration dictionary to make master-
     and builder-specific changes to the standard workflow.
 
     The specific workflow paths that are taken are also influenced by several
     build properties.
 
     TODO(dnj): When CrOS migrates away from BuildBot, replace property
@@ skipping 62 matching lines @@
       cbb_args.extend(['--master-build-id', self.c.cbb.build_id])
 
     # Add custom args, if there are any.
     cbb_args.extend(args)
 
     # Run cbuildbot.
     return self.cbuildbot(str('cbuildbot [%s]' % (self.c.cbb.config,)),
                           self.c.cbb.config,
                           args=cbb_args,
                           cwd=self.m.path['slave_build'])