# Copyright (c) 2012 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.

"""Configuration options for various cbuildbot builders."""

from __future__ import print_function

import copy

from chromite.cbuildbot import config_lib
from chromite.cbuildbot import constants
from chromite.lib import factory


# Set to 'True' if this is a release branch. This updates the '-release' builder
# configuration to the shape used by the release waterfall.
IS_RELEASE_BRANCH = False


def OverrideConfigForTrybot(build_config, options):
  """Apply trybot-specific configuration settings.

  Args:
    build_config: The build configuration dictionary to override.
      The dictionary is not modified.
    options: The options passed on the commandline.

  Returns:
    A build configuration dictionary with the overrides applied.
  """
  copy_config = copy.deepcopy(build_config)
  for my_config in [copy_config] + copy_config['child_configs']:
    # Force uprev. This is so patched in changes are always
    # built.
    my_config['uprev'] = True
    if my_config['internal']:
      my_config['overlays'] = constants.BOTH_OVERLAYS

    # Use the local manifest which only requires elevated access if it's really
    # needed to build.
    if not options.remote_trybot:
      my_config['manifest'] = my_config['dev_manifest']

    my_config['push_image'] = False

    if my_config['build_type'] != constants.PAYLOADS_TYPE:
      my_config['paygen'] = False

    if options.hwtest and my_config['hw_tests_override'] is not None:
      my_config['hw_tests'] = my_config['hw_tests_override']

    # Default to starting with a fresh chroot on remote trybot runs.
    if options.remote_trybot:
      my_config['chroot_replace'] = True

    # In trybots, we want to always run VM tests and all unit tests, so that
    # developers will get better testing for their changes.
    if my_config['vm_tests_override'] is not None:
      my_config['vm_tests'] = my_config['vm_tests_override']

  return copy_config


def GetDefaultWaterfall(build_config):
  if not (build_config['important'] or build_config['master']):
    return None
  if build_config['branch']:
    return None
  b_type = build_config['build_type']

  if config_lib.IsCanaryType(b_type):
    # If this is a canary build, it may fall on different waterfalls:
    # - If we're building for a release branch, it belongs on a release
    #   waterfall.
    # - Otherwise, it belongs on the internal waterfall.
    if IS_RELEASE_BRANCH:
      return constants.WATERFALL_RELEASE
    else:
      return constants.WATERFALL_INTERNAL
  elif config_lib.IsCQType(b_type):
    # A Paladin can appear on the public or internal waterfall depending on its
    # 'internal' status.
    return (constants.WATERFALL_INTERNAL if build_config['internal'] else
            constants.WATERFALL_EXTERNAL)
  elif config_lib.IsPFQType(b_type) or b_type == constants.PRE_CQ_LAUNCHER_TYPE:
    # These builder types belong on the internal waterfall.
    return constants.WATERFALL_INTERNAL
  else:
    # No default active waterfall.
    return None


class HWTestList(object):
  """Container for methods to generate HWTest lists."""

  @classmethod
  def DefaultList(cls, **kwargs):
    """Returns a default list of HWTestConfig's for a build

    Args:
      *kwargs: overrides for the configs
    """
    # Number of tests running in parallel in the AU suite.
    AU_TESTS_NUM = 2
    # Number of tests running in parallel in the asynchronous canary
    # test suite
    ASYNC_TEST_NUM = 2

    # Set the number of machines for the au and qav suites. If we are
    # constrained in the number of duts in the lab, only give 1 dut to each.
    if (kwargs.get('num', constants.HWTEST_DEFAULT_NUM) >=
        constants.HWTEST_DEFAULT_NUM):
      au_dict = dict(num=AU_TESTS_NUM)
      async_dict = dict(num=ASYNC_TEST_NUM)
    else:
      au_dict = dict(num=1)
      async_dict = dict(num=1)

    au_kwargs = kwargs.copy()
    au_kwargs.update(au_dict)

    async_kwargs = kwargs.copy()
    async_kwargs.update(async_dict)
    async_kwargs['priority'] = constants.HWTEST_POST_BUILD_PRIORITY
    async_kwargs['retry'] = False
    async_kwargs['max_retries'] = None
    async_kwargs['async'] = True
    async_kwargs['suite_min_duts'] = 1

    # BVT + AU suite.
    return [config_lib.HWTestConfig(constants.HWTEST_BVT_SUITE,
                                    blocking=True, **kwargs),
            config_lib.HWTestConfig(constants.HWTEST_AU_SUITE,
                                    blocking=True, **au_kwargs),
            config_lib.HWTestConfig(constants.HWTEST_COMMIT_SUITE,
                                    **async_kwargs),
            config_lib.HWTestConfig(constants.HWTEST_CANARY_SUITE,
                                    **async_kwargs)]

  @classmethod
  def DefaultListCanary(cls, **kwargs):
    """Returns a default list of config_lib.HWTestConfig's for a canary build.

    Args:
      *kwargs: overrides for the configs
    """
    # Set minimum_duts default to 4, which means that lab will check the
    # number of available duts to meet the minimum requirement before creating
    # the suite job for canary builds.
    kwargs.setdefault('minimum_duts', 4)
    kwargs.setdefault('file_bugs', True)
    return HWTestList.DefaultList(**kwargs)

  @classmethod
  def AFDOList(cls, **kwargs):
    """Returns a default list of HWTestConfig's for a AFDO build.

    Args:
      *kwargs: overrides for the configs
    """
    afdo_dict = dict(pool=constants.HWTEST_SUITES_POOL,
                     timeout=120 * 60, num=1, async=True, retry=False,
                     max_retries=None)
    afdo_dict.update(kwargs)
    return [config_lib.HWTestConfig('perf_v2', **afdo_dict)]

  @classmethod
  def DefaultListNonCanary(cls, **kwargs):
    """Return a default list of HWTestConfig's for a non-canary build.

    Optional arguments may be overridden in `kwargs`, except that
    the `blocking` setting cannot be provided.
    """
    return [config_lib.HWTestConfig(constants.HWTEST_BVT_SUITE, **kwargs),
            config_lib.HWTestConfig(constants.HWTEST_COMMIT_SUITE, **kwargs)]

  @classmethod
  def DefaultListCQ(cls, **kwargs):
    """Return a default list of HWTestConfig's for a CQ build.

    Optional arguments may be overridden in `kwargs`, except that
    the `blocking` setting cannot be provided.
    """
    default_dict = dict(pool=constants.HWTEST_PALADIN_POOL, timeout=120 * 60,
                        file_bugs=False, priority=constants.HWTEST_CQ_PRIORITY,
                        minimum_duts=4, offload_failures_only=True)
    # Allows kwargs overrides to default_dict for cq.
    default_dict.update(kwargs)
    return HWTestList.DefaultListNonCanary(**default_dict)

  @classmethod
  def DefaultListPFQ(cls, **kwargs):
    """Return a default list of HWTestConfig's for a PFQ build.

    Optional arguments may be overridden in `kwargs`, except that
    the `blocking` setting cannot be provided.
    """
    default_dict = dict(pool=constants.HWTEST_PFQ_POOL, file_bugs=True,
                        priority=constants.HWTEST_PFQ_PRIORITY,
                        retry=False, max_retries=None, minimum_duts=4)
    # Allows kwargs overrides to default_dict for pfq.
    default_dict.update(kwargs)
    return HWTestList.DefaultListNonCanary(**default_dict)

  @classmethod
  def SharedPoolPFQ(cls, **kwargs):
    """Return a list of HWTestConfigs for PFQ which uses a shared pool.

    The returned suites will run in pool:critical by default, which is
    shared with other types of builders (canaries, cq). The first suite in the
    list is a blocking sanity suite that verifies the build will not break dut.
    """
    sanity_dict = dict(pool=constants.HWTEST_MACH_POOL,
                       file_bugs=True, priority=constants.HWTEST_PFQ_PRIORITY,
                       retry=False, max_retries=None)
    sanity_dict.update(kwargs)
    sanity_dict.update(dict(num=1, minimum_duts=1, suite_min_duts=1,
                            blocking=True))
    default_dict = dict(pool=constants.HWTEST_MACH_POOL,
                        suite_min_duts=3)
    default_dict.update(kwargs)
    suite_list = [config_lib.HWTestConfig(constants.HWTEST_SANITY_SUITE,
                                          **sanity_dict)]
    suite_list.extend(HWTestList.DefaultListPFQ(**default_dict))
    return suite_list

  @classmethod
  def SharedPoolCQ(cls, **kwargs):
    """Return a list of HWTestConfigs for CQ which uses a shared pool.

    The returned suites will run in pool:critical by default, which is
    shared with other types of builder (canaries, pfq). The first suite in the
    list is a blocking sanity suite that verifies the build will not break dut.
    """
    sanity_dict = dict(pool=constants.HWTEST_MACH_POOL, timeout=120 * 60,
                       file_bugs=False, priority=constants.HWTEST_CQ_PRIORITY)
    sanity_dict.update(kwargs)
    sanity_dict.update(dict(num=1, minimum_duts=1, suite_min_duts=1,
                            blocking=True))
    default_dict = dict(pool=constants.HWTEST_MACH_POOL,
                        suite_min_duts=10)
    default_dict.update(kwargs)
    suite_list = [config_lib.HWTestConfig(constants.HWTEST_SANITY_SUITE,
                                          **sanity_dict)]
    suite_list.extend(HWTestList.DefaultListCQ(**default_dict))
    return suite_list

  @classmethod
  def SharedPoolCanary(cls, **kwargs):
    """Return a list of HWTestConfigs for Canary which uses a shared pool.

    The returned suites will run in pool:critical by default, which is
    shared with CQs. The first suite in the list is a blocking sanity suite
    that verifies the build will not break dut.
    """
    sanity_dict = dict(pool=constants.HWTEST_MACH_POOL, file_bugs=True)
    sanity_dict.update(kwargs)
    sanity_dict.update(dict(num=1, minimum_duts=1, suite_min_duts=1,
                            blocking=True))
    default_dict = dict(pool=constants.HWTEST_MACH_POOL,
                        suite_min_duts=6)
    default_dict.update(kwargs)
    suite_list = [config_lib.HWTestConfig(constants.HWTEST_SANITY_SUITE,
                                          **sanity_dict)]
    suite_list.extend(HWTestList.DefaultListCanary(**default_dict))
    return suite_list

  @classmethod
  def AFDORecordTest(cls, **kwargs):
    default_dict = dict(pool=constants.HWTEST_SUITES_POOL,
                        warn_only=True, num=1, file_bugs=True,
                        timeout=constants.AFDO_GENERATE_TIMEOUT)
    # Allows kwargs overrides to default_dict for cq.
    default_dict.update(kwargs)
    return config_lib.HWTestConfig(constants.HWTEST_AFDO_SUITE, **default_dict)

  @classmethod
  def WiFiCellPoolPreCQ(cls, **kwargs):
    """Return a list of HWTestConfigs which run wifi tests.

    This should be used by the ChromeOS WiFi team to ensure changes pass the
    wifi tests as a pre-cq sanity check.
    """
    default_dict = dict(pool=constants.HWTEST_WIFICELL_PRE_CQ_POOL,
                        blocking=True, file_bugs=False,
                        priority=constants.HWTEST_DEFAULT_PRIORITY,
                        retry=False, max_retries=None, minimum_duts=1)
    default_dict.update(kwargs)
    suite_list = [config_lib.HWTestConfig(constants.WIFICELL_PRE_CQ,
                                          **default_dict)]
    return suite_list

def append_useflags(useflags):
  """Used to append a set of useflags to existing useflags.

  Useflags that shadow prior use flags will cause the prior flag to be removed.
  (e.g. appending '-foo' to 'foo' will cause 'foo' to be removed)

  Usage:
    new_config = base_config.derive(useflags=append_useflags(['foo', '-bar'])

  Args:
    useflags: List of string useflags to append.
  """
  assert isinstance(useflags, (list, set))
  shadowed_useflags = {'-' + flag for flag in useflags
                       if not flag.startswith('-')}
  shadowed_useflags.update({flag[1:] for flag in useflags
                            if flag.startswith('-')})
  def handler(old_useflags):
    new_useflags = set(old_useflags or [])
    new_useflags.update(useflags)
    new_useflags.difference_update(shadowed_useflags)
    return sorted(list(new_useflags))

  return handler


TRADITIONAL_VM_TESTS_SUPPORTED = [constants.SMOKE_SUITE_TEST_TYPE,
                                  constants.SIMPLE_AU_TEST_TYPE,
                                  constants.CROS_VM_TEST_TYPE]

#
# Define assorted constants describing various sets of boards.
#

# Base per-board configuration.
# Every board must appear in exactly 1 of the following sets.

_arm_internal_release_boards = frozenset([
    'arkham',
    'beaglebone',
    'beaglebone_servo',
    'cosmos',
    'daisy',
    'daisy_skate',
    'daisy_spring',
    'daisy_winter',
    'kayle',
    'nyan',
    'nyan_big',
    'nyan_blaze',
    'nyan_freon',
    'nyan_kitty',
    'oak',
    'peach_pi',
    'peach_pit',
    'purin',
    'smaug',
    'storm',
    'rush',
    'rush_ryu',
    'veyron_brain',
    'veyron_danger',
    'veyron_gus',
    'veyron_jaq',
    'veyron_jerry',
    'veyron_mickey',
    'veyron_mighty',
    'veyron_minnie',
    'veyron_pinky',
    'veyron_rialto',
    'veyron_romy',
    'veyron_shark',
    'veyron_speedy',
    'veyron_thea',
    'whirlwind',
])

_arm_external_boards = frozenset([
    'arm-generic',
    'arm-generic_freon',
    'arm64-generic',
])

_x86_internal_release_boards = frozenset([
    'auron',
    'auron_paine',
    'auron_yuna',
    'bayleybay',
    'banjo',
    'beltino',
    'bobcat',
    'butterfly',
    'butterfly_freon',
    'candy',
    'celes',
    'cid',
    'clapper',
    'cranky',
    'cyan',
    'edgar',
    'enguarde',
    'expresso',
    'falco',
    'falco_li',
    'gandof',
    'glados',
    'glimmer',
    'gnawty',
    'guado',
    'guado_moblab',
    'heli',
    'jecht',
    'kip',
    'lakitu',
    'leon',
    'link',
    'lulu',
    'lumpy',
    'lumpy_freon',
    'mccloud',
    'monroe',
    'ninja',
    'orco',
    'panther',
    'panther_embedded',
    'panther_moblab',
    'parrot',
    'parrot_freon',
    'parrot_ivb',
    'parry',
    'peppy',
    'quawks',
    'rambi',
    'reks',
    'rikku',
    'samus',
    'setzer',
    'slippy',
    'squawks',
    'stout',
    'strago',
    'stumpy',
    'stumpy_freon',
    'stumpy_moblab',
    'sumo',
    'swanky',
    'terra',
    'tidus',
    'tricky',
    'ultima',
    'winky',
    'wizpig',
    'wolf',
    'x86-alex',
    'x86-alex_freon',
    'x86-alex_he',
    'x86-alex_he-freon',
    'x86-mario',
    'x86-mario_freon',
    'x86-zgb',
    'x86-zgb_freon',
    'x86-zgb_he',
    'x86-zgb_he-freon',
    'zako',
])

_x86_external_boards = frozenset([
    'amd64-generic',
    'amd64-generic_freon',
    'gizmo',
    'x32-generic',
    'x86-generic',
])

_mips_internal_release_boards = frozenset([
])

_mips_external_boards = frozenset([
    'mipseb-n32-generic',
    'mipseb-n64-generic',
    'mipseb-o32-generic',
    'mipsel-n32-generic',
    'mipsel-n64-generic',
    'mipsel-o32-generic',
])

# Every board should be in only 1 of the above sets.
_distinct_board_sets = [
    _arm_internal_release_boards,
    _arm_external_boards,
    _x86_internal_release_boards,
    _x86_external_boards,
    _mips_internal_release_boards,
    _mips_external_boards,
]

_arm_full_boards = (_arm_internal_release_boards |
                    _arm_external_boards)
_x86_full_boards = (_x86_internal_release_boards |
                    _x86_external_boards)
_mips_full_boards = (_mips_internal_release_boards |
                     _mips_external_boards)

_arm_boards = _arm_full_boards
_x86_boards = _x86_full_boards
_mips_boards = _mips_full_boards

_all_release_boards = (
    _arm_internal_release_boards |
    _x86_internal_release_boards |
    _mips_internal_release_boards
)
_all_full_boards = (
    _arm_full_boards |
    _x86_full_boards |
    _mips_full_boards
)
_all_boards = (
    _x86_boards |
    _arm_boards |
    _mips_boards
)

_arm_release_boards = _arm_internal_release_boards
_x86_release_boards = _x86_internal_release_boards
_mips_release_boards = _mips_internal_release_boards

_internal_boards = _all_release_boards

# Board can appear in 1 or more of the following sets.
_brillo_boards = frozenset([
    'arkham',
    'cosmos',
    'gizmo',
    'kayle',
    'lakitu',
    'panther_embedded',
    'purin',
    'storm',
    'whirlwind',
])

_moblab_boards = frozenset([
    'stumpy_moblab',
    'panther_moblab',
    'guado_moblab',
])

_minimal_profile_boards = frozenset([
    'bobcat',
])

_nofactory_boards = frozenset([
    'daisy_winter',
    'smaug',
])

_toolchains_from_source = frozenset([
    'mipseb-n32-generic',
    'mipseb-n64-generic',
    'mipseb-o32-generic',
    'mipsel-n32-generic',
    'mipsel-n64-generic',
    'x32-generic',
])

_noimagetest_boards = frozenset([
    'lakitu',
])

_nohwqual_boards = frozenset([
    'kayle',
    'lakitu',
])

_norootfs_verification_boards = frozenset([
])

_base_layout_boards = frozenset([
    'lakitu',
])

_no_unittest_boards = frozenset((
))

_upload_gce_images_boards = frozenset([
    'lakitu',
])

_no_vmtest_boards = _arm_boards | _mips_boards | _brillo_boards


# This is a list of configs that should be included on the main waterfall, but
# aren't included by default (see IsDefaultMainWaterfall). This loosely
# corresponds to the set of experimental or self-standing configs.
_waterfall_config_map = {
    constants.WATERFALL_EXTERNAL: frozenset([
        # Experimental Paladins
        'amd64-generic_freon-paladin',

        # Incremental
        'amd64-generic-incremental',
        'daisy-incremental',
        'x86-generic-incremental',

        # Full
        'amd64-generic-full',
        'arm-generic-full',
        'daisy-full',
        'mipsel-o32-generic-full',
        'oak-full',
        'x86-generic-full',

        # ASAN
        'amd64-generic-asan',
        'x86-generic-asan',

        # Utility
        'chromiumos-sdk',
        'refresh-packages',

        # LLVM
        'amd64-generic-llvm',
    ]),

    constants.WATERFALL_INTERNAL: frozenset([
        # Experimental Paladins
        'lakitu-paladin',

        # Experimental Canaries (Group)
        'glados-release-group',
        'pineview-freon-release-group',
        'rambi-d-release-group',
        'rambi-e-release-group',
        'storm-release-group',
        'strago-release-group',
        'veyron-b-release-group',
        'veyron-c-release-group',
        'veyron-d-release-group',

        # Experimental Canaries
        'bobcat-release',
        'cosmos-release',
        'daisy_winter-release',
        'kayle-release',
        'nyan_freon-release',
        'panther_moblab-release',
        'rush_ryu-release',
        'smaug-release',
        'lakitu-release',
        'guado_moblab-release',

        # Experimental PFQs.
        'tricky-chrome-pfq',

        # Incremental Builders.
        'mario-incremental',
        'lakitu-incremental',

        # Firmware Builders.
        'link-depthcharge-full-firmware',

        # Toolchain Builders.
        'internal-toolchain-major',
        'internal-toolchain-minor',
    ]),

    constants.WATERFALL_RELEASE: frozenset([
    ]),
}


@factory.CachedFunctionCall
def GetConfig():
  site_config = config_lib.SiteConfig()

  default_hw_tests_override = config_lib.BuildConfig(
      hw_tests_override=HWTestList.DefaultList(
          num=constants.HWTEST_TRYBOT_NUM, pool=constants.HWTEST_TRYBOT_POOL,
          file_bugs=False),
  )

  # Arch-specific mixins.

  # Config parameters for builders that do not run tests on the builder.
  no_unittest_builder = config_lib.BuildConfig(
      unittests=False,
  )

  no_vmtest_builder = config_lib.BuildConfig(
      vm_tests=[],
      vm_tests_override=None,
  )

  no_hwtest_builder = config_lib.BuildConfig(
      hw_tests=[],
      hw_tests_override=[],
  )

  # Builder-specific mixins

  config_lib.BuildConfig(
      # Full builds that build fully from binaries.
      build_type=constants.BUILD_FROM_SOURCE_TYPE,
      archive_build_debug=True,
      images=['test', 'factory_install'],
      git_sync=True,
  )

  full = site_config.AddTemplate(
      'full',
      default_hw_tests_override,
      # Full builds are test builds to show that we can build from scratch,
      # so use settings to build from scratch, and archive the results.
      usepkg_build_packages=False,
      chrome_sdk=True,

      build_type=constants.BUILD_FROM_SOURCE_TYPE,
      archive_build_debug=True,
      images=['base', 'recovery', 'test', 'factory_install'],
      git_sync=True,
      trybot_list=True,
      description='Full Builds',
      image_test=True,
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Continuous',
  )

  # Full builders with prebuilts.
  full_prebuilts = full.derive(
      prebuilts=constants.PUBLIC,
  )

  pfq = config_lib.BuildConfig(
      build_type=constants.PFQ_TYPE,
      important=True,
      uprev=True,
      overlays=constants.PUBLIC_OVERLAYS,
      manifest_version=True,
      trybot_list=True,
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Chrome-PFQ',
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE,
                constants.SIMPLE_AU_TEST_TYPE],
      vm_tests_override=TRADITIONAL_VM_TESTS_SUPPORTED,
  )

  paladin = site_config.AddTemplate(
      'paladin',
      default_hw_tests_override,
      chroot_replace=False,
      important=True,
      build_type=constants.PALADIN_TYPE,
      overlays=constants.PUBLIC_OVERLAYS,
      prebuilts=constants.PUBLIC,
      manifest_version=True,
      trybot_list=True,
      description='Commit Queue',
      upload_standalone_images=False,
      images=['base', 'test'],
      image_test=True,
      chrome_sdk=True,
      chrome_sdk_build_chrome=False,
      doc='http://www.chromium.org/chromium-os/build/builder-overview#TOC-CQ',

      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE],
      vm_tests_override=TRADITIONAL_VM_TESTS_SUPPORTED,
  )

  # Incremental builders are intended to test the developer workflow.
  # For that reason, they don't uprev.
  incremental = site_config.AddTemplate(
      'incremental',
      default_hw_tests_override,
      build_type=constants.INCREMENTAL_TYPE,
      chroot_replace=False,
      uprev=False,
      overlays=constants.PUBLIC_OVERLAYS,
      description='Incremental Builds',
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Continuous',
  )

  # This builds with more source available.
  internal = config_lib.BuildConfig(
      internal=True,
      overlays=constants.BOTH_OVERLAYS,
      manifest_repo_url=constants.MANIFEST_INT_URL,
  )

  brillo = config_lib.BuildConfig(
      sync_chrome=False,
      chrome_sdk=False,
      afdo_use=False,
      dev_installer_prebuilts=False,
      # TODO(gauravsh): crbug.com/356414 Start running tests on Brillo configs.
      vm_tests=[],
      hw_tests=[],
  )

  moblab = config_lib.BuildConfig(
      image_test=False,
      vm_tests=[],
  )

  beaglebone = brillo.derive(image_test=False, rootfs_verification=False)

  # This adds Chrome branding.
  official_chrome = config_lib.BuildConfig(
      useflags=[constants.USE_CHROME_INTERNAL],
  )

  # This sets chromeos_official.
  official = official_chrome.derive(
      chromeos_official=True,
  )

  _cros_sdk = site_config.AddConfigWithoutTemplate(
      'chromiumos-sdk',
      full_prebuilts,
      no_hwtest_builder,
      # The amd64-host has to be last as that is when the toolchains
      # are bundled up for inclusion in the sdk.
      boards=[
          'x86-generic', 'arm-generic', 'amd64-generic', 'mipsel-o32-generic'
      ],
      build_type=constants.CHROOT_BUILDER_TYPE,
      builder_class_name='sdk_builders.ChrootSdkBuilder',
      use_sdk=False,
      trybot_list=True,
      description='Build the SDK and all the cross-compilers',
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Continuous',
  )

  asan = site_config.AddTemplate(
      'asan',
      default_hw_tests_override,
      profile='asan',
      disk_layout='2gb-rootfs',
      # TODO(deymo): ASan builders generate bigger files, in particular a bigger
      # Chrome binary, that update_engine can't handle in delta payloads due to
      # memory limits. Remove the following lines once crbug.com/329248 is
      # fixed.
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE],
      vm_tests_override=None,
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-ASAN',
  )

  llvm = site_config.AddTemplate(
      'llvm',
      default_hw_tests_override,
      profile='llvm',
      description='Build with LLVM',
  )

  telemetry = site_config.AddTemplate(
      'telemetry',
      default_hw_tests_override,
      build_type=constants.INCREMENTAL_TYPE,
      uprev=False,
      overlays=constants.PUBLIC_OVERLAYS,
      vm_tests=[constants.TELEMETRY_SUITE_TEST_TYPE],
      description='Telemetry Builds',
  )

  chromium_pfq = site_config.AddTemplate(
      'chromium-pfq',
      default_hw_tests_override,
      build_type=constants.CHROME_PFQ_TYPE,
      important=True,
      uprev=False,
      overlays=constants.PUBLIC_OVERLAYS,
      manifest_version=True,
      chrome_rev=constants.CHROME_REV_LATEST,
      chrome_sdk=True,
      description='Preflight Chromium Uprev & Build (public)',
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE,
                constants.SIMPLE_AU_TEST_TYPE],
      vm_tests_override=None,
  )

  # TODO(davidjames): Convert this to an external config once the unified master
  # logic is ready.
  internal_chromium_pfq = internal.derive(
      chromium_pfq,
      description='Preflight Chromium Uprev & Build (internal)',
      overlays=constants.BOTH_OVERLAYS,
      prebuilts=constants.PUBLIC,
  )

  site_config.AddConfig(
      internal_chromium_pfq, 'master-chromium-pfq',
      boards=[],
      master=True,
      binhost_test=True,
      push_overlays=constants.BOTH_OVERLAYS,
      afdo_update_ebuild=True,
      chrome_sdk=False,
      health_alert_recipients=['chromeos-infra-eng@grotations.appspotmail.com',
                               'tree',
                               'chrome'],
  )

  chrome_pfq = site_config.AddTemplate(
      'chrome-pfq',
      internal_chromium_pfq,
      official,
      important=True,
      overlays=constants.BOTH_OVERLAYS,
      description='Preflight Chrome Uprev & Build (internal)',
      prebuilts=constants.PRIVATE,
  )

  chrome_try = config_lib.BuildConfig(
      build_type=constants.CHROME_PFQ_TYPE,
      chrome_rev=constants.CHROME_REV_TOT,
      use_lkgm=True,
      important=False,
      manifest_version=False,
  )

  chromium_info = site_config.AddTemplate(
      'chromium-pfq-informational',
      chromium_pfq,
      chrome_try,
      chrome_sdk=False,
      description='Informational Chromium Uprev & Build (public)',
  )

  chrome_info = site_config.AddTemplate(
      'chrome-pfq-informational',
      chromium_info,
      internal, official,
      description='Informational Chrome Uprev & Build (internal)',
  )

  chrome_perf = site_config.AddTemplate(
      'chrome-perf',
      chrome_info,
      no_unittest_builder,
      no_vmtest_builder,
      description='Chrome Performance test bot',
      hw_tests=[config_lib.HWTestConfig(
          'perf_v2', pool=constants.HWTEST_CHROME_PERF_POOL,
          timeout=90 * 60, critical=True, num=1)],
      use_chrome_lkgm=True,
      use_lkgm=False,
      useflags=append_useflags(['-cros-debug']),
  )


  # A base config for each board.
  _base_configs = dict()

  def _CreateBaseConfigs():
    for board in _all_boards:
      base = config_lib.BuildConfig()

      if board in _internal_boards:
        base.update(internal)
        base.update(official_chrome)
        base.update(manifest=constants.OFFICIAL_MANIFEST)
      if board in _brillo_boards:
        base.update(brillo)
      if board in _moblab_boards:
        base.update(moblab)
      if board in _minimal_profile_boards:
        base.update(profile='minimal')
      if board in _nofactory_boards:
        base.update(factory=False)
        base.update(factory_toolkit=False)
        base.update(factory_install_netboot=False)
      if board in _toolchains_from_source:
        base.update(usepkg_toolchain=False)
      if board in _noimagetest_boards:
        base.update(image_test=False)
      if board in _nohwqual_boards:
        base.update(hwqual=False)
      if board in _norootfs_verification_boards:
        base.update(rootfs_verification=False)
      if board in _base_layout_boards:
        base.update(disk_layout='base')
      if board in _no_unittest_boards:
        base.update(no_unittest_builder)
      if board in _no_vmtest_boards:
        base.update(no_vmtest_builder)
      if board in _upload_gce_images_boards:
        base.update(upload_gce_images=True)

      # TODO(akeshet) Eliminate or clean up this special case.
      # kayle board has a lot of kayle-specific config changes.
      if board == 'kayle':
        base.update(manifest='kayle.xml',
                    dev_manifest='kayle.xml',
                    factory_toolkit=False,
                    # TODO(namnguyen): Cannot build factory net install (no
                    # usbnet).
                    factory_install_netboot=False,
                    # TODO(namngyuyen) Cannot build dev or test images due to
                    # #436523.
                    images=['base'])

      board_config = base.derive(boards=[board])
      # Note: base configs should not specify a useflag list. Convert any
      # useflags that this base config has accrued (for instance,
      # 'chrome_internal', via official_chrome) into an append_useflags
      # callable. This is because the board base config is the last config to be
      # derived from when creating a board-specific config,
      if 'useflags' in board_config:
        board_config['useflags'] = append_useflags(board_config['useflags'])
      _base_configs[board] = board_config

  _CreateBaseConfigs()

  def _CreateConfigsForBoards(config_base, boards, name_suffix, **kwargs):
    """Create configs based on |config_base| for all boards in |boards|.

    Note: Existing configs will not be overwritten.

    Args:
      config_base: A BuildConfig instance to inherit from.
      boards: A set of boards to create configs for.
      name_suffix: A naming suffix. Configs will have names of the form
                   board-name_suffix.
      **kwargs: Additional keyword arguments to be used in AddConfig.
    """
    for board in boards:
      config_name = '%s-%s' % (board, name_suffix)
      if config_name not in site_config:
        base = config_lib.BuildConfig()
        config = site_config.AddConfig(config_base, config_name, base,
                                       _base_configs[board], **kwargs)
        if board in _nofactory_boards:
          try:
            config.get('images', []).remove('factory_install')
          except ValueError:
            pass


  _chromium_pfq_important_boards = frozenset([
      'arm-generic_freon',
      'arm-generic',
      'daisy',
      'mipsel-o32-generic',
      'x86-generic',
  ])

  def _AddFullConfigs():
    """Add x86 and arm full configs."""
    external_overrides = config_lib.BuildConfig.delete_keys(internal)
    external_overrides.update(manifest=config_lib.BuildConfig.delete_key())
    external_overrides.update(
        useflags=append_useflags(['-%s' % constants.USE_CHROME_INTERNAL]))
    _CreateConfigsForBoards(full_prebuilts, _all_full_boards,
                            config_lib.CONFIG_TYPE_FULL,
                            **external_overrides)
    _CreateConfigsForBoards(chromium_info, _all_full_boards,
                            'tot-chromium-pfq-informational', important=False,
                            **external_overrides)
    # Create important configs, then non-important configs.
    _CreateConfigsForBoards(
        internal_chromium_pfq, _chromium_pfq_important_boards,
        'chromium-pfq', **external_overrides)
    _CreateConfigsForBoards(internal_chromium_pfq, _all_full_boards,
                            'chromium-pfq', important=False,
                            **external_overrides)

  _AddFullConfigs()


  # These remaining chromium pfq configs have eccentricities that are easier to
  # create manually.

  site_config.AddConfig(
      internal_chromium_pfq, 'amd64-generic-chromium-pfq',
      _base_configs['amd64-generic'],
      disk_layout='2gb-rootfs',
  )

  site_config.AddConfig(
      internal_chromium_pfq, 'amd64-generic_freon-chromium-pfq',
      _base_configs['amd64-generic_freon'],
      disk_layout='2gb-rootfs',
      vm_tests=[],
  )

  _chrome_pfq_important_boards = frozenset([
      'peppy',
      'rush_ryu',
      'veyron_pinky',
      'x86-alex_freon',
      'nyan',
  ])


  # TODO(akeshet): Replace this with a config named x86-alex-chrome-pfq.
  site_config.AddConfig(
      chrome_pfq, 'alex-chrome-pfq',
      _base_configs['x86-alex'],
  )

  site_config.AddConfig(
      chrome_pfq, 'lumpy-chrome-pfq',
      _base_configs['lumpy'],
      afdo_generate=True,
      hw_tests=[HWTestList.AFDORecordTest()] + HWTestList.SharedPoolPFQ(),
  )

  site_config.AddConfig(
      chrome_pfq, 'daisy_skate-chrome-pfq',
      _base_configs['daisy_skate'],
      hw_tests=HWTestList.SharedPoolPFQ(),
  )

  site_config.AddConfig(
      chrome_pfq, 'falco-chrome-pfq',
      _base_configs['falco'],
      hw_tests=HWTestList.SharedPoolPFQ(),
  )

  site_config.AddConfig(
      chrome_pfq, 'peach_pit-chrome-pfq',
      _base_configs['peach_pit'],
      hw_tests=HWTestList.SharedPoolPFQ(),
  )

  site_config.AddConfig(
      chrome_pfq, 'tricky-chrome-pfq',
      _base_configs['tricky'],
      hw_tests=HWTestList.SharedPoolPFQ(),
      important=False,
  )

  _telemetry_boards = frozenset([
      'amd64-generic',
      'arm-generic',
      'x86-generic',
  ])

  _CreateConfigsForBoards(telemetry, _telemetry_boards, 'telemetry')

  _toolchain_major = site_config.AddConfigWithoutTemplate(
      'toolchain-major',
      _cros_sdk,
      latest_toolchain=True,
      prebuilts=False,
      trybot_list=False,
      gcc_githash='svn-mirror/google/main',
      description='Test next major toolchain revision',
  )

  _toolchain_minor = site_config.AddConfigWithoutTemplate(
      'toolchain-minor',
      _cros_sdk,
      latest_toolchain=True,
      prebuilts=False,
      trybot_list=False,
      gcc_githash='svn-mirror/google/gcc-4_9',
      description='Test next minor toolchain revision',
  )

  site_config.AddConfig(
      llvm,
      'amd64-generic-llvm',
      incremental,
      boards=['amd64-generic'],
      chroot_replace=True,
      description='Build with LLVM',
      trybot_list=True,
  )

  site_config.AddConfig(
      asan,
      'x86-generic-asan',
      incremental,
      boards=['x86-generic'],
      chroot_replace=True,
      description='Build with Address Sanitizer (Clang)',
      trybot_list=True,
  )

  tot_asan_info = site_config.AddTemplate(
      'tot-asan-informational',
      chromium_info,
      asan,
      description='Build TOT Chrome with Address Sanitizer (Clang)',
  )

  site_config.AddConfig(
      tot_asan_info,
      'x86-generic-tot-asan-informational',
      boards=['x86-generic'],
  )

  site_config.AddConfig(
      asan,
      'amd64-generic-asan',
      incremental,
      boards=['amd64-generic'],
      description='Build with Address Sanitizer (Clang)',
      trybot_list=True,
  )


  site_config.AddConfig(
      tot_asan_info, 'amd64-generic-tot-asan-informational',
      boards=['amd64-generic'],
  )

  incremental_beaglebone = incremental.derive(beaglebone)
  site_config.AddConfig(
      incremental_beaglebone, 'beaglebone-incremental',
      boards=['beaglebone'],
      trybot_list=True,
      description='Incremental Beaglebone Builder',
  )

  site_config.AddConfigWithoutTemplate(
      'refresh-packages',
      no_vmtest_builder,
      no_hwtest_builder,
      boards=['x86-generic', 'arm-generic'],
      builder_class_name='misc_builders.RefreshPackagesBuilder',
      description='Check upstream Gentoo for package updates',
  )

  site_config.AddConfig(
      incremental, 'x86-generic-incremental',
      _base_configs['x86-generic'],
  )

  site_config.AddConfig(
      incremental, 'daisy-incremental',
      _base_configs['daisy'],
      config_lib.BuildConfig.delete_keys(internal),
      manifest=config_lib.BuildConfig.delete_key(),
      useflags=append_useflags(['-chrome_internal']),
  )

  site_config.AddConfig(
      incremental, 'amd64-generic-incremental',
      _base_configs['amd64-generic'],
      # This builder runs on a VM, so it can't run VM tests.
      vm_tests=[],
  )

  site_config.AddConfig(
      incremental, 'x32-generic-incremental',
      _base_configs['x32-generic'],
      # This builder runs on a VM, so it can't run VM tests.
      vm_tests=[],
  )

  site_config.AddConfig(
      paladin, 'x86-generic-asan-paladin',
      _base_configs['x86-generic'],
      asan,
      description='Paladin build with Address Sanitizer (Clang)',
      important=False,
  )

  site_config.AddConfig(
      paladin, 'amd64-generic-asan-paladin',
      _base_configs['amd64-generic'],
      asan,
      description='Paladin build with Address Sanitizer (Clang)',
      important=False,
  )

  _chrome_perf_boards = frozenset([
      'daisy',
      'lumpy',
      'parrot',
  ])

  _CreateConfigsForBoards(chrome_perf, _chrome_perf_boards, 'chrome-perf',
                          trybot_list=True)


  _CreateConfigsForBoards(chromium_info,
                          ['x86-generic', 'amd64-generic'],
                          'telem-chromium-pfq-informational',
                          **telemetry.derive(chrome_try))

  #
  # Internal Builds
  #

  internal_pfq = internal.derive(
      official_chrome, pfq,
      overlays=constants.BOTH_OVERLAYS,
      prebuilts=constants.PRIVATE,
  )

  # Because branch directories may be shared amongst builders on multiple
  # branches, they must delete the chroot every time they run.
  # They also potentially need to build [new] Chrome.
  internal_pfq_branch = site_config.AddTemplate(
      'pre-flight-branch',
      internal_pfq,
      branch=True,
      trybot_list=False,
      sync_chrome=True,
      active_waterfall=constants.WATERFALL_RELEASE)

  internal_paladin = internal.derive(
      official_chrome, paladin,
      manifest=constants.OFFICIAL_MANIFEST,
      overlays=constants.BOTH_OVERLAYS,
      prebuilts=constants.PRIVATE,
      vm_tests=[],
      description=paladin['description'] + ' (internal)',
  )

  # Used for paladin builders with nowithdebug flag (a.k.a -cros-debug)
  internal_nowithdebug_paladin = internal_paladin.derive(
      useflags=append_useflags(['-cros-debug']),
      description=paladin['description'] + ' (internal, nowithdebug)',
      prebuilts=False,
  )

  _CreateConfigsForBoards(
      internal_nowithdebug_paladin,
      ['x86-generic', 'amd64-generic'],
      'nowithdebug-paladin',
      important=False,
  )

  site_config.AddConfig(
      internal_nowithdebug_paladin,
      'x86-mario-nowithdebug-paladin',
      boards=['x86-mario'])

  # Used for builders which build completely from source except Chrome.
  full_compile_paladin = paladin.derive(
      board_replace=True,
      chrome_binhost_only=True,
      chrome_sdk=False,
      cpe_export=False,
      debug_symbols=False,
      prebuilts=False,
      unittests=False,
      upload_hw_test_artifacts=False,
      vm_tests=[],
  )

  # falco is the only board that has the -clang-clean CFLAG right now,
  # so it's important that falco stays as a full-compile builder.
  # TODO(yunlian): Add -clang-clean to more boards.
  # See https://chromium-review.googlesource.com/#/c/275862/
  _CreateConfigsForBoards(
      full_compile_paladin,
      ['falco', 'nyan'],
      'full-compile-paladin',
  )

  pre_cq = site_config.AddTemplate(
      'pre-cq',
      paladin,
      build_type=constants.INCREMENTAL_TYPE,
      build_packages_in_background=True,
      pre_cq=True,
      archive=False,
      chrome_sdk=False,
      chroot_replace=True,
      debug_symbols=False,
      prebuilts=False,
      cpe_export=False,
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE],
      vm_tests_override=None,
      description='Verifies compilation, building an image, and vm/unit tests '
                  'if supported.',
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Pre-CQ',
      health_alert_recipients=['chromeos-infra-eng@grotations.appspotmail.com'],
      health_threshold=3,
  )

  # Pre-CQ targets that only check compilation and unit tests.
  unittest_only_pre_cq = pre_cq.derive(
      no_vmtest_builder,
      description='Verifies compilation and unit tests only',
      compilecheck=True,
  )

  # Pre-CQ targets that don't run VMTests.
  no_vmtest_pre_cq = site_config.AddTemplate(
      'no-vmtest-pre-cq',
      pre_cq,
      no_vmtest_builder,
      description='Verifies compilation, building an image, and unit tests '
                  'if supported.',
  )

  # Pre-CQ targets that only check compilation.
  compile_only_pre_cq = site_config.AddTemplate(
      'compile-only-pre-cq',
      unittest_only_pre_cq,
      description='Verifies compilation only',
      unittests=False,
  )

  site_config.AddConfigWithoutTemplate(
      constants.BRANCH_UTIL_CONFIG,
      internal_paladin,
      no_vmtest_builder,
      no_hwtest_builder,
      boards=[],
      # Disable postsync_patch to prevent conflicting patches from being applied
      # - e.g., patches from 'master' branch being applied to a branch.
      postsync_patch=False,
      # Disable postsync_reexec to continue running the 'master' branch chromite
      # for all stages, rather than the chromite in the branch buildroot.
      postsync_reexec=False,
      # Need to reset the paladin build_type we inherited.
      build_type=None,
      builder_class_name='release_builders.CreateBranchBuilder',
      description='Used for creating/deleting branches (TPMs only)',
  )

  # Internal incremental builders don't use official chrome because we want
  # to test the developer workflow.
  internal_incremental = internal.derive(
      incremental,
      overlays=constants.BOTH_OVERLAYS,
      description='Incremental Builds (internal)',
  )

  # A test-ap image is just a test image with a special profile enabled.
  # Note that each board enabled for test-ap use has to have the testbed-ap
  # profile linked to from its private overlay.
  _test_ap = site_config.AddTemplate(
      'test-ap',
      internal,
      default_hw_tests_override,
      description='WiFi AP images used in testing',
      profile='testbed-ap',
      vm_tests=[],
  )

  site_config.AddGroup(
      'test-ap-group',
      site_config.AddConfig(_test_ap, 'stumpy-test-ap', boards=['stumpy']),
      site_config.AddConfig(_test_ap, 'panther-test-ap', boards=['panther']),
  )

  ### Master paladin (CQ builder).

  site_config.AddConfig(
      internal_paladin, 'master-paladin',
      boards=[],
      master=True,
      binhost_test=True,
      push_overlays=constants.BOTH_OVERLAYS,
      description='Commit Queue master (all others are slaves)',

      # This name should remain synced with with the name used in
      # build_internals/masters/master.chromeos/board_config.py.
      # TODO(mtennant): Fix this.  There should be some amount of auto-
      # configuration in the board_config.py code.
      health_threshold=3,
      health_alert_recipients=['chromeos-infra-eng@grotations.appspotmail.com',
                               'tree'],
      sanity_check_slaves=['wolf-tot-paladin'],
      trybot_list=False,
  )

  ### Other paladins (CQ builders).
  # These are slaves of the master paladin by virtue of matching
  # in a few config values (e.g. 'build_type', 'branch', etc).  If
  # they are not 'important' then they are ignored slaves.
  # TODO(mtennant): This master-slave relationship should be specified
  # here in the configuration, rather than GetSlavesForMaster().
  # Something like the following:
  # master_paladin = site_config.AddConfig(internal_paladin, ...)
  # master_paladin.AddSlave(site_config.AddConfig(internal_paladin, ...))

  # Sanity check builder, part of the CQ but builds without the patches
  # under test.
  site_config.AddConfig(
      internal_paladin, 'wolf-tot-paladin',
      boards=['wolf'],
      do_not_apply_cq_patches=True,
      prebuilts=False,
      hw_tests=HWTestList.SharedPoolCQ(),
  )

  _paladin_boards = _all_boards

  # List of paladin boards where the regular paladin config is important.
  _paladin_important_boards = frozenset([
      'amd64-generic',
      'arm-generic',
      'auron',
      'beaglebone',
      'butterfly',
      'daisy',
      'daisy_skate',
      'daisy_spring',
      'nyan_freon',
      'falco',
      'gizmo',
      'kayle',
      'leon',
      'link',
      'lumpy',
      'mipsel-o32-generic',
      'monroe',
      'nyan',
      'oak',
      'panther',
      'panther_moblab',
      'parrot',
      'peach_pit',
      'peppy',
      'rambi',
      'rush_ryu',
      'samus',
      'smaug',
      'storm',
      'stout',
      'strago',
      'stumpy',
      'stumpy_moblab',
      'tricky',
      'veyron_pinky',
      'whirlwind',
      'wolf',
      'x86-alex',
      'x86-alex_freon',
      'x86-generic',
      'x86-mario',
      'x86-zgb',
  ])

  _paladin_simple_vmtest_boards = frozenset([
      'rambi',
      'x86-mario',
  ])

  _paladin_devmode_vmtest_boards = frozenset([
      'parrot',
  ])

  _paladin_cros_vmtest_boards = frozenset([
      'stout',
  ])

  _paladin_smoke_vmtest_boards = frozenset([
      'amd64-generic',
      'x86-generic',
  ])

  _paladin_default_vmtest_boards = frozenset([
      'x32-generic',
  ])

  _paladin_hwtest_boards = frozenset([
      'daisy_skate',
      'link',
      'lumpy',
      'peach_pit',
      'peppy',
      'stumpy',
      'wolf',
      'x86-alex',
      'x86-zgb',
  ])

  _paladin_moblab_hwtest_boards = frozenset([
      'stumpy_moblab',
  ])

  _paladin_chroot_replace_boards = frozenset([
      'butterfly',
      'daisy_spring',
  ])

  _paladin_separate_symbols = frozenset([
      'amd64-generic',
      'gizmo',
  ])

  def _CreatePaladinConfigs():
    for board in _paladin_boards:
      assert board in _base_configs, '%s not in _base_configs' % board
      config_name = '%s-%s' % (board, constants.PALADIN_TYPE)
      customizations = config_lib.BuildConfig()
      base_config = _base_configs[board]
      if board in _paladin_hwtest_boards:
        customizations.update(hw_tests=HWTestList.DefaultListCQ())
      if board in _paladin_moblab_hwtest_boards:
        customizations.update(
            hw_tests=[
                config_lib.HWTestConfig(
                    constants.HWTEST_MOBLAB_QUICK_SUITE,
                    blocking=True, num=1, timeout=120*60,
                    pool=constants.HWTEST_PALADIN_POOL)
            ])
      if board not in _paladin_important_boards:
        customizations.update(important=False)
      if board in _paladin_chroot_replace_boards:
        customizations.update(chroot_replace=True)
      if board in _internal_boards:
        customizations = customizations.derive(
            internal, official_chrome,
            manifest=constants.OFFICIAL_MANIFEST)
      if board in _paladin_separate_symbols:
        customizations.update(separate_debug_symbols=True)

      if board not in _paladin_default_vmtest_boards:
        vm_tests = []
        if board in _paladin_simple_vmtest_boards:
          vm_tests.append(constants.SIMPLE_AU_TEST_TYPE)
        if board in _paladin_cros_vmtest_boards:
          vm_tests.append(constants.CROS_VM_TEST_TYPE)
        if board in _paladin_devmode_vmtest_boards:
          vm_tests.append(constants.DEV_MODE_TEST_TYPE)
        if board in _paladin_smoke_vmtest_boards:
          vm_tests.append(constants.SMOKE_SUITE_TEST_TYPE)
        customizations.update(vm_tests=vm_tests)

        if paladin.vm_tests_override is not None:
          # Make sure any new tests are also in override.
          override = paladin.vm_tests_override[:]
          for test in vm_tests:
            if test not in override:
              override.append(test)

          customizations.update(vm_tests_override=override)

      if base_config.get('internal'):
        customizations.update(
            prebuilts=constants.PRIVATE,
            description=paladin['description'] + ' (internal)')
      else:
        customizations.update(prebuilts=constants.PUBLIC)
      site_config.AddConfig(
          paladin, config_name,
          customizations,
          base_config)


  _CreatePaladinConfigs()


  site_config.AddConfig(
      internal_paladin, 'lumpy-incremental-paladin',
      boards=['lumpy'],
      build_before_patching=True,
      prebuilts=False,
      compilecheck=True,
      unittests=False,
  )

  ### Paladins (CQ builders) which do not run VM or Unit tests on the builder
  ### itself.
  external_brillo_paladin = paladin.derive(brillo)

  site_config.AddConfig(
      external_brillo_paladin, 'panther_embedded-minimal-paladin',
      boards=['panther_embedded'],
      profile='minimal',
      trybot_list=True,
  )

  internal_beaglebone_paladin = internal_paladin.derive(beaglebone)

  site_config.AddConfig(
      internal_beaglebone_paladin, 'beaglebone-paladin',
      boards=['beaglebone'],
      trybot_list=True,
  )

  site_config.AddConfig(
      internal_beaglebone_paladin, 'beaglebone_servo-paladin',
      boards=['beaglebone_servo'],
      important=False,
  )


  def ShardHWTestsBetweenBuilders(*args):
    """Divide up the hardware tests between the given list of config names.

    Each of the config names must have the same hardware test suites, and the
    number of suites must be equal to the number of config names.

    Args:
      *args: A list of config names.
    """
    # List of config names.
    names = args
    # Verify sanity before sharding the HWTests.
    for name in names:
      assert len(site_config[name].hw_tests) == len(names), \
        '%s should have %d tests, but found %d' % (
            name, len(names), len(site_config[name].hw_tests))
    for name in names[1:]:
      for test1, test2 in zip(site_config[name].hw_tests,
                              site_config[names[0]].hw_tests):
        assert test1.__dict__ == test2.__dict__, \
            '%s and %s have different hw_tests configured' % (names[0], name)

    # Assign each config the Nth HWTest.
    for i, name in enumerate(names):
      site_config[name]['hw_tests'] = [site_config[name].hw_tests[i]]

  # Shard the bvt-inline and bvt-cq hw tests between similar builders.
  # The first builder gets bvt-inline, and the second builder gets bvt-cq.
  # bvt-cq takes longer, so it usually makes sense to give it the faster board.
  ShardHWTestsBetweenBuilders('x86-zgb-paladin', 'x86-alex-paladin')
  ShardHWTestsBetweenBuilders('wolf-paladin', 'peppy-paladin')
  ShardHWTestsBetweenBuilders('daisy_skate-paladin', 'peach_pit-paladin')
  ShardHWTestsBetweenBuilders('lumpy-paladin', 'stumpy-paladin')

  # Add a pre-cq config for every board.
  _CreateConfigsForBoards(pre_cq, _all_boards, 'pre-cq')
  _CreateConfigsForBoards(no_vmtest_pre_cq, _all_boards, 'no-vmtest-pre-cq')
  _CreateConfigsForBoards(
      compile_only_pre_cq, _all_boards, 'compile-only-pre-cq')

  site_config.AddConfig(
      pre_cq, constants.BINHOST_PRE_CQ,
      no_vmtest_pre_cq,
      internal,
      boards=[],
      binhost_test=True,
  )

  # TODO(davidjames): Add peach_pit, nyan, and beaglebone to pre-cq.
  # TODO(davidjames): Update daisy_spring to build images again.
  site_config.AddGroup(
      'mixed-a-pre-cq',
      # daisy_spring w/kernel 3.8.
      site_config['daisy_spring-compile-only-pre-cq'],
      # lumpy w/kernel 3.8.
      site_config['lumpy-compile-only-pre-cq'],
  )

  site_config.AddGroup(
      'mixed-b-pre-cq',
      # arm64 w/kernel 3.14.
      site_config['rush_ryu-compile-only-pre-cq'],
      # samus w/kernel 3.14.
      site_config['samus-compile-only-pre-cq'],
  )

  site_config.AddGroup(
      'mixed-c-pre-cq',
      # brillo
      site_config['storm-compile-only-pre-cq'],
  )

  site_config.AddGroup(
      'external-mixed-pre-cq',
      site_config['x86-generic-no-vmtest-pre-cq'],
      site_config['amd64-generic-no-vmtest-pre-cq'],
  )

  site_config.AddGroup(
      'kernel-3_14-a-pre-cq',
      site_config['x86-generic-no-vmtest-pre-cq'],
      site_config['arm-generic-no-vmtest-pre-cq']
  )

  site_config.AddGroup(
      'kernel-3_14-b-pre-cq',
      site_config['storm-no-vmtest-pre-cq'],
  )

  site_config.AddGroup(
      'kernel-3_14-c-pre-cq',
      site_config['veyron_pinky-no-vmtest-pre-cq'],
      site_config['rush_ryu-no-vmtest-pre-cq']
  )

  site_config.AddConfigWithoutTemplate(
      'pre-cq-launcher',
      internal_paladin,
      no_vmtest_builder,
      no_hwtest_builder,
      boards=[],
      build_type=constants.PRE_CQ_LAUNCHER_TYPE,
      description='Launcher for Pre-CQ builders',
      trybot_list=False,
      manifest_version=False,
      # Every Pre-CQ launch failure should send out an alert.
      health_threshold=1,
      health_alert_recipients=['chromeos-infra-eng@grotations.appspotmail.com',
                               'tree'],
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Pre-CQ',
  )


  site_config.AddConfig(
      internal_incremental, 'mario-incremental',
      boards=['x86-mario'],
  )

  site_config.AddConfig(
      internal_incremental, 'lakitu-incremental',
      _base_configs['lakitu'],
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE],
  )

  site_config.AddConfigWithoutTemplate(
      'internal-toolchain-major',
      _toolchain_major, internal, official,
      boards=['x86-alex', 'stumpy', 'daisy', 'lakitu'],
      build_tests=True,
      description=_toolchain_major['description'] + ' (internal)',
  )

  site_config.AddConfigWithoutTemplate(
      'internal-toolchain-minor',
      _toolchain_minor, internal, official,
      boards=['x86-alex', 'stumpy', 'daisy', 'lakitu'],
      build_tests=True,
      description=_toolchain_minor['description'] + ' (internal)',
  )

  _release = site_config.AddTemplate(
      'release',
      full,
      official,
      internal,
      default_hw_tests_override,
      build_type=constants.CANARY_TYPE,
      useflags=append_useflags(['-cros-debug']),
      build_tests=True,
      afdo_use=True,
      manifest=constants.OFFICIAL_MANIFEST,
      manifest_version=True,
      images=['base', 'recovery', 'test', 'factory_install'],
      push_image=True,
      upload_symbols=True,
      binhost_bucket='gs://chromeos-dev-installer',
      binhost_key='RELEASE_BINHOST',
      binhost_base_url='https://commondatastorage.googleapis.com/'
                       'chromeos-dev-installer',
      dev_installer_prebuilts=True,
      git_sync=False,
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE,
                constants.DEV_MODE_TEST_TYPE,
                constants.CROS_VM_TEST_TYPE],
      hw_tests=HWTestList.SharedPoolCanary(),
      paygen=True,
      signer_tests=True,
      trybot_list=True,
      hwqual=True,
      description="Release Builds (canary) (internal)",
      chrome_sdk=True,
      image_test=True,
      doc='http://www.chromium.org/chromium-os/build/builder-overview#'
          'TOC-Canaries',
  )

  _grouped_config = config_lib.BuildConfig(
      build_packages_in_background=True,
      chrome_sdk_build_chrome=False,
      unittests=None,
      vm_tests=[],
  )

  _grouped_variant_config = _grouped_config.derive(
      chrome_sdk=False,
  )

  _grouped_variant_release = _release.derive(_grouped_variant_config)

  ### Master release config.

  site_config.AddConfig(
      _release, 'master-release',
      boards=[],
      master=(not IS_RELEASE_BRANCH),
      sync_chrome=False,
      chrome_sdk=False,
      health_alert_recipients=['chromeos-infra-eng@grotations.appspotmail.com',
                               'tree'],
      afdo_use=False,
      branch_util_test=True,
  )

  ### Release config groups.

  site_config.AddGroup(
      'x86-alex-release-group',
      site_config.AddConfig(
          _release, 'x86-alex-release',
          boards=['x86-alex'],
      ),
      site_config.AddConfig(
          _grouped_variant_release, 'x86-alex_he-release',
          boards=['x86-alex_he'],
          hw_tests=[],
          upload_hw_test_artifacts=False,
          paygen_skip_testing=True,
      ),
  )

  site_config.AddGroup(
      'x86-zgb-release-group',
      site_config.AddConfig(
          _release, 'x86-zgb-release',
          boards=['x86-zgb'],
      ),
      site_config.AddConfig(
          _grouped_variant_release, 'x86-zgb_he-release',
          boards=['x86-zgb_he'],
          hw_tests=[],
          upload_hw_test_artifacts=False,
          paygen_skip_testing=True,
      ),
  )

  ### Release AFDO configs.

  release_afdo = _release.derive(
      trybot_list=False,
      hw_tests=(
          HWTestList.DefaultList(pool=constants.HWTEST_SUITES_POOL, num=4) +
          HWTestList.AFDOList()
      ),
      push_image=False,
      paygen=False,
      dev_installer_prebuilts=False,
  )

  release_afdo_generate = site_config.AddTemplate(
      config_lib.CONFIG_TYPE_RELEASE_AFDO + '-generate',
      release_afdo,
      afdo_generate_min=True,
      afdo_use=False,
      afdo_update_ebuild=True,

      hw_tests=[HWTestList.AFDORecordTest()],
      hw_tests_override=[HWTestList.AFDORecordTest(
          num=constants.HWTEST_TRYBOT_NUM,
          pool=constants.HWTEST_TRYBOT_POOL,
          file_bugs=False,
          priority=constants.HWTEST_DEFAULT_PRIORITY,
      )],
  )

  release_afdo_use = site_config.AddTemplate(
      config_lib.CONFIG_TYPE_RELEASE_AFDO + '-use',
      release_afdo,
      afdo_use=True,
  )

  # Now generate generic release-afdo configs if we haven't created anything
  # more specific above already. release-afdo configs are builders that do AFDO
  # profile collection and optimization in the same builder. Used by developers
  # that want to measure performance changes caused by their changes.
  def _AddAFDOConfigs():
    for board in _all_release_boards:
      base = _base_configs[board]

      config_name = '%s-%s' % (board, config_lib.CONFIG_TYPE_RELEASE_AFDO)
      if config_name in site_config:
        continue

      generate_config_name = (
          '%s-%s-%s' % (board,
                        config_lib.CONFIG_TYPE_RELEASE_AFDO,
                        'generate'))
      use_config_name = '%s-%s-%s' % (board,
                                      config_lib.CONFIG_TYPE_RELEASE_AFDO,
                                      'use')

      # We can't use AFDO data if afdo_use is disabled for this board.
      if not base.get('afdo_use', True):
        continue

      site_config.AddGroup(
          config_name,
          site_config.AddConfig(
              release_afdo_generate, generate_config_name, base
          ),
          site_config.AddConfig(
              release_afdo_use, use_config_name, base
          ),
      )

  _AddAFDOConfigs()

  ### Release configs.

  _critical_for_chrome_boards = frozenset([
      'daisy',
      'lumpy',
      'parrot',
  ])

  # bayleybay-release does not enable vm_tests or unittests due to the compiler
  # flags enabled for baytrail.
  site_config.AddConfig(
      _release, 'bayleybay-release',
      boards=['bayleybay'],
      hw_tests=[],
      vm_tests=[],
      unittests=False,
  )

  site_config.AddConfig(
      _release, 'beltino-release',
      boards=['beltino'],
      hw_tests=[],
      vm_tests=[],
  )

  # bobcat-release does not enable vm_tests or unittests due to the compiler
  # flags enabled for baytrail.
  site_config.AddConfig(
      _release, 'bobcat-release',
      boards=['bobcat'],
      hw_tests=[],
      profile='minimal',
      # This build doesn't generate signed images, so don't try to release them.
      paygen=False,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'gizmo-release',
      _base_configs['gizmo'],
      important=True,
      paygen=False,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'samus-release',
      _base_configs['samus'],
      important=True,
  )

  ### Arm release configs.

  site_config.AddConfig(
      _release, 'veyron_rialto-release',
      _base_configs['veyron_rialto'],
      # rialto does not use Chrome.
      sync_chrome=False,
      chrome_sdk=False,
  )

  # Now generate generic release configs if we haven't created anything more
  # specific above already.
  def _AddReleaseConfigs():
    # We have to mark all autogenerated PFQs as not important so the master
    # does not wait for them.  http://crbug.com/386214
    # If you want an important PFQ, you'll have to declare it yourself.
    _CreateConfigsForBoards(
        chrome_info, _all_release_boards, 'tot-chrome-pfq-informational',
        important=False)
    _CreateConfigsForBoards(
        chrome_pfq, _chrome_pfq_important_boards, 'chrome-pfq')
    _CreateConfigsForBoards(
        chrome_pfq, _all_release_boards, 'chrome-pfq', important=False)
    _CreateConfigsForBoards(
        _release, _critical_for_chrome_boards, config_lib.CONFIG_TYPE_RELEASE,
        critical_for_chrome=True)
    _CreateConfigsForBoards(
        _release, _all_release_boards, config_lib.CONFIG_TYPE_RELEASE)

  _AddReleaseConfigs()

  site_config.AddConfig(
      _release, 'panther_embedded-minimal-release',
      _base_configs['panther_embedded'],
      profile='minimal',
      important=True,
      paygen=False,
      signer_tests=False,
  )

  # beaglebone build doesn't generate signed images, so don't try to release
  # them.
  _beaglebone_release = _release.derive(beaglebone, paygen=False,
                                        signer_tests=False,
                                        images=['base', 'test'])

  site_config.AddGroup(
      'beaglebone-release-group',
      site_config.AddConfig(
          _beaglebone_release, 'beaglebone-release',
          boards=['beaglebone'],
      ),
      site_config.AddConfig(
          _beaglebone_release, 'beaglebone_servo-release',
          boards=['beaglebone_servo'],
          payload_image='base'
      ).derive(_grouped_variant_config),
      important=True,
  )

  site_config.AddConfig(
      _release, 'kayle-release',
      _base_configs['kayle'],
      paygen=False,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'cosmos-release',
      _base_configs['cosmos'],

      paygen_skip_testing=True,
      important=False,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'storm-release',
      _base_configs['storm'],

      # Hw Lab can't test storm, yet.
      paygen_skip_testing=True,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'mipsel-o32-generic-release',
      _base_configs['mipsel-o32-generic'],
      paygen_skip_delta_payloads=True,
      afdo_use=False,
      hw_tests=[],
  )

  site_config.AddConfig(
      _release, 'stumpy_moblab-release',
      _base_configs['stumpy_moblab'],
      images=['base', 'recovery', 'test'],
      paygen_skip_delta_payloads=True,
      # TODO: re-enable paygen testing when crbug.com/386473 is fixed.
      paygen_skip_testing=True,
      important=True,
      afdo_use=False,
      signer_tests=False,
      hw_tests=[
          config_lib.HWTestConfig(constants.HWTEST_MOBLAB_SUITE, blocking=True,
                                  num=1, timeout=120*60),
          config_lib.HWTestConfig(constants.HWTEST_BVT_SUITE, blocking=True,
                                  warn_only=True, num=1),
          config_lib.HWTestConfig(constants.HWTEST_AU_SUITE, blocking=True,
                                  warn_only=True, num=1)],
  )

  site_config.AddConfig(
      _release, 'panther_moblab-release',
      _base_configs['panther_moblab'],
      images=['base', 'recovery', 'test'],
      paygen_skip_delta_payloads=True,
      # TODO: re-enable paygen testing when crbug.com/386473 is fixed.
      paygen_skip_testing=True,
      important=False,
      afdo_use=False,
      signer_tests=False,
      hw_tests=[
          config_lib.HWTestConfig(
              constants.HWTEST_BVT_SUITE, blocking=True,
              warn_only=True, num=1
          ),
          config_lib.HWTestConfig(
              constants.HWTEST_AU_SUITE, blocking=True,
              warn_only=True, num=1
          ),
      ],
  )

  site_config.AddConfig(
      _release, 'guado_moblab-release',
      _base_configs['guado_moblab'],
      images=['base', 'recovery', 'test'],
      paygen_skip_delta_payloads=True,
      # TODO: re-enable paygen testing when crbug.com/386473 is fixed.
      paygen_skip_testing=True,
      important=False,
      afdo_use=False,
      signer_tests=False,
      hw_tests=[
          config_lib.HWTestConfig(
              constants.HWTEST_BVT_SUITE, blocking=True,
              warn_only=True, num=1
          ),
          config_lib.HWTestConfig(
              constants.HWTEST_AU_SUITE, blocking=True,
              warn_only=True, num=1
          ),
      ],
  )

  site_config.AddConfig(
      _release, 'rush-release',
      _base_configs['rush'],
      hw_tests=[],
      # This build doesn't generate signed images, so don't try to release them.
      paygen=False,
      signer_tests=False,
  )

  site_config.AddConfig(
      _release, 'rush_ryu-release',
      _base_configs['rush_ryu'],
      images=['base', 'test', 'factory_install'],
      dev_installer_prebuilts=False,
      paygen=False,
      signer_tests=False,
      push_image=False,
      hw_tests=[],
  )

  site_config.AddConfig(
      _release, 'veyron_mickey-release',
      _base_configs['veyron_mickey'],
      hw_tests=[],
      vm_tests=[],
  )

  site_config.AddConfig(
      _release, 'veyron_romy-release',
      _base_configs['veyron_romy'],
      hw_tests=[],
      vm_tests=[],
  )

  site_config.AddConfig(
      _release, 'whirlwind-release',
      _base_configs['whirlwind'],
      dev_installer_prebuilts=True,
  )

  site_config.AddConfig(
      _release, 'lakitu-release',
      _base_configs['lakitu'],
      vm_tests=[constants.SMOKE_SUITE_TEST_TYPE]
  )

  site_config.AddConfig(
      pre_cq, constants.WIFICELL_PRE_CQ,
      internal,
      boards=['samus'],
      hw_tests=HWTestList.WiFiCellPoolPreCQ()
  )

  ### Per-chipset release groups

  def _AddGroupConfig(name, base_board, group_boards=None,
                      group_variant_boards=None, **kwargs):
    """Generate full & release group configs."""
    def _boards_list(x):
      # Make sure _boards_list is a valid list (not None or tuple)
      return [] if x is None else list(x)

    group_boards = _boards_list(group_boards)
    group_variant_boards = _boards_list(group_variant_boards)

    for group in ('release', 'full'):
      configs = []

      all_boards = [base_board] + group_boards + group_variant_boards
      desc = '%s; Group config (boards: %s)' % (
          site_config['%s-%s' % (base_board, group)].description,
          ', '.join(all_boards))

      for board in all_boards:
        if board in group_boards:
          subconfig = _grouped_config
        elif board in group_variant_boards:
          subconfig = _grouped_variant_config
        else:
          subconfig = {}
        board_config = '%s-%s' % (board, group)
        configs.append(site_config[board_config].derive(subconfig, **kwargs))

        config_name = '%s-%s-group' % (name, group)
        important = group == 'release' and kwargs.get('important', True)
      site_config.AddGroup(
          config_name, *configs, description=desc,
          important=important
      )

  # pineview chipset boards
  _AddGroupConfig(
      'pineview', 'x86-mario', (
          'x86-alex',
          'x86-zgb',
      ), (
          'x86-alex_he',
          'x86-zgb_he',
      )
  )

  # pineview chipset boards (freon variant)
  _AddGroupConfig(
      'pineview-freon', 'x86-mario_freon', (
          'x86-alex_freon',
          'x86-zgb_freon',
      ), (
          'x86-alex_he-freon',
          'x86-zgb_he-freon',
      ),
      important=False
  )

  # sandybridge chipset boards
  _AddGroupConfig(
      'sandybridge', 'parrot', (
          'lumpy',
          'butterfly',
          'stumpy',
      )
  )

  # sandybridge chipset boards (freon variant)
  _AddGroupConfig(
      'sandybridge-freon', 'parrot_freon', (
          'lumpy_freon',
          'butterfly_freon',
          'stumpy_freon',
      )
  )

  # ivybridge chipset boards
  _AddGroupConfig(
      'ivybridge-freon', 'stout', (
          'link',
      ), (
          'parrot_ivb',
      )
  )

  # slippy-based haswell boards
  # TODO(davidjames): Combine slippy and beltino into haswell canary, once we've
  # optimized our builders more.
  # slippy itself is deprecated in favor of the below boards, so we don't bother
  # building it.
  # TODO(dnj): Re-add peppy canary once builders are allocated.
  _AddGroupConfig(
      'slippy', 'peppy', (
          'falco',
          'leon',
          'wolf',
      ), (
          'falco_li',
      )
  )

  # beltino-based haswell boards
  # beltino itself is deprecated in favor of the below boards, so we don't
  # bother building it.

  _AddGroupConfig(
      'beltino-a', 'panther', (
          'mccloud',
      )
  )

  _AddGroupConfig(
      'beltino-b', 'monroe', (
          'tricky',
          'zako',
      )
  )

  # rambi-based boards
  _AddGroupConfig(
      'rambi-a', 'rambi', (
          'clapper',
          'enguarde',
          'expresso',
      )
  )

  _AddGroupConfig(
      'rambi-b', 'glimmer', (
          'gnawty',
          'kip',
          'quawks',
      )
  )

  _AddGroupConfig(
      'rambi-c', 'squawks', (
          'swanky',
          'winky',
          'candy',
      )
  )

  _AddGroupConfig(
      'rambi-d', 'banjo', (
          'cranky',
          'ninja',
          'sumo',
      ),
      important=False,
  )

  _AddGroupConfig(
      'rambi-e', 'orco', (
          'heli',
      ),
      important=False,
  )

  # daisy-based boards
  _AddGroupConfig(
      'daisy', 'daisy', (
          'daisy_spring',
          'daisy_skate',
      ),
  )

  # peach-based boards
  _AddGroupConfig(
      'peach', 'peach_pit', (
          'peach_pi',
      )
  )

  # nyan-based boards
  _AddGroupConfig(
      'nyan', 'nyan', (
          'nyan_big',
          'nyan_blaze',
          'nyan_kitty',
      )
  )

  # auron-based boards
  _AddGroupConfig(
      'auron', 'auron', (
          'auron_yuna',
          'auron_paine',
      )
  )

  _AddGroupConfig(
      'auron-b', 'lulu', (
          'cid',
          'gandof',
      )
  )

  # veyron-based boards
  _AddGroupConfig(
      'veyron', 'veyron_pinky', (
          'veyron_jerry',
          'veyron_mighty',
          'veyron_speedy'
      ),
  )

  _AddGroupConfig(
      'veyron-b', 'veyron_gus', (
          'veyron_jaq',
          'veyron_minnie',
          'veyron_rialto',
      ),
      important=False,
  )

  _AddGroupConfig(
      'veyron-c', 'veyron_brain', (
          'veyron_danger',
          'veyron_thea',
          'veyron_shark',
      ),
      important=False,
  )

  _AddGroupConfig(
      'veyron-d', 'veyron_mickey', (
          'veyron_romy',
      ),
      important=False,
  )

  # jecht-based boards
  _AddGroupConfig(
      'jecht', 'jecht', (
          'guado',
          'tidus',
          'rikku',
      )
  )

  # strago-based boards
  _AddGroupConfig(
      'strago', 'strago', (
          'cyan',
      ),
      important=False,
  )

  # oak-based boards
  _AddGroupConfig(
      'oak', 'oak', (
      )
  )

  # glados-based boards
  _AddGroupConfig(
      'glados', 'glados', (
      ),
      important=False,
  )

  # storm-based boards
  _AddGroupConfig(
      'storm', 'storm', (
          'arkham',
          'whirlwind',
      ),
      important=False,
  )

  # Factory and Firmware releases much inherit from these classes.
  # Modifications for these release builders should go here.

  # Naming conventions also must be followed. Factory and firmware branches
  # must end in -factory or -firmware suffixes.

  _factory_release = site_config.AddTemplate(
      'factory',
      _release,
      upload_hw_test_artifacts=False,
      upload_symbols=False,
      hw_tests=[],
      chrome_sdk=False,
      description='Factory Builds',
      paygen=False,
      afdo_use=False,
  )

  _firmware = config_lib.BuildConfig(
      no_vmtest_builder,
      images=[],
      factory_toolkit=False,
      packages=['virtual/chromeos-firmware', 'chromeos-base/autotest-all'],
      usepkg_build_packages=True,
      sync_chrome=False,
      build_tests=True,
      chrome_sdk=False,
      unittests=False,
      hw_tests=[],
      dev_installer_prebuilts=False,
      upload_hw_test_artifacts=True,
      upload_symbols=False,
      useflags=['chromeless_tty'],
      signer_tests=False,
      trybot_list=False,
      paygen=False,
      image_test=False,
  )

  _firmware_release = site_config.AddTemplate(
      'firmware',
      _release,
      _firmware,
      description='Firmware Canary',
      manifest=constants.DEFAULT_MANIFEST,
      afdo_use=False,
  )

  _depthcharge_release = site_config.AddTemplate(
      'depthcharge-firmware',
      _firmware_release,
      useflags=append_useflags(['depthcharge']))

  _depthcharge_full_internal = site_config.AddTemplate(
      'depthcharge-full-firmware',
      full,
      internal,
      _firmware,
      useflags=append_useflags(['depthcharge']),
      description='Firmware Informational',
  )

  _firmware_boards = frozenset([
      'auron',
      'banjo',
      'bayleybay',
      'beltino',
      'butterfly',
      'candy',
      'celes',
      'clapper',
      'cyan',
      'daisy',
      'daisy_skate',
      'daisy_spring',
      'edgar',
      'enguarde',
      'expresso',
      'falco',
      'glimmer',
      'gnawty',
      'jecht',
      'kip',
      'leon',
      'link',
      'lumpy',
      'monroe',
      'ninja',
      'orco',
      'panther',
      'parrot',
      'parry',
      'peach_pi',
      'peach_pit',
      'peppy',
      'quawks',
      'rambi',
      'reks',
      'rikku',
      'samus',
      'setzer',
      'slippy',
      'smaug',
      'squawks',
      'storm',
      'stout',
      'strago',
      'stumpy',
      'sumo',
      'swanky',
      'terra',
      'ultima',
      'winky',
      'wizpig',
      'wolf',
      'x86-mario',
      'zako',
  ])

  _x86_depthcharge_firmware_boards = frozenset([
      'auron',
      'banjo',
      'bayleybay',
      'candy',
      'celes',
      'clapper',
      'cyan',
      'enguarde',
      'expresso',
      'glados',
      'glimmer',
      'gnawty',
      'heli',
      'jecht',
      'kip',
      'leon',
      'link',
      'ninja',
      'orco',
      'parry',
      'quawks',
      'rambi',
      'rikku',
      'samus',
      'squawks',
      'strago',
      'sumo',
      'swanky',
      'ultima',
      'winky',
      'zako',
  ])


  def _AddFirmwareConfigs():
    """Add x86 and arm firmware configs."""
    for board in _firmware_boards:
      site_config.AddConfig(
          _firmware_release,
          '%s-%s' % (board, config_lib.CONFIG_TYPE_FIRMWARE),
          _base_configs[board],
          no_vmtest_builder,
      )

    for board in _x86_depthcharge_firmware_boards:
      site_config.AddConfig(
          _depthcharge_release,
          '%s-%s-%s' % (board, 'depthcharge', config_lib.CONFIG_TYPE_FIRMWARE),
          _base_configs[board],
          no_vmtest_builder,
      )
      site_config.AddConfig(
          _depthcharge_full_internal,
          '%s-%s-%s-%s' % (board, 'depthcharge', config_lib.CONFIG_TYPE_FULL,
                           config_lib.CONFIG_TYPE_FIRMWARE),
          _base_configs[board],
          no_vmtest_builder,
      )

  _AddFirmwareConfigs()

  site_config.AddConfig(
      internal_pfq_branch, 'strago-pre-flight-branch',
      _firmware,
      master=True,
      push_overlays=constants.BOTH_OVERLAYS,
      boards=['strago'],
  )

  # This is an example factory branch configuration.
  # Modify it to match your factory branch.
  site_config.AddConfig(
      _factory_release, 'x86-mario-factory',
      boards=['x86-mario'],
  )

  _payloads = site_config.AddTemplate(
      'payloads',
      internal,
      no_vmtest_builder,
      no_unittest_builder,
      no_hwtest_builder,
      build_type=constants.PAYLOADS_TYPE,
      builder_class_name='release_builders.GeneratePayloadsBuilder',
      description='Regenerate release payloads.',

      # Sync to the code used to do the build the first time.
      manifest_version=True,

      # This is the actual work we want to do.
      paygen=True,

      upload_hw_test_artifacts=False,
  )

  def _AddPayloadConfigs():
    """Create <board>-payloads configs for all payload generating boards.

    We create a config named 'board-payloads' for every board which has a
    config with 'paygen' True. The idea is that we have a build that generates
    payloads, we need to have a tryjob to re-attempt them on failure.
    """
    payload_boards = set()

    def _search_config_and_children(search_config):
      # If paygen is enabled, add it's boards to our list of payload boards.
      if search_config['paygen']:
        for board in search_config['boards']:
          payload_boards.add(board)

      # Recurse on any child configs.
      for child in search_config['child_configs']:
        _search_config_and_children(child)

    # Search all configs for boards that generate payloads.
    for _, search_config in site_config.iteritems():
      _search_config_and_children(search_config)

    # Generate a payloads trybot config for every board that generates payloads.
    for board in payload_boards:
      name = '%s-payloads' % board
      site_config.AddConfig(_payloads, name, boards=[board])

  _AddPayloadConfigs()

  # Add special builders to help with cbuidlbot development/testing.
  site_config.Add(
      'sync-test-cbuildbot',
      no_hwtest_builder,
      boards=[],
      builder_class_name='test_builders.ManifestVersionedSyncBuilder',
      chroot_replace=True,
  )

  # On release branches, x86-mario is the release master.
  #
  # TODO(dnj): This should go away once the boardless release master is complete
  # (crbug.com/458675)
  if IS_RELEASE_BRANCH:
    site_config['x86-mario-release']['master'] = True

  def _SetupWaterfalls():
    for name, c in site_config.iteritems():
      if not c.get('active_waterfall'):
        c['active_waterfall'] = GetDefaultWaterfall(c)

    # Apply manual configs.
    for waterfall, names in _waterfall_config_map.iteritems():
      for name in names:
        site_config[name]['active_waterfall'] = waterfall

  _SetupWaterfalls()


  def _InsertHwTestsOverrideDefaults(build):
    """Insert default hw_tests values for a given build.

    Also updates child builds.

    Args:
      build: BuildConfig instance to modify in place.
    """
    for child in build['child_configs']:
      _InsertHwTestsOverrideDefaults(child)

    if build['hw_tests_override'] is not None:
      # Explicitly set, no need to insert defaults.
      return

    if not build['hw_tests']:
      build['hw_tests_override'] = HWTestList.DefaultList(
          num=constants.HWTEST_TRYBOT_NUM, pool=constants.HWTEST_TRYBOT_POOL,
          file_bugs=False)
    else:
      # Copy over base tests.
      build['hw_tests_override'] = [copy.copy(x) for x in build['hw_tests']]

      # Adjust for manual test environment.
      for hw_config in build['hw_tests_override']:
        hw_config.num = constants.HWTEST_TRYBOT_NUM
        hw_config.pool = constants.HWTEST_TRYBOT_POOL
        hw_config.file_bugs = False
        hw_config.priority = constants.HWTEST_DEFAULT_PRIORITY

    # TODO: Fix full_release_test.py/AUTest on trybots, crbug.com/390828.
    build['hw_tests_override'] = [
        hw_config for hw_config in build['hw_tests_override']
        if hw_config.suite != constants.HWTEST_AU_SUITE]

  for build in site_config.itervalues():
    _InsertHwTestsOverrideDefaults(build)

  return site_config