blob: 354379a95fb701151dbc11198952b1cd3fb06382 [file] [log] [blame]
# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Script that deploys a Chrome build to a device.
The script supports deploying Chrome from these sources:
1. A local build output directory, such as chromium/src/out/[Debug|Release].
2. A Chrome tarball uploaded by a trybot/official-builder to GoogleStorage.
3. A Chrome tarball existing locally.
The script copies the necessary contents of the source location (tarball or
build directory) and rsyncs the contents of the staging directory onto your
device's rootfs.
from __future__ import print_function
import argparse
import collections
import contextlib
import functools
import glob
import multiprocessing
import os
import shlex
import shutil
import time
from chromite.cbuildbot import constants
from chromite.cbuildbot import failures_lib
from chromite.cli.cros import cros_chrome_sdk
from chromite.lib import chrome_util
from chromite.lib import commandline
from chromite.lib import cros_build_lib
from chromite.lib import cros_logging as logging
from chromite.lib import gs
from chromite.lib import osutils
from chromite.lib import parallel
from chromite.lib import remote_access as remote
from chromite.lib import stats
from chromite.lib import timeout_util
MOUNT_RW_COMMAND = 'mount -o remount,rw /'
LSOF_COMMAND = 'lsof %s/chrome'
_ANDROID_DIR = '/system/chrome'
_ANDROID_DIR_EXTRACT_PATH = 'system/chrome/*'
_CHROME_DIR = '/opt/google/chrome'
_CHROME_DIR_MOUNT = '/mnt/stateful_partition/deploy_rootfs/opt/google/chrome'
'if mountpoint -q %(dir)s; then umount %(dir)s; fi')
_BIND_TO_FINAL_DIR_CMD = 'mount --rbind %s %s'
_SET_MOUNT_FLAGS_CMD = 'mount -o remount,exec,suid %s'
DF_COMMAND = 'df -k %s'
def _UrlBaseName(url):
"""Return the last component of the URL."""
return url.rstrip('/').rpartition('/')[-1]
class DeployFailure(failures_lib.StepFailure):
"""Raised whenever the deploy fails."""
DeviceInfo = collections.namedtuple(
'DeviceInfo', ['target_dir_size', 'target_fs_free'])
class DeployChrome(object):
"""Wraps the core deployment functionality."""
def __init__(self, options, tempdir, staging_dir):
"""Initialize the class.
options: options object.
tempdir: Scratch space for the class. Caller has responsibility to clean
it up.
staging_dir: Directory to stage the files to.
self.tempdir = tempdir
self.options = options
self.staging_dir = staging_dir
if not self.options.staging_only:
self.device = remote.RemoteDevice(, port=options.port,
self._target_dir_is_still_readonly = multiprocessing.Event()
self.copy_paths = chrome_util.GetCopyPaths('chrome')
self.chrome_dir = _CHROME_DIR
def _GetRemoteMountFree(self, remote_dir):
result = self.device.RunCommand(DF_COMMAND % remote_dir)
line = result.output.splitlines()[1]
value = line.split()[3]
multipliers = {
'G': 1024 * 1024 * 1024,
'M': 1024 * 1024,
'K': 1024,
return int(value.rstrip('GMK')) * multipliers.get(value[-1], 1)
def _GetRemoteDirSize(self, remote_dir):
result = self.device.RunCommand('du -ks %s' % remote_dir,
return int(result.output.split()[0])
def _GetStagingDirSize(self):
result = cros_build_lib.DebugRunCommand(['du', '-ks', self.staging_dir],
return int(result.output.split()[0])
def _ChromeFileInUse(self):
result = self.device.RunCommand(LSOF_COMMAND % (self.options.target_dir,),
error_code_ok=True, capture_output=True)
return result.returncode == 0
def _DisableRootfsVerification(self):
if not self.options.force:
logging.error('Detected that the device has rootfs verification enabled.')'This script can automatically remove the rootfs '
'verification, which requires that it reboot the device.')'Make sure the device is in developer mode!')'Skip this prompt by specifying --force.')
if not cros_build_lib.BooleanPrompt('Remove roots verification?', False):
# Since we stopped Chrome earlier, it's good form to start it up again.
if self.options.startui:'Starting Chrome...')
self.device.RunCommand('start ui')
raise DeployFailure('Need rootfs verification to be disabled. '
'Aborting.')'Removing rootfs verification from %s',
# Running in VM's cause make_dev_ssd's firmware sanity checks to fail.
# Use --force to bypass the checks.
cmd = ('/usr/share/vboot/bin/ --partitions %d '
'--remove_rootfs_verification --force')
self.device.RunCommand(cmd % partition, error_code_ok=True)
# A reboot in developer mode takes a while (and has delays), so the user
# will have time to read and act on the USB boot instructions below.'Please remember to press Ctrl-U if you are booting from USB.')
# Now that the machine has been rebooted, we need to kill Chrome again.
# Make sure the rootfs is writable now.
def _CheckUiJobStarted(self):
# status output is in the format:
# <job_name> <status> ['process' <pid>].
# <status> is in the format <goal>/<state>.
result = self.device.RunCommand('status ui', capture_output=True)
except cros_build_lib.RunCommandError as e:
if 'Unknown job' in e.result.error:
return False
raise e
return result.output.split()[1].split('/')[0] == 'start'
def _KillProcsIfNeeded(self):
if self._CheckUiJobStarted():'Shutting down Chrome...')
self.device.RunCommand('stop ui')
# Developers sometimes run session_manager manually, in which case we'll
# need to help shut the chrome processes down.
with timeout_util.Timeout(KILL_PROC_MAX_WAIT):
while self._ChromeFileInUse():
logging.warning('The chrome binary on the device is in use.')
logging.warning('Killing chrome and session_manager processes...\n')
self.device.RunCommand("pkill 'chrome|session_manager'",
# Wait for processes to actually terminate
time.sleep(POST_KILL_WAIT)'Rechecking the chrome binary...')
except timeout_util.TimeoutError:
msg = ('Could not kill processes after %s seconds. Please exit any '
'running chrome processes and try again.' % KILL_PROC_MAX_WAIT)
raise DeployFailure(msg)
def _MountRootfsAsWritable(self, error_code_ok=True):
"""Mount the rootfs as writable.
If the command fails, and error_code_ok is True, and the target dir is not
writable then this function sets self._target_dir_is_still_readonly.
error_code_ok: See remote.RemoteAccess.RemoteSh for details.
# TODO: Should migrate to use the remount functions in remote_access.
result = self.device.RunCommand(MOUNT_RW_COMMAND,
if (result.returncode and
not self.device.IsDirWritable(self.options.target_dir)):
def _GetDeviceInfo(self):
steps = [
functools.partial(self._GetRemoteDirSize, self.options.target_dir),
functools.partial(self._GetRemoteMountFree, self.options.target_dir)
return_values = parallel.RunParallelSteps(steps, return_values=True)
return DeviceInfo(*return_values)
def _CheckDeviceFreeSpace(self, device_info):
"""See if target device has enough space for Chrome.
device_info: A DeviceInfo named tuple.
effective_free = device_info.target_dir_size + device_info.target_fs_free
staging_size = self._GetStagingDirSize()
if effective_free < staging_size:
raise DeployFailure(
'Not enough free space on the device. Required: %s MiB, '
'actual: %s MiB.' % (staging_size / 1024, effective_free / 1024))
if device_info.target_fs_free < (100 * 1024):
logging.warning('The device has less than 100MB free. deploy_chrome may '
'hang during the transfer.')
def _Deploy(self):'Copying Chrome to %s on device...', self.options.target_dir)
# Show the output (status) for this command.
dest_path = _CHROME_DIR
if not self.device.HasRsync():
raise DeployFailure(
'rsync is not found on the device.\n'
'Run dev_install on the device to get rsync installed')
self.device.CopyToDevice('%s/' % os.path.abspath(self.staging_dir),
inplace=True, debug_level=logging.INFO,
for p in self.copy_paths:
if p.mode:
# Set mode if necessary.
self.device.RunCommand('chmod %o %s/%s' % (
p.mode, dest_path, p.src if not p.dest else p.dest))
if self.options.startui:'Starting UI...')
self.device.RunCommand('start ui')
def _CheckConnection(self):
try:'Testing connection to the device...')
except cros_build_lib.RunCommandError as ex:
logging.error('Error connecting to the test device.')
raise DeployFailure(ex)
def _CheckDeployType(self):
if self.options.build_dir:
def BinaryExists(filename):
"""Checks if the passed-in file is present in the build directory."""
return os.path.exists(os.path.join(self.options.build_dir, filename))
# Handle non-Chrome deployments.
if not BinaryExists('chrome'):
if BinaryExists('envoy_shell'):
self.copy_paths = chrome_util.GetCopyPaths('envoy')
elif BinaryExists('app_shell'):
self.copy_paths = chrome_util.GetCopyPaths('app_shell')
# TODO(derat): Update _Deploy() and remove this after figuring out how
# {app,envoy}_shell should be executed.
self.options.startui = False
def _PrepareStagingDir(self):
_PrepareStagingDir(self.options, self.tempdir, self.staging_dir,
self.copy_paths, self.chrome_dir)
def _MountTarget(self):'Mounting Chrome...')
# Create directory if does not exist
self.device.RunCommand('mkdir -p --mode 0775 %s' % (
# Umount the existing mount on mount_dir if present first
self.device.RunCommand(_UMOUNT_DIR_IF_MOUNTPOINT_CMD %
{'dir': self.options.mount_dir})
self.device.RunCommand(_BIND_TO_FINAL_DIR_CMD % (self.options.target_dir,
# Chrome needs partition to have exec and suid flags set
self.device.RunCommand(_SET_MOUNT_FLAGS_CMD % (self.options.mount_dir,))
def Cleanup(self):
"""Clean up RemoteDevice."""
if not self.options.staging_only:
def Perform(self):
# If requested, just do the staging step.
if self.options.staging_only:
return 0
# Run setup steps in parallel. If any step fails, RunParallelSteps will
# stop printing output at that point, and halt any running steps.
steps = [self._GetDeviceInfo, self._CheckConnection,
self._KillProcsIfNeeded, self._MountRootfsAsWritable,
ret = parallel.RunParallelSteps(steps, halt_on_error=True,
# If we're trying to deploy to a dir which is not writable and we failed
# to mark the rootfs as writable, try disabling rootfs verification.
if self._target_dir_is_still_readonly.is_set():
if self.options.mount_dir is not None:
# Actually deploy Chrome to the device.
def ValidateGypDefines(value):
"""Convert GYP_DEFINES-formatted string to dictionary."""
return chrome_util.ProcessGypDefines(value)
def _CreateParser():
"""Create our custom parser."""
parser = commandline.ArgumentParser(description=__doc__, caching=True)
# TODO(rcui): Have this use the UI-V2 format of having source and target
# device be specified as positional arguments.
parser.add_argument('--force', action='store_true', default=False,
help='Skip all prompts (i.e., for disabling of rootfs '
'verification). This may result in the target '
'machine being rebooted.')
sdk_board_env = os.environ.get(cros_chrome_sdk.SDKFetcher.SDK_BOARD_ENV)
parser.add_argument('--board', default=sdk_board_env,
help="The board the Chrome build is targeted for. When "
"in a 'cros chrome-sdk' shell, defaults to the SDK "
parser.add_argument('--build-dir', type='path',
help='The directory with Chrome build artifacts to '
'deploy from. Typically of format '
'<chrome_root>/out/Debug. When this option is used, '
'the GYP_DEFINES environment variable must be set.')
parser.add_argument('--target-dir', type='path',
help='Target directory on device to deploy Chrome into.')
parser.add_argument('-g', '--gs-path', type='gs_path',
help='GS path that contains the chrome to deploy.')
parser.add_argument('--nostartui', action='store_false', dest='startui',
help="Don't restart the ui daemon after deployment.")
parser.add_argument('--nostrip', action='store_false', dest='dostrip',
help="Don't strip binaries during deployment. Warning: "
'the resulting binaries will be very large!')
parser.add_argument('-p', '--port', type=int, default=remote.DEFAULT_SSH_PORT,
help='Port of the target device to connect to.')
parser.add_argument('-t', '--to',
help='The IP address of the CrOS device to deploy to.')
parser.add_argument('-v', '--verbose', action='store_true', default=False,
help='Show more debug output.')
parser.add_argument('--mount-dir', type='path', default=None,
help='Deploy Chrome in target directory and bind it '
'to the directory specified by this flag.'
'Any existing mount on this directory will be '
'umounted first.')
parser.add_argument('--mount', action='store_true', default=False,
help='Deploy Chrome to default target directory and bind '
'it to the default mount directory.'
'Any existing mount on this directory will be '
'umounted first.')
group = parser.add_argument_group('Advanced Options')
group.add_argument('-l', '--local-pkg-path', type='path',
help='Path to local chrome prebuilt package to deploy.')
group.add_argument('--sloppy', action='store_true', default=False,
help='Ignore when mandatory artifacts are missing.')
group.add_argument('--staging-flags', default=None, type=ValidateGypDefines,
help=('Extra flags to control staging. Valid flags are - '
'%s' % ', '.join(chrome_util.STAGING_FLAGS)))
group.add_argument('--strict', action='store_true', default=False,
help='Stage artifacts based on the GYP_DEFINES '
'environment variable and --staging-flags, if set. '
'Enforce that all optional artifacts are deployed.')
group.add_argument('--strip-flags', default=None,
help="Flags to call the 'strip' binutil tool with. "
"Overrides the default arguments.")
group.add_argument('--ping', action='store_true', default=False,
help='Ping the device before connection attempt.')
group = parser.add_argument_group(
'Metadata Overrides (Advanced)',
description='Provide all of these overrides in order to remove '
'dependencies on metadata.json existence.')
group.add_argument('--target-tc', action='store', default=None,
help='Override target toolchain name, e.g. '
group.add_argument('--toolchain-url', action='store', default=None,
help='Override toolchain url format pattern, e.g. '
# GYP_DEFINES that Chrome was built with. Influences which files are staged
# when --build-dir is set. Defaults to reading from the GYP_DEFINES
# enviroment variable.
parser.add_argument('--gyp-defines', default=None, type=ValidateGypDefines,
# Path of an empty directory to stage chrome artifacts to. Defaults to a
# temporary directory that is removed when the script finishes. If the path
# is specified, then it will not be removed.
parser.add_argument('--staging-dir', type='path', default=None,
# Only prepare the staging directory, and skip deploying to the device.
parser.add_argument('--staging-only', action='store_true', default=False,
# Path to a binutil 'strip' tool to strip binaries with. The passed-in path
# is used as-is, and not normalized. Used by the Chrome ebuild to skip
# fetching the SDK toolchain.
parser.add_argument('--strip-bin', default=None, help=argparse.SUPPRESS)
return parser
def _ParseCommandLine(argv):
"""Parse args, and run environment-independent checks."""
parser = _CreateParser()
options = parser.parse_args(argv)
if not any([options.gs_path, options.local_pkg_path, options.build_dir]):
parser.error('Need to specify either --gs-path, --local-pkg-path, or '
if options.build_dir and any([options.gs_path, options.local_pkg_path]):
parser.error('Cannot specify both --build_dir and '
if options.build_dir and not options.board:
parser.error('--board is required when --build-dir is specified.')
if options.gs_path and options.local_pkg_path:
parser.error('Cannot specify both --gs-path and --local-pkg-path')
if not (options.staging_only or
parser.error('Need to specify --to')
if (options.strict or options.staging_flags) and not options.build_dir:
parser.error('--strict and --staging-flags require --build-dir to be '
if options.staging_flags and not options.strict:
parser.error('--staging-flags requires --strict to be set.')
if options.sloppy and options.strict:
parser.error('Cannot specify both --strict and --sloppy.')
if options.mount or options.mount_dir:
if not options.target_dir:
options.target_dir = _CHROME_DIR_MOUNT
if not options.target_dir:
options.target_dir = _CHROME_DIR
if options.mount and not options.mount_dir:
options.mount_dir = _CHROME_DIR
return options
def _PostParseCheck(options):
"""Perform some usage validation (after we've parsed the arguments).
options: The options object returned by optparse.
_args: The args object returned by optparse.
if options.local_pkg_path and not os.path.isfile(options.local_pkg_path):
cros_build_lib.Die('%s is not a file.', options.local_pkg_path)
if not options.gyp_defines:
gyp_env = os.getenv('GYP_DEFINES', None)
if gyp_env is not None:
options.gyp_defines = chrome_util.ProcessGypDefines(gyp_env)
logging.debug('GYP_DEFINES taken from environment: %s',
if options.strict and not options.gyp_defines:
cros_build_lib.Die('When --strict is set, the GYP_DEFINES environment '
'variable must be set.')
def _FetchChromePackage(cache_dir, tempdir, gs_path):
"""Get the chrome prebuilt tarball from GS.
Path to the fetched chrome tarball.
gs_ctx = gs.GSContext(cache_dir=cache_dir, init_boto=True)
files = gs_ctx.LS(gs_path)
files = [found for found in files if
_UrlBaseName(found).startswith('%s-' % constants.CHROME_PN)]
if not files:
raise Exception('No chrome package found at %s' % gs_path)
elif len(files) > 1:
# - Users should provide us with a direct link to either a stripped or
# unstripped chrome package.
# - In the case of being provided with an archive directory, where both
# stripped and unstripped chrome available, use the stripped chrome
# package.
# - Stripped chrome pkg is chromeos-chrome-<version>.tar.gz
# - Unstripped chrome pkg is chromeos-chrome-<version>-unstripped.tar.gz.
files = [f for f in files if not 'unstripped' in f]
assert len(files) == 1
logging.warning('Multiple chrome packages found. Using %s', files[0])
filename = _UrlBaseName(files[0])'Fetching %s...', filename)
gs_ctx.Copy(files[0], tempdir, print_cmd=False)
chrome_path = os.path.join(tempdir, filename)
assert os.path.exists(chrome_path)
return chrome_path
def _StripBinContext(options):
if not options.dostrip:
yield None
elif options.strip_bin:
yield options.strip_bin
sdk = cros_chrome_sdk.SDKFetcher(options.cache_dir, options.board)
components = (sdk.TARGET_TOOLCHAIN_KEY, constants.CHROME_ENV_TAR)
with sdk.Prepare(components=components, target_tc=options.target_tc,
toolchain_url=options.toolchain_url) as ctx:
env_path = os.path.join(ctx.key_map[constants.CHROME_ENV_TAR].path,
strip_bin = osutils.SourceEnvironment(env_path, ['STRIP'])['STRIP']
strip_bin = os.path.join(ctx.key_map[sdk.TARGET_TOOLCHAIN_KEY].path,
'bin', os.path.basename(strip_bin))
yield strip_bin
def _PrepareStagingDir(options, tempdir, staging_dir, copy_paths=None,
"""Place the necessary files in the staging directory.
The staging directory is the directory used to rsync the build artifacts over
to the device. Only the necessary Chrome build artifacts are put into the
staging directory.
os.chmod(staging_dir, 0o755)
if options.build_dir:
with _StripBinContext(options) as strip_bin:
strip_flags = (None if options.strip_flags is None else
staging_dir, options.build_dir, strip_bin, strict=options.strict,
sloppy=options.sloppy, gyp_defines=options.gyp_defines,
strip_flags=strip_flags, copy_paths=copy_paths)
pkg_path = options.local_pkg_path
if options.gs_path:
pkg_path = _FetchChromePackage(options.cache_dir, tempdir,
assert pkg_path'Extracting %s...', pkg_path)
# Extract only the ./opt/google/chrome contents, directly into the staging
# dir, collapsing the directory hierarchy.
if pkg_path[-4:] == '.zip':
['unzip', '-X', pkg_path, _ANDROID_DIR_EXTRACT_PATH, '-d',
for filename in glob.glob(os.path.join(staging_dir, 'system/chrome/*')):
shutil.move(filename, staging_dir)
osutils.RmDir(os.path.join(staging_dir, 'system'), ignore_missing=True)
['tar', '--strip-components', '4', '--extract',
'--preserve-permissions', '--file', pkg_path, '.%s' % chrome_dir],
def main(argv):
options = _ParseCommandLine(argv)
# Set cros_build_lib debug level to hide RunCommand spew.
if options.verbose:
with stats.UploadContext() as queue:
cmd_stats = stats.Stats.SafeInit(cmd_line=argv, cmd_base='deploy_chrome')
if cmd_stats:
queue.put([cmd_stats, stats.StatsUploader.URL, 1])
with osutils.TempDir(set_global=True) as tempdir:
staging_dir = options.staging_dir
if not staging_dir:
staging_dir = os.path.join(tempdir, 'chrome')
deploy = DeployChrome(options, tempdir, staging_dir)
except failures_lib.StepFailure as ex:
raise SystemExit(str(ex).strip())