blob: 82a87c8a45861c087d921c8604b546bec973c107 [file] [log] [blame]
# -*- coding: utf-8 -*-
# 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.
"""Main builder code for Chromium OS.
Used by Chromium OS buildbot configuration for all Chromium OS builds including
full and pre-flight-queue builds.
from __future__ import print_function
import distutils.version # pylint: disable=import-error,no-name-in-module
import glob
import json
import optparse # pylint: disable=deprecated-module
import os
import pickle
import sys
from chromite.cbuildbot import builders
from chromite.cbuildbot import cbuildbot_run
from chromite.cbuildbot import repository
from chromite.cbuildbot import topology
from chromite.cbuildbot.stages import completion_stages
from chromite.lib import builder_status_lib
from chromite.lib import cidb
from chromite.lib import cgroups
from chromite.lib import cleanup
from chromite.lib import commandline
from chromite.lib import config_lib
from chromite.lib import constants
from chromite.lib import cros_build_lib
from chromite.lib import cros_logging as logging
from chromite.lib import failures_lib
from chromite.lib import git
from chromite.lib import gob_util
from chromite.lib import osutils
from chromite.lib import parallel
from chromite.lib import retry_stats
from chromite.lib import sudo
from chromite.lib import tee
from chromite.lib import timeout_util
from chromite.lib import ts_mon_config
from chromite.lib.buildstore import BuildStore
assert sys.version_info >= (3, 6), 'This module requires Python 3.6+'
_DEFAULT_LOG_DIR = 'cbuildbot_logs'
_BUILDBOT_LOG_FILE = 'cbuildbot.log'
_DEFAULT_INT_BUILDROOT = 'trybot-internal'
_API_VERSION_ATTR = 'api_version'
def _BackupPreviousLog(log_file, backup_limit=25):
"""Rename previous log.
log_file: The absolute path to the previous log.
backup_limit: Maximum number of old logs to keep.
if os.path.exists(log_file):
old_logs = sorted(glob.glob(log_file + '.*'),
if len(old_logs) >= backup_limit:
last = 0
if old_logs:
last = int(old_logs.pop().rpartition('.')[2])
os.rename(log_file, log_file + '.' + str(last + 1))
def _IsDistributedBuilder(options, chrome_rev, build_config):
"""Determines whether the builder should be a DistributedBuilder.
options: options passed on the commandline.
chrome_rev: Chrome revision to build.
build_config: Builder configuration dictionary.
True if the builder should be a distributed_builder
if not options.buildbot:
return False
elif chrome_rev in (constants.CHROME_REV_TOT,
# We don't do distributed logic to TOT Chrome PFQ's, nor local
# chrome roots (e.g. chrome try bots)
# TODO(davidjames): Update any builders that rely on this logic to use
# manifest_version=False instead.
return False
elif build_config['manifest_version']:
return True
return False
def _RunBuildStagesWrapper(options, site_config, build_config):
"""Helper function that wraps RunBuildStages()."""'cbuildbot was executed with args %s',
chrome_rev = build_config['chrome_rev']
if options.chrome_rev:
chrome_rev = options.chrome_rev
if chrome_rev == constants.CHROME_REV_TOT:
options.chrome_version = gob_util.GetTipOfTrunkRevision(
options.chrome_rev = constants.CHROME_REV_SPEC
# If it's likely we'll need to build Chrome, fetch the source.
if build_config['sync_chrome'] is None:
options.managed_chrome = (
chrome_rev != constants.CHROME_REV_LOCAL and
(not build_config['usepkg_build_packages'] or chrome_rev or
options.managed_chrome = build_config['sync_chrome']
chrome_root_mgr = None
if options.managed_chrome:
# Create a temp directory for syncing Chrome source.
chrome_root_mgr = osutils.TempDir(prefix='chrome_root_')
options.chrome_root = chrome_root_mgr.tempdir
# We are done munging options values, so freeze options object now to avoid
# further abuse of it.
# TODO(mtennant): one by one identify each options value override and see if
# it can be handled another way. Try to push this freeze closer and closer
# to the start of the script (e.g. in or after _PostParseCheck).
metadata_dump_dict = {
# A detected default has been set before now if it wasn't explicit.
'branch': options.branch,
if options.metadata_dump:
with open(options.metadata_dump, 'r') as metadata_file:
metadata_dump_dict = json.loads(
with parallel.Manager() as manager:
builder_run = cbuildbot_run.BuilderRun(
options, site_config, build_config, manager)
buildstore = BuildStore()
if metadata_dump_dict:
if builder_run.config.builder_class_name is None:
# TODO: This should get relocated to chromeos_config.
if _IsDistributedBuilder(options, chrome_rev, build_config):
builder_cls_name = 'simple_builders.DistributedBuilder'
builder_cls_name = 'simple_builders.SimpleBuilder'
builder_cls = builders.GetBuilderClass(builder_cls_name)
builder = builder_cls(builder_run, buildstore)
builder = builders.Builder(builder_run, buildstore)
if not builder.Run():
if chrome_root_mgr:
def _CheckChromeVersionOption(_option, _opt_str, value, parser):
"""Upgrade other options based on chrome_version being passed."""
value = value.strip()
if parser.values.chrome_rev is None and value:
parser.values.chrome_rev = constants.CHROME_REV_SPEC
parser.values.chrome_version = value
def _CheckChromeRootOption(_option, _opt_str, value, parser):
"""Validate and convert chrome_root to full-path form."""
if parser.values.chrome_rev is None:
parser.values.chrome_rev = constants.CHROME_REV_LOCAL
parser.values.chrome_root = value
def FindCacheDir(_parser, _options):
return None
class CustomGroup(optparse.OptionGroup):
"""Custom option group which supports arguments passed-through to trybot."""
def add_remote_option(self, *args, **kwargs):
"""For arguments that are passed-through to remote trybot."""
return optparse.OptionGroup.add_option(self, *args,
class CustomOption(commandline.FilteringOption):
"""Subclass FilteringOption class to implement pass-through and api."""
def __init__(self, *args, **kwargs):
# The remote_pass_through argument specifies whether we should directly
# pass the argument (with its value) onto the remote trybot.
self.pass_through = kwargs.pop('remote_pass_through', False)
self.api_version = int(kwargs.pop('api', '0'))
commandline.FilteringOption.__init__(self, *args, **kwargs)
class CustomParser(commandline.FilteringParser):
"""Custom option parser which supports arguments passed-through to trybot"""
def add_remote_option(self, *args, **kwargs):
"""For arguments that are passed-through to remote trybot."""
return self.add_option(*args, remote_pass_through=True, **kwargs)
def CreateParser():
"""Expose _CreateParser publicly."""
# Name _CreateParser is needed for commandline library.
return _CreateParser()
def _CreateParser():
"""Generate and return the parser with all the options."""
# Parse options
usage = 'usage: %prog [options] buildbot_config [buildbot_config ...]'
parser = CustomParser(usage=usage, caching=FindCacheDir)
# Main options
parser.add_remote_option('-b', '--branch',
help='The manifest branch to test. The branch to '
'check the buildroot out to.')
parser.add_option('-r', '--buildroot', type='path', dest='buildroot',
help='Root directory where source is checked out to, and '
'where the build occurs. For external build configs, '
"defaults to 'trybot' directory at top level of your "
'repo-managed checkout.')
parser.add_option('--workspace', type='path',
help='Root directory for a secondary checkout .')
parser.add_option('--bootstrap-dir', type='path',
help='Bootstrapping cbuildbot may involve checking out '
'multiple copies of chromite. All these checkouts '
'will be contained in the directory specified here. '
'Default:%s' % osutils.GetGlobalTempDir())
parser.add_remote_option('--android_rev', type='choice',
help=('Revision of Android to use, of type [%s]'
% '|'.join(constants.VALID_ANDROID_REVISIONS)))
parser.add_remote_option('--chrome_rev', type='choice',
help=('Revision of Chrome to use, of type [%s]'
% '|'.join(constants.VALID_CHROME_REVISIONS)))
help='Name of profile to sub-specify board variant.')
# TODO( Running GOMA is under development. Following
# flags are added for development purpose due to repository dependency,
# but not officially supported yet.
parser.add_option('--goma_dir', type='path',
help='Specify a directory containing goma. When this is '
'set, GOMA is used to build Chrome.')
parser.add_option('--chromeos_goma_dir', type='path',
help='Specify a directory containing goma for '
'build package.')
parser.add_option('--goma_client_json', type='path',
help='Specify a service-account-goma-client.json path. '
'The file is needed on bots to run GOMA.')
group = CustomGroup(
'Deprecated Options')
parser.add_option('--local', action='store_true', default=False,
help='Deprecated. See cros tryjob.')
parser.add_option('--remote', action='store_true', default=False,
help='Deprecated. See cros tryjob.')
# Patch selection options.
group = CustomGroup(
'Patch Options')
group.add_remote_option('-g', '--gerrit-patches', action='split_extend',
type='string', default=[],
metavar="'Id1 *int_Id2...IdN'",
help='Space-separated list of short-form Gerrit '
"Change-Id's or change numbers to patch. "
"Please prepend '*' to internal Change-Id's")
# Remote trybot options.
group = CustomGroup(
'Options used to configure tryjob behavior.')
group.add_remote_option('--hwtest', action='store_true', default=False,
help='Run the HWTest stage (tests on real hardware)')
group.add_remote_option('--channel', action='split_extend', dest='channels',
help='Specify a channel for a payloads trybot. Can '
'be specified multiple times. No valid for '
'non-payloads configs.')
# Advanced options.
group = CustomGroup(
'Advanced Options',
'Caution: use these options at your own risk.')
group.add_remote_option('--bootstrap-args', action='append', default=[],
help='Args passed directly to the bootstrap re-exec '
'to skip verification by the bootstrap code')
group.add_remote_option('--buildbot', action='store_true', dest='buildbot',
help='This is running on a buildbot. '
'This can be used to make a build operate '
'like an official builder, e.g. generate '
'new version numbers and archive official '
'artifacts and such. This should only be '
'used if you are confident in what you are '
'doing, as it will make automated commits.')
parser.add_remote_option('--repo-cache', type='path', dest='_repo_cache',
help='Present for backwards compatibility, ignored.')
group.add_remote_option('--no-buildbot-tags', action='store_false',
dest='enable_buildbot_tags', default=True,
help='Suppress buildbot specific tags from log '
'output. This is used to hide recursive '
'cbuilbot runs on the waterfall.')
group.add_remote_option('--buildnumber', type='int', default=0,
help='build number')
group.add_option('--chrome_root', action='callback', type='path',
help='Local checkout of Chrome to use.')
group.add_remote_option('--chrome_version', action='callback', type='string',
help='Used with SPEC logic to force a particular '
'git revision of chrome rather than the '
group.add_remote_option('--clobber', action='store_true', default=False,
help='Clears an old checkout before syncing')
group.add_remote_option('--latest-toolchain', action='store_true',
help='Use the latest toolchain.')
parser.add_option('--log_dir', dest='log_dir', type='path',
help='Directory where logs are stored.')
group.add_remote_option('--maxarchives', type='int',
dest='max_archive_builds', default=3,
help='Change the local saved build count limit.')
help='Overrides the default manifest repo url.')
group.add_remote_option('--compilecheck', action='store_true', default=False,
help='Only verify compilation and unit tests.')
group.add_remote_option('--noarchive', action='store_false', dest='archive',
default=True, help="Don't run archive stage.")
group.add_remote_option('--nobootstrap', action='store_false',
dest='bootstrap', default=True,
help="Don't checkout and run from a standalone "
'chromite repo.')
group.add_remote_option('--nobuild', action='store_false', dest='build',
help="Don't actually build (for cbuildbot dev)")
group.add_remote_option('--noclean', action='store_false', dest='clean',
default=True, help="Don't clean the buildroot")
group.add_remote_option('--nocgroups', action='store_false', dest='cgroups',
help='Disable cbuildbots usage of cgroups.')
group.add_remote_option('--nochromesdk', action='store_false',
dest='chrome_sdk', default=True,
help="Don't run the ChromeSDK stage which builds "
'Chrome outside of the chroot.')
group.add_remote_option('--noprebuilts', action='store_false',
dest='prebuilts', default=True,
help="Don't upload prebuilts.")
group.add_remote_option('--nopatch', action='store_false',
dest='postsync_patch', default=True,
help="Don't run PatchChanges stage. This does not "
'disable patching in of chromite patches '
'during BootstrapStage.')
group.add_remote_option('--nopaygen', action='store_false',
dest='paygen', default=True,
help="Don't generate payloads.")
group.add_remote_option('--noreexec', action='store_false',
dest='postsync_reexec', default=True,
help="Don't reexec into the buildroot after syncing.")
group.add_remote_option('--nosdk', action='store_true', default=False,
help='Re-create the SDK from scratch.')
group.add_remote_option('--nosync', action='store_false', dest='sync',
default=True, help="Don't sync before building.")
group.add_remote_option('--notests', action='store_false', dest='tests',
help='Override values from buildconfig, run no '
'tests, and build no autotest and artifacts.')
group.add_remote_option('--novmtests', action='store_false', dest='vmtests',
help='Override values from buildconfig, run no '
group.add_remote_option('--noimagetests', action='store_false',
dest='image_test', default=True,
help='Override values from buildconfig and run no '
'image tests.')
group.add_remote_option('--nouprev', action='store_false', dest='uprev',
help='Override values from buildconfig and never '
help='Reuse git data stored in an existing repo '
'checkout. This can drastically reduce the network '
'time spent setting up the trybot checkout. By '
"default, if this option isn't given but cbuildbot "
'is invoked from a repo checkout, cbuildbot will '
'use the repo root.')
group.add_option('--resume', action='store_true', default=False,
help='Skip stages already successfully completed.')
group.add_remote_option('--timeout', type='int', default=0,
help='Specify the maximum amount of time this job '
'can run for, at which point the build will be '
'aborted. If set to zero, then there is no '
group.add_remote_option('--version', dest='force_version',
help='Used with manifest logic. Forces use of this '
'version rather than create or get latest. '
'Examples: 4815.0.0-rc1, 4815.1.2')
group.add_remote_option('--git-cache-dir', type='path',
help='Specify the cache directory to store the '
'project caches populated by the git-cache '
'tool. Bootstrap the projects based on the git '
'cache files instead of fetching them directly '
'from the GoB servers.')
group.add_remote_option('--chrome-preload-dir', type='path',
help='Specify a preloaded chrome source cache '
'directory populated by the git-cache tool. '
'Bootstrap chrome based on the cached files '
'instead of fetching them directly from the GoB '
'servers. When both this argument and '
'--git-cache-dir are provided this value will '
'be preferred for the chrome source cache.')
group.add_remote_option('--debug-cidb', action='store_true', default=False,
help='Force Debug CIDB to be used.')
# cbuildbot ChromeOS Findit options
group.add_remote_option('--cbb_build_packages', action='split_extend',
help='Specify an explicit list of packages to build '
'for integration with Findit.')
group.add_remote_option('--cbb_snapshot_revision', type='string',
dest='cbb_snapshot_revision', default=None,
help='Snapshot manifest revision to sync to '
'for building.')
help="Don't publish git commits to prebuilt.conf or sdk_version.conf")
# Internal options.
group = CustomGroup(
'Internal Chromium OS Build Team Options',
'Caution: these are for meant for the Chromium OS build team only')
group.add_remote_option('--archive-base', type='gs_path',
help='Base GS URL (gs://<bucket_name>/<path>) to '
'upload archive artifacts to')
'--cq-gerrit-query', dest='cq_gerrit_override',
help='If given, this gerrit query will be used to find what patches to '
"test, rather than the normal 'CommitQueue>=1 AND Verified=1 AND "
"CodeReview=2' query it defaults to. Use with care- note "
'additionally this setting only has an effect if the buildbot '
"target is a cq target, and we're in buildbot mode.")
group.add_option('--pass-through', action='append', type='string',
dest='pass_through_args', default=[])
group.add_option('--reexec-api-version', action='store_true',
dest='output_api_version', default=False,
help='Used for handling forwards/backwards compatibility '
'with --resume and --bootstrap')
group.add_option('--remote-trybot', action='store_true', default=False,
help='Indicates this is running on a remote trybot machine')
api=constants.REEXEC_API_GOMA, # Approximate.
help='The unique ID in buildbucket of current build '
'generated by buildbucket.')
group.add_remote_option('--remote-patches', action='split_extend', default=[],
help='Patches uploaded by the trybot client when '
'run using the -p option')
# Note the default here needs to be hardcoded to 3; that is the last version
# that lacked this functionality.
group.add_option('--remote-version', type='int', default=3,
help='Deprecated and ignored.')
group.add_option('--sourceroot', type='path', default=constants.SOURCE_ROOT)
group.add_remote_option('--test-bootstrap', action='store_true',
help='Causes cbuildbot to bootstrap itself twice, '
'in the sequence A->B->C: A(unpatched) patches '
'and bootstraps B; B patches and bootstraps C')
help='Path to a pickled validation pool. Intended '
'for use only with the commit queue.')
help='Path to a json dumped metadata file. This '
'will be used as the initial metadata.')
group.add_remote_option('--master-build-id', type='int',
help='cidb build id of the master build to this '
'slave build.')
help='buildbucket id of the master build to this '
'slave build.')
# TODO(nxia):
# cbuildbot doesn't use pickle files anymore, remove this.
help='Override the result of the _FetchSlaveStatuses '
'method of MasterSlaveSyncCompletionStage, by '
'specifying a file with a pickle of the result '
'to be returned.')
group.add_option('--previous-build-state', type='string', default='',
help='A base64-encoded BuildSummary object describing the '
'previous build run on the same build machine.')
# Debug options
# Temporary hack; in place till --dry-run replaces --debug.
# pylint: disable=protected-access
group = parser.debug_group
debug = [x for x in group.option_list if x._long_opts == ['--debug']][0] += ' Currently functions as --dry-run in addition.'
debug.pass_through = True
group.add_option('--notee', action='store_false', dest='tee', default=True,
help='Disable logging and internal tee process. Primarily '
'used for debugging cbuildbot itself.')
return parser
def _FinishParsing(options):
"""Perform some parsing tasks that need to take place after optparse.
This function needs to be easily testable! Keep it free of
environment-dependent code. Put more detailed usage validation in
options: The options object returned by optparse
# Populate options.pass_through_args.
accepted, _ = commandline.FilteringParser.FilterArgs(
options.parsed_args, lambda x: x.opt_inst.pass_through)
if options.local or options.remote:
cros_build_lib.Die('Deprecated usage. Please use cros tryjob instead.')
if not options.buildroot:
cros_build_lib.Die('A buildroot is required to build.')
if options.chrome_root:
if options.chrome_rev != constants.CHROME_REV_LOCAL:
cros_build_lib.Die('Chrome rev must be %s if chrome_root is set.' %
elif options.chrome_rev == constants.CHROME_REV_LOCAL:
cros_build_lib.Die('Chrome root must be set if chrome_rev is %s.' %
if options.chrome_version:
if options.chrome_rev != constants.CHROME_REV_SPEC:
cros_build_lib.Die('Chrome rev must be %s if chrome_version is set.' %
elif options.chrome_rev == constants.CHROME_REV_SPEC:
'Chrome rev must not be %s if chrome_version is not set.'
% constants.CHROME_REV_SPEC)
patches = bool(options.gerrit_patches)
# When running in release mode, make sure we are running with checked-in code.
# We want checked-in cbuildbot/scripts to prevent errors, and we want to build
# a release image with checked-in code for CrOS packages.
if options.buildbot and patches and not options.debug:
'Cannot provide patches when running with --buildbot!')
if options.buildbot and options.remote_trybot:
'--buildbot and --remote-trybot cannot be used together.')
# Record whether --debug was set explicitly vs. it was inferred.
options.debug_forced = options.debug
# We force --debug to be set for builds that are not 'official'.
options.debug = options.debug or not options.buildbot
# pylint: disable=unused-argument
def _PostParseCheck(parser, options, site_config):
"""Perform some usage validation after we've parsed the arguments
parser: Option parser that was used to parse arguments.
options: The options returned by optparse.
site_config: config_lib.SiteConfig containing all config info.
if not options.branch:
options.branch = git.GetChromiteTrackingBranch()
# Because the default cache dir depends on other options, FindCacheDir
# always returns None, and we setup the default here.
if options.cache_dir is None:
# Note, options.sourceroot is set regardless of the path
# actually existing.
options.cache_dir = os.path.join(options.buildroot, '.cache')
options.cache_dir = os.path.abspath(options.cache_dir)
# Ensure that all args are legitimate config targets.
if options.build_config_name not in site_config:
cros_build_lib.Die('Unknown build config: "%s"' % options.build_config_name)
build_config = site_config[options.build_config_name]
is_payloads_build = build_config.build_type == constants.PAYLOADS_TYPE
if options.channels and not is_payloads_build:
cros_build_lib.Die('--channel must only be used with a payload config,'
' not target (%s).' % options.build_config_name)
if not options.channels and is_payloads_build:
cros_build_lib.Die('payload configs (%s) require --channel to do anything'
' useful.' % options.build_config_name)
# If the build config explicitly forces the debug flag, set the debug flag
# as if it was set from the command line.
if build_config.debug:
options.debug = True
if not (config_lib.isTryjobConfig(build_config) or options.buildbot):
'Refusing to run non-tryjob config as a tryjob.\n'
'Please "repo sync && cros tryjob --list %s" for alternatives.\n'
'See go/cros-explicit-tryjob-build-configs-psa.',
# The --version option is not compatible with an external target unless the
# --buildbot option is specified. More correctly, only "paladin versions"
# will work with external targets, and those are only used with --buildbot.
# If --buildbot is specified, then user should know what they are doing and
# only specify a version that will work. See
if (options.force_version and
not (options.buildbot or build_config.internal)):
cros_build_lib.Die('Cannot specify --version without --buildbot for an'
' external target (%s).' % options.build_config_name)
def ParseCommandLine(parser, argv):
"""Completely parse the commandline arguments"""
(options, args) = parser.parse_args(argv)
# Handle the request for the reexec command line API version number.
if options.output_api_version:
# Record the configs targeted. Strip out null arguments.
build_config_names = [x for x in args if x]
if len(build_config_names) != 1:
cros_build_lib.Die('Expected exactly one build config. Got: %r',
options.build_config_name = build_config_names[-1]
return options
def _GetRunEnvironment(options, build_config):
"""Determine whether this is a prod/debug/standalone run."""
if options.debug_cidb:
# One of these arguments should always be set if running on a real builder.
# If we aren't on a real builder, we are standalone.
if not options.buildbot and not options.remote_trybot:
if build_config['debug_cidb']:
def _SetupConnections(options, build_config):
"""Set up CIDB connections using the appropriate Setup call.
options: Command line options structure.
build_config: Config object for this build.
# Outline:
# 1) Based on options and build_config, decide whether we are a production
# run, debug run, or standalone run.
# 2) Set up cidb instance accordingly.
# 3) Update topology info from cidb, so that any other service set up can use
# topology.
# 4) Set up any other services.
run_type = _GetRunEnvironment(options, build_config)
if run_type == _ENVIRONMENT_PROD:
context = ts_mon_config.SetupTsMonGlobalState('cbuildbot', indirect=True)
elif run_type == _ENVIRONMENT_DEBUG:
context = ts_mon_config.TrivialContextManager()
context = ts_mon_config.TrivialContextManager()
return context
class _MockMethodWithReturnValue(object):
"""A method mocker which just returns the specific value."""
def __init__(self, return_value):
self.return_value = return_value
def __call__(self, *args, **kwargs):
return self.return_value
class _ObjectMethodPatcher(object):
"""A simplified mock.object.patch.
It is a context manager that patches an object's method with specified
return value.
def __init__(self, target, attr, return_value=None):
target: object to patch.
attr: method name of the object to patch.
return_value: the return value when calling target.attr
""" = target
self.attr = attr
self.return_value = return_value
self.original_attr = None
self.new_attr = _MockMethodWithReturnValue(self.return_value)
def __enter__(self):
self.original_attr =[self.attr]
setattr(, self.attr, self.new_attr)
def __exit__(self, *args):
if and self.original_attr:
setattr(, self.attr, self.original_attr)
# TODO(build): This function is too damn long.
def main(argv):
# We get false positives with the options object.
# pylint: disable=attribute-defined-outside-init
# Turn on strict sudo checks.
cros_build_lib.STRICT_SUDO = True
# Set umask to 022 so files created by buildbot are readable.
parser = _CreateParser()
options = ParseCommandLine(parser, argv)
# Fetch our site_config now, because we need it to do anything else.
site_config = config_lib.GetConfig()
_PostParseCheck(parser, options, site_config)
if options.enable_buildbot_tags:
if (options.buildbot and
not options.debug and
not cros_build_lib.HostIsCIBuilder()):
# --buildbot can only be used on a real builder, unless it's debug.
cros_build_lib.Die('This host is not a supported build machine.')
# Only one config arg is allowed in this mode, which was confirmed earlier.
build_config = site_config[options.build_config_name]
# TODO: Re-enable this block when reference_repo support handles this
# properly. (see chromium:330775)
# if options.reference_repo is None:
# repo_path = os.path.join(options.sourceroot, '.repo')
# # If we're being run from a repo checkout, reuse the repo's git pool to
# # cut down on sync time.
# if os.path.exists(repo_path):
# options.reference_repo = options.sourceroot
if options.reference_repo:
if not os.path.exists(options.reference_repo):
parser.error('Reference path %s does not exist'
% (options.reference_repo,))
elif not os.path.exists(os.path.join(options.reference_repo, '.repo')):
parser.error('Reference path %s does not look to be the base of a '
'repo checkout; no .repo exists in the root.'
% (options.reference_repo,))
if (options.buildbot or options.remote_trybot) and not options.resume:
if not options.cgroups:
parser.error('Options --buildbot/--remote-trybot and --nocgroups cannot '
'be used together. Cgroup support is required for '
'buildbot/remote-trybot mode.')
if not cgroups.Cgroup.IsSupported():
parser.error('Option --buildbot/--remote-trybot was given, but this '
'system does not support cgroups. Failing.')
missing = osutils.FindMissingBinaries(_BUILDBOT_REQUIRED_BINARIES)
if missing:
parser.error('Option --buildbot/--remote-trybot requires the following '
"binaries which couldn't be found in $PATH: %s"
% (', '.join(missing)))
if options.reference_repo:
options.reference_repo = os.path.abspath(options.reference_repo)
# Sanity check of buildroot- specifically that it's not pointing into the
# midst of an existing repo since git-repo doesn't support nesting.
if (not repository.IsARepoRoot(options.buildroot) and
'Configured buildroot %s is a subdir of an existing repo checkout.'
% options.buildroot)
if not options.log_dir:
options.log_dir = os.path.join(options.buildroot, _DEFAULT_LOG_DIR)
log_file = None
if options.tee:
log_file = os.path.join(options.log_dir, _BUILDBOT_LOG_FILE)
with cros_build_lib.ContextManagerStack() as stack:
# Preserve chromite; we might be running from there!
options.preserve_paths = set(['chromite'])
if log_file is not None:
# We don't want the critical section to try to clean up the tee process,
# so we run Tee (forked off) outside of it. This prevents a deadlock
# because the Tee process only exits when its pipe is closed, and the
# critical section accidentally holds on to that file handle.
stack.Add(tee.Tee, log_file)
critical_section = stack.Add(cleanup.EnforcedCleanupSection)
if not options.resume:
# If we're in resume mode, use our parents tempdir rather than
# nesting another layer.
stack.Add(osutils.TempDir, prefix='cbuildbot-tmp', set_global=True)
logging.debug('Cbuildbot tempdir is %r.', os.environ.get('TMP'))
if options.cgroups:
stack.Add(cgroups.SimpleContainChildren, 'cbuildbot')
# Mark everything between EnforcedCleanupSection and here as having to
# be rolled back via the contextmanager cleanup handlers. This
# ensures that sudo bits cannot outlive cbuildbot, that anything
# cgroups would kill gets killed, etc.
if options.mock_slave_status is not None:
with open(options.mock_slave_status, 'r') as f:
mock_statuses = pickle.load(f)
for key, value in mock_statuses.items():
mock_statuses[key] = builder_status_lib.BuilderStatus(**value)
stack.Add(_SetupConnections, options, build_config)
timeout_display_message = (
'This build has reached the timeout deadline set by the master. '
'Either this stage or a previous one took too long (see stage '
'timing historical summary in ReportStage) or the build failed '
'to start on time.')
if options.timeout > 0:
stack.Add(timeout_util.FatalTimeout, options.timeout,
_RunBuildStagesWrapper(options, site_config, build_config)
except failures_lib.ExitEarlyException as ex:
# This build finished successfully. Do not re-raise ExitEarlyException.'One stage exited early: %s', ex)