def test_downloader_populate_https():
# "images.key" with https
action = DownloaderAction("key",
"/path/to/save",
params={"url": "https://url.org/resource.img"})
action.level = 1
action.populate(
{"images": {
"key": {
"url": "https://url.org/resource.img"
}
}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], HttpDownloadAction)
assert action.pipeline.actions[0].url == urlparse(
"https://url.org/resource.img")
# "key" with https
action = DownloaderAction("key",
"/path/to/save",
params={"url": "https://url.org/resource.img"})
action.level = 1
action.populate({"key": {"url": "https://url.org/resource.img"}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], HttpDownloadAction)
assert action.pipeline.actions[0].url == urlparse(
"https://url.org/resource.img")
def populate(self, parameters):
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
path = self.mkdtemp()
if 'uefi' in parameters:
uefi_path = self.mkdtemp()
self.internal_pipeline.add_action(
DownloaderAction('uefi', uefi_path))
# uefi option of QEMU needs a directory, not the filename
self.set_namespace_data(action=self.name,
label='image',
key='uefi_dir',
value=uefi_path,
parameters=parameters)
# alternatively use the -bios option and standard image args
for image in parameters['images'].keys():
if image != 'yaml_line':
self.internal_pipeline.add_action(DownloaderAction(
image, path))
if parameters['images'][image].get('format', '') == 'qcow2':
self.internal_pipeline.add_action(
QCowConversionAction(image))
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(
OverlayAction()) # idempotent, includes testdef
self.internal_pipeline.add_action(ApplyOverlayGuest())
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
"""
The dispatcher does the first download as the first deployment is not guaranteed to
have DNS resolution fully working, so we can use the IP address of the dispatcher
to get it (with the advantage that the dispatcher decompresses it so that the ramdisk
can pipe the raw image directly from wget to dd.
This also allows the use of local file:// locations which are visible to the dispatcher
but not the device.
"""
self.image_path = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(OverlayAction()) # idempotent, includes testdef
uniquify = parameters.get('uniquify', True)
if 'images' in parameters:
for k in sorted(parameters['images'].keys()):
if k == 'yaml_line':
continue
self.internal_pipeline.add_action(DownloaderAction(
k, path=self.image_path, uniquify=uniquify))
if parameters['images'][k].get('apply-overlay', False):
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(ApplyOverlayImage())
self.internal_pipeline.add_action(DDAction())
elif 'image' in parameters:
self.internal_pipeline.add_action(DownloaderAction(
'image', path=self.image_path, uniquify=uniquify))
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(ApplyOverlayImage())
self.internal_pipeline.add_action(DDAction())
# FIXME: could support tarballs too
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def test_downloader_populate_scp():
# "images.key" with scp
action = DownloaderAction("key",
"/path/to/save",
params={"url": "scp://user@host:/resource.img"})
action.level = 1
action.populate(
{"images": {
"key": {
"url": "scp://user@host:/resource.img"
}
}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], ScpDownloadAction)
assert action.pipeline.actions[0].url == urlparse(
"scp://user@host:/resource.img")
# "key" with scp
action = DownloaderAction("key",
"/path/to/save",
params={"url": "scp://user@host:/resource.img"})
action.level = 1
action.populate({"key": {"url": "scp://user@host:/resource.img"}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], ScpDownloadAction)
assert action.pipeline.actions[0].url == urlparse(
"scp://user@host:/resource.img")
def populate(self, parameters):
self.pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
path = self.mkdtemp()
if "uefi" in parameters:
uefi_path = self.mkdtemp()
self.pipeline.add_action(
DownloaderAction("uefi", uefi_path, params=parameters["uefi"])
)
# uefi option of QEMU needs a directory, not the filename
self.set_namespace_data(
action=self.name,
label="image",
key="uefi_dir",
value=uefi_path,
parameters=parameters,
)
# alternatively use the -bios option and standard image args
for image in parameters["images"].keys():
self.pipeline.add_action(
DownloaderAction(image, path, params=parameters["images"][image])
)
if parameters["images"][image].get("format", "") == "qcow2":
self.pipeline.add_action(QCowConversionAction(image))
if self.test_needs_overlay(parameters):
self.pipeline.add_action(OverlayAction()) # idempotent, includes testdef
self.pipeline.add_action(ApplyOverlayGuest())
if self.test_needs_deployment(parameters):
self.pipeline.add_action(DeployDeviceEnvironment())
def test_downloader_no_url():
# 1. no url available
action = DownloaderAction("key", "/path/to/save", params={})
action.level = 1
with pytest.raises(JobError) as exc:
action.populate({"key": {}})
assert exc.match("Invalid deploy action: 'url' is missing for 'key'")
def populate(self, parameters):
self.tftp_dir = self.mkdtemp(override=tftpd_dir())
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.set_namespace_data(action=self.name,
label='tftp',
key='tftp_dir',
value=self.tftp_dir,
parameters=parameters)
for key in ['initrd', 'kernel', 'dtb', 'nbdroot']:
if key in parameters:
download = DownloaderAction(key, path=self.tftp_dir)
download.max_retries = 3 # overridden by failure_retry in the parameters, if set.
self.internal_pipeline.add_action(download)
if key == 'initrd':
self.set_namespace_data(action="tftp-deploy",
label='tftp',
key='ramdisk',
value=True,
parameters=parameters)
self.set_namespace_data(action=self.name,
label='nbd',
key='initrd',
value=True,
parameters=parameters)
# prepare overlay
self.internal_pipeline.add_action(OverlayAction())
# setup values for protocol and later steps
self.set_namespace_data(action=self.name,
label='nbd',
key='initrd',
value=True,
parameters=parameters)
# store in parameters for protocol 'xnbd' to tear-down xnbd-server
# and store in namespace for boot action
# ip
parameters['lava-xnbd'] = {}
self.nbd_ip = dispatcher_ip(self.job.parameters['dispatcher'])
parameters['lava-xnbd']['ip'] = self.nbd_ip
self.set_namespace_data(action=self.name,
label='nbd',
key='nbd_server_ip',
value=self.nbd_ip,
parameters=parameters)
# port
self.nbd_port = get_free_port(self.job.parameters['dispatcher'])
parameters['lava-xnbd']['port'] = self.nbd_port
self.set_namespace_data(action=self.name,
label='nbd',
key='nbd_server_port',
value=self.nbd_port,
parameters=parameters)
# handle XnbdAction next - bring-up xnbd-server
self.internal_pipeline.add_action(XnbdAction())
def populate(self, parameters):
self.tftp_dir = self.mkdtemp(override=filesystem.tftpd_dir())
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.set_namespace_data(
action=self.name,
label="tftp",
key="tftp_dir",
value=self.tftp_dir,
parameters=parameters,
)
for key in ["initrd", "kernel", "dtb", "nbdroot"]:
if key in parameters:
download = DownloaderAction(key,
path=self.tftp_dir,
params=parameters[key])
download.max_retries = (
3 # overridden by failure_retry in the parameters, if set.
)
self.pipeline.add_action(download)
if key == "initrd":
self.set_namespace_data(
action="tftp-deploy",
label="tftp",
key="ramdisk",
value=True,
parameters=parameters,
)
self.set_namespace_data(
action=self.name,
label="nbd",
key="initrd",
value=True,
parameters=parameters,
)
# prepare overlay
self.pipeline.add_action(OverlayAction())
if "kernel" in parameters and "type" in parameters["kernel"]:
self.pipeline.add_action(PrepareKernelAction())
# setup values for protocol and later steps
self.set_namespace_data(
action=self.name,
label="nbd",
key="initrd",
value=True,
parameters=parameters,
)
# store in parameters for protocol 'xnbd' to tear-down xnbd-server
# and store in namespace for boot action
# ip
parameters["lava-xnbd"] = {}
# handle XnbdAction next - bring-up xnbd-server
self.pipeline.add_action(XnbdAction())
def test_downloader_unsupported_scheme():
# Test raise
# 1. unsuported scheme
action = DownloaderAction("key",
"/path/to/save",
params={"url": "ftp://user@host:/resource.img"})
action.level = 1
with pytest.raises(JobError) as exc:
action.populate({"key": {"url": "ftp://user@host:/resource.img"}})
assert exc.match("Unsupported url protocol scheme: ftp")
def populate(self, parameters):
self.preseed_path = self.mkdtemp(override=tftpd_dir())
self.internal_pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
self.internal_pipeline.add_action(IsoEmptyImage())
# the preseed file needs to go into the dispatcher apache tmp directory.
self.internal_pipeline.add_action(DownloaderAction('preseed', self.preseed_path))
self.internal_pipeline.add_action(DownloaderAction('iso', self.mkdtemp()))
self.internal_pipeline.add_action(IsoPullInstaller())
self.internal_pipeline.add_action(QemuCommandLine())
# prepare overlay at this stage - make it available after installation.
self.internal_pipeline.add_action(OverlayAction()) # idempotent, includes testdef
self.internal_pipeline.add_action(ApplyOverlayGuest())
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.tftp_dir = self.mkdtemp(override=tftpd_dir())
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.set_namespace_data(action=self.name,
label='tftp',
key='tftp_dir',
value=self.tftp_dir,
parameters=parameters)
for key in [
'ramdisk', 'kernel', 'dtb', 'nfsrootfs', 'modules', 'preseed'
]:
if key in parameters:
self.internal_pipeline.add_action(
DownloaderAction(key, path=self.tftp_dir))
if key == 'ramdisk':
self.set_namespace_data(action=self.name,
label='tftp',
key='ramdisk',
value=True,
parameters=parameters)
# TftpAction is a deployment, so once the files are in place, just do the overlay
self.internal_pipeline.add_action(PrepareOverlayTftp())
self.internal_pipeline.add_action(LxcCreateUdevRuleAction())
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
tar_flags = (parameters["deployment_data"]["tar_flags"] if "tar_flags"
in parameters["deployment_data"].keys() else "")
self.set_namespace_data(
action=self.name,
label=self.name,
key="tar_flags",
value=tar_flags,
parameters=parameters,
)
self.pipeline.add_action(OverlayAction())
for item in self.items:
if item in parameters:
self.pipeline.add_action(DownloaderAction(item,
path=self.mkdtemp()),
params=parameters[item])
self.set_namespace_data(
action=self.name,
label="scp",
key=item,
value=True,
parameters=parameters,
)
# we might not have anything to download, just the overlay to push
self.pipeline.add_action(PrepareOverlayScp())
# prepare the device environment settings in common data for enabling in the boot step
self.pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.parameters = parameters
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
if self.test_needs_overlay(parameters):
self.pipeline.add_action(OverlayAction())
path = self.mkdtemp()
self.set_namespace_data(action="uuu-deploy",
label="uuu-images",
key="root_location",
value=path)
images_param = dict(parameters["images"])
images = list(images_param.keys())
self.set_namespace_data(action="uuu-deploy",
label="uuu-images",
key="images_names",
value=images)
for image in images:
self.pipeline.add_action(
DownloaderAction(image,
path=path,
params=parameters["images"][image]))
if images_param[image].get("apply-overlay", False):
if self.test_needs_overlay(parameters):
if images_param[image].get("sparse", False):
self.pipeline.add_action(
ApplyOverlaySparseImage(image_key=image))
else:
self.pipeline.add_action(
ApplyOverlayImage(image_key=image))
def populate(self, parameters):
self.tftp_dir = self.mkdtemp(override=filesystem.tftpd_dir())
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.set_namespace_data(
action=self.name,
label="tftp",
key="tftp_dir",
value=self.tftp_dir,
parameters=parameters,
)
for key in [
"ramdisk", "kernel", "dtb", "nfsrootfs", "modules", "preseed"
]:
if key in parameters:
self.pipeline.add_action(
DownloaderAction(key,
path=self.tftp_dir,
params=parameters[key]))
if key == "ramdisk":
self.set_namespace_data(
action=self.name,
label="tftp",
key="ramdisk",
value=True,
parameters=parameters,
)
# TftpAction is a deployment, so once the files are in place, just do the overlay
self.pipeline.add_action(PrepareOverlayTftp())
self.pipeline.add_action(LxcCreateUdevRuleAction())
if self.test_needs_deployment(parameters):
self.pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
download_dir = self.mkdtemp()
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
# Musca will autoboot previously deployed binaries
# Therefore disconnect serial to avoid clutter.
self.pipeline.add_action(DisconnectDevice())
# If we don't run with a strict schema, it is possible to pass validation with warnings
# even without the required 'test_binary' field.
# Therefore, ensure the DownloaderAction.populate does not fail, and catch this at validate step.
image_params = parameters.get("images", {}).get("test_binary")
if image_params:
self.pipeline.add_action(
DownloaderAction("test_binary",
path=download_dir,
params=image_params))
# Turn on
self.pipeline.add_action(ResetDevice())
# Wait for storage
self.pipeline.add_action(WaitMuscaMassStorageAction())
# Deploy test binary
self.pipeline.add_action(MountMuscaMassStorageDevice())
self.pipeline.add_action(DeployMuscaTestBinary())
self.pipeline.add_action(UnmountMuscaMassStorageDevice())
# Check for FAIL.TXT to check if we were successful
self.pipeline.add_action(
WaitMuscaMassStorageAction(udev_action="change"))
self.pipeline.add_action(MountMuscaMassStorageDevice())
self.pipeline.add_action(CheckMuscaFlashAction())
self.pipeline.add_action(UnmountMuscaMassStorageDevice())
def populate(self, parameters):
"""
The dispatcher does the first download as the first deployment is not guaranteed to
have DNS resolution fully working, so we can use the IP address of the dispatcher
to get it (with the advantage that the dispatcher decompresses it so that the ramdisk
can pipe the raw image directly from wget to deploy with tools (dd,tar and so on).)
This also allows the use of local file:// locations which are visible to the dispatcher
but not the device.
"""
self.image_path = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
uniquify = parameters.get('uniquify', True)
self.internal_pipeline.add_action(QemudevDeployMasterAction())
if 'rootfs_path' in parameters:
self.internal_pipeline.add_action(DownloaderAction('rootfs', path=self.image_path, uniquify=uniquify))
self.internal_pipeline.add_action(QemudevDeploySlaveAction())
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(OverlayAction()) # idempotent, includes testdef
# FIXME: could support tarballs too
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
tar_flags = parameters['deployment_data'][
'tar_flags'] if 'tar_flags' in parameters['deployment_data'].keys(
) else ''
self.set_namespace_data(action=self.name,
label=self.name,
key='tar_flags',
value=tar_flags,
parameters=parameters)
self.internal_pipeline.add_action(OverlayAction())
for item in self.items:
if item in parameters:
self.internal_pipeline.add_action(
DownloaderAction(item, path=self.mkdtemp()), parameters)
self.set_namespace_data(action=self.name,
label='scp',
key=item,
value=True,
parameters=parameters)
# we might not have anything to download, just the overlay to push
self.internal_pipeline.add_action(PrepareOverlayScp())
# prepare the device environment settings in common data for enabling in the boot step
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
download_dir = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.internal_pipeline.add_action(DisconnectDevice())
self.internal_pipeline.add_action(ResetDevice())
self.internal_pipeline.add_action(WaitUSBMassStorageDeviceAction())
for image in parameters["images"].keys():
self.internal_pipeline.add_action(
DownloaderAction(image, path=download_dir))
self.internal_pipeline.add_action(MountVExpressMassStorageDevice())
# Sort the keys so recovery_image will be first
for image in sorted(parameters["images"].keys()):
if image == "recovery_image":
self.internal_pipeline.add_action(
ExtractVExpressRecoveryImage())
self.internal_pipeline.add_action(
DeployVExpressRecoveryImage())
else:
self.internal_pipeline.add_action(DeployMPSTestBinary(image))
# Should we hard reboot the board after flash?
params = self.job.device["actions"]["deploy"]["methods"]["mps"][
"parameters"]
if params["hard-reboot"]:
# Unmount the mass storage device before rebooting
self.internal_pipeline.add_action(
UnmountVExpressMassStorageDevice())
self.internal_pipeline.add_action(PowerOff())
else:
# Unmount the mass storage device after the creation of reboot.txt
self.internal_pipeline.add_action(DeployMPSRebootTxt())
self.internal_pipeline.add_action(
UnmountVExpressMassStorageDevice())
def populate(self, parameters):
download_dir = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
if 'nfsrootfs' in parameters:
self.internal_pipeline.add_action(
DownloaderAction('nfsrootfs', path=download_dir))
if 'modules' in parameters:
self.internal_pipeline.add_action(
DownloaderAction('modules', path=download_dir))
# NfsAction is a deployment, so once the nfsrootfs has been deployed, just do the overlay
self.internal_pipeline.add_action(ExtractNfsRootfs())
self.internal_pipeline.add_action(OverlayAction())
self.internal_pipeline.add_action(ExtractModules())
self.internal_pipeline.add_action(ApplyOverlayTftp())
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
path = self.mkdtemp()
self.internal_pipeline.add_action(DownloaderAction('image', path=path))
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(OverlayAction())
self.internal_pipeline.add_action(ApplyOverlayImage())
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
def test_downloader_populate_file():
# "images.key" with lxc
action = DownloaderAction("key",
"/path/to/save",
params={"url": "lxc:///resource.img"})
action.level = 1
action.populate({"images": {"key": {"url": "lxc:///resource.img"}}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], LxcDownloadAction)
assert action.pipeline.actions[0].url == urlparse("lxc:///resource.img")
# "key" with lxc
action = DownloaderAction("key",
"/path/to/save",
params={"url": "lxc:///resource.img"})
action.level = 1
action.populate({"key": {"url": "lxc:///resource.img"}})
assert len(action.pipeline.actions) == 1
assert isinstance(action.pipeline.actions[0], LxcDownloadAction)
assert action.pipeline.actions[0].url == urlparse("lxc:///resource.img")
def populate(self, parameters):
self.internal_pipeline = Pipeline(
parent=self, job=self.job, parameters=parameters
)
# Download the images
self.path = self.mkdtemp()
for image in parameters["images"].keys():
self.internal_pipeline.add_action(DownloaderAction(image, self.path))
if self.test_needs_deployment(parameters):
self.internal_pipeline.add_action(DeployDeviceEnvironment())
if self.test_needs_overlay(parameters):
self.internal_pipeline.add_action(OverlayAction())
def populate(self, parameters):
self.image_path = self.mkdtemp()
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
if self.test_needs_overlay(parameters):
self.pipeline.add_action(OverlayAction())
uniquify = parameters.get("uniquify", True)
if "images" in parameters:
for k in sorted(parameters["images"].keys()):
self.pipeline.add_action(
DownloaderAction(k,
self.image_path,
parameters["images"][k],
uniquify=uniquify))
def populate(self, parameters):
self.preseed_path = self.mkdtemp(override=filesystem.tftpd_dir())
self.pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.pipeline.add_action(IsoEmptyImage())
# the preseed file needs to go into the dispatcher apache tmp directory.
self.pipeline.add_action(
DownloaderAction("preseed",
self.preseed_path,
params=parameters["images"]["preseed"]))
self.pipeline.add_action(
DownloaderAction("iso",
self.mkdtemp(),
params=parameters["images"]["iso"]))
self.pipeline.add_action(IsoPullInstaller())
self.pipeline.add_action(QemuCommandLine())
# prepare overlay at this stage - make it available after installation.
if self.test_needs_overlay(parameters):
self.pipeline.add_action(
OverlayAction()) # idempotent, includes testdef
self.pipeline.add_action(ApplyOverlayGuest())
if self.test_needs_deployment(parameters):
self.pipeline.add_action(DeployDeviceEnvironment())
def populate(self, parameters):
self.tftp_dir = self.mkdtemp(override=tftpd_dir())
self.internal_pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
self.set_namespace_data(action=self.name, label='tftp', key='tftp_dir', value=self.tftp_dir, parameters=parameters)
for key in ['initrd', 'kernel', 'dtb', 'nbdroot']:
if key in parameters:
download = DownloaderAction(key, path=self.tftp_dir)
download.max_retries = 3 # overridden by failure_retry in the parameters, if set.
self.internal_pipeline.add_action(download)
if key == 'initrd':
self.set_namespace_data(action="tftp-deploy", label='tftp', key='ramdisk', value=True, parameters=parameters)
self.set_namespace_data(action=self.name, label='nbd', key='initrd', value=True, parameters=parameters)
# prepare overlay
self.internal_pipeline.add_action(OverlayAction())
# setup values for protocol and later steps
self.set_namespace_data(action=self.name, label='nbd', key='initrd', value=True, parameters=parameters)
# store in parameters for protocol 'xnbd' to tear-down xnbd-server
# and store in namespace for boot action
# ip
parameters['lava-xnbd'] = {}
# handle XnbdAction next - bring-up xnbd-server
self.internal_pipeline.add_action(XnbdAction())
def populate(self, parameters):
# Import the module here to avoid cyclic import.
from lava_dispatcher.actions.deploy.download import DownloaderAction
# Add 'url' as an alias to 'repository'. DownloaderAction requires an
# 'url' key.
params = dict(**parameters, url=self.parameters["repository"])
self.download_dir = self.mkdtemp()
self.action_key = "url_repo"
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=params)
self.internal_pipeline.add_action(
DownloaderAction(self.action_key, self.download_dir,
params=params))
def populate(self, parameters):
download_dir = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
if 'recovery_image' in parameters:
self.internal_pipeline.add_action(DownloaderAction('recovery_image', path=download_dir))
self.internal_pipeline.add_action(LxcCreateUdevRuleAction())
self.force_prompt = True
self.internal_pipeline.add_action(ConnectDevice())
self.internal_pipeline.add_action(ResetDevice())
self.internal_pipeline.add_action(ExtractVExpressRecoveryImage())
self.internal_pipeline.add_action(EnterVExpressMCC())
self.internal_pipeline.add_action(EnableVExpressMassStorage())
self.internal_pipeline.add_action(WaitUSBMassStorageDeviceAction())
self.internal_pipeline.add_action(MountVExpressMassStorageDevice())
self.internal_pipeline.add_action(DeployVExpressRecoveryImage())
self.internal_pipeline.add_action(UnmountVExpressMassStorageDevice())
self.internal_pipeline.add_action(VExpressFlashErase())
def populate(self, parameters):
download_dir = self.mkdtemp()
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
self.internal_pipeline.add_action(ConnectDevice())
self.internal_pipeline.add_action(ResetDevice())
self.internal_pipeline.add_action(WaitUSBMassStorageDeviceAction())
for image in parameters['images'].keys():
if image != 'yaml_line':
self.internal_pipeline.add_action(
DownloaderAction(image, path=download_dir))
self.internal_pipeline.add_action(MountVExpressMassStorageDevice())
if 'recovery_image' in parameters['images'].keys():
self.internal_pipeline.add_action(ExtractVExpressRecoveryImage())
self.internal_pipeline.add_action(DeployVExpressRecoveryImage())
if 'test_binary' in parameters['images'].keys():
self.internal_pipeline.add_action(DeployMPSTestBinary())
self.internal_pipeline.add_action(UnmountVExpressMassStorageDevice())
def populate(self, parameters):
self.pipeline = Pipeline(parent=self, job=self.job, parameters=parameters)
if self.test_needs_overlay(parameters):
self.pipeline.add_action(OverlayAction())
# Check if the device has a power command such as HiKey, Dragonboard,
# etc. against device that doesn't like Nexus, etc.
if self.job.device.get("fastboot_via_uboot", False):
self.pipeline.add_action(ConnectDevice())
self.pipeline.add_action(UBootEnterFastbootAction())
elif self.job.device.hard_reset_command:
self.force_prompt = True
self.pipeline.add_action(ConnectDevice())
if not is_lxc_requested(self.job):
self.pipeline.add_action(PrePower())
self.pipeline.add_action(ResetDevice())
else:
self.pipeline.add_action(EnterFastbootAction())
fastboot_dir = self.mkdtemp()
for image in sorted(parameters["images"].keys()):
self.pipeline.add_action(
DownloaderAction(
image, fastboot_dir, params=parameters["images"][image]
)
)
if parameters["images"][image].get("apply-overlay", False):
if self.test_needs_overlay(parameters):
if parameters["images"][image].get("sparse", True):
self.pipeline.add_action(ApplyOverlaySparseImage(image))
else:
use_root_part = parameters["images"][image].get(
"root_partition", False
)
self.pipeline.add_action(
ApplyOverlayImage(image, use_root_partition=use_root_part)
)
if self.test_needs_overlay(parameters) and self.test_needs_deployment(
parameters
):
self.pipeline.add_action(DeployDeviceEnvironment())
self.pipeline.add_action(FastbootFlashOrderAction())
def populate(self, parameters):
super().populate(parameters)
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
recovery = self.job.device["actions"]["deploy"]["methods"]["recovery"]
recovery_dir = self.mkdtemp()
image_keys = sorted(parameters["images"].keys())
for image in image_keys:
self.internal_pipeline.add_action(
DownloaderAction(image, recovery_dir))
self.internal_pipeline.add_action(CopyToLxcAction())
tags = []
if "tags" in recovery:
tags = recovery["tags"]
if "serial" in tags:
# might not be a usable shell here, just power on.
# FIXME: if used, FastbootAction must not try to reconnect
self.internal_pipeline.add_action(ConnectDevice())
def populate(self, parameters):
super().populate(parameters)
self.internal_pipeline = Pipeline(parent=self,
job=self.job,
parameters=parameters)
recovery = self.job.device['actions']['deploy']['methods']['recovery']
recovery_dir = self.mkdtemp()
image_keys = sorted(parameters['images'].keys())
for image in image_keys:
if image != 'yaml_line':
self.internal_pipeline.add_action(
DownloaderAction(image, recovery_dir))
self.internal_pipeline.add_action(CopyToLxcAction())
tags = []
if 'tags' in recovery:
tags = recovery['tags']
if 'serial' in tags:
# might not be a usable shell here, just power on.
# FIXME: if used, FastbootAction must not try to reconnect
self.internal_pipeline.add_action(ConnectDevice())
