=== modified file 'lava_dispatcher/actions/boot_control.py'
@@ -49,12 +49,17 @@
parameters_schema['properties']['wait_for_home_screen'] = {
'default': False, 'optional': True
}
+ parameters_schema['properties']['interactive_boot_cmds'] = {
+ 'default': False, 'optional': True
+ }
- def run(self, options=None, adb_check=False, wait_for_home_screen=True):
- if not options:
- options = []
+ def run(self, options=[], adb_check=False,
+ wait_for_home_screen=True, interactive_boot_cmds=False):
client = self.client
- client.target_device.boot_options = options
+ if interactive_boot_cmds:
+ client.config.boot_cmds = options
+ else:
+ client.target_device.boot_options = options
client.config.android_wait_for_home_screen = wait_for_home_screen
try:
client.boot_linaro_android_image(
=== modified file 'lava_dispatcher/actions/deploy.py'
@@ -100,8 +100,11 @@
'ramdisk': {'type': 'string', 'optional': True},
'dtb': {'type': 'string', 'optional': True},
'rootfs': {'type': 'string', 'optional': True},
+ 'bootloader': {'type': 'string', 'optional': True},
+ 'firmware': {'type': 'string', 'optional': True},
'rootfstype': {'type': 'string', 'optional': True},
- 'bootloader': {'type': 'string', 'optional': True, 'default': 'u_boot'},
+ 'bootloadertype': {'type': 'string', 'optional': True, 'default': 'u_boot'},
+ 'role': {'type': 'string', 'optional': True},
},
'additionalProperties': False,
}
@@ -112,11 +115,12 @@
if 'kernel' not in parameters:
raise ValueError('must specify a kernel')
- def run(self, kernel=None, ramdisk=None, dtb=None, rootfs=None, rootfstype='ext4',
- bootloader='u_boot'):
+ def run(self, kernel=None, ramdisk=None, dtb=None, rootfs=None, bootloader=None,
+ firmware=None, rootfstype='ext4', bootloadertype='u_boot'):
self.client.deploy_linaro_kernel(
- kernel=kernel, ramdisk=ramdisk, dtb=dtb, rootfs=rootfs,
- rootfstype=rootfstype, bootloader=bootloader)
+ kernel=kernel, ramdisk=ramdisk, dtb=dtb, rootfs=rootfs,
+ bootloader=bootloader, firmware=firmware, rootfstype=rootfstype,
+ bootloadertype=bootloadertype)
class cmd_dummy_deploy(BaseAction):
=== modified file 'lava_dispatcher/client/base.py'
@@ -149,6 +149,29 @@
prompt_str_includes_rc=prompt_str_includes_rc)
self._client = client
+ def get_target_ip(self):
+ logging.info("Waiting for network to come up")
+ try:
+ self.wait_network_up(timeout=20)
+ except NetworkError:
+ logging.exception("Unable to reach LAVA server")
+ raise
+
+ pattern1 = "<(\d?\d?\d?\.\d?\d?\d?\.\d?\d?\d?\.\d?\d?\d?)>"
+ cmd = ("ifconfig %s | grep 'inet addr' | awk -F: '{print $2}' |"
+ "awk '{print \"<\" $1 \">\"}'" %
+ self._client.config.default_network_interface)
+ self.run(
+ cmd, [pattern1, pexpect.EOF, pexpect.TIMEOUT], timeout=5)
+ if self.match_id != 0:
+ msg = "Unable to determine target image IP address"
+ logging.error(msg)
+ raise CriticalError(msg)
+
+ ip = self.match.group(1)
+ logging.debug("Target image IP is %s" % ip)
+ return ip
+
def _check_network_up(self):
"""Internal function for checking network once."""
lava_server_ip = self._client.context.config.lava_server_ip
=== modified file 'lava_dispatcher/client/targetdevice.py'
@@ -65,9 +65,11 @@
self.target_device.deploy_linaro_prebuilt(image)
def deploy_linaro_kernel(self, kernel, ramdisk=None, dtb=None, rootfs=None,
- rootfstype='ext4', bootloader='u_boot'):
+ bootloader=None, firmware=None, rootfstype='ext4',
+ bootloadertype='u_boot'):
self.target_device.deploy_linaro_kernel(kernel, ramdisk, dtb, rootfs,
- bootloader)
+ bootloader, firmware, rootfstype,
+ bootloadertype)
def _boot_linaro_image(self):
if self.proc:
=== removed file 'lava_dispatcher/default-config/lava-dispatcher/device-types/arndale-uefi.conf'
@@ -1,54 +0,0 @@
-boot_part = 2
-root_part = 3
-
-boot_cmds = sendline a,
- expect Choice:,
- sendline 1,
- expect Select the Boot Device:,
- sendline 2,
- expect File path of the EFI Application or the kernel:,
- sendline uImage,
- expect Boot Type: [a] ATAGS, [g] Global FDT or [l] Local FDT? [a/g/l],
- sendline g,
- expect Add an initrd: [y/n],
- sendline y,
- expect File path of the initrd:,
- sendline uInitrd,
- expect Arguments to pass to the binary:,
- sendline "root=/dev/mmcblk1p6 rw rootwait console=ttySAC2,115200n8 init --no-log",
- expect Description for this new Entry:,
- sendline Test Image,
- expect Choice:,
- sendline 5,
- expect Start:,
- sendline 2
-
-
-client_type = uefi
-
-boot_cmds_android = 3
-
-interrupt_boot_prompt = The default boot selection will start in
-
-bootloader_prompt = Start:
-
-lmc_dev_arg = arndale
-
-# Original linaro-android-media-create generated Android system SD card layout
-boot_part_android_org = 2
-sys_part_android_org = 3
-cache_part_android_org = 5
-data_part_android_org = 6
-sdcard_part_android_org = 7
-
-# Android LAVA test image SD card layout
-sys_part_android = 6
-sdcard_part_android = 7
-data_part_android = 7
-
-boot_options =
- boot_cmds
-
-[boot_cmds]
-default = boot_cmds
-
=== modified file 'lava_dispatcher/default-config/lava-dispatcher/device-types/arndale.conf'
@@ -21,7 +21,8 @@
sdcard_part_android = 7
data_part_android = 7
-image_boot_msg = Starting kernel
+android_orig_block_device = mmcblk1
+android_lava_block_device = mmcblk1
boot_cmds_android = mmc init,
mmc part 0,
=== modified file 'lava_dispatcher/device/bootloader.py'
@@ -22,19 +22,25 @@
import contextlib
import time
import os
-import pexpect
from lava_dispatcher.device.master import (
MasterImageTarget
)
+from lava_dispatcher.client.base import (
+ NetworkCommandRunner,
+)
from lava_dispatcher.utils import (
- string_to_list
+ string_to_list,
+ mk_targz,
+ rmtree,
)
from lava_dispatcher.errors import (
- CriticalError
+ CriticalError,
+ OperationFailed,
)
from lava_dispatcher.downloader import (
- download_image
+ download_image,
+ download_with_retry,
)
class BootloaderTarget(MasterImageTarget):
@@ -45,50 +51,67 @@
self._boot_cmds = None
self._lava_cmds = None
self._uboot_boot = False
+ self._http_pid = None
# This is the offset into the path, used to reference bootfiles
self._offset = self.scratch_dir.index('images')
- def power_off(self, proc):
- if self._uboot_boot:
- if self.config.power_off_cmd:
- self.context.run_command(self.config.power_off_cmd)
+ def deploy_linaro_kernel(self, kernel, ramdisk, dtb, rootfs, bootloader,
+ firmware, rootfstype, bootloadertype):
+ if bootloadertype == "u_boot":
+ # We assume we will be controlling u-boot
+ if kernel is not None:
+ # We have been passed kernel image, setup TFTP boot
+ self._uboot_boot = True
+ # We are not booted yet
+ self._booted = False
+ # We specify OE deployment data, vanilla as possible
+ self.deployment_data = self.target_map['oe']
+ # Set the TFTP server IP (Dispatcher)
+ self._lava_cmds = "lava_server_ip=" + \
+ self.context.config.lava_server_ip + ","
+ kernel = download_image(kernel, self.context,
+ self.scratch_dir, decompress=False)
+ self._lava_cmds += "lava_kernel=" + \
+ kernel[self._offset::] + ","
+ if ramdisk is not None:
+ # We have been passed a ramdisk
+ ramdisk = download_image(ramdisk, self.context,
+ self.scratch_dir,
+ decompress=False)
+ self._lava_cmds += "lava_ramdisk=" + \
+ ramdisk[self._offset::] + ","
+ if dtb is not None:
+ # We have been passed a device tree blob
+ dtb = download_image(dtb, self.context,
+ self.scratch_dir, decompress=False)
+ self._lava_cmds += "lava_dtb=" + dtb[self._offset::] + ","
+ if rootfs is not None:
+ # We have been passed a rootfs
+ rootfs = download_image(rootfs, self.context,
+ self.scratch_dir, decompress=False)
+ self._lava_cmds += "lava_rootfs=" + \
+ rootfs[self._offset::] + ","
+ if bootloader is not None:
+ # We have been passed a bootloader
+ bootloader = download_image(bootloader, self.context,
+ self.scratch_dir,
+ decompress=False)
+ self._lava_cmds += "lava_bootloader=" + \
+ bootloader[self._offset::] + ","
+ if firmware is not None:
+ # We have been passed firmware
+ firmware = download_image(firmware, self.context,
+ self.scratch_dir,
+ decompress=False)
+ self._lava_cmds += "lava_firmware=" + \
+ firmware[self._offset::] + ","
+ else:
+ # This *should* never happen
+ raise CriticalError("No kernel images to boot")
else:
- super(BootloaderTarget, self).power_off(proc)
-
- def deploy_linaro_kernel(self, kernel, ramdisk, dtb, rootfs, bootloader):
- if bootloader == "u_boot":
- # We assume we will be controlling u-boot
- if kernel is not None:
- # We have been passed kernel image, setup TFTP boot
- self._uboot_boot = True
- # Set the TFTP server IP (Dispatcher)
- self._lava_cmds = "lava_server_ip=" + self.context.config.lava_server_ip + ","
- kernel = download_image(kernel, self.context, self.scratch_dir, decompress=False)
- # Set the TFTP bootfile path for the kernel
- self._lava_cmds += "lava_kernel=" + kernel[self._offset::] + ","
- if ramdisk is not None:
- # We have been passed a ramdisk
- ramdisk = download_image(ramdisk, self.context, self.scratch_dir, decompress=False)
- # Set the TFTP bootfile path for the ramdisk
- self._lava_cmds += "lava_ramdisk=" + ramdisk[self._offset::] + ","
- if dtb is not None:
- # We have been passed a device tree blob
- dtb = download_image(dtb, self.context, self.scratch_dir, decompress=False)
- # Set the bootfile path for the ramdisk
- self._lava_cmds += "lava_dtb=" + dtb[self._offset::] + ","
- if rootfs is not None:
- # We have been passed a rootfs
- rootfs = download_image(rootfs, self.context, self.scratch_dir, decompress=True)
- self._lava_cmds += "lava_rootfs=" + dtb[self._offset::] + ","
- else:
- # TODO: Faking the deployment data - Ubuntu
- self.deployment_data = self.target_map['ubuntu']
- else:
- # This *should* never happen
- raise CriticalError("No kernel images to boot")
- else:
- # Define other "types" of bootloaders here. UEFI? Grub?
- raise CriticalError("U-Boot is the only supported bootloader at this time")
+ # Define other "types" of bootloaders here. UEFI? Grub?
+ raise CriticalError("U-Boot is the only supported bootloader \
+ at this time")
def deploy_linaro(self, hwpack, rfs, bootloader):
self._uboot_boot = False
@@ -99,32 +122,136 @@
super(BootloaderTarget, self).deploy_linaro_prebuilt(image)
def _inject_boot_cmds(self):
- if isinstance(self.config.boot_cmds, basestring):
+ if self._is_job_defined_boot_cmds(self.config.boot_cmds):
+ logging.info('Overriding boot_cmds from job file')
+ self._boot_cmds = string_to_list(self._lava_cmds.encode('ascii')) \
+ + self.config.boot_cmds
+ else:
if self.config.boot_cmds_tftp is None:
raise CriticalError("No TFTP boot commands defined")
else:
+ logging.info('Loading boot_cmds from device configuration')
self._boot_cmds = self._lava_cmds + self.config.boot_cmds_tftp
- self._boot_cmds = string_to_list(self._boot_cmds.encode('ascii'))
- else:
- self._boot_cmds = string_to_list(self._lava_cmds.encode('ascii')) + self.config.boot_cmds
+ self._boot_cmds = string_to_list(
+ self._boot_cmds.encode('ascii'))
def _run_boot(self):
self._enter_bootloader(self.proc)
self._inject_boot_cmds()
self._customize_bootloader(self.proc, self._boot_cmds)
- self._wait_for_prompt(self.proc, ['\(initramfs\)', self.config.master_str],
- self.config.boot_linaro_timeout)
+ self.proc.expect(self.config.image_boot_msg, timeout=300)
+ self._wait_for_prompt(self.proc, ['\(initramfs\)',
+ self.config.master_str],
+ self.config.boot_linaro_timeout)
def _boot_linaro_image(self):
- if self._uboot_boot:
- if self.config.hard_reset_command:
- self._hard_reboot()
- else:
- raise CriticalError("No hard reset command defined")
- self._run_boot()
- self.proc.sendline('export PS1="%s"' % self.deployment_data['TESTER_PS1'])
+ if self._uboot_boot and not self._booted:
+ try:
+ if self.config.hard_reset_command:
+ self._hard_reboot()
+ self._run_boot()
+ else:
+ self._soft_reboot()
+ self._run_boot()
+ except:
+ raise OperationFailed("_run_boot failed")
+ self.proc.sendline('export PS1="%s"'
+ % self.deployment_data['TESTER_PS1'])
self._booted = True
+ elif self._uboot_boot and self._booted:
+ self.proc.sendline('export PS1="%s"'
+ % self.deployment_data['TESTER_PS1'])
else:
super(BootloaderTarget, self)._boot_linaro_image()
+ def start_http_server(self, runner, ip):
+ if self._http_pid is not None:
+ raise OperationFailed("busybox httpd already running with pid %d"
+ % self._http_pid)
+ # busybox produces no output to parse for,
+ # so run it in the bg and get its pid
+ runner.run('busybox httpd -f &')
+ runner.run('echo pid:$!:pid', response="pid:(\d+):pid", timeout=10)
+ if runner.match_id != 0:
+ raise OperationFailed("busybox httpd did not start")
+ else:
+ self._http_pid = runner.match.group(1)
+ url_base = "http://%s" % ip
+ return url_base
+
+ def stop_http_server(self, runner):
+ if self._http_pid is None:
+ raise OperationFailed("busybox httpd not running, \
+ but stop_http_server called.")
+ runner.run('kill %s' % self._http_pid)
+ self._http_pid = None
+
+ @contextlib.contextmanager
+ def file_system(self, partition, directory):
+ if self._uboot_boot:
+ try:
+ pat = self.deployment_data['TESTER_PS1_PATTERN']
+ incrc = self.deployment_data['TESTER_PS1_INCLUDES_RC']
+ runner = NetworkCommandRunner(self, pat, incrc)
+
+ targetdir = '/%s' % directory
+ runner.run('mkdir -p %s' % targetdir)
+ parent_dir, target_name = os.path.split(targetdir)
+ runner.run('/bin/tar -cmzf /tmp/fs.tgz -C %s %s'
+ % (parent_dir, target_name))
+ runner.run('cd /tmp') # need to be in same dir as fs.tgz
+
+ ip = runner.get_target_ip()
+ url_base = self.start_http_server(runner, ip)
+
+ url = url_base + '/fs.tgz'
+ logging.info("Fetching url: %s" % url)
+ tf = download_with_retry(self.context, self.scratch_dir,
+ url, False)
+
+ tfdir = os.path.join(self.scratch_dir, str(time.time()))
+
+ try:
+ os.mkdir(tfdir)
+ self.context.run_command('/bin/tar -C %s -xzf %s'
+ % (tfdir, tf))
+ yield os.path.join(tfdir, target_name)
+ finally:
+ tf = os.path.join(self.scratch_dir, 'fs.tgz')
+ mk_targz(tf, tfdir)
+ rmtree(tfdir)
+
+ # get the last 2 parts of tf, ie "scratchdir/tf.tgz"
+ tf = '/'.join(tf.split('/')[-2:])
+ runner.run('rm -rf %s' % targetdir)
+ self._target_extract(runner, tf, parent_dir)
+ finally:
+ self.stop_http_server(runner)
+ else:
+ with super(BootloaderTarget, self).file_system(
+ partition, directory) as path:
+ yield path
+
+ def _target_extract(self, runner, tar_file, dest, timeout=-1):
+ tmpdir = self.context.config.lava_image_tmpdir
+ url = self.context.config.lava_image_url
+ tar_file = tar_file.replace(tmpdir, '')
+ tar_url = '/'.join(u.strip('/') for u in [url, tar_file])
+ self._target_extract_url(runner, tar_url, dest, timeout=timeout)
+
+ def _target_extract_url(self, runner, tar_url, dest, timeout=-1):
+ decompression_cmd = ''
+ if tar_url.endswith('.gz') or tar_url.endswith('.tgz'):
+ decompression_cmd = '| /bin/gzip -dc'
+ elif tar_url.endswith('.bz2'):
+ decompression_cmd = '| /bin/bzip2 -dc'
+ elif tar_url.endswith('.tar'):
+ decompression_cmd = ''
+ else:
+ raise RuntimeError('bad file extension: %s' % tar_url)
+
+ runner.run('wget -O - %s %s | /bin/tar -C %s -xmf -'
+ % (tar_url, decompression_cmd, dest),
+ timeout=timeout)
+
target_class = BootloaderTarget
=== modified file 'lava_dispatcher/device/fastmodel.py'
@@ -301,10 +301,10 @@
if self._uefi:
self._enter_bootloader(self.proc)
- if isinstance(self.config.boot_cmds, basestring):
+ if self._is_job_defined_boot_cmds(self.config.boot_cmds):
+ boot_cmds = self.config.boot_cmds
+ else:
boot_cmds = string_to_list(self.config.boot_cmds.encode('ascii'))
- else:
- boot_cmds = self.config.boot_cmds
self._customize_bootloader(self.proc, boot_cmds)
return self.proc
=== modified file 'lava_dispatcher/device/master.py'
@@ -99,8 +99,6 @@
return self.device_version
def power_on(self):
- if self.config.power_on_cmd:
- self.context.run_command(self.config.power_on_cmd)
self._boot_linaro_image()
return self.proc
@@ -390,7 +388,7 @@
def _wait_for_master_boot(self):
self.proc.expect(self.config.image_boot_msg, timeout=300)
- self.proc.expect(self.config.master_str, timeout=300)
+ self._wait_for_prompt(self.proc, self.config.master_str, timeout=300)
def boot_master_image(self):
"""
@@ -428,7 +426,7 @@
runner = MasterCommandRunner(self)
try:
- self.master_ip = runner.get_master_ip()
+ self.master_ip = runner.get_target_ip()
self.device_version = runner.get_device_version()
except NetworkError as e:
msg = "Failed to get network up: " % e
@@ -485,22 +483,31 @@
self.proc.empty_buffer()
def _boot_linaro_image(self):
+ boot_cmds_job_file = False
+ boot_cmds_boot_options = False
boot_cmds = self.deployment_data['boot_cmds']
options = boot_options.as_dict(self, defaults={'boot_cmds': boot_cmds})
+ boot_cmds_job_file = self._is_job_defined_boot_cmds(self.config.boot_cmds)
+
+ if 'boot_cmds' in options:
+ if options['boot_cmds'].value != 'boot_cmds':
+ boot_cmds_boot_options = True
+
# Interactive boot_cmds from the job file are a list.
# We check for them first, if they are present, we use
# them and ignore the other cases.
- if not isinstance(self.config.boot_cmds, basestring):
+ if boot_cmds_job_file:
logging.info('Overriding boot_cmds from job file')
boot_cmds_override = True
boot_cmds = self.config.boot_cmds
# If there were no interactive boot_cmds, next we check
# for boot_option overrides. If one exists, we use them
# and ignore all other cases.
- elif options['boot_cmds'].value != 'boot_cmds':
+ elif boot_cmds_boot_options:
logging.info('Overriding boot_cmds from boot_options')
boot_cmds = options['boot_cmds'].value
+ logging.info('boot_option=%s' % boot_cmds)
boot_cmds = self.config.cp.get('__main__', boot_cmds)
boot_cmds = string_to_list(boot_cmds.encode('ascii'))
# No interactive or boot_option overrides are present,
@@ -541,29 +548,6 @@
super(MasterCommandRunner, self).__init__(
target, target.MASTER_PS1_PATTERN, prompt_str_includes_rc=True)
- def get_master_ip(self):
- logging.info("Waiting for network to come up")
- try:
- self.wait_network_up(timeout=20)
- except NetworkError:
- logging.exception("Unable to reach LAVA server")
- raise
-
- pattern1 = "<(\d?\d?\d?\.\d?\d?\d?\.\d?\d?\d?\.\d?\d?\d?)>"
- cmd = ("ifconfig %s | grep 'inet addr' | awk -F: '{print $2}' |"
- "awk '{print \"<\" $1 \">\"}'" %
- self._client.config.default_network_interface)
- self.run(
- cmd, [pattern1, pexpect.EOF, pexpect.TIMEOUT], timeout=5)
- if self.match_id != 0:
- msg = "Unable to determine master image IP address"
- logging.error(msg)
- raise CriticalError(msg)
-
- ip = self.match.group(1)
- logging.debug("Master image IP is %s" % ip)
- return ip
-
def get_device_version(self):
pattern = 'device_version=(\d+-\d+/\d+-\d+)'
self.run("echo \"device_version="
=== modified file 'lava_dispatcher/device/qemu.py'
@@ -38,22 +38,58 @@
extract_targz,
finalize_process,
)
+from lava_dispatcher.errors import (
+ CriticalError
+)
class QEMUTarget(Target):
def __init__(self, context, config):
super(QEMUTarget, self).__init__(context, config)
+ self._qemu_options = None
self._sd_image = None
+ def deploy_linaro_kernel(self, kernel, ramdisk, dtb, rootfs, bootloader,
+ firmware, rootfstype, bootloadertype):
+ if rootfs is not None:
+ self._sd_image = download_image(rootfs, self.context)
+ self._customize_linux(self._sd_image)
+ self.append_qemu_options(self.config.qemu_options.format(
+ DISK_IMAGE=self._sd_image))
+ kernel_args = 'root=/dev/sda1'
+ else:
+ raise CriticalError("You must specify a QEMU file system image")
+
+ if kernel is not None:
+ kernel = download_image(kernel, self.context)
+ self.append_qemu_options(' -kernel %s' % kernel)
+ kernel_args += ' console=ttyS0,115200'
+ if ramdisk is not None:
+ ramdisk = download_image(ramdisk, self.context)
+ self.append_qemu_options(' -initrd %s' % ramdisk)
+ if dtb is not None:
+ dtb = download_image(dtb, self.context)
+ self.append_qemu_options(' -dtb %s' % ramdisk)
+ if firmware is not None:
+ firmware = download_image(firmware, self.context)
+ self.append_qemu_options(' -bios %s' % firmware)
+ self.append_qemu_options(' -append "%s"' % kernel_args)
+ else:
+ raise CriticalError("No kernel images to boot")
+
def deploy_linaro(self, hwpack=None, rootfs=None, bootloader='u_boot'):
odir = self.scratch_dir
self._sd_image = generate_image(self, hwpack, rootfs, odir, bootloader)
self._customize_linux(self._sd_image)
+ self.append_qemu_options(self.config.qemu_options.format(
+ DISK_IMAGE=self._sd_image))
def deploy_linaro_prebuilt(self, image):
self._sd_image = download_image(image, self.context)
self._customize_linux(self._sd_image)
+ self.append_qemu_options(self.config.qemu_options.format(
+ DISK_IMAGE=self._sd_image))
@contextlib.contextmanager
def file_system(self, partition, directory):
@@ -70,9 +106,7 @@
extract_targz(tb, '%s/%s' % (mntdir, directory))
def power_on(self):
- qemu_options = self.config.qemu_options.format(
- DISK_IMAGE=self._sd_image)
- qemu_cmd = '%s %s' % (self.config.qemu_binary, qemu_options)
+ qemu_cmd = '%s %s' % (self.config.qemu_binary, self._qemu_options)
logging.info('launching qemu with command %r' % qemu_cmd)
proc = self.context.spawn(qemu_cmd, timeout=1200)
return proc
@@ -89,4 +123,10 @@
except subprocess.CalledProcessError:
return "unknown"
+ def append_qemu_options(self, parameter):
+ if self._qemu_options is None:
+ self._qemu_options = parameter
+ else:
+ self._qemu_options += parameter
+
target_class = QEMUTarget
=== modified file 'lava_dispatcher/device/target.py'
@@ -140,7 +140,7 @@
yield runner
finally:
if proc and runner:
- self.power_off(proc)
+ pass
def _get_runner(self, proc):
from lava_dispatcher.client.base import CommandRunner
@@ -178,6 +178,12 @@
def _wait_for_prompt(self, connection, prompt_pattern, timeout):
wait_for_prompt(connection, prompt_pattern, timeout)
+ def _is_job_defined_boot_cmds(self, boot_cmds):
+ if isinstance(self.config.boot_cmds, basestring):
+ return False
+ else:
+ return True
+
def _enter_bootloader(self, connection):
if connection.expect(self.config.interrupt_boot_prompt) != 0:
raise Exception("Failed to enter bootloader")
=== removed file 'lava_dispatcher/device/uefi.py'
@@ -1,67 +0,0 @@
-# Copyright (C) 2013 Linaro Limited
-#
-# Author: Dave Pigott <dave.pigott@linaro.org>
-#
-# This file is part of LAVA Dispatcher.
-#
-# LAVA Dispatcher is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# LAVA Dispatcher is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along
-# with this program; if not, see <http://www.gnu.org/licenses>.
-
-import logging
-import re
-from lava_dispatcher.device.master import (
- MasterImageTarget
-)
-
-
-class UEFITarget(MasterImageTarget):
-
- def __init__(self, context, config):
- super(UEFITarget, self).__init__(context, config)
-
- def _boot(self, boot_cmds):
- """
-
- :param boot_cmds:
- :raise:
- """
- try:
- self._soft_reboot()
- self._enter_uefi()
- except:
- logging.exception("enter uefi failed")
- self._hard_reboot()
- self._enter_uefi()
- self.proc.expect(self.config.bootloader_prompt, timeout=300)
- for line in range(0, len(boot_cmds)):
- parts = re.match('^(?P<action>sendline|expect)\s*(?P<command>.*)', line)
- try:
- action = parts.group('action')
- command = re.escape(parts.group('command'))
- except AttributeError as e:
- raise Exception("Badly formatted command in boot_cmds %s" % e)
- if action == "sendline":
- self.proc.send(command)
- elif action == "expect":
- self.proc.expect(command, timeout=300)
- else:
- raise Exception("Unrecognised action in boot_cmds")
-
- def _enter_uefi(self):
- if self.proc.expect(self.config.interrupt_boot_prompt) != 0:
- raise Exception("Failed to enter bootloader")
- self.proc.send(self.config.interrupt_boot_command)
-
-
-target_class = UEFITarget