def repack_shellball(self, hostname):
"""Repack DUT shellball and replace on DUT.
@param hostname: hostname of DUT.
"""
extract_dir = tempfile.mkdtemp(prefix='extract', dir='/tmp')
self.dut_run_cmd('mkdir %s' % extract_dir)
self.dut_run_cmd('cp %s %s' % (self.SHELLBALL_ORG, self.SHELLBALL_COPY))
self.dut_run_cmd('%s --sb_extract %s' % (self.SHELLBALL_COPY,
extract_dir))
dut_access = remote_access.RemoteDevice(hostname, username='******')
self.dut_run_cmd('cp %s %s' % (self.SHELLBALL_ORG, self.SHELLBALL_COPY))
# Replace bin files.
target_file = '%s/%s' % (extract_dir, 'ec.bin')
dut_access.CopyToDevice(self.new_ec, target_file, mode='scp')
target_file = '%s/%s' % (extract_dir, 'bios.bin')
dut_access.CopyToDevice(self.new_bios, target_file, mode='scp')
if self.new_pd:
target_file = '%s/%s' % (extract_dir, 'pd.bin')
dut_access.CopyToDevice(self.new_pd, target_file, mode='scp')
self.dut_run_cmd('%s --sb_repack %s' % (self.SHELLBALL_COPY,
extract_dir))
# Call to "shar" in chromeos-firmwareupdate might fail and the repack
# ignore failure and exit with 0 status (http://crosbug.com/p/33719).
# Add additional check to ensure the repack is successful.
command = 'tail -1 %s' % self.SHELLBALL_COPY
output = self.dut_run_cmd(command)
if 'exit 0' not in output:
raise error.TestError('Failed to repack %s' % self.SHELLBALL_COPY)
def CopyPayload(request_data):
"""Copy a payload file to a target DUT.
This constructs a `RemoteDevice`, and calls its `CopyToDevice()`
method to copy a payload file to the target device. A payload
file is either the `stateful.tgz` tarball, or a Chrome OS AU
payload (typically a full payload).
The `request_data` argument has the following fields:
* hostname: Name of the target DUT where the payload will
be copied.
* localpath: Path on this system to the payload file.
* remotepath: Path on the DUT where the payload will be copied.
* kwargs: Keyword arguments dictionanry to be passed
to `RemoteDevice.CopyToDevice()`.
* kwargs['log_stdout_to_file']: If present, a file to which logger
output will be written. The output will typically include the
command used for the copy, and standard input/output of that copy
command.
"""
log_handler = None
log_file = request_data.kwargs.get('log_stdout_to_file')
if log_file:
log_handler = logging.FileHandler(log_file)
log_handler.setFormatter(LOG_FORMATTER)
logging.getLogger().addHandler(log_handler)
try:
device = remote_access.RemoteDevice(request_data.hostname)
device.CopyToDevice(request_data.localpath,
request_data.remotepath,
mode='scp',
**request_data.kwargs)
finally:
if log_handler:
logging.getLogger().removeHandler(log_handler)
def InitRemote(self):
"""Initialize remote access."""
self.remote = remote_access.RemoteDevice(
self.device,
port=self.ssh_port,
connect_settings=self._ConnectSettings(),
private_key=self.private_key)
self.device_addr = 'ssh://%s' % self.device
if self.ssh_port:
self.device_addr += ':%d' % self.ssh_port
def test_QuickProvision(self, run_command_call, _):
"""Tests launching quick provision."""
cmd = ('curl -o /tmp/quick-provision foo-static/quick-provision && '
'bash /tmp/quick-provision --status_url foo-url foo-build-name '
'foo-static')
device = remote_access.RemoteDevice('fake-hostname')
self._cros_update_trigger._QuickProvision(device)
run_command_call.assert_called_with(cmd,
log_output=True,
shell=True,
capture_output=True,
ssh_error_ok=True,
encoding='utf-8')
def __init__(self, opts):
"""Initialize VM.
Args:
opts: command line options.
"""
self.qemu_path = opts.qemu_path
self.qemu_bios_path = opts.qemu_bios_path
self.qemu_m = opts.qemu_m
self.qemu_cpu = opts.qemu_cpu
self.qemu_smp = opts.qemu_smp
if self.qemu_smp == 0:
self.qemu_smp = min(8, multiprocessing.cpu_count)
self.enable_kvm = opts.enable_kvm
# We don't need sudo access for software emulation or if /dev/kvm is
# writeable.
self.use_sudo = self.enable_kvm and not os.access('/dev/kvm', os.W_OK)
self.display = opts.display
self.image_path = opts.image_path
self.image_format = opts.image_format
self.board = opts.board
self.ssh_port = opts.ssh_port
self.dry_run = opts.dry_run
self.start = opts.start
self.stop = opts.stop
self.cmd = opts.args[1:] if opts.cmd else None
self.cache_dir = os.path.abspath(opts.cache_dir)
assert os.path.isdir(self.cache_dir), "Cache directory doesn't exist"
self.vm_dir = opts.vm_dir
if not self.vm_dir:
self.vm_dir = os.path.join(osutils.GetGlobalTempDir(),
'cros_vm_%d' % self.ssh_port)
self._CreateVMDir()
self.pidfile = os.path.join(self.vm_dir, 'kvm.pid')
self.kvm_monitor = os.path.join(self.vm_dir, 'kvm.monitor')
self.kvm_pipe_in = '%s.in' % self.kvm_monitor # to KVM
self.kvm_pipe_out = '%s.out' % self.kvm_monitor # from KVM
self.kvm_serial = '%s.serial' % self.kvm_monitor
self.remote = remote_access.RemoteDevice(remote_access.LOCALHOST,
port=self.ssh_port)
self.device_addr = 'ssh://%s:%d' % (remote_access.LOCALHOST,
self.ssh_port)
def __init__(self, options, tempdir, staging_dir):
"""Initialize the class.
Args:
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(options.to,
port=options.port,
ping=options.ping,
private_key=options.private_key)
self._root_dir_is_still_readonly = multiprocessing.Event()
self.copy_paths = chrome_util.GetCopyPaths('chrome')
self.chrome_dir = _CHROME_DIR