def _run_cros_config_host(build_target, args, log_output=True):
"""Run the cros_config_host tool.
Args:
build_target (build_target_lib.BuildTarget): The build target.
args: List of arguments to pass.
log_output: Whether to log the output of the cros_config_host.
Returns:
Output of the tool
"""
cros_build_lib.AssertInsideChroot()
tool = '/usr/bin/cros_config_host'
if not os.path.isfile(tool):
return None
config_fname = build_target.full_path(
'usr/share/chromeos-config/yaml/config.yaml')
result = cros_build_lib.run([tool, '-c', config_fname] + args,
capture_output=True,
encoding='utf-8',
log_output=log_output,
check=False)
if result.returncode:
# Show the output for debugging purposes.
if 'No such file or directory' not in result.error:
logging.error('cros_config_host failed: %s\n', result.error)
return None
return result.output.strip().splitlines()
def main(argv: List[str]) -> None:
cros_build_lib.AssertInsideChroot()
parser = get_parser()
opts = parser.parse_args(argv)
opts.Freeze()
only_files = {Path(f).resolve() for f in opts.file}
git_repo_base = opts.git_repo_base
if git_repo_base:
git_repo_base = Path(opts.git_repo_base)
if not (git_repo_base / '.git').exists():
# This script doesn't strictly care if there's a .git dir there; more of
# a smoke check.
parser.error(f'Given git repo base ({git_repo_base}) has no .git dir')
package_ebuilds = [
portage_util.EBuild(x)
for x in resolve_package_ebuilds(opts.board, opts.package)
]
setup_tidy(opts.board, package_ebuilds)
lints = filter_tidy_lints(
only_files,
git_repo_base,
diags=run_tidy(opts.board, package_ebuilds, opts.keep_lint_dirs,
opts.nonfatal_parse_errors))
osutils.WriteFile(
opts.output,
json.dumps({'tidy_diagnostics': [x.to_dict() for x in lints]}),
atomic=True)
def BuildPackages(target, sysroot, run_configs):
"""Build and install packages into a sysroot.
Args:
target (build_target_lib.BuildTarget): The target whose packages are being
installed.
sysroot (sysroot_lib.Sysroot): The sysroot where the packages are being
installed.
run_configs (BuildPackagesRunConfig): The run configs.
"""
cros_build_lib.AssertInsideChroot()
cmd = [os.path.join(constants.CROSUTILS_DIR, 'build_packages'),
'--board', target.name, '--board_root', sysroot.path]
cmd += run_configs.GetBuildPackagesArgs()
extra_env = run_configs.GetEnv()
extra_env['USE_NEW_PARALLEL_EMERGE'] = '1'
with osutils.TempDir() as tempdir:
extra_env[constants.CROS_METRICS_DIR_ENVVAR] = tempdir
try:
# REVIEW: discuss which dimensions to flatten into the metric
# name other than target.name...
with metrics.timer('service.sysroot.BuildPackages.RunCommand'):
cros_build_lib.run(cmd, extra_env=extra_env)
except cros_build_lib.RunCommandError as e:
failed_pkgs = portage_util.ParseDieHookStatusFile(tempdir)
raise sysroot_lib.PackageInstallError(
str(e), e.result, exception=e, packages=failed_pkgs)
def main(argv):
"""Generate the delta sysroot
Create a tarball containing a sysroot that can be patched over extracted
prebuilt package contents to create a complete sysroot.
1. Unpack all packages for a board into an unpack_only sysroot directory.
2. Emerge all packages for a board into a build sysroot directory.
3. Create a batch file using:
rsync -rplgoDc --delete --write-batch=<batch> <build_sys> <unpackonly_sys>
4. Put the batch file inside a tarball.
"""
options = _ParseCommandLine(argv)
FinishParsing(options)
cros_build_lib.AssertInsideChroot()
with osutils.TempDir(set_global=False, sudo_rm=True) as tmp_dir:
build_sysroot = os.path.join(tmp_dir, 'build-sys')
unpackonly_sysroot = os.path.join(tmp_dir, 'tmp-sys')
batch_filename = options.out_batch
GenerateSysroot(unpackonly_sysroot, options.board, options.build_tests,
unpack_only=True)
GenerateSysroot(build_sysroot, options.board, options.build_tests,
unpack_only=False)
# Finally create batch file.
CreateBatchFile(build_sysroot, unpackonly_sysroot,
os.path.join(tmp_dir, batch_filename))
cros_build_lib.CreateTarball(
os.path.join(options.out_dir, options.out_file), tmp_dir, sudo=True,
inputs=[batch_filename])
def get_all_firmware_versions(build_target):
"""Extract firmware version for all models present.
Args:
build_target (build_target_lib.BuildTarget): The build target.
Returns:
A dict of FirmwareVersions namedtuple instances by model.
Each element will be populated based on whether it was present in the
command output.
"""
cros_build_lib.AssertInsideChroot()
result = {}
# Note that example output for _get_firmware_version_cmd_result is available
# in the packages_unittest.py for testing get_all_firmware_versions.
cmd_result = _get_firmware_version_cmd_result(build_target)
# There is a blank line between the version info for each model.
firmware_version_payloads = cmd_result.split('\n\n')
for firmware_version_payload in firmware_version_payloads:
if 'BIOS' in firmware_version_payload:
firmware_version = _find_firmware_versions(
firmware_version_payload)
result[firmware_version.model] = firmware_version
return result
def main(argv):
"""Parses arguments and executes a command.
Args:
argv: The prorgram arguments.
Returns:
0 on success. Non-zero on failure.
"""
cros_build_lib.AssertInsideChroot()
options = ParseArgs(argv)
if options.board is None:
logging.error('Please specify "--board" or set ".default_board".')
return 1
SysrootPath.SetPathToSysroot(options.board)
InstallBaseDependencies(options)
if options.command == 'cleanup':
ExecuteCleanupCommand()
elif options.command == 'coverage':
ExecuteCoverageCommand(options)
elif options.command == 'setup':
ExecuteSetupCommand()
elif options.command == 'download':
ExecuteDownloadCommand(options)
elif options.command == 'reproduce':
ExecuteReproduceCommand(options)
elif options.command == 'shell':
return ExecuteShellCommand()
return 0
def main(argv):
cros_build_lib.AssertInsideChroot()
opts = _ParseArguments(argv)
site_config = config_lib.GetConfig()
logging.info('Generating board configs. This takes about 2m...')
for key in sorted(binhost.GetChromePrebuiltConfigs(site_config)):
binhost.GenConfigsForBoard(key.board,
regen=opts.regen,
error_code_ok=True)
# Fetch all compat IDs.
fetcher = binhost.CompatIdFetcher()
keys = binhost.GetChromePrebuiltConfigs(site_config).keys()
compat_ids = fetcher.FetchCompatIds(keys)
# Save the PFQ configs.
pfq_configs = binhost.PrebuiltMapping.Get(keys, compat_ids)
filename_internal = binhost.PrebuiltMapping.GetFilename(
opts.buildroot, 'chrome')
pfq_configs.Dump(filename_internal)
git.AddPath(filename_internal)
git.Commit(os.path.dirname(filename_internal),
'Update PFQ config dump',
allow_empty=True)
filename_external = binhost.PrebuiltMapping.GetFilename(opts.buildroot,
'chromium',
internal=False)
pfq_configs.Dump(filename_external, internal=False)
git.AddPath(filename_external)
git.Commit(os.path.dirname(filename_external),
'Update PFQ config dump',
allow_empty=True)
def builds(atom, build_target, packages=None):
"""Check if |build_target| builds |atom| (has it in its depgraph)."""
cros_build_lib.AssertInsideChroot()
graph, _sdk_graph = dependency.GetBuildDependency(build_target.name,
packages)
return any(atom in package for package in graph['package_deps'])
def main(argv):
opts = _ParseArguments(argv)
cros_build_lib.AssertInsideChroot()
board = opts.build_target_name
bests = {}
for cpv in opts.packages:
bests[cpv.atom] = portage_util.PortageqBestVisible(cpv.atom,
board=board)
# Emerge args:
# g: use binpkgs (needed to find if we have one)
# u: update packages to latest version (want updates to invalidate binpkgs)
# D: deep -- consider full tree rather that just immediate deps
# (changes in dependencies and transitive deps can invalidate a binpkg)
# N: Packages with changed use flags should be considered
# (changes in dependencies and transitive deps can invalidate a binpkg)
# q: quiet (simplifies output)
# p: pretend (don't actually install it)
args = ['-guDNqp', '--with-bdeps=y', '--color=n']
if board:
args.append('--board=%s' % board)
args.extend('=%s' % best.cpf for best in bests.values())
generator = depgraph.DepGraphGenerator()
generator.Initialize(args)
results = {}
for atom, best in bests.items():
results[atom] = generator.HasPrebuilt(best.cpf)
osutils.WriteFile(opts.output, json.dumps(results))
def InstallToolchain(target, sysroot, run_configs):
"""Update the toolchain to a sysroot.
This entry point just installs the target's toolchain into the sysroot.
Everything else must have been done already for this to be successful.
Args:
target (build_target_lib.BuildTarget): The target whose toolchain is being
installed.
sysroot (sysroot_lib.Sysroot): The sysroot where the toolchain is being
installed.
run_configs (SetupBoardRunConfig): The run configs.
"""
cros_build_lib.AssertInsideChroot()
if not sysroot.Exists():
# Sanity check before we try installing anything.
raise ValueError('The sysroot must exist, run Create first.')
# Step 4: Install toolchain and packages.
# Dependencies: Portage configs and wrappers have been installed.
if run_configs.init_board_pkgs:
logging.info('Updating toolchain.')
# Use the local packages if we're doing a local only build or usepkg is set.
local_init = run_configs.usepkg or run_configs.local_build
_InstallToolchain(sysroot, target, local_init=local_init)
def main(argv):
parser = GetParser()
options = parser.parse_args(argv)
options.Freeze()
if options.command == 'list-all':
board_to_packages = workon_helper.ListAllWorkedOnAtoms()
color = terminal.Color()
for board in sorted(board_to_packages):
print(color.Start(color.GREEN) + board + ':' + color.Stop())
for package in board_to_packages[board]:
print(' ' + package)
print('')
return 0
# TODO(wiley): Assert that we're not running as root.
cros_build_lib.AssertInsideChroot()
if options.host:
friendly_name = 'host'
sysroot = '/'
elif options.board:
friendly_name = options.board
sysroot = cros_build_lib.GetSysroot(board=options.board)
else:
cros_build_lib.Die('You must specify either --host, --board')
helper = workon_helper.WorkonHelper(sysroot, friendly_name)
try:
if options.command == 'start':
helper.StartWorkingOnPackages(options.packages,
use_all=options.all,
use_workon_only=options.workon_only)
elif options.command == 'stop':
helper.StopWorkingOnPackages(options.packages,
use_all=options.all,
use_workon_only=options.workon_only)
elif options.command == 'info':
triples = helper.GetPackageInfo(
options.packages,
use_all=options.all,
use_workon_only=options.workon_only)
for package, repos, paths in triples:
print(package, ','.join(repos), ','.join(paths))
elif options.command == 'list':
packages = helper.ListAtoms(use_all=options.all,
use_workon_only=options.workon_only)
if packages:
print('\n'.join(packages))
elif options.command == 'iterate':
helper.RunCommandInPackages(options.packages,
options.iterate_command,
use_all=options.all,
use_workon_only=options.workon_only)
except workon_helper.WorkonError as e:
cros_build_lib.Die(e)
return 0
def main(argv):
parser = GetParser()
options = parser.parse_args(argv)
options.Freeze()
# Figure out what we're supposed to do and reject conflicting options.
conflicting_options = (
options.cfg_name,
options.show_packages,
options.create_packages,
)
if sum(bool(x) for x in conflicting_options) > 1:
parser.error('conflicting options: create-packages & show-packages & '
'show-board-cfg')
targets_wanted = set(options.targets.split(','))
boards_wanted = (set(options.include_boards.split(','))
if options.include_boards else set())
if options.cfg_name:
ShowConfig(options.cfg_name)
elif options.show_packages is not None:
cros_build_lib.AssertInsideChroot()
target = options.show_packages
Crossdev.Load(False)
for package in GetTargetPackages(target):
print(GetPortagePackage(target, package))
elif options.create_packages:
cros_build_lib.AssertInsideChroot()
Crossdev.Load(False)
CreatePackages(targets_wanted, options.output_dir)
else:
cros_build_lib.AssertInsideChroot()
# This has to be always run as root.
if os.geteuid() != 0:
cros_build_lib.Die('this script must be run as root')
Crossdev.Load(options.reconfig)
root = options.sysroot or '/'
UpdateToolchains(options.usepkg, options.deleteold, options.hostonly,
options.reconfig, targets_wanted, boards_wanted,
root=root)
Crossdev.Save()
return 0
def builds(atom, build_target, packages=None):
"""Check if |build_target| builds |atom| (has it in its depgraph)."""
cros_build_lib.AssertInsideChroot()
pkgs = tuple(packages) if packages else None
# TODO(crbug/1081828): Receive and use sysroot.
graph, _sdk_graph = dependency.GetBuildDependency(build_target.root,
build_target.name, pkgs)
return any(atom in package for package in graph['package_deps'])
def main(argv):
cros_build_lib.AssertInsideChroot()
opts = _ParseArguments(argv)
filename = binhost.PrebuiltMapping.GetFilename(opts.buildroot,
opts.prebuilt_type)
pfq_configs = binhost.PrebuiltMapping.Load(filename)
extra_useflags = os.environ.get('USE', '').split()
compat_id = binhost.CalculateCompatId(opts.board, extra_useflags)
for key in pfq_configs.GetPrebuilts(compat_id):
print(key.board)
def main(argv):
cros_build_lib.AssertInsideChroot()
opts = _ParseArgs(argv)
try:
toolchain.InstallToolchain(sysroot=opts.sysroot,
toolchain=opts.toolchain,
force=opts.force, configure=opts.configure)
except (toolchain.Error, cros_build_lib.RunCommandError, ValueError) as e:
cros_build_lib.Die(e)
def _CheckSaneArguments(command, options):
"""Checks to make sure the flags are sane. Dies if arguments are not sane."""
if not command in COMMAND_DICTIONARY.keys():
_PrintUsageAndDie('%s is not a valid command' % command)
if not options.packages and command == 'commit' and not options.all:
_PrintUsageAndDie('Please specify at least one package')
if options.boards:
cros_build_lib.AssertInsideChroot()
if not os.path.isdir(options.srcroot):
_PrintUsageAndDie('srcroot is not a valid path')
options.srcroot = os.path.abspath(options.srcroot)
def main(argv):
opts = ParseArgs(argv)
cros_build_lib.AssertInsideChroot()
sysroot = opts.sysroot or cros_build_lib.GetSysroot(opts.board)
package_blacklist = portage_util.UNITTEST_PACKAGE_BLACKLIST
if opts.package_blacklist:
package_blacklist |= set(opts.package_blacklist.split())
packages = set()
# The list of packages to test can be passed as a file containing a
# space-separated list of package names.
# This is used by the builder to test only the packages that were upreved.
if opts.package_file and os.path.exists(opts.package_file):
packages = set(osutils.ReadFile(opts.package_file).split())
if opts.packages:
packages |= set(opts.packages.split())
# If no packages were specified, use all testable packages.
if not (opts.packages or opts.package_file):
workon = workon_helper.WorkonHelper(sysroot)
packages = (workon.InstalledWorkonAtoms()
if opts.installed else workon.ListAtoms(use_all=True))
for cp in packages & package_blacklist:
logging.info('Skipping blacklisted package %s.', cp)
packages = packages - package_blacklist
pkg_with_test = portage_util.PackagesWithTest(sysroot, packages)
if packages - pkg_with_test:
logging.warning('The following packages do not have tests:')
logging.warning('\n'.join(sorted(packages - pkg_with_test)))
if opts.pretend:
print('\n'.join(sorted(pkg_with_test)))
return
env = None
if opts.nowithdebug:
use_flags = os.environ.get('USE', '')
use_flags += ' -cros-debug'
env = {'USE': use_flags}
try:
chroot_util.RunUnittests(sysroot,
pkg_with_test,
extra_env=env,
jobs=min(10, multiprocessing.cpu_count()))
except cros_build_lib.RunCommandError:
logging.error('Unittests failed.')
raise
def main(argv):
cros_build_lib.AssertInsideChroot()
opts = _ParseArgs(argv)
try:
success = image_lib.SecurityTest(board=opts.board, image=opts.image,
baselines=opts.baselines,
vboot_hash=opts.vboot_hash)
except image_lib.Error as e:
cros_build_lib.Die(e)
else:
return 0 if success else 1
def main(argv):
cros_build_lib.AssertInsideChroot()
args = ParseArguments(argv)
if os.geteuid() != 0:
try:
cros_build_lib.SudoRunCommand([sys.executable] + sys.argv)
except cros_build_lib.RunCommandError:
return 1
return 0
if not args.board:
print 'No board specified. Aborting.'
return 1
manifest = git.ManifestCheckout.Cached(constants.SOURCE_ROOT)
source_path = manifest.GetProjectPath(AUTOTEST_PROJECT_NAME, absolute=True)
source_path = os.path.join(source_path, '')
script_path = os.path.dirname(__file__)
include_pattern_file = os.path.join(script_path, INCLUDE_PATTERNS_FILENAME)
# TODO: Determine the following string programatically.
sysroot_path = os.path.join('/build', args.board, '')
sysroot_autotest_path = os.path.join(sysroot_path, 'usr', 'local',
'autotest', '')
rsync_output = RsyncQuickmerge(source_path, sysroot_autotest_path,
include_pattern_file, args.pretend,
args.overwrite)
if args.verbose:
logging.info(rsync_output.output)
change_report = ItemizeChangesFromRsyncOutput(rsync_output.output,
sysroot_autotest_path)
if not args.pretend:
UpdatePackageContents(change_report, AUTOTEST_EBUILD, sysroot_path)
for ebuild in DOWNGRADE_EBUILDS:
if not DowngradePackageVersion(sysroot_path, ebuild):
logging.warning(
'Unable to downgrade package %s version number.', ebuild)
RemoveBzipPackages(sysroot_autotest_path)
if args.pretend:
logging.info('The following message is pretend only. No filesystem '
'changes made.')
logging.info(
'Quickmerge complete. Created or modified %s files.',
len(change_report.new_files) + len(change_report.modified_files))
return 0
def main(argv):
options = ParseCommandLine(argv)
FinishParsing(options)
cros_build_lib.AssertInsideChroot()
with sudo.SudoKeepAlive(ttyless_sudo=False):
with osutils.TempDir(set_global=True, sudo_rm=True) as tempdir:
sysroot = os.path.join(tempdir, SYSROOT)
os.mkdir(sysroot)
GenerateSysroot(sysroot, options).Perform()
def Emerge(packages,
sysroot,
with_deps=True,
rebuild_deps=True,
use_binary=True,
jobs=None,
debug_output=False):
"""Emerge the specified |packages|.
Args:
packages: List of packages to emerge.
sysroot: Path to the sysroot in which to emerge.
with_deps: Whether to include dependencies.
rebuild_deps: Whether to rebuild dependencies.
use_binary: Whether to use binary packages.
jobs: Number of jobs to run in parallel.
debug_output: Emit debug level output.
Raises:
cros_build_lib.RunCommandError: If emerge returns an error.
"""
cros_build_lib.AssertInsideChroot()
if not packages:
raise ValueError('No packages provided')
cmd = GetEmergeCommand(sysroot)
cmd.append('-uNv')
modified_packages = workon.ListModifiedWorkonPackages(
sysroot_lib.Sysroot(sysroot))
if modified_packages:
mod_pkg_list = ' '.join(modified_packages)
cmd += [
'--reinstall-atoms=' + mod_pkg_list,
'--usepkg-exclude=' + mod_pkg_list
]
cmd.append('--deep' if with_deps else '--nodeps')
if use_binary:
cmd += ['-g', '--with-bdeps=y']
if sysroot == '/':
# Only update toolchains in the chroot when binpkgs are available. The
# toolchain rollout process only takes place when the chromiumos sdk
# builder finishes a successful build and pushes out binpkgs.
cmd += ['--useoldpkg-atoms=%s' % ' '.join(_GetToolchainPackages())]
if rebuild_deps:
cmd.append('--rebuild-if-unbuilt')
if jobs:
cmd.append('--jobs=%d' % jobs)
if debug_output:
cmd.append('--show-output')
cros_build_lib.SudoRunCommand(cmd + packages)
def main(argv):
options = ParseCommandLine(argv)
FinishParsing(options)
cros_build_lib.AssertInsideChroot()
with sudo.SudoKeepAlive(ttyless_sudo=False):
with osutils.TempDir(set_global=True, sudo_rm=True) as tempdir:
warnings_dir = os.path.join(tempdir, TIDY_WARNINGS)
os.mkdir(warnings_dir)
GenerateTidyWarnings(warnings_dir, options).Perform()
def main(argv):
"""Main function."""
cros_build_lib.AssertInsideChroot()
opts = _ParseArgs(argv)
if opts.init_latest:
cros_sdk_lib.InitLatestVersion()
else:
try:
cros_sdk_lib.RunChrootVersionHooks()
except cros_sdk_lib.Error as e:
cros_build_lib.Die(e)
def main(argv):
cros_build_lib.AssertInsideChroot()
opts = ParseArguments(argv)
if opts.config:
config_content = osutils.ReadFile(opts.config)
else:
config_content = GetConfigContent(opts)
logging.info('Using config: %s', config_content)
if opts.dump_config:
print(config_content)
PrepareImage(opts.image, config_content, opts.enrollment_domain)
def main(argv):
cros_build_lib.AssertInsideChroot()
options = GetOptions(argv)
if options.action == ACTION_GET_ENTRY:
db = user_db.UserDB(options.sysroot)
if options.database == USER_DB:
print(db.GetUserEntry(options.name, skip_lock=options.nolock))
else:
print(db.GetGroupEntry(options.name, skip_lock=options.nolock))
return 0
overlays = sysroot_lib.Sysroot(options.sysroot).GetStandardField(
sysroot_lib.STANDARD_FIELD_PORTDIR_OVERLAY).split()
# TODO(wiley) This process could be optimized to avoid reparsing these
# overlay databases each time.
account_db = accounts_lib.AccountDatabase()
for overlay_path in overlays:
database_path = os.path.join(overlay_path, ACCOUNT_DB_FILENAME)
if os.path.exists(database_path):
account_db.AddAccountsFromDatabase(database_path)
installed_users = user_db.UserDB(options.sysroot)
if options.action == ACTION_INSTALL_USER:
account_db.InstallUser(options.name,
installed_users,
uid=options.uid,
shell=options.shell,
homedir=options.home,
primary_group=options.primary_group)
homedir = account_db.users[options.name].home
homedir_path = os.path.join(options.sysroot, homedir)
if homedir != '/dev/null' and not os.path.exists(homedir_path):
osutils.SafeMakedirs(homedir_path, sudo=True)
uid = account_db.users[options.name].uid
cros_build_lib.sudo_run(
['chown', '%d:%d' % (uid, uid), homedir_path], print_cmd=False)
elif options.action == ACTION_INSTALL_GROUP:
account_db.InstallGroup(options.name, installed_users, gid=options.gid)
else:
cros_build_lib.Die('Unsupported account type: %s' %
options.account_type)
def main(argv):
cros_build_lib.AssertInsideChroot()
parser = commandline.ArgumentParser(description=__doc__)
parser.add_argument('--output',
required=True,
help='File to write results to')
parser.add_argument('board', nargs='+')
opts = parser.parse_args(argv)
output = opts.output
if output == '-':
output = '/dev/stdout'
results = {x: get_all_package_objects(x) for x in opts.board}
with open(output, 'w') as f:
json.dump(results, f)
def get_firmware_versions(build_target):
"""Extract version information from the firmware updater, if one exists.
Args:
build_target (build_target_lib.BuildTarget): The build target.
Returns:
A FirmwareVersions namedtuple instance.
Each element will either be set to the string output by the firmware
updater shellball, or None if there is no firmware updater.
"""
cros_build_lib.AssertInsideChroot()
cmd_result = _get_firmware_version_cmd_result(build_target)
if cmd_result:
return _find_firmware_versions(cmd_result)
else:
return FirmwareVersions(None, None, None, None, None)
def Update(arguments):
"""Update the chroot.
Args:
arguments (UpdateArguments): The various arguments for updating a chroot.
Returns:
int - The version of the chroot after the update.
"""
# TODO: This should be able to be run either in or out of the chroot.
cros_build_lib.AssertInsideChroot()
cmd = [os.path.join(constants.CROSUTILS_DIR, 'update_chroot')]
cmd.extend(arguments.GetArgList())
cros_build_lib.run(cmd)
return GetChrootVersion()
def find_fingerprints(build_target):
"""Returns a list of fingerprints for this build.
Args:
build_target (build_target_lib.BuildTarget): The build target.
Returns:
list[str] - List of fingerprint strings.
"""
cros_build_lib.AssertInsideChroot()
fp_file = 'cheets-fingerprint.txt'
fp_path = os.path.join(image_lib.GetLatestImageLink(build_target.name),
fp_file)
if not os.path.isfile(fp_path):
logging.info('Fingerprint file not found: %s', fp_path)
return []
logging.info('Reading fingerprint file: %s', fp_path)
fingerprints = osutils.ReadFile(fp_path).splitlines()
return fingerprints
def main(argv):
parser = commandline.ArgumentParser(description=__doc__)
parser.add_argument(
'--sysroot',
type='path',
help='The sysroot to use for brick metadata validation.')
parser.add_argument('appc_pod_manifest_path',
type='path',
help='path to appc pod manifest')
parser.add_argument('sandbox_spec_path',
type='path',
help='path to file to write resulting SandboxSpec to. '
'Must not exist.')
options = parser.parse_args(argv)
options.Freeze()
cros_build_lib.AssertInsideChroot()
generator = sandbox_spec_generator.SandboxSpecGenerator(options.sysroot)
generator.WriteSandboxSpec(options.appc_pod_manifest_path,
options.sandbox_spec_path)
return 0
