def reset_interface(self, iface_mac):
"""
Check interface through guestfish.Fix mac if necessary.
"""
# disk or domain
vm_ref = self.params.get("libvirt_domain")
if not vm_ref:
vm_ref = self.params.get("disk_img")
if not vm_ref:
logging.error("No object to edit.")
return False
logging.info("Resetting %s's mac to %s", vm_ref, iface_mac)
# Fix file which includes interface devices information
# Default is /etc/udev/rules.d/70-persistent-net.rules
devices_file = "/etc/udev/rules.d/70-persistent-net.rules"
# Set file which binds mac and IP-address
ifcfg_files = [
"/etc/sysconfig/network-scripts/ifcfg-p1p1",
"/etc/sysconfig/network-scripts/ifcfg-eth0"
]
# Fix devices file
mac_regex = (r"\w.:\w.:\w.:\w.:\w.:\w.")
edit_expr = "s/%s/%s/g" % (mac_regex, iface_mac)
file_ret = self.is_file(devices_file)
if file_ret.stdout.strip() == "true":
self.close_session()
try:
result = lgf.virt_edit_cmd(vm_ref,
devices_file,
expr=edit_expr,
debug=True,
ignore_status=True)
if result.exit_status:
logging.error("Edit %s failed:%s", devices_file, result)
return False
except lgf.LibguestfsCmdError, detail:
logging.error("Edit %s failed:%s", devices_file, detail)
return False
self.new_session()
# Just to keep output looking better
self.is_ready()
logging.debug(self.cat(devices_file))
def reset_interface(self, iface_mac):
"""
Check interface through guestfish.Fix mac if necessary.
"""
# disk or domain
vm_ref = self.params.get("libvirt_domain")
if not vm_ref:
vm_ref = self.params.get("disk_img")
if not vm_ref:
logging.error("No object to edit.")
return False
logging.info("Resetting %s's mac to %s", vm_ref, iface_mac)
# Fix file which includes interface devices information
# Default is /etc/udev/rules.d/70-persistent-net.rules
devices_file = "/etc/udev/rules.d/70-persistent-net.rules"
# Set file which binds mac and IP-address
ifcfg_files = ["/etc/sysconfig/network-scripts/ifcfg-p1p1",
"/etc/sysconfig/network-scripts/ifcfg-eth0"]
# Fix devices file
mac_regex = (r"\w.:\w.:\w.:\w.:\w.:\w.")
edit_expr = "s/%s/%s/g" % (mac_regex, iface_mac)
file_ret = self.is_file(devices_file)
if file_ret.stdout.strip() == "true":
self.close_session()
try:
result = lgf.virt_edit_cmd(vm_ref, devices_file,
expr=edit_expr, debug=True,
ignore_status=True)
if result.exit_status:
logging.error("Edit %s failed:%s", devices_file, result)
return False
except lgf.LibguestfsCmdError, detail:
logging.error("Edit %s failed:%s", devices_file, detail)
return False
self.new_session()
# Just to keep output looking better
self.is_ready()
logging.debug(self.cat(devices_file))
def run(test, params, env):
"""
Test of virt-edit.
1) Get and init parameters for test.
2) Prepare environment.
3) Run virt-edit command and get result.
5) Recover environment.
6) Check result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
remote_host = params.get("virt_edit_remote_host", "HOST.EXAMPLE")
remote_user = params.get("virt_edit_remote_user", "root")
remote_passwd = params.get("virt_edit_remote_passwd", "PASSWD.EXAMPLE")
connect_uri = params.get("virt_edit_connect_uri")
if connect_uri is not None:
uri = "qemu+ssh://%s@%s/system" % (remote_user, remote_host)
if uri.count("EXAMPLE"):
raise error.TestNAError("Please config host and passwd first.")
# Config ssh autologin for it
ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22)
else:
uri = libvirt_vm.normalize_connect_uri(
params.get("connect_uri", "default"))
start_vm = params.get("start_vm", "no")
vm_ref = params.get("virt_edit_vm_ref", vm_name)
file_ref = params.get("virt_edit_file_ref", "/etc/hosts")
created_img = params.get("virt_edit_created_img", "/tmp/foo.img")
foo_line = params.get("foo_line", "")
options = params.get("virt_edit_options")
options_suffix = params.get("virt_edit_options_suffix")
status_error = params.get("status_error", "no")
backup_extension = params.get("virt_edit_backup_extension")
test_format = params.get("virt_edit_format")
# virt-edit should not be used when vm is running.
# (for normal test)
if vm.is_alive() and start_vm == "no":
vm.destroy(gracefully=True)
dom_disk_dict = vm.get_disk_devices() # TODO
dom_uuid = vm.get_uuid()
# Disk format: raw or qcow2
disk_format = None
# If object is a disk file path
is_disk = False
if vm_ref == "domdisk":
if len(dom_disk_dict) != 1:
raise error.TestError("Only one disk device should exist on "
"%s:\n%s." % (vm_name, dom_disk_dict))
disk_detail = dom_disk_dict.values()[0]
vm_ref = disk_detail['source']
logging.info("disk to be edit:%s", vm_ref)
if test_format:
# Get format:raw or qcow2
info = utils.run("qemu-img info %s" % vm_ref).stdout
for line in info.splitlines():
comps = line.split(':')
if comps[0].count("format"):
disk_format = comps[-1].strip()
break
if disk_format is None:
raise error.TestError("Cannot get disk format:%s" % info)
is_disk = True
elif vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "createdimg":
vm_ref = created_img
utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img)
is_disk = True
# Decide whether pass a exprt for virt-edit command.
if foo_line != "":
expr = "s/$/%s/" % foo_line
else:
expr = ""
if backup_extension is not None:
if options is None:
options = ""
options += " -b %s" % backup_extension
# Stop libvirtd if test need.
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Run test
result = lgf.virt_edit_cmd(vm_ref,
file_ref,
is_disk=is_disk,
disk_format=disk_format,
options=options,
extra=options_suffix,
expr=expr,
connect_uri=uri,
debug=True)
status = result.exit_status
# Recover libvirtd.
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
utils.run("rm -f %s" % created_img)
# Remove backup file in vm if it exists
if backup_extension is not None:
backup_file = file_ref + backup_extension
cleanup_file_in_vm(vm, backup_file)
status_error = (status_error == "yes")
if status != 0:
if not status_error:
raise error.TestFail("Command executed failed.")
else:
if (expr != ""
and (not login_to_check_foo_line(vm, file_ref, foo_line))):
raise error.TestFail("Virt-edit to add %s in %s failed."
"Test failed." % (foo_line, file_ref))
def run_virt_edit(test, params, env):
"""
Test of virt-edit.
1) Get and init parameters for test.
2) Prepare environment.
3) Run virt-edit command and get result.
5) Recover environment.
6) Check result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default"))
start_vm = params.get("start_vm", "no")
vm_ref = params.get("virt_edit_vm_ref", vm_name)
file_ref = params.get("virt_edit_file_ref", "/etc/hosts")
created_img = params.get("virt_edit_created_img", "/tmp/foo.img")
foo_line = params.get("foo_line", "")
options = params.get("virt_edit_options")
options_suffix = params.get("virt_edit_options_suffix")
status_error = params.get("status_error", "no")
# virt-edit should not be used when vm is running.
# (for normal test)
if vm.is_alive() and start_vm == "no":
vm.destroy(gracefully=True)
dom_disk_dict = vm.get_disk_devices() # TODO
dom_uuid = vm.get_uuid()
if vm_ref == "domdisk":
if len(dom_disk_dict) != 1:
raise error.TestError("Only one disk device should exist on "
"%s:\n%s." % (vm_name, dom_disk_dict))
disk_detail = dom_disk_dict.values()[0]
vm_ref = disk_detail['source']
logging.info("disk to be edit:%s", vm_ref)
elif vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "createdimg":
vm_ref = created_img
utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img)
# Decide whether pass a exprt for virt-edit command.
if foo_line != "":
expr = "s/$/%s/" % foo_line
else:
expr = ""
# Stop libvirtd if test need.
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Run test
virsh_dargs = {'ignore_status': True, 'debug': True, 'uri': uri}
result = lgf.virt_edit_cmd(vm_ref, file_ref, options,
options_suffix, expr, **virsh_dargs)
status = result.exit_status
# Recover libvirtd.
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
utils.run("rm -f %s" % created_img)
status_error = (status_error == "yes")
if status != 0:
if not status_error:
raise error.TestFail("Command executed failed.")
else:
if (expr != "" and
(not login_to_check_foo_line(vm, file_ref, foo_line))):
raise error.TestFail("Virt-edit to add %s in %s failed."
"Test failed." % (foo_line, file_ref))
def run(test, params, env):
"""
Test of virt-edit.
1) Get and init parameters for test.
2) Prepare environment.
3) Run virt-edit command and get result.
5) Recover environment.
6) Check result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
remote_host = params.get("virt_edit_remote_host", "HOST.EXAMPLE")
remote_user = params.get("virt_edit_remote_user", "root")
remote_passwd = params.get("virt_edit_remote_passwd", "PASSWD.EXAMPLE")
connect_uri = params.get("virt_edit_connect_uri")
if connect_uri is not None:
uri = "qemu+ssh://%s@%s/system" % (remote_user, remote_host)
if uri.count("EXAMPLE"):
raise error.TestNAError("Please config host and passwd first.")
# Config ssh autologin for it
ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22)
else:
uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
start_vm = params.get("start_vm", "no")
vm_ref = params.get("virt_edit_vm_ref", vm_name)
file_ref = params.get("virt_edit_file_ref", "/etc/hosts")
created_img = params.get("virt_edit_created_img", "/tmp/foo.img")
foo_line = params.get("foo_line", "")
options = params.get("virt_edit_options")
options_suffix = params.get("virt_edit_options_suffix")
status_error = params.get("status_error", "no")
backup_extension = params.get("virt_edit_backup_extension")
test_format = params.get("virt_edit_format")
# virt-edit should not be used when vm is running.
# (for normal test)
if vm.is_alive() and start_vm == "no":
vm.destroy(gracefully=True)
dom_disk_dict = vm.get_disk_devices() # TODO
dom_uuid = vm.get_uuid()
# Disk format: raw or qcow2
disk_format = None
# If object is a disk file path
is_disk = False
if vm_ref == "domdisk":
if len(dom_disk_dict) != 1:
raise error.TestError("Only one disk device should exist on "
"%s:\n%s." % (vm_name, dom_disk_dict))
disk_detail = dom_disk_dict.values()[0]
vm_ref = disk_detail['source']
logging.info("disk to be edit:%s", vm_ref)
if test_format:
# Get format:raw or qcow2
info = utils.run("qemu-img info %s" % vm_ref).stdout
for line in info.splitlines():
comps = line.split(':')
if comps[0].count("format"):
disk_format = comps[-1].strip()
break
if disk_format is None:
raise error.TestError("Cannot get disk format:%s" % info)
options = "--format=%s" % disk_format
is_disk = True
elif vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "createdimg":
vm_ref = created_img
utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img)
is_disk = True
# Decide whether pass a exprt for virt-edit command.
if foo_line != "":
expr = "s/$/%s/" % foo_line
else:
expr = ""
if backup_extension is not None:
if options is None:
options = ""
options += " -b %s" % backup_extension
# Stop libvirtd if test need.
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Run test
result = lgf.virt_edit_cmd(vm_ref, file_ref, is_disk, options,
options_suffix, expr, uri, debug=True)
status = result.exit_status
# Recover libvirtd.
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
utils.run("rm -f %s" % created_img)
# Remove backup file in vm if it exists
if backup_extension is not None:
backup_file = file_ref + backup_extension
cleanup_file_in_vm(vm, backup_file)
status_error = (status_error == "yes")
if status != 0:
if not status_error:
raise error.TestFail("Command executed failed.")
else:
if (expr != "" and
(not login_to_check_foo_line(vm, file_ref, foo_line))):
raise error.TestFail("Virt-edit to add %s in %s failed."
"Test failed." % (foo_line, file_ref))
class GuestfishTools(lgf.GuestfishPersistent):
"""Useful Tools for Guestfish class."""
__slots__ = ('params', )
def __init__(self, params):
"""
Init a persistent guestfish shellsession.
"""
self.params = params
disk_img = params.get("disk_img")
ro_mode = bool(params.get("gf_ro_mode", False))
libvirt_domain = params.get("libvirt_domain")
inspector = bool(params.get("gf_inspector", False))
mount_options = params.get("mount_options")
run_mode = params.get("gf_run_mode", "interactive")
super(GuestfishTools, self).__init__(disk_img, ro_mode,
libvirt_domain, inspector,
mount_options=mount_options,
run_mode=run_mode)
def get_root(self):
"""
Get root filesystem w/ guestfish
"""
getroot_result = self.inspect_os()
roots_list = getroot_result.stdout.splitlines()
if getroot_result.exit_status or not len(roots_list):
logging.error("Get root failed:%s", getroot_result)
return (False, getroot_result)
return (True, roots_list[0].strip())
def analyse_release(self):
"""
Analyse /etc/redhat-release
"""
logging.info("Analysing /etc/redhat-release...")
release_result = self.cat("/etc/redhat-release")
logging.debug(release_result)
if release_result.exit_status:
logging.error("Cat /etc/redhat-release failed")
return (False, release_result)
release_type = {'rhel': "Red Hat Enterprise Linux",
'fedora': "Fedora"}
for key in release_type:
if re.search(release_type[key], release_result.stdout):
return (True, key)
def write_file(self, path, content):
"""
Create a new file to vm with guestfish
"""
logging.info("Creating file %s in vm...", path)
write_result = self.write(path, content)
if write_result.exit_status:
logging.error("Create '%s' with content '%s' failed:%s",
path, content, write_result)
return False
return True
def get_partitions_info(self, device="/dev/sda"):
"""
Get disk partition's information.
"""
list_result = self.part_list(device)
if list_result.exit_status:
logging.error("List partition info failed:%s", list_result)
return (False, list_result)
list_lines = list_result.stdout.splitlines()
# This dict is a struct like this: {key:{a dict}, key:{a dict}}
partitions = {}
# This dict is a struct of normal dict, for temp value of a partition
part_details = {}
index = -1
for line in list_lines:
# Init for a partition
if re.search("\[\d\]\s+=", line):
index = line.split("]")[0].split("[")[-1]
part_details = {}
partitions[index] = part_details
if re.search("part_num", line):
part_num = int(line.split(":")[-1].strip())
part_details['num'] = part_num
elif re.search("part_start", line):
part_start = int(line.split(":")[-1].strip())
part_details['start'] = part_start
elif re.search("part_end", line):
part_end = int(line.split(":")[-1].strip())
part_details['end'] = part_end
elif re.search("part_size", line):
part_size = int(line.split(":")[-1].strip())
part_details['size'] = part_size
if index != -1:
partitions[index] = part_details
logging.info(partitions)
return (True, partitions)
def get_part_size(self, part_num):
status, partitions = self.get_partitions_info()
if status is False:
return None
for partition in partitions.values():
if str(partition.get("num")) == str(part_num):
return partition.get("size")
def create_fs(self):
"""
Create filesystem of disk
Choose lvm or physical partition and create fs on it
"""
image_path = self.params.get("image_path")
self.add_drive(image_path)
self.run()
partition_type = self.params.get("partition_type")
fs_type = self.params.get("fs_type", "ext3")
image_size = self.params.get("image_size", "6G")
with_blocksize = self.params.get("with_blocksize")
blocksize = self.params.get("blocksize")
tarball_path = self.params.get("tarball_path")
if partition_type not in ['lvm', 'physical']:
return (False, "partition_type is incorrect, support [physical,lvm]")
if partition_type == "lvm":
logging.info("create lvm partition...")
pv_name = self.params.get("pv_name", "/dev/sdb")
vg_name = self.params.get("vg_name", "vol_test")
lv_name = self.params.get("lv_name", "vol_file")
mount_point = "/dev/%s/%s" % (vg_name, lv_name)
lv_size = int(image_size.replace('G', '')) * 1000
self.pvcreate(pv_name)
self.vgcreate(vg_name, pv_name)
self.lvcreate(lv_name, vg_name, lv_size)
elif partition_type == "physical":
logging.info("create physical partition...")
pv_name = self.params.get("pv_name", "/dev/sdb")
mount_point = pv_name + "1"
self.part_disk(pv_name, "mbr")
self.part_list(pv_name)
if with_blocksize == "yes" and fs_type != "btrfs":
if blocksize:
self.mkfs_opts(fs_type, mount_point, "blocksize:%s" % (blocksize))
self.vfs_type(mount_point)
else:
logging.error("with_blocksize is set but blocksize not given")
self.umount_all()
self.sync()
return (False, "with_blocksize is set but blocksize not given")
else:
self.mkfs(fs_type, mount_point)
self.vfs_type(mount_point)
if tarball_path:
self.mount_options("noatime", mount_point, '/')
self.tar_in(tarball_path, '/')
self.ll('/')
self.umount_all()
self.sync()
return (True, "create_fs successfully")
def create_msdos_part(self, device, start="1", end="-1"):
"""
Create a msdos partition in given device.
Default partition section is whole disk(1~-1).
And return its part name if part add succeed.
"""
logging.info("Creating a new partition on %s...", device)
init_result = self.part_init(device, "msdos")
if init_result.exit_status:
logging.error("Init disk failed:%s", init_result)
return (False, init_result)
add_result = self.part_add(device, "p", start, end)
if add_result.exit_status:
logging.error("Add a partition failed:%s", add_result)
return (False, add_result)
# Get latest created part num to return
status, partitions = self.get_partitions_info(device)
if status is False:
return (False, partitions)
part_num = -1
for partition in partitions.values():
cur_num = partition.get("num")
if cur_num > part_num:
part_num = cur_num
if part_num == -1:
return (False, partitions)
return (True, part_num)
def create_whole_disk_msdos_part(self, device):
"""
Create only one msdos partition in given device.
And return its part name if part add succeed.
"""
logging.info("Creating one partition of whole %s...", device)
init_result = self.part_init(device, "msdos")
if init_result.exit_status:
logging.error("Init disk failed:%s", init_result)
return (False, init_result)
disk_result = self.part_disk(device, "msdos")
if disk_result.exit_status:
logging.error("Init disk failed:%s", disk_result)
return (False, disk_result)
# Get latest created part num to return
status, partitions = self.get_partitions_info(device)
if status is False:
return (False, partitions)
part_num = -1
for partition in partitions.values():
cur_num = partition.get("num")
if cur_num > part_num:
part_num = cur_num
if part_num == -1:
return (False, partitions)
return (True, part_num)
def get_bootable_part(self, device="/dev/sda"):
status, partitions = self.get_partitions_info(device)
if status is False:
return (False, partitions)
for partition in partitions.values():
num = partition.get("num")
ba_result = self.part_get_bootable(device, num)
if ba_result.stdout.strip() == "true":
return (True, "%s%s" % (device, num))
return (False, partitions)
def get_mbr_id(self, device="/dev/sda"):
status, partitions = self.get_partitions_info(device)
if status is False:
return (False, partitions)
for partition in partitions.values():
num = partition.get("num")
mbr_id_result = self.part_get_mbr_id(device, num)
if mbr_id_result.exit_status == 0:
return (True, mbr_id_result.stdout.strip())
return (False, partitions)
def get_part_type(self, device="/dev/sda"):
part_type_result = self.part_get_parttype(device)
if part_type_result.exit_status:
return (False, part_type_result)
return (True, part_type_result.stdout.strip())
def get_md5(self, path):
"""
Get files md5 value.
"""
logging.info("Computing %s's md5...", path)
md5_result = self.checksum("md5", path)
if md5_result.exit_status:
logging.error("Check %s's md5 failed:%s", path, md5_result)
return (False, md5_result)
return (True, md5_result.stdout.strip())
def reset_interface(self, iface_mac):
"""
Check interface through guestfish.Fix mac if necessary.
"""
# disk or domain
vm_ref = self.params.get("libvirt_domain")
if not vm_ref:
vm_ref = self.params.get("disk_img")
if not vm_ref:
logging.error("No object to edit.")
return False
logging.info("Resetting %s's mac to %s", vm_ref, iface_mac)
# Fix file which includes interface devices information
# Default is /etc/udev/rules.d/70-persistent-net.rules
devices_file = "/etc/udev/rules.d/70-persistent-net.rules"
# Set file which binds mac and IP-address
ifcfg_files = ["/etc/sysconfig/network-scripts/ifcfg-p1p1",
"/etc/sysconfig/network-scripts/ifcfg-eth0"]
# Fix devices file
mac_regex = (r"\w.:\w.:\w.:\w.:\w.:\w.")
edit_expr = "s/%s/%s/g" % (mac_regex, iface_mac)
file_ret = self.is_file(devices_file)
if file_ret.stdout.strip() == "true":
self.close_session()
try:
result = lgf.virt_edit_cmd(vm_ref, devices_file,
expr=edit_expr, debug=True,
ignore_status=True)
if result.exit_status:
logging.error("Edit %s failed:%s", devices_file, result)
return False
except lgf.LibguestfsCmdError, detail:
logging.error("Edit %s failed:%s", devices_file, detail)
return False
self.new_session()
# Just to keep output looking better
self.is_ready()
logging.debug(self.cat(devices_file))
# Fix interface file
for ifcfg_file in ifcfg_files:
file_ret = self.is_file(ifcfg_file)
if file_ret.stdout.strip() == "false":
continue
self.close_session()
self.params['ifcfg_file'] = ifcfg_file
try:
result = lgf.virt_edit_cmd(vm_ref, ifcfg_file,
expr=edit_expr, debug=True,
ignore_status=True)
if result.exit_status:
logging.error("Edit %s failed:%s", ifcfg_file, result)
return False
except lgf.LibguestfsCmdError, detail:
logging.error("Edit %s failed:%s", ifcfg_file, detail)
return False
self.new_session()
# Just to keep output looking better
self.is_ready()
logging.debug(self.cat(ifcfg_file))
def run_virt_edit(test, params, env):
"""
Test of virt-edit.
1) Get and init parameters for test.
2) Prepare environment.
3) Run virt-edit command and get result.
5) Recover environment.
6) Check result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
start_vm = params.get("start_vm", "no")
vm_ref = params.get("virt_edit_vm_ref", vm_name)
file_ref = params.get("virt_edit_file_ref", "/etc/hosts")
created_img = params.get("virt_edit_created_img", "/tmp/foo.img")
foo_line = params.get("foo_line", "")
options = params.get("virt_edit_options")
options_suffix = params.get("virt_edit_options_suffix")
status_error = params.get("status_error", "no")
# virt-edit should not be used when vm is running.
# (for normal test)
if vm.is_alive() and start_vm == "no":
vm.destroy(gracefully=True)
dom_disk_dict = vm.get_disk_devices() # TODO
dom_uuid = vm.get_uuid()
if vm_ref == "domdisk":
if len(dom_disk_dict) != 1:
raise error.TestError("Only one disk device should exist on "
"%s:\n%s." % (vm_name, dom_disk_dict))
disk_detail = dom_disk_dict.values()[0]
vm_ref = disk_detail['source']
logging.info("disk to be edit:%s", vm_ref)
elif vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "createdimg":
vm_ref = created_img
utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img)
# Decide whether pass a exprt for virt-edit command.
if foo_line != "":
expr = "s/$/%s/" % foo_line
else:
expr = ""
# Stop libvirtd if test need.
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
# Run test
virsh_dargs = {'ignore_status': True, 'debug': True, 'uri': uri}
result = lgf.virt_edit_cmd(vm_ref, file_ref, options, options_suffix, expr,
**virsh_dargs)
status = result.exit_status
# Recover libvirtd.
if libvirtd == "off":
libvirt_vm.libvirtd_start()
utils.run("rm -f %s" % created_img)
status_error = (status_error == "yes")
if status != 0:
if not status_error:
raise error.TestFail("Command executed failed.")
else:
if (expr != ""
and (not login_to_check_foo_line(vm, file_ref, foo_line))):
raise error.TestFail("Virt-edit to add %s in %s failed."
"Test failed." % (foo_line, file_ref))
