Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1 | #!/usr/bin/python |
| 2 | |
Mike Frysinger | d6925b5 | 2012-07-16 16:11:00 -0400 | [diff] [blame] | 3 | # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 4 | # Use of this source code is governed by a BSD-style license that can be |
| 5 | # found in the LICENSE file. |
| 6 | |
| 7 | """Main builder code for Chromium OS. |
| 8 | |
| 9 | Used by Chromium OS buildbot configuration for all Chromium OS builds including |
| 10 | full and pre-flight-queue builds. |
| 11 | """ |
| 12 | |
David James | 1fddb8f | 2013-04-25 15:23:07 -0700 | [diff] [blame] | 13 | import collections |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 14 | import distutils.version |
Mike Frysinger | 6903c76 | 2012-12-04 01:57:16 -0500 | [diff] [blame] | 15 | import errno |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 16 | import glob |
Chris Sosa | 4f6ffaf | 2012-05-01 17:05:44 -0700 | [diff] [blame] | 17 | import logging |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 18 | import optparse |
| 19 | import os |
Aviv Keshet | cf9c272 | 2014-02-25 15:15:10 -0800 | [diff] [blame] | 20 | import pickle |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 21 | import sys |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 22 | import time |
David James | 3541a13 | 2013-03-18 13:21:58 -0700 | [diff] [blame] | 23 | import traceback |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 24 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 25 | from chromite.buildbot import cbuildbot_config |
| 26 | from chromite.buildbot import cbuildbot_stages as stages |
| 27 | from chromite.buildbot import cbuildbot_results as results_lib |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 28 | from chromite.buildbot import cbuildbot_run |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 29 | from chromite.buildbot import constants |
Aviv Keshet | 4e75002 | 2014-03-07 16:50:34 -0800 | [diff] [blame] | 30 | from chromite.buildbot import manifest_version |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 31 | from chromite.buildbot import remote_try |
| 32 | from chromite.buildbot import repository |
| 33 | from chromite.buildbot import tee |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 34 | from chromite.buildbot import trybot_patch_pool |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 35 | |
Brian Harring | c92a701 | 2012-02-29 10:11:34 -0800 | [diff] [blame] | 36 | from chromite.lib import cgroups |
Brian Harring | a184efa | 2012-03-04 11:51:25 -0800 | [diff] [blame] | 37 | from chromite.lib import cleanup |
Brian Harring | b6cf914 | 2012-09-01 20:43:17 -0700 | [diff] [blame] | 38 | from chromite.lib import commandline |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 39 | from chromite.lib import cros_build_lib |
David James | a0a664e | 2013-02-13 09:52:01 -0800 | [diff] [blame] | 40 | from chromite.lib import gclient |
Brian Harring | 511055e | 2012-10-10 02:58:59 -0700 | [diff] [blame] | 41 | from chromite.lib import gerrit |
David James | 97d9587 | 2012-11-16 15:09:56 -0800 | [diff] [blame] | 42 | from chromite.lib import git |
Brian Harring | af019fb | 2012-05-10 15:06:13 -0700 | [diff] [blame] | 43 | from chromite.lib import osutils |
Brian Harring | 511055e | 2012-10-10 02:58:59 -0700 | [diff] [blame] | 44 | from chromite.lib import patch as cros_patch |
David James | 6450a0a | 2012-12-04 07:59:53 -0800 | [diff] [blame] | 45 | from chromite.lib import parallel |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 46 | from chromite.lib import sudo |
David James | 3432acd | 2013-11-27 10:02:18 -0800 | [diff] [blame] | 47 | from chromite.lib import timeout_util |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 48 | |
Aviv Keshet | a0159be | 2013-12-12 13:56:28 -0800 | [diff] [blame] | 49 | import mock |
| 50 | |
Ryan Cui | add4912 | 2012-03-21 22:19:58 -0700 | [diff] [blame] | 51 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 52 | _DEFAULT_LOG_DIR = 'cbuildbot_logs' |
| 53 | _BUILDBOT_LOG_FILE = 'cbuildbot.log' |
| 54 | _DEFAULT_EXT_BUILDROOT = 'trybot' |
| 55 | _DEFAULT_INT_BUILDROOT = 'trybot-internal' |
Brian Harring | 351ce44 | 2012-03-09 16:38:14 -0800 | [diff] [blame] | 56 | _BUILDBOT_REQUIRED_BINARIES = ('pbzip2',) |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 57 | _API_VERSION_ATTR = 'api_version' |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 58 | |
| 59 | |
Ryan Cui | 4f6cf7e | 2012-04-18 16:12:27 -0700 | [diff] [blame] | 60 | def _PrintValidConfigs(display_all=False): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 61 | """Print a list of valid buildbot configs. |
| 62 | |
Mike Frysinger | 02e1e07 | 2013-11-10 22:11:34 -0500 | [diff] [blame] | 63 | Args: |
Ryan Cui | 4f6cf7e | 2012-04-18 16:12:27 -0700 | [diff] [blame] | 64 | display_all: Print all configs. Otherwise, prints only configs with |
| 65 | trybot_list=True. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 66 | """ |
Ryan Cui | 4f6cf7e | 2012-04-18 16:12:27 -0700 | [diff] [blame] | 67 | def _GetSortKey(config_name): |
| 68 | config_dict = cbuildbot_config.config[config_name] |
| 69 | return (not config_dict['trybot_list'], config_dict['description'], |
| 70 | config_name) |
| 71 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 72 | COLUMN_WIDTH = 45 |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 73 | print |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 74 | print 'config'.ljust(COLUMN_WIDTH), 'description' |
| 75 | print '------'.ljust(COLUMN_WIDTH), '-----------' |
| 76 | config_names = cbuildbot_config.config.keys() |
Ryan Cui | 4f6cf7e | 2012-04-18 16:12:27 -0700 | [diff] [blame] | 77 | config_names.sort(key=_GetSortKey) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 78 | for name in config_names: |
Ryan Cui | 4f6cf7e | 2012-04-18 16:12:27 -0700 | [diff] [blame] | 79 | if display_all or cbuildbot_config.config[name]['trybot_list']: |
| 80 | desc = cbuildbot_config.config[name].get('description') |
| 81 | desc = desc if desc else '' |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 82 | print name.ljust(COLUMN_WIDTH), desc |
| 83 | |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 84 | print |
| 85 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 86 | |
| 87 | def _GetConfig(config_name): |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 88 | """Gets the configuration for the build if it exists, None otherwise.""" |
| 89 | if cbuildbot_config.config.has_key(config_name): |
| 90 | return cbuildbot_config.config[config_name] |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 91 | |
| 92 | |
Ryan Cui | e1e4e66 | 2012-05-21 16:39:46 -0700 | [diff] [blame] | 93 | def AcquirePoolFromOptions(options): |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 94 | """Generate patch objects from passed in options. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 95 | |
| 96 | Args: |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 97 | options: The options object generated by optparse. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 98 | |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 99 | Returns: |
| 100 | trybot_patch_pool.TrybotPatchPool object. |
| 101 | |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 102 | Raises: |
Brian Harring | 511055e | 2012-10-10 02:58:59 -0700 | [diff] [blame] | 103 | gerrit.GerritException, cros_patch.PatchException |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 104 | """ |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 105 | gerrit_patches = [] |
| 106 | local_patches = [] |
| 107 | remote_patches = [] |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 108 | |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 109 | if options.gerrit_patches: |
Brian Harring | 511055e | 2012-10-10 02:58:59 -0700 | [diff] [blame] | 110 | gerrit_patches = gerrit.GetGerritPatchInfo( |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 111 | options.gerrit_patches) |
| 112 | for patch in gerrit_patches: |
| 113 | if patch.IsAlreadyMerged(): |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 114 | cros_build_lib.Warning('Patch %s has already been merged.' % str(patch)) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 115 | |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 116 | if options.local_patches: |
David James | 97d9587 | 2012-11-16 15:09:56 -0800 | [diff] [blame] | 117 | manifest = git.ManifestCheckout.Cached(options.sourceroot) |
Brian Harring | 609dc4e | 2012-05-07 02:17:44 -0700 | [diff] [blame] | 118 | local_patches = cros_patch.PrepareLocalPatches(manifest, |
| 119 | options.local_patches) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 120 | |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 121 | if options.remote_patches: |
| 122 | remote_patches = cros_patch.PrepareRemotePatches( |
| 123 | options.remote_patches) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 124 | |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 125 | return trybot_patch_pool.TrybotPatchPool(gerrit_patches, local_patches, |
| 126 | remote_patches) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 127 | |
| 128 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 129 | class Builder(object): |
| 130 | """Parent class for all builder types. |
| 131 | |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 132 | This class functions as an abstract parent class for various build types. |
| 133 | Its intended use is builder_instance.Run(). |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 134 | |
Matt Tennant | 3f35155 | 2014-01-03 14:28:00 -0800 | [diff] [blame] | 135 | Attributes: |
| 136 | _run: The BuilderRun object for this run. |
| 137 | archive_stages: Dict of BuildConfig keys to ArchiveStage values. |
| 138 | patch_pool: TrybotPatchPool. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 139 | """ |
| 140 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 141 | def __init__(self, builder_run): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 142 | """Initializes instance variables. Must be called by all subclasses.""" |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 143 | self._run = builder_run |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 144 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 145 | if self._run.config.chromeos_official: |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 146 | os.environ['CHROMEOS_OFFICIAL'] = '1' |
| 147 | |
David James | 58e0c09 | 2012-03-04 20:31:12 -0800 | [diff] [blame] | 148 | self.archive_stages = {} |
Brian Harring | 76d1bf6 | 2012-06-01 13:52:48 -0700 | [diff] [blame] | 149 | self.patch_pool = trybot_patch_pool.TrybotPatchPool() |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 150 | |
| 151 | def Initialize(self): |
| 152 | """Runs through the initialization steps of an actual build.""" |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 153 | if self._run.options.resume: |
| 154 | results_lib.LoadCheckpoint(self._run.buildroot) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 155 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 156 | self._RunStage(stages.CleanUpStage) |
| 157 | |
| 158 | def _GetStageInstance(self, stage, *args, **kwargs): |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 159 | """Helper function to get a stage instance given the args. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 160 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 161 | Useful as almost all stages just take in builder_run. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 162 | """ |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 163 | # Normally the default BuilderRun (self._run) is used, but it can |
| 164 | # be overridden with "builder_run" kwargs (e.g. for child configs). |
| 165 | builder_run = kwargs.pop('builder_run', self._run) |
| 166 | return stage(builder_run, *args, **kwargs) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 167 | |
| 168 | def _SetReleaseTag(self): |
Matt Tennant | 9c1c849 | 2014-02-27 13:09:07 -0800 | [diff] [blame] | 169 | """Sets run.attrs.release_tag from the manifest manager used in sync. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 170 | |
Matt Tennant | f4980ee | 2014-01-29 09:21:27 -0800 | [diff] [blame] | 171 | Must be run after sync stage as syncing enables us to have a release tag, |
| 172 | and must be run before any usage of attrs.release_tag. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 173 | |
| 174 | TODO(mtennant): Find a bottleneck place in syncing that can set this |
Matt Tennant | f4980ee | 2014-01-29 09:21:27 -0800 | [diff] [blame] | 175 | directly. Be careful, as there are several kinds of syncing stages, and |
| 176 | sync stages have been known to abort with sys.exit calls. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 177 | """ |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 178 | manifest_manager = getattr(self._run.attrs, 'manifest_manager', None) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 179 | if manifest_manager: |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 180 | self._run.attrs.release_tag = manifest_manager.current_version |
Matt Tennant | 3f35155 | 2014-01-03 14:28:00 -0800 | [diff] [blame] | 181 | else: |
| 182 | self._run.attrs.release_tag = None |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 183 | |
Matt Tennant | a42a574 | 2014-02-09 13:42:12 -0800 | [diff] [blame] | 184 | cros_build_lib.Debug('Saved release_tag value for run: %r', |
| 185 | self._run.attrs.release_tag) |
| 186 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 187 | def _RunStage(self, stage, *args, **kwargs): |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 188 | """Wrapper to run a stage. |
| 189 | |
| 190 | Args: |
| 191 | stage: A BuilderStage class. |
| 192 | args: args to pass to stage constructor. |
| 193 | kwargs: kwargs to pass to stage constructor. |
Mike Frysinger | 1a736a8 | 2013-12-12 01:50:59 -0500 | [diff] [blame] | 194 | |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 195 | Returns: |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 196 | Whatever the stage's Run method returns. |
| 197 | """ |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 198 | stage_instance = self._GetStageInstance(stage, *args, **kwargs) |
| 199 | return stage_instance.Run() |
| 200 | |
Matt Tennant | f4980ee | 2014-01-29 09:21:27 -0800 | [diff] [blame] | 201 | def _RunSyncStage(self, sync_instance): |
| 202 | """Run given |sync_instance| stage and be sure attrs.release_tag set.""" |
| 203 | try: |
| 204 | sync_instance.Run() |
| 205 | finally: |
| 206 | self._SetReleaseTag() |
| 207 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 208 | def GetSyncInstance(self): |
| 209 | """Returns an instance of a SyncStage that should be run. |
| 210 | |
| 211 | Subclasses must override this method. |
| 212 | """ |
| 213 | raise NotImplementedError() |
| 214 | |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 215 | def GetCompletionInstance(self): |
Aviv Keshet | f274615 | 2013-11-26 10:42:46 -0800 | [diff] [blame] | 216 | """Returns the MasterSlaveSyncCompletionStage for this build. |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 217 | |
| 218 | Subclasses may override this method. |
| 219 | |
Mike Frysinger | 02e1e07 | 2013-11-10 22:11:34 -0500 | [diff] [blame] | 220 | Returns: |
| 221 | None |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 222 | """ |
| 223 | return None |
| 224 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 225 | def RunStages(self): |
| 226 | """Subclasses must override this method. Runs the appropriate code.""" |
| 227 | raise NotImplementedError() |
| 228 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 229 | def _ReExecuteInBuildroot(self, sync_instance): |
| 230 | """Reexecutes self in buildroot and returns True if build succeeds. |
| 231 | |
| 232 | This allows the buildbot code to test itself when changes are patched for |
| 233 | buildbot-related code. This is a no-op if the buildroot == buildroot |
| 234 | of the running chromite checkout. |
| 235 | |
| 236 | Args: |
Matt Tennant | 8534885 | 2014-01-10 15:16:02 -0800 | [diff] [blame] | 237 | sync_instance: Instance of the sync stage that was run to sync. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 238 | |
| 239 | Returns: |
| 240 | True if the Build succeeded. |
| 241 | """ |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 242 | if not self._run.options.resume: |
| 243 | results_lib.WriteCheckpoint(self._run.options.buildroot) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 244 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 245 | args = stages.BootstrapStage.FilterArgsForTargetCbuildbot( |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 246 | self._run.options.buildroot, constants.PATH_TO_CBUILDBOT, |
| 247 | self._run.options) |
Brian Harring | 37e559b | 2012-05-22 20:47:32 -0700 | [diff] [blame] | 248 | |
David James | 2333c18 | 2013-02-13 16:16:15 -0800 | [diff] [blame] | 249 | # Specify a buildroot explicitly (just in case, for local trybot). |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 250 | # Suppress any timeout options given from the commandline in the |
| 251 | # invoked cbuildbot; our timeout will enforce it instead. |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 252 | args += ['--resume', '--timeout', '0', '--notee', '--nocgroups', |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 253 | '--buildroot', os.path.abspath(self._run.options.buildroot)] |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 254 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 255 | if hasattr(self._run.attrs, 'manifest_manager'): |
| 256 | # TODO(mtennant): Is this the same as self._run.attrs.release_tag? |
| 257 | ver = self._run.attrs.manifest_manager.current_version |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 258 | args += ['--version', ver] |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 259 | |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 260 | pool = getattr(sync_instance, 'pool', None) |
| 261 | if pool: |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 262 | filename = os.path.join(self._run.options.buildroot, |
| 263 | 'validation_pool.dump') |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 264 | pool.Save(filename) |
| 265 | args += ['--validation_pool', filename] |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 266 | |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 267 | # Reset the cache dir so that the child will calculate it automatically. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 268 | if not self._run.options.cache_dir_specified: |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 269 | commandline.BaseParser.ConfigureCacheDir(None) |
| 270 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 271 | # Re-run the command in the buildroot. |
| 272 | # Finally, be generous and give the invoked cbuildbot 30s to shutdown |
| 273 | # when something occurs. It should exit quicker, but the sigterm may |
| 274 | # hit while the system is particularly busy. |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 275 | return_obj = cros_build_lib.RunCommand( |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 276 | args, cwd=self._run.options.buildroot, error_code_ok=True, |
| 277 | kill_timeout=30) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 278 | return return_obj.returncode == 0 |
| 279 | |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 280 | def _InitializeTrybotPatchPool(self): |
| 281 | """Generate patch pool from patches specified on the command line. |
| 282 | |
| 283 | Do this only if we need to patch changes later on. |
| 284 | """ |
| 285 | changes_stage = stages.PatchChangesStage.StageNamePrefix() |
| 286 | check_func = results_lib.Results.PreviouslyCompletedRecord |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 287 | if not check_func(changes_stage) or self._run.options.bootstrap: |
| 288 | self.patch_pool = AcquirePoolFromOptions(self._run.options) |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 289 | |
| 290 | def _GetBootstrapStage(self): |
| 291 | """Constructs and returns the BootStrapStage object. |
| 292 | |
| 293 | We return None when there are no chromite patches to test, and |
| 294 | --test-bootstrap wasn't passed in. |
| 295 | """ |
| 296 | stage = None |
| 297 | chromite_pool = self.patch_pool.Filter(project=constants.CHROMITE_PROJECT) |
Ryan Cui | 5616a51 | 2012-08-17 13:39:36 -0700 | [diff] [blame] | 298 | manifest_pool = self.patch_pool.FilterManifest() |
David James | 97d9587 | 2012-11-16 15:09:56 -0800 | [diff] [blame] | 299 | chromite_branch = git.GetChromiteTrackingBranch() |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 300 | if (chromite_pool or manifest_pool or |
| 301 | self._run.options.test_bootstrap or |
| 302 | chromite_branch != self._run.options.branch): |
| 303 | stage = stages.BootstrapStage(self._run, chromite_pool, |
| 304 | manifest_pool) |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 305 | return stage |
| 306 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 307 | def Run(self): |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 308 | """Main runner for this builder class. Runs build and prints summary. |
| 309 | |
| 310 | Returns: |
| 311 | Whether the build succeeded. |
| 312 | """ |
| 313 | self._InitializeTrybotPatchPool() |
| 314 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 315 | if self._run.options.bootstrap: |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 316 | bootstrap_stage = self._GetBootstrapStage() |
| 317 | if bootstrap_stage: |
| 318 | # BootstrapStage blocks on re-execution of cbuildbot. |
| 319 | bootstrap_stage.Run() |
| 320 | return bootstrap_stage.returncode == 0 |
| 321 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 322 | print_report = True |
David James | 3d4d350 | 2012-04-09 15:12:06 -0700 | [diff] [blame] | 323 | exception_thrown = False |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 324 | success = True |
David James | 9ebb2a4 | 2013-08-13 20:29:57 -0700 | [diff] [blame] | 325 | sync_instance = None |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 326 | try: |
| 327 | self.Initialize() |
| 328 | sync_instance = self.GetSyncInstance() |
Matt Tennant | f4980ee | 2014-01-29 09:21:27 -0800 | [diff] [blame] | 329 | self._RunSyncStage(sync_instance) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 330 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 331 | if self._run.ShouldPatchAfterSync(): |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 332 | # Filter out patches to manifest, since PatchChangesStage can't handle |
| 333 | # them. Manifest patches are patched in the BootstrapStage. |
| 334 | non_manifest_patches = self.patch_pool.FilterManifest(negate=True) |
| 335 | if non_manifest_patches: |
| 336 | self._RunStage(stages.PatchChangesStage, non_manifest_patches) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 337 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 338 | if self._run.ShouldReexecAfterSync(): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 339 | print_report = False |
| 340 | success = self._ReExecuteInBuildroot(sync_instance) |
| 341 | else: |
| 342 | self.RunStages() |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 343 | |
David James | 3541a13 | 2013-03-18 13:21:58 -0700 | [diff] [blame] | 344 | except Exception as ex: |
| 345 | # If the build is marked as successful, but threw exceptions, that's a |
| 346 | # problem. |
David James | 7fbf2d4 | 2012-07-14 18:23:49 -0700 | [diff] [blame] | 347 | exception_thrown = True |
David James | 3541a13 | 2013-03-18 13:21:58 -0700 | [diff] [blame] | 348 | if results_lib.Results.BuildSucceededSoFar(): |
| 349 | traceback.print_exc(file=sys.stdout) |
David James | 7fbf2d4 | 2012-07-14 18:23:49 -0700 | [diff] [blame] | 350 | raise |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 351 | |
David James | 3541a13 | 2013-03-18 13:21:58 -0700 | [diff] [blame] | 352 | if not (print_report and isinstance(ex, results_lib.StepFailure)): |
| 353 | raise |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 354 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 355 | finally: |
| 356 | if print_report: |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 357 | results_lib.WriteCheckpoint(self._run.options.buildroot) |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 358 | completion_instance = self.GetCompletionInstance() |
Matt Tennant | 066d932 | 2014-01-28 10:37:48 -0800 | [diff] [blame] | 359 | self._RunStage(stages.ReportStage, sync_instance, completion_instance) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 360 | success = results_lib.Results.BuildSucceededSoFar() |
David James | 3d4d350 | 2012-04-09 15:12:06 -0700 | [diff] [blame] | 361 | if exception_thrown and success: |
| 362 | success = False |
David James | bb20ac8 | 2012-07-18 10:59:16 -0700 | [diff] [blame] | 363 | cros_build_lib.PrintBuildbotStepWarnings() |
| 364 | print """\ |
David James | 3d4d350 | 2012-04-09 15:12:06 -0700 | [diff] [blame] | 365 | Exception thrown, but all stages marked successful. This is an internal error, |
| 366 | because the stage that threw the exception should be marked as failing.""" |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 367 | |
| 368 | return success |
| 369 | |
| 370 | |
David James | 1fddb8f | 2013-04-25 15:23:07 -0700 | [diff] [blame] | 371 | BoardConfig = collections.namedtuple('BoardConfig', ['board', 'name']) |
| 372 | |
| 373 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 374 | class SimpleBuilder(Builder): |
| 375 | """Builder that performs basic vetting operations.""" |
| 376 | |
| 377 | def GetSyncInstance(self): |
| 378 | """Sync to lkgm or TOT as necessary. |
| 379 | |
Mike Frysinger | 02e1e07 | 2013-11-10 22:11:34 -0500 | [diff] [blame] | 380 | Returns: |
| 381 | The instance of the sync stage to run. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 382 | """ |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 383 | if self._run.options.force_version: |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 384 | sync_stage = self._GetStageInstance(stages.ManifestVersionedSyncStage) |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 385 | elif self._run.config.use_lkgm: |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 386 | sync_stage = self._GetStageInstance(stages.LKGMSyncStage) |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 387 | elif self._run.config.use_chrome_lkgm: |
Chris Sosa | 52a81b6 | 2012-11-14 06:12:54 -0800 | [diff] [blame] | 388 | sync_stage = self._GetStageInstance(stages.ChromeLKGMSyncStage) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 389 | else: |
| 390 | sync_stage = self._GetStageInstance(stages.SyncStage) |
| 391 | |
| 392 | return sync_stage |
| 393 | |
David James | 4f2d830 | 2013-03-19 06:35:58 -0700 | [diff] [blame] | 394 | @staticmethod |
| 395 | def _RunParallelStages(stage_objs): |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 396 | """Run the specified stages in parallel. |
| 397 | |
| 398 | Args: |
| 399 | stage_objs: BuilderStage objects. |
| 400 | """ |
David James | 4f2d830 | 2013-03-19 06:35:58 -0700 | [diff] [blame] | 401 | steps = [stage.Run for stage in stage_objs] |
| 402 | try: |
| 403 | parallel.RunParallelSteps(steps) |
Matt Tennant | 0940c38 | 2014-01-21 20:43:55 -0800 | [diff] [blame] | 404 | |
David James | 4f2d830 | 2013-03-19 06:35:58 -0700 | [diff] [blame] | 405 | except BaseException as ex: |
| 406 | # If a stage threw an exception, it might not have correctly reported |
| 407 | # results (e.g. because it was killed before it could report the |
| 408 | # results.) In this case, attribute the exception to any stages that |
| 409 | # didn't report back correctly (if any). |
| 410 | for stage in stage_objs: |
David James | 6b70424 | 2013-10-18 14:51:37 -0700 | [diff] [blame] | 411 | for name in stage.GetStageNames(): |
| 412 | if not results_lib.Results.StageHasResults(name): |
| 413 | results_lib.Results.Record(name, ex, str(ex)) |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 414 | |
David James | 4f2d830 | 2013-03-19 06:35:58 -0700 | [diff] [blame] | 415 | raise |
| 416 | |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 417 | def _RunBackgroundStagesForBoard(self, builder_run, board, compilecheck): |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 418 | """Run background board-specific stages for the specified board. |
| 419 | |
| 420 | Args: |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 421 | builder_run: BuilderRun object for these background stages. |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 422 | board: Board name. |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 423 | compilecheck: Boolean. If True, run only the compile steps. |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 424 | """ |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 425 | config = builder_run.config |
Matt Tennant | 066d932 | 2014-01-28 10:37:48 -0800 | [diff] [blame] | 426 | |
| 427 | # TODO(mtennant): This is the last usage of self.archive_stages. We can |
| 428 | # kill it once we migrate its uses to BuilderRun so that none of the |
| 429 | # stages below need it as an argument. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 430 | archive_stage = self.archive_stages[BoardConfig(board, config.name)] |
| 431 | if config.pgo_generate: |
Ahmad Sharif | a2db40a | 2013-07-22 13:51:52 -0400 | [diff] [blame] | 432 | self._RunParallelStages([archive_stage]) |
David James | 1fddb8f | 2013-04-25 15:23:07 -0700 | [diff] [blame] | 433 | return |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 434 | |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 435 | if compilecheck: |
David James | 565bc9a | 2013-04-08 14:54:45 -0700 | [diff] [blame] | 436 | self._RunStage(stages.BuildPackagesStage, board, archive_stage, |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 437 | builder_run=builder_run) |
| 438 | self._RunStage(stages.UnitTestStage, board, |
| 439 | builder_run=builder_run) |
David James | 565bc9a | 2013-04-08 14:54:45 -0700 | [diff] [blame] | 440 | return |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 441 | |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 442 | # signer_results can't complete without push_image. |
| 443 | assert not config['signer_results'] or config['push_image'] |
| 444 | |
| 445 | # paygen can't complete without signer_results. |
| 446 | assert not config['paygen'] or config['signer_results'] |
Don Garrett | 82c0ae8 | 2014-02-03 18:25:11 -0800 | [diff] [blame] | 447 | |
Mike Frysinger | 31ac04f | 2013-11-10 21:07:48 -0500 | [diff] [blame] | 448 | # While this stage list is run in parallel, the order here dictates the |
| 449 | # order that things will be shown in the log. So group things together |
| 450 | # that make sense when read in order. Also keep in mind that, since we |
| 451 | # gather output manually, early slow stages will prevent any output from |
| 452 | # later stages showing up until it finishes. |
Ryan Cui | 3ea98e0 | 2013-08-07 16:01:48 -0700 | [diff] [blame] | 453 | stage_list = [] |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 454 | if builder_run.options.chrome_sdk and config.chrome_sdk: |
Ryan Cui | 3ea98e0 | 2013-08-07 16:01:48 -0700 | [diff] [blame] | 455 | stage_list.append([stages.ChromeSDKStage, board, archive_stage]) |
David James | 6b70424 | 2013-10-18 14:51:37 -0700 | [diff] [blame] | 456 | stage_list += [ |
Matt Tennant | 06460b7 | 2014-02-10 18:00:13 -0800 | [diff] [blame] | 457 | [stages.RetryStage, 1, stages.VMTestStage, board], |
David James | 6b70424 | 2013-10-18 14:51:37 -0700 | [diff] [blame] | 458 | [stages.SignerTestStage, board, archive_stage], |
Don Garrett | 7604d6a | 2014-01-15 14:45:39 -0800 | [diff] [blame] | 459 | [stages.SignerResultsStage, board, archive_stage], |
Don Garrett | 82c0ae8 | 2014-02-03 18:25:11 -0800 | [diff] [blame] | 460 | [stages.PaygenStage, board, archive_stage], |
David James | 6b70424 | 2013-10-18 14:51:37 -0700 | [diff] [blame] | 461 | [stages.UnitTestStage, board], |
| 462 | [stages.UploadPrebuiltsStage, board, archive_stage], |
Mike Frysinger | 31ac04f | 2013-11-10 21:07:48 -0500 | [diff] [blame] | 463 | [stages.DevInstallerPrebuiltsStage, board, archive_stage], |
Matt Tennant | 06460b7 | 2014-02-10 18:00:13 -0800 | [diff] [blame] | 464 | [stages.DebugSymbolsStage, board], |
David James | 6b70424 | 2013-10-18 14:51:37 -0700 | [diff] [blame] | 465 | ] |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 466 | |
David James | 58e0c09 | 2012-03-04 20:31:12 -0800 | [diff] [blame] | 467 | # We can not run hw tests without archiving the payloads. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 468 | if builder_run.options.archive: |
| 469 | for suite_config in config.hw_tests: |
Chris Sosa | ba25052 | 2013-03-27 18:57:34 -0700 | [diff] [blame] | 470 | if suite_config.async: |
| 471 | stage_list.append([stages.ASyncHWTestStage, board, archive_stage, |
| 472 | suite_config]) |
| 473 | elif suite_config.suite == constants.HWTEST_AU_SUITE: |
| 474 | stage_list.append([stages.AUTestStage, board, archive_stage, |
| 475 | suite_config]) |
Aviv Keshet | 23efd04 | 2013-10-01 13:59:08 -0700 | [diff] [blame] | 476 | elif suite_config.suite == constants.HWTEST_QAV_SUITE: |
| 477 | stage_list.append([stages.QATestStage, board, |
| 478 | archive_stage, suite_config]) |
Chris Sosa | 077df81 | 2013-01-25 17:05:28 -0800 | [diff] [blame] | 479 | else: |
Chris Sosa | ba25052 | 2013-03-27 18:57:34 -0700 | [diff] [blame] | 480 | stage_list.append([stages.HWTestStage, board, archive_stage, |
| 481 | suite_config]) |
Chris Sosa | 817b1f9 | 2012-07-19 15:00:23 -0700 | [diff] [blame] | 482 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 483 | stage_objs = [self._GetStageInstance(*x, builder_run=builder_run) |
| 484 | for x in stage_list] |
David James | 4f2d830 | 2013-03-19 06:35:58 -0700 | [diff] [blame] | 485 | self._RunParallelStages(stage_objs + [archive_stage]) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 486 | |
David James | 3b4bacf | 2014-02-19 17:25:15 -0800 | [diff] [blame] | 487 | def _RunSetupBoard(self): |
| 488 | """Run the SetupBoard stage for all child configs and boards.""" |
| 489 | for builder_run in self._run.GetUngroupedBuilderRuns(): |
| 490 | for board in builder_run.config.boards: |
| 491 | self._RunStage(stages.SetupBoardStage, board, builder_run=builder_run) |
| 492 | |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 493 | def _RunChrootBuilderTypeBuild(self): |
| 494 | """Runs through stages of a CHROOT_BUILDER_TYPE build.""" |
| 495 | self._RunStage(stages.UprevStage, boards=[], enter_chroot=False) |
| 496 | self._RunStage(stages.InitSDKStage) |
David James | 3b4bacf | 2014-02-19 17:25:15 -0800 | [diff] [blame] | 497 | self._RunStage(stages.SetupBoardStage, constants.CHROOT_BUILDER_BOARD) |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 498 | self._RunStage(stages.SyncChromeStage) |
| 499 | self._RunStage(stages.PatchChromeStage) |
| 500 | self._RunStage(stages.SDKPackageStage) |
| 501 | self._RunStage(stages.SDKTestStage) |
| 502 | self._RunStage(stages.UploadPrebuiltsStage, |
| 503 | constants.CHROOT_BUILDER_BOARD, None) |
| 504 | |
| 505 | def _RunRefreshPackagesTypeBuild(self): |
| 506 | """Runs through the stages of a REFRESH_PACKAGES_TYPE build.""" |
| 507 | self._RunStage(stages.InitSDKStage) |
David James | 3b4bacf | 2014-02-19 17:25:15 -0800 | [diff] [blame] | 508 | self._RunSetupBoard() |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 509 | self._RunStage(stages.RefreshPackageStatusStage) |
| 510 | |
Matt Tennant | e817904 | 2013-10-01 15:47:32 -0700 | [diff] [blame] | 511 | def _RunMasterPaladinBuild(self): |
| 512 | """Runs through the stages of the paladin (commit queue) master build.""" |
| 513 | self._RunStage(stages.InitSDKStage) |
| 514 | self._RunStage(stages.UprevStage) |
Matt Tennant | 9c1c849 | 2014-02-27 13:09:07 -0800 | [diff] [blame] | 515 | # The CQ (paladin) master will not actually run the SyncChrome stage, but |
| 516 | # we want the logic that gets triggered when SyncChrome stage is skipped. |
| 517 | self._RunStage(stages.SyncChromeStage) |
Matt Tennant | e817904 | 2013-10-01 15:47:32 -0700 | [diff] [blame] | 518 | self._RunStage(stages.MasterUploadPrebuiltsStage) |
| 519 | |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 520 | def _RunDefaultTypeBuild(self): |
| 521 | """Runs through the stages of a non-special-type build.""" |
| 522 | self._RunStage(stages.InitSDKStage) |
| 523 | self._RunStage(stages.UprevStage) |
David James | 3b4bacf | 2014-02-19 17:25:15 -0800 | [diff] [blame] | 524 | self._RunSetupBoard() |
Matt Tennant | 8534885 | 2014-01-10 15:16:02 -0800 | [diff] [blame] | 525 | self._RunStage(stages.SyncChromeStage) |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 526 | self._RunStage(stages.PatchChromeStage) |
| 527 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 528 | # Prepare stages to run in background. If child_configs exist then |
| 529 | # run each of those here, otherwise use default config. |
Matt Tennant | 950c6cb | 2014-01-10 16:45:03 -0800 | [diff] [blame] | 530 | builder_runs = self._run.GetUngroupedBuilderRuns() |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 531 | |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 532 | tasks = [] |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 533 | for builder_run in builder_runs: |
Matt Tennant | a42a574 | 2014-02-09 13:42:12 -0800 | [diff] [blame] | 534 | # Prepare a local archive directory for each "run". |
| 535 | builder_run.GetArchive().SetupArchivePath() |
| 536 | |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 537 | for board in builder_run.config.boards: |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 538 | archive_stage = self._GetStageInstance( |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 539 | stages.ArchiveStage, board, builder_run=builder_run, |
Matt Tennant | 8534885 | 2014-01-10 15:16:02 -0800 | [diff] [blame] | 540 | chrome_version=self._run.attrs.chrome_version) |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 541 | board_config = BoardConfig(board, builder_run.config.name) |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 542 | self.archive_stages[board_config] = archive_stage |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 543 | tasks.append((builder_run, board, archive_stage)) |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 544 | |
| 545 | # Set up a process pool to run test/archive stages in the background. |
David James | ed8349b | 2014-03-01 11:27:04 -0800 | [diff] [blame] | 546 | # This process runs task(board) for each board added to the queue. |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 547 | task_runner = self._RunBackgroundStagesForBoard |
| 548 | with parallel.BackgroundTaskRunner(task_runner) as queue: |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 549 | for builder_run, board, archive_stage in tasks: |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 550 | compilecheck = (builder_run.config.compilecheck or |
| 551 | builder_run.options.compilecheck) |
| 552 | if not compilecheck: |
| 553 | # Run BuildPackages and BuildImage in the foreground, generating |
| 554 | # or using PGO data if requested. |
David James | ed8349b | 2014-03-01 11:27:04 -0800 | [diff] [blame] | 555 | kwargs = {'archive_stage': archive_stage, 'builder_run': builder_run} |
| 556 | if builder_run.config.pgo_generate: |
| 557 | kwargs['pgo_generate'] = True |
| 558 | elif builder_run.config.pgo_use: |
| 559 | kwargs['pgo_use'] = True |
| 560 | |
| 561 | self._RunStage(stages.BuildPackagesStage, board, **kwargs) |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 562 | self._RunStage(stages.BuildImageStage, board, **kwargs) |
David James | ed8349b | 2014-03-01 11:27:04 -0800 | [diff] [blame] | 563 | |
| 564 | if builder_run.config.pgo_generate: |
| 565 | suite = cbuildbot_config.PGORecordTest() |
| 566 | self._RunStage(stages.HWTestStage, board, archive_stage, suite, |
| 567 | builder_run=builder_run) |
| 568 | |
| 569 | # Kick off our background stages. |
Gwendal Grignou | b2bc8a3 | 2014-03-16 22:56:58 +0000 | [diff] [blame] | 570 | queue.put([builder_run, board, compilecheck]) |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 571 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 572 | def RunStages(self): |
| 573 | """Runs through build process.""" |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 574 | # TODO(sosa): Split these out into classes. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 575 | if self._run.config.build_type == constants.PRE_CQ_LAUNCHER_TYPE: |
David James | 816a594 | 2013-04-11 22:59:32 -0700 | [diff] [blame] | 576 | self._RunStage(stages.PreCQLauncherStage) |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 577 | elif self._run.config.build_type == constants.CREATE_BRANCH_TYPE: |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 578 | self._RunStage(stages.BranchUtilStage) |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 579 | elif self._run.config.build_type == constants.CHROOT_BUILDER_TYPE: |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 580 | self._RunChrootBuilderTypeBuild() |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 581 | elif self._run.config.build_type == constants.REFRESH_PACKAGES_TYPE: |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 582 | self._RunRefreshPackagesTypeBuild() |
Matt Tennant | e817904 | 2013-10-01 15:47:32 -0700 | [diff] [blame] | 583 | elif (self._run.config.build_type == constants.PALADIN_TYPE and |
| 584 | self._run.config.master): |
| 585 | self._RunMasterPaladinBuild() |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 586 | else: |
Aviv Keshet | 7dc300f | 2013-10-11 12:57:49 -0400 | [diff] [blame] | 587 | self._RunDefaultTypeBuild() |
David James | 58e0c09 | 2012-03-04 20:31:12 -0800 | [diff] [blame] | 588 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 589 | |
| 590 | class DistributedBuilder(SimpleBuilder): |
| 591 | """Build class that has special logic to handle distributed builds. |
| 592 | |
| 593 | These builds sync using git/manifest logic in manifest_versions. In general |
| 594 | they use a non-distributed builder code for the bulk of the work. |
| 595 | """ |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 596 | def __init__(self, *args, **kwargs): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 597 | """Initializes a buildbot builder. |
| 598 | |
| 599 | Extra variables: |
| 600 | completion_stage_class: Stage used to complete a build. Set in the Sync |
| 601 | stage. |
| 602 | """ |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 603 | super(DistributedBuilder, self).__init__(*args, **kwargs) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 604 | self.completion_stage_class = None |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 605 | self.sync_stage = None |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 606 | self._completion_stage = None |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 607 | |
| 608 | def GetSyncInstance(self): |
| 609 | """Syncs the tree using one of the distributed sync logic paths. |
| 610 | |
Mike Frysinger | 02e1e07 | 2013-11-10 22:11:34 -0500 | [diff] [blame] | 611 | Returns: |
| 612 | The instance of the sync stage to run. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 613 | """ |
| 614 | # Determine sync class to use. CQ overrides PFQ bits so should check it |
| 615 | # first. |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 616 | if self._run.config.pre_cq or self._run.options.pre_cq: |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 617 | sync_stage = self._GetStageInstance(stages.PreCQSyncStage, |
| 618 | self.patch_pool.gerrit_patches) |
| 619 | self.completion_stage_class = stages.PreCQCompletionStage |
| 620 | self.patch_pool.gerrit_patches = [] |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 621 | elif cbuildbot_config.IsCQType(self._run.config.build_type): |
| 622 | if self._run.config.do_not_apply_cq_patches: |
Aviv Keshet | 00bc951 | 2013-11-25 14:58:47 -0800 | [diff] [blame] | 623 | sync_stage = self._GetStageInstance(stages.MasterSlaveSyncStage) |
| 624 | else: |
| 625 | sync_stage = self._GetStageInstance(stages.CommitQueueSyncStage) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 626 | self.completion_stage_class = stages.CommitQueueCompletionStage |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 627 | elif cbuildbot_config.IsPFQType(self._run.config.build_type): |
Aviv Keshet | f274615 | 2013-11-26 10:42:46 -0800 | [diff] [blame] | 628 | sync_stage = self._GetStageInstance(stages.MasterSlaveSyncStage) |
| 629 | self.completion_stage_class = stages.MasterSlaveSyncCompletionStage |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 630 | else: |
| 631 | sync_stage = self._GetStageInstance(stages.ManifestVersionedSyncStage) |
| 632 | self.completion_stage_class = stages.ManifestVersionedSyncCompletionStage |
| 633 | |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 634 | self.sync_stage = sync_stage |
| 635 | return self.sync_stage |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 636 | |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 637 | def GetCompletionInstance(self): |
| 638 | """Returns the completion_stage_class instance that was used for this build. |
| 639 | |
Mike Frysinger | 1a736a8 | 2013-12-12 01:50:59 -0500 | [diff] [blame] | 640 | Returns: |
| 641 | None if the completion_stage instance was not yet created (this |
| 642 | occurs during Publish). |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 643 | """ |
| 644 | return self._completion_stage |
| 645 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 646 | def Publish(self, was_build_successful): |
| 647 | """Completes build by publishing any required information.""" |
| 648 | completion_stage = self._GetStageInstance(self.completion_stage_class, |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 649 | self.sync_stage, |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 650 | was_build_successful) |
Aviv Keshet | 5c39b6a | 2013-10-07 15:44:54 -0400 | [diff] [blame] | 651 | self._completion_stage = completion_stage |
David James | 11fd7e8 | 2013-10-23 20:02:16 -0700 | [diff] [blame] | 652 | completion_successful = False |
| 653 | try: |
| 654 | completion_stage.Run() |
| 655 | completion_successful = True |
| 656 | finally: |
| 657 | if not completion_successful: |
| 658 | was_build_successful = False |
Matt Tennant | efb5952 | 2013-10-18 13:49:28 -0700 | [diff] [blame] | 659 | if self._run.config.push_overlays: |
David James | 11fd7e8 | 2013-10-23 20:02:16 -0700 | [diff] [blame] | 660 | self._RunStage(stages.PublishUprevChangesStage, was_build_successful) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 661 | |
| 662 | def RunStages(self): |
| 663 | """Runs simple builder logic and publishes information to overlays.""" |
| 664 | was_build_successful = False |
David James | 843ed25 | 2013-09-11 16:18:10 -0700 | [diff] [blame] | 665 | try: |
| 666 | super(DistributedBuilder, self).RunStages() |
| 667 | was_build_successful = results_lib.Results.BuildSucceededSoFar() |
| 668 | except SystemExit as ex: |
| 669 | # If a stage calls sys.exit(0), it's exiting with success, so that means |
| 670 | # we should mark ourselves as successful. |
| 671 | if ex.code == 0: |
| 672 | was_build_successful = True |
| 673 | raise |
| 674 | finally: |
| 675 | self.Publish(was_build_successful) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 676 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 677 | |
| 678 | def _ConfirmBuildRoot(buildroot): |
| 679 | """Confirm with user the inferred buildroot, and mark it as confirmed.""" |
Brian Harring | 521e724 | 2012-11-01 16:57:42 -0700 | [diff] [blame] | 680 | cros_build_lib.Warning('Using default directory %s as buildroot', buildroot) |
| 681 | if not cros_build_lib.BooleanPrompt(default=False): |
| 682 | print('Please specify a different buildroot via the --buildroot option.') |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 683 | sys.exit(0) |
| 684 | |
| 685 | if not os.path.exists(buildroot): |
| 686 | os.mkdir(buildroot) |
| 687 | |
| 688 | repository.CreateTrybotMarker(buildroot) |
| 689 | |
| 690 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 691 | def _ConfirmRemoteBuildbotRun(): |
| 692 | """Confirm user wants to run with --buildbot --remote.""" |
Brian Harring | 521e724 | 2012-11-01 16:57:42 -0700 | [diff] [blame] | 693 | cros_build_lib.Warning( |
| 694 | 'You are about to launch a PRODUCTION job! This is *NOT* a ' |
| 695 | 'trybot run! Are you sure?') |
| 696 | if not cros_build_lib.BooleanPrompt(default=False): |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 697 | print('Please specify --pass-through="--debug".') |
| 698 | sys.exit(0) |
| 699 | |
| 700 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 701 | def _DetermineDefaultBuildRoot(sourceroot, internal_build): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 702 | """Default buildroot to be under the directory that contains current checkout. |
| 703 | |
Mike Frysinger | 02e1e07 | 2013-11-10 22:11:34 -0500 | [diff] [blame] | 704 | Args: |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 705 | internal_build: Whether the build is an internal build |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 706 | sourceroot: Use specified sourceroot. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 707 | """ |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 708 | if not repository.IsARepoRoot(sourceroot): |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 709 | cros_build_lib.Die( |
| 710 | 'Could not find root of local checkout at %s. Please specify ' |
| 711 | 'using the --sourceroot option.' % sourceroot) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 712 | |
| 713 | # Place trybot buildroot under the directory containing current checkout. |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 714 | top_level = os.path.dirname(os.path.realpath(sourceroot)) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 715 | if internal_build: |
| 716 | buildroot = os.path.join(top_level, _DEFAULT_INT_BUILDROOT) |
| 717 | else: |
| 718 | buildroot = os.path.join(top_level, _DEFAULT_EXT_BUILDROOT) |
| 719 | |
| 720 | return buildroot |
| 721 | |
| 722 | |
Mike Frysinger | 6903c76 | 2012-12-04 01:57:16 -0500 | [diff] [blame] | 723 | def _DisableYamaHardLinkChecks(): |
| 724 | """Disable Yama kernel hardlink security checks. |
| 725 | |
| 726 | The security module disables hardlinking to files you do not have |
| 727 | write access to which causes some of our build scripts problems. |
| 728 | Disable it so we don't have to worry about it. |
| 729 | """ |
| 730 | PROC_PATH = '/proc/sys/kernel/yama/protected_nonaccess_hardlinks' |
| 731 | SYSCTL_PATH = PROC_PATH[len('/proc/sys/'):].replace('/', '.') |
| 732 | |
| 733 | # Yama not available in this system -- nothing to do. |
| 734 | if not os.path.exists(PROC_PATH): |
| 735 | return |
| 736 | |
| 737 | # Already disabled -- nothing to do. |
| 738 | if osutils.ReadFile(PROC_PATH).strip() == '0': |
| 739 | return |
| 740 | |
| 741 | # Create a hardlink in a tempdir and see if we get back EPERM. |
David James | 4bc1370 | 2013-03-26 08:08:04 -0700 | [diff] [blame] | 742 | with osutils.TempDir() as tempdir: |
Mike Frysinger | 6903c76 | 2012-12-04 01:57:16 -0500 | [diff] [blame] | 743 | try: |
| 744 | os.link('/bin/sh', os.path.join(tempdir, 'sh')) |
| 745 | except OSError as e: |
| 746 | if e.errno == errno.EPERM: |
| 747 | cros_build_lib.Warning('Disabling Yama hardlink security') |
| 748 | cros_build_lib.SudoRunCommand(['sysctl', '%s=0' % SYSCTL_PATH]) |
| 749 | |
| 750 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 751 | def _BackupPreviousLog(log_file, backup_limit=25): |
| 752 | """Rename previous log. |
| 753 | |
| 754 | Args: |
| 755 | log_file: The absolute path to the previous log. |
Aviv Keshet | 9e4236b | 2013-12-13 13:07:50 -0800 | [diff] [blame] | 756 | backup_limit: Maximum number of old logs to keep. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 757 | """ |
| 758 | if os.path.exists(log_file): |
| 759 | old_logs = sorted(glob.glob(log_file + '.*'), |
| 760 | key=distutils.version.LooseVersion) |
| 761 | |
| 762 | if len(old_logs) >= backup_limit: |
| 763 | os.remove(old_logs[0]) |
| 764 | |
| 765 | last = 0 |
| 766 | if old_logs: |
| 767 | last = int(old_logs.pop().rpartition('.')[2]) |
| 768 | |
| 769 | os.rename(log_file, log_file + '.' + str(last + 1)) |
| 770 | |
Ryan Cui | 5616a51 | 2012-08-17 13:39:36 -0700 | [diff] [blame] | 771 | |
Gaurav Shah | 298aa37 | 2014-01-31 09:27:24 -0800 | [diff] [blame] | 772 | def _IsDistributedBuilder(options, chrome_rev, build_config): |
| 773 | """Determines whether the builder should be a DistributedBuilder. |
| 774 | |
| 775 | Args: |
| 776 | options: options passed on the commandline. |
| 777 | chrome_rev: Chrome revision to build. |
| 778 | build_config: Builder configuration dictionary. |
| 779 | |
| 780 | Returns: |
| 781 | True if the builder should be a distributed_builder |
| 782 | """ |
| 783 | if build_config['pre_cq'] or options.pre_cq: |
| 784 | return True |
| 785 | elif not options.buildbot: |
| 786 | return False |
| 787 | elif chrome_rev in (constants.CHROME_REV_TOT, |
| 788 | constants.CHROME_REV_LOCAL, |
| 789 | constants.CHROME_REV_SPEC): |
| 790 | # We don't do distributed logic to TOT Chrome PFQ's, nor local |
| 791 | # chrome roots (e.g. chrome try bots) |
| 792 | # TODO(davidjames): Update any builders that rely on this logic to use |
| 793 | # manifest_version=False instead. |
| 794 | return False |
| 795 | elif build_config['manifest_version']: |
| 796 | return True |
| 797 | |
| 798 | return False |
| 799 | |
| 800 | |
David James | 944a48e | 2012-03-07 12:19:03 -0800 | [diff] [blame] | 801 | def _RunBuildStagesWrapper(options, build_config): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 802 | """Helper function that wraps RunBuildStages().""" |
Matt Tennant | 7feda35 | 2013-12-20 14:03:40 -0800 | [diff] [blame] | 803 | cros_build_lib.Info('cbuildbot was executed with args %s' % |
| 804 | cros_build_lib.CmdToStr(sys.argv)) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 805 | |
David James | a0a664e | 2013-02-13 09:52:01 -0800 | [diff] [blame] | 806 | chrome_rev = build_config['chrome_rev'] |
| 807 | if options.chrome_rev: |
| 808 | chrome_rev = options.chrome_rev |
| 809 | if chrome_rev == constants.CHROME_REV_TOT: |
| 810 | # Build the TOT Chrome revision. |
| 811 | svn_url = gclient.GetBaseURLs()[0] |
| 812 | options.chrome_version = gclient.GetTipOfTrunkSvnRevision(svn_url) |
| 813 | options.chrome_rev = constants.CHROME_REV_SPEC |
| 814 | |
David James | 4a404a5 | 2013-02-19 13:07:59 -0800 | [diff] [blame] | 815 | # If it's likely we'll need to build Chrome, fetch the source. |
Mike Frysinger | f4d9ab8 | 2013-03-05 19:38:05 -0500 | [diff] [blame] | 816 | if build_config['sync_chrome'] is None: |
| 817 | options.managed_chrome = (chrome_rev != constants.CHROME_REV_LOCAL and |
| 818 | (not build_config['usepkg_build_packages'] or chrome_rev or |
David James | 3cce464 | 2013-05-10 17:50:23 -0700 | [diff] [blame] | 819 | build_config['profile'] or options.rietveld_patches)) |
Mike Frysinger | f4d9ab8 | 2013-03-05 19:38:05 -0500 | [diff] [blame] | 820 | else: |
| 821 | options.managed_chrome = build_config['sync_chrome'] |
David James | 2333c18 | 2013-02-13 16:16:15 -0800 | [diff] [blame] | 822 | |
| 823 | if options.managed_chrome: |
| 824 | # Tell Chrome to fetch the source locally. |
Matt Tennant | 628ffdd | 2013-11-27 14:44:39 -0800 | [diff] [blame] | 825 | internal = constants.USE_CHROME_INTERNAL in build_config['useflags'] |
David James | 2333c18 | 2013-02-13 16:16:15 -0800 | [diff] [blame] | 826 | chrome_src = 'chrome-src-internal' if internal else 'chrome-src' |
| 827 | options.chrome_root = os.path.join(options.cache_dir, 'distfiles', 'target', |
| 828 | chrome_src) |
David James | 9e27e66 | 2013-02-14 13:42:43 -0800 | [diff] [blame] | 829 | elif options.rietveld_patches: |
David James | 4a404a5 | 2013-02-19 13:07:59 -0800 | [diff] [blame] | 830 | cros_build_lib.Die('This builder does not support Rietveld patches.') |
David James | 2333c18 | 2013-02-13 16:16:15 -0800 | [diff] [blame] | 831 | |
Matt Tennant | 95a42ad | 2013-12-27 15:38:36 -0800 | [diff] [blame] | 832 | # We are done munging options values, so freeze options object now to avoid |
| 833 | # further abuse of it. |
| 834 | # TODO(mtennant): one by one identify each options value override and see if |
| 835 | # it can be handled another way. Try to push this freeze closer and closer |
| 836 | # to the start of the script (e.g. in or after _PostParseCheck). |
| 837 | options.Freeze() |
| 838 | |
Matt Tennant | 0940c38 | 2014-01-21 20:43:55 -0800 | [diff] [blame] | 839 | with parallel.Manager() as manager: |
| 840 | builder_run = cbuildbot_run.BuilderRun(options, build_config, manager) |
| 841 | if _IsDistributedBuilder(options, chrome_rev, build_config): |
| 842 | builder_cls = DistributedBuilder |
| 843 | else: |
| 844 | builder_cls = SimpleBuilder |
| 845 | builder = builder_cls(builder_run) |
| 846 | if not builder.Run(): |
| 847 | sys.exit(1) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 848 | |
| 849 | |
| 850 | # Parser related functions |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 851 | def _CheckLocalPatches(sourceroot, local_patches): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 852 | """Do an early quick check of the passed-in patches. |
| 853 | |
| 854 | If the branch of a project is not specified we append the current branch the |
| 855 | project is on. |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 856 | |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 857 | TODO(davidjames): The project:branch format isn't unique, so this means that |
| 858 | we can't differentiate what directory the user intended to apply patches to. |
| 859 | We should references by directory instead. |
| 860 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 861 | Args: |
| 862 | sourceroot: The checkout where patches are coming from. |
Aviv Keshet | 9e4236b | 2013-12-13 13:07:50 -0800 | [diff] [blame] | 863 | local_patches: List of patches to check in project:branch format. |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 864 | |
| 865 | Returns: |
| 866 | A list of patches that have been verified, in project:branch format. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 867 | """ |
Ryan Cui | cedd8a5 | 2012-03-22 02:28:35 -0700 | [diff] [blame] | 868 | verified_patches = [] |
David James | 97d9587 | 2012-11-16 15:09:56 -0800 | [diff] [blame] | 869 | manifest = git.ManifestCheckout.Cached(sourceroot) |
Ryan Cui | cedd8a5 | 2012-03-22 02:28:35 -0700 | [diff] [blame] | 870 | for patch in local_patches: |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 871 | project, _, branch = patch.partition(':') |
| 872 | |
Gaurav Shah | 7afb056 | 2013-12-26 15:05:39 -0800 | [diff] [blame] | 873 | checkouts = manifest.FindCheckouts(project, only_patchable=True) |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 874 | if not checkouts: |
| 875 | cros_build_lib.Die('Project %s does not exist.' % (project,)) |
| 876 | if len(checkouts) > 1: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 877 | cros_build_lib.Die( |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 878 | 'We do not yet support local patching for projects that are checked ' |
| 879 | 'out to multiple directories. Try uploading your patch to gerrit ' |
| 880 | 'and referencing it via the -g option instead.' |
| 881 | ) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 882 | |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 883 | ok = False |
| 884 | for checkout in checkouts: |
| 885 | project_dir = checkout.GetPath(absolute=True) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 886 | |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 887 | # If no branch was specified, we use the project's current branch. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 888 | if not branch: |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 889 | local_branch = git.GetCurrentBranch(project_dir) |
| 890 | else: |
| 891 | local_branch = branch |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 892 | |
David James | e3b0606 | 2013-11-09 18:52:02 -0800 | [diff] [blame] | 893 | if local_branch and git.DoesLocalBranchExist(project_dir, local_branch): |
| 894 | verified_patches.append('%s:%s' % (project, local_branch)) |
| 895 | ok = True |
| 896 | |
| 897 | if not ok: |
| 898 | if branch: |
| 899 | cros_build_lib.Die('Project %s does not have branch %s' |
| 900 | % (project, branch)) |
| 901 | else: |
| 902 | cros_build_lib.Die('Project %s is not on a branch!' % (project,)) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 903 | |
Ryan Cui | cedd8a5 | 2012-03-22 02:28:35 -0700 | [diff] [blame] | 904 | return verified_patches |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 905 | |
| 906 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 907 | def _CheckChromeVersionOption(_option, _opt_str, value, parser): |
| 908 | """Upgrade other options based on chrome_version being passed.""" |
| 909 | value = value.strip() |
| 910 | |
| 911 | if parser.values.chrome_rev is None and value: |
| 912 | parser.values.chrome_rev = constants.CHROME_REV_SPEC |
| 913 | |
| 914 | parser.values.chrome_version = value |
| 915 | |
| 916 | |
| 917 | def _CheckChromeRootOption(_option, _opt_str, value, parser): |
| 918 | """Validate and convert chrome_root to full-path form.""" |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 919 | if parser.values.chrome_rev is None: |
| 920 | parser.values.chrome_rev = constants.CHROME_REV_LOCAL |
| 921 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 922 | parser.values.chrome_root = value |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 923 | |
| 924 | |
| 925 | def _CheckChromeRevOption(_option, _opt_str, value, parser): |
| 926 | """Validate the chrome_rev option.""" |
| 927 | value = value.strip() |
| 928 | if value not in constants.VALID_CHROME_REVISIONS: |
| 929 | raise optparse.OptionValueError('Invalid chrome rev specified') |
| 930 | |
| 931 | parser.values.chrome_rev = value |
| 932 | |
| 933 | |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 934 | def FindCacheDir(_parser, _options): |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 935 | return None |
| 936 | |
| 937 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 938 | class CustomGroup(optparse.OptionGroup): |
Aviv Keshet | 9e4236b | 2013-12-13 13:07:50 -0800 | [diff] [blame] | 939 | """Custom option group which supports arguments passed-through to trybot.""" |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 940 | def add_remote_option(self, *args, **kwargs): |
| 941 | """For arguments that are passed-through to remote trybot.""" |
| 942 | return optparse.OptionGroup.add_option(self, *args, |
| 943 | remote_pass_through=True, |
| 944 | **kwargs) |
| 945 | |
| 946 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 947 | class CustomOption(commandline.FilteringOption): |
| 948 | """Subclass FilteringOption class to implement pass-through and api.""" |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 949 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 950 | ACTIONS = commandline.FilteringOption.ACTIONS + ('extend',) |
| 951 | STORE_ACTIONS = commandline.FilteringOption.STORE_ACTIONS + ('extend',) |
| 952 | TYPED_ACTIONS = commandline.FilteringOption.TYPED_ACTIONS + ('extend',) |
| 953 | ALWAYS_TYPED_ACTIONS = (commandline.FilteringOption.ALWAYS_TYPED_ACTIONS + |
| 954 | ('extend',)) |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 955 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 956 | def __init__(self, *args, **kwargs): |
| 957 | # The remote_pass_through argument specifies whether we should directly |
| 958 | # pass the argument (with its value) onto the remote trybot. |
| 959 | self.pass_through = kwargs.pop('remote_pass_through', False) |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 960 | self.api_version = int(kwargs.pop('api', '0')) |
| 961 | commandline.FilteringOption.__init__(self, *args, **kwargs) |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 962 | |
| 963 | def take_action(self, action, dest, opt, value, values, parser): |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 964 | if action == 'extend': |
Mike Frysinger | d6925b5 | 2012-07-16 16:11:00 -0400 | [diff] [blame] | 965 | # If there is extra spaces between each argument, we get '' which later |
| 966 | # code barfs on, so skip those. e.g. We see this with the forms: |
| 967 | # cbuildbot -p 'proj:branch ' ... |
| 968 | # cbuildbot -p ' proj:branch' ... |
| 969 | # cbuildbot -p 'proj:branch proj2:branch' ... |
| 970 | lvalue = value.split() |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 971 | values.ensure_value(dest, []).extend(lvalue) |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 972 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 973 | commandline.FilteringOption.take_action( |
| 974 | self, action, dest, opt, value, values, parser) |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 975 | |
| 976 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 977 | class CustomParser(commandline.FilteringParser): |
Aviv Keshet | 9e4236b | 2013-12-13 13:07:50 -0800 | [diff] [blame] | 978 | """Custom option parser which supports arguments passed-trhough to trybot""" |
Matt Tennant | e817904 | 2013-10-01 15:47:32 -0700 | [diff] [blame] | 979 | |
Brian Harring | b6cf914 | 2012-09-01 20:43:17 -0700 | [diff] [blame] | 980 | DEFAULT_OPTION_CLASS = CustomOption |
| 981 | |
| 982 | def add_remote_option(self, *args, **kwargs): |
| 983 | """For arguments that are passed-through to remote trybot.""" |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 984 | return self.add_option(*args, remote_pass_through=True, **kwargs) |
Brian Harring | b6cf914 | 2012-09-01 20:43:17 -0700 | [diff] [blame] | 985 | |
| 986 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 987 | def _CreateParser(): |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 988 | """Generate and return the parser with all the options.""" |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 989 | # Parse options |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 990 | usage = "usage: %prog [options] buildbot_config [buildbot_config ...]" |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 991 | parser = CustomParser(usage=usage, caching=FindCacheDir) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 992 | |
| 993 | # Main options |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 994 | parser.add_option('-l', '--list', action='store_true', dest='list', |
| 995 | default=False, |
| 996 | help='List the suggested trybot configs to use (see --all)') |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 997 | parser.add_option('-a', '--all', action='store_true', dest='print_all', |
| 998 | default=False, |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 999 | help='List all of the buildbot configs available w/--list') |
| 1000 | |
| 1001 | parser.add_option('--local', default=False, action='store_true', |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1002 | help='Specifies that this tryjob should be run locally. ' |
| 1003 | 'Implies --debug.') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1004 | parser.add_option('--remote', default=False, action='store_true', |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1005 | help='Specifies that this tryjob should be run remotely.') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1006 | |
Ryan Cui | e1e4e66 | 2012-05-21 16:39:46 -0700 | [diff] [blame] | 1007 | parser.add_remote_option('-b', '--branch', |
| 1008 | help='The manifest branch to test. The branch to ' |
| 1009 | 'check the buildroot out to.') |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 1010 | parser.add_option('-r', '--buildroot', dest='buildroot', type='path', |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1011 | help='Root directory where source is checked out to, and ' |
| 1012 | 'where the build occurs. For external build configs, ' |
| 1013 | "defaults to 'trybot' directory at top level of your " |
| 1014 | 'repo-managed checkout.') |
| 1015 | parser.add_remote_option('--chrome_rev', default=None, type='string', |
| 1016 | action='callback', dest='chrome_rev', |
| 1017 | callback=_CheckChromeRevOption, |
| 1018 | help=('Revision of Chrome to use, of type [%s]' |
| 1019 | % '|'.join(constants.VALID_CHROME_REVISIONS))) |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1020 | parser.add_remote_option('--profile', default=None, type='string', |
| 1021 | action='store', dest='profile', |
| 1022 | help='Name of profile to sub-specify board variant.') |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1023 | |
Ryan Cui | f4f84be | 2012-07-09 18:50:41 -0700 | [diff] [blame] | 1024 | # |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1025 | # Patch selection options. |
| 1026 | # |
| 1027 | |
| 1028 | group = CustomGroup( |
| 1029 | parser, |
| 1030 | 'Patch Options') |
| 1031 | |
| 1032 | group.add_remote_option('-g', '--gerrit-patches', action='extend', |
| 1033 | default=[], type='string', |
| 1034 | metavar="'Id1 *int_Id2...IdN'", |
| 1035 | help="Space-separated list of short-form Gerrit " |
| 1036 | "Change-Id's or change numbers to patch. " |
| 1037 | "Please prepend '*' to internal Change-Id's") |
| 1038 | group.add_remote_option('-G', '--rietveld-patches', action='extend', |
| 1039 | default=[], type='string', |
| 1040 | metavar="'id1[:subdir1]...idN[:subdirN]'", |
| 1041 | help='Space-separated list of short-form Rietveld ' |
| 1042 | 'issue numbers to patch. If no subdir is ' |
| 1043 | 'specified, the src directory is used.') |
| 1044 | group.add_option('-p', '--local-patches', action='extend', default=[], |
| 1045 | metavar="'<project1>[:<branch1>]...<projectN>[:<branchN>]'", |
| 1046 | help='Space-separated list of project branches with ' |
| 1047 | 'patches to apply. Projects are specified by name. ' |
| 1048 | 'If no branch is specified the current branch of the ' |
| 1049 | 'project will be used.') |
| 1050 | |
| 1051 | parser.add_option_group(group) |
| 1052 | |
| 1053 | # |
| 1054 | # Remote trybot options. |
| 1055 | # |
| 1056 | |
| 1057 | group = CustomGroup( |
| 1058 | parser, |
| 1059 | 'Remote Trybot Options (--remote)') |
| 1060 | |
| 1061 | group.add_remote_option('--hwtest', dest='hwtest', action='store_true', |
| 1062 | default=False, |
| 1063 | help='Run the HWTest stage (tests on real hardware)') |
| 1064 | group.add_option('--remote-description', default=None, |
| 1065 | help='Attach an optional description to a --remote run ' |
| 1066 | 'to make it easier to identify the results when it ' |
| 1067 | 'finishes') |
| 1068 | group.add_option('--slaves', action='extend', default=[], |
| 1069 | help='Specify specific remote tryslaves to run on (e.g. ' |
| 1070 | 'build149-m2); if the bot is busy, it will be queued') |
| 1071 | group.add_option('--test-tryjob', action='store_true', |
| 1072 | default=False, |
| 1073 | help='Submit a tryjob to the test repository. Will not ' |
| 1074 | 'show up on the production trybot waterfall.') |
| 1075 | |
| 1076 | parser.add_option_group(group) |
| 1077 | |
| 1078 | # |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1079 | # Branch creation options. |
| 1080 | # |
| 1081 | |
| 1082 | group = CustomGroup( |
| 1083 | parser, |
| 1084 | 'Branch Creation Options (used with branch-util)') |
| 1085 | |
| 1086 | group.add_remote_option('--branch-name', |
| 1087 | help='The branch to create or delete.') |
| 1088 | group.add_remote_option('--delete-branch', default=False, action='store_true', |
| 1089 | help='Delete the branch specified in --branch-name.') |
| 1090 | group.add_remote_option('--rename-to', type='string', |
| 1091 | help='Rename a branch to the specified name.') |
| 1092 | group.add_remote_option('--force-create', default=False, action='store_true', |
| 1093 | help='Overwrites an existing branch.') |
| 1094 | |
| 1095 | parser.add_option_group(group) |
| 1096 | |
| 1097 | # |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1098 | # Advanced options. |
Ryan Cui | f4f84be | 2012-07-09 18:50:41 -0700 | [diff] [blame] | 1099 | # |
| 1100 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1101 | group = CustomGroup( |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1102 | parser, |
| 1103 | 'Advanced Options', |
| 1104 | 'Caution: use these options at your own risk.') |
| 1105 | |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1106 | group.add_remote_option('--bootstrap-args', action='append', default=[], |
| 1107 | help='Args passed directly to the bootstrap re-exec ' |
| 1108 | 'to skip verification by the bootstrap code') |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1109 | group.add_remote_option('--buildbot', dest='buildbot', action='store_true', |
| 1110 | default=False, help='This is running on a buildbot') |
| 1111 | group.add_remote_option('--buildnumber', help='build number', type='int', |
| 1112 | default=0) |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 1113 | group.add_option('--chrome_root', default=None, type='path', |
| 1114 | action='callback', callback=_CheckChromeRootOption, |
| 1115 | dest='chrome_root', help='Local checkout of Chrome to use.') |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1116 | group.add_remote_option('--chrome_version', default=None, type='string', |
| 1117 | action='callback', dest='chrome_version', |
| 1118 | callback=_CheckChromeVersionOption, |
| 1119 | help='Used with SPEC logic to force a particular SVN ' |
| 1120 | 'revision of chrome rather than the latest.') |
| 1121 | group.add_remote_option('--clobber', action='store_true', dest='clobber', |
| 1122 | default=False, |
| 1123 | help='Clears an old checkout before syncing') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1124 | group.add_remote_option('--latest-toolchain', action='store_true', |
| 1125 | default=False, |
| 1126 | help='Use the latest toolchain.') |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 1127 | parser.add_option('--log_dir', dest='log_dir', type='path', |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1128 | help=('Directory where logs are stored.')) |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1129 | group.add_remote_option('--maxarchives', dest='max_archive_builds', |
| 1130 | default=3, type='int', |
| 1131 | help="Change the local saved build count limit.") |
Ryan Cui | bbd3d4b | 2012-08-17 12:20:37 -0700 | [diff] [blame] | 1132 | parser.add_remote_option('--manifest-repo-url', |
| 1133 | help=('Overrides the default manifest repo url.')) |
David James | 565bc9a | 2013-04-08 14:54:45 -0700 | [diff] [blame] | 1134 | group.add_remote_option('--compilecheck', action='store_true', default=False, |
| 1135 | help='Only verify compilation and unit tests.') |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1136 | group.add_remote_option('--noarchive', action='store_false', dest='archive', |
| 1137 | default=True, help="Don't run archive stage.") |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 1138 | group.add_remote_option('--nobootstrap', action='store_false', |
| 1139 | dest='bootstrap', default=True, |
| 1140 | help="Don't checkout and run from a standalone " |
| 1141 | "chromite repo.") |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1142 | group.add_remote_option('--nobuild', action='store_false', dest='build', |
| 1143 | default=True, |
| 1144 | help="Don't actually build (for cbuildbot dev)") |
| 1145 | group.add_remote_option('--noclean', action='store_false', dest='clean', |
| 1146 | default=True, help="Don't clean the buildroot") |
Ryan Cui | f7f2469 | 2012-05-18 16:35:33 -0700 | [diff] [blame] | 1147 | group.add_remote_option('--nocgroups', action='store_false', dest='cgroups', |
| 1148 | default=True, |
| 1149 | help='Disable cbuildbots usage of cgroups.') |
Ryan Cui | 3ea98e0 | 2013-08-07 16:01:48 -0700 | [diff] [blame] | 1150 | group.add_remote_option('--nochromesdk', action='store_false', |
| 1151 | dest='chrome_sdk', default=True, |
| 1152 | help="Don't run the ChromeSDK stage which builds " |
| 1153 | "Chrome outside of the chroot.") |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1154 | group.add_remote_option('--noprebuilts', action='store_false', |
| 1155 | dest='prebuilts', default=True, |
| 1156 | help="Don't upload prebuilts.") |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1157 | group.add_remote_option('--nopatch', action='store_false', |
| 1158 | dest='postsync_patch', default=True, |
| 1159 | help=("Don't run PatchChanges stage. This does not " |
| 1160 | "disable patching in of chromite patches " |
| 1161 | "during BootstrapStage.")) |
Don Garrett | 82c0ae8 | 2014-02-03 18:25:11 -0800 | [diff] [blame] | 1162 | group.add_remote_option('--nopaygen', action='store_false', |
| 1163 | dest='paygen', default=True, |
| 1164 | help="Don't generate payloads.") |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1165 | group.add_remote_option('--noreexec', action='store_false', |
| 1166 | dest='postsync_reexec', default=True, |
| 1167 | help="Don't reexec into the buildroot after syncing.") |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1168 | group.add_remote_option('--nosdk', action='store_true', |
| 1169 | default=False, |
| 1170 | help='Re-create the SDK from scratch.') |
Don Garrett | 7604d6a | 2014-01-15 14:45:39 -0800 | [diff] [blame] | 1171 | group.add_remote_option('--nosigner-results', action='store_false', |
| 1172 | dest='signer_results', default=True, |
| 1173 | help="Don't display signing results.") |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1174 | group.add_remote_option('--nosync', action='store_false', dest='sync', |
| 1175 | default=True, help="Don't sync before building.") |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1176 | group.add_remote_option('--notests', action='store_false', dest='tests', |
| 1177 | default=True, |
| 1178 | help='Override values from buildconfig and run no ' |
| 1179 | 'tests.') |
| 1180 | group.add_remote_option('--nouprev', action='store_false', dest='uprev', |
| 1181 | default=True, |
| 1182 | help='Override values from buildconfig and never ' |
| 1183 | 'uprev.') |
David James | dac7a91 | 2013-11-18 11:14:44 -0800 | [diff] [blame] | 1184 | group.add_option('--reference-repo', action='store', default=None, |
| 1185 | dest='reference_repo', |
| 1186 | help='Reuse git data stored in an existing repo ' |
| 1187 | 'checkout. This can drastically reduce the network ' |
| 1188 | 'time spent setting up the trybot checkout. By ' |
| 1189 | "default, if this option isn't given but cbuildbot " |
| 1190 | 'is invoked from a repo checkout, cbuildbot will ' |
| 1191 | 'use the repo root.') |
Ryan Cui | cedd8a5 | 2012-03-22 02:28:35 -0700 | [diff] [blame] | 1192 | group.add_option('--resume', action='store_true', default=False, |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1193 | help='Skip stages already successfully completed.') |
| 1194 | group.add_remote_option('--timeout', action='store', type='int', default=0, |
| 1195 | help='Specify the maximum amount of time this job ' |
| 1196 | 'can run for, at which point the build will be ' |
| 1197 | 'aborted. If set to zero, then there is no ' |
| 1198 | 'timeout.') |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1199 | group.add_remote_option('--version', dest='force_version', default=None, |
| 1200 | help='Used with manifest logic. Forces use of this ' |
Aviv Keshet | c2c123d | 2013-10-14 18:06:12 -0400 | [diff] [blame] | 1201 | 'version rather than create or get latest. ' |
| 1202 | 'Examples: 4815.0.0-rc1, 4815.1.2') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1203 | |
| 1204 | parser.add_option_group(group) |
| 1205 | |
| 1206 | # |
| 1207 | # Internal options. |
| 1208 | # |
| 1209 | |
| 1210 | group = CustomGroup( |
| 1211 | parser, |
Mike Frysinger | 34db869 | 2013-11-11 14:54:08 -0500 | [diff] [blame] | 1212 | 'Internal Chromium OS Build Team Options', |
| 1213 | 'Caution: these are for meant for the Chromium OS build team only') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1214 | |
| 1215 | group.add_remote_option('--archive-base', type='gs_path', |
| 1216 | help='Base GS URL (gs://<bucket_name>/<path>) to ' |
| 1217 | 'upload archive artifacts to') |
Brian Harring | ab8fb5c | 2012-07-18 11:28:22 -0700 | [diff] [blame] | 1218 | group.add_remote_option('--cq-gerrit-query', dest='cq_gerrit_override', |
| 1219 | default=None, |
| 1220 | help= |
| 1221 | "If given, this gerrit query will be used to find what patches to test, " |
Aviv Keshet | efd6bbf | 2013-12-12 13:36:57 -0800 | [diff] [blame] | 1222 | "rather than the normal 'CommitQueue>=1 AND Verified=1 AND CodeReview=2' " |
Brian Harring | ab8fb5c | 2012-07-18 11:28:22 -0700 | [diff] [blame] | 1223 | "query it defaults to. Use with care- note additionally this setting " |
| 1224 | "only has an effect if the buildbot target is a cq target, and we're " |
| 1225 | "in buildbot mode.") |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1226 | group.add_option('--pass-through', dest='pass_through_args', action='append', |
| 1227 | type='string', default=[]) |
David James | f421c6d | 2013-04-11 15:37:57 -0700 | [diff] [blame] | 1228 | group.add_remote_option('--pre-cq', action='store_true', default=False, |
| 1229 | help='Mark CLs as tested by the PreCQ on success.') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1230 | group.add_option('--reexec-api-version', dest='output_api_version', |
Ryan Cui | f4f84be | 2012-07-09 18:50:41 -0700 | [diff] [blame] | 1231 | action='store_true', default=False, |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1232 | help='Used for handling forwards/backwards compatibility ' |
| 1233 | 'with --resume and --bootstrap') |
| 1234 | group.add_option('--remote-trybot', dest='remote_trybot', |
| 1235 | action='store_true', default=False, |
| 1236 | help='Indicates this is running on a remote trybot machine') |
| 1237 | group.add_remote_option('--remote-patches', action='extend', default=[], |
| 1238 | help='Patches uploaded by the trybot client when run ' |
| 1239 | 'using the -p option') |
Brian Harring | f611e6e | 2012-07-17 18:47:44 -0700 | [diff] [blame] | 1240 | # Note the default here needs to be hardcoded to 3; that is the last version |
| 1241 | # that lacked this functionality. |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1242 | group.add_option('--remote-version', default=3, type=int, action='store', |
| 1243 | help='Used for compatibility checks w/tryjobs running in ' |
| 1244 | 'older chromite instances') |
| 1245 | group.add_option('--sourceroot', type='path', default=constants.SOURCE_ROOT) |
| 1246 | group.add_remote_option('--test-bootstrap', action='store_true', |
| 1247 | default=False, |
| 1248 | help='Causes cbuildbot to bootstrap itself twice, in ' |
| 1249 | 'the sequence A->B->C: A(unpatched) patches and ' |
| 1250 | 'bootstraps B; B patches and bootstraps C') |
| 1251 | group.add_remote_option('--validation_pool', default=None, |
| 1252 | help='Path to a pickled validation pool. Intended ' |
| 1253 | 'for use only with the commit queue.') |
Aviv Keshet | a0159be | 2013-12-12 13:56:28 -0800 | [diff] [blame] | 1254 | group.add_remote_option('--mock-tree-status', dest='mock_tree_status', |
| 1255 | default=None, action='store', |
| 1256 | help='Override the tree status value that would be ' |
| 1257 | 'returned from the the actual tree. Example ' |
| 1258 | 'values: open, closed, throttled. When used ' |
| 1259 | 'in conjunction with --debug, the tree status ' |
| 1260 | 'will not be ignored as it usually is in a ' |
| 1261 | '--debug run.') |
Aviv Keshet | cf9c272 | 2014-02-25 15:15:10 -0800 | [diff] [blame] | 1262 | group.add_remote_option('--mock-slave-status', dest='mock_slave_status', |
| 1263 | default=None, action='store', |
| 1264 | metavar='MOCK_SLAVE_STATUS_PICKLE_FILE', |
| 1265 | help='Override the result of the _FetchSlaveStatuses ' |
| 1266 | 'method of MasterSlaveSyncCompletionStage, by ' |
| 1267 | 'specifying a file with a pickle of the result ' |
| 1268 | 'to be returned.') |
Mike Frysinger | 81af6ef | 2013-04-03 02:24:09 -0400 | [diff] [blame] | 1269 | |
| 1270 | parser.add_option_group(group) |
Ryan Cui | f4f84be | 2012-07-09 18:50:41 -0700 | [diff] [blame] | 1271 | |
| 1272 | # |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1273 | # Debug options |
Ryan Cui | f4f84be | 2012-07-09 18:50:41 -0700 | [diff] [blame] | 1274 | # |
Brian Harring | fec89fe | 2012-09-23 07:30:54 -0700 | [diff] [blame] | 1275 | # Temporary hack; in place till --dry-run replaces --debug. |
| 1276 | # pylint: disable=W0212 |
Brian Harring | 009db50 | 2012-10-10 02:21:37 -0700 | [diff] [blame] | 1277 | group = parser.debug_group |
Brian Harring | fec89fe | 2012-09-23 07:30:54 -0700 | [diff] [blame] | 1278 | debug = [x for x in group.option_list if x._long_opts == ['--debug']][0] |
| 1279 | debug.help += " Currently functions as --dry-run in addition." |
| 1280 | debug.pass_through = True |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1281 | group.add_option('--notee', action='store_false', dest='tee', default=True, |
| 1282 | help="Disable logging and internal tee process. Primarily " |
| 1283 | "used for debugging cbuildbot itself.") |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1284 | return parser |
| 1285 | |
| 1286 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1287 | def _FinishParsing(options, args): |
| 1288 | """Perform some parsing tasks that need to take place after optparse. |
| 1289 | |
| 1290 | This function needs to be easily testable! Keep it free of |
| 1291 | environment-dependent code. Put more detailed usage validation in |
| 1292 | _PostParseCheck(). |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1293 | |
| 1294 | Args: |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 1295 | options: The options object returned by optparse |
| 1296 | args: The args object returned by optparse |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1297 | """ |
Ryan Cui | 41023d9 | 2012-11-13 19:59:50 -0800 | [diff] [blame] | 1298 | # Populate options.pass_through_args. |
| 1299 | accepted, _ = commandline.FilteringParser.FilterArgs( |
| 1300 | options.parsed_args, lambda x: x.opt_inst.pass_through) |
| 1301 | options.pass_through_args.extend(accepted) |
Brian Harring | 07039b5 | 2012-05-13 17:56:47 -0700 | [diff] [blame] | 1302 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1303 | if options.chrome_root: |
| 1304 | if options.chrome_rev != constants.CHROME_REV_LOCAL: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1305 | cros_build_lib.Die('Chrome rev must be %s if chrome_root is set.' % |
| 1306 | constants.CHROME_REV_LOCAL) |
David James | a0a664e | 2013-02-13 09:52:01 -0800 | [diff] [blame] | 1307 | elif options.chrome_rev == constants.CHROME_REV_LOCAL: |
| 1308 | cros_build_lib.Die('Chrome root must be set if chrome_rev is %s.' % |
| 1309 | constants.CHROME_REV_LOCAL) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1310 | |
| 1311 | if options.chrome_version: |
| 1312 | if options.chrome_rev != constants.CHROME_REV_SPEC: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1313 | cros_build_lib.Die('Chrome rev must be %s if chrome_version is set.' % |
| 1314 | constants.CHROME_REV_SPEC) |
David James | a0a664e | 2013-02-13 09:52:01 -0800 | [diff] [blame] | 1315 | elif options.chrome_rev == constants.CHROME_REV_SPEC: |
| 1316 | cros_build_lib.Die( |
| 1317 | 'Chrome rev must not be %s if chrome_version is not set.' |
| 1318 | % constants.CHROME_REV_SPEC) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1319 | |
David James | 9e27e66 | 2013-02-14 13:42:43 -0800 | [diff] [blame] | 1320 | patches = bool(options.gerrit_patches or options.local_patches or |
| 1321 | options.rietveld_patches) |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1322 | if options.remote: |
| 1323 | if options.local: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1324 | cros_build_lib.Die('Cannot specify both --remote and --local') |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 1325 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1326 | if not options.buildbot and not patches: |
Gaurav Shah | ed0399e | 2014-02-03 13:36:22 -0800 | [diff] [blame] | 1327 | prompt = ('No patches were provided; are you sure you want to just ' |
| 1328 | 'run a remote build of %s?' % ( |
| 1329 | options.branch if options.branch else 'ToT')) |
| 1330 | if not cros_build_lib.BooleanPrompt(prompt=prompt, default=False): |
Brian Harring | 7cc4b93 | 2012-11-01 16:58:55 -0700 | [diff] [blame] | 1331 | cros_build_lib.Die('Must provide patches when running with --remote.') |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1332 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1333 | # --debug needs to be explicitly passed through for remote invocations. |
| 1334 | release_mode_with_patches = (options.buildbot and patches and |
| 1335 | '--debug' not in options.pass_through_args) |
| 1336 | else: |
| 1337 | if len(args) > 1: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1338 | cros_build_lib.Die('Multiple configs not supported if not running with ' |
Brian Harring | f1aad83 | 2012-07-18 10:46:39 -0700 | [diff] [blame] | 1339 | '--remote. Got %r', args) |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1340 | |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 1341 | if options.slaves: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1342 | cros_build_lib.Die('Cannot use --slaves if not running with --remote.') |
Ryan Cui | 79319ab | 2012-05-21 12:59:18 -0700 | [diff] [blame] | 1343 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1344 | release_mode_with_patches = (options.buildbot and patches and |
| 1345 | not options.debug) |
| 1346 | |
David James | 5734ea3 | 2012-08-15 20:23:49 -0700 | [diff] [blame] | 1347 | # When running in release mode, make sure we are running with checked-in code. |
| 1348 | # We want checked-in cbuildbot/scripts to prevent errors, and we want to build |
| 1349 | # a release image with checked-in code for CrOS packages. |
| 1350 | if release_mode_with_patches: |
| 1351 | cros_build_lib.Die( |
| 1352 | 'Cannot provide patches when running with --buildbot!') |
| 1353 | |
Ryan Cui | ba41ad3 | 2012-03-08 17:15:29 -0800 | [diff] [blame] | 1354 | if options.buildbot and options.remote_trybot: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1355 | cros_build_lib.Die( |
| 1356 | '--buildbot and --remote-trybot cannot be used together.') |
Ryan Cui | ba41ad3 | 2012-03-08 17:15:29 -0800 | [diff] [blame] | 1357 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1358 | # Record whether --debug was set explicitly vs. it was inferred. |
| 1359 | options.debug_forced = False |
| 1360 | if options.debug: |
| 1361 | options.debug_forced = True |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1362 | if not options.debug: |
Ryan Cui | 16ca581 | 2012-03-08 20:34:27 -0800 | [diff] [blame] | 1363 | # We don't set debug by default for |
| 1364 | # 1. --buildbot invocations. |
| 1365 | # 2. --remote invocations, because it needs to push changes to the tryjob |
| 1366 | # repo. |
| 1367 | options.debug = not options.buildbot and not options.remote |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1368 | |
Ryan Cui | 1c13a25 | 2012-10-16 15:00:16 -0700 | [diff] [blame] | 1369 | # Record the configs targeted. |
| 1370 | options.build_targets = args[:] |
| 1371 | |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1372 | if constants.BRANCH_UTIL_CONFIG in options.build_targets: |
Ryan Cui | 7bd8db6 | 2013-08-08 16:29:51 -0700 | [diff] [blame] | 1373 | if options.remote: |
| 1374 | cros_build_lib.Die( |
Matt Tennant | a130ea3 | 2013-12-19 09:38:39 -0800 | [diff] [blame] | 1375 | 'Running %s as a remote tryjob is not yet supported.', |
| 1376 | constants.BRANCH_UTIL_CONFIG) |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1377 | if len(options.build_targets) > 1: |
| 1378 | cros_build_lib.Die( |
Matt Tennant | a130ea3 | 2013-12-19 09:38:39 -0800 | [diff] [blame] | 1379 | 'Cannot run %s with any other configs.', |
| 1380 | constants.BRANCH_UTIL_CONFIG) |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1381 | if not options.branch_name: |
| 1382 | cros_build_lib.Die( |
Matt Tennant | a130ea3 | 2013-12-19 09:38:39 -0800 | [diff] [blame] | 1383 | 'Must specify --branch-name with the %s config.', |
| 1384 | constants.BRANCH_UTIL_CONFIG) |
| 1385 | if options.branch and options.branch != options.branch_name: |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1386 | cros_build_lib.Die( |
Matt Tennant | a130ea3 | 2013-12-19 09:38:39 -0800 | [diff] [blame] | 1387 | 'If --branch is specified with the %s config, it must' |
| 1388 | ' have the same value as --branch-name.', |
| 1389 | constants.BRANCH_UTIL_CONFIG) |
| 1390 | |
| 1391 | exclusive_opts = {'--version': options.force_version, |
| 1392 | '--delete-branch': options.delete_branch, |
| 1393 | '--rename-to': options.rename_to, |
| 1394 | } |
| 1395 | if 1 != sum(1 for x in exclusive_opts.values() if x): |
| 1396 | cros_build_lib.Die('When using the %s config, you must' |
| 1397 | ' specifiy one and only one of the following' |
| 1398 | ' options: %s.', constants.BRANCH_UTIL_CONFIG, |
| 1399 | ', '.join(exclusive_opts.keys())) |
| 1400 | |
| 1401 | # When deleting or renaming a branch, the --branch and --nobootstrap |
| 1402 | # options are implied. |
| 1403 | if options.delete_branch or options.rename_to: |
| 1404 | if not options.branch: |
| 1405 | cros_build_lib.Info('Automatically enabling sync to branch %s' |
| 1406 | ' for this %s flow.', options.branch_name, |
| 1407 | constants.BRANCH_UTIL_CONFIG) |
| 1408 | options.branch = options.branch_name |
| 1409 | if options.bootstrap: |
| 1410 | cros_build_lib.Info('Automatically disabling bootstrap step for' |
| 1411 | ' this %s flow.', constants.BRANCH_UTIL_CONFIG) |
| 1412 | options.bootstrap = False |
| 1413 | |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1414 | elif any([options.delete_branch, options.rename_to, options.branch_name]): |
| 1415 | cros_build_lib.Die( |
| 1416 | 'Cannot specify --delete-branch, --rename-to or --branch-name when not ' |
| 1417 | 'running the %s config', constants.BRANCH_UTIL_CONFIG) |
| 1418 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1419 | |
Brian Harring | 1d7ba94 | 2012-04-24 06:37:18 -0700 | [diff] [blame] | 1420 | # pylint: disable=W0613 |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1421 | def _PostParseCheck(parser, options, args): |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1422 | """Perform some usage validation after we've parsed the arguments |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1423 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1424 | Args: |
Aviv Keshet | 9e4236b | 2013-12-13 13:07:50 -0800 | [diff] [blame] | 1425 | parser: Option parser that was used to parse arguments. |
| 1426 | options: The options returned by optparse. |
| 1427 | args: The args returned by optparse. |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1428 | """ |
Ryan Cui | e1e4e66 | 2012-05-21 16:39:46 -0700 | [diff] [blame] | 1429 | if not options.branch: |
David James | 97d9587 | 2012-11-16 15:09:56 -0800 | [diff] [blame] | 1430 | options.branch = git.GetChromiteTrackingBranch() |
Ryan Cui | e1e4e66 | 2012-05-21 16:39:46 -0700 | [diff] [blame] | 1431 | |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1432 | if not repository.IsARepoRoot(options.sourceroot): |
| 1433 | if options.local_patches: |
| 1434 | raise Exception('Could not find repo checkout at %s!' |
| 1435 | % options.sourceroot) |
| 1436 | |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 1437 | # Because the default cache dir depends on other options, FindCacheDir |
| 1438 | # always returns None, and we setup the default here. |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1439 | if options.cache_dir is None: |
| 1440 | # Note, options.sourceroot is set regardless of the path |
| 1441 | # actually existing. |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 1442 | if options.buildroot is not None: |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1443 | options.cache_dir = os.path.join(options.buildroot, '.cache') |
David James | ac8c2a7 | 2013-02-13 18:44:33 -0800 | [diff] [blame] | 1444 | elif os.path.exists(options.sourceroot): |
| 1445 | options.cache_dir = os.path.join(options.sourceroot, '.cache') |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1446 | else: |
| 1447 | options.cache_dir = parser.FindCacheDir(parser, options) |
| 1448 | options.cache_dir = os.path.abspath(options.cache_dir) |
Brian Harring | 8c1d7b1 | 2012-10-04 17:36:32 -0700 | [diff] [blame] | 1449 | parser.ConfigureCacheDir(options.cache_dir) |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1450 | |
Yu-Ju Hong | 2c06676 | 2013-10-28 14:05:08 -0700 | [diff] [blame] | 1451 | osutils.SafeMakedirsNonRoot(options.cache_dir) |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 1452 | |
Brian Harring | 609dc4e | 2012-05-07 02:17:44 -0700 | [diff] [blame] | 1453 | if options.local_patches: |
Brian Harring | 1d7ba94 | 2012-04-24 06:37:18 -0700 | [diff] [blame] | 1454 | options.local_patches = _CheckLocalPatches( |
Brian Harring | 609dc4e | 2012-05-07 02:17:44 -0700 | [diff] [blame] | 1455 | options.sourceroot, options.local_patches) |
Brian Harring | 1d7ba94 | 2012-04-24 06:37:18 -0700 | [diff] [blame] | 1456 | |
| 1457 | default = os.environ.get('CBUILDBOT_DEFAULT_MODE') |
| 1458 | if (default and not any([options.local, options.buildbot, |
| 1459 | options.remote, options.remote_trybot])): |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1460 | cros_build_lib.Info("CBUILDBOT_DEFAULT_MODE=%s env var detected, using it." |
| 1461 | % default) |
Brian Harring | 1d7ba94 | 2012-04-24 06:37:18 -0700 | [diff] [blame] | 1462 | default = default.lower() |
| 1463 | if default == 'local': |
| 1464 | options.local = True |
| 1465 | elif default == 'remote': |
| 1466 | options.remote = True |
| 1467 | elif default == 'buildbot': |
| 1468 | options.buildbot = True |
| 1469 | else: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1470 | cros_build_lib.Die("CBUILDBOT_DEFAULT_MODE value %s isn't supported. " |
| 1471 | % default) |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1472 | |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1473 | # Ensure that all args are legitimate config targets. |
| 1474 | invalid_target = False |
| 1475 | for arg in args: |
Matt Tennant | 2c19203 | 2014-01-16 13:49:28 -0800 | [diff] [blame] | 1476 | build_config = _GetConfig(arg) |
| 1477 | if not build_config: |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1478 | cros_build_lib.Error('No such configuraton target: "%s".', arg) |
| 1479 | invalid_target = True |
| 1480 | |
Matt Tennant | 2c19203 | 2014-01-16 13:49:28 -0800 | [diff] [blame] | 1481 | # The --version option is not compatible with an external target unless the |
| 1482 | # --buildbot option is specified. More correctly, only "paladin versions" |
| 1483 | # will work with external targets, and those are only used with --buildbot. |
| 1484 | # If --buildbot is specified, then user should know what they are doing and |
| 1485 | # only specify a version that will work. See crbug.com/311648. |
| 1486 | elif options.force_version and not options.buildbot: |
| 1487 | if not build_config.internal: |
| 1488 | cros_build_lib.Die('Cannot specify --version without --buildbot for an' |
| 1489 | ' external target (%s).' % arg) |
| 1490 | |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1491 | if invalid_target: |
| 1492 | print 'Please specify one of:' |
| 1493 | _PrintValidConfigs() |
| 1494 | cros_build_lib.Die('One or more invalid configuration targets specified.') |
| 1495 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1496 | |
| 1497 | def _ParseCommandLine(parser, argv): |
| 1498 | """Completely parse the commandline arguments""" |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1499 | (options, args) = parser.parse_args(argv) |
Brian Harring | 37e559b | 2012-05-22 20:47:32 -0700 | [diff] [blame] | 1500 | |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1501 | # Strip out null arguments. |
| 1502 | # TODO(rcui): Remove when buildbot is fixed |
| 1503 | args = [arg for arg in args if arg] |
| 1504 | |
| 1505 | # A couple options, like --list, trigger a quick exit. |
Brian Harring | 37e559b | 2012-05-22 20:47:32 -0700 | [diff] [blame] | 1506 | if options.output_api_version: |
Ryan Cui | 724f1d3 | 2012-10-15 18:10:22 -0700 | [diff] [blame] | 1507 | print constants.REEXEC_API_VERSION |
Brian Harring | 37e559b | 2012-05-22 20:47:32 -0700 | [diff] [blame] | 1508 | sys.exit(0) |
| 1509 | |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 1510 | if options.list: |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1511 | if args: |
| 1512 | cros_build_lib.Die('No arguments expected with the --list options.') |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 1513 | _PrintValidConfigs(options.print_all) |
| 1514 | sys.exit(0) |
| 1515 | |
Ryan Cui | 8be1606 | 2012-04-24 12:05:26 -0700 | [diff] [blame] | 1516 | if not args: |
Matt Tennant | 763497d | 2014-01-17 16:45:54 -0800 | [diff] [blame] | 1517 | parser.error('Invalid usage: no configuration targets provided.' |
| 1518 | 'Use -h to see usage. Use -l to list supported configs.') |
Ryan Cui | 8be1606 | 2012-04-24 12:05:26 -0700 | [diff] [blame] | 1519 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1520 | _FinishParsing(options, args) |
| 1521 | return options, args |
| 1522 | |
| 1523 | |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 1524 | # TODO(build): This function is too damn long. |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1525 | def main(argv): |
David James | 59a0a2b | 2013-03-22 14:04:44 -0700 | [diff] [blame] | 1526 | # Turn on strict sudo checks. |
| 1527 | cros_build_lib.STRICT_SUDO = True |
| 1528 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1529 | # Set umask to 022 so files created by buildbot are readable. |
Mike Frysinger | 60ec101 | 2013-10-21 00:11:10 -0400 | [diff] [blame] | 1530 | os.umask(0o22) |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1531 | |
Ryan Cui | 8586797 | 2012-02-23 18:21:49 -0800 | [diff] [blame] | 1532 | parser = _CreateParser() |
| 1533 | (options, args) = _ParseCommandLine(parser, argv) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1534 | |
Brian Harring | ae0a532 | 2012-09-15 01:46:51 -0700 | [diff] [blame] | 1535 | _PostParseCheck(parser, options, args) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1536 | |
Mike Frysinger | 8fd67dc | 2012-12-03 23:51:18 -0500 | [diff] [blame] | 1537 | cros_build_lib.AssertOutsideChroot() |
Zdenek Behan | 98ec2fb | 2012-08-31 17:12:18 +0200 | [diff] [blame] | 1538 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1539 | if options.remote: |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1540 | cros_build_lib.logger.setLevel(logging.WARNING) |
Ryan Cui | 16ca581 | 2012-03-08 20:34:27 -0800 | [diff] [blame] | 1541 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1542 | # Verify configs are valid. |
Dan Shi | 0bdb713 | 2013-07-30 16:22:12 -0700 | [diff] [blame] | 1543 | # If hwtest flag is enabled, post a warning that HWTest step may fail if the |
| 1544 | # specified board is not a released platform or it is a generic overlay. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1545 | for bot in args: |
Aviv Keshet | a96a2a9 | 2013-02-05 17:21:51 -0800 | [diff] [blame] | 1546 | build_config = _GetConfig(bot) |
| 1547 | if options.hwtest: |
Dan Shi | 0bdb713 | 2013-07-30 16:22:12 -0700 | [diff] [blame] | 1548 | cros_build_lib.Warning( |
| 1549 | 'If %s is not a released platform or it is a generic overlay, ' |
| 1550 | 'the HWTest step will most likely not run; please ask the lab ' |
| 1551 | 'team for help if this is unexpected.' % build_config['boards']) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1552 | |
| 1553 | # Verify gerrit patches are valid. |
Ryan Cui | 16ca581 | 2012-03-08 20:34:27 -0800 | [diff] [blame] | 1554 | print 'Verifying patches...' |
Ryan Cui | e1e4e66 | 2012-05-21 16:39:46 -0700 | [diff] [blame] | 1555 | patch_pool = AcquirePoolFromOptions(options) |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 1556 | |
Ryan Cui | eaa9efd | 2012-04-25 17:56:45 -0700 | [diff] [blame] | 1557 | # --debug need to be explicitly passed through for remote invocations. |
| 1558 | if options.buildbot and '--debug' not in options.pass_through_args: |
| 1559 | _ConfirmRemoteBuildbotRun() |
| 1560 | |
Ryan Cui | 16ca581 | 2012-03-08 20:34:27 -0800 | [diff] [blame] | 1561 | print 'Submitting tryjob...' |
Ryan Cui | 16d9e1f | 2012-05-11 10:50:18 -0700 | [diff] [blame] | 1562 | tryjob = remote_try.RemoteTryJob(options, args, patch_pool.local_patches) |
Ryan Cui | a25d8eb | 2012-07-11 14:54:27 -0700 | [diff] [blame] | 1563 | tryjob.Submit(testjob=options.test_tryjob, dryrun=False) |
Ryan Cui | 16ca581 | 2012-03-08 20:34:27 -0800 | [diff] [blame] | 1564 | print 'Tryjob submitted!' |
| 1565 | print ('Go to %s to view the status of your job.' |
Ryan Cui | 4906e1c | 2012-04-03 20:09:34 -0700 | [diff] [blame] | 1566 | % tryjob.GetTrybotWaterfallLink()) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1567 | sys.exit(0) |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 1568 | |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 1569 | elif (not options.buildbot and not options.remote_trybot |
| 1570 | and not options.resume and not options.local): |
Ryan Cui | 88b901c | 2013-06-21 11:35:30 -0700 | [diff] [blame] | 1571 | options.local = True |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1572 | cros_build_lib.Warning( |
| 1573 | 'Running in LOCAL TRYBOT mode! Use --remote to submit REMOTE ' |
| 1574 | 'tryjobs. Use --local to suppress this message.') |
| 1575 | cros_build_lib.Warning( |
Ryan Cui | 5159135 | 2012-07-09 15:15:53 -0700 | [diff] [blame] | 1576 | 'In the future, --local will be required to run the local ' |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1577 | 'trybot.') |
Ryan Cui | 54da070 | 2012-04-19 18:38:08 -0700 | [diff] [blame] | 1578 | time.sleep(5) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1579 | |
Matt Tennant | 759e235 | 2013-09-27 15:14:44 -0700 | [diff] [blame] | 1580 | # Only one config arg is allowed in this mode, which was confirmed earlier. |
Ryan Cui | 8be1606 | 2012-04-24 12:05:26 -0700 | [diff] [blame] | 1581 | bot_id = args[-1] |
| 1582 | build_config = _GetConfig(bot_id) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1583 | |
David James | dac7a91 | 2013-11-18 11:14:44 -0800 | [diff] [blame] | 1584 | if options.reference_repo is None: |
| 1585 | repo_path = os.path.join(options.sourceroot, '.repo') |
| 1586 | # If we're being run from a repo checkout, reuse the repo's git pool to |
| 1587 | # cut down on sync time. |
| 1588 | if os.path.exists(repo_path): |
| 1589 | options.reference_repo = options.sourceroot |
| 1590 | elif options.reference_repo: |
| 1591 | if not os.path.exists(options.reference_repo): |
| 1592 | parser.error('Reference path %s does not exist' |
| 1593 | % (options.reference_repo,)) |
| 1594 | elif not os.path.exists(os.path.join(options.reference_repo, '.repo')): |
| 1595 | parser.error('Reference path %s does not look to be the base of a ' |
| 1596 | 'repo checkout; no .repo exists in the root.' |
| 1597 | % (options.reference_repo,)) |
| 1598 | |
Brian Harring | f11bf68 | 2012-05-14 15:53:43 -0700 | [diff] [blame] | 1599 | if (options.buildbot or options.remote_trybot) and not options.resume: |
Brian Harring | 470f611 | 2012-03-02 11:47:10 -0800 | [diff] [blame] | 1600 | if not options.cgroups: |
Ryan Cui | d4a2421 | 2012-04-04 18:08:12 -0700 | [diff] [blame] | 1601 | parser.error('Options --buildbot/--remote-trybot and --nocgroups cannot ' |
| 1602 | 'be used together. Cgroup support is required for ' |
| 1603 | 'buildbot/remote-trybot mode.') |
Mike Frysinger | a78a56e | 2012-11-20 06:02:30 -0500 | [diff] [blame] | 1604 | if not cgroups.Cgroup.IsSupported(): |
Ryan Cui | d4a2421 | 2012-04-04 18:08:12 -0700 | [diff] [blame] | 1605 | parser.error('Option --buildbot/--remote-trybot was given, but this ' |
| 1606 | 'system does not support cgroups. Failing.') |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1607 | |
David James | aad5cc7 | 2012-10-26 15:03:13 -0700 | [diff] [blame] | 1608 | missing = osutils.FindMissingBinaries(_BUILDBOT_REQUIRED_BINARIES) |
Brian Harring | 351ce44 | 2012-03-09 16:38:14 -0800 | [diff] [blame] | 1609 | if missing: |
Ryan Cui | d4a2421 | 2012-04-04 18:08:12 -0700 | [diff] [blame] | 1610 | parser.error("Option --buildbot/--remote-trybot requires the following " |
| 1611 | "binaries which couldn't be found in $PATH: %s" |
Brian Harring | 351ce44 | 2012-03-09 16:38:14 -0800 | [diff] [blame] | 1612 | % (', '.join(missing))) |
| 1613 | |
David James | dac7a91 | 2013-11-18 11:14:44 -0800 | [diff] [blame] | 1614 | if options.reference_repo: |
| 1615 | options.reference_repo = os.path.abspath(options.reference_repo) |
| 1616 | |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1617 | if not options.buildroot: |
| 1618 | if options.buildbot: |
Mike Frysinger | 6903c76 | 2012-12-04 01:57:16 -0500 | [diff] [blame] | 1619 | parser.error('Please specify a buildroot with the --buildbot option.') |
Matt Tennant | d55b1f4 | 2012-04-13 14:15:01 -0700 | [diff] [blame] | 1620 | |
Ryan Cui | 5ba7e15 | 2012-05-10 14:36:52 -0700 | [diff] [blame] | 1621 | options.buildroot = _DetermineDefaultBuildRoot(options.sourceroot, |
| 1622 | build_config['internal']) |
Brian Harring | 470f611 | 2012-03-02 11:47:10 -0800 | [diff] [blame] | 1623 | # We use a marker file in the buildroot to indicate the user has |
| 1624 | # consented to using this directory. |
| 1625 | if not os.path.exists(repository.GetTrybotMarkerPath(options.buildroot)): |
| 1626 | _ConfirmBuildRoot(options.buildroot) |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1627 | |
| 1628 | # Sanity check of buildroot- specifically that it's not pointing into the |
| 1629 | # midst of an existing repo since git-repo doesn't support nesting. |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1630 | if (not repository.IsARepoRoot(options.buildroot) and |
David James | 13a69c9 | 2013-05-09 10:37:42 -0700 | [diff] [blame] | 1631 | git.FindRepoDir(options.buildroot)): |
Brian Harring | 3fec5a8 | 2012-03-01 05:57:03 -0800 | [diff] [blame] | 1632 | parser.error('Configured buildroot %s points into a repository checkout, ' |
| 1633 | 'rather than the root of it. This is not supported.' |
| 1634 | % options.buildroot) |
| 1635 | |
Chris Sosa | b5ea3b4 | 2012-10-25 15:25:20 -0700 | [diff] [blame] | 1636 | if not options.log_dir: |
| 1637 | options.log_dir = os.path.join(options.buildroot, _DEFAULT_LOG_DIR) |
| 1638 | |
Brian Harring | d166aaf | 2012-05-14 18:31:53 -0700 | [diff] [blame] | 1639 | log_file = None |
| 1640 | if options.tee: |
Chris Sosa | b5ea3b4 | 2012-10-25 15:25:20 -0700 | [diff] [blame] | 1641 | log_file = os.path.join(options.log_dir, _BUILDBOT_LOG_FILE) |
| 1642 | osutils.SafeMakedirs(options.log_dir) |
Brian Harring | d166aaf | 2012-05-14 18:31:53 -0700 | [diff] [blame] | 1643 | _BackupPreviousLog(log_file) |
| 1644 | |
Brian Harring | 1b8c4c8 | 2012-05-29 23:03:04 -0700 | [diff] [blame] | 1645 | with cros_build_lib.ContextManagerStack() as stack: |
Aaron Gable | 881fccb | 2013-09-27 18:35:24 -0700 | [diff] [blame] | 1646 | # TODO(ferringb): update this once |
| 1647 | # https://chromium-review.googlesource.com/25359 |
David James | cebc727 | 2013-07-17 16:45:05 -0700 | [diff] [blame] | 1648 | # is landed- it's sensitive to the manifest-versions cache path. |
| 1649 | options.preserve_paths = set(['manifest-versions', '.cache', |
| 1650 | 'manifest-versions-internal']) |
| 1651 | if log_file is not None: |
| 1652 | # We don't want the critical section to try to clean up the tee process, |
| 1653 | # so we run Tee (forked off) outside of it. This prevents a deadlock |
| 1654 | # because the Tee process only exits when its pipe is closed, and the |
| 1655 | # critical section accidentally holds on to that file handle. |
| 1656 | stack.Add(tee.Tee, log_file) |
| 1657 | options.preserve_paths.add(_DEFAULT_LOG_DIR) |
| 1658 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1659 | critical_section = stack.Add(cleanup.EnforcedCleanupSection) |
| 1660 | stack.Add(sudo.SudoKeepAlive) |
Brian Harring | d166aaf | 2012-05-14 18:31:53 -0700 | [diff] [blame] | 1661 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1662 | if not options.resume: |
Brian Harring | 2bf55e1 | 2012-05-13 21:31:55 -0700 | [diff] [blame] | 1663 | # If we're in resume mode, use our parents tempdir rather than |
| 1664 | # nesting another layer. |
David James | 4bc1370 | 2013-03-26 08:08:04 -0700 | [diff] [blame] | 1665 | stack.Add(osutils.TempDir, prefix='cbuildbot-tmp', set_global=True) |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1666 | logging.debug("Cbuildbot tempdir is %r.", os.environ.get('TMP')) |
Brian Harring | d166aaf | 2012-05-14 18:31:53 -0700 | [diff] [blame] | 1667 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1668 | if options.cgroups: |
| 1669 | stack.Add(cgroups.SimpleContainChildren, 'cbuildbot') |
Brian Harring | a184efa | 2012-03-04 11:51:25 -0800 | [diff] [blame] | 1670 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1671 | # Mark everything between EnforcedCleanupSection and here as having to |
| 1672 | # be rolled back via the contextmanager cleanup handlers. This |
| 1673 | # ensures that sudo bits cannot outlive cbuildbot, that anything |
| 1674 | # cgroups would kill gets killed, etc. |
David James | fb3aac9 | 2013-10-16 13:26:52 -0700 | [diff] [blame] | 1675 | stack.Add(critical_section.ForkWatchdog) |
Brian Harring | d166aaf | 2012-05-14 18:31:53 -0700 | [diff] [blame] | 1676 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1677 | if options.timeout > 0: |
David James | 3432acd | 2013-11-27 10:02:18 -0800 | [diff] [blame] | 1678 | stack.Add(timeout_util.FatalTimeout, options.timeout) |
Brian Harring | a184efa | 2012-03-04 11:51:25 -0800 | [diff] [blame] | 1679 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1680 | if not options.buildbot: |
| 1681 | build_config = cbuildbot_config.OverrideConfigForTrybot( |
| 1682 | build_config, |
David James | e8dcfc4 | 2013-03-21 19:49:49 -0700 | [diff] [blame] | 1683 | options) |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1684 | |
Mike Frysinger | 6903c76 | 2012-12-04 01:57:16 -0500 | [diff] [blame] | 1685 | if options.buildbot or options.remote_trybot: |
| 1686 | _DisableYamaHardLinkChecks() |
| 1687 | |
Aviv Keshet | a0159be | 2013-12-12 13:56:28 -0800 | [diff] [blame] | 1688 | if options.mock_tree_status is not None: |
| 1689 | stack.Add(mock.patch.object, timeout_util, '_GetStatus', |
| 1690 | return_value=options.mock_tree_status) |
| 1691 | |
Aviv Keshet | cf9c272 | 2014-02-25 15:15:10 -0800 | [diff] [blame] | 1692 | if options.mock_slave_status is not None: |
| 1693 | with open(options.mock_slave_status, 'r') as f: |
Aviv Keshet | 4e75002 | 2014-03-07 16:50:34 -0800 | [diff] [blame] | 1694 | mock_statuses = pickle.load(f) |
| 1695 | for key, value in mock_statuses.iteritems(): |
| 1696 | mock_statuses[key] = manifest_version.BuilderStatus(**value) |
Aviv Keshet | cf9c272 | 2014-02-25 15:15:10 -0800 | [diff] [blame] | 1697 | stack.Add(mock.patch.object, stages.MasterSlaveSyncCompletionStage, |
Aviv Keshet | 4e75002 | 2014-03-07 16:50:34 -0800 | [diff] [blame] | 1698 | '_FetchSlaveStatuses', return_value=mock_statuses) |
Aviv Keshet | cf9c272 | 2014-02-25 15:15:10 -0800 | [diff] [blame] | 1699 | |
Brian Harring | c2d09d9 | 2012-05-13 22:03:15 -0700 | [diff] [blame] | 1700 | _RunBuildStagesWrapper(options, build_config) |