Mike Frysinger | f1ba7ad | 2022-09-12 05:42:57 -0400 | [diff] [blame] | 1 | # Copyright 2019 The ChromiumOS Authors |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 2 | # Use of this source code is governed by a BSD-style license that can be |
| 3 | # found in the LICENSE file. |
| 4 | |
| 5 | """Sysroot controller.""" |
| 6 | |
Chris McDonald | 1672ddb | 2021-07-21 11:48:23 -0600 | [diff] [blame] | 7 | import logging |
Michael Mortensen | 4ccfb08 | 2020-01-22 16:24:03 -0700 | [diff] [blame] | 8 | import os |
Jack Neus | 26b9467 | 2022-10-27 17:33:21 +0000 | [diff] [blame^] | 9 | import traceback |
Michael Mortensen | 4ccfb08 | 2020-01-22 16:24:03 -0700 | [diff] [blame] | 10 | |
Alex Klein | 8cb365a | 2019-05-15 16:24:53 -0600 | [diff] [blame] | 11 | from chromite.api import controller |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 12 | from chromite.api import faux |
Alex Klein | 2b23672 | 2019-06-19 15:44:26 -0600 | [diff] [blame] | 13 | from chromite.api import validate |
Alex Klein | a9d500b | 2019-04-22 15:37:51 -0600 | [diff] [blame] | 14 | from chromite.api.controller import controller_util |
Chris McDonald | 1672ddb | 2021-07-21 11:48:23 -0600 | [diff] [blame] | 15 | from chromite.api.gen.chromiumos import common_pb2 |
Will Bradley | 7e5b8c1 | 2019-07-30 12:44:15 -0600 | [diff] [blame] | 16 | from chromite.api.metrics import deserialize_metrics_log |
LaMont Jones | feffd1b | 2020-08-05 18:24:59 -0600 | [diff] [blame] | 17 | from chromite.lib import binpkg |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 18 | from chromite.lib import build_target_lib |
| 19 | from chromite.lib import chroot_lib |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 20 | from chromite.lib import cros_build_lib |
Michael Mortensen | 798ee19 | 2020-01-17 13:04:43 -0700 | [diff] [blame] | 21 | from chromite.lib import goma_lib |
Alex Klein | aef4194 | 2022-04-19 14:13:17 -0600 | [diff] [blame] | 22 | from chromite.lib import metrics_lib |
Michael Mortensen | 3f6b4bd | 2020-02-07 14:16:43 -0700 | [diff] [blame] | 23 | from chromite.lib import osutils |
Alex Klein | a9d6460 | 2019-05-17 14:55:37 -0600 | [diff] [blame] | 24 | from chromite.lib import portage_util |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 25 | from chromite.lib import sysroot_lib |
| 26 | from chromite.service import sysroot |
| 27 | |
Chris McDonald | 1672ddb | 2021-07-21 11:48:23 -0600 | [diff] [blame] | 28 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 29 | _ACCEPTED_LICENSES = "@CHROMEOS" |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 30 | |
Alex Klein | eaa4853 | 2022-07-28 08:51:32 -0600 | [diff] [blame] | 31 | DEFAULT_BACKTRACK = 30 |
| 32 | |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 33 | |
Yoshiki Iguchi | a43704b | 2021-12-16 13:31:48 +0900 | [diff] [blame] | 34 | def _GetGomaLogDirectory(): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 35 | """Get goma's log directory based on the env variables. |
Yoshiki Iguchi | a43704b | 2021-12-16 13:31:48 +0900 | [diff] [blame] | 36 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 37 | Returns: |
Alex Klein | 611dddd | 2022-10-11 17:02:01 -0600 | [diff] [blame] | 38 | a string of a directory name where goma's log may exist, or None if no |
| 39 | potential directories exist. |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 40 | """ |
| 41 | # TODO(crbug.com/1045001): Replace environment variable with query to |
| 42 | # goma object after goma refactoring allows this. |
| 43 | candidates = [ |
| 44 | "GLOG_log_dir", |
| 45 | "GOOGLE_LOG_DIR", |
| 46 | "TEST_TMPDIR", |
| 47 | "TMPDIR", |
| 48 | "TMP", |
| 49 | ] |
| 50 | for candidate in candidates: |
| 51 | value = os.environ.get(candidate) |
| 52 | if value and os.path.isdir(value): |
| 53 | return value |
Yoshiki Iguchi | a43704b | 2021-12-16 13:31:48 +0900 | [diff] [blame] | 54 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 55 | # "/tmp" will always exist. |
| 56 | return "/tmp" |
Yoshiki Iguchi | a43704b | 2021-12-16 13:31:48 +0900 | [diff] [blame] | 57 | |
| 58 | |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 59 | def ExampleGetResponse(): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 60 | """Give an example response to assemble upstream in caller artifacts.""" |
| 61 | uabs = common_pb2.UploadedArtifactsByService |
| 62 | cabs = common_pb2.ArtifactsByService |
| 63 | return uabs.Sysroot( |
| 64 | artifacts=[ |
| 65 | uabs.Sysroot.ArtifactPaths( |
| 66 | artifact_type=cabs.Sysroot.ArtifactType.SIMPLE_CHROME_SYSROOT, |
| 67 | paths=[ |
| 68 | common_pb2.Path( |
| 69 | path="/tmp/sysroot_chromeos-base_chromeos-chrome.tar.xz", |
| 70 | location=common_pb2.Path.OUTSIDE, |
| 71 | ) |
| 72 | ], |
| 73 | ), |
| 74 | uabs.Sysroot.ArtifactPaths( |
| 75 | artifact_type=cabs.Sysroot.ArtifactType.DEBUG_SYMBOLS, |
| 76 | paths=[ |
| 77 | common_pb2.Path( |
| 78 | path="/tmp/debug.tgz", location=common_pb2.Path.OUTSIDE |
| 79 | ) |
| 80 | ], |
| 81 | ), |
| 82 | uabs.Sysroot.ArtifactPaths( |
| 83 | artifact_type=cabs.Sysroot.ArtifactType.BREAKPAD_DEBUG_SYMBOLS, |
| 84 | paths=[ |
| 85 | common_pb2.Path( |
| 86 | path="/tmp/debug_breakpad.tar.xz", |
| 87 | location=common_pb2.Path.OUTSIDE, |
| 88 | ) |
| 89 | ], |
| 90 | ), |
| 91 | ] |
| 92 | ) |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 93 | |
| 94 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 95 | def GetArtifacts( |
| 96 | in_proto: common_pb2.ArtifactsByService.Sysroot, |
| 97 | chroot: chroot_lib.Chroot, |
| 98 | sysroot_class: sysroot_lib.Sysroot, |
| 99 | build_target: build_target_lib.BuildTarget, |
| 100 | output_dir: str, |
| 101 | ) -> list: |
| 102 | """Builds and copies sysroot artifacts to specified output_dir. |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 103 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 104 | Copies sysroot artifacts to output_dir, returning a list of (output_dir: str) |
| 105 | paths to the desired files. |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 106 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 107 | Args: |
Alex Klein | 611dddd | 2022-10-11 17:02:01 -0600 | [diff] [blame] | 108 | in_proto: Proto request defining reqs. |
| 109 | chroot: The chroot class used for these artifacts. |
| 110 | sysroot_class: The sysroot class used for these artifacts. |
| 111 | build_target: The build target used for these artifacts. |
| 112 | output_dir: The path to write artifacts to. |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 113 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 114 | Returns: |
Alex Klein | 611dddd | 2022-10-11 17:02:01 -0600 | [diff] [blame] | 115 | A list of dictionary mappings of ArtifactType to list of paths. |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 116 | """ |
| 117 | generated = [] |
| 118 | artifact_types = { |
| 119 | in_proto.ArtifactType.SIMPLE_CHROME_SYSROOT: sysroot.CreateSimpleChromeSysroot, |
| 120 | in_proto.ArtifactType.CHROME_EBUILD_ENV: sysroot.CreateChromeEbuildEnv, |
| 121 | in_proto.ArtifactType.BREAKPAD_DEBUG_SYMBOLS: sysroot.BundleBreakpadSymbols, |
| 122 | in_proto.ArtifactType.DEBUG_SYMBOLS: sysroot.BundleDebugSymbols, |
Jack Neus | 11b6ebd | 2022-10-21 17:54:36 +0000 | [diff] [blame] | 123 | in_proto.ArtifactType.FUZZER_SYSROOT: sysroot.CreateFuzzerSysroot, |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 124 | } |
Jack Neus | 5e56fef | 2021-06-18 16:57:28 +0000 | [diff] [blame] | 125 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 126 | for output_artifact in in_proto.output_artifacts: |
| 127 | for artifact_type, func in artifact_types.items(): |
| 128 | if artifact_type in output_artifact.artifact_types: |
Jack Neus | 26b9467 | 2022-10-27 17:33:21 +0000 | [diff] [blame^] | 129 | try: |
| 130 | result = func( |
| 131 | chroot, sysroot_class, build_target, output_dir |
| 132 | ) |
| 133 | except Exception as e: |
| 134 | generated.append( |
| 135 | { |
| 136 | "type": artifact_type, |
| 137 | "failed": True, |
| 138 | "failure_reason": str(e), |
| 139 | } |
| 140 | ) |
| 141 | artifact_name = ( |
| 142 | common_pb2.ArtifactsByService.Sysroot.ArtifactType.Name( |
| 143 | artifact_type |
| 144 | ) |
| 145 | ) |
| 146 | logging.warning( |
| 147 | "%s artifact generation failed with exception %s", |
| 148 | artifact_name, |
| 149 | e, |
| 150 | ) |
| 151 | logging.warning("traceback:\n%s", traceback.format_exc()) |
| 152 | continue |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 153 | if result: |
| 154 | generated.append( |
| 155 | { |
| 156 | "paths": [result] |
| 157 | if isinstance(result, str) |
| 158 | else result, |
| 159 | "type": artifact_type, |
| 160 | } |
| 161 | ) |
Jack Neus | 5e56fef | 2021-06-18 16:57:28 +0000 | [diff] [blame] | 162 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 163 | return generated |
George Engelbrecht | c9a8e81 | 2021-06-16 18:14:17 -0600 | [diff] [blame] | 164 | |
| 165 | |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 166 | @faux.all_empty |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 167 | @validate.require("build_target.name") |
Alex Klein | 231d2da | 2019-07-22 16:44:45 -0600 | [diff] [blame] | 168 | @validate.validation_complete |
| 169 | def Create(input_proto, output_proto, _config): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 170 | """Create or replace a sysroot.""" |
| 171 | update_chroot = not input_proto.flags.chroot_current |
| 172 | replace_sysroot = input_proto.flags.replace |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 173 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 174 | build_target = controller_util.ParseBuildTarget( |
| 175 | input_proto.build_target, input_proto.profile |
| 176 | ) |
| 177 | package_indexes = [ |
| 178 | binpkg.PackageIndexInfo.from_protobuf(x) |
| 179 | for x in input_proto.package_indexes |
| 180 | ] |
| 181 | run_configs = sysroot.SetupBoardRunConfig( |
| 182 | force=replace_sysroot, |
| 183 | upgrade_chroot=update_chroot, |
| 184 | package_indexes=package_indexes, |
| 185 | backtrack=DEFAULT_BACKTRACK, |
| 186 | ) |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 187 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 188 | try: |
| 189 | created = sysroot.Create( |
| 190 | build_target, run_configs, accept_licenses=_ACCEPTED_LICENSES |
| 191 | ) |
| 192 | except sysroot.Error as e: |
| 193 | cros_build_lib.Die(e) |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 194 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 195 | output_proto.sysroot.path = created.path |
| 196 | output_proto.sysroot.build_target.name = build_target.name |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 197 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 198 | return controller.RETURN_CODE_SUCCESS |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 199 | |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 200 | |
Michael Mortensen | 98592f6 | 2019-09-27 13:34:18 -0600 | [diff] [blame] | 201 | @faux.all_empty |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 202 | @validate.require("build_target.name", "packages") |
| 203 | @validate.require_each("packages", ["category", "package_name"]) |
Michael Mortensen | 3f6b4bd | 2020-02-07 14:16:43 -0700 | [diff] [blame] | 204 | @validate.validation_complete |
| 205 | def GenerateArchive(input_proto, output_proto, _config): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 206 | """Generate a sysroot. Typically used by informational builders.""" |
| 207 | build_target_name = input_proto.build_target.name |
| 208 | pkg_list = [] |
| 209 | for package in input_proto.packages: |
| 210 | pkg_list.append("%s/%s" % (package.category, package.package_name)) |
Michael Mortensen | 3f6b4bd | 2020-02-07 14:16:43 -0700 | [diff] [blame] | 211 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 212 | with osutils.TempDir(delete=False) as temp_output_dir: |
| 213 | sysroot_tar_path = sysroot.GenerateArchive( |
| 214 | temp_output_dir, build_target_name, pkg_list |
| 215 | ) |
Michael Mortensen | 3f6b4bd | 2020-02-07 14:16:43 -0700 | [diff] [blame] | 216 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 217 | # By assigning this Path variable to the tar path, the tar file will be |
| 218 | # copied out to the input_proto's ResultPath location. |
| 219 | output_proto.sysroot_archive.path = sysroot_tar_path |
| 220 | output_proto.sysroot_archive.location = common_pb2.Path.INSIDE |
Michael Mortensen | 3f6b4bd | 2020-02-07 14:16:43 -0700 | [diff] [blame] | 221 | |
| 222 | |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 223 | def _MockFailedPackagesResponse(_input_proto, output_proto, _config): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 224 | """Mock error response that populates failed packages.""" |
| 225 | fail = output_proto.failed_package_data.add() |
| 226 | fail.name.package_name = "package" |
| 227 | fail.name.category = "category" |
| 228 | fail.name.version = "1.0.0_rc-r1" |
| 229 | fail.log_path.path = ( |
| 230 | "/path/to/package:category-1.0.0_rc-r1:20210609-1337.log" |
| 231 | ) |
| 232 | fail.log_path.location = common_pb2.Path.INSIDE |
Lizzy Presland | 7e23a61 | 2021-11-09 21:49:42 +0000 | [diff] [blame] | 233 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 234 | fail2 = output_proto.failed_package_data.add() |
| 235 | fail2.name.package_name = "bar" |
| 236 | fail2.name.category = "foo" |
| 237 | fail2.name.version = "3.7-r99" |
| 238 | fail2.log_path.path = "/path/to/foo:bar-3.7-r99:20210609-1620.log" |
| 239 | fail2.log_path.location = common_pb2.Path.INSIDE |
Lizzy Presland | 7e23a61 | 2021-11-09 21:49:42 +0000 | [diff] [blame] | 240 | |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 241 | |
| 242 | @faux.empty_success |
| 243 | @faux.error(_MockFailedPackagesResponse) |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 244 | @validate.require("sysroot.path", "sysroot.build_target.name") |
| 245 | @validate.exists("sysroot.path") |
Alex Klein | 231d2da | 2019-07-22 16:44:45 -0600 | [diff] [blame] | 246 | @validate.validation_complete |
| 247 | def InstallToolchain(input_proto, output_proto, _config): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 248 | """Install the toolchain into a sysroot.""" |
| 249 | compile_source = ( |
| 250 | input_proto.flags.compile_source or input_proto.flags.toolchain_changed |
| 251 | ) |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 252 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 253 | sysroot_path = input_proto.sysroot.path |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 254 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 255 | build_target = controller_util.ParseBuildTarget( |
| 256 | input_proto.sysroot.build_target |
| 257 | ) |
| 258 | target_sysroot = sysroot_lib.Sysroot(sysroot_path) |
| 259 | run_configs = sysroot.SetupBoardRunConfig(usepkg=not compile_source) |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 260 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 261 | _LogBinhost(build_target.name) |
Alex Klein | a9d6460 | 2019-05-17 14:55:37 -0600 | [diff] [blame] | 262 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 263 | try: |
| 264 | sysroot.InstallToolchain(build_target, target_sysroot, run_configs) |
| 265 | except sysroot_lib.ToolchainInstallError as e: |
| 266 | controller_util.retrieve_package_log_paths( |
| 267 | e.failed_toolchain_info, output_proto, target_sysroot |
| 268 | ) |
Alex Klein | da35fcf | 2019-03-07 16:01:15 -0700 | [diff] [blame] | 269 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 270 | return controller.RETURN_CODE_UNSUCCESSFUL_RESPONSE_AVAILABLE |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 271 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 272 | return controller.RETURN_CODE_SUCCESS |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 273 | |
Alex Klein | 076841b | 2019-08-29 15:19:39 -0600 | [diff] [blame] | 274 | |
| 275 | @faux.empty_success |
| 276 | @faux.error(_MockFailedPackagesResponse) |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 277 | @validate.require("sysroot.build_target.name") |
| 278 | @validate.exists("sysroot.path") |
| 279 | @validate.require_each("packages", ["category", "package_name"]) |
| 280 | @validate.require_each("use_flags", ["flag"]) |
Alex Klein | 231d2da | 2019-07-22 16:44:45 -0600 | [diff] [blame] | 281 | @validate.validation_complete |
Alex Klein | aef4194 | 2022-04-19 14:13:17 -0600 | [diff] [blame] | 282 | @metrics_lib.collect_metrics |
Alex Klein | 231d2da | 2019-07-22 16:44:45 -0600 | [diff] [blame] | 283 | def InstallPackages(input_proto, output_proto, _config): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 284 | """Install packages into a sysroot, building as necessary and permitted.""" |
| 285 | compile_source = ( |
| 286 | input_proto.flags.compile_source or input_proto.flags.toolchain_changed |
| 287 | ) |
Joanna Wang | 1ec0c81 | 2021-11-17 17:41:27 -0800 | [diff] [blame] | 288 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 289 | use_remoteexec = bool( |
| 290 | input_proto.remoteexec_config.reproxy_cfg_file |
| 291 | and input_proto.remoteexec_config.reclient_dir |
| 292 | ) |
Joanna Wang | 1ec0c81 | 2021-11-17 17:41:27 -0800 | [diff] [blame] | 293 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 294 | # Testing if Goma will support unknown compilers now. |
| 295 | use_goma = input_proto.flags.use_goma and not use_remoteexec |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 296 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 297 | target_sysroot = sysroot_lib.Sysroot(input_proto.sysroot.path) |
| 298 | build_target = controller_util.ParseBuildTarget( |
| 299 | input_proto.sysroot.build_target |
| 300 | ) |
Alex Klein | ca572ee | 2020-09-03 10:47:14 -0600 | [diff] [blame] | 301 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 302 | # Get the package atom for each specified package. The field is optional, so |
| 303 | # error only when we cannot parse an atom for each of the given packages. |
| 304 | packages = [ |
| 305 | controller_util.PackageInfoToCPV(x).cp for x in input_proto.packages |
| 306 | ] |
Alex Klein | ca572ee | 2020-09-03 10:47:14 -0600 | [diff] [blame] | 307 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 308 | package_indexes = [ |
| 309 | binpkg.PackageIndexInfo.from_protobuf(x) |
| 310 | for x in input_proto.package_indexes |
| 311 | ] |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 312 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 313 | # Calculate which packages would have been merged, but don't install anything. |
| 314 | dryrun = input_proto.flags.dryrun |
Navil Perez | 5766d1b | 2021-05-26 17:38:15 +0000 | [diff] [blame] | 315 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 316 | if not target_sysroot.IsToolchainInstalled(): |
| 317 | cros_build_lib.Die("Toolchain must first be installed.") |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 318 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 319 | _LogBinhost(build_target.name) |
Alex Klein | a9d6460 | 2019-05-17 14:55:37 -0600 | [diff] [blame] | 320 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 321 | use_flags = [u.flag for u in input_proto.use_flags] |
| 322 | build_packages_config = sysroot.BuildPackagesRunConfig( |
| 323 | use_any_chrome=False, |
| 324 | usepkg=not compile_source, |
| 325 | install_debug_symbols=True, |
| 326 | packages=packages, |
| 327 | package_indexes=package_indexes, |
| 328 | use_flags=use_flags, |
| 329 | use_goma=use_goma, |
| 330 | use_remoteexec=use_remoteexec, |
| 331 | incremental_build=False, |
| 332 | dryrun=dryrun, |
| 333 | backtrack=DEFAULT_BACKTRACK, |
| 334 | ) |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 335 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 336 | try: |
| 337 | sysroot.BuildPackages( |
| 338 | build_target, target_sysroot, build_packages_config |
| 339 | ) |
| 340 | except sysroot_lib.PackageInstallError as e: |
| 341 | if not e.failed_packages: |
| 342 | # No packages to report, so just exit with an error code. |
| 343 | return controller.RETURN_CODE_COMPLETED_UNSUCCESSFULLY |
Alex Klein | 2557b4f | 2019-07-11 14:34:00 -0600 | [diff] [blame] | 344 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 345 | controller_util.retrieve_package_log_paths( |
| 346 | e.failed_packages, output_proto, target_sysroot |
| 347 | ) |
Alex Klein | d4e1e42 | 2019-03-18 16:00:41 -0600 | [diff] [blame] | 348 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 349 | return controller.RETURN_CODE_UNSUCCESSFUL_RESPONSE_AVAILABLE |
| 350 | finally: |
| 351 | # Copy goma logs to specified directory if there is a goma_config and |
| 352 | # it contains a log_dir to store artifacts. |
| 353 | if input_proto.goma_config.log_dir.dir: |
| 354 | log_source_dir = _GetGomaLogDirectory() |
| 355 | archiver = goma_lib.LogsArchiver( |
| 356 | log_source_dir, |
| 357 | dest_dir=input_proto.goma_config.log_dir.dir, |
| 358 | stats_file=input_proto.goma_config.stats_file, |
| 359 | counterz_file=input_proto.goma_config.counterz_file, |
| 360 | ) |
| 361 | archiver_tuple = archiver.Archive() |
| 362 | if archiver_tuple.stats_file: |
| 363 | output_proto.goma_artifacts.stats_file = ( |
| 364 | archiver_tuple.stats_file |
| 365 | ) |
| 366 | if archiver_tuple.counterz_file: |
| 367 | output_proto.goma_artifacts.counterz_file = ( |
| 368 | archiver_tuple.counterz_file |
| 369 | ) |
| 370 | output_proto.goma_artifacts.log_files[:] = archiver_tuple.log_files |
Alex Klein | a9d6460 | 2019-05-17 14:55:37 -0600 | [diff] [blame] | 371 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 372 | # Return without populating the response if it is a dryrun. |
| 373 | if dryrun: |
| 374 | return controller.RETURN_CODE_SUCCESS |
Navil Perez | 5766d1b | 2021-05-26 17:38:15 +0000 | [diff] [blame] | 375 | |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 376 | # Read metric events log and pipe them into output_proto.events. |
| 377 | deserialize_metrics_log(output_proto.events, prefix=build_target.name) |
Will Bradley | 7e5b8c1 | 2019-07-30 12:44:15 -0600 | [diff] [blame] | 378 | |
Alex Klein | a9d6460 | 2019-05-17 14:55:37 -0600 | [diff] [blame] | 379 | |
| 380 | def _LogBinhost(board): |
Alex Klein | 1699fab | 2022-09-08 08:46:06 -0600 | [diff] [blame] | 381 | """Log the portage binhost for the given board.""" |
| 382 | binhost = portage_util.PortageqEnvvar( |
| 383 | "PORTAGE_BINHOST", board=board, allow_undefined=True |
| 384 | ) |
| 385 | if not binhost: |
| 386 | logging.warning("Portage Binhost not found.") |
| 387 | else: |
| 388 | logging.info("Portage Binhost: %s", binhost) |