def check_requisite_startuppolicy_cdrom(vm, params, test):
"""
Check iso cdrom device with startup policy in VM after iso file is renamed
:param vm: one object representing VM
:param params: wrapped parameters in dictionary format
:param test: test assert object
"""
first_iso_path = params.get("virt_disk_device_source")
renamed_first_iso_path = "%s.bak" % first_iso_path
os.rename(first_iso_path, renamed_first_iso_path)
# Save and restore the guest
tmp_save_path = "/tmp/save"
virsh.save(vm.name, tmp_save_path, ignore_status=False)
virsh.restore(tmp_save_path, ignore_status=False)
vm.wait_for_login().close()
# Cdrom should be empty
check_source_in_cdrom_device(vm, None, test)
# Create second iso disk, and update VM with it
if 'tray' in params:
params.pop('tray')
params.update({
"virt_disk_device_source":
params.get("virt_disk_device_source_second")
})
iso_cdrom_disk_second = create_iso_cdrom_disk(params, create_iso=False)
virsh.update_device(vm.name,
iso_cdrom_disk_second.xml,
flagstr="--live",
debug=True)
vm.wait_for_login().close()
def check_iso_cdrom_device_updated(vm, params, test):
"""
Check iso cdrom device in VM can be updated
:param vm: one object representing VM
:param params: wrapped parameters in dictionary format
:param test: test assert object
"""
session = vm.wait_for_login()
eject_cdrom_device_cmd = "eject /dev/sr0"
status = session.cmd_status(eject_cdrom_device_cmd)
if status:
test.fail("Failed to eject cdrom device in VM")
# Save and restore the guest
tmp_save_path = "/tmp/save"
virsh.save(vm.name, tmp_save_path, ignore_status=False)
virsh.restore(tmp_save_path, ignore_status=False)
vm.wait_for_login().close()
device_target = params.get("target_dev")
another_iso_path = params.get("virt_disk_device_source_second")
virsh.change_media(vm.name,
device_target,
another_iso_path,
ignore_status=False)
# Check cdrom has been changed with new iso file
check_source_in_cdrom_device(vm, another_iso_path, test)
def run_restart_save_restore(params, libvirtd, vm):
"""
Save and restore a domain after restart daemon.
"""
libvirtd.restart()
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
virsh.save(vm.name, save_path)
virsh.restore(save_path)
def run_restart_save_restore(params, libvirtd, vm):
"""
Save and restore a domain after restart daemon.
"""
libvirtd.restart()
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
virsh.save(vm.name, save_path)
virsh.restore(save_path)
def test_save_restore_hostdev_device_with_teaming():
logging.info("Save/restore VM.")
save_file = os.path.join(data_dir.get_tmp_dir(), "save_file")
virsh.save(vm_name,
save_file,
debug=True,
ignore_status=False,
timeout=10)
if not libvirt.check_vm_state(vm_name, "shut off"):
test.fail("The guest should be down after executing 'virsh save'.")
virsh.restore(save_file, debug=True, ignore_status=False)
if not libvirt.check_vm_state(vm_name, "running"):
test.fail(
"The guest should be running after executing 'virsh restore'.")
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login()
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
logging.info("Detach the hostdev device.")
hostdev_dev = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name).devices.\
by_device_tag("hostdev")
virsh.detach_device(vm_name,
hostdev_dev.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
check_hostdev = vm_xml.VMXML.new_from_dumpxml(vm_name)\
.devices.by_device_tag('hostdev')
if check_hostdev:
test.fail("The hostdev device exists after detaching %s." %
check_hostdev)
check_vm_network_accessed(vm_session,
2,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=False)
logging.info("Attach the hostdev device.")
virsh.attach_device(vm_name,
hostdev_dev.xml,
debug=True,
ignore_status=False)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def check_disk_save_restore(save_file, device_targets,
startup_policy):
"""
Check domain save and restore operation.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
restore_error = False
# Check disk startup policy option
if "optional" in startup_policy:
os.remove(disks[0]["source"])
restore_error = True
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret, restore_error)
if restore_error:
return
# Connect to the domain and check disk.
try:
session = vm.wait_for_login()
cmd = ("ls /dev/%s && mkfs.ext3 -F /dev/%s && mount /dev/%s"
" /mnt && ls /mnt && touch /mnt/test && umount /mnt"
% (device_targets[0], device_targets[0], device_targets[0]))
status, output = session.cmd_status_output(cmd)
if status:
session.close()
raise exceptions.TestError("Failed to read/write disk in VM:"
" %s" % output)
session.close()
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError), detail:
raise exceptions.TestError(str(detail))
def check_disk_save_restore(save_file, device_targets,
startup_policy):
"""
Check domain save and restore operation.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
restore_error = False
# Check disk startup policy option
if "optional" in startup_policy:
os.remove(disks[0]["source"])
restore_error = True
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret, restore_error)
if restore_error:
return
# Connect to the domain and check disk.
try:
session = vm.wait_for_login()
cmd = ("ls /dev/%s && mkfs.ext3 -F /dev/%s && mount /dev/%s"
" /mnt && ls /mnt && touch /mnt/test && umount /mnt"
% (device_targets[0], device_targets[0], device_targets[0]))
s, o = session.cmd_status_output(cmd)
if s:
session.close()
raise error.TestError("Failed to read/write disk in VM:"
" %s" % o)
session.close()
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError), e:
raise error.TestError(str(e))
def set_condn(action, recover=False):
"""
Set/reset guest state/action
:param action: Guest state change/action
:param recover: whether to recover given state default: False
"""
if not recover:
if action == "pin_vcpu":
for i in range(cur_vcpu):
virsh.vcpupin(vm_name, i, hmi_cpu, "--live",
ignore_status=False, debug=True)
virsh.emulatorpin(vm_name, hmi_cpu, "live",
ignore_status=False, debug=True)
elif action == "filetrans":
utils_test.run_file_transfer(test, params, env)
elif action == "save":
save_file = os.path.join(data_dir.get_tmp_dir(),
vm_name + ".save")
result = virsh.save(vm_name, save_file, ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
time.sleep(10)
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
os.remove(save_file)
elif action == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
time.sleep(10)
result = virsh.resume(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
return
def manipulate_domain(vm_name, action, recover=False):
"""
Save/managedsave/S3/S4 domain or recover it.
"""
tmp_dir = data_dir.get_tmp_dir()
save_file = os.path.join(tmp_dir, vm_name + ".save")
if not recover:
if action == "save":
save_option = ""
result = virsh.save(vm_name,
save_file,
save_option,
ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
elif action == "managedsave":
managedsave_option = ""
result = virsh.managedsave(vm_name,
managedsave_option,
ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
elif action == "s3":
suspend_target = "mem"
result = virsh.dompmsuspend(vm_name,
suspend_target,
ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
elif action == "s4":
suspend_target = "disk"
result = virsh.dompmsuspend(vm_name,
suspend_target,
ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
# Wait domain state change: 'in shutdown' -> 'shut off'
utils_misc.wait_for(lambda: virsh.is_dead(vm_name), 5)
else:
logging.debug("No operation for the domain")
else:
if action == "save":
if os.path.exists(save_file):
result = virsh.restore(save_file,
ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
os.remove(save_file)
else:
raise error.TestError("No save file for domain restore")
elif action in ["managedsave", "s4"]:
result = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif action == "s3":
suspend_target = "mem"
result = virsh.dompmwakeup(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
else:
logging.debug("No need recover the domain")
def check_disk_save_restore(save_file, device_targets):
"""
Check domain save and restore operation.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Connect to the domain and check disk.
try:
session = vm.wait_for_login()
cmd = ("ls /dev/%s && mkfs.ext3 -F /dev/%s && mount /dev/%s"
" /mnt && ls /mnt && touch /mnt/test && umount /mnt" %
(device_targets[0], device_targets[0], device_targets[0]))
s, o = session.cmd_status_output(cmd)
if s:
session.close()
raise error.TestError("Failed to read/write disk in VM:"
" %s" % o)
session.close()
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError), e:
raise error.TestError(str(e))
def save_restore(): # pylint: disable=W0611
"""
Sub test for save and restore
"""
save_path = os.path.join(data_dir.get_tmp_dir(),
'%s.save' % params['os_variant'])
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
def check_save_restore(save_file):
"""
Test domain save and restore.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
def check_save_restore(save_file):
"""
Test domain save and restore.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
def test_with_label(vm, params, test):
"""
Test nvdimm with label setting
:param vm: vm object
:param params: dict, test parameters
:param test: test object
:raises: test.fail if checkpoints fail
"""
test_str = params.get('test_str')
test_file = params.get('test_file')
vm_name = params.get('main_vm')
vm_session = vm.wait_for_login()
# Create a file on the nvdimm device.
create_file_within_nvdimm_disk(vm_session, test_file, test_str, test, block_size=4096)
# Reboot the guest, and remount the nvdimm device in the guest.
# Check the file foo-label is exited
vm_session.close()
virsh.reboot(vm_name, debug=True)
vm_session = vm.wait_for_login()
vm_session.cmd('mount -o dax /dev/pmem0 /mnt')
if test_str not in vm_session.cmd('cat /mnt/foo-label '):
test.fail('"%s" should be in output' % test_str)
vm_session.close()
if params.get('check_life_cycle', 'no') == 'yes':
virsh.managedsave(vm_name, ignore_status=False, debug=True)
vm.start()
vm_session = vm.wait_for_login()
check_nvdimm_file(test_str, test_file, vm_session, test)
vm_session.close()
vm_s1 = vm_name + ".s1"
virsh.save(vm_name, vm_s1, ignore_status=False, debug=True)
virsh.restore(vm_s1, ignore_status=False, debug=True)
vm_session = vm.wait_for_login()
check_nvdimm_file(test_str, test_file, vm_session, test)
vm_session.close()
virsh.snapshot_create_as(vm_name, vm_s1, ignore_status=False, debug=True)
virsh.snapshot_revert(vm_name, vm_s1, ignore_status=False, debug=True)
virsh.snapshot_delete(vm_name, vm_s1, ignore_status=False, debug=True)
def check_bootorder_snapshot(disk_name):
"""
Check VM disk's bootorder option with snapshot.
:param disk_name. The target disk to be checked.
"""
logging.info("Checking diskorder option with snapshot...")
snapshot1 = "s1"
snapshot2 = "s2"
snapshot2_file = os.path.join(test.tmpdir, "s2")
ret = virsh.snapshot_create(vm_name, "", **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.snapshot_create_as(vm_name, "%s --disk-only" % snapshot1,
**virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.snapshot_dumpxml(vm_name, snapshot1)
libvirt.check_exit_status(ret)
cmd = "echo \"%s\" | grep %s.%s" % (ret.stdout, disk_name, snapshot1)
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestError("Check snapshot disk failed")
ret = virsh.snapshot_create_as(vm_name,
"%s --memspec file=%s,snapshot=external"
% (snapshot2, snapshot2_file),
**virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.dumpxml(vm_name)
libvirt.check_exit_status(ret)
cmd = ("echo \"%s\" | grep -A 16 %s.%s | grep \"boot order='%s'\""
% (ret.stdout, disk_name, snapshot2, bootorder))
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestError("Check snapshot disk with bootorder failed")
snap_lists = virsh.snapshot_list(vm_name)
if snapshot1 not in snap_lists or snapshot2 not in snap_lists:
raise error.TestError("Check snapshot list failed")
# Check virsh save command after snapshot.
save_file = "/tmp/%s.save" % vm_name
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Check virsh restore command after snapshot.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
#Passed all test.
os.remove(save_file)
def check_save_restore(vm_name):
"""
Do save/restore operation and check status
"""
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
try:
result = virsh.save(vm_name, save_file, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
result = virsh.restore(save_file, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
finally:
os.remove(save_file)
def test_save_restore_hostdev_iface_with_teaming():
logging.info("Save/restore VM.")
save_file = os.path.join(data_dir.get_tmp_dir(), "save_file")
virsh.save(vm_name,
save_file,
debug=True,
ignore_status=False,
timeout=10)
if not libvirt.check_vm_state(vm_name, "shut off"):
test.fail("The guest should be down after executing 'virsh save'.")
virsh.restore(save_file, debug=True, ignore_status=False)
if not libvirt.check_vm_state(vm_name, "running"):
test.fail(
"The guest should be running after executing 'virsh restore'.")
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login()
check_vm_network_accessed(vm_session,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def check_bootorder_snapshot(disk_name):
"""
Check VM disk's bootorder option with snapshot.
:param disk_name. The target disk to be checked.
"""
logging.info("Checking diskorder option with snapshot...")
snapshot1 = "s1"
snapshot2 = "s2"
snapshot2_file = os.path.join(test.tmpdir, "s2")
ret = virsh.snapshot_create(vm_name, "", **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.snapshot_create_as(vm_name, "%s --disk-only" % snapshot1,
**virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.snapshot_dumpxml(vm_name, snapshot1)
libvirt.check_exit_status(ret)
cmd = "echo \"%s\" | grep %s.%s" % (ret.stdout, disk_name, snapshot1)
if process.system(cmd, ignore_status=True, shell=True):
raise exceptions.TestError("Check snapshot disk failed")
ret = virsh.snapshot_create_as(vm_name,
"%s --memspec file=%s,snapshot=external"
% (snapshot2, snapshot2_file),
**virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.dumpxml(vm_name)
libvirt.check_exit_status(ret)
cmd = ("echo \"%s\" | grep -A 16 %s.%s | grep \"boot order='%s'\""
% (ret.stdout, disk_name, snapshot2, bootorder))
if process.system(cmd, ignore_status=True, shell=True):
raise exceptions.TestError("Check snapshot disk with bootorder failed")
snap_lists = virsh.snapshot_list(vm_name)
if snapshot1 not in snap_lists or snapshot2 not in snap_lists:
raise exceptions.TestError("Check snapshot list failed")
# Check virsh save command after snapshot.
save_file = "/tmp/%s.save" % vm_name
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Check virsh restore command after snapshot.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
#Passed all test.
os.remove(save_file)
def check_save_restore(vm_name):
"""
Do save/restore operation and check status
"""
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
try:
result = virsh.save(vm_name, save_file, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
result = virsh.restore(save_file, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
finally:
os.remove(save_file)
def check_save_restore():
"""
Test save and restore operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(), "%s.save" % vm_name)
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
# Login to check vm status
vm.wait_for_login().close()
def check_disk_save_restore(save_file):
"""
Check domain save and restore operation.
:param save_file: the path to saved file
"""
# Save the domain.
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
def check_save_restore():
"""
Test save and restore operation
"""
save_file = os.path.join(test.tmpdir, "%s.save" % vm_name)
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
# Login to check vm status
vm.wait_for_login().close()
def manipulate_domain(vm_name, action, recover=False):
"""
Save/managedsave/S3/S4 domain or recover it.
"""
tmp_dir = data_dir.get_tmp_dir()
save_file = os.path.join(tmp_dir, vm_name + ".save")
if not recover:
if action == "save":
save_option = ""
result = virsh.save(vm_name, save_file, save_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif action == "managedsave":
managedsave_option = ""
result = virsh.managedsave(vm_name, managedsave_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif action == "s3":
suspend_target = "mem"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif action == "s4":
suspend_target = "disk"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
# Wait domain state change: 'in shutdown' -> 'shut off'
utils_misc.wait_for(lambda: virsh.is_dead(vm_name), 5)
else:
logging.debug("No operation for the domain")
else:
if action == "save":
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
os.remove(save_file)
else:
raise error.TestError("No save file for domain restore")
elif action in ["managedsave", "s4"]:
result = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif action == "s3":
suspend_target = "mem"
result = virsh.dompmwakeup(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
else:
logging.debug("No need recover the domain")
def run_pm_test(params, libvirtd, vm):
"""
Destroy VM after executed a series of operations about S3 and save restore
"""
vm_name = vm.name
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
try:
pm_xml = VMPMXML()
pm_xml.mem_enabled = 'yes'
vm_xml.pm = pm_xml
vm_xml.sync()
vm.prepare_guest_agent()
virsh.dompmsuspend(vm.name, 'mem')
virsh.dompmwakeup(vm.name)
virsh.save(vm.name, save_path)
virsh.restore(save_path)
virsh.dompmsuspend(vm.name, 'mem')
virsh.save(vm.name, save_path)
virsh.destroy(vm.name)
finally:
vm_xml_backup.sync()
def run_pm_test(params, libvirtd, vm):
"""
Destroy VM after executed a series of operations about S3 and save restore
"""
vm_name = vm.name
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
try:
pm_xml = VMPMXML()
pm_xml.mem_enabled = 'yes'
vm_xml.pm = pm_xml
vm_xml.sync()
vm.prepare_guest_agent()
virsh.dompmsuspend(vm.name, 'mem')
virsh.dompmwakeup(vm.name)
virsh.save(vm.name, save_path)
virsh.restore(save_path)
virsh.dompmsuspend(vm.name, 'mem')
virsh.save(vm.name, save_path)
virsh.destroy(vm.name)
finally:
vm_xml_backup.sync()
def snapshot(): # pylint: disable=W0611
"""
Sub test for snapshot
"""
for i in range(1, 4):
ret = virsh.snapshot_create_as(vm_name, "sn%s --disk-only" % i)
libvirt.check_exit_status(ret)
process.system("systemctl restart libvirtd")
save_path = os.path.join(tmp_dir, "test.save")
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
session = vm.wait_for_login()
session.close()
def domain_lifecycle(vmxml, vm, test, virsh_dargs, **kwargs):
"""
Test the lifrcycle of the domain
:params: vmxml: the xml of the vm
:params: vm: vm to wait for login the vm
:params: test: system parameter
:params: virsh_dargs: the debugging status of virsh command
"""
vm_name = kwargs.get("vm_name")
save_file = kwargs.get("save_file")
boot_type = kwargs.get("boot_type")
nvram_file = kwargs.get("nvram_file")
ret = virsh.define(vmxml.xml, **virsh_dargs)
stdout_patt = "Domain .*%s.* defined from %s" % (vm_name, vmxml.xml)
utlv.check_result(ret, expected_match=[stdout_patt])
ret = virsh.start(vm_name, **virsh_dargs)
stdout_patt = "Domain .*%s.* started" % vm_name
utlv.check_result(ret, expected_match=[stdout_patt])
vm.wait_for_login()
ret = virsh.destroy(vm_name, **virsh_dargs)
stdout_patt = "Domain .*%s.* destroyed" % vm_name
utlv.check_result(ret, expected_match=[stdout_patt])
vm.start()
ret = virsh.save(vm_name, save_file, **virsh_dargs)
stdout_patt = "Domain .*%s.* saved to %s" % (vm_name, save_file)
utlv.check_result(ret, expected_match=[stdout_patt])
ret = virsh.restore(save_file, **virsh_dargs)
stdout_patt = "Domain restored from %s" % save_file
utlv.check_result(ret, expected_match=[stdout_patt])
ret = virsh.undefine(vm_name, options="--nvram", **virsh_dargs)
stdout_patt = "Domain .*%s.* has been undefined" % vm_name
utlv.check_result(ret, expected_match=[stdout_patt])
if boot_type == "ovmf":
if os.path.exists(nvram_file):
test.fail("nvram file still exists after vm undefine")
def save_restore_hook():
"""
Do save/restore operation and check the results.
"""
hook_para = "%s %s" % (hook_file, vm_name)
save_file = os.path.join(test.tmpdir,
"%s.save" % vm_name)
disk_src = vm.get_first_disk_devices()['source']
if domainxml_test:
disk_dist = "/tmp/%s.move" % vm_name
shutil.copy(disk_src, disk_dist)
script = (hook_script %
(vm_name, disk_src, disk_dist))
prepare_hook_file(script)
elif basic_test:
prepare_hook_file(hook_script %
(vm_name, hook_log))
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if domainxml_test:
disk_src_save = vm.get_first_disk_devices()['source']
if disk_src != disk_src_save:
raise error.TestFail("Failed to check hooks for"
" save operation")
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
if domainxml_test:
disk_src_restore = vm.get_first_disk_devices()['source']
if disk_dist != disk_src_restore:
raise error.TestFail("Failed to check hooks for"
" restore operation")
vm.destroy()
if os.path.exists(disk_dist):
os.remove(disk_dist)
vmxml_backup.sync()
if basic_test:
hook_str = hook_para + " restore begin -"
if not check_hooks(hook_str):
raise error.TestFail("Failed to check "
"restore hooks.")
def save_restore_hook():
"""
Do save/restore operation and check the results.
"""
hook_para = "%s %s" % (hook_file, vm_name)
save_file = os.path.join(test.tmpdir,
"%s.save" % vm_name)
disk_src = vm.get_first_disk_devices()['source']
if domainxml_test:
disk_dist = "/tmp/%s.move" % vm_name
shutil.copy(disk_src, disk_dist)
script = (hook_script %
(vm_name, disk_src, disk_dist))
prepare_hook_file(script)
elif basic_test:
prepare_hook_file(hook_script %
(vm_name, hook_log))
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if domainxml_test:
disk_src_save = vm.get_first_disk_devices()['source']
if disk_src != disk_src_save:
test.fail("Failed to check hooks for"
" save operation")
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
if domainxml_test:
disk_src_restore = vm.get_first_disk_devices()['source']
if disk_dist != disk_src_restore:
test.fail("Failed to check hooks for"
" restore operation")
vm.destroy()
if os.path.exists(disk_dist):
os.remove(disk_dist)
vmxml_backup.sync()
if basic_test:
hook_str = hook_para + " restore begin -"
if not check_hooks(hook_str):
test.fail("Failed to check "
"restore hooks.")
def _wait_for_restore():
try:
virsh.restore(save_file, debug=True, ignore_status=False)
return True
except Exception as e:
logging.error(e)
def run(test, params, env):
"""
Test virsh {at|de}tach-disk command.
The command can attach new disk/detach disk.
1.Prepare test environment,destroy or suspend a VM.
2.Perform virsh attach/detach-disk operation.
3.Recover test environment.
4.Confirm the test result.
"""
def check_vm_partition(vm, device, os_type, target_name, old_parts):
"""
Check VM disk's partition.
:param vm. VM guest.
:param os_type. VM's operation system type.
:param target_name. Device target type.
:return: True if check successfully.
"""
logging.info("Checking VM partittion...")
if vm.is_dead():
vm.start()
try:
attached = False
if os_type == "linux":
session = vm.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
added_parts = list(set(new_parts).difference(set(old_parts)))
logging.debug("Added parts: %s" % added_parts)
for i in range(len(added_parts)):
if device == "disk":
if target_name.startswith("vd"):
if added_parts[i].startswith("vd"):
attached = True
elif target_name.startswith(
"hd") or target_name.startswith("sd"):
if added_parts[i].startswith("sd"):
attached = True
elif device == "cdrom":
if added_parts[i].startswith("sr"):
attached = True
session.close()
return attached
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def acpiphp_module_modprobe(vm, os_type):
"""
Add acpiphp module if VM's os type is rhle5.*
:param vm. VM guest.
:param os_type. VM's operation system type.
:return: True if operate successfully.
"""
if vm.is_dead():
vm.start()
try:
if os_type == "linux":
session = vm.wait_for_login()
s_rpm, _ = session.cmd_status_output("rpm --version")
# If status is different from 0, this
# guest OS doesn't support the rpm package
# manager
if s_rpm:
session.close()
return True
_, o_vd = session.cmd_status_output(
"rpm -qa | grep redhat-release")
if o_vd.find("5Server") != -1:
s_mod, o_mod = session.cmd_status_output(
"modprobe acpiphp")
del o_mod
if s_mod != 0:
session.close()
return False
session.close()
return True
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def check_shareable(at_with_shareable, test_twice):
"""
check if current libvirt version support shareable option
at_with_shareable: True or False. Whether attach disk with shareable option
test_twice: True or False. Whether perform operations twice
return: True or cancel the test
"""
if at_with_shareable or test_twice:
if libvirt_version.version_compare(3, 9, 0):
return True
else:
test.cancel(
"Current libvirt version doesn't support shareable feature"
)
# Get test command.
test_cmd = params.get("at_dt_disk_test_cmd", "attach-disk")
vm_ref = params.get("at_dt_disk_vm_ref", "name")
at_options = params.get("at_dt_disk_at_options", "")
dt_options = params.get("at_dt_disk_dt_options", "")
at_with_shareable = "yes" == params.get("at_with_shareable", 'no')
pre_vm_state = params.get("at_dt_disk_pre_vm_state", "running")
status_error = "yes" == params.get("status_error", 'no')
no_attach = params.get("at_dt_disk_no_attach", 'no')
os_type = params.get("os_type", "linux")
qemu_file_lock = params.get("qemu_file_lock", "")
if qemu_file_lock:
if utils_misc.compare_qemu_version(2, 9, 0):
logging.info('From qemu-kvm-rhev 2.9.0:'
'QEMU image locking, which should prevent multiple '
'runs of QEMU or qemu-img when a VM is running.')
if test_cmd == "detach-disk" or pre_vm_state == "shut off":
test.cancel('This case is not supported.')
else:
logging.info(
'The expect result is failure as opposed with succeed')
status_error = True
# Disk specific attributes.
device = params.get("at_dt_disk_device", "disk")
device_source_name = params.get("at_dt_disk_device_source", "attach.img")
device_source_format = params.get("at_dt_disk_device_source_format", "raw")
device_target = params.get("at_dt_disk_device_target", "vdd")
device_disk_bus = params.get("at_dt_disk_bus_type", "virtio")
source_path = "yes" == params.get("at_dt_disk_device_source_path", "yes")
create_img = "yes" == params.get("at_dt_disk_create_image", "yes")
test_twice = "yes" == params.get("at_dt_disk_test_twice", "no")
test_type = "yes" == params.get("at_dt_disk_check_type", "no")
test_audit = "yes" == params.get("at_dt_disk_check_audit", "no")
test_block_dev = "yes" == params.get("at_dt_disk_iscsi_device", "no")
test_logcial_dev = "yes" == params.get("at_dt_disk_logical_device", "no")
restart_libvirtd = "yes" == params.get("at_dt_disk_restart_libvirtd", "no")
detach_disk_with_print_xml = "yes" == params.get(
"detach_disk_with_print_xml", "no")
vg_name = params.get("at_dt_disk_vg", "vg_test_0")
lv_name = params.get("at_dt_disk_lv", "lv_test_0")
serial = params.get("at_dt_disk_serial", "")
address = params.get("at_dt_disk_address", "")
address2 = params.get("at_dt_disk_address2", "")
cache_options = params.get("cache_options", "")
time_sleep = params.get("time_sleep", 3)
if check_shareable(at_with_shareable, test_twice):
at_options += " --mode shareable"
if serial:
at_options += (" --serial %s" % serial)
if address2:
at_options_twice = at_options + (" --address %s" % address2)
if address:
at_options += (" --address %s" % address)
if cache_options:
if cache_options.count("directsync"):
if not libvirt_version.version_compare(1, 0, 0):
test.cancel("'directsync' cache option doesn't "
"support in current libvirt version.")
at_options += (" --cache %s" % cache_options)
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Start vm and get all partions in vm.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
old_parts = utils_disk.get_parts_list(session)
session.close()
vm.destroy(gracefully=False)
# Back up xml file.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Create virtual device file.
device_source_path = os.path.join(data_dir.get_tmp_dir(),
device_source_name)
if test_block_dev:
device_source = libvirt.setup_or_cleanup_iscsi(True)
if not device_source:
# We should skip this case
test.cancel("Can not get iscsi device name in host")
if test_logcial_dev:
lv_utils.vg_create(vg_name, device_source)
device_source = libvirt.create_local_disk("lvm",
size="10M",
vgname=vg_name,
lvname=lv_name)
logging.debug("New created volume: %s", lv_name)
else:
if source_path and create_img:
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1G",
disk_format=device_source_format)
else:
device_source = device_source_name
# if we are testing audit, we need to start audit servcie first.
if test_audit:
auditd_service = Factory.create_service("auditd")
if not auditd_service.status():
auditd_service.start()
logging.info("Auditd service status: %s" % auditd_service.status())
# If we are testing cdrom device, we need to detach hdc in VM first.
if device == "cdrom":
if vm.is_alive():
vm.destroy(gracefully=False)
s_detach = virsh.detach_disk(vm_name, device_target, "--config")
if not s_detach:
logging.error("Detach hdc failed before test.")
# If we are testing detach-disk, we need to attach certain device first.
if test_cmd == "detach-disk" and no_attach != "yes":
s_at_options = "--driver qemu --config"
#Since lock feature is introduced in libvirt 3.9.0 afterwards, disk shareable options
#need be set if disk needs be attached multitimes
if check_shareable(at_with_shareable, test_twice):
s_at_options += " --mode shareable"
s_attach = virsh.attach_disk(vm_name,
device_source,
device_target,
s_at_options,
debug=True).exit_status
if s_attach != 0:
logging.error("Attaching device failed before testing detach-disk")
else:
logging.debug(
"Attaching device succeeded before testing detach-disk")
if test_twice:
device_target2 = params.get("at_dt_disk_device_target2",
device_target)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1",
disk_format=device_source_format)
s_attach = virsh.attach_disk(vm_name, device_source,
device_target2,
s_at_options).exit_status
if s_attach != 0:
logging.error("Attaching device failed before testing "
"detach-disk test_twice")
vm.start()
vm.wait_for_login()
# Add acpiphp module before testing if VM's os type is rhle5.*
if not acpiphp_module_modprobe(vm, os_type):
test.error("Add acpiphp module failed before test.")
# Turn VM into certain state.
if pre_vm_state == "paused":
logging.info("Suspending %s..." % vm_name)
if vm.is_alive():
vm.pause()
elif pre_vm_state == "shut off":
logging.info("Shuting down %s..." % vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
# Get disk count before test.
disk_count_before_cmd = vm_xml.VMXML.get_disk_count(vm_name)
# Test.
domid = vm.get_id()
domuuid = vm.get_uuid()
# Confirm how to reference a VM.
if vm_ref == "name":
vm_ref = vm_name
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
else:
vm_ref = ""
if test_cmd == "attach-disk":
status = virsh.attach_disk(vm_ref,
device_source,
device_target,
at_options,
debug=True).exit_status
elif test_cmd == "detach-disk":
# For detach disk with print-xml option, it only print information,and not actual disk detachment.
if detach_disk_with_print_xml and libvirt_version.version_compare(
4, 5, 0):
ret = virsh.detach_disk(vm_ref, device_target, at_options)
libvirt.check_exit_status(ret)
cmd = ("echo \"%s\" | grep -A 16 %s" %
(ret.stdout.strip(), device_source_name))
if process.system(cmd, ignore_status=True, shell=True):
test.error("Check disk with source image name failed")
status = virsh.detach_disk(vm_ref,
device_target,
dt_options,
debug=True).exit_status
if restart_libvirtd:
libvirtd_serv = utils_libvirtd.Libvirtd()
libvirtd_serv.restart()
if test_twice:
device_target2 = params.get("at_dt_disk_device_target2", device_target)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1G",
disk_format=device_source_format)
if test_cmd == "attach-disk":
if address2:
at_options = at_options_twice
status = virsh.attach_disk(vm_ref,
device_source,
device_target2,
at_options,
debug=True).exit_status
elif test_cmd == "detach-disk":
status = virsh.detach_disk(vm_ref,
device_target2,
dt_options,
debug=True).exit_status
# Resume guest after command. On newer libvirt this is fixed as it has
# been a bug. The change in xml file is done after the guest is resumed.
if pre_vm_state == "paused":
vm.resume()
time.sleep(5)
# Check audit log
check_audit_after_cmd = True
if test_audit:
grep_audit = ('grep "%s" /var/log/audit/audit.log' %
test_cmd.split("-")[0])
cmd = (grep_audit + ' | ' +
'grep "%s" | tail -n1 | grep "res=success"' % device_source)
if process.run(cmd, shell=True).exit_status:
logging.error("Audit check failed")
check_audit_after_cmd = False
# Need wait a while for xml to sync
time.sleep(float(time_sleep))
# Check disk count after command.
check_count_after_cmd = True
disk_count_after_cmd = vm_xml.VMXML.get_disk_count(vm_name)
if test_cmd == "attach-disk":
if disk_count_after_cmd == disk_count_before_cmd:
check_count_after_cmd = False
elif test_cmd == "detach-disk":
if disk_count_after_cmd < disk_count_before_cmd:
check_count_after_cmd = False
# Recover VM state.
if pre_vm_state == "shut off":
vm.start()
# Check in VM after command.
check_vm_after_cmd = True
check_vm_after_cmd = check_vm_partition(vm, device, os_type, device_target,
old_parts)
# Check disk type after attach.
check_disk_type = True
if test_type:
if test_block_dev:
check_disk_type = vm_xml.VMXML.check_disk_type(
vm_name, device_source, "block")
else:
check_disk_type = vm_xml.VMXML.check_disk_type(
vm_name, device_source, "file")
# Check disk serial after attach.
check_disk_serial = True
if serial:
disk_serial = vm_xml.VMXML.get_disk_serial(vm_name, device_target)
if serial != disk_serial:
check_disk_serial = False
# Check disk address after attach.
check_disk_address = True
if address:
disk_address = vm_xml.VMXML.get_disk_address(vm_name, device_target)
if address != disk_address:
check_disk_address = False
# Check multifunction address after attach.
check_disk_address2 = True
if address2:
disk_address2 = vm_xml.VMXML.get_disk_address(vm_name, device_target2)
if address2 != disk_address2:
check_disk_address2 = False
# Check disk cache option after attach.
check_cache_after_cmd = True
if cache_options:
disk_cache = vm_xml.VMXML.get_disk_attr(vm_name, device_target,
"driver", "cache")
if cache_options == "default":
if disk_cache is not None:
check_cache_after_cmd = False
elif disk_cache != cache_options:
check_cache_after_cmd = False
# Eject cdrom test
eject_cdrom = "yes" == params.get("at_dt_disk_eject_cdrom", "no")
save_vm = "yes" == params.get("at_dt_disk_save_vm", "no")
save_file = os.path.join(data_dir.get_tmp_dir(), "vm.save")
try:
if eject_cdrom:
eject_params = {
'type_name': "file",
'device_type': "cdrom",
'target_dev': device_target,
'target_bus': device_disk_bus
}
eject_xml = libvirt.create_disk_xml(eject_params)
with open(eject_xml) as eject_file:
logging.debug("Eject CDROM by XML: %s", eject_file.read())
# Run command tiwce to make sure cdrom tray open first #BZ892289
# Open tray
virsh.attach_device(domainarg=vm_name,
filearg=eject_xml,
debug=True)
# Add time sleep between two attach commands.
if time_sleep:
time.sleep(float(time_sleep))
# Eject cdrom
result = virsh.attach_device(domainarg=vm_name,
filearg=eject_xml,
debug=True)
if result.exit_status != 0:
test.fail("Eject CDROM failed")
if vm_xml.VMXML.check_disk_exist(vm_name, device_source):
test.fail("Find %s after do eject" % device_source)
# Save and restore VM
if save_vm:
result = virsh.save(vm_name, save_file, debug=True)
libvirt.check_exit_status(result)
result = virsh.restore(save_file, debug=True)
libvirt.check_exit_status(result)
if vm_xml.VMXML.check_disk_exist(vm_name, device_source):
test.fail("Find %s after do restore" % device_source)
# Destroy VM.
vm.destroy(gracefully=False)
# Check disk count after VM shutdown (with --config).
check_count_after_shutdown = True
inactive_vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disk_count_after_shutdown = len(inactive_vmxml.get_disk_all())
if test_cmd == "attach-disk":
if disk_count_after_shutdown == disk_count_before_cmd:
check_count_after_shutdown = False
elif test_cmd == "detach-disk":
if disk_count_after_shutdown < disk_count_before_cmd:
check_count_after_shutdown = False
finally:
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
logging.debug("Restore the VM XML")
backup_xml.sync()
if os.path.exists(save_file):
os.remove(save_file)
if test_block_dev:
if test_logcial_dev:
libvirt.delete_local_disk("lvm",
vgname=vg_name,
lvname=lv_name)
lv_utils.vg_remove(vg_name)
process.run("pvremove %s" % device_source,
shell=True,
ignore_status=True)
libvirt.setup_or_cleanup_iscsi(False)
else:
libvirt.delete_local_disk("file", device_source)
# Check results.
if status_error:
if not status:
test.fail("virsh %s exit with unexpected value." % test_cmd)
else:
if status:
test.fail("virsh %s failed." % test_cmd)
if test_cmd == "attach-disk":
if at_options.count("config"):
if not check_count_after_shutdown:
test.fail("Cannot see config attached device "
"in xml file after VM shutdown.")
if not check_disk_serial:
test.fail("Serial set failed after attach")
if not check_disk_address:
test.fail("Address set failed after attach")
if not check_disk_address2:
test.fail("Address(multifunction) set failed"
" after attach")
else:
if not check_count_after_cmd:
test.fail("Cannot see device in xml file" " after attach.")
if not check_vm_after_cmd:
test.fail("Cannot see device in VM after" " attach.")
if not check_disk_type:
test.fail("Check disk type failed after" " attach.")
if not check_audit_after_cmd:
test.fail("Audit hotplug failure after attach")
if not check_cache_after_cmd:
test.fail("Check cache failure after attach")
if at_options.count("persistent"):
if not check_count_after_shutdown:
test.fail("Cannot see device attached "
"with persistent after "
"VM shutdown.")
else:
if check_count_after_shutdown:
test.fail("See non-config attached device "
"in xml file after VM shutdown.")
elif test_cmd == "detach-disk":
if dt_options.count("config"):
if check_count_after_shutdown:
test.fail("See config detached device in "
"xml file after VM shutdown.")
else:
if check_count_after_cmd:
test.fail("See device in xml file " "after detach.")
if check_vm_after_cmd:
test.fail("See device in VM after detach.")
if not check_audit_after_cmd:
test.fail("Audit hotunplug failure " "after detach")
if dt_options.count("persistent"):
if check_count_after_shutdown:
test.fail("See device deattached "
"with persistent after "
"VM shutdown.")
else:
if not check_count_after_shutdown:
test.fail("See non-config detached "
"device in xml file after "
"VM shutdown.")
else:
test.error("Unknown command %s." % test_cmd)
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
def check_file_own(file_path, exp_uid, exp_gid):
"""
Check the uid and gid of file_path
:param file_path: The file path
:param exp_uid: The expected uid
:param exp_gid: The expected gid
:raise: test.fail if the uid and gid of file are not expected
"""
fstat_res = os.stat(file_path)
if fstat_res.st_uid != exp_uid or fstat_res.st_gid != exp_gid:
test.fail("The uid.gid {}.{} is not expected, it should be {}.{}.".
format(fstat_res.st_uid, fstat_res.st_gid, exp_uid,
exp_gid))
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
time_before_save = int(params.get('time_before_save', 0))
setup_nfs = "yes" == params.get("setup_nfs", "no")
setup_iscsi = "yes" == params.get("setup_iscsi", "no")
check_log = params.get("check_log")
check_str_not_in_log = params.get("check_str_not_in_log")
qemu_conf_dict = eval(params.get("qemu_conf_dict", "{}"))
vm_ref_uid = None
vm_ref_gid = None
qemu_conf = None
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
try:
if "--xml" in extra_param:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name,
options="--migratable")
backup_xml = vmxml.copy()
# Grant more priveledge on the file in order for un-priveledge user
# to access.
os.chmod(vmxml.xml, stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
if not setup_nfs:
extra_param = "--xml %s" % vmxml.xml
dict_os_attrs = {}
if "hd" in vmxml.os.boots:
dict_os_attrs.update({"boots": ["cdrom"]})
vmxml.set_os_attrs(**dict_os_attrs)
else:
test.cancel("Please add 'hd' in boots for --xml testing")
logging.info("vmxml os is %s after update" %
vmxml.os.xmltreefile)
else:
params["mnt_path_name"] = params.get("nfs_mount_dir")
vm_ref_uid = params["change_file_uid"] = pwd.getpwnam(
"qemu").pw_uid
vm_ref_gid = params["change_file_gid"] = grp.getgrnam(
"qemu").gr_gid
libvirt.set_vm_disk(vm, params)
session = vm.wait_for_login()
# Clear log file
if check_log:
cmd = "> %s" % check_log
process.run(cmd, shell=True, verbose=True)
if qemu_conf_dict:
logging.debug("Update qemu configuration file.")
qemu_conf = libvirt.customize_libvirt_config(
qemu_conf_dict, "qemu")
process.run("cat /etc/libvirt/qemu.conf", shell=True, verbose=True)
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref,
extra_param,
debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
test.fail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(data_dir.get_tmp_dir(), "save.file")
if setup_iscsi:
tmp_file = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size='1G')
time.sleep(time_before_save)
ret = virsh.save(vm_name, tmp_file, debug=True)
libvirt.check_exit_status(ret)
if vm_ref == "saved_file" or setup_iscsi:
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(data_dir.get_tmp_dir(), "new.file")
with open(tmp_file, 'w') as tmp:
pass
vm_ref = tmp_file
# Change the ownership of the saved file
if vm_ref_uid and vm_ref_gid:
os.chown(vm_ref, vm_ref_uid, vm_ref_gid)
tmpdir = data_dir.get_tmp_dir()
dump_xml = os.path.join(tmpdir, "test.xml")
virsh.save_image_dumpxml(vm_ref, "> %s" % dump_xml)
extra_param = "--xml %s" % dump_xml
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref,
extra_param,
debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(
5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("Run successfully with wrong command!")
else:
if status:
test.fail("Run failed with right command")
if not re.search(vm_name, list_output):
test.fail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
if (extra_param.count("running") or extra_param.count("xml")
or not extra_param):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be" " running after restore")
if extra_param.count("xml"):
if not setup_nfs:
aft_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
boots_list = aft_vmxml.os.boots
if "hd" in boots_list or "cdrom" not in boots_list:
test.fail("Update xml with restore failed")
else:
if vm_ref_uid and vm_ref_gid:
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
vm.destroy()
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
if check_str_not_in_log and check_log:
libvirt.check_logfile(check_str_not_in_log, check_log, False)
finally:
if vm.is_paused():
virsh.resume(vm_name)
if "--xml" in extra_param:
backup_xml.sync()
if setup_nfs:
libvirt.setup_or_cleanup_nfs(is_setup=False,
mount_dir=params.get("mnt_path_name"),
export_dir=params.get("export_dir"),
rm_export_dir=False)
if setup_iscsi:
libvirt.setup_or_cleanup_iscsi(False)
rename_file()
result = virsh.start(vm_name, **virsh_dargs)
libvirt.check_exit_status(result, expect_error=start_error)
if not start_error:
check_disk_source(vm_name, target_dev, expect_value)
# Step 3. Move back the source file and start the domain(if needed)
rename_file(revert=True)
if not vm.is_alive():
vm.start()
# Step 4. Save the domain normally, then remove the source file
# and restore it back
vm.save_to_file(save_file)
rename_file()
result = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(result, expect_error=restore_error)
if not restore_error:
check_disk_source(vm_name, target_dev, expect_value)
# Step 5. Move back the source file and restore the domain(if needed)
rename_file(revert=True)
if not vm.is_alive():
result = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(result, expect_error=False)
finally:
vmxml_backup.sync()
if os.path.exists(save_file):
os.remove(save_file)
if os.path.exists(disk_xml_file):
os.remove(disk_xml_file)
def run(test, params, env):
"""
Attach/Detach an iscsi network/volume disk to domain
1. For secret usage testing:
1.1. Setup an iscsi target with CHAP authentication.
1.2. Define a secret for iscsi target usage
1.3. Set secret value
2. Create
4. Create an iscsi network disk XML
5. Attach disk with the XML file and check the disk inside the VM
6. Detach the disk
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
disk_device = params.get("disk_device", "disk")
disk_type = params.get("disk_type", "network")
disk_src_protocol = params.get("disk_source_protocol", "iscsi")
disk_src_host = params.get("disk_source_host", "127.0.0.1")
disk_src_port = params.get("disk_source_port", "3260")
disk_src_pool = params.get("disk_source_pool")
disk_src_mode = params.get("disk_source_mode", "host")
pool_type = params.get("pool_type", "iscsi")
pool_src_host = params.get("pool_source_host", "127.0.0.1")
disk_target = params.get("disk_target", "vdb")
disk_target_bus = params.get("disk_target_bus", "virtio")
disk_readonly = params.get("disk_readonly", "no")
chap_auth = "yes" == params.get("chap_auth", "no")
chap_user = params.get("chap_username", "")
chap_passwd = params.get("chap_password", "")
secret_usage_target = params.get("secret_usage_target")
secret_ephemeral = params.get("secret_ephemeral", "no")
secret_private = params.get("secret_private", "yes")
status_error = "yes" == params.get("status_error", "no")
# Indicate the PPC platform
on_ppc = False
if platform.platform().count('ppc64'):
on_ppc = True
if disk_src_protocol == 'iscsi':
if not libvirt_version.version_compare(1, 0, 4):
raise error.TestNAError("'iscsi' disk doesn't support in"
" current libvirt version.")
if disk_type == "volume":
if not libvirt_version.version_compare(1, 0, 5):
raise error.TestNAError("'volume' type disk doesn't support in"
" current libvirt version.")
# Back VM XML
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
try:
if chap_auth:
# Create a secret xml to define it
secret_xml = SecretXML(secret_ephemeral, secret_private)
secret_xml.auth_type = "chap"
secret_xml.auth_username = chap_user
secret_xml.usage = disk_src_protocol
secret_xml.target = secret_usage_target
logging.debug("Define secret by XML: %s",
open(secret_xml.xml).read())
# Define secret
cmd_result = virsh.secret_define(secret_xml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Get secret uuid
try:
secret_uuid = cmd_result.stdout.strip().split()[1]
except IndexError:
raise error.TestError("Fail to get new created secret uuid")
# Set secret value
secret_string = base64.b64encode(chap_passwd)
cmd_result = virsh.secret_set_value(secret_uuid, secret_string,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
else:
# Set chap_user and chap_passwd to empty to avoid setup
# CHAP authentication when export iscsi target
chap_user = ""
chap_passwd = ""
# Setup iscsi target
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(
is_setup=True,
is_login=False,
image_size='1G',
chap_user=chap_user,
chap_passwd=chap_passwd,
portal_ip=disk_src_host)
# Create iscsi pool
if disk_type == "volume":
# Create an iscsi pool xml to create it
pool_src_xml = pool_xml.SourceXML()
pool_src_xml.host_name = pool_src_host
pool_src_xml.device_path = iscsi_target
poolxml = pool_xml.PoolXML(pool_type=pool_type)
poolxml.name = disk_src_pool
poolxml.set_source(pool_src_xml)
poolxml.target_path = "/dev/disk/by-path"
# Create iscsi pool
cmd_result = virsh.pool_create(poolxml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
def get_vol():
"""Get the volume info"""
# Refresh the pool
cmd_result = virsh.pool_refresh(disk_src_pool)
libvirt.check_exit_status(cmd_result)
# Get volume name
cmd_result = virsh.vol_list(disk_src_pool, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
vol_list = []
vol_list = re.findall(r"(\S+)\ +(\S+)[\ +\n]",
str(cmd_result.stdout))
if len(vol_list) > 1:
return vol_list[1]
else:
return None
# Wait for a while so that we can get the volume info
vol_info = utils_misc.wait_for(get_vol, 10)
if vol_info:
vol_name, vol_path = vol_info
else:
raise error.TestError("Failed to get volume info")
# Snapshot doesn't support raw disk format, create a qcow2 volume
# disk for snapshot operation.
process.run('qemu-img create -f qcow2 %s %s' % (vol_path, '100M'),
shell=True)
# Create iscsi network disk XML
disk_params = {
'device_type': disk_device,
'type_name': disk_type,
'target_dev': disk_target,
'target_bus': disk_target_bus,
'readonly': disk_readonly
}
disk_params_src = {}
if disk_type == "network":
disk_params_src = {
'source_protocol': disk_src_protocol,
'source_name': iscsi_target + "/%s" % lun_num,
'source_host_name': disk_src_host,
'source_host_port': disk_src_port
}
elif disk_type == "volume":
disk_params_src = {
'source_pool': disk_src_pool,
'source_volume': vol_name,
'driver_type': 'qcow2',
'source_mode': disk_src_mode
}
else:
error.TestNAError("Unsupport disk type in this test")
disk_params.update(disk_params_src)
if chap_auth:
disk_params_auth = {
'auth_user': chap_user,
'secret_type': disk_src_protocol,
'secret_usage': secret_xml.target
}
disk_params.update(disk_params_auth)
disk_xml = libvirt.create_disk_xml(disk_params)
start_vm = "yes" == params.get("start_vm", "yes")
if start_vm:
if vm.is_dead():
vm.start()
vm.wait_for_login()
else:
if not vm.is_dead():
vm.destroy()
attach_option = params.get("attach_option", "")
disk_xml_f = open(disk_xml)
disk_xml_content = disk_xml_f.read()
disk_xml_f.close()
logging.debug("Attach disk by XML: %s", disk_xml_content)
cmd_result = virsh.attach_device(domainarg=vm_name,
filearg=disk_xml,
flagstr=attach_option,
dargs=virsh_dargs)
libvirt.check_exit_status(cmd_result, status_error)
if vm.is_dead():
cmd_result = virsh.start(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Wait for domain is stable
vm.wait_for_login().close()
domain_operation = params.get("domain_operation", "")
if domain_operation == "save":
save_file = os.path.join(test.tmpdir, "vm.save")
cmd_result = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.restore(save_file)
libvirt.check_exit_status(cmd_result)
if os.path.exists(save_file):
os.remove(save_file)
elif domain_operation == "snapshot":
# Run snapshot related commands: snapshot-create-as, snapshot-list
# snapshot-info, snapshot-dumpxml, snapshot-create
snapshot_name1 = "snap1"
snapshot_name2 = "snap2"
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
virsh.snapshot_list(vm_name, **virsh_dargs)
except process.CmdError:
error.TestFail("Failed getting snapshots list for %s" %
vm_name)
try:
virsh.snapshot_info(vm_name, snapshot_name1, **virsh_dargs)
except process.CmdError:
error.TestFail("Failed getting snapshots info for %s" %
vm_name)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_create(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_current(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
snapshot_file = os.path.join(test.tmpdir, snapshot_name2)
sn_create_op = ("%s --disk-only --diskspec %s,file=%s" %
(snapshot_name2, disk_target, snapshot_file))
cmd_result = virsh.snapshot_create_as(vm_name, sn_create_op,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_revert(vm_name, snapshot_name1,
**virsh_dargs)
cmd_result = virsh.snapshot_list(vm_name, **virsh_dargs)
if snapshot_name2 not in cmd_result:
raise error.TestError("Snapshot %s not found" % snapshot_name2)
else:
logging.error("Unsupport operation %s in this case, so skip it",
domain_operation)
def find_attach_disk(expect=True):
"""
Find attached disk inside the VM
"""
found_disk = False
if vm.is_dead():
raise error.TestError("Domain %s is not running" % vm_name)
else:
try:
session = vm.wait_for_login()
# Here the script needs wait for a while for the guest to
# recognize the hotplugged disk on PPC
if on_ppc:
time.sleep(10)
cmd = "grep %s /proc/partitions" % disk_target
s, o = session.cmd_status_output(cmd)
logging.info("%s output: %s", cmd, o)
session.close()
if s == 0:
found_disk = True
except (LoginError, VMError, ShellError), e:
logging.error(str(e))
if found_disk == expect:
logging.debug("Check disk inside the VM PASS as expected")
else:
raise error.TestError("Check disk inside the VM FAIL")
# Check disk inside the VM, expect is False if status_error=True
find_attach_disk(not status_error)
# Detach disk
cmd_result = virsh.detach_disk(vm_name, disk_target)
libvirt.check_exit_status(cmd_result, status_error)
# Check disk inside the VM
find_attach_disk(False)
def run_virsh_save(test, params, env):
"""
Test command: virsh save.
The command can save the RAM state of a running domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh save command with assigned options.
4.Recover test environment.(If the libvirtd service is stopped ,start
the libvirtd service.)
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
domid = virsh.domid(vm_name).strip()
domuuid = virsh.domuuid(vm_name).strip()
savefile = params.get("save_file")
pre_vm_state = params.get("save_pre_vm_state", "null")
libvirtd = params.get("save_libvirtd")
extra_param = params.get("save_extra_param")
vm_ref = params.get("save_vm_ref")
# prepare the environment
if vm_ref == "name" and pre_vm_state == "paused":
virsh.suspend(vm_name)
elif vm_ref == "name" and pre_vm_state == "shut off":
virsh.destroy(vm_name)
# set the option
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "save_invalid_id" or vm_ref == "save_invalid_uuid":
vm_ref = params.get(vm_ref)
elif vm_ref.find("name") != -1 or vm_ref == "extra_param":
savefile = "%s %s" % (savefile, extra_param)
if vm_ref == "only_name":
savefile = " "
vm_ref = vm_name
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
status = virsh.save(vm_ref, savefile, ignore_status=True).exit_status
# recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
# cleanup
if os.path.exists(savefile):
virsh.restore(savefile)
os.remove(savefile)
# check status_error
status_error = params.get("save_status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
def run_virsh_domjobinfo(test, params, env):
"""
Test command: virsh domjobinfo.
The command returns information about jobs running on a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domjobinfo operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
pre_vm_state = params.get("domjobinfo_pre_vm_state", "null")
vm_ref = params.get("domjobinfo_vm_ref")
status_error = params.get("status_error", "no")
libvirtd = params.get("libvirtd", "on")
tmp_file = os.path.join(test.tmpdir, '%s.tmp' % vm_name )
#prepare the state of vm
if pre_vm_state == "dump":
virsh.dump(vm_name, tmp_file)
elif pre_vm_state == "save":
virsh.save(vm_name, tmp_file)
elif pre_vm_state == "restore":
virsh.save(vm_name, tmp_file)
virsh.restore(tmp_file)
elif pre_vm_state == "managedsave":
virsh.managedsave(vm_name)
#run test case
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "name":
vm_ref = "%s %s" % (vm_name, params.get("domjobinfo_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.domjobinfo(vm_ref, ignore_status=True).exit_status
#recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
def trigger_events(dom, events_list=[]):
"""
Trigger various events in events_list
:param dom: the vm objects corresponding to the domain
:return: the expected output that virsh event command prints out
"""
expected_events_list = []
tmpdir = data_dir.get_tmp_dir()
save_path = os.path.join(tmpdir, "%s_event.save" % dom.name)
new_disk = os.path.join(tmpdir, "%s_new_disk.img" % dom.name)
print dom.name
try:
for event in events_list:
if event in ['start', 'restore']:
if dom.is_alive():
dom.destroy()
else:
if not dom.is_alive():
dom.start()
dom.wait_for_login().close()
if event == "start":
virsh.start(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Started Booted")
dom.wait_for_login().close()
elif event == "save":
virsh.save(dom.name, save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Saved")
elif event == "restore":
if not os.path.exists(save_path):
logging.error("%s not exist", save_path)
else:
virsh.restore(save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Started Restored")
elif event == "destroy":
virsh.destroy(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Destroyed")
elif event == "reset":
virsh.reset(dom.name, **virsh_dargs)
expected_events_list.append("'reboot' for %s")
elif event == "vcpupin":
virsh.vcpupin(dom.name, '0', '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.vcpupin0: 0")
elif event == "emulatorpin":
virsh.emulatorpin(dom.name, '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.emulatorpin: 0")
elif event == "setmem":
mem_size = int(params.get("mem_size", 512000))
virsh.setmem(dom.name, mem_size, **virsh_dargs)
expected_events_list.append("'balloon-change' for %s:")
elif event == "detach-disk":
if not os.path.exists(new_disk):
open(new_disk, 'a').close()
# Attach disk firstly, this event will not be catched
virsh.attach_disk(dom.name, new_disk, 'vdb', **virsh_dargs)
virsh.detach_disk(dom.name, 'vdb', **virsh_dargs)
expected_events_list.append("'device-removed' for %s:"
" virtio-disk1")
else:
raise error.TestError("Unsupported event: %s" % event)
# Event may not received immediately
time.sleep(3)
finally:
if os.path.exists(save_path):
os.unlink(save_path)
if os.path.exists(new_disk):
os.unlink(new_disk)
return [(dom.name, event) for event in expected_events_list]
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
raise error.TestFail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(test.tmpdir, "save.file")
virsh.save(vm_name, tmp_file)
if vm_ref == "saved_file":
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(test.tmpdir, "new.file")
open(tmp_file, 'w').close()
vm_ref = tmp_file
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
try:
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status:
raise error.TestFail("Run failed with right command")
if not re.search(vm_name, list_output):
raise error.TestFail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
raise error.TestFail("Guest state should be"
" paused after restore"
" due to the option --paused")
if extra_param.count("running"):
if vm.is_dead() or vm.is_paused():
raise error.TestFail("Guest state should be"
" running after restore"
" due to the option --running")
finally:
if vm.is_paused():
virsh.resume(vm_name)
def run(test, params, env):
"""
Test mtu feature from virtual network
"""
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
mtu_type = params.get('mtu_type')
mtu_size = params.get('mtu_size', '')
net = params.get('net', DEFAULT_NET)
net_type = params.get('net_type', '')
with_iface = 'yes' == params.get('with_iface', 'no')
with_net = 'yes' == params.get('with_net', 'no')
status_error = 'yes' == params.get('status_error', 'no')
check = params.get('check', '')
error_msg = params.get('error_msg', '')
bridge_name = 'br_mtu' + utils_misc.generate_random_string(3)
add_pkg = params.get('add_pkg', '')
model = params.get('model', 'virtio')
def set_network(size, net='default'):
"""
Set mtu size to a certain network
"""
logging.info('Set mtu size of network "%s" to %s', net, size)
default_xml = NetworkXML.new_from_net_dumpxml(net)
default_xml.mtu = size
default_xml.sync()
logging.debug(virsh.net_dumpxml(net))
def set_interface(mtu_size='', source_network='default',
iface_type='network', iface_model='virtio'):
"""
Set mtu size to a certain interface
"""
interface_type = 'bridge' if iface_type in ('bridge', 'openvswitch') else iface_type
iface_dict = {
'type': interface_type,
'source': "{'%s': '%s'}" % (interface_type, source_network),
'model': iface_model
}
if iface_type == 'openvswitch':
iface_dict.update({'virtualport_type': 'openvswitch'})
if mtu_size:
iface_dict.update({'mtu': "{'size': %s}" % mtu_size})
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_name).stdout)
def get_default_if():
"""
Get default interface that is using by vm
"""
ifaces = utils_net.get_sorted_net_if()
logging.debug('Interfaces on host: %s', ifaces)
for iface in ifaces[0]:
if 'Link detected: yes' in process.run('ethtool %s' % iface).stdout_text:
logging.debug('Found host interface "%s"', iface)
return iface
def create_bridge():
"""
Create a bridge on host for test
"""
cmd_create_br = 'nmcli con add type bridge con-name %s ifname %s'
con_name = 'con_' + utils_misc.generate_random_string(3)
bridge_name = 'br_' + utils_misc.generate_random_string(3)
process.run(cmd_create_br % (con_name, bridge_name), verbose=True)
return con_name, bridge_name
def create_network_xml(name, network_type, base_if='', **kwargs):
"""
Create a network xml to be defined
"""
m_net = NetworkXML(name)
m_net.forward = {'mode': 'bridge'}
if network_type in ('bridge', 'openvswitch'):
m_net.bridge = {'name': kwargs['bridge_name']}
elif network_type == 'macvtap':
if base_if:
m_net.forward_interface = [{'dev': base_if}]
if network_type == 'openvswitch':
m_net.virtualport_type = 'openvswitch'
if 'mtu' in kwargs:
m_net.mtu = kwargs['mtu']
logging.debug(m_net)
return m_net.xml
def create_iface(iface_type, **kwargs):
"""
Create a interface to be attached to vm
"""
m_iface = Interface(iface_type)
m_iface.mac_address = utils_net.generate_mac_address_simple()
if 'base_if' in kwargs:
m_iface.source = {'dev': kwargs['base_if'],
'mode': 'vepa'}
if 'source_net' in kwargs:
m_iface.source = {'network': kwargs['source_net']}
if 'mtu' in kwargs:
m_iface.mtu = {'size': kwargs['mtu']}
if 'model_net' in kwargs:
m_iface.model = kwargs['model_net']
logging.debug(m_iface.get_xml())
logging.debug(m_iface)
return m_iface
def check_mtu(mtu_size, qemu=False):
"""
Check if mtu meets expectation on host
"""
error = ''
live_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_xml = live_vmxml.get_devices('interface')[0]
logging.debug(iface_xml.target)
dev = iface_xml.target['dev']
ifconfig_info = process.run('ifconfig|grep mtu|grep %s' % dev,
shell=True, verbose=True).stdout_text
if 'mtu %s' % mtu_size in ifconfig_info:
logging.info('PASS on ifconfig check for vnet.')
else:
error += 'Fail on ifconfig check for vnet.'
if qemu:
qemu_mtu_info = process.run('ps aux|grep qemu-kvm',
shell=True, verbose=True).stdout_text
if 'host_mtu=%s' % mtu_size in qemu_mtu_info:
logging.info('PASS on qemu cmd line check.')
else:
error += 'Fail on qemu cmd line check.'
if error:
test.fail(error)
def check_mtu_in_vm(fn_login, mtu_size):
"""
Check if mtu meets expectations in vm
"""
session = fn_login()
check_cmd = 'ifconfig'
output = session.cmd(check_cmd)
session.close()
logging.debug(output)
if 'mtu %s' % mtu_size not in output:
test.fail('MTU check inside vm failed.')
else:
logging.debug("MTU check inside vm passed.")
try:
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
bk_netxml = NetworkXML.new_from_net_dumpxml(DEFAULT_NET)
if add_pkg:
add_pkg = add_pkg.split()
utils_package.package_install(add_pkg)
if 'openvswitch' in add_pkg:
br = 'ovsbr0' + utils_misc.generate_random_string(3)
process.run('systemctl start openvswitch.service', shell=True, verbose=True)
process.run('ovs-vsctl add-br %s' % br, shell=True, verbose=True)
process.run('ovs-vsctl show', shell=True, verbose=True)
if not check or check in ['save', 'managedsave', 'hotplug_save']:
# Create bridge or network and set mtu
iface_type = 'network'
if net_type in ('bridge', 'openvswitch'):
if net_type == 'bridge':
params['con_name'], br = create_bridge()
if mtu_type == 'network':
test_net = create_network_xml(
bridge_name, net_type,
bridge_name=br
)
virsh.net_create(test_net, debug=True)
virsh.net_dumpxml(bridge_name, debug=True)
if mtu_type == 'interface':
iface_type = net_type
bridge_name = br
elif net_type == 'network':
if mtu_type == 'network':
set_network(mtu_size)
iface_mtu = 0
if mtu_type == 'interface':
iface_mtu = mtu_size
if mtu_type == 'network' and with_iface:
mtu_size = str(int(mtu_size)//2)
iface_mtu = mtu_size
source_net = bridge_name if net_type in ('bridge', 'openvswitch') else 'default'
# set mtu in vm interface
set_interface(iface_mtu, source_network=source_net, iface_type=iface_type, iface_model=model)
vm.start()
vm_login = vm.wait_for_serial_login if net_type in ('bridge', 'openvswitch') else vm.wait_for_login
vm_login().close()
check_qemu = True if mtu_type == 'interface' else False
# Test mtu after save vm
if check in ('save', 'hotplug_save'):
if check == 'hotplug_save':
iface = create_iface('network', source_net='default',
mtu=mtu_size, model_net=model)
params['mac'] = iface.mac_address
virsh.attach_device(vm_name, iface.xml, debug=True)
virsh.dumpxml(vm_name, debug=True)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] not in str(dom_xml):
test.fail('Failed to attach interface with mtu')
save_path = os.path.join(data_dir.get_tmp_dir(), vm_name + '.save')
virsh.save(vm_name, save_path, debug=True)
virsh.restore(save_path, debug=True)
if check == 'managedsave':
virsh.managedsave(vm_name, debug=True)
virsh.start(vm_name, debug=True)
# Check in both host and vm
check_mtu(mtu_size, check_qemu)
check_mtu_in_vm(vm_login, mtu_size)
vm_login(timeout=60).close()
if check == 'hotplug_save':
virsh.detach_interface(vm_name, 'network %s' % params['mac'], debug=True)
time.sleep(5)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] in str(dom_xml):
test.fail('Failed to detach interface with mtu after save-restore')
else:
hotplug = 'yes' == params.get('hotplug', 'False')
if check == 'net_update':
result = virsh.net_update(
DEFAULT_NET, 'modify', 'mtu',
'''"<mtu size='%s'/>"''' % mtu_size,
debug=True
)
if check in ('macvtap', 'bridge_net', 'ovswitch_net'):
base_if = get_default_if()
macv_name = 'direct-macvtap' + utils_misc.generate_random_string(3)
# Test mtu in different type of network
if mtu_type == 'network':
if check == 'macvtap':
test_net = create_network_xml(macv_name, 'macvtap',
base_if, mtu=mtu_size)
if check == 'bridge_net':
params['con_name'], br = create_bridge()
test_net = create_network_xml(
bridge_name, 'bridge', mtu=mtu_size,
bridge_name=br
)
if check == 'ovswitch_net':
test_net = create_network_xml(
bridge_name, 'openvswitch', mtu=mtu_size,
bridge_name=br
)
if 'net_create' in params['id']:
result = virsh.net_create(test_net, debug=True)
if 'net_define' in params['id']:
result = virsh.net_define(test_net, debug=True)
# Test mtu with or without a binding network
elif mtu_type == 'interface':
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_net:
test_net = create_network_xml(macv_name, 'macvtap', base_if)
virsh.net_create(test_net, debug=True)
iface = create_iface('network', source_net=macv_name, mtu=mtu_size)
if hotplug:
result = virsh.attach_device(vm_name, iface.xml, debug=True)
else:
vmxml.add_device(iface)
vmxml.sync()
result = virsh.start(vm_name)
else:
iface = create_iface('direct', base_if=base_if, mtu=mtu_size)
if hotplug:
result = virsh.attach_device(vm_name, iface.xml, debug=True)
else:
vmxml.add_device(iface)
result = virsh.define(vmxml.xml, debug=True)
if check == 'invalid_val':
iface = create_iface('network', source_net='default', mtu=mtu_size)
result = virsh.attach_device(vm_name, iface.xml, debug=True)
# Check result
libvirt.check_exit_status(result, status_error)
libvirt.check_result(result, [error_msg])
finally:
bk_xml.sync()
bk_netxml.sync()
if 'test_net' in locals():
virsh.net_destroy(bridge_name, debug=True)
if params.get('con_name'):
process.run('nmcli con del %s' % params['con_name'], verbose=True)
if add_pkg:
process.run("ovs-vsctl del-br %s" % br, verbose=True)
utils_package.package_remove(add_pkg)
def manipulate_domain(vm_name, vm_operation, recover=False):
"""
Operate domain to given state or recover it.
:params vm_name: Name of the VM domain
:params vm_operation: Operation to be performed on VM domain
like save, managedsave, suspend
:params recover: flag to inform whether to set or reset
vm_operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
if not recover:
if vm_operation == "save":
save_option = ""
result = virsh.save(vm_name, save_file, save_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "managedsave":
managedsave_option = ""
result = virsh.managedsave(vm_name, managedsave_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s3":
suspend_target = "mem"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s4":
suspend_target = "disk"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
# Wait domain state change: 'in shutdown' -> 'shut off'
utils_misc.wait_for(lambda: virsh.is_dead(vm_name), 5)
elif vm_operation == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "reboot":
vm.reboot()
vm_uptime_init = vm.uptime()
else:
logging.debug("No operation for the domain")
else:
if vm_operation == "save":
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
os.remove(save_file)
else:
test.error("No save file for domain restore")
elif vm_operation in ["managedsave", "s4"]:
result = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s3":
suspend_target = "mem"
result = virsh.dompmwakeup(vm_name, ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "suspend":
result = virsh.resume(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "reboot":
pass
else:
logging.debug("No need recover the domain")
def manipulate_vm(vm, operation, params=None):
"""
Manipulate the VM.
:param vm: VM instance
:param operation: stress_in_vms, inject_nmi, dump, suspend_resume
or save_restore
:param params: Test parameters
"""
err_msg = ''
# Special operations for test
if operation == "stress":
logging.debug("Load stress in VM")
err_msg = utils_test.load_stress(operation, params=params, vms=[vm])[0]
elif operation == "inject_nmi":
inject_times = int(params.get("inject_times", 10))
logging.info("Trying to inject nmi %s times", inject_times)
while inject_times > 0:
try:
inject_times -= 1
virsh.inject_nmi(vm.name, debug=True, ignore_status=False)
except process.CmdError as detail:
err_msg = "Inject nmi failed: %s" % detail
elif operation == "dump":
dump_times = int(params.get("dump_times", 10))
logging.info("Trying to dump vm %s times", dump_times)
while dump_times > 0:
dump_times -= 1
dump_path = os.path.join(data_dir.get_tmp_dir(), "dump.file")
try:
virsh.dump(vm.name, dump_path, debug=True, ignore_status=False)
except (process.CmdError, OSError) as detail:
err_msg = "Dump %s failed: %s" % (vm.name, detail)
try:
os.remove(dump_path)
except OSError:
pass
elif operation == "suspend_resume":
paused_times = int(params.get("paused_times", 10))
logging.info("Trying to suspend/resume vm %s times", paused_times)
while paused_times > 0:
paused_times -= 1
try:
virsh.suspend(vm.name, debug=True, ignore_status=False)
virsh.resume(vm.name, debug=True, ignore_status=False)
except process.CmdError as detail:
err_msg = "Suspend-Resume %s failed: %s" % (vm.name, detail)
elif operation == "save_restore":
save_times = int(params.get("save_times", 10))
logging.info("Trying to save/restore vm %s times", save_times)
while save_times > 0:
save_times -= 1
save_path = os.path.join(data_dir.get_tmp_dir(), "save.file")
try:
virsh.save(vm.name, save_path, debug=True,
ignore_status=False)
virsh.restore(save_path, debug=True, ignore_status=False)
except process.CmdError as detail:
err_msg = "Save-Restore %s failed: %s" % (vm.name, detail)
try:
os.remove(save_path)
except OSError:
pass
else:
err_msg = "Unsupport operation in this function: %s" % operation
return err_msg
def run(test, params, env):
"""
Test command: virsh save.
The command can save the RAM state of a running domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh save command with assigned options.
4.Recover test environment.(If the libvirtd service is stopped ,start
the libvirtd service.)
5.Confirm the test result.
"""
savefile = params.get("save_file", "save.file")
if savefile:
savefile = os.path.join(test.tmpdir, savefile)
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("save_extra_param")
vm_ref = params.get("save_vm_ref")
progress = ("yes" == params.get("save_progress", "no"))
options = params.get("save_option", "")
status_error = ("yes" == params.get("save_status_error", "yes"))
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
domid = vm.get_id()
domuuid = vm.get_uuid()
# set the option
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref.count("invalid"):
vm_ref = params.get(vm_ref)
elif vm_ref.count("name"):
vm_ref = vm_name
vm_ref += (" %s" % extra_param)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if progress:
options += " --verbose"
result = virsh.save(vm_ref, savefile, options, ignore_status=True,
unprivileged_user=unprivileged_user,
uri=uri, debug=True)
status = result.exit_status
err_msg = result.stderr.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
if savefile:
virsh.restore(savefile)
# check status_error
try:
if status_error:
if not status:
raise error.TestFail("virsh run succeeded with an "
"incorrect command")
else:
if status:
raise error.TestFail("virsh run failed with a "
"correct command")
if progress and not err_msg.count("Save:"):
raise error.TestFail("No progress information outputed!")
if options.count("running"):
if vm.is_dead() or vm.is_paused():
raise error.TestFail("Guest state should be"
" running after restore"
" due to the option --running")
elif options.count("paused"):
if not vm.is_paused():
raise error.TestFail("Guest state should be"
" paused after restore"
" due to the option --paused")
else:
if vm.is_dead():
raise error.TestFail("Guest state should be"
" alive after restore"
" since no option was specified")
finally:
if vm.is_paused():
virsh.resume(vm_name)
def run(test, params, env):
"""
Test DAC in save/restore domain to nfs pool.
(1).Init variables for test.
(2).Create nfs pool
(3).Start VM and check result.
(4).Save domain to the nfs pool.
(5).Restore domain from the nfs file.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("dac_nfs_save_restore_host_selinux", "enforcing")
# Get qemu.conf config variables
qemu_user = params.get("qemu_user")
qemu_group = params.get("qemu_group")
dynamic_ownership = "yes" == params.get("dynamic_ownership", "yes")
# Get variables about pool vol
virt_use_nfs = params.get("virt_use_nfs", "off")
nfs_server_dir = params.get("nfs_server_dir", "nfs-server")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
export_options = params.get("export_options", "rw,async,no_root_squash")
emulated_image = params.get("emulated_image")
vol_name = params.get("vol_name")
vol_format = params.get("vol_format")
bk_file_name = params.get("bk_file_name")
# Get pool file variables
pre_file = "yes" == params.get("pre_file", "yes")
pre_file_name = params.get("pre_file_name", "dac_nfs_file")
file_tup = ("file_user", "file_group", "file_mode")
file_val = []
for i in file_tup:
try:
file_val.append(int(params.get(i)))
except ValueError:
test.cancel("%s value '%s' is not a number." %
(i, params.get(i)))
# False positive - file_val was filled in the for loop above.
# pylint: disable=E0632
file_user, file_group, file_mode = file_val
# Get variables about VM and get a VM object and VMXML instance.
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Backup domain disk label
disks = vm.get_disk_devices()
backup_labels_of_disks = {}
for disk in list(disks.values()):
disk_path = disk['source']
f = os.open(disk_path, 0)
stat_re = os.fstat(f)
backup_labels_of_disks[disk_path] = "%s:%s" % (stat_re.st_uid,
stat_re.st_gid)
os.close(f)
# Backup selinux status of host.
backup_sestatus = utils_selinux.get_status()
pvt = None
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
try:
# chown domain disk mode to avoid fail on local disk
for disk in list(disks.values()):
disk_path = disk['source']
if qemu_user == "root":
os.chown(disk_path, 0, 0)
elif qemu_user == "qemu":
os.chown(disk_path, 107, 107)
# Set selinux of host.
utils_selinux.set_status(host_sestatus)
# set qemu conf
qemu_conf.user = qemu_user
qemu_conf.group = qemu_user
if dynamic_ownership:
qemu_conf.dynamic_ownership = 1
else:
qemu_conf.dynamic_ownership = 0
logging.debug("the qemu.conf content is: %s" % qemu_conf)
libvirtd.restart()
# Create dst pool for save/restore
logging.debug("export_options is: %s" % export_options)
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name, pool_type, pool_target,
emulated_image, image_size="1G",
pre_disk_vol=["20M"],
export_options=export_options)
# Set virt_use_nfs
result = process.run("setsebool virt_use_nfs %s" % virt_use_nfs, shell=True)
if result.exit_status:
test.cancel("Failed to set virt_use_nfs value")
# Create a file on nfs server dir.
tmp_dir = data_dir.get_tmp_dir()
nfs_path = os.path.join(tmp_dir, nfs_server_dir)
server_file_path = os.path.join(nfs_path, pre_file_name)
if pre_file and not os.path.exists(server_file_path):
open(server_file_path, 'a').close()
if not pre_file and os.path.exists(server_file_path):
test.cancel("File %s already exist in pool %s" %
(server_file_path, pool_name))
# Get nfs mount file path
mnt_path = os.path.join(tmp_dir, pool_target)
mnt_file_path = os.path.join(mnt_path, pre_file_name)
# Change img ownership and mode on nfs server dir
if pre_file:
os.chown(server_file_path, file_user, file_group)
os.chmod(server_file_path, file_mode)
# Start VM.
try:
vm.start()
# Start VM successfully.
except virt_vm.VMStartError as e:
# Starting VM failed.
test.fail("Domain failed to start. "
"error: %s" % e)
label_before = check_ownership(server_file_path)
if label_before:
logging.debug("file ownership on nfs server before save: %s" %
label_before)
# Save domain to nfs pool file
save_re = virsh.save(vm_name, mnt_file_path, debug=True)
if save_re.exit_status:
if not status_error:
test.fail("Failed to save domain to nfs pool file.")
else:
if status_error:
test.fail("Save domain to nfs pool file succeeded, "
"expected Fail.")
label_after = check_ownership(server_file_path)
if label_after:
logging.debug("file ownership on nfs server after save: %s"
% label_after)
# Restore domain from the nfs pool file
if not save_re.exit_status:
restore_re = virsh.restore(mnt_file_path, debug=True)
if restore_re.exit_status:
if not status_error:
test.fail("Failed to restore domain from nfs "
"pool file.")
else:
if status_error:
test.fail("Restore domain from nfs pool file "
"succeeded, expected Fail.")
label_after_rs = check_ownership(server_file_path)
if label_after_rs:
logging.debug("file ownership on nfs server after restore: %s"
% label_after_rs)
finally:
# clean up
for path, label in list(backup_labels_of_disks.items()):
label_list = label.split(":")
os.chown(path, int(label_list[0]), int(label_list[1]))
if pvt:
try:
pvt.cleanup_pool(pool_name, pool_type, pool_target,
emulated_image)
except exceptions.TestFail as detail:
logging.error(str(detail))
utils_selinux.set_status(backup_sestatus)
qemu_conf.restore()
libvirtd.restart()
def run(test, params, env):
"""
Test command: virsh dompmsuspend <domain> <target>
The command suspends a running domain using guest OS's power management.
"""
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_state = params.get("vm_state", "running")
suspend_target = params.get("pm_suspend_target", "mem")
pm_enabled = params.get("pm_enabled", "not_set")
test_managedsave = "yes" == params.get("test_managedsave", "no")
test_save_restore = "yes" == params.get("test_save_restore", "no")
test_suspend_resume = "yes" == params.get("test_suspend_resume", "no")
pmsuspend_error = 'yes' == params.get("pmsuspend_error", 'no')
# Libvirt acl test related params
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
# A backup of original vm
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
# Expected possible fail patterns.
# Error output should match one of these patterns.
# An empty list mean test should succeed.
fail_pat = []
virsh_dargs = {'debug': True, 'ignore_status': True}
if params.get('setup_libvirt_polkit') == 'yes':
virsh_dargs_copy = virsh_dargs.copy()
virsh_dargs_copy['uri'] = uri
virsh_dargs_copy['unprivileged_user'] = unprivileged_user
if pmsuspend_error:
fail_pat.append('access denied')
# Setup possible failure patterns
if pm_enabled == 'not_set':
fail_pat.append('not supported')
if pm_enabled == 'no':
fail_pat.append('disabled')
if vm_state == 'paused':
fail_pat.append('not responding')
elif vm_state == 'shutoff':
fail_pat.append('not running')
try:
if vm.is_alive():
vm.destroy()
# Set pm tag in domain's XML if needed.
if pm_enabled == 'not_set':
try:
if vmxml.pm:
del vmxml.pm
except xcepts.LibvirtXMLNotFoundError:
pass
else:
pm_xml = vm_xml.VMPMXML()
if suspend_target == 'mem':
pm_xml.mem_enabled = pm_enabled
elif suspend_target == 'disk':
pm_xml.disk_enabled = pm_enabled
elif suspend_target == 'hybrid':
pm_xml.mem_enabled = pm_enabled
pm_xml.disk_enabled = pm_enabled
vmxml.pm = pm_xml
vmxml.sync()
vm.prepare_guest_agent()
# Create swap partition/file if nessesary.
need_mkswap = False
if suspend_target in ['disk', 'hybrid']:
need_mkswap = not vm.has_swap()
if need_mkswap:
logging.debug("Creating swap partition.")
vm.create_swap_partition()
try:
libvirtd = utils_libvirtd.Libvirtd()
savefile = os.path.join(test.tmpdir, "%s.save" % vm_name)
session = vm.wait_for_login()
# Touch a file on guest to test managed save command.
if test_managedsave:
session.cmd_status("touch pmtest")
# Set vm state
if vm_state == "paused":
vm.pause()
elif vm_state == "shutoff":
vm.destroy()
# Run test case
result = virsh.dompmsuspend(vm_name, suspend_target, debug=True,
uri=uri,
unprivileged_user=unprivileged_user)
if result.exit_status == 0:
if fail_pat:
raise error.TestFail("Expected failed with %s, but run succeed"
":\n%s" % (fail_pat, result))
else:
if not fail_pat:
raise error.TestFail("Expected success, but run failed:\n%s"
% result)
#if not any_pattern_match(fail_pat, result.stderr):
if not any(p in result.stderr for p in fail_pat):
raise error.TestFail("Expected failed with one of %s, but "
"failed with:\n%s" % (fail_pat, result))
if test_managedsave:
ret = virsh.managedsave(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
# Dompmwakeup should return false here
ret = virsh.dompmwakeup(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret, True)
ret = virsh.start(vm_name)
libvirt.check_exit_status(ret)
if not vm.is_paused():
raise error.TestFail("Vm status is not paused before pm wakeup")
if params.get('setup_libvirt_polkit') == 'yes':
ret = virsh.dompmwakeup(vm_name, **virsh_dargs_copy)
else:
ret = virsh.dompmwakeup(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
if not vm.is_paused():
raise error.TestFail("Vm status is not paused after pm wakeup")
ret = virsh.resume(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
sess = vm.wait_for_login()
if sess.cmd_status("ls pmtest && rm -f pmtest"):
raise error.TestFail("Check managed save failed on guest")
sess.close()
if test_save_restore:
# Run a series of operations to check libvirtd status.
ret = virsh.dompmwakeup(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
# Wait for vm is started
vm.wait_for_login()
ret = virsh.save(vm_name, savefile, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(savefile, **virsh_dargs)
libvirt.check_exit_status(ret)
# Wait for vm is started
vm.wait_for_login()
# run pmsuspend again
ret = virsh.dompmsuspend(vm_name, suspend_target, **virsh_dargs)
libvirt.check_exit_status(ret)
# save and restore the guest again.
ret = virsh.save(vm_name, savefile, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(savefile, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.destroy(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
if not libvirtd.is_running():
raise error.TestFail("libvirtd crashed")
if test_suspend_resume:
ret = virsh.suspend(vm_name)
libvirt.check_exit_status(ret, expect_error=True)
if vm.state() != 'pmsuspended':
raise error.TestFail("VM state should be pmsuspended")
ret = virsh.resume(vm_name)
libvirt.check_exit_status(ret, expect_error=True)
if vm.state() != 'pmsuspended':
raise error.TestFail("VM state should be pmsuspended")
finally:
libvirtd.restart()
# Remove the tmp file
if os.path.exists(savefile):
os.remove(savefile)
# Restore VM state
if vm_state == "paused":
vm.resume()
if suspend_target in ['mem', 'hybrid']:
if vm.state() == "pmsuspended":
virsh.dompmwakeup(vm_name)
else:
if vm.state() == "in shutdown":
vm.wait_for_shutdown()
if vm.is_dead():
vm.start()
# Cleanup
session.close()
if need_mkswap:
vm.cleanup_swap()
finally:
# Destroy the vm.
if vm.is_alive():
vm.destroy()
# Recover xml of vm.
vmxml_backup.sync()
def run_virsh_restore(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = params.get("restore_status_error")
libvirtd = params.get("restore_libvirtd")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
#run test
if vm_ref =="" or vm_ref == "xyz":
status = virsh.restore(vm_ref, ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
status, output = session.cmd_status_output(cmd,
internal_timeout = 10)
session.close()
if not re.search("processor", output):
raise error.TestFail("Unable to read /proc/cpuinfo")
tmp_file = vm_ref
if vm_ref == "/tmp/save.file":
virsh.save(vm_name, vm_ref)
vm_ref = "%s %s" % (vm_ref, extra_param)
elif vm_ref == "/tmp/new.file":
open(vm_ref, 'w').close()
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
status = virsh.restore(vm_ref, ignore_status=True).exit_status
os.unlink(tmp_file)
if status_error == "no":
list_output = virsh.dom_list().stdout.strip()
session.close()
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
if vm.is_alive():
vm.destroy()
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
else:
if not re.search(vm_name, list_output):
raise error.TestFail("Run failed with right command")
paused_times -= 1
try:
virsh.suspend(vm.name, debug=True, ignore_status=False)
virsh.resume(vm.name, debug=True, ignore_status=False)
except error.CmdError, detail:
err_msg = "Suspend-Resume %s failed: %s" % (vm.name, detail)
elif operation == "save_restore":
save_times = int(params.get("save_times", 10))
logging.info("Trying to save/restore vm %s times", save_times)
while save_times > 0:
save_times -= 1
save_path = os.path.join(data_dir.get_tmp_dir(), "save.file")
try:
virsh.save(vm.name, save_path, debug=True,
ignore_status=False)
virsh.restore(save_path, debug=True, ignore_status=False)
except error.CmdError, detail:
err_msg = "Save-Restore %s failed: %s" % (vm.name, detail)
try:
os.remove(save_path)
except OSError:
pass
else:
err_msg = "Unsupport operation in this function: %s" % operation
return err_msg
def translate_timer_name(timer_name):
"""
Translate timer name in XML to clock source name in VM.
def run(test, params, env):
"""
Test command: virsh save-image-dumpxml <file>
virsh save-image-define <file> [--xml <string>]
1) Prepare test environment.
2) Execute save-image-dumpxml to get VM xml description
3) Edit the xml string and call virsh save-image-define to redefine it
4) Restore VM
5) Check the new xml of the VM
"""
def get_image_xml():
# Invoke save-image-dumpxml
cmd_result = virsh.save_image_dumpxml(vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to dump xml from "
"saved state file:%s" % vm_save)
xml = cmd_result.stdout.strip()
match_string = "<name>%s</name>" % vm_name
if not re.search(match_string, xml):
raise error.TestFail("The xml from saved state file "
"is invalid")
return xml
def redefine_new_xml():
if restore_state == "running":
option = "--running"
elif restore_state == "paused":
option = "--paused"
else:
raise error.TestFail("Unknown save-image-define option")
cmd_result = virsh.save_image_define(vm_save, xmlfile, option,
debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to redefine new xml %s for %s" %
(xmlfile, vm_save))
def vm_state_check():
cmd_result = virsh.dumpxml(vm_name, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to dump xml of domain %s" % vm_name)
# The xml should contain the match_string
xml = cmd_result.stdout.strip()
match_string = "<boot dev='cdrom'/>"
if not re.search(match_string, xml):
raise error.TestFail("After domain restore, "
"the xml is not expected")
domstate = virsh.domstate(vm_name, debug=True).stdout.strip()
if restore_state != domstate:
raise error.TestFail("The domain state is not expected")
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
restore_state = params.get("restore_state", "running")
vm_save = params.get("vm_save", "vm.save")
try:
# Get a tmp_dir.
tmp_dir = data_dir.get_tmp_dir()
if os.path.dirname(vm_save) is "":
vm_save = os.path.join(tmp_dir, vm_save)
# Save the RAM state of a running domain
cmd_result = virsh.save(vm_name, vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to save running domain %s" % vm_name)
xml = get_image_xml()
# Replace <boot dev='hd'/> to <boot dev='cdrom'/>
newxml = xml.replace("<boot dev='hd'/>", "<boot dev='cdrom'/>")
logging.debug("After string replacement, the new xml is %s", newxml)
# Write new xml into a tempfile
tmp_file = tempfile.NamedTemporaryFile(prefix=("new_vm_xml_"),
dir=tmp_dir)
xmlfile = tmp_file.name
tmp_file.close()
fd = open(xmlfile, 'w')
fd.write(newxml)
fd.close()
# Redefine new xml for domain's saved state file
redefine_new_xml()
# Restore domain
cmd_result = virsh.restore(vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to restore domain %s" % vm_name)
os.remove(vm_save)
vm_state_check()
finally:
# cleanup
if restore_state == "paused":
virsh.resume(vm_name)
if os.path.exists(vm_save):
virsh.restore(vm_save)
os.remove(vm_save)
if os.path.exists(xmlfile):
os.remove(xmlfile)
def run_virsh_save(test, params, env):
"""
Test command: virsh save.
The command can save the RAM state of a running domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh save command with assigned options.
4.Recover test environment.(If the libvirtd service is stopped ,start
the libvirtd service.)
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
domid = vm.get_id().strip()
domuuid = vm.get_uuid().strip()
savefile = params.get("save_file", "save.file")
# If savefile is not an abs path, join it to test.tmpdir
if os.path.dirname(savefile) is "":
savefile = os.path.join(test.tmpdir, savefile)
pre_vm_state = params.get("save_pre_vm_state", "null")
libvirtd = params.get("save_libvirtd")
extra_param = params.get("save_extra_param")
vm_ref = params.get("save_vm_ref")
# prepare the environment
if vm_ref == "name" and pre_vm_state == "paused":
virsh.suspend(vm_name)
elif vm_ref == "name" and pre_vm_state == "shut off":
virsh.destroy(vm_name)
# set the option
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "save_invalid_id" or vm_ref == "save_invalid_uuid":
vm_ref = params.get(vm_ref)
elif vm_ref.find("name") != -1 or vm_ref == "extra_param":
savefile = "%s %s" % (savefile, extra_param)
if vm_ref == "only_name":
savefile = " "
vm_ref = vm_name
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
status = virsh.save(vm_ref, savefile, ignore_status=True).exit_status
# recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
# cleanup
if os.path.exists(savefile):
virsh.restore(savefile)
os.remove(savefile)
# check status_error
status_error = params.get("save_status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
try:
# Get a tmp_dir.
tmp_dir = data_dir.get_tmp_dir()
if os.path.dirname(vm_save) is "":
vm_save = os.path.join(tmp_dir, vm_save)
# Save the RAM state of a running domain
cmd_result = virsh.save(vm_name, vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to save running domain %s" % vm_name)
# Edit the xml in the saved state file
edit_image_xml()
# Restore domain
cmd_result = virsh.restore(vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to restore domain %s" % vm_name)
os.remove(vm_save)
vm_state_check()
finally:
# cleanup
if restore_state == "paused":
virsh.resume(vm_name)
if os.path.exists(vm_save):
virsh.restore(vm_save)
os.remove(vm_save)
def run(test, params, env):
"""
Attach/Detach an iscsi network/volume disk to domain
1. For secret usage testing:
1.1. Setup an iscsi target with CHAP authentication.
1.2. Define a secret for iscsi target usage
1.3. Set secret value
2. Create
4. Create an iscsi network disk XML
5. Attach disk with the XML file and check the disk inside the VM
6. Detach the disk
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
disk_device = params.get("disk_device", "disk")
disk_type = params.get("disk_type", "network")
disk_src_protocol = params.get("disk_source_protocol", "iscsi")
disk_src_host = params.get("disk_source_host", "127.0.0.1")
disk_src_port = params.get("disk_source_port", "3260")
disk_src_pool = params.get("disk_source_pool")
disk_src_mode = params.get("disk_source_mode", "host")
pool_type = params.get("pool_type", "iscsi")
pool_src_host = params.get("pool_source_host", "127.0.0.1")
disk_target = params.get("disk_target", "vdb")
disk_target_bus = params.get("disk_target_bus", "virtio")
disk_readonly = params.get("disk_readonly", "no")
chap_auth = "yes" == params.get("chap_auth", "no")
chap_user = params.get("chap_username", "")
chap_passwd = params.get("chap_password", "")
secret_usage_target = params.get("secret_usage_target")
secret_ephemeral = params.get("secret_ephemeral", "no")
secret_private = params.get("secret_private", "yes")
status_error = "yes" == params.get("status_error", "no")
# Indicate the PPC platform
on_ppc = False
if platform.platform().count('ppc64'):
on_ppc = True
if disk_src_protocol == 'iscsi':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
if disk_type == "volume":
if not libvirt_version.version_compare(1, 0, 5):
test.cancel("'volume' type disk doesn't support in"
" current libvirt version.")
# Back VM XML
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
try:
start_vm = "yes" == params.get("start_vm", "yes")
if start_vm:
if vm.is_dead():
vm.start()
vm.wait_for_login()
else:
if not vm.is_dead():
vm.destroy()
if chap_auth:
# Create a secret xml to define it
secret_xml = SecretXML(secret_ephemeral, secret_private)
secret_xml.auth_type = "chap"
secret_xml.auth_username = chap_user
secret_xml.usage = disk_src_protocol
secret_xml.target = secret_usage_target
with open(secret_xml.xml) as f:
logging.debug("Define secret by XML: %s", f.read())
# Define secret
cmd_result = virsh.secret_define(secret_xml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Get secret uuid
try:
secret_uuid = cmd_result.stdout.strip().split()[1]
except IndexError:
test.error("Fail to get new created secret uuid")
# Set secret value
encoding = locale.getpreferredencoding()
secret_string = base64.b64encode(chap_passwd.encode(encoding)).decode(encoding)
cmd_result = virsh.secret_set_value(secret_uuid, secret_string,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
else:
# Set chap_user and chap_passwd to empty to avoid setup
# CHAP authentication when export iscsi target
chap_user = ""
chap_passwd = ""
# Setup iscsi target
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=False,
image_size='1G',
chap_user=chap_user,
chap_passwd=chap_passwd,
portal_ip=disk_src_host)
# Create iscsi pool
if disk_type == "volume":
# Create an iscsi pool xml to create it
pool_src_xml = pool_xml.SourceXML()
pool_src_xml.host_name = pool_src_host
pool_src_xml.device_path = iscsi_target
poolxml = pool_xml.PoolXML(pool_type=pool_type)
poolxml.name = disk_src_pool
poolxml.set_source(pool_src_xml)
poolxml.target_path = "/dev/disk/by-path"
# Create iscsi pool
cmd_result = virsh.pool_create(poolxml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
def get_vol():
"""Get the volume info"""
# Refresh the pool
cmd_result = virsh.pool_refresh(disk_src_pool)
libvirt.check_exit_status(cmd_result)
# Get volume name
cmd_result = virsh.vol_list(disk_src_pool, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
vol_list = []
vol_list = re.findall(r"(\S+)\ +(\S+)",
str(cmd_result.stdout.strip()))
if len(vol_list) > 1:
return vol_list[1]
else:
return None
# Wait for a while so that we can get the volume info
vol_info = utils_misc.wait_for(get_vol, 10)
if vol_info:
vol_name, vol_path = vol_info
else:
test.error("Failed to get volume info")
# Snapshot doesn't support raw disk format, create a qcow2 volume
# disk for snapshot operation.
process.run('qemu-img create -f qcow2 %s %s' % (vol_path, '100M'),
shell=True)
# Create iscsi network disk XML
disk_params = {'device_type': disk_device,
'type_name': disk_type,
'target_dev': disk_target,
'target_bus': disk_target_bus,
'readonly': disk_readonly}
disk_params_src = {}
if disk_type == "network":
disk_params_src = {'source_protocol': disk_src_protocol,
'source_name': iscsi_target + "/%s" % lun_num,
'source_host_name': disk_src_host,
'source_host_port': disk_src_port}
elif disk_type == "volume":
disk_params_src = {'source_pool': disk_src_pool,
'source_volume': vol_name,
'driver_type': 'qcow2',
'source_mode': disk_src_mode}
else:
test.cancel("Unsupport disk type in this test")
disk_params.update(disk_params_src)
if chap_auth:
disk_params_auth = {'auth_user': chap_user,
'secret_type': disk_src_protocol,
'secret_usage': secret_xml.target}
disk_params.update(disk_params_auth)
disk_xml = libvirt.create_disk_xml(disk_params)
attach_option = params.get("attach_option", "")
cmd_result = virsh.attach_device(domainarg=vm_name, filearg=disk_xml,
flagstr=attach_option,
dargs=virsh_dargs)
libvirt.check_exit_status(cmd_result, status_error)
if vm.is_dead():
cmd_result = virsh.start(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Wait for domain is stable
vm.wait_for_login().close()
domain_operation = params.get("domain_operation", "")
if domain_operation == "save":
save_file = os.path.join(data_dir.get_tmp_dir(), "vm.save")
cmd_result = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.restore(save_file)
libvirt.check_exit_status(cmd_result)
if os.path.exists(save_file):
os.remove(save_file)
elif domain_operation == "snapshot":
# Run snapshot related commands: snapshot-create-as, snapshot-list
# snapshot-info, snapshot-dumpxml, snapshot-create
snapshot_name1 = "snap1"
snapshot_name2 = "snap2"
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
virsh.snapshot_list(vm_name, **virsh_dargs)
except process.CmdError:
test.fail("Failed getting snapshots list for %s" % vm_name)
try:
virsh.snapshot_info(vm_name, snapshot_name1, **virsh_dargs)
except process.CmdError:
test.fail("Failed getting snapshots info for %s" % vm_name)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_create(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_current(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
snapshot_file = os.path.join(data_dir.get_tmp_dir(), snapshot_name2)
sn_create_op = ("%s --disk-only --diskspec %s,file=%s"
% (snapshot_name2, disk_target, snapshot_file))
cmd_result = virsh.snapshot_create_as(vm_name, sn_create_op,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_revert(vm_name, snapshot_name1,
**virsh_dargs)
cmd_result = virsh.snapshot_list(vm_name, **virsh_dargs)
if snapshot_name2 not in cmd_result:
test.error("Snapshot %s not found" % snapshot_name2)
elif domain_operation == "":
logging.debug("No domain operation provided, so skip it")
else:
logging.error("Unsupport operation %s in this case, so skip it",
domain_operation)
def find_attach_disk(expect=True):
"""
Find attached disk inside the VM
"""
found_disk = False
if vm.is_dead():
test.error("Domain %s is not running" % vm_name)
else:
try:
session = vm.wait_for_login()
# Here the script needs wait for a while for the guest to
# recognize the hotplugged disk on PPC
if on_ppc:
time.sleep(10)
cmd = "grep %s /proc/partitions" % disk_target
s, o = session.cmd_status_output(cmd)
logging.info("%s output: %s", cmd, o)
session.close()
if s == 0:
found_disk = True
except (LoginError, VMError, ShellError) as e:
logging.error(str(e))
if found_disk == expect:
logging.debug("Check disk inside the VM PASS as expected")
else:
test.error("Check disk inside the VM FAIL")
# Check disk inside the VM, expect is False if status_error=True
find_attach_disk(not status_error)
# Detach disk
cmd_result = virsh.detach_disk(vm_name, disk_target)
libvirt.check_exit_status(cmd_result, status_error)
# Check disk inside the VM
find_attach_disk(False)
finally:
# Clean up snapshot
# Shut down before cleaning up snapshots
if vm.is_alive():
vm.destroy()
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
# Restore vm
vmxml_backup.sync("--snapshots-metadata")
# Destroy pool and undefine secret, which may not exist
try:
if disk_type == "volume":
virsh.pool_destroy(disk_src_pool)
if chap_auth:
virsh.secret_undefine(secret_uuid)
except Exception:
pass
libvirt.setup_or_cleanup_iscsi(is_setup=False)
try:
# Get a tmp_dir.
tmp_dir = data_dir.get_tmp_dir()
if os.path.dirname(vm_save) is "":
vm_save = os.path.join(tmp_dir, vm_save)
# Save the RAM state of a running domain
cmd_result = virsh.save(vm_name, vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to save running domain %s" % vm_name)
# Edit the xml in the saved state file
edit_image_xml()
# Restore domain
cmd_result = virsh.restore(vm_save, debug=True)
if cmd_result.exit_status:
raise error.TestFail("Failed to restore domain %s" % vm_name)
os.remove(vm_save)
vm_state_check()
finally:
# cleanup
if restore_state == "paused":
virsh.resume(vm_name)
if os.path.exists(vm_save):
virsh.restore(vm_save)
os.remove(vm_save)
def run(test, params, env):
"""
Test DAC in save/restore domain to nfs pool.
(1).Init variables for test.
(2).Create nfs pool
(3).Start VM and check result.
(4).Save domain to the nfs pool.
(5).Restore domain from the nfs file.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("dac_nfs_save_restore_host_selinux",
"enforcing")
# Get qemu.conf config variables
qemu_user = params.get("qemu_user")
qemu_group = params.get("qemu_group")
dynamic_ownership = "yes" == params.get("dynamic_ownership", "yes")
# Get variables about pool vol
virt_use_nfs = params.get("virt_use_nfs", "off")
nfs_server_dir = params.get("nfs_server_dir", "nfs-server")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
export_options = params.get("export_options", "rw,async,no_root_squash")
emulated_image = params.get("emulated_image")
vol_name = params.get("vol_name")
vol_format = params.get("vol_format")
bk_file_name = params.get("bk_file_name")
# Get pool file variables
pre_file = "yes" == params.get("pre_file", "yes")
pre_file_name = params.get("pre_file_name", "dac_nfs_file")
file_tup = ("file_user", "file_group", "file_mode")
file_val = []
for i in file_tup:
try:
file_val.append(int(params.get(i)))
except ValueError:
raise error.TestNAError("%s value '%s' is not a number." %
(i, params.get(i)))
file_user, file_group, file_mode = file_val
# Get variables about VM and get a VM object and VMXML instance.
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
if vm.is_alive():
vm.destroy()
# Backup domain disk label
disks = vm.get_disk_devices()
backup_labels_of_disks = {}
for disk in disks.values():
disk_path = disk['source']
f = os.open(disk_path, 0)
stat_re = os.fstat(f)
backup_labels_of_disks[disk_path] = "%s:%s" % (stat_re.st_uid,
stat_re.st_gid)
os.close(f)
# Backup selinux status of host.
backup_sestatus = utils_selinux.get_status()
pvt = None
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
try:
# chown domain disk mode to avoid fail on local disk
for disk in disks.values():
disk_path = disk['source']
if qemu_user == "root":
os.chown(disk_path, 0, 0)
elif qemu_user == "qemu":
os.chown(disk_path, 107, 107)
# Set selinux of host.
utils_selinux.set_status(host_sestatus)
# set qemu conf
qemu_conf.user = qemu_user
qemu_conf.group = qemu_user
if dynamic_ownership:
qemu_conf.dynamic_ownership = 1
else:
qemu_conf.dynamic_ownership = 0
logging.debug("the qemu.conf content is: %s" % qemu_conf)
libvirtd.restart()
# Create dst pool for save/restore
logging.debug("export_options is: %s" % export_options)
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name,
pool_type,
pool_target,
emulated_image,
image_size="1G",
pre_disk_vol=["20M"],
export_options=export_options)
# Set virt_use_nfs
result = utils.run("setsebool virt_use_nfs %s" % virt_use_nfs)
if result.exit_status:
raise error.TestNAError("Failed to set virt_use_nfs value")
# Create a file on nfs server dir.
tmp_dir = data_dir.get_tmp_dir()
nfs_path = os.path.join(tmp_dir, nfs_server_dir)
server_file_path = os.path.join(nfs_path, pre_file_name)
if pre_file and not os.path.exists(server_file_path):
open(server_file_path, 'a').close()
if not pre_file and os.path.exists(server_file_path):
raise error.TestNAError("File %s already exist in pool %s" %
(server_file_path, pool_name))
# Get nfs mount file path
mnt_path = os.path.join(tmp_dir, pool_target)
mnt_file_path = os.path.join(mnt_path, pre_file_name)
# Change img ownership and mode on nfs server dir
if pre_file:
os.chown(server_file_path, file_user, file_group)
os.chmod(server_file_path, file_mode)
# Start VM.
try:
vm.start()
# Start VM successfully.
except virt_vm.VMStartError, e:
# Starting VM failed.
raise error.TestFail("Domain failed to start. " "error: %s" % e)
label_before = check_ownership(server_file_path)
if label_before:
logging.debug("file ownership on nfs server before save: %s" %
label_before)
# Save domain to nfs pool file
save_re = virsh.save(vm_name, mnt_file_path, debug=True)
if save_re.exit_status:
if not status_error:
raise error.TestFail("Failed to save domain to nfs pool file.")
else:
if status_error:
raise error.TestFail("Save domain to nfs pool file succeeded, "
"expected Fail.")
label_after = check_ownership(server_file_path)
if label_after:
logging.debug("file ownership on nfs server after save: %s" %
label_after)
# Restore domain from the nfs pool file
if not save_re.exit_status:
restore_re = virsh.restore(mnt_file_path, debug=True)
if restore_re.exit_status:
if not status_error:
raise error.TestFail("Failed to restore domain from nfs "
"pool file.")
else:
if status_error:
raise error.TestFail("Restore domain from nfs pool file "
"succeeded, expected Fail.")
label_after_rs = check_ownership(server_file_path)
if label_after_rs:
logging.debug(
"file ownership on nfs server after restore: %s" %
label_after_rs)
def run(test, params, env):
"""
Test command: virsh save.
The command can save the RAM state of a running domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh save command with assigned options.
4.Recover test environment.(If the libvirtd service is stopped ,start
the libvirtd service.)
5.Confirm the test result.
"""
savefile = params.get("save_file", "save.file")
if savefile:
savefile = os.path.join(data_dir.get_tmp_dir(), savefile)
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("save_extra_param")
vm_ref = params.get("save_vm_ref")
progress = ("yes" == params.get("save_progress", "no"))
options = params.get("save_option", "")
status_error = ("yes" == params.get("save_status_error", "yes"))
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
uri = params.get("virsh_uri")
readonly = ("yes" == params.get("save_readonly", "no"))
expect_msg = params.get("save_err_msg", "")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
domid = vm.get_id()
domuuid = vm.get_uuid()
# set the option
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref.count("invalid"):
vm_ref = params.get(vm_ref)
elif vm_ref.count("name"):
vm_ref = vm_name
vm_ref += (" %s" % extra_param)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if progress:
options += " --verbose"
result = virsh.save(vm_ref,
savefile,
options,
ignore_status=True,
unprivileged_user=unprivileged_user,
uri=uri,
debug=True,
readonly=readonly)
status = result.exit_status
err_msg = result.stderr.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
if savefile:
virsh.restore(savefile, debug=True)
# check status_error
try:
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(
5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("virsh run succeeded with an "
"incorrect command")
if readonly:
if not re.search(expect_msg, err_msg):
test.fail("Fail to get expect err msg: %s" % expect_msg)
else:
if status:
test.fail("virsh run failed with a " "correct command")
if progress and not err_msg.count("Save:"):
test.fail("No progress information outputted!")
if options.count("running"):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be"
" running after restore"
" due to the option --running")
elif options.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
else:
if vm.is_dead():
test.fail("Guest state should be"
" alive after restore"
" since no option was specified")
finally:
if vm.is_paused():
virsh.resume(vm_name)
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
time_before_save = int(params.get('time_before_save', 0))
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
if "--xml" in extra_param:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name, options="--migratable")
backup_xml = vmxml.copy()
# Grant more priveledge on the file in order for un-priveledge user
# to access.
os.chmod(vmxml.xml, stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
extra_param = "--xml %s" % vmxml.xml
dict_os_attrs = {}
if "hd" in vmxml.os.boots:
dict_os_attrs.update({"boots": ["cdrom"]})
vmxml.set_os_attrs(**dict_os_attrs)
else:
test.cancel("Please add 'hd' in boots for --xml testing")
logging.info("vmxml os is %s after update" % vmxml.os.xmltreefile)
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
test.fail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(data_dir.get_tmp_dir(), "save.file")
time.sleep(time_before_save)
ret = virsh.save(vm_name, tmp_file, debug=True)
libvirt.check_exit_status(ret)
if vm_ref == "saved_file":
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(data_dir.get_tmp_dir(), "new.file")
with open(tmp_file, 'w') as tmp:
pass
vm_ref = tmp_file
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
try:
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(5, 6, 0):
logging.info("From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("Run successfully with wrong command!")
else:
if status:
test.fail("Run failed with right command")
if not re.search(vm_name, list_output):
test.fail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
if (extra_param.count("running") or
extra_param.count("xml") or
not extra_param):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be"
" running after restore")
if extra_param.count("xml"):
aft_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
boots_list = aft_vmxml.os.boots
if "hd" in boots_list or "cdrom" not in boots_list:
test.fail("Update xml with restore failed")
finally:
if vm.is_paused():
virsh.resume(vm_name)
if "--xml" in extra_param:
backup_xml.sync()
virsh.attach_device(domainarg=vm_name, filearg=eject_xml, debug=True)
# Add time sleep between two attach commands.
if time_sleep:
time.sleep(float(time_sleep))
# Eject cdrom
result = virsh.attach_device(domainarg=vm_name, filearg=eject_xml,
debug=True)
if result.exit_status != 0:
raise error.TestFail("Eject CDROM failed")
if vm_xml.VMXML.check_disk_exist(vm_name, device_source):
raise error.TestFail("Find %s after do eject" % device_source)
# Save and restore VM
if save_vm:
result = virsh.save(vm_name, save_file, debug=True)
libvirt.check_exit_status(result)
result = virsh.restore(save_file, debug=True)
libvirt.check_exit_status(result)
if vm_xml.VMXML.check_disk_exist(vm_name, device_source):
raise error.TestFail("Find %s after do restore" % device_source)
# Destroy VM.
vm.destroy(gracefully=False)
# Check disk count after VM shutdown (with --config).
check_count_after_shutdown = True
inactive_vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disk_count_after_shutdown = len(inactive_vmxml.get_disk_all())
if test_cmd == "attach-disk":
if disk_count_after_shutdown == disk_count_before_cmd:
check_count_after_shutdown = False
elif test_cmd == "detach-disk":
def trigger_events(events_list=[]):
"""
Trigger various events in events_list
"""
expected_events_list = []
tmpdir = data_dir.get_tmp_dir()
save_path = os.path.join(tmpdir, "vm_event.save")
new_disk = os.path.join(tmpdir, "new_disk.img")
try:
for event in events_list:
if event in ["start", "restore"]:
if vm.is_alive():
vm.destroy()
else:
if not vm.is_alive():
vm.start()
vm.wait_for_login().close()
if event == "start":
virsh.start(vm_name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:" " Started Booted")
vm.wait_for_login().close()
elif event == "save":
virsh.save(vm_name, save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:" " Stopped Saved")
elif event == "restore":
if not os.path.exists(save_path):
logging.error("%s not exist", save_path)
else:
virsh.restore(save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:" " Started Restored")
elif event == "destroy":
virsh.destroy(vm_name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:" " Stopped Destroyed")
elif event == "reset":
virsh.reset(vm_name, **virsh_dargs)
expected_events_list.append("'reboot' for %s")
elif event == "vcpupin":
virsh.vcpupin(vm_name, "0", "0", **virsh_dargs)
expected_events_list.append("'tunable' for %s:" "\n\tcputune.vcpupin0: 0")
elif event == "emulatorpin":
virsh.emulatorpin(vm_name, "0", **virsh_dargs)
expected_events_list.append("'tunable' for %s:" "\n\tcputune.emulatorpin: 0")
elif event == "setmem":
virsh.setmem(vm_name, 1048576, **virsh_dargs)
expected_events_list.append("'balloon-change' for %s:")
elif event == "detach-disk":
if not os.path.exists(new_disk):
open(new_disk, "a").close()
# Attach disk firstly, this event will not be catched
virsh.attach_disk(vm_name, new_disk, "vdb", **virsh_dargs)
virsh.detach_disk(vm_name, "vdb", **virsh_dargs)
expected_events_list.append("'device-removed' for %s:" " virtio-disk1")
else:
raise error.TestError("Unsupported event: %s" % event)
# Event may not received immediately
time.sleep(3)
finally:
if os.path.exists(save_path):
os.unlink(save_path)
if os.path.exists(new_disk):
os.unlink(new_disk)
return expected_events_list
def run(test, params, env):
"""
Different cpu compat mode scenario tests
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_feature(vm, feature="", vcpu=0):
"""
Checks the given feature is present
:param vm: VM Name
:param feature: feature to be verified
:param vcpu: vcpu number to pin guest test
:return: true on success, test fail on failure
"""
session = vm.wait_for_login()
if 'power8' in feature:
cmd = 'lscpu|grep -i "Model name:.*power8"'
elif 'xive' in feature:
# remove -v once guest xive support is available
# right now power9 guest supports only xics
cmd = "grep -v xive /sys/firmware/devicetree/base/interrupt-*/compatible"
elif 'xics' in feature:
cmd = "grep -v xive /sys/firmware/devicetree/base/interrupt-*/compatible"
elif 'power9' in feature:
cmd = 'lscpu|grep -i "Model name:.*power9"'
elif 'hpt' in feature:
cmd = 'grep "MMU.*: Hash" /proc/cpuinfo'
elif 'rpt' in feature:
cmd = 'grep "MMU.*: Radix" /proc/cpuinfo'
elif 'isa' in feature:
utils_package.package_install('gcc', session)
cmd = "echo 'int main(){asm volatile (\".long 0x7c0005e6\");"
cmd += "return 0;}' > ~/a.c;cc ~/a.c;taskset -c %s ./a.out" % vcpu
status, output = session.cmd_status_output(cmd)
logging.debug(output)
session.close()
if feature != "isa2.7":
if status != 0:
test.fail("Feature: %s check failed inside "
"%s guest on %s host" % (feature,
guest_version,
host_version))
else:
if status == 0:
test.fail("isa3.0 instruction succeeds in "
"%s guest on %s host" % (guest_version,
host_version))
return True
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
pin_vcpu = 0
host_version = params.get("host_version")
guest_version = params.get("guest_version")
max_vcpu = params.get("cpucompat_vcpu_max", "")
cur_vcpu = int(params.get("cpucompat_vcpu_cur", "1"))
cores = int(params.get("topology_cores", '1'))
sockets = int(params.get("topology_sockets", '1'))
threads = int(params.get("topology_threads", '1'))
status_error = "yes" == params.get("status_error", "no")
condn = params.get("condn", "")
guest_features = params.get("guest_features", "")
if guest_features:
guest_features = guest_features.split(',')
if guest_version:
guest_features.append(guest_version)
if host_version not in cpu.get_cpu_arch():
test.cancel("Unsupported Host cpu version")
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
org_xml = vmxml.copy()
# Destroy the vm
vm.destroy()
try:
# Set cpu model
if max_vcpu:
pin_vcpu = int(max_vcpu) - 1
libvirt_xml.VMXML.set_vm_vcpus(vm_name, int(max_vcpu), cur_vcpu,
sockets=sockets, cores=cores,
threads=threads, add_topology=True)
libvirt_xml.VMXML.set_cpu_mode(vm_name, model=guest_version)
logging.debug(virsh.dumpxml(vm_name))
try:
vm.start()
except virt_vm.VMStartError as detail:
if not status_error:
test.fail("%s" % detail)
else:
pass
if max_vcpu:
virsh.setvcpus(vm_name, int(max_vcpu), "--live",
ignore_status=False, debug=True)
if not utils_misc.check_if_vm_vcpu_match(int(max_vcpu), vm):
test.fail("Vcpu hotplug failed")
if not status_error:
for feature in guest_features:
check_feature(vm, feature, vcpu=pin_vcpu)
if condn == "filetrans":
utils_test.run_file_transfer(test, params, env)
elif condn == "stress":
bt = utils_test.run_avocado_bg(vm, params, test)
if not bt:
test.cancel("guest stress failed to start")
elif condn == "save":
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
result = virsh.save(vm_name, save_file, ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
# Just sleep few secs before guest recovery
time.sleep(2)
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
os.remove(save_file)
elif condn == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
# Just sleep few secs before guest recovery
time.sleep(2)
result = virsh.resume(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
else:
pass
finally:
org_xml.sync()
def run(test, params, env):
"""
Attach/Detach an iscsi network/volume disk to domain
1. For secret usage testing:
1.1. Setup an iscsi target with CHAP authentication.
1.2. Define a secret for iscsi target usage
1.3. Set secret value
2. Create
4. Create an iscsi network disk XML
5. Attach disk with the XML file and check the disk inside the VM
6. Detach the disk
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
disk_device = params.get("disk_device", "disk")
disk_type = params.get("disk_type", "network")
disk_src_protocal = params.get("disk_source_protocal", "iscsi")
disk_src_host = params.get("disk_source_host", "127.0.0.1")
disk_src_port = params.get("disk_source_port", "3260")
disk_src_pool = params.get("disk_source_pool")
disk_src_mode = params.get("disk_source_mode", "host")
pool_type = params.get("pool_type", "iscsi")
pool_src_host = params.get("pool_source_host", "127.0.0.1")
disk_target = params.get("disk_target", "vdb")
disk_target_bus = params.get("disk_target_bus", "virtio")
disk_readonly = params.get("disk_readonly", "no")
chap_auth = "yes" == params.get("chap_auth", "no")
chap_user = params.get("chap_username", "")
chap_passwd = params.get("chap_password", "")
secret_usage_target = params.get("secret_usage_target")
secret_ephemeral = params.get("secret_ephemeral", "no")
secret_private = params.get("secret_private", "yes")
status_error = "yes" == params.get("status_error", "no")
if disk_type == "volume":
if not libvirt_version.version_compare(1, 0, 5):
raise error.TestNAError("'volume' type disk doesn't support in"
+ " current libvirt version.")
# Back VM XML
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
try:
if chap_auth:
# Create a secret xml to define it
secret_xml = SecretXML(secret_ephemeral, secret_private)
secret_xml.auth_type = "chap"
secret_xml.auth_username = chap_user
secret_xml.usage = disk_src_protocal
secret_xml.target = secret_usage_target
logging.debug("Define secret by XML: %s", open(secret_xml.xml).read())
# Define secret
cmd_result = virsh.secret_define(secret_xml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Get secret uuid
try:
secret_uuid = cmd_result.stdout.strip().split()[1]
except IndexError:
raise error.TestError("Fail to get new created secret uuid")
# Set secret value
secret_string = base64.b64encode(chap_passwd)
cmd_result = virsh.secret_set_value(secret_uuid, secret_string,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
else:
# Set chap_user and chap_passwd to empty to avoid setup
# CHAP authentication when export iscsi target
chap_user = ""
chap_passwd = ""
# Setup iscsi target
iscsi_target = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=False,
chap_user=chap_user,
chap_passwd=chap_passwd)
# Create iscsi pool
if disk_type == "volume":
# Create an iscsi pool xml to create it
pool_src_xml = pool_xml.SourceXML()
pool_src_xml.hostname = pool_src_host
pool_src_xml.device_path = iscsi_target
poolxml = pool_xml.PoolXML(pool_type=pool_type)
poolxml.name = disk_src_host
poolxml.set_source(pool_src_xml)
poolxml.target_path = "/dev/disk/by-path"
# Create iscsi pool
cmd_result = virsh.pool_create(poolxml.xml, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
# Get volume name
cmd_result = virsh.vol_list(disk_src_pool, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
vol_name = re.findall(r"(\S+)\ +(\S+)[\ +\n]",
str(cmd_result.stdout))[1][0]
except IndexError:
raise error.TestError("Fail to get volume name")
# Create iscsi network disk XML
disk_params = {'device_type': disk_device,
'type_name': disk_type,
'target_dev': disk_target,
'target_bus': disk_target_bus,
'readonly': disk_readonly}
disk_params_src = {}
if disk_type == "network":
disk_params_src = {'source_protocol': disk_src_protocal,
'source_name': iscsi_target + "/1",
'source_host_name': disk_src_host,
'source_host_port': disk_src_port}
elif disk_type == "volume":
disk_params_src = {'source_pool': disk_src_pool,
'source_volume': vol_name,
'source_mode': disk_src_mode}
else:
error.TestNAError("Unsupport disk type in this test")
disk_params.update(disk_params_src)
if chap_auth:
disk_params_auth = {'auth_user': chap_user,
'secret_type': disk_src_protocal,
'secret_usage': secret_xml.target}
disk_params.update(disk_params_auth)
disk_xml = libvirt.create_disk_xml(disk_params)
start_vm = "yes" == params.get("start_vm", "yes")
if start_vm:
if vm.is_dead():
vm.start()
else:
if not vm.is_dead():
vm.destroy()
attach_option = params.get("attach_option", "")
# Attach the iscsi network disk to domain
logging.debug("Attach disk by XML: %s", open(disk_xml).read())
cmd_result = virsh.attach_device(domainarg=vm_name, filearg=disk_xml,
flagstrs=attach_option,
dargs=virsh_dargs)
libvirt.check_exit_status(cmd_result, status_error)
if vm.is_dead():
vm.start()
cmd_result = virsh.start(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
domain_operation = params.get("domain_operation", "")
if domain_operation == "save":
save_file = os.path.join(test.tmpdir, "vm.save")
cmd_result = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.restore(save_file)
libvirt.check_exit_status(cmd_result)
if os.path.exists(save_file):
os.remove(save_file)
elif domain_operation == "snapshot":
# Run snapshot related commands: snapshot-create-as, snapshot-list
# snapshot-info, snapshot-dumpxml, snapshot-create
snapshot_name1 = "snap1"
snapshot_name2 = "snap2"
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_list(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_info(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name1,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_create(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_current(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
sn_create_op = "%s --disk_ony %s" % (snapshot_name2, disk_target)
cmd_result = virsh.snapshot_create_as(vm_name, sn_create_op,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_revert(vm_name, snapshot_name1,
**virsh_dargs)
cmd_result = virsh.snapshot_list(vm_name, **virsh_dargs)
libvirt.check_exit_status(cmd_result)
cmd_result = virsh.snapshot_delete(vm_name, snapshot_name2,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
pass
else:
logging.error("Unsupport operation %s in this case, so skip it",
domain_operation)
def find_attach_disk(expect=True):
"""
Find attached disk inside the VM
"""
found_disk = False
if vm.is_dead():
raise error.TestError("Domain %s is not running" % vm_name)
else:
try:
session = vm.wait_for_login()
cmd = "grep %s /proc/partitions" % disk_target
s, o = session.cmd_status_output(cmd)
logging.info("%s output: %s", cmd, o)
session.close()
if s == 0:
found_disk = True
except (LoginError, VMError, ShellError), e:
logging.error(str(e))
if found_disk == expect:
logging.debug("Check disk inside the VM PASS as expected")
else:
raise error.TestError("Check disk inside the VM FAIL")
# Check disk inside the VM, expect is False if status_error=True
find_attach_disk(not status_error)
# Detach disk
cmd_result = virsh.detach_disk(vm_name, disk_target)
libvirt.check_exit_status(cmd_result, status_error)
# Check disk inside the VM
find_attach_disk(False)
def manipulate_domain(vm_name, vm_operation, recover=False):
"""
Operate domain to given state or recover it.
:params vm_name: Name of the VM domain
:params vm_operation: Operation to be performed on VM domain
like save, managedsave, suspend
:params recover: flag to inform whether to set or reset
vm_operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
if not recover:
if vm_operation == "save":
save_option = ""
result = virsh.save(vm_name, save_file, save_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "managedsave":
managedsave_option = ""
result = virsh.managedsave(vm_name, managedsave_option,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s3":
suspend_target = "mem"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s4":
suspend_target = "disk"
result = virsh.dompmsuspend(vm_name, suspend_target,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
# Wait domain state change: 'in shutdown' -> 'shut off'
utils_misc.wait_for(lambda: virsh.is_dead(vm_name), 5)
elif vm_operation == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "reboot":
vm.reboot()
else:
logging.debug("No operation for the domain")
else:
if vm_operation == "save":
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
os.remove(save_file)
else:
test.error("No save file for domain restore")
elif vm_operation in ["managedsave", "s4"]:
result = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "s3":
suspend_target = "mem"
result = virsh.dompmwakeup(vm_name, ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "suspend":
result = virsh.resume(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif vm_operation == "reboot":
pass
else:
logging.debug("No need recover the domain")
def set_condition(vm_name, condn, reset=False, guestbt=None):
"""
Set domain to given state or reset it.
"""
bt = None
if not reset:
if condn == "avocadotest":
bt = utils_test.run_avocado_bg(vm, params, test)
if not bt:
test.cancel("guest stress failed to start")
# Allow stress to start
time.sleep(condn_sleep_sec)
return bt
elif condn == "stress":
utils_test.load_stress("stress_in_vms", params=params, vms=[vm])
elif condn in ["save", "managedsave"]:
# No action
pass
elif condn == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif condn == "hotplug":
result = virsh.setvcpus(vm_name, max_vcpu, "--live",
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
exp_vcpu = {'max_config': max_vcpu, 'max_live': max_vcpu,
'cur_config': current_vcpu, 'cur_live': max_vcpu,
'guest_live': max_vcpu}
result = utils_hotplug.check_vcpu_value(vm, exp_vcpu,
option="--live")
elif condn == "host_smt":
if cpu.get_cpu_arch() == 'power9':
result = process.run("ppc64_cpu --smt=4", shell=True)
else:
test.cancel("Host SMT changes not allowed during guest live")
else:
logging.debug("No operation for the domain")
else:
if condn == "save":
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
result = virsh.save(vm_name, save_file,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
time.sleep(condn_sleep_sec)
if os.path.exists(save_file):
result = virsh.restore(save_file, ignore_status=True,
debug=True)
libvirt.check_exit_status(result)
os.remove(save_file)
else:
test.error("No save file for domain restore")
elif condn == "managedsave":
result = virsh.managedsave(vm_name,
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
time.sleep(condn_sleep_sec)
result = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif condn == "suspend":
result = virsh.resume(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(result)
elif condn == "avocadotest":
guestbt.join(ignore_status=True)
elif condn == "stress":
utils_test.unload_stress("stress_in_vms", params=params, vms=[vm])
elif condn == "hotplug":
result = virsh.setvcpus(vm_name, current_vcpu, "--live",
ignore_status=True, debug=True)
libvirt.check_exit_status(result)
exp_vcpu = {'max_config': max_vcpu, 'max_live': current_vcpu,
'cur_config': current_vcpu, 'cur_live': current_vcpu,
'guest_live': current_vcpu}
result = utils_hotplug.check_vcpu_value(vm, exp_vcpu,
option="--live")
elif condn == "host_smt":
result = process.run("ppc64_cpu --smt=2", shell=True)
# Change back the host smt
result = process.run("ppc64_cpu --smt=4", shell=True)
# Work around due to known cgroup issue after cpu hot(un)plug
# sequence
root_cpuset_path = utils_cgroup.get_cgroup_mountpoint("cpuset")
machine_cpuset_paths = []
if os.path.isdir(os.path.join(root_cpuset_path,
"machine.slice")):
machine_cpuset_paths.append(os.path.join(root_cpuset_path,
"machine.slice"))
if os.path.isdir(os.path.join(root_cpuset_path, "machine")):
machine_cpuset_paths.append(os.path.join(root_cpuset_path,
"machine"))
if not machine_cpuset_paths:
logging.warning("cgroup cpuset might not recover properly "
"for guests after host smt changes, "
"restore it manually")
root_cpuset_cpus = os.path.join(root_cpuset_path, "cpuset.cpus")
for path in machine_cpuset_paths:
machine_cpuset_cpus = os.path.join(path, "cpuset.cpus")
# check if file content differs
cmd = "diff %s %s" % (root_cpuset_cpus,
machine_cpuset_cpus)
if process.system(cmd, verbose=True, ignore_status=True):
cmd = "cp %s %s" % (root_cpuset_cpus,
machine_cpuset_cpus)
process.system(cmd, verbose=True)
else:
logging.debug("No need recover the domain")
return bt
