blob: 81d1ac11308fa2c88faded3830196a379ca0bc11 [file] [log] [blame]
Alex Kleineb77ffa2019-05-28 14:47:44 -06001# -*- coding: utf-8 -*-
2# Copyright 2019 The Chromium OS Authors. All rights reserved.
3# Use of this source code is governed by a BSD-style license that can be
4# found in the LICENSE file.
5
6"""Package utility functionality."""
7
8from __future__ import print_function
9
Yaakov Shaul730814a2019-09-10 13:58:25 -060010import collections
Yaakov Shaulcb1cfc32019-09-16 13:51:19 -060011import fileinput
Alex Klein87531182019-08-12 15:23:37 -060012import functools
Yaakov Shaul395ae832019-09-09 14:45:32 -060013import json
Evan Hernandezb51f1522019-08-15 11:29:40 -060014import os
Michael Mortensenb70e8a82019-10-10 18:43:41 -060015import re
Yaakov Shaulcb1cfc32019-09-16 13:51:19 -060016import sys
Alex Klein87531182019-08-12 15:23:37 -060017
Alex Klein149fd3b2019-12-16 16:01:05 -070018import six
19
Andrew Lamb2bde9e42019-11-04 13:24:09 -070020from google.protobuf import json_format
Yaakov Shaul730814a2019-09-10 13:58:25 -060021
Andrew Lamb2bde9e42019-11-04 13:24:09 -070022from chromite.api.gen.config import replication_config_pb2
Michael Mortensen9fdb14b2019-10-17 11:17:30 -060023from chromite.cbuildbot import manifest_version
Alex Kleineb77ffa2019-05-28 14:47:44 -060024from chromite.lib import constants
Evan Hernandezb51f1522019-08-15 11:29:40 -060025from chromite.lib import cros_build_lib
Alex Klein4de25e82019-08-05 15:58:39 -060026from chromite.lib import cros_logging as logging
Alex Kleineb77ffa2019-05-28 14:47:44 -060027from chromite.lib import git
Michael Mortensende716a12020-05-15 11:27:00 -060028from chromite.lib import image_lib
Michael Mortensenb70e8a82019-10-10 18:43:41 -060029from chromite.lib import osutils
Alex Kleineb77ffa2019-05-28 14:47:44 -060030from chromite.lib import portage_util
Andrew Lamb2bde9e42019-11-04 13:24:09 -070031from chromite.lib import replication_lib
Alex Kleind6195b62019-08-06 16:01:16 -060032from chromite.lib import uprev_lib
Alex Kleineb77ffa2019-05-28 14:47:44 -060033
Alex Klein36b117f2019-09-30 15:13:46 -060034if cros_build_lib.IsInsideChroot():
35 from chromite.service import dependency
36
Mike Frysingerbafb3182020-02-21 03:15:43 -050037
Alex Klein87531182019-08-12 15:23:37 -060038# Registered handlers for uprevving versioned packages.
39_UPREV_FUNCS = {}
40
Alex Kleineb77ffa2019-05-28 14:47:44 -060041
42class Error(Exception):
43 """Module's base error class."""
44
45
Alex Klein4de25e82019-08-05 15:58:39 -060046class UnknownPackageError(Error):
47 """Uprev attempted for a package without a registered handler."""
48
49
Alex Kleineb77ffa2019-05-28 14:47:44 -060050class UprevError(Error):
51 """An error occurred while uprevving packages."""
52
53
Michael Mortensenb70e8a82019-10-10 18:43:41 -060054class NoAndroidVersionError(Error):
55 """An error occurred while trying to determine the android version."""
56
57
58class NoAndroidBranchError(Error):
59 """An error occurred while trying to determine the android branch."""
60
61
62class NoAndroidTargetError(Error):
63 """An error occurred while trying to determine the android target."""
64
65
Alex Klein4de25e82019-08-05 15:58:39 -060066class AndroidIsPinnedUprevError(UprevError):
67 """Raised when we try to uprev while Android is pinned."""
68
69 def __init__(self, new_android_atom):
70 """Initialize a AndroidIsPinnedUprevError.
71
72 Args:
73 new_android_atom: The Android atom that we failed to
74 uprev to, due to Android being pinned.
75 """
76 assert new_android_atom
77 msg = ('Failed up uprev to Android version %s as Android was pinned.' %
78 new_android_atom)
79 super(AndroidIsPinnedUprevError, self).__init__(msg)
80 self.new_android_atom = new_android_atom
Alex Klein87531182019-08-12 15:23:37 -060081
82
Yaakov Shaul1eafe832019-09-10 16:50:26 -060083class EbuildManifestError(Error):
84 """Error when running ebuild manifest."""
85
86
Andrew Lamb9563a152019-12-04 11:42:18 -070087class GeneratedCrosConfigFilesError(Error):
88 """Error when cros_config_schema does not produce expected files"""
89
90 def __init__(self, expected_files, found_files):
91 msg = ('Expected to find generated C files: %s. Actually found: %s' %
92 (expected_files, found_files))
93 super(GeneratedCrosConfigFilesError, self).__init__(msg)
94
Alex Klein7a3a7dd2020-01-08 16:44:38 -070095
Yaakov Shaul730814a2019-09-10 13:58:25 -060096UprevVersionedPackageModifications = collections.namedtuple(
97 'UprevVersionedPackageModifications', ('new_version', 'files'))
Alex Klein34afcbc2019-08-22 16:14:31 -060098
Yaakov Shaul730814a2019-09-10 13:58:25 -060099
100class UprevVersionedPackageResult(object):
101 """Data object for uprev_versioned_package."""
102
103 def __init__(self):
104 self.modified = []
105
106 def add_result(self, new_version, modified_files):
107 """Adds version/ebuilds tuple to result.
108
109 Args:
110 new_version: New version number of package.
111 modified_files: List of files modified for the given version.
112 """
113 result = UprevVersionedPackageModifications(new_version, modified_files)
114 self.modified.append(result)
115 return self
Alex Klein34afcbc2019-08-22 16:14:31 -0600116
117 @property
118 def uprevved(self):
Yaakov Shaul730814a2019-09-10 13:58:25 -0600119 return bool(self.modified)
Alex Klein34afcbc2019-08-22 16:14:31 -0600120
121
Yaakov Shaulcb1cfc32019-09-16 13:51:19 -0600122def patch_ebuild_vars(ebuild_path, variables):
123 """Updates variables in ebuild.
124
125 Use this function rather than portage_util.EBuild.UpdateEBuild when you
126 want to preserve the variable position and quotes within the ebuild.
127
128 Args:
129 ebuild_path: The path of the ebuild.
130 variables: Dictionary of variables to update in ebuild.
131 """
132 try:
133 for line in fileinput.input(ebuild_path, inplace=1):
134 varname, eq, _ = line.partition('=')
135 if eq == '=' and varname.strip() in variables:
136 value = variables[varname]
137 sys.stdout.write('%s="%s"\n' % (varname, value))
138 else:
139 sys.stdout.write(line)
140 finally:
141 fileinput.close()
142
143
Alex Klein87531182019-08-12 15:23:37 -0600144def uprevs_versioned_package(package):
145 """Decorator to register package uprev handlers."""
146 assert package
147
148 def register(func):
149 """Registers |func| as a handler for |package|."""
150 _UPREV_FUNCS[package] = func
151
152 @functools.wraps(func)
153 def pass_through(*args, **kwargs):
154 return func(*args, **kwargs)
155
156 return pass_through
157
158 return register
159
160
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700161def uprev_android(tracking_branch,
162 android_package,
163 android_build_branch,
164 chroot,
165 build_targets=None,
Shao-Chuan Lee9c39e0c2020-04-24 11:40:34 +0900166 android_version=None):
Alex Klein4de25e82019-08-05 15:58:39 -0600167 """Returns the portage atom for the revved Android ebuild - see man emerge."""
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700168 command = [
169 'cros_mark_android_as_stable',
170 '--tracking_branch=%s' % tracking_branch,
171 '--android_package=%s' % android_package,
172 '--android_build_branch=%s' % android_build_branch,
173 ]
Alex Klein4de25e82019-08-05 15:58:39 -0600174 if build_targets:
175 command.append('--boards=%s' % ':'.join(bt.name for bt in build_targets))
176 if android_version:
177 command.append('--force_version=%s' % android_version)
Alex Klein4de25e82019-08-05 15:58:39 -0600178
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700179 result = cros_build_lib.run(
180 command,
181 stdout=True,
182 enter_chroot=True,
Mike Frysinger88d96362020-02-14 19:05:45 -0500183 encoding='utf-8',
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700184 chroot_args=chroot.get_enter_args())
Alex Klein4de25e82019-08-05 15:58:39 -0600185
Mike Frysinger88d96362020-02-14 19:05:45 -0500186 portage_atom_string = result.stdout.strip()
187 android_atom = None
188 if portage_atom_string:
189 android_atom = portage_atom_string.splitlines()[-1].partition('=')[-1]
Alex Klein4de25e82019-08-05 15:58:39 -0600190 if not android_atom:
191 logging.info('Found nothing to rev.')
192 return None
193
194 for target in build_targets or []:
195 # Sanity check: We should always be able to merge the version of
196 # Android we just unmasked.
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700197 command = ['emerge-%s' % target.name, '-p', '--quiet', '=%s' % android_atom]
Alex Klein4de25e82019-08-05 15:58:39 -0600198 try:
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700199 cros_build_lib.run(
200 command, enter_chroot=True, chroot_args=chroot.get_enter_args())
Alex Klein4de25e82019-08-05 15:58:39 -0600201 except cros_build_lib.RunCommandError:
202 logging.error(
203 'Cannot emerge-%s =%s\nIs Android pinned to an older '
204 'version?', target, android_atom)
205 raise AndroidIsPinnedUprevError(android_atom)
206
207 return android_atom
208
209
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700210def uprev_build_targets(build_targets,
211 overlay_type,
212 chroot=None,
Alex Kleineb77ffa2019-05-28 14:47:44 -0600213 output_dir=None):
214 """Uprev the set provided build targets, or all if not specified.
215
216 Args:
Alex Klein2960c752020-03-09 13:43:38 -0600217 build_targets (list[build_target_lib.BuildTarget]|None): The build targets
Alex Kleineb77ffa2019-05-28 14:47:44 -0600218 whose overlays should be uprevved, empty or None for all.
219 overlay_type (str): One of the valid overlay types except None (see
220 constants.VALID_OVERLAYS).
221 chroot (chroot_lib.Chroot|None): The chroot to clean, if desired.
222 output_dir (str|None): The path to optionally dump result files.
223 """
224 # Need a valid overlay, but exclude None.
225 assert overlay_type and overlay_type in constants.VALID_OVERLAYS
226
227 if build_targets:
228 overlays = portage_util.FindOverlaysForBoards(
229 overlay_type, boards=[t.name for t in build_targets])
230 else:
231 overlays = portage_util.FindOverlays(overlay_type)
232
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700233 return uprev_overlays(
234 overlays,
235 build_targets=build_targets,
236 chroot=chroot,
237 output_dir=output_dir)
Alex Kleineb77ffa2019-05-28 14:47:44 -0600238
239
240def uprev_overlays(overlays, build_targets=None, chroot=None, output_dir=None):
241 """Uprev the given overlays.
242
243 Args:
244 overlays (list[str]): The list of overlay paths.
Alex Klein2960c752020-03-09 13:43:38 -0600245 build_targets (list[build_target_lib.BuildTarget]|None): The build targets
Alex Kleineb77ffa2019-05-28 14:47:44 -0600246 to clean in |chroot|, if desired. No effect unless |chroot| is provided.
247 chroot (chroot_lib.Chroot|None): The chroot to clean, if desired.
248 output_dir (str|None): The path to optionally dump result files.
249
250 Returns:
251 list[str] - The paths to all of the modified ebuild files. This includes the
252 new files that were added (i.e. the new versions) and all of the removed
253 files (i.e. the old versions).
254 """
255 assert overlays
256
257 manifest = git.ManifestCheckout.Cached(constants.SOURCE_ROOT)
258
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700259 uprev_manager = uprev_lib.UprevOverlayManager(
260 overlays,
261 manifest,
262 build_targets=build_targets,
263 chroot=chroot,
264 output_dir=output_dir)
Alex Kleineb77ffa2019-05-28 14:47:44 -0600265 uprev_manager.uprev()
266
267 return uprev_manager.modified_ebuilds
268
269
Alex Klein87531182019-08-12 15:23:37 -0600270def uprev_versioned_package(package, build_targets, refs, chroot):
271 """Call registered uprev handler function for the package.
272
273 Args:
274 package (portage_util.CPV): The package being uprevved.
Alex Klein2960c752020-03-09 13:43:38 -0600275 build_targets (list[build_target_lib.BuildTarget]): The build targets to
Alex Klein87531182019-08-12 15:23:37 -0600276 clean on a successful uprev.
277 refs (list[uprev_lib.GitRef]):
278 chroot (chroot_lib.Chroot): The chroot to enter for cleaning.
279
280 Returns:
Alex Klein34afcbc2019-08-22 16:14:31 -0600281 UprevVersionedPackageResult: The result.
Alex Klein87531182019-08-12 15:23:37 -0600282 """
283 assert package
284
285 if package.cp not in _UPREV_FUNCS:
286 raise UnknownPackageError(
287 'Package "%s" does not have a registered handler.' % package.cp)
288
Andrew Lambea9a8a22019-12-12 14:03:43 -0700289 return _UPREV_FUNCS[package.cp](build_targets, refs, chroot)
Alex Klein87531182019-08-12 15:23:37 -0600290
291
Navil Perezf57ba872020-06-04 22:38:37 +0000292@uprevs_versioned_package('media-libs/virglrenderer')
293def uprev_virglrenderer(_build_targets, refs, _chroot):
294 """Updates virglrenderer ebuilds.
295
296 See: uprev_versioned_package.
297
298 Returns:
299 UprevVersionedPackageResult: The result of updating virglrenderer ebuilds.
300 """
Navil Perezf57ba872020-06-04 22:38:37 +0000301 overlay = os.path.join(constants.SOURCE_ROOT,
302 constants.CHROMIUMOS_OVERLAY_DIR)
George Engelbrechte73f2782020-06-10 14:10:46 -0600303 repo_path = os.path.join(constants.SOURCE_ROOT, 'src', 'third_party',
304 'virglrenderer')
305 manifest = git.ManifestCheckout.Cached(repo_path)
Navil Perezf57ba872020-06-04 22:38:37 +0000306
307 uprev_manager = uprev_lib.UprevOverlayManager([overlay], manifest)
308 # TODO(crbug.com/1066242): Ebuilds for virglrenderer are currently
309 # blacklisted. Do not force uprevs after builder is stable and ebuilds are no
310 # longer blacklisted.
311 uprev_manager.uprev(package_list=['media-libs/virglrenderer'], force=True)
312
George Engelbrechte73f2782020-06-10 14:10:46 -0600313 updated_files = uprev_manager.modified_ebuilds
Navil Perezf57ba872020-06-04 22:38:37 +0000314 result = UprevVersionedPackageResult()
315 result.add_result(refs[0].revision, updated_files)
316 return result
317
318
Yaakov Shaul395ae832019-09-09 14:45:32 -0600319@uprevs_versioned_package('afdo/kernel-profiles')
320def uprev_kernel_afdo(*_args, **_kwargs):
David Burger92485342019-09-10 17:52:45 -0600321 """Updates kernel ebuilds with versions from kernel_afdo.json.
Yaakov Shaul395ae832019-09-09 14:45:32 -0600322
323 See: uprev_versioned_package.
Yaakov Shaul1eafe832019-09-10 16:50:26 -0600324
325 Raises:
326 EbuildManifestError: When ebuild manifest does not complete successfuly.
Yaakov Shaul395ae832019-09-09 14:45:32 -0600327 """
328 path = os.path.join(constants.SOURCE_ROOT, 'src', 'third_party',
329 'toolchain-utils', 'afdo_metadata', 'kernel_afdo.json')
330
David Burger92485342019-09-10 17:52:45 -0600331 with open(path, 'r') as f:
332 versions = json.load(f)
Yaakov Shaul395ae832019-09-09 14:45:32 -0600333
Yaakov Shaul730814a2019-09-10 13:58:25 -0600334 result = UprevVersionedPackageResult()
Yaakov Shaul395ae832019-09-09 14:45:32 -0600335 for version, version_info in versions.items():
Yaakov Shauldd8b4112019-09-11 11:44:03 -0600336 path = os.path.join('src', 'third_party', 'chromiumos-overlay',
337 'sys-kernel', version)
338 ebuild_path = os.path.join(constants.SOURCE_ROOT, path,
339 '%s-9999.ebuild' % version)
Yaakov Shaula187b152019-09-11 12:41:32 -0600340 chroot_ebuild_path = os.path.join(constants.CHROOT_SOURCE_ROOT, path,
341 '%s-9999.ebuild' % version)
Yaakov Shaul730814a2019-09-10 13:58:25 -0600342 afdo_profile_version = version_info['name']
Yaakov Shaulcb1cfc32019-09-16 13:51:19 -0600343 patch_ebuild_vars(ebuild_path,
344 dict(AFDO_PROFILE_VERSION=afdo_profile_version))
Yaakov Shaul1eafe832019-09-10 16:50:26 -0600345
346 try:
Yaakov Shaul730814a2019-09-10 13:58:25 -0600347 cmd = ['ebuild', chroot_ebuild_path, 'manifest', '--force']
Mike Frysinger45602c72019-09-22 02:15:11 -0400348 cros_build_lib.run(cmd, enter_chroot=True)
Yaakov Shaul1eafe832019-09-10 16:50:26 -0600349 except cros_build_lib.RunCommandError as e:
350 raise EbuildManifestError(
351 'Error encountered when regenerating the manifest for ebuild: %s\n%s'
Yaakov Shaula187b152019-09-11 12:41:32 -0600352 % (chroot_ebuild_path, e), e)
Yaakov Shaul1eafe832019-09-10 16:50:26 -0600353
Yaakov Shauldd8b4112019-09-11 11:44:03 -0600354 manifest_path = os.path.join(constants.SOURCE_ROOT, path, 'Manifest')
Yaakov Shaul1eafe832019-09-10 16:50:26 -0600355
Yaakov Shaul730814a2019-09-10 13:58:25 -0600356 result.add_result(afdo_profile_version, [ebuild_path, manifest_path])
357
358 return result
Yaakov Shaul395ae832019-09-09 14:45:32 -0600359
360
Trent Begineb624182020-07-14 10:09:45 -0600361@uprevs_versioned_package('chromeos-base/termina-dlc')
362def uprev_termina_dlc(_build_targets, _refs, chroot):
363 """Updates shared termina-dlc ebuild - chromeos-base/termina-dlc.
Trent Beginaf51f1b2020-03-09 17:35:31 -0600364
365 See: uprev_versioned_package.
366 """
Trent Begineb624182020-07-14 10:09:45 -0600367 package = 'termina-dlc'
Trent Beginaf51f1b2020-03-09 17:35:31 -0600368 package_path = os.path.join(constants.CHROMIUMOS_OVERLAY_DIR, 'chromeos-base',
369 package)
370 version_pin_path = os.path.join(package_path, 'VERSION-PIN')
371 return uprev_ebuild_from_pin(package_path, version_pin_path, chroot)
372
373
Trent Begin315d9d92019-12-03 21:55:53 -0700374@uprevs_versioned_package('chromeos-base/chromeos-dtc-vm')
Trent Beginaf51f1b2020-03-09 17:35:31 -0600375def uprev_sludge(_build_targets, _refs, chroot):
Trent Begin315d9d92019-12-03 21:55:53 -0700376 """Updates sludge VM - chromeos-base/chromeos-dtc-vm.
377
378 See: uprev_versioned_package.
379 """
380 package = 'chromeos-dtc-vm'
Trent Begind943df92020-02-25 10:30:10 -0700381 package_path = os.path.join('src', 'private-overlays',
382 'project-wilco-private', 'chromeos-base', package)
383 version_pin_path = os.path.join(package_path, 'VERSION-PIN')
Trent Begin315d9d92019-12-03 21:55:53 -0700384
Trent Begin6daa8702020-01-29 14:58:12 -0700385 return uprev_ebuild_from_pin(package_path, version_pin_path, chroot)
Trent Begin315d9d92019-12-03 21:55:53 -0700386
387
Trent Begin6daa8702020-01-29 14:58:12 -0700388def uprev_ebuild_from_pin(package_path, version_pin_path, chroot):
Trent Begin315d9d92019-12-03 21:55:53 -0700389 """Changes the package ebuild's version to match the version pin file.
390
391 Args:
392 package_path: The path of the package relative to the src root. This path
393 should contain a single ebuild with the same name as the package.
Trent Begind943df92020-02-25 10:30:10 -0700394 version_pin_path: The path of the version_pin file that contains only a
395 version string. The ebuild's version will be directly set to this
Trent Begin315d9d92019-12-03 21:55:53 -0700396 number.
Trent Begin6daa8702020-01-29 14:58:12 -0700397 chroot (chroot_lib.Chroot): specify a chroot to enter.
Trent Begin315d9d92019-12-03 21:55:53 -0700398
399 Returns:
400 UprevVersionedPackageResult: The result.
401 """
402 package = os.path.basename(package_path)
Trent Begind943df92020-02-25 10:30:10 -0700403
404 package_src_path = os.path.join(constants.SOURCE_ROOT, package_path)
405 ebuild_paths = list(portage_util.EBuild.List(package_src_path))
Fergus Dall2209d0b2020-08-06 11:51:43 +1000406 stable_ebuild = None
407 unstable_ebuild = None
408 for path in ebuild_paths:
409 ebuild = portage_util.EBuild(path)
410 if ebuild.is_stable:
411 stable_ebuild = ebuild
412 else:
413 unstable_ebuild = ebuild
414
415 if stable_ebuild is None:
416 raise UprevError('No stable ebuild found for %s' % package)
417 if unstable_ebuild is None:
418 raise UprevError('No unstable ebuild found for %s' % package)
419 if len(ebuild_paths) > 2:
420 raise UprevError('Found too many ebuilds for %s: '
421 'expected one stable and one unstable' % package)
Trent Begin315d9d92019-12-03 21:55:53 -0700422
Trent Begind943df92020-02-25 10:30:10 -0700423 version_pin_src_path = os.path.join(constants.SOURCE_ROOT, version_pin_path)
424 version = osutils.ReadFile(version_pin_src_path).strip()
Fergus Dall2209d0b2020-08-06 11:51:43 +1000425
426 # If the new version is the same as the old version, bump the revision number,
427 # otherwise reset it to 1
428 if version == stable_ebuild.version_no_rev:
429 version = '%s-r%d' % (version, stable_ebuild.current_revision + 1)
430 else:
431 version = version + '-r1'
432
Fergus Dall6d5b7472020-08-13 21:24:28 +1000433 new_ebuild_path = os.path.join(package_path,
434 '%s-%s.ebuild' % (package, version))
435 new_ebuild_src_path = os.path.join(constants.SOURCE_ROOT,
436 new_ebuild_path)
Trent Begin4a11a632020-02-28 12:59:58 -0700437 manifest_src_path = os.path.join(package_src_path, 'Manifest')
Fergus Dall2209d0b2020-08-06 11:51:43 +1000438
439 portage_util.EBuild.MarkAsStable(unstable_ebuild.ebuild_path,
440 new_ebuild_src_path, {})
441 osutils.SafeUnlink(stable_ebuild.ebuild_path)
Trent Begin315d9d92019-12-03 21:55:53 -0700442
Trent Begin6daa8702020-01-29 14:58:12 -0700443 try:
Fergus Dall6d5b7472020-08-13 21:24:28 +1000444 # UpdateEbuildManifest runs inside the chroot and therefore needs a
445 # chroot-relative path.
446 new_ebuild_chroot_path = os.path.join(constants.CHROOT_SOURCE_ROOT,
447 new_ebuild_path)
448 portage_util.UpdateEbuildManifest(new_ebuild_chroot_path, chroot=chroot)
Trent Begin6daa8702020-01-29 14:58:12 -0700449 except cros_build_lib.RunCommandError as e:
Trent Begind943df92020-02-25 10:30:10 -0700450 raise EbuildManifestError(
Trent Begin6daa8702020-01-29 14:58:12 -0700451 'Unable to update manifest for %s: %s' % (package, e.stderr))
452
Trent Begin315d9d92019-12-03 21:55:53 -0700453 result = UprevVersionedPackageResult()
Trent Begin4a11a632020-02-28 12:59:58 -0700454 result.add_result(version,
Fergus Dall2209d0b2020-08-06 11:51:43 +1000455 [new_ebuild_src_path,
456 stable_ebuild.ebuild_path,
457 manifest_src_path])
Trent Begin315d9d92019-12-03 21:55:53 -0700458 return result
459
460
Alex Klein87531182019-08-12 15:23:37 -0600461@uprevs_versioned_package(constants.CHROME_CP)
Andrew Lambea9a8a22019-12-12 14:03:43 -0700462def uprev_chrome(build_targets, refs, chroot):
Alex Klein87531182019-08-12 15:23:37 -0600463 """Uprev chrome and its related packages.
464
465 See: uprev_versioned_package.
466 """
467 # Determine the version from the refs (tags), i.e. the chrome versions are the
468 # tag names.
469 chrome_version = uprev_lib.get_chrome_version_from_refs(refs)
Chris McDonald25881af2020-05-12 03:17:53 -0600470 logging.debug('Chrome version determined from refs: %s', chrome_version)
Alex Klein87531182019-08-12 15:23:37 -0600471
472 uprev_manager = uprev_lib.UprevChromeManager(
473 chrome_version, build_targets=build_targets, chroot=chroot)
David Burger37f48672019-09-18 17:07:56 -0600474 result = UprevVersionedPackageResult()
Alex Klein87531182019-08-12 15:23:37 -0600475 # Start with chrome itself, as we can't do anything else unless chrome
476 # uprevs successfully.
Chris McDonald25881af2020-05-12 03:17:53 -0600477 # TODO(crbug.com/1080429): Handle all possible outcomes of a Chrome uprev
478 # attempt. The expected behavior is documented in the following table:
479 #
480 # Outcome of Chrome uprev attempt:
481 # NEWER_VERSION_EXISTS:
482 # Do nothing.
483 # SAME_VERSION_EXISTS or REVISION_BUMP:
484 # Uprev followers
485 # Assert not VERSION_BUMP (any other outcome is fine)
486 # VERSION_BUMP or NEW_EBUILD_CREATED:
487 # Uprev followers
488 # Assert that Chrome & followers are at same package version
Alex Klein87531182019-08-12 15:23:37 -0600489 if not uprev_manager.uprev(constants.CHROME_CP):
David Burger37f48672019-09-18 17:07:56 -0600490 return result
Alex Klein87531182019-08-12 15:23:37 -0600491
492 # With a successful chrome rev, also uprev related packages.
493 for package in constants.OTHER_CHROME_PACKAGES:
494 uprev_manager.uprev(package)
495
David Burger37f48672019-09-18 17:07:56 -0600496 return result.add_result(chrome_version, uprev_manager.modified_ebuilds)
Alex Klein87531182019-08-12 15:23:37 -0600497
498
Andrew Lamb9563a152019-12-04 11:42:18 -0700499def _generate_platform_c_files(replication_config, chroot):
500 """Generates platform C files from a platform JSON payload.
501
502 Args:
503 replication_config (replication_config_pb2.ReplicationConfig): A
504 ReplicationConfig that has already been run. If it produced a
505 build_config.json file, that file will be used to generate platform C
506 files. Otherwise, nothing will be generated.
507 chroot (chroot_lib.Chroot): The chroot to use to generate.
508
509 Returns:
510 A list of generated files.
511 """
512 # Generate the platform C files from the build config. Note that it would be
513 # more intuitive to generate the platform C files from the platform config;
514 # however, cros_config_schema does not allow this, because the platform config
515 # payload is not always valid input. For example, if a property is both
516 # 'required' and 'build-only', it will fail schema validation. Thus, use the
517 # build config, and use '-f' to filter.
518 build_config_path = [
519 rule.destination_path
520 for rule in replication_config.file_replication_rules
521 if rule.destination_path.endswith('build_config.json')
522 ]
523
524 if not build_config_path:
525 logging.info(
Alex Kleinad6b48a2020-01-08 16:57:41 -0700526 'No build_config.json found, will not generate platform C files. '
527 'Replication config: %s', replication_config)
Andrew Lamb9563a152019-12-04 11:42:18 -0700528 return []
529
530 if len(build_config_path) > 1:
Alex Kleinad6b48a2020-01-08 16:57:41 -0700531 raise ValueError('Expected at most one build_config.json destination path. '
532 'Replication config: %s' % replication_config)
Andrew Lamb9563a152019-12-04 11:42:18 -0700533
534 build_config_path = build_config_path[0]
535
536 # Paths to the build_config.json and dir to output C files to, in the
537 # chroot.
538 build_config_chroot_path = os.path.join(constants.CHROOT_SOURCE_ROOT,
539 build_config_path)
540 generated_output_chroot_dir = os.path.join(constants.CHROOT_SOURCE_ROOT,
541 os.path.dirname(build_config_path))
542
543 command = [
544 'cros_config_schema', '-m', build_config_chroot_path, '-g',
545 generated_output_chroot_dir, '-f', '"TRUE"'
546 ]
547
548 cros_build_lib.run(
549 command, enter_chroot=True, chroot_args=chroot.get_enter_args())
550
551 # A relative (to the source root) path to the generated C files.
552 generated_output_dir = os.path.dirname(build_config_path)
553 generated_files = []
554 expected_c_files = ['config.c', 'ec_config.c', 'ec_config.h']
555 for f in expected_c_files:
556 if os.path.exists(
557 os.path.join(constants.SOURCE_ROOT, generated_output_dir, f)):
558 generated_files.append(os.path.join(generated_output_dir, f))
559
560 if len(expected_c_files) != len(generated_files):
561 raise GeneratedCrosConfigFilesError(expected_c_files, generated_files)
562
563 return generated_files
564
565
Andrew Lambe836f222019-12-09 12:27:38 -0700566def _get_private_overlay_package_root(ref, package):
567 """Returns the absolute path to the root of a given private overlay.
568
569 Args:
570 ref (uprev_lib.GitRef): GitRef for the private overlay.
571 package (str): Path to the package in the overlay.
572 """
573 # There might be a cleaner way to map from package -> path within the source
574 # tree. For now, just use string patterns.
Andrew Lamb4aa09912020-01-08 13:55:56 -0700575 private_overlay_ref_pattern = r'/chromeos\/overlays\/overlay-([\w-]+)-private'
Andrew Lambe836f222019-12-09 12:27:38 -0700576 match = re.match(private_overlay_ref_pattern, ref.path)
577 if not match:
578 raise ValueError('ref.path must match the pattern: %s. Actual ref: %s' %
579 (private_overlay_ref_pattern, ref))
580
581 overlay = match.group(1)
582
583 return os.path.join(constants.SOURCE_ROOT,
584 'src/private-overlays/overlay-%s-private' % overlay,
585 package)
586
587
Andrew Lambea9a8a22019-12-12 14:03:43 -0700588@uprevs_versioned_package('chromeos-base/chromeos-config-bsp')
589def replicate_private_config(_build_targets, refs, chroot):
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700590 """Replicate a private cros_config change to the corresponding public config.
591
Alex Kleinad6b48a2020-01-08 16:57:41 -0700592 See uprev_versioned_package for args
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700593 """
Andrew Lambea9a8a22019-12-12 14:03:43 -0700594 package = 'chromeos-base/chromeos-config-bsp'
595
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700596 if len(refs) != 1:
597 raise ValueError('Expected exactly one ref, actual %s' % refs)
598
599 # Expect a replication_config.jsonpb in the package root.
Andrew Lambe836f222019-12-09 12:27:38 -0700600 package_root = _get_private_overlay_package_root(refs[0], package)
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700601 replication_config_path = os.path.join(package_root,
602 'replication_config.jsonpb')
603
604 try:
605 replication_config = json_format.Parse(
606 osutils.ReadFile(replication_config_path),
607 replication_config_pb2.ReplicationConfig())
608 except IOError:
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700609 raise ValueError(
610 'Expected ReplicationConfig missing at %s' % replication_config_path)
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700611
612 replication_lib.Replicate(replication_config)
613
614 modified_files = [
615 rule.destination_path
616 for rule in replication_config.file_replication_rules
617 ]
618
Andrew Lamb9563a152019-12-04 11:42:18 -0700619 # The generated platform C files are not easily filtered by replication rules,
620 # i.e. JSON / proto filtering can be described by a FieldMask, arbitrary C
621 # files cannot. Therefore, replicate and filter the JSON payloads, and then
622 # generate filtered C files from the JSON payload.
623 modified_files.extend(_generate_platform_c_files(replication_config, chroot))
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700624
625 # Use the private repo's commit hash as the new version.
626 new_private_version = refs[0].revision
627
Andrew Lamb988f4da2019-12-10 10:16:43 -0700628 # modified_files should contain only relative paths at this point, but the
629 # returned UprevVersionedPackageResult must contain only absolute paths.
630 for i, modified_file in enumerate(modified_files):
631 assert not os.path.isabs(modified_file)
632 modified_files[i] = os.path.join(constants.SOURCE_ROOT, modified_file)
633
Andrew Lamb2bde9e42019-11-04 13:24:09 -0700634 return UprevVersionedPackageResult().add_result(new_private_version,
635 modified_files)
636
637
Alex Kleinbbef2b32019-08-27 10:38:50 -0600638def get_best_visible(atom, build_target=None):
639 """Returns the best visible CPV for the given atom.
640
641 Args:
642 atom (str): The atom to look up.
Alex Klein2960c752020-03-09 13:43:38 -0600643 build_target (build_target_lib.BuildTarget): The build target whose
Alex Kleinda39c6d2019-09-16 14:36:36 -0600644 sysroot should be searched, or the SDK if not provided.
Alex Kleinad6b48a2020-01-08 16:57:41 -0700645
646 Returns:
647 portage_util.CPV|None: The best visible package.
Alex Kleinbbef2b32019-08-27 10:38:50 -0600648 """
David Burger1e0fe232019-07-01 14:52:07 -0600649 assert atom
Alex Kleinbbef2b32019-08-27 10:38:50 -0600650
651 board = build_target.name if build_target else None
652 return portage_util.PortageqBestVisible(atom, board=board)
Alex Kleinda39c6d2019-09-16 14:36:36 -0600653
654
Alex Klein149fd3b2019-12-16 16:01:05 -0700655def has_prebuilt(atom, build_target=None, useflags=None):
Alex Kleinda39c6d2019-09-16 14:36:36 -0600656 """Check if a prebuilt exists.
657
658 Args:
659 atom (str): The package whose prebuilt is being queried.
Alex Klein2960c752020-03-09 13:43:38 -0600660 build_target (build_target_lib.BuildTarget): The build target whose
Alex Kleinda39c6d2019-09-16 14:36:36 -0600661 sysroot should be searched, or the SDK if not provided.
Alex Klein149fd3b2019-12-16 16:01:05 -0700662 useflags: Any additional USE flags that should be set. May be a string
663 of properly formatted USE flags, or an iterable of individual flags.
Alex Kleinad6b48a2020-01-08 16:57:41 -0700664
665 Returns:
666 bool: True iff there is an available prebuilt, False otherwise.
Alex Kleinda39c6d2019-09-16 14:36:36 -0600667 """
668 assert atom
669
670 board = build_target.name if build_target else None
Alex Klein149fd3b2019-12-16 16:01:05 -0700671 extra_env = None
672 if useflags:
673 new_flags = useflags
674 if not isinstance(useflags, six.string_types):
675 new_flags = ' '.join(useflags)
676
677 existing = os.environ.get('USE', '')
678 final_flags = '%s %s' % (existing, new_flags)
679 extra_env = {'USE': final_flags.strip()}
680 return portage_util.HasPrebuilt(atom, board=board, extra_env=extra_env)
Alex Klein36b117f2019-09-30 15:13:46 -0600681
682
David Burger0f9dd4e2019-10-08 12:33:42 -0600683def builds(atom, build_target, packages=None):
Alex Klein36b117f2019-09-30 15:13:46 -0600684 """Check if |build_target| builds |atom| (has it in its depgraph)."""
685 cros_build_lib.AssertInsideChroot()
686
Alex Kleind8cd4c62020-09-14 13:37:47 -0600687 pkgs = tuple(packages) if packages else None
LaMont Jones4cbecba2020-05-12 11:54:27 -0600688 # TODO(crbug/1081828): Receive and use sysroot.
689 graph, _sdk_graph = dependency.GetBuildDependency(
Alex Kleind8cd4c62020-09-14 13:37:47 -0600690 build_target.root, build_target.name, pkgs)
Alex Klein36b117f2019-09-30 15:13:46 -0600691 return any(atom in package for package in graph['package_deps'])
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600692
693
Michael Mortensenb51a1f02019-10-16 13:28:20 -0600694def determine_chrome_version(build_target):
Michael Mortensenc2615b72019-10-15 08:12:24 -0600695 """Returns the current Chrome version for the board (or in buildroot).
696
697 Args:
Alex Klein2960c752020-03-09 13:43:38 -0600698 build_target (build_target_lib.BuildTarget): The board build target.
Alex Kleinad6b48a2020-01-08 16:57:41 -0700699
700 Returns:
701 str|None: The chrome version if available.
Michael Mortensenc2615b72019-10-15 08:12:24 -0600702 """
Michael Mortensen9fe740c2019-10-29 14:42:48 -0600703 # TODO(crbug/1019770): Long term we should not need the try/catch here once
704 # the builds function above only returns True for chrome when
705 # determine_chrome_version will succeed.
706 try:
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700707 cpv = portage_util.PortageqBestVisible(
708 constants.CHROME_CP, build_target.name, cwd=constants.SOURCE_ROOT)
Michael Mortensen9fe740c2019-10-29 14:42:48 -0600709 except cros_build_lib.RunCommandError as e:
710 # Return None because portage failed when trying to determine the chrome
711 # version.
712 logging.warning('Caught exception in determine_chrome_package: %s', e)
713 return None
Michael Mortensenc2615b72019-10-15 08:12:24 -0600714 # Something like 78.0.3877.4_rc -> 78.0.3877.4
715 return cpv.version_no_rev.partition('_')[0]
716
717
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600718def determine_android_package(board):
719 """Returns the active Android container package in use by the board.
720
721 Args:
722 board: The board name this is specific to.
Alex Kleinad6b48a2020-01-08 16:57:41 -0700723
724 Returns:
725 str|None: The android package string if there is one.
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600726 """
Michael Mortensene0f4b542019-10-24 15:30:23 -0600727 try:
728 packages = portage_util.GetPackageDependencies(board, 'virtual/target-os')
Michael Mortensene0f4b542019-10-24 15:30:23 -0600729 except cros_build_lib.RunCommandError as e:
730 # Return None because a command (likely portage) failed when trying to
731 # determine the package.
732 logging.warning('Caught exception in determine_android_package: %s', e)
733 return None
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600734
Alex Kleinad6b48a2020-01-08 16:57:41 -0700735 # We assume there is only one Android package in the depgraph.
736 for package in packages:
737 if package.startswith('chromeos-base/android-container-') or \
738 package.startswith('chromeos-base/android-vm-'):
739 return package
740 return None
741
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600742
743def determine_android_version(boards=None):
744 """Determine the current Android version in buildroot now and return it.
745
746 This uses the typical portage logic to determine which version of Android
747 is active right now in the buildroot.
748
749 Args:
750 boards: List of boards to check version of.
751
752 Returns:
753 The Android build ID of the container for the boards.
754
755 Raises:
756 NoAndroidVersionError: if no unique Android version can be determined.
757 """
758 if not boards:
759 return None
760 # Verify that all boards have the same version.
761 version = None
762 for board in boards:
763 package = determine_android_package(board)
764 if not package:
Michael Mortensenedf76532019-10-16 14:22:37 -0600765 return None
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600766 cpv = portage_util.SplitCPV(package)
767 if not cpv:
768 raise NoAndroidVersionError(
769 'Android version could not be determined for %s' % board)
770 if not version:
771 version = cpv.version_no_rev
772 elif version != cpv.version_no_rev:
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700773 raise NoAndroidVersionError('Different Android versions (%s vs %s) for %s'
774 % (version, cpv.version_no_rev, boards))
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600775 return version
776
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700777
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600778def determine_android_branch(board):
779 """Returns the Android branch in use by the active container ebuild."""
780 try:
781 android_package = determine_android_package(board)
782 except cros_build_lib.RunCommandError:
783 raise NoAndroidBranchError(
784 'Android branch could not be determined for %s' % board)
785 if not android_package:
Michael Mortensenedf76532019-10-16 14:22:37 -0600786 return None
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600787 ebuild_path = portage_util.FindEbuildForBoardPackage(android_package, board)
788 # We assume all targets pull from the same branch and that we always
Federico 'Morg' Pareschicd9165a2020-05-29 09:45:55 +0900789 # have at least one of the following targets.
Shao-Chuan Lee73bba612020-06-17 11:47:04 +0900790 targets = constants.ANDROID_ALL_BUILD_TARGETS
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600791 ebuild_content = osutils.SourceEnvironment(ebuild_path, targets)
792 for target in targets:
793 if target in ebuild_content:
794 branch = re.search(r'(.*?)-linux-', ebuild_content[target])
795 if branch is not None:
796 return branch.group(1)
797 raise NoAndroidBranchError(
798 'Android branch could not be determined for %s (ebuild empty?)' % board)
799
800
801def determine_android_target(board):
Michael Mortensen14960d02019-10-18 07:53:59 -0600802 """Returns the Android target in use by the active container ebuild."""
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600803 try:
804 android_package = determine_android_package(board)
805 except cros_build_lib.RunCommandError:
806 raise NoAndroidTargetError(
807 'Android Target could not be determined for %s' % board)
808 if not android_package:
Michael Mortensenedf76532019-10-16 14:22:37 -0600809 return None
Michael Mortensenb70e8a82019-10-10 18:43:41 -0600810 if android_package.startswith('chromeos-base/android-vm-'):
811 return 'bertha'
812 elif android_package.startswith('chromeos-base/android-container-'):
813 return 'cheets'
814
815 raise NoAndroidTargetError(
816 'Android Target cannot be determined for the package: %s' %
817 android_package)
Michael Mortensen9fdb14b2019-10-17 11:17:30 -0600818
819
820def determine_platform_version():
821 """Returns the platform version from the source root."""
Michael Mortensen009cb662019-10-21 11:38:43 -0600822 # Platform version is something like '12575.0.0'.
Michael Mortensen9fdb14b2019-10-17 11:17:30 -0600823 version = manifest_version.VersionInfo.from_repo(constants.SOURCE_ROOT)
824 return version.VersionString()
Michael Mortensen009cb662019-10-21 11:38:43 -0600825
826
827def determine_milestone_version():
828 """Returns the platform version from the source root."""
829 # Milestone version is something like '79'.
830 version = manifest_version.VersionInfo.from_repo(constants.SOURCE_ROOT)
831 return version.chrome_branch
832
Alex Klein7a3a7dd2020-01-08 16:44:38 -0700833
Michael Mortensen009cb662019-10-21 11:38:43 -0600834def determine_full_version():
835 """Returns the full version from the source root."""
836 # Full version is something like 'R79-12575.0.0'.
837 milestone_version = determine_milestone_version()
838 platform_version = determine_platform_version()
839 full_version = ('R%s-%s' % (milestone_version, platform_version))
840 return full_version
Michael Mortensen71ef5682020-05-07 14:29:24 -0600841
842
Michael Mortensende716a12020-05-15 11:27:00 -0600843def find_fingerprints(build_target):
844 """Returns a list of fingerprints for this build.
845
846 Args:
847 build_target (build_target_lib.BuildTarget): The build target.
848
849 Returns:
850 list[str] - List of fingerprint strings.
851 """
852 cros_build_lib.AssertInsideChroot()
853 fp_file = 'cheets-fingerprint.txt'
854 fp_path = os.path.join(
855 image_lib.GetLatestImageLink(build_target.name),
856 fp_file)
857 if not os.path.isfile(fp_path):
858 logging.info('Fingerprint file not found: %s', fp_path)
Michael Mortensend81d81e2020-06-09 14:20:59 -0600859 return []
Michael Mortensende716a12020-05-15 11:27:00 -0600860 logging.info('Reading fingerprint file: %s', fp_path)
861 fingerprints = osutils.ReadFile(fp_path).splitlines()
862 return fingerprints
863
864
Michael Mortensen59e30872020-05-18 14:12:49 -0600865def get_all_firmware_versions(build_target):
866 """Extract firmware version for all models present.
867
868 Args:
869 build_target (build_target_lib.BuildTarget): The build target.
870
871 Returns:
872 A dict of FirmwareVersions namedtuple instances by model.
873 Each element will be populated based on whether it was present in the
874 command output.
875 """
876 cros_build_lib.AssertInsideChroot()
877 result = {}
878 # Note that example output for _get_firmware_version_cmd_result is available
879 # in the packages_unittest.py for testing get_all_firmware_versions.
880 cmd_result = _get_firmware_version_cmd_result(build_target)
881
882 # There is a blank line between the version info for each model.
883 firmware_version_payloads = cmd_result.split('\n\n')
884 for firmware_version_payload in firmware_version_payloads:
885 if 'BIOS' in firmware_version_payload:
886 firmware_version = _find_firmware_versions(firmware_version_payload)
887 result[firmware_version.model] = firmware_version
888 return result
889
890
Michael Mortensen71ef5682020-05-07 14:29:24 -0600891FirmwareVersions = collections.namedtuple(
892 'FirmwareVersions', ['model', 'main', 'main_rw', 'ec', 'ec_rw'])
893
894
895def get_firmware_versions(build_target):
896 """Extract version information from the firmware updater, if one exists.
897
898 Args:
899 build_target (build_target_lib.BuildTarget): The build target.
900
901 Returns:
902 A FirmwareVersions namedtuple instance.
903 Each element will either be set to the string output by the firmware
904 updater shellball, or None if there is no firmware updater.
905 """
906 cros_build_lib.AssertInsideChroot()
907 cmd_result = _get_firmware_version_cmd_result(build_target)
908 if cmd_result:
909 return _find_firmware_versions(cmd_result)
910 else:
911 return FirmwareVersions(None, None, None, None, None)
912
913
914def _get_firmware_version_cmd_result(build_target):
915 """Gets the raw result output of the firmware updater version command.
916
917 Args:
918 build_target (build_target_lib.BuildTarget): The build target.
919
920 Returns:
921 Command execution result.
922 """
923 updater = os.path.join(build_target.root,
924 'usr/sbin/chromeos-firmwareupdate')
925 logging.info('Calling updater %s', updater)
926 # Call the updater using the chroot-based path.
927 return cros_build_lib.run([updater, '-V'],
928 capture_output=True, log_output=True,
929 encoding='utf-8').stdout
930
931
932def _find_firmware_versions(cmd_output):
933 """Finds firmware version output via regex matches against the cmd_output.
934
935 Args:
936 cmd_output: The raw output to search against.
937
938 Returns:
939 FirmwareVersions namedtuple with results.
940 Each element will either be set to the string output by the firmware
941 updater shellball, or None if there is no match.
942 """
943
944 # Sometimes a firmware bundle includes a special combination of RO+RW
945 # firmware. In this case, the RW firmware version is indicated with a "(RW)
946 # version" field. In other cases, the "(RW) version" field is not present.
947 # Therefore, search for the "(RW)" fields first and if they aren't present,
948 # fallback to the other format. e.g. just "BIOS version:".
949 # TODO(mmortensen): Use JSON once the firmware updater supports it.
950 main = None
951 main_rw = None
952 ec = None
953 ec_rw = None
954 model = None
955
956 match = re.search(r'BIOS version:\s*(?P<version>.*)', cmd_output)
957 if match:
958 main = match.group('version')
959
960 match = re.search(r'BIOS \(RW\) version:\s*(?P<version>.*)', cmd_output)
961 if match:
962 main_rw = match.group('version')
963
964 match = re.search(r'EC version:\s*(?P<version>.*)', cmd_output)
965 if match:
966 ec = match.group('version')
967
968 match = re.search(r'EC \(RW\) version:\s*(?P<version>.*)', cmd_output)
969 if match:
970 ec_rw = match.group('version')
971
972 match = re.search(r'Model:\s*(?P<model>.*)', cmd_output)
973 if match:
974 model = match.group('model')
975
976 return FirmwareVersions(model, main, main_rw, ec, ec_rw)
Michael Mortensena4af79e2020-05-06 16:18:48 -0600977
978
979MainEcFirmwareVersions = collections.namedtuple(
980 'MainEcFirmwareVersions', ['main_fw_version', 'ec_fw_version'])
981
982def determine_firmware_versions(build_target):
983 """Returns a namedtuple with main and ec firmware versions.
984
985 Args:
986 build_target (build_target_lib.BuildTarget): The build target.
987
988 Returns:
989 MainEcFirmwareVersions namedtuple with results.
990 """
991 fw_versions = get_firmware_versions(build_target)
992 main_fw_version = fw_versions.main_rw or fw_versions.main
993 ec_fw_version = fw_versions.ec_rw or fw_versions.ec
994
995 return MainEcFirmwareVersions(main_fw_version, ec_fw_version)
Michael Mortensenfbf2b2d2020-05-14 16:33:06 -0600996
997def determine_kernel_version(build_target):
998 """Returns a string containing the kernel version for this build target.
999
1000 Args:
1001 build_target (build_target_lib.BuildTarget): The build target.
1002
1003 Returns:
1004 (str) The kernel versions, or None.
1005 """
1006 try:
1007 packages = portage_util.GetPackageDependencies(build_target.name,
1008 'virtual/linux-sources')
1009 except cros_build_lib.RunCommandError as e:
1010 logging.warning('Unable to get package list for metadata: %s', e)
1011 return None
1012 for package in packages:
1013 if package.startswith('sys-kernel/chromeos-kernel-'):
1014 kernel_version = portage_util.SplitCPV(package).version
1015 logging.info('Found active kernel version: %s', kernel_version)
1016 return kernel_version
1017 return None
Michael Mortensen125bb012020-05-21 14:02:10 -06001018
1019
1020def get_models(build_target, log_output=True):
1021 """Obtain a list of models supported by a unified board.
1022
1023 This ignored whitelabel models since GoldenEye has no specific support for
1024 these at present.
1025
1026 Args:
1027 build_target (build_target_lib.BuildTarget): The build target.
1028 log_output: Whether to log the output of the cros_config_host invocation.
1029
1030 Returns:
1031 A list of models supported by this board, if it is a unified build; None,
1032 if it is not a unified build.
1033 """
1034 return _run_cros_config_host(build_target, ['list-models'],
1035 log_output=log_output)
1036
1037
Michael Mortensen359c1f32020-05-28 19:35:42 -06001038def get_key_id(build_target, model):
1039 """Obtain the key_id for a model within the build_target.
1040
1041 Args:
1042 build_target (build_target_lib.BuildTarget): The build target.
1043 model (str): The model name
1044
1045 Returns:
1046 A key_id (str) or None.
1047 """
1048 model_arg = '--model=' + model
1049 key_id_list = _run_cros_config_host(
1050 build_target,
1051 [model_arg, 'get', '/firmware-signing', 'key-id'])
1052 key_id = None
1053 if len(key_id_list) == 1:
1054 key_id = key_id_list[0]
1055 return key_id
1056
1057
Michael Mortensen125bb012020-05-21 14:02:10 -06001058def _run_cros_config_host(build_target, args, log_output=True):
1059 """Run the cros_config_host tool.
1060
1061 Args:
1062 build_target (build_target_lib.BuildTarget): The build target.
1063 args: List of arguments to pass.
1064 log_output: Whether to log the output of the cros_config_host.
1065
1066 Returns:
1067 Output of the tool
1068 """
1069 cros_build_lib.AssertInsideChroot()
1070 tool = '/usr/bin/cros_config_host'
1071 if not os.path.isfile(tool):
1072 return None
1073
1074 config_fname = build_target.full_path(
1075 'usr/share/chromeos-config/yaml/config.yaml')
1076
1077 result = cros_build_lib.run(
1078 [tool, '-c', config_fname] + args,
1079 capture_output=True,
1080 encoding='utf-8',
1081 log_output=log_output,
1082 check=False)
1083 if result.returncode:
1084 # Show the output for debugging purposes.
1085 if 'No such file or directory' not in result.error:
1086 logging.error('cros_config_host failed: %s\n', result.error)
1087 return None
1088 return result.output.strip().splitlines()