def run(test, params, env):
"""
libvirt boot savevm test:
1) Start guest booting
2) Record origin informations of snapshot list for floppy(optional).
3) Periodically savevm/loadvm while guest booting
4) Stop test when able to login, or fail after timeout seconds.
5) Check snapshot list for floppy and compare with the origin
one(optional).
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
if params.get("with_floppy") == "yes":
floppy_name = params.get("floppies", "fl")
floppy_params = {
"image_format": params.get("floppy_format", "qcow2"),
"image_size": params.get("floppy_size", "1.4M"),
"image_name": params.get("%s_name" % floppy_name, "images/test"),
"vm_type": params.get("vm_type"),
"qemu_img_binary": utils_misc.get_qemu_img_binary(params)
}
floppy = qemu_storage.QemuImg(floppy_params, data_dir.get_data_dir(),
floppy_name)
floppy.create(floppy_params)
floppy_orig_info = floppy.snapshot_list()
vm.create(params=params)
vm.verify_alive() # This shouldn't require logging in to guest
savevm_delay = float(params["savevm_delay"])
savevm_login_delay = float(params["savevm_login_delay"])
savevm_login_timeout = float(params["savevm_timeout"])
savevm_statedir = params.get("savevm_statedir", tempfile.gettempdir())
fd, savevm_statefile = tempfile.mkstemp(suffix='.img',
prefix=vm.name + '-',
dir=savevm_statedir)
os.close(fd) # save_to_file doesn't need the file open
start_time = time.time()
cycles = 0
successful_login = False
while (time.time() - start_time) < savevm_login_timeout:
logging.info("Save/Restore cycle %d", cycles + 1)
time.sleep(savevm_delay)
vm.pause()
if params['save_method'] == 'save_to_file':
vm.save_to_file(savevm_statefile) # Re-use same filename
vm.restore_from_file(savevm_statefile)
else:
vm.savevm("1")
vm.loadvm("1")
vm.resume() # doesn't matter if already running or not
vm.verify_kernel_crash() # just in case
try:
vm.wait_for_login(timeout=savevm_login_delay)
successful_login = True # not set if timeout expires
os.unlink(savevm_statefile) # don't let these clutter disk
break
except:
pass # loop until successful login or time runs out
cycles += 1
time_elapsed = int(time.time() - start_time)
info = "after %s s, %d load/save cycles" % (time_elapsed, cycles + 1)
if not successful_login:
raise error.TestFail("Can't log on '%s' %s" % (vm.name, info))
else:
logging.info("Test ended %s", info)
if params.get("with_floppy") == "yes":
vm.destroy()
floppy_info = floppy.snapshot_list()
if floppy_info == floppy_orig_info:
raise error.TestFail("savevm didn't create snapshot in floppy."
" original snapshot list is: %s"
" now snapshot list is: %s" %
(floppy_orig_info, floppy_info))
def run(test, params, env):
"""
Test virsh snapshot command when disk in all kinds of type.
(1). Init the variables from params.
(2). Create a image by specifice format.
(3). Attach disk to vm.
(4). Snapshot create.
(5). Snapshot revert.
(6). cleanup.
"""
# Init variables.
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
image_format = params.get("snapshot_image_format", "qcow2")
snapshot_del_test = "yes" == params.get("snapshot_del_test", "no")
status_error = ("yes" == params.get("status_error", "no"))
snapshot_from_xml = ("yes" == params.get("snapshot_from_xml", "no"))
snapshot_current = ("yes" == params.get("snapshot_current", "no"))
snapshot_revert_paused = ("yes" == params.get("snapshot_revert_paused",
"no"))
# Pool variables.
snapshot_with_pool = "yes" == params.get("snapshot_with_pool", "no")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
emulated_image = params.get("emulated_image")
vol_name = params.get("vol_name")
vol_format = params.get("vol_format")
lazy_refcounts = "yes" == params.get("lazy_refcounts")
options = params.get("snapshot_options", "")
# Set volume xml attribute dictionary, extract all params start with 'vol_'
# which are for setting volume xml, except 'lazy_refcounts'.
vol_arg = {}
for key in params.keys():
if key.startswith('vol_'):
if key[4:] in ['capacity', 'allocation', 'owner', 'group']:
vol_arg[key[4:]] = int(params[key])
else:
vol_arg[key[4:]] = params[key]
vol_arg['lazy_refcounts'] = lazy_refcounts
supported_pool_list = [
"dir", "fs", "netfs", "logical", "iscsi", "disk", "gluster"
]
if snapshot_with_pool:
if pool_type not in supported_pool_list:
raise error.TestNAError("%s not in support list %s" %
(pool_target, supported_pool_list))
# Do xml backup for final recovery
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Some variable for xmlfile of snapshot.
snapshot_memory = params.get("snapshot_memory", "internal")
snapshot_disk = params.get("snapshot_disk", "internal")
# Skip 'qed' cases for libvirt version greater than 1.1.0
if libvirt_version.version_compare(1, 1, 0):
if vol_format == "qed":
raise error.TestNAError("QED support changed, check bug: "
"https://bugzilla.redhat.com/show_bug.cgi"
"?id=731570")
# Init snapshot_name
snapshot_name = None
snapshot_external_disk = []
snapshot_xml_path = None
del_status = None
image = None
pvt = None
# Get a tmp dir
tmp_dir = data_dir.get_tmp_dir()
snap_cfg_path = "/var/lib/libvirt/qemu/snapshot/%s/" % vm_name
try:
if snapshot_with_pool:
# Create dst pool for create attach vol img
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name,
pool_type,
pool_target,
emulated_image,
image_size="1G",
pre_disk_vol=["20M"])
if pool_type in ["iscsi", "disk"]:
# iscsi and disk pool did not support create volume in libvirt,
# logical pool could use libvirt to create volume but volume
# format is not supported and will be 'raw' as default.
pv = libvirt_storage.PoolVolume(pool_name)
vols = pv.list_volumes().keys()
if vols:
vol_name = vols[0]
else:
raise error.TestNAError("No volume in pool: %s", pool_name)
else:
# Set volume xml file
volxml = libvirt_xml.VolXML()
newvol = volxml.new_vol(**vol_arg)
vol_xml = newvol['xml']
# Run virsh_vol_create to create vol
logging.debug("create volume from xml: %s" %
newvol.xmltreefile)
cmd_result = virsh.vol_create(pool_name,
vol_xml,
ignore_status=True,
debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to create attach volume.")
cmd_result = virsh.vol_path(vol_name, pool_name, debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to get volume path from pool.")
img_path = cmd_result.stdout.strip()
if pool_type in ["logical", "iscsi", "disk"]:
# Use qemu-img to format logical, iscsi and disk block device
if vol_format != "raw":
cmd = "qemu-img create -f %s %s 10M" % (vol_format,
img_path)
cmd_result = utils.run(cmd, ignore_status=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to format volume, %s" %
cmd_result.stdout.strip())
extra = "--persistent --subdriver %s" % vol_format
else:
# Create a image.
params['image_name'] = "snapshot_test"
params['image_format'] = image_format
params['image_size'] = "1M"
image = qemu_storage.QemuImg(params, tmp_dir, "snapshot_test")
img_path, _ = image.create(params)
extra = "--persistent --subdriver %s" % image_format
# Do the attach action.
out = utils.run("qemu-img info %s" % img_path)
logging.debug("The img info is:\n%s" % out.stdout.strip())
result = virsh.attach_disk(vm_name,
source=img_path,
target="vdf",
extra=extra,
debug=True)
if result.exit_status:
raise error.TestNAError("Failed to attach disk %s to VM."
"Detail: %s." % (img_path, result.stderr))
# Create snapshot.
if snapshot_from_xml:
snapshot_name = "snapshot_test"
lines = [
"<domainsnapshot>\n",
"<name>%s</name>\n" % snapshot_name,
"<description>Snapshot Test</description>\n"
]
if snapshot_memory == "external":
memory_external = os.path.join(tmp_dir, "snapshot_memory")
snapshot_external_disk.append(memory_external)
lines.append("<memory snapshot=\'%s\' file='%s'/>\n" %
(snapshot_memory, memory_external))
else:
lines.append("<memory snapshot='%s'/>\n" % snapshot_memory)
# Add all disks into xml file.
disks = vm.get_disk_devices().values()
lines.append("<disks>\n")
for disk in disks:
lines.append("<disk name='%s' snapshot='%s'>\n" %
(disk['source'], snapshot_disk))
if snapshot_disk == "external":
snap_path = "%s.snap" % os.path.basename(disk['source'])
disk_external = os.path.join(tmp_dir, snap_path)
snapshot_external_disk.append(disk_external)
lines.append("<source file='%s'/>\n" % disk_external)
lines.append("</disk>\n")
lines.append("</disks>\n")
lines.append("</domainsnapshot>")
snapshot_xml_path = "%s/snapshot_xml" % tmp_dir
snapshot_xml_file = open(snapshot_xml_path, "w")
snapshot_xml_file.writelines(lines)
snapshot_xml_file.close()
logging.debug("The xml content for snapshot create is:")
with open(snapshot_xml_path, 'r') as fin:
logging.debug(fin.read())
options += " --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
out_err = snapshot_result.stderr.strip()
if snapshot_result.exit_status:
if status_error:
return
else:
if re.search(
"live disk snapshot not supported with this QEMU binary",
out_err):
raise error.TestNAError(out_err)
if libvirt_version.version_compare(1, 2, 5):
# As commit d2e668e in 1.2.5, internal active snapshot
# without memory state is rejected. Handle it as SKIP
# for now. This could be supportted in future by bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1103063
if re.search(
"internal snapshot of a running VM" +
" must include the memory state", out_err):
raise error.TestNAError("Check Bug #1083345, %s" %
out_err)
raise error.TestFail(
"Failed to create snapshot. Error:%s." % out_err)
else:
snapshot_result = virsh.snapshot_create(vm_name, options)
if snapshot_result.exit_status:
if status_error:
return
else:
raise error.TestFail(
"Failed to create snapshot. Error:%s." %
snapshot_result.stderr.strip())
snapshot_name = re.search("\d+",
snapshot_result.stdout.strip()).group(0)
if snapshot_current:
lines = [
"<domainsnapshot>\n",
"<description>Snapshot Test</description>\n",
"<state>running</state>\n",
"<creationTime>%s</creationTime>" % snapshot_name,
"</domainsnapshot>"
]
snapshot_xml_path = "%s/snapshot_xml" % tmp_dir
snapshot_xml_file = open(snapshot_xml_path, "w")
snapshot_xml_file.writelines(lines)
snapshot_xml_file.close()
logging.debug("The xml content for snapshot create is:")
with open(snapshot_xml_path, 'r') as fin:
logging.debug(fin.read())
options += "--redefine %s --current" % snapshot_xml_path
if snapshot_result.exit_status:
raise error.TestFail("Failed to create snapshot --current."
"Error:%s." %
snapshot_result.stderr.strip())
if status_error:
if not snapshot_del_test:
raise error.TestFail("Success to create snapshot in negative"
" case\nDetail: %s" % snapshot_result)
# Touch a file in VM.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
# Init a unique name for tmp_file.
tmp_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
tmp_file_path = tmp_file.name
tmp_file.close()
echo_cmd = "echo SNAPSHOT_DISK_TEST >> %s" % tmp_file_path
status, output = session.cmd_status_output(echo_cmd)
logging.debug("The echo output in domain is: '%s'", output)
if status:
raise error.TestFail("'%s' run failed with '%s'" %
(tmp_file_path, output))
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("File created with content: '%s'", output)
session.close()
# Destroy vm for snapshot revert.
if not libvirt_version.version_compare(1, 2, 3):
virsh.destroy(vm_name)
# Revert snapshot.
revert_options = ""
if snapshot_revert_paused:
revert_options += " --paused"
revert_result = virsh.snapshot_revert(vm_name,
snapshot_name,
revert_options,
debug=True)
if revert_result.exit_status:
# As commit d410e6f for libvirt 1.2.3, attempts to revert external
# snapshots will FAIL with an error "revert to external snapshot
# not supported yet". Thus, let's check for that and handle as a
# SKIP for now. Check bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1071264
if libvirt_version.version_compare(1, 2, 3):
if re.search("revert to external snapshot not supported yet",
revert_result.stderr):
raise error.TestNAError(revert_result.stderr.strip())
else:
raise error.TestFail("Revert snapshot failed. %s" %
revert_result.stderr.strip())
if vm.is_dead():
raise error.TestFail("Revert snapshot failed.")
if snapshot_revert_paused:
if vm.is_paused():
vm.resume()
else:
raise error.TestFail("Revert command successed, but VM is not "
"paused after reverting with --paused"
" option.")
# login vm.
session = vm.wait_for_login()
# Check the result of revert.
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("After revert cat file output='%s'", output)
if not status:
raise error.TestFail("Tmp file exists, revert failed.")
# Close the session.
session.close()
# Test delete snapshot without "--metadata", delete external disk
# snapshot will fail for now.
# Only do this when snapshot creat succeed which filtered in cfg file.
if snapshot_del_test:
if snapshot_name:
del_result = virsh.snapshot_delete(vm_name,
snapshot_name,
debug=True,
ignore_status=True)
del_status = del_result.exit_status
snap_xml_path = snap_cfg_path + "%s.xml" % snapshot_name
if del_status:
if not status_error:
raise error.TestFail("Failed to delete snapshot.")
else:
if not os.path.exists(snap_xml_path):
raise error.TestFail(
"Snapshot xml file %s missing" % snap_xml_path)
else:
if status_error:
err_msg = "Snapshot delete succeed but expect fail."
raise error.TestFail(err_msg)
else:
if os.path.exists(snap_xml_path):
raise error.TestFail("Snapshot xml file %s still" %
snap_xml_path + " exist")
finally:
virsh.detach_disk(vm_name, target="vdf", extra="--persistent")
if image:
image.remove()
if del_status and snapshot_name:
virsh.snapshot_delete(vm_name, snapshot_name, "--metadata")
for disk in snapshot_external_disk:
if os.path.exists(disk):
os.remove(disk)
vmxml_backup.sync("--snapshots-metadata")
if snapshot_xml_path:
if os.path.exists(snapshot_xml_path):
os.unlink(snapshot_xml_path)
if pvt:
try:
pvt.cleanup_pool(pool_name, pool_type, pool_target,
emulated_image)
except error.TestFail, detail:
logging.error(str(detail))
def run_linux_vm_check(test, params, env):
"""
Check VM after conversion
"""
target = params.get('target')
check_obj = utils_v2v.LinuxVMCheck(test, params, env)
logging.info("Check guest os info")
os_info = check_obj.get_vm_os_info()
os_vendor = check_obj.get_vm_os_vendor()
if os_vendor == 'Red Hat':
os_version = os_info.split()[6]
else:
raise error.TestFail("Only RHEL is supported now.")
logging.info("Check guest kernel after conversion")
kernel_version = check_obj.get_vm_kernel()
if re.search('xen', kernel_version):
raise error.TestFail("FAIL")
else:
logging.info("SUCCESS")
logging.info("Check parted info after conversion")
parted_info = check_obj.get_vm_parted()
if os_version != '3':
if re.findall('/dev/vd\S+', parted_info):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
logging.info("Check virtio_net module in modprobe conf")
modprobe_conf = check_obj.get_vm_modprobe_conf()
if not re.search('No such file', modprobe_conf):
virtio_mod = re.findall(r'(?m)^alias.*virtio', modprobe_conf)
net_blk_mod = re.findall(r'(?m)^alias\s+scsi|(?m)^alias\s+eth',
modprobe_conf)
if len(virtio_mod) == len(net_blk_mod):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
logging.info("Check virtio module")
modules = check_obj.get_vm_modules()
if os_version == '3':
if re.search("e1000|^ide", modules):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
elif re.search("virtio", modules):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
logging.info("Check virtio pci devices")
pci = check_obj.get_vm_pci_list()
if os_version != '3':
if (re.search('[Vv]irtio network', pci)
and re.search('[Vv]irtio block', pci)):
if target == "ovirt":
logging.info("SUCCESS")
elif (target != "ovirt" and re.search('[Vv]irtio memory', pci)):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
else:
raise error.TestFail("FAIL")
logging.info("Check in /etc/rc.local")
rc_output = check_obj.get_vm_rc_local()
if re.search('^[modprobe|insmod].*xen-vbd.*', rc_output):
raise error.TestFail("FAIL")
else:
logging.info("SUCCESS")
logging.info("Check vmware tools")
if check_obj.has_vmware_tools() == False:
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
logging.info("Check tty")
tty = check_obj.get_vm_tty()
if re.search('[xh]vc0', tty):
raise error.TestFail("FAIL")
else:
logging.info("SUCCESS")
logging.info("Check video")
video = check_obj.get_vm_video()
if not re.search('el6', kernel_version):
if re.search('cirrus', video):
logging.info("SUCCESS")
else:
raise error.TestFail("FAIL")
def test(self):
super(test_multihost_eject, self).test()
self.mount_dir = params.get("mount_dir", None)
format_floppy_cmd = params["format_floppy_cmd"]
floppy = params["floppy_name"]
second_floppy = params["second_floppy_name"]
if not os.path.isabs(floppy):
floppy = os.path.join(data_dir.get_data_dir(), floppy)
if not os.path.isabs(second_floppy):
second_floppy = os.path.join(data_dir.get_data_dir(),
second_floppy)
if not self.is_src:
self.floppy = create_floppy(params)
pid = None
sync_id = {'src': self.srchost,
'dst': self.dsthost,
"type": "file_trasfer"}
filename = "orig"
if self.is_src: # Starts in source
vm = env.get_vm(self.vms[0])
session = vm.wait_for_login(timeout=login_timeout)
if self.mount_dir: # If linux
session.cmd("rm -f %s" % (os.path.join(self.mount_dir,
filename)))
# If mount_dir specified, treat guest as a Linux OS
# Some Linux distribution does not load floppy at boot
# and Windows needs time to load and init floppy driver
error.context("Prepare floppy for writing.")
if self.mount_dir: # If linux
lsmod = session.cmd("lsmod")
if not 'floppy' in lsmod:
session.cmd("modprobe floppy")
else:
time.sleep(20)
if not floppy in vm.monitor.info("block"):
raise error.TestFail("Wrong floppy image is placed in vm.")
try:
session.cmd(format_floppy_cmd)
except aexpect.ShellCmdError, e:
if e.status == 1:
logging.error("First access to floppy failed, "
" Trying a second time as a workaround")
session.cmd(format_floppy_cmd)
error.context("Check floppy")
if self.mount_dir: # If linux
session.cmd("mount -t vfat %s %s" % (guest_floppy_path,
self.mount_dir), timeout=30)
session.cmd("umount %s" % (self.mount_dir), timeout=30)
written = None
if self.mount_dir:
filepath = os.path.join(self.mount_dir, "test.txt")
session.cmd("echo 'test' > %s" % (filepath))
output = session.cmd("cat %s" % (filepath))
written = "test\n"
else: # Windows version.
filepath = "A:\\test.txt"
session.cmd("echo test > %s" % (filepath))
output = session.cmd("type %s" % (filepath))
written = "test \n\n"
if output != written:
raise error.TestFail("Data read from the floppy differs"
"from the data written to it."
" EXPECTED: %s GOT: %s" %
(repr(written), repr(output)))
error.context("Change floppy.")
vm.monitor.cmd("eject floppy0")
vm.monitor.cmd("change floppy %s" % (second_floppy))
session.cmd(format_floppy_cmd)
error.context("Mount and copy data")
if self.mount_dir: # If linux
session.cmd("mount -t vfat %s %s" % (guest_floppy_path,
self.mount_dir), timeout=30)
if not second_floppy in vm.monitor.info("block"):
raise error.TestFail("Wrong floppy image is placed in vm.")
def run(test, params, env):
"""
Test virsh vol-create command to cover the following matrix:
pool_type = [dir, fs, netfs]
volume_format = [raw, bochs, cloop, cow, dmg, iso, qcow, qcow2, qed,
vmdk, vpc]
pool_type = [disk]
volume_format = [none, linux, fat16, fat32, linux-swap, linux-lvm,
linux-raid, extended]
pool_type = [logical]
volume_format = [none]
pool_type = [iscsi, scsi]
Not supported with format type
TODO:
pool_type = [rbd, glusterfs]
Reference: http://www.libvirt.org/storage.html
"""
src_pool_type = params.get("src_pool_type")
src_pool_target = params.get("src_pool_target")
src_emulated_image = params.get("src_emulated_image")
extra_option = params.get("extra_option", "")
vol_name = params.get("vol_name", "vol_create_test")
vol_format = params.get("vol_format")
lazy_refcounts = "yes" == params.get("lazy_refcounts")
status_error = "yes" == params.get("status_error", "no")
# Set volume xml attribute dictionary, extract all params start with 'vol_'
# which are for setting volume xml, except 'lazy_refcounts'.
vol_arg = {}
for key in params.keys():
if key.startswith('vol_'):
if key[4:] in ['capacity', 'allocation', 'owner', 'group']:
vol_arg[key[4:]] = int(params[key])
else:
vol_arg[key[4:]] = params[key]
vol_arg['lazy_refcounts'] = lazy_refcounts
pool_type = ['dir', 'disk', 'fs', 'logical', 'netfs', 'iscsi', 'scsi']
if src_pool_type not in pool_type:
raise error.TestNAError("pool type %s not in supported type list: %s" %
(src_pool_type, pool_type))
if not libvirt_version.version_compare(1, 0, 0):
if "--prealloc-metadata" in extra_option:
raise error.TestNAError("metadata preallocation not supported in" +
" current libvirt version.")
# libvirt acl polkit 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.")
try:
# Create the src pool
src_pool_name = "virt-%s-pool" % src_pool_type
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(src_pool_name,
src_pool_type,
src_pool_target,
src_emulated_image,
image_size="2G",
pre_disk_vol=["1M"])
# Print current pools for debugging
logging.debug("Current pools:%s",
libvirt_storage.StoragePool().list_pools())
# Set volume xml file
volxml = libvirt_xml.VolXML()
newvol = volxml.new_vol(**vol_arg)
vol_xml = newvol['xml']
if params.get('setup_libvirt_polkit') == 'yes':
utils.run("chmod 666 %s" % vol_xml, ignore_status=True)
# Run virsh_vol_create to create vol
logging.debug("create volume from xml: %s" % newvol.xmltreefile)
cmd_result = virsh.vol_create(src_pool_name,
vol_xml,
extra_option,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not status_error:
if not status:
src_pv = libvirt_storage.PoolVolume(src_pool_name)
src_volumes = src_pv.list_volumes().keys()
logging.debug("Current volumes in %s: %s", src_pool_name,
src_volumes)
if vol_name not in src_volumes:
raise error.TestFail(
"Can't find volume: %s from pool: %s" %
(vol_name, src_pool_name))
# check format in volume xml
post_xml = volxml.new_from_vol_dumpxml(vol_name, src_pool_name)
logging.debug("the created volume xml is: %s" %
post_xml.xmltreefile)
if 'format' in post_xml.keys():
if post_xml.format != vol_format:
raise error.TestFail(
"Volume format %s is not expected" % vol_format +
" as defined.")
else:
# Skip the format not supported by qemu-img error
if vol_format:
fmt_err = "Unknown file format '%s'" % vol_format
fmt_err1 = "Formatting or formatting option not "
fmt_err1 += "supported for file format '%s'" % vol_format
fmt_err2 = "Driver '%s' does not support " % vol_format
fmt_err2 += "image creation"
if "qemu-img" in cmd_result.stderr:
er = cmd_result.stderr
if fmt_err in er or fmt_err1 in er or fmt_err2 in er:
err_msg = "Volume format '%s' is not" % vol_format
err_msg += " supported by qemu-img."
raise error.TestNAError(err_msg)
else:
raise error.TestFail("Run failed with right command.")
else:
raise error.TestFail("Run failed with right command.")
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
raise error.TestFail("Expect fail, but run successfully!")
finally:
# Cleanup
try:
pvt.cleanup_pool(src_pool_name, src_pool_type, src_pool_target,
src_emulated_image)
except error.TestFail, detail:
logging.error(str(detail))
def run(test, params, env):
"""
Test command: virsh secret-define <file>
secret-undefine <secret>
The testcase is to define or modify a secret
from an XML file, then undefine it
"""
# MAIN TEST CODE ###
# Process cartesian parameters
secret_ref = params.get("secret_ref")
ephemeral = params.get("ephemeral_value", "no")
private = params.get("private_value", "no")
modify_volume = ("yes" == params.get("secret_modify_volume", "no"))
remove_uuid = ("yes" == params.get("secret_remove_uuid", "no"))
if secret_ref == "secret_valid_uuid":
# Generate valid uuid
cmd = "uuidgen"
status, uuid = commands.getstatusoutput(cmd)
if status:
raise error.TestNAError("Failed to generate valid uuid")
elif secret_ref == "secret_invalid_uuid":
uuid = params.get(secret_ref)
# libvirt acl related params
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
define_acl = "yes" == params.get("define_acl", "no")
undefine_acl = "yes" == params.get("undefine_acl", "no")
get_value_acl = "yes" == params.get("get_value_acl", "no")
define_error = "yes" == params.get("define_error", "no")
undefine_error = "yes" == params.get("undefine_error", "no")
get_value_error = "yes" == params.get("get_value_error", "no")
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.")
acl_dargs = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True
}
# Get a full path of tmpfile, the tmpfile need not exist
tmp_dir = data_dir.get_tmp_dir()
volume_path = os.path.join(tmp_dir, "secret_volume")
secret_xml_obj = SecretXML(ephemeral, private)
secret_xml_obj.uuid = uuid
secret_xml_obj.volume = volume_path
secret_xml_obj.usage = "volume"
secret_obj_xmlfile = os.path.join(SECRET_DIR, uuid + ".xml")
def check_exit_status(result, expect_error=False):
"""
Check the exit status of virsh commands.
:param result: Virsh command result object
:param expect_error: Boolean value, expect command success or fail
"""
if expect_error:
if result.exit_status == 0:
raise error.TestFail("Expect fail, but run successfully.")
else:
logging.debug("Command failed as expected.")
else:
if result.exit_status != 0:
raise error.TestFail(result.stderr)
# Run the test
try:
if define_acl:
utils.run("chmod 666 %s" % secret_xml_obj.xml)
cmd_result = virsh.secret_define(secret_xml_obj.xml, **acl_dargs)
else:
cmd_result = virsh.secret_define(secret_xml_obj.xml, debug=True)
check_exit_status(cmd_result, define_error)
if cmd_result.exit_status:
return
# Check ephemeral attribute
exist = os.path.exists(secret_obj_xmlfile)
if (ephemeral == "yes" and exist) or \
(ephemeral == "no" and not exist):
raise error.TestFail("The ephemeral attribute worked not expected")
# Check private attrbute
virsh.secret_set_value(uuid, SECRET_BASE64, debug=True)
if get_value_acl:
cmd_result = virsh.secret_get_value(uuid, **acl_dargs)
else:
cmd_result = virsh.secret_get_value(uuid, debug=True)
check_exit_status(cmd_result, get_value_error)
status = cmd_result.exit_status
err_msg = "The private attribute worked not expected"
if private == "yes" and not status:
raise error.TestFail(err_msg)
if private == "no" and status:
if not get_value_error:
raise error.TestFail(err_msg)
if modify_volume:
volume_path = os.path.join(tmp_dir, "secret_volume_modify")
secret_xml_obj.volume = volume_path
cmd_result = virsh.secret_define(secret_xml_obj.xml, debug=True)
if cmd_result.exit_status == 0:
raise error.TestFail("Expect fail on redefine after modify "
"volume, but success indeed")
if remove_uuid:
secret_xml_obj2 = SecretXML(ephemeral, private)
secret_xml_obj2.volume = volume_path
secret_xml_obj2.usage = "volume"
cmd_result = virsh.secret_define(secret_xml_obj2.xml, debug=True)
if cmd_result.exit_status == 0:
raise error.TestFail("Expect fail on redefine after remove "
"uuid, but success indeed")
if undefine_acl:
cmd_result = virsh.secret_undefine(uuid, **acl_dargs)
else:
cmd_result = virsh.secret_undefine(uuid, debug=True)
check_exit_status(cmd_result, undefine_error)
finally:
# cleanup
virsh.secret_undefine(uuid, ignore_status=True)
if os.path.exists(volume_path):
os.unlink(volume_path)
if os.path.exists(secret_obj_xmlfile):
os.unlink(secret_obj_xmlfile)
if self.mount_dir:
filepath = os.path.join(self.mount_dir, "test.txt")
session.cmd("echo 'test' > %s" % (filepath))
output = session.cmd("cat %s" % (filepath))
written = "test\n"
else: # Windows version.
filepath = "A:\\test.txt"
session.cmd("echo test > %s" % (filepath))
output = session.cmd("type %s" % (filepath))
written = "test \n\n"
if output != written:
raise error.TestFail("Data read from the floppy differs"
"from the data written to it."
" EXPECTED: %s GOT: %s" %
(repr(written), repr(output)))
self.mig._hosts_barrier(self.mig.hosts, self.mig.hosts,
'finish_floppy_test', login_timeout)
def clean(self):
super(test_multihost_eject, self).clean()
test_type = params.get("test_type", "test_singlehost")
if (test_type in locals()):
tests_group = locals()[test_type]
tests_group()
else:
raise error.TestFail("Test group '%s' is not defined in"
" migration_with_dst_problem test" % test_type)
if not self.kill_first:
if self.vm.is_dead():
self.vm.start()
try:
self.vm.wait_for_login()
except remote.LoginTimeoutError, detail:
raise error.TestFail(str(detail))
else:
virsh.remove_domain(self.vm_name)
if self.twice_execute or self.read_only:
self.td1 = threading.Thread(target=unattended_install.run,
args=(self.test, params, self.env))
self.td1.start()
self.td1.join()
if not virsh.domain_exists(self.vm_name):
raise error.TestFail("Domain '%s' installation failed!"
% self.vm_name)
def recover(self, params=None):
"""
Recover test environment
"""
if self.selinux_enforcing:
utils_selinux.set_status("enforcing")
if virsh.domain_exists(self.vm_name):
virsh.remove_domain(self.vm_name)
image_file = params.get("image_name")
if os.path.exists(image_file):
os.remove(image_file)
if os.path.isdir(self.image_path):
os.rmdir(self.image_path)
self.env.unregister_vm(self.vm_name)
def run(test, params, env):
"""
Verify guest NIC numbers again whats provided in test config file.
If the guest NICs info does not match whats in the params at first,
try to fix these by operating the networking config file.
1. Boot guest with multi NICs.
2. Check whether guest NICs info match with params setting.
3. Create configure file for every NIC interface in guest.
4. Reboot guest.
5. Check whether guest NICs info match with params setting.
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_nics_num(expect_c, session):
txt = "Check whether guest NICs info match with params setting."
error.context(txt, logging.info)
nics_list = utils_net.get_linux_ifname(session)
actual_c = len(nics_list)
msg = "Expected NICs count is: %d\n" % expect_c
msg += "Actual NICs count is: %d\n" % actual_c
if not expect_c == actual_c:
msg += "Nics count mismatch!\n"
return (False, msg)
return (True, msg + 'Nics count match')
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
# Redirect ifconfig output from guest to log file
log_file = os.path.join(test.debugdir, "ifconfig")
ifconfig_output = session.cmd("ifconfig")
log_file_object = open(log_file, "w")
log_file_object.write(ifconfig_output)
# Get the ethernet cards number from params
nics_num = len(params.objects("nics"))
logging.info("[ %s ] NICs card specified in config file" % nics_num)
# Pre-judgement for the ethernet interface
logging.debug(check_nics_num(nics_num, session)[1])
txt = "Create configure file for every NIC interface in guest."
error.context(txt, logging.info)
ifname_list = utils_net.get_linux_ifname(session)
ifcfg_path = "/etc/sysconfig/network-scripts/ifcfg-%s"
for ifname in ifname_list:
eth_config_path = ifcfg_path % ifname
eth_config = """DEVICE=%s
BOOTPROTO=dhcp
ONBOOT=yes
""" % ifname
cmd = "echo '%s' > %s" % (eth_config, eth_config_path)
s, o = session.get_command_status_output(cmd)
if s != 0:
err_msg = "Failed to create ether config file: %s\nReason is: %s"
raise error.TestError(err_msg % (eth_config_path, o))
# Reboot and check the configurations.
new_session = vm.reboot(session)
s, msg = check_nics_num(nics_num, new_session)
if not s:
raise error.TestFail(msg)
# NICs matched.
logging.info(msg)
def wait_for_migration():
if not utils_misc.wait_for(mig_finished, mig_timeout, 2, 2,
"Waiting for migration to finish"):
raise error.TestFail("Timeout expired while waiting for migration "
"to finish")
if device_count_after_shutdown < device_count_before_cmd:
check_count_after_shutdown = False
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml.sync()
if test_block_dev:
libvirt.setup_or_cleanup_iscsi(False)
elif os.path.exists(device_source):
os.remove(device_source)
# Check results.
if status_error:
if not status:
raise error.TestFail("detach-device exit with unexpected value.")
else:
if status:
raise error.TestFail("virsh detach-device failed.")
if dt_options.count("config"):
if check_count_after_shutdown:
raise error.TestFail("See config detached device in "
"xml file after VM shutdown.")
if pre_vm_state == "shut off":
if check_count_after_cmd:
raise error.TestFail("See device in xml after detach with"
" --config option")
elif pre_vm_state == "running":
if not check_vm_after_cmd and device in ['disk', 'cdrom']:
raise error.TestFail("Cannot see device in VM after"
" detach with '--config' option"
def verify_guest_down(self, **args):
# Make sure the VM goes down
error.context("Wait for guest goes down after suspend")
suspend_timeout = 240 + int(self.params.get("smp")) * 60
if not utils_misc.wait_for(self.vm.is_dead, suspend_timeout, 2, 2):
raise error.TestFail("VM refuses to go down. Suspend failed.")
def migrate(vm,
env=None,
mig_timeout=3600,
mig_protocol="tcp",
mig_cancel=False,
offline=False,
stable_check=False,
clean=False,
save_path=None,
dest_host='localhost',
mig_port=None):
"""
Migrate a VM locally and re-register it in the environment.
:param vm: The VM to migrate.
:param env: The environment dictionary. If omitted, the migrated VM will
not be registered.
:param mig_timeout: timeout value for migration.
:param mig_protocol: migration protocol
:param mig_cancel: Test migrate_cancel or not when protocol is tcp.
:param dest_host: Destination host (defaults to 'localhost').
:param mig_port: Port that will be used for migration.
:return: The post-migration VM, in case of same host migration, True in
case of multi-host migration.
"""
def mig_finished():
try:
o = vm.monitor.info("migrate")
if isinstance(o, str):
return "status: active" not in o
else:
return o.get("status") != "active"
except Exception:
pass
def mig_succeeded():
o = vm.monitor.info("migrate")
if isinstance(o, str):
return "status: completed" in o
else:
return o.get("status") == "completed"
def mig_failed():
o = vm.monitor.info("migrate")
if isinstance(o, str):
return "status: failed" in o
else:
return o.get("status") == "failed"
def mig_cancelled():
o = vm.monitor.info("migrate")
if isinstance(o, str):
return ("Migration status: cancelled" in o
or "Migration status: canceled" in o)
else:
return (o.get("status") == "cancelled"
or o.get("status") == "canceled")
def wait_for_migration():
if not utils_misc.wait_for(mig_finished, mig_timeout, 2, 2,
"Waiting for migration to finish"):
raise error.TestFail("Timeout expired while waiting for migration "
"to finish")
if dest_host == 'localhost':
dest_vm = vm.clone()
if (dest_host == 'localhost') and stable_check:
# Pause the dest vm after creation
dest_vm.params['extra_params'] = (
dest_vm.params.get('extra_params', '') + ' -S')
if dest_host == 'localhost':
dest_vm.create(migration_mode=mig_protocol, mac_source=vm)
try:
try:
if mig_protocol in ["tcp", "rdma", "x-rdma"]:
if dest_host == 'localhost':
uri = mig_protocol + ":0:%d" % dest_vm.migration_port
else:
uri = mig_protocol + ':%s:%d' % (dest_host, mig_port)
elif mig_protocol == "unix":
uri = "unix:%s" % dest_vm.migration_file
elif mig_protocol == "exec":
uri = '"exec:nc localhost %s"' % dest_vm.migration_port
if offline:
vm.pause()
vm.monitor.migrate(uri)
if mig_cancel:
time.sleep(2)
vm.monitor.cmd("migrate_cancel")
if not utils_misc.wait_for(
mig_cancelled, 60, 2, 2, "Waiting for migration "
"cancellation"):
raise error.TestFail("Failed to cancel migration")
if offline:
vm.resume()
if dest_host == 'localhost':
dest_vm.destroy(gracefully=False)
return vm
else:
wait_for_migration()
if (dest_host == 'localhost') and stable_check:
save_path = None or "/tmp"
save1 = os.path.join(save_path, "src")
save2 = os.path.join(save_path, "dst")
vm.save_to_file(save1)
dest_vm.save_to_file(save2)
# Fail if we see deltas
md5_save1 = utils.hash_file(save1)
md5_save2 = utils.hash_file(save2)
if md5_save1 != md5_save2:
raise error.TestFail("Mismatch of VM state before "
"and after migration")
if (dest_host == 'localhost') and offline:
dest_vm.resume()
except Exception:
if dest_host == 'localhost':
dest_vm.destroy()
raise
finally:
if (dest_host == 'localhost') and stable_check and clean:
logging.debug("Cleaning the state files")
if os.path.isfile(save1):
os.remove(save1)
if os.path.isfile(save2):
os.remove(save2)
# Report migration status
if mig_succeeded():
logging.info("Migration finished successfully")
elif mig_failed():
raise error.TestFail("Migration failed")
else:
status = vm.monitor.info("migrate")
raise error.TestFail("Migration ended with unknown status: %s" %
status)
if dest_host == 'localhost':
if dest_vm.monitor.verify_status("paused"):
logging.debug("Destination VM is paused, resuming it")
dest_vm.resume()
# Kill the source VM
vm.destroy(gracefully=False)
# Replace the source VM with the new cloned VM
if (dest_host == 'localhost') and (env is not None):
env.register_vm(vm.name, dest_vm)
# Return the new cloned VM
if dest_host == 'localhost':
return dest_vm
else:
return vm
def gagent_check_fstrim(self, test, params, env):
"""
Execute "guest-fstrim" command to guest agent
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def get_host_scsi_disk():
"""
Get latest scsi disk which enulated by scsi_debug module
Return the device name and the id in host
"""
scsi_disk_info = process.system_output(
avo_path.find_command('lsscsi'), shell=True).splitlines()
scsi_debug = [_ for _ in scsi_disk_info if 'scsi_debug' in _][-1]
scsi_debug = scsi_debug.split()
host_id = scsi_debug[0][1:-1]
device_name = scsi_debug[-1]
return (host_id, device_name)
def get_guest_discard_disk(session):
"""
Get disk without partitions in guest.
"""
list_disk_cmd = "ls /dev/[sh]d*|sed 's/[0-9]//p'|uniq -u"
disk = session.cmd_output(list_disk_cmd).splitlines()[0]
return disk
def get_provisioning_mode(device, host_id):
"""
Get disk provisioning mode, value usually is 'writesame_16',
depends on params for scsi_debug module.
"""
device_name = os.path.basename(device)
path = "/sys/block/%s/device/scsi_disk" % device_name
path += "/%s/provisioning_mode" % host_id
return utils.read_one_line(path).strip()
def get_allocation_bitmap():
"""
get block allocation bitmap
"""
path = "/sys/bus/pseudo/drivers/scsi_debug/map"
try:
return utils.read_one_line(path).strip()
except IOError:
logging.warn("could not get bitmap info, path '%s' is "
"not exist", path)
return ""
for vm in env.get_all_vms():
if vm:
vm.destroy()
env.unregister_vm(vm.name)
host_id, disk_name = get_host_scsi_disk()
provisioning_mode = get_provisioning_mode(disk_name, host_id)
logging.info("Current provisioning_mode = '%s'", provisioning_mode)
bitmap = get_allocation_bitmap()
if bitmap:
logging.debug("block allocation bitmap: %s" % bitmap)
raise error.TestError("block allocation bitmap"
" not empty before test.")
vm_name = params["main_vm"]
test_image = "scsi_debug"
params["start_vm"] = "yes"
params["image_name_%s" % test_image] = disk_name
params["image_format_%s" % test_image] = "raw"
params["image_raw_device_%s" % test_image] = "yes"
params["force_create_image_%s" % test_image] = "no"
params["drive_format_%s" % test_image] = "scsi-block"
params["drv_extra_params_%s" % test_image] = "discard=on"
params["images"] = " ".join([params["images"], test_image])
error_context.context("boot guest with disk '%s'" % disk_name, logging.info)
env_process.preprocess_vm(test, params, env, vm_name)
self.setup(test, params, env)
timeout = float(params.get("login_timeout", 240))
session = self.vm.wait_for_login(timeout=timeout)
device_name = get_guest_discard_disk(session)
error_context.context("format disk '%s' in guest" % device_name, logging.info)
format_disk_cmd = params["format_disk_cmd"]
format_disk_cmd = format_disk_cmd.replace("DISK", device_name)
session.cmd(format_disk_cmd)
error_context.context("mount disk with discard options '%s'" % device_name,
logging.info)
mount_disk_cmd = params["mount_disk_cmd"]
mount_disk_cmd = mount_disk_cmd.replace("DISK", device_name)
session.cmd(mount_disk_cmd)
error_context.context("write the disk with dd command", logging.info)
write_disk_cmd = params["write_disk_cmd"]
session.cmd(write_disk_cmd)
error_context.context("Delete the file created before on disk", logging.info)
delete_file_cmd = params["delete_file_cmd"]
session.cmd(delete_file_cmd)
# check the bitmap before trim
bitmap_before_trim = get_allocation_bitmap()
if not re.match(r"\d+-\d+", bitmap_before_trim):
raise error.TestFail("didn't get the bitmap of the target disk")
error_context.context("the bitmap_before_trim is %s" % bitmap_before_trim,
logging.info)
total_block_before_trim = abs(sum([eval(i) for i in
bitmap_before_trim.split(',')]))
error_context.context("the total_block_before_trim is %d"
% total_block_before_trim, logging.info)
error_context.context("execute the guest-fstrim cmd", logging.info)
self.gagent.fstrim()
# check the bitmap after trim
bitmap_after_trim = get_allocation_bitmap()
if not re.match(r"\d+-\d+", bitmap_after_trim):
raise error.TestFail("didn't get the bitmap of the target disk")
error_context.context("the bitmap_after_trim is %s" % bitmap_after_trim,
logging.info)
total_block_after_trim = abs(sum([eval(i) for i in
bitmap_after_trim.split(',')]))
error_context.context("the total_block_after_trim is %d"
% total_block_after_trim, logging.info)
if total_block_after_trim > total_block_before_trim:
raise error.TestFail("the bitmap_after_trim is lager, the command"
" guest-fstrim may not work")
if self.vm:
self.vm.destroy()
else:
expected_mem = int(dargs["size"])
print_debug_stats(original_vmxml_mem, original_dominfo_mem,
expected_mem, test_vmxml_mem, test_dominfo_mem)
else:
if vm.state() == "paused":
vm.resume()
finally:
original_vmxml.sync()
# Don't care about memory comparison on error test
if status_error:
if status is 0:
raise error.TestFail("Error test did not result in an error.")
else:
vmxml_match = (test_vmxml_mem == expected_mem)
if xen_host:
dominfo_match = is_in_range(test_dominfo_mem, expected_mem,
delta_per)
else:
dominfo_match = (test_dominfo_mem == expected_mem)
if (status or start_status or not vmxml_match or not dominfo_match):
msg = "test conditions not met: "
if status:
msg += "Non-zero virsh setmaxmem exit code. "
if not vmxml_match:
msg += "Max memory in VM's xml is not matched. "
if not dominfo_match:
msg += "Max memory in dominfo's output is not matched. "
def run_nic_hotplug(test, params, env):
"""
Test hotplug of NIC devices
1) Boot up guest with one nic
2) Add a host network device through monitor cmd and check if it's added
3) Add nic device through monitor cmd and check if it's added
4) Check if new interface gets ip address
5) Disable primary link of guest
6) Ping guest new ip from host
7) Delete nic device and netdev
8) Re-enable primary link of guest
BEWARE OF THE NETWORK BRIDGE DEVICE USED FOR THIS TEST ("nettype=bridge"
and "netdst=<bridgename>" param). The KVM autotest default bridge virbr0,
leveraging libvirt, works fine for the purpose of this test. When using
other bridges, the timeouts which usually happen when the bridge
topology changes (that is, devices get added and removed) may cause random
failures.
@param test: KVM test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
vm = utils_test.get_living_vm(env, params.get("main_vm"))
login_timeout = int(params.get("login_timeout", 360))
pci_model = params.get("pci_model", "rtl8139")
run_dhclient = params.get("run_dhclient", "no")
netdst = params.get("netdst", "virbr0")
guest_is_not_windows = "Win" not in params.get("guest_name", "")
session = utils_test.wait_for_login(vm, timeout=login_timeout)
udev_rules_path = "/etc/udev/rules.d/70-persistent-net.rules"
udev_rules_bkp_path = "/tmp/70-persistent-net.rules"
def guest_path_isfile(path):
try:
session.cmd("test -f %s" % path)
except aexpect.ShellError:
return False
return True
if guest_is_not_windows:
if guest_path_isfile(udev_rules_path):
session.cmd("mv -f %s %s" % (udev_rules_path, udev_rules_bkp_path))
# Modprobe the module if specified in config file
module = params.get("modprobe_module")
if module:
session.get_command_output("modprobe %s" % module)
# hot-add the nic
nic_name = 'hotadded'
nic_info = vm.hotplug_nic(nic_model=pci_model, nic_name=nic_name,
netdst=netdst)
# Only run dhclient if explicitly set and guest is not running Windows.
# Most modern Linux guests run NetworkManager, and thus do not need this.
if run_dhclient == "yes" and guest_is_not_windows:
session_serial = vm.wait_for_serial_login(timeout=login_timeout)
ifname = utils_test.get_linux_ifname(session, nic_info['mac'])
session_serial.cmd("dhclient %s &" % ifname)
logging.info("Shutting down the primary link(s)")
for nic in vm.virtnet:
if nic.nic_name == nic_name:
continue
else:
vm.monitor.cmd("set_link %s off" % nic.device_id)
try:
logging.info("Waiting for new nic's ip address acquisition...")
try:
ip = vm.wait_for_get_address(nic_name)
except virt_vm.VMIPAddressMissingError:
raise error.TestFail("Could not get or verify ip address of nic")
logging.info("Got the ip address of new nic: %s", ip)
logging.info("Ping test the new nic ...")
s, o = utils_test.ping(ip, 100)
if s != 0:
logging.error(o)
raise error.TestFail("New nic failed ping test")
logging.info("Detaching the previously attached nic from vm")
vm.hotunplug_nic(nic_name)
finally:
logging.info("Re-enabling the primary link(s)")
for nic in vm.virtnet:
if nic.nic_name == nic_name:
continue
else:
vm.monitor.cmd("set_link %s on" % nic.device_id)
# Attempt to put back udev network naming rules, even if the command to
# disable the rules failed. We may be undoing what was done in a previous
# (failed) test that never reached this point.
if guest_is_not_windows:
if guest_path_isfile(udev_rules_bkp_path):
session.cmd("mv -f %s %s" % (udev_rules_bkp_path, udev_rules_path))
def run(test, params, env):
"""
Test domfstrim command, make sure that all supported options work well
Test scenaries:
1. fstrim without options
2. fstrim with --minimum with large options
3. fstrim with --minimum with small options
Note: --mountpoint still not supported so will not test here
"""
def recompose_xml(vm_name, scsi_disk):
"""
Add scsi disk, guest agent and scsi controller for guest
:param: vm_name: Name of domain
:param: scsi_disk: scsi_debug disk name
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_path = scsi_disk
# Add scsi disk xml
scsi_disk = Disk(type_name="block")
scsi_disk.device = "lun"
scsi_disk.source = scsi_disk.new_disk_source(
**{'attrs': {'dev': disk_path}})
scsi_disk.target = {'dev': "sdb", 'bus': "scsi"}
find_scsi = "no"
controllers = vmxml.xmltreefile.findall("devices/controller")
for controller in controllers:
if controller.get("type") == "scsi":
find_scsi = "yes"
vmxml.add_device(scsi_disk)
# Add scsi disk controller
if find_scsi == "no":
scsi_controller = Controller("controller")
scsi_controller.type = "scsi"
scsi_controller.index = "0"
scsi_controller.model = "virtio-scsi"
vmxml.add_device(scsi_controller)
# Redefine guest
vmxml.sync()
if not virsh.has_help_command('domfstrim'):
raise error.TestNAError("This version of libvirt does not support "
"the domfstrim test")
try:
utils_path.find_command("lsscsi")
except utils_path.CmdNotFoundError:
raise error.TestNAError("Command 'lsscsi' is missing. You must "
"install it.")
vm_name = params.get("main_vm", "avocado-vt-vm1")
status_error = ("yes" == params.get("status_error", "no"))
minimum = params.get("domfstrim_minimum")
mountpoint = params.get("domfstrim_mountpoint")
options = params.get("domfstrim_options", "")
is_fulltrim = ("yes" == params.get("is_fulltrim", "yes"))
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
has_qemu_ga = not ("yes" == params.get("no_qemu_ga", "no"))
start_qemu_ga = not ("yes" == params.get("no_start_qemu_ga", "no"))
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.")
# Do backup for origin xml
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
vm = env.get_vm(vm_name)
if not vm.is_alive():
vm.start()
session = vm.wait_for_login()
bef_list = session.cmd_output("fdisk -l|grep ^/dev|"
"cut -d' ' -f1").split("\n")
session.close()
vm.destroy()
# Load module and get scsi disk name
utils.load_module("scsi_debug lbpu=1 lbpws=1")
scsi_disk = utils.run("lsscsi|grep scsi_debug|"
"awk '{print $6}'").stdout.strip()
# Create partition
open("/tmp/fdisk-cmd", "w").write("n\np\n\n\n\nw\n")
output = utils.run("fdisk %s < /tmp/fdisk-cmd"
% scsi_disk).stdout.strip()
logging.debug("fdisk output %s", output)
os.remove("/tmp/fdisk-cmd")
# Format disk
output = utils.run("mkfs.ext3 %s1" % scsi_disk).stdout.strip()
logging.debug("output %s", output)
# Add scsi disk in guest
recompose_xml(vm_name, scsi_disk)
# Prepare guest agent and start guest
if has_qemu_ga:
vm.prepare_guest_agent(start=start_qemu_ga)
else:
# Remove qemu-ga channel
vm.prepare_guest_agent(channel=has_qemu_ga, start=False)
guest_session = vm.wait_for_login()
# Get new generated disk
af_list = guest_session.cmd_output("fdisk -l|grep ^/dev|"
"cut -d' ' -f1").split('\n')
new_disk = "".join(list(set(bef_list) ^ set(af_list)))
# Mount disk in guest
guest_session.cmd("mkdir -p /home/test && mount %s /home/test" %
new_disk)
# Do first fstrim before all to get original map for compare
cmd_result = virsh.domfstrim(vm_name)
if cmd_result.exit_status != 0:
if not status_error:
raise error.TestFail("Fail to do virsh domfstrim, error %s" %
cmd_result.stderr)
def get_diskmap_size():
"""
Collect size from disk map
:return: disk size
"""
map_cmd = "cat /sys/bus/pseudo/drivers/scsi_debug/map"
diskmap = utils.run(map_cmd).stdout.strip('\n\x00')
sum = 0
for i in diskmap.split(","):
sum = sum + int(i.split("-")[1]) - int(i.split("-")[0])
logging.debug("disk map (size:%d) is %s", sum, diskmap)
return sum
ori_size = get_diskmap_size()
# Write date in disk
dd_cmd = "dd if=/dev/zero of=/home/test/file bs=1048576 count=5; sync"
guest_session.cmd(dd_cmd)
def _full_mapped():
"""
Do full map check
:return: True or False
"""
full_size = get_diskmap_size()
return (ori_size < full_size)
if not utils_misc.wait_for(_full_mapped, timeout=30):
raise error.TestError("Scsi map is not updated after dd command.")
full_size = get_diskmap_size()
# Remove disk content in guest
guest_session.cmd("rm -rf /home/test/*; sync")
guest_session.close()
def _trim_completed():
"""
Do empty fstrim check
:return: True of False
"""
cmd_result = virsh.domfstrim(vm_name, minimum, mountpoint, options,
unprivileged_user=unprivileged_user,
uri=uri)
if cmd_result.exit_status != 0:
if not status_error:
raise error.TestFail("Fail to do virsh domfstrim, error %s"
% cmd_result.stderr)
else:
logging.info("Fail to do virsh domfstrim as expected: %s",
cmd_result.stderr)
return True
empty_size = get_diskmap_size()
logging.info("Trimmed disk to %d", empty_size)
if is_fulltrim:
return empty_size <= ori_size
else:
# For partly trim will check later
return False
if not utils_misc.wait_for(_trim_completed, timeout=30):
# Get result again to check partly fstrim
empty_size = get_diskmap_size()
if not is_fulltrim:
if ori_size < empty_size <= full_size:
logging.info("Success to do fstrim partly")
return True
raise error.TestFail("Fail to do fstrim. (original size: %s), "
"(current size: %s), (full size: %s)" %
(ori_size, empty_size, full_size))
logging.info("Success to do fstrim")
finally:
# Do domain recovery
vm.shutdown()
xml_backup.sync()
utils.unload_module("scsi_debug")
session = utils_test.wait_for_login(vm, timeout=login_timeout)
fragment_host_memory(mem_path)
total = get_mem_stat('MemTotal')
hugepagesize = get_mem_stat('Hugepagesize')
nr_full = int(0.8 * (total / hugepagesize))
nr_hp_before = set_libhugetlbfs(nr_full)
error.context("activating khugepaged defrag functionality")
change_feature_status("on", "khugepaged/defrag", test_config)
change_feature_status("on", "defrag", test_config)
sleep_time = 10
logging.debug("Sleeping %s s to settle things out" % sleep_time)
time.sleep(sleep_time)
nr_hp_after = set_libhugetlbfs(nr_full)
if nr_hp_before >= nr_hp_after:
raise error.TestFail("No memory defragmentation on host: "
"%s huge pages before turning "
"khugepaged defrag on, %s after it" %
(nr_hp_before, nr_hp_after))
logging.info("Defrag test succeeded")
session.close()
finally:
logging.debug("Cleaning up libhugetlbfs on host")
set_libhugetlbfs(0)
def run(test, params, env):
"""
Test svirt in virt-install.
(1). Init variables.
(2). Set selinux on host.
(3). Set label of image.
(4). run a virt-install command.
(5). clean up.
As this test only care whether the qemu-kvm process
can access the image. It is not necessary to install
a full os in a vm. Just verify the vm is alive after
virt-install command is enough. Then we can save a lot
of time and make this test independent from unattended_install.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("host_selinux", "enforcing")
# Get variables about seclabel for VM.
sec_type = params.get("svirt_install_vm_sec_type", "dynamic")
sec_model = params.get("svirt_install_vm_sec_model", "selinux")
sec_label = params.get("svirt_install_vm_sec_label", None)
sec_relabel = params.get("svirt_install_vm_sec_relabel", "yes")
# Set selinux status on host.
backup_sestatus = utils_selinux.get_status()
utils_selinux.set_status(host_sestatus)
# Set the image label.
disk_label = params.get("svirt_install_disk_label", None)
vm_name = params.get("main_vm", None)
# svirt will prevent accessing via a symble link.
data_path = data_dir.get_data_dir()
real_data_path = os.path.realpath(data_path)
image_path = os.path.join(real_data_path, "svirt_image")
if virsh.domain_exists(vm_name):
virsh.remove_domain(vm_name)
if not os.path.exists(image_path):
utils_test.libvirt.create_local_disk("file", path=image_path)
try:
utils_selinux.set_context_of_file(image_path, disk_label)
cmd = "virt-install --name %s --import --disk path=%s --ram '1024' " % (
vm_name, image_path)
cmd += " --security"
if sec_type == 'static':
if sec_label is None:
raise ValueError("Seclabel is not setted for static.")
cmd += " type=static,label=%s" % (sec_label)
elif sec_type == 'dynamic':
cmd += " type=dynamic"
else:
raise ValueError("Security type %s is not supported." % sec_type)
if sec_relabel is not None:
cmd += ",relabel=%s" % sec_relabel
cmd += " --noautoconsole --graphics vnc &"
utils.run(cmd, ignore_status=True)
def _vm_alive():
return virsh.is_alive(vm_name)
if (utils_misc.wait_for(_vm_alive, timeout=5)):
if status_error:
raise error.TestFail('Test succeeded in negative case.')
else:
if not status_error:
raise error.TestFail("Test failed in positive case.")
finally:
# cleanup
utils_selinux.set_status(backup_sestatus)
if virsh.domain_exists(vm_name):
virsh.remove_domain(vm_name)
if not os.path.exists(image_path):
utils_test.libvirt.delete_local_disk("file", path=image_path)
def run_virsh_capabilities(test, params, env):
"""
Test the command virsh capabilities
(1) Call virsh capabilities
(2) Call virsh capabilities with an unexpected option
(3) Call virsh capabilities with libvirtd service stop
"""
def compare_capabilities_xml(source):
dom = parseString(source)
host = dom.getElementsByTagName('host')[0]
# check that host has a non-empty UUID tag.
uuid = host.getElementsByTagName('uuid')[0]
host_uuid_output = uuid.firstChild.data
logging.info("Host uuid (capabilities_xml):%s", host_uuid_output)
if host_uuid_output == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# check the host arch.
arch = host.getElementsByTagName('arch')[0]
host_arch_output = arch.firstChild.data
logging.info("Host arch (capabilities_xml):%s", host_arch_output)
cmd_result = utils.run("arch", ignore_status=True)
if cmp(host_arch_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("The host arch in capabilities_xml is wrong!")
# check the host cpus num.
cpus = dom.getElementsByTagName('cpus')[0]
host_cpus_output = cpus.getAttribute('num')
logging.info("Host cpus num (capabilities_xml):%s",
host_cpus_output)
cmd = "less /proc/cpuinfo | grep processor | wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
if cmp(host_cpus_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("Host cpus num (capabilities_xml) is "
"wrong")
# check the arch of guest supported.
cmd = "/usr/libexec/qemu-kvm --cpu ? | grep qemu"
cmd_result = utils.run(cmd, ignore_status=True)
guest_wordsize_array = dom.getElementsByTagName('wordsize')
length = len(guest_wordsize_array)
for i in range(length):
element = guest_wordsize_array[i]
guest_wordsize = element.firstChild.data
logging.info("Arch of guest supported (capabilities_xml):%s",
guest_wordsize)
if not re.search(guest_wordsize, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an extra arch "
"of guest to support!")
# check the type of hyperviosr.
guest_domain_type = dom.getElementsByTagName('domain')[0]
guest_domain_type_output = guest_domain_type.getAttribute('type')
logging.info("Hypervisor (capabilities_xml):%s",
guest_domain_type_output)
cmd_result = utils.run("virsh uri", ignore_status=True)
if not re.search(guest_domain_type_output, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an different "
"hypervisor")
connect_uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default") )
# Prepare libvirtd service
if params.has_key("libvirtd"):
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Run test case
option = params.get("virsh_cap_options")
try:
output = virsh.capabilities(option, uri=connect_uri,
ignore_status=False, debug=True)
status = 0 # good
except error.CmdError:
status = 1 # bad
output = ''
# Recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail("Command 'virsh capabilities' succeeded "
"with libvirtd service stopped, incorrect")
else:
raise error.TestFail("Command 'virsh capabilities %s' succeeded "
"(incorrect command)" % option)
elif status_error == "no":
compare_capabilities_xml(output)
if status != 0:
raise error.TestFail("Command 'virsh capabilities %s' failed "
"(correct command)" % option)
def test(self):
super(test_multihost_write, self).test()
copy_timeout = int(params.get("copy_timeout", 480))
self.mount_dir = params["mount_dir"]
format_floppy_cmd = params["format_floppy_cmd"]
check_copy_path = params["check_copy_path"]
pid = None
sync_id = {'src': self.srchost,
'dst': self.dsthost,
"type": "file_trasfer"}
filename = "orig"
if self.is_src: # Starts in source
vm = env.get_vm(self.vms[0])
session = vm.wait_for_login(timeout=login_timeout)
if self.mount_dir:
session.cmd("rm -f %s" % (os.path.join(self.mount_dir,
filename)))
session.cmd("rm -f %s" % (check_copy_path))
# If mount_dir specified, treat guest as a Linux OS
# Some Linux distribution does not load floppy at boot
# and Windows needs time to load and init floppy driver
error.context("Prepare floppy for writing.")
if self.mount_dir:
lsmod = session.cmd("lsmod")
if not 'floppy' in lsmod:
session.cmd("modprobe floppy")
else:
time.sleep(20)
session.cmd(format_floppy_cmd)
error.context("Mount and copy data")
if self.mount_dir:
session.cmd("mount -t vfat %s %s" % (guest_floppy_path,
self.mount_dir),
timeout=30)
error.context("File copying test")
pid = lazy_copy(vm, os.path.join(self.mount_dir, filename),
check_copy_path, copy_timeout)
sync = SyncData(self.mig.master_id(), self.mig.hostid,
self.mig.hosts, sync_id, self.mig.sync_server)
pid = sync.sync(pid, timeout=floppy_prepare_timeout)[self.srchost]
self.mig.migrate_wait([self.vms[0]], self.srchost, self.dsthost)
if not self.is_src: # Starts in destination
vm = env.get_vm(self.vms[0])
session = vm.wait_for_login(timeout=login_timeout)
error.context("Wait for copy finishing.")
status = int(session.cmd_status("kill %s" % pid,
timeout=copy_timeout))
if not status in [0]:
raise error.TestFail("Copy process was terminatted with"
" error code %s" % (status))
session.cmd_status("kill -s SIGINT %s" % (pid),
timeout=copy_timeout)
error.context("Check floppy file checksum.")
md5_cmd = params.get("md5_cmd")
if md5_cmd:
md5_floppy = session.cmd("%s %s" % (params.get("md5_cmd"),
os.path.join(self.mount_dir, filename)))
try:
md5_floppy = md5_floppy.split(" ")[0]
except IndexError:
error.TestError("Failed to get md5 from source file,"
" output: '%s'" % md5_floppy)
md5_check = session.cmd("%s %s" % (params.get("md5_cmd"),
check_copy_path))
try:
md5_check = md5_check.split(" ")[0]
except IndexError:
error.TestError("Failed to get md5 from source file,"
" output: '%s'" % md5_floppy)
if md5_check != md5_floppy:
raise error.TestFail("There is mistake in copying,"
" it is possible to check file on vm.")
session.cmd("rm -f %s" % (os.path.join(self.mount_dir,
filename)))
session.cmd("rm -f %s" % (check_copy_path))
self.mig._hosts_barrier(self.mig.hosts, self.mig.hosts,
'finish_floppy_test', login_timeout)
def run(test, params, env):
"""
Test command: virsh setmem.
1) Prepare vm environment.
2) Handle params
3) Prepare libvirtd status.
4) Run test command and wait for current memory's stable.
5) Recover environment.
4) Check result.
"""
def vm_proc_meminfo(session):
"""
Get guest total memory
"""
proc_meminfo = session.cmd_output("cat /proc/meminfo")
# verify format and units are expected
return int(
re.search(r'MemTotal:\s+(\d+)\s+[kK]B', proc_meminfo).group(1))
def make_domref(domarg, vm_ref, domid, vm_name, domuuid):
"""
Create domain options of command
"""
# Specify domain as argument or parameter
if domarg == "yes":
dom_darg_key = "domainarg"
else:
dom_darg_key = "domain"
# How to reference domain
if vm_ref == "domid":
dom_darg_value = domid
elif vm_ref == "domname":
dom_darg_value = vm_name
elif vm_ref == "domuuid":
dom_darg_value = domuuid
elif vm_ref == "none":
dom_darg_value = None
elif vm_ref == "emptystring":
dom_darg_value = '""'
else: # stick in value directly
dom_darg_value = vm_ref
return {dom_darg_key: dom_darg_value}
def make_sizeref(sizearg, mem_ref, original_mem):
"""
Create size options of command
"""
if sizearg == "yes":
size_darg_key = "sizearg"
else:
size_darg_key = "size"
if mem_ref == "halfless":
size_darg_value = "%d" % (original_mem / 2)
elif mem_ref == "halfmore":
size_darg_value = "%d" % int(original_mem * 1.5) # no fraction
elif mem_ref == "same":
size_darg_value = "%d" % original_mem
elif mem_ref == "emptystring":
size_darg_value = '""'
elif mem_ref == "zero":
size_darg_value = "0"
elif mem_ref == "toosmall":
size_darg_value = "1024"
elif mem_ref == "toobig":
size_darg_value = "1099511627776" # (KiB) One Petabyte
elif mem_ref == "none":
size_darg_value = None
else: # stick in value directly
size_darg_value = mem_ref
return {size_darg_key: size_darg_value}
def is_in_range(actual, expected, error_percent):
"""
Check if value in reasonable range
"""
deviation = 100 - (100 * (float(actual) / float(expected)))
logging.debug("Deviation: %0.2f%%" % float(deviation))
return float(deviation) <= float(error_percent)
def is_old_libvirt():
"""
Check if libvirt is old version
"""
regex = r'\s+\[--size\]\s+'
return bool(not virsh.has_command_help_match('setmem', regex))
def print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem, expected_mem,
delta_percentage):
"""
Print debug message for test
"""
dbgmsg = ("Original inside mem : %d KiB\n"
"Expected inside mem : %d KiB\n"
"Actual inside mem : %d KiB\n"
"Inside mem deviation : %0.2f%%\n"
"Original outside mem : %d KiB\n"
"Expected outside mem : %d KiB\n"
"Actual outside mem : %d KiB\n"
"Outside mem deviation: %0.2f%%\n"
"Acceptable deviation %0.2f%%" %
(original_inside_mem, expected_mem, test_inside_mem, 100 -
(100 * (float(test_inside_mem) / float(expected_mem))),
original_outside_mem, expected_mem, test_outside_mem, 100 -
(100 * (float(test_outside_mem) / float(expected_mem))),
float(delta_percentage)))
for dbgline in dbgmsg.splitlines():
logging.debug(dbgline)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_ref = params.get("setmem_vm_ref", "")
mem_ref = params.get("setmem_mem_ref", "")
flags = params.get("setmem_flags", "")
status_error = params.get("status_error", "no")
old_libvirt_fail = params.get("setmem_old_libvirt_fail", "no")
quiesce_delay = int(params.get("setmem_quiesce_delay", "1"))
domarg = params.get("setmem_domarg", "no")
sizearg = params.get("setmem_sizearg", "no")
libvirt = params.get("libvirt", "on")
delta_percentage = float(params.get("setmem_delta_per", "10"))
start_vm = params.get("start_vm", "yes")
vm_name = params.get("main_vm", "virt-tests-vm1")
paused_after_start_vm = "yes" == params.get("paused_after_start_vm", "no")
# Gather environment parameters
vm = env.get_vm(vm_name)
if start_vm == "yes":
if paused_after_start_vm:
vm.resume()
session = vm.wait_for_login()
original_inside_mem = vm_proc_meminfo(session)
session.close()
if paused_after_start_vm:
vm.pause()
original_outside_mem = vm.get_used_mem()
else:
# Retrieve known mem value, convert into kilobytes
original_inside_mem = int(params.get("mem", "1024")) * 1024
original_outside_mem = original_inside_mem
domid = vm.get_id()
domuuid = vm.get_uuid()
uri = vm.connect_uri
old_libvirt = is_old_libvirt()
if old_libvirt:
logging.info("Running test on older libvirt")
use_kilobytes = True
else:
logging.info("Running test on newer libvirt")
use_kilobytes = False
# Argument pattern is complex, build with dargs
dargs = {
'flagstr': flags,
'use_kilobytes': use_kilobytes,
'uri': uri,
'ignore_status': True,
"debug": True
}
dargs.update(make_domref(domarg, vm_ref, domid, vm_name, domuuid))
dargs.update(make_sizeref(sizearg, mem_ref, original_outside_mem))
# Prepare libvirtd status
if libvirt == "off":
utils_libvirtd.libvirtd_stop()
else:
if not utils_libvirtd.libvirtd_is_running() and \
not utils_libvirtd.libvirtd_start():
raise error.TestFail("Cannot start libvirtd")
if status_error == "yes" or old_libvirt_fail == "yes":
logging.info("Error Test: Expecting an error to occur!")
result = virsh.setmem(**dargs)
status = result.exit_status
# Recover libvirtd status
if libvirt == "off":
utils_libvirtd.libvirtd_start()
if status is 0:
logging.info("Waiting %d seconds for VM memory to settle",
quiesce_delay)
# It takes time for kernel to settle on new memory
# and current clean pages is not predictable. Therefor,
# extremely difficult to determine quiescence, so
# sleep one second per error percent is reasonable option.
time.sleep(quiesce_delay)
# Gather stats if not running error test
if status_error == "no" and old_libvirt_fail == "no":
if start_vm == "yes":
if vm.state() == "shut off":
vm.start()
# Make sure it's never paused
vm.resume()
session = vm.wait_for_login()
# Actual results
test_inside_mem = vm_proc_meminfo(session)
session.close()
test_outside_mem = vm.get_used_mem()
else:
test_inside_mem = original_inside_mem
test_outside_mem = original_outside_mem
# Expected results for both inside and outside
if sizearg == "yes":
expected_mem = int(dargs["sizearg"])
else:
expected_mem = int(dargs["size"])
print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem, expected_mem,
delta_percentage)
if status is 0: # Restore original memory
restore_status = virsh.setmem(domainarg=vm_name,
sizearg=original_outside_mem,
ignore_status=True,
flagstr=flags).exit_status
if restore_status != 0:
logging.warning(
"Failed to restore VM's original memory to %s KiB" %
original_outside_mem)
else:
# virsh setmem failed, no need to restore
pass
# Don't care about memory comparison on error test
if status_error == "no" and old_libvirt_fail == "no":
outside_in_range = is_in_range(test_outside_mem, expected_mem,
delta_percentage)
inside_in_range = is_in_range(test_inside_mem, expected_mem,
delta_percentage)
if status is not 0 or not outside_in_range or not inside_in_range:
msg = "test conditions not met: "
if status is not 0:
msg += "Non-zero virsh setmem exit code. " # maybe multiple
if not outside_in_range: # errors
msg += "Outside memory deviated. "
if not inside_in_range:
msg += "Inside memory deviated. "
raise error.TestFail(msg)
return # Normal test passed
elif status_error == "no" and old_libvirt_fail == "yes":
if status is 0:
if old_libvirt:
raise error.TestFail("Error test did not result in an error")
else:
if not old_libvirt:
raise error.TestFail("Newer libvirt failed when it should not")
else: # Verify an error test resulted in error
if status is 0:
raise error.TestFail("Error test did not result in an error")
def test(self):
create_floppy(params)
vm = env.get_vm(params["main_vm"])
vm.create()
self.session = vm.wait_for_login(timeout=login_timeout)
self.dest_dir = params["mount_dir"]
# If mount_dir specified, treat guest as a Linux OS
# Some Linux distribution does not load floppy at boot and Windows
# needs time to load and init floppy driver
if self.dest_dir:
lsmod = self.session.cmd("lsmod")
if not 'floppy' in lsmod:
self.session.cmd("modprobe floppy")
else:
time.sleep(20)
error.context("Formating floppy disk before using it")
format_cmd = params["format_floppy_cmd"]
self.session.cmd(format_cmd, timeout=120)
logging.info("Floppy disk formatted successfully")
if self.dest_dir:
error.context("Mounting floppy")
self.session.cmd("mount -t vfat %s %s" % (guest_floppy_path,
self.dest_dir))
error.context("Testing floppy")
self.session.cmd(params["test_floppy_cmd"])
error.context("Copying file to the floppy")
md5_cmd = params.get("md5_cmd")
if md5_cmd:
md5_source = self.session.cmd("%s %s" % (params["md5_cmd"],
source_file))
try:
md5_source = md5_source.split(" ")[0]
except IndexError:
error.TestError("Failed to get md5 from source file,"
" output: '%s'" % md5_source)
else:
md5_source = None
self.session.cmd("%s %s %s" % (params["copy_cmd"], source_file,
dest_file))
logging.info("Succeed to copy file '%s' into floppy disk" %
source_file)
error.context("Checking if the file is unchanged after copy")
if md5_cmd:
md5_dest = self.session.cmd("%s %s" % (params["md5_cmd"],
dest_file))
try:
md5_dest = md5_dest.split(" ")[0]
except IndexError:
error.TestError("Failed to get md5 from dest file,"
" output: '%s'" % md5_dest)
if md5_source != md5_dest:
raise error.TestFail("File changed after copy to floppy")
else:
md5_dest = None
self.session.cmd("%s %s %s" % (params["diff_file_cmd"],
source_file, dest_file))
if (re.findall(r"Trigger a crash\s.*BUG:", details, re.M)
and details.count("BUG:") != 1):
raise error.TestFail("Got multiple kernel crashes. Please "
"note that one of them was "
"intentionally generated by sysrq in "
"this test.\n%s" % details)
end_time = time.time() + timeout
while time.time() < end_time:
try:
session = vm.wait_for_login(timeout=timeout)
except VMDeadKernelCrashError, details:
details = str(details)
if (re.findall(r"Trigger a crash\s.*BUG:", details, re.M)
and details.count("BUG:") != 1):
raise error.TestFail("Got multiple kernel crashes. "
"Please note that one of them was "
"intentionally generated by sysrq "
"in this test.\n%s" % details)
else:
break
error.context("check time offset via ntp", logging.info)
output = session.cmd_output(ntp_query_cmd)
try:
offset = re.findall(r"[+-](\d+\.\d+)", output, re.M)[-1]
except IndexError:
offset = 0.0
if float(offset) > deviation:
raise error.TestFail("Unacceptable offset '%s', " % offset +
"deviation '%s'" % deviation)
def run_virsh_shutdown(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus 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()
vm_ref = params.get("shutdown_vm_ref")
libvirtd = params.get("libvirtd", "on")
# run test case
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref, ignore_status=True).exit_status
else:
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError(
"Remote test parameters unchanged from default")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s shutdown %s" % (remote_uri, vm_name)
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
status_error = params.get("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(test, params, env):
"""
Time clock offset check when guest crash/bsod test:
1) boot guest with '-rtc base=utc,clock=host,driftfix=slew';
2) sync host system time with "ntpdate clock.redhat.com";
3) inject nmi to guest/ make linux kernel crash;
4) sleep long time, then reset vm via system_reset;
5) query clock offset from ntp server;
:param test: QEMU test object.
:param params: Dictionary with test parameters.
:param env: Dictionary with the test environment.
"""
ntp_server = params.get("ntp_server", "clock.redhat.com")
ntp_cmd = params["ntp_cmd"]
ntp_query_cmd = params["ntp_query_cmd"]
nmi_cmd = params.get("nmi_cmd", "inject-nmi")
sleep_time = float(params.get("sleep_time", 1800))
deviation = float(params.get("deviation", 5))
error.context("sync host time with ntp server", logging.info)
utils.system("ntpdate %s" % ntp_server)
error.context("start guest", logging.info)
params["start_vm"] = "yes"
preprocess(test, params, env)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
error.context("sync time in guest", logging.info)
session.cmd(ntp_cmd)
error.context("inject nmi interrupt in vm", logging.info)
target, cmd = re.split("\s*:\s*", nmi_cmd)
if target == "monitor":
vm.monitor.send_args_cmd(cmd)
else:
session.sendline(cmd)
try:
session.cmd("dir")
except Exception:
pass
else:
raise error.TestFail("Guest OS still alive ...")
error.context("sleep %s seconds" % sleep_time, logging.info)
time.sleep(sleep_time)
# Autotest parses serial output and could raise VMDeadKernelCrash
# we generated using sysrq. Ignore one "BUG:" line
try:
session = vm.reboot(method="system_reset")
except VMDeadKernelCrashError, details:
details = str(details)
if (re.findall(r"Trigger a crash\s.*BUG:", details, re.M)
and details.count("BUG:") != 1):
raise error.TestFail("Got multiple kernel crashes. Please "
"note that one of them was "
"intentionally generated by sysrq in "
"this test.\n%s" % details)
end_time = time.time() + timeout
while time.time() < end_time:
try:
session = vm.wait_for_login(timeout=timeout)
except VMDeadKernelCrashError, details:
details = str(details)
if (re.findall(r"Trigger a crash\s.*BUG:", details, re.M)
and details.count("BUG:") != 1):
raise error.TestFail("Got multiple kernel crashes. "
"Please note that one of them was "
"intentionally generated by sysrq "
"in this test.\n%s" % details)
else:
break
def run_rv_input(test, params, env):
"""
Test for testing keyboard inputs through spice.
Test depends on rv_connect test.
@param test: QEMU test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
guest_vm = env.get_vm(params["guest_vm"])
guest_vm.verify_alive()
client_vm = env.get_vm(params["client_vm"])
client_vm.verify_alive()
guest_session = guest_vm.wait_for_login(
timeout=int(params.get("login_timeout", 360)))
guest_root_session = guest_vm.wait_for_login(timeout=int(
params.get("login_timeout", 360)),
username="******",
password="******")
try:
guest_session.cmd("! test -e /etc/redhat-release")
except ShellCmdError:
deploy_epel_repo(guest_root_session, params)
#utils_spice.launch_startx(guest_vm)
# Verify that gnome is now running on the guest
try:
guest_session.cmd("ps aux | grep -v grep | grep gnome-session")
except aexpect.ShellCmdError:
raise error.TestWarn("gnome-session was probably not corretly started")
guest_session.cmd("export DISPLAY=:0.0")
install_wxpython(guest_root_session, params)
deploy_test_form(test, guest_vm, params)
#Get test type and perform proper test
test_type = params.get("config_test")
test_mapping = {
'type_and_func_keys': test_type_and_func_keys,
'leds_and_esc_keys': test_leds_and_esc_keys,
'nonus_layout': test_nonus_layout,
'leds_migration': test_leds_migration
}
test_parameters = {
'type_and_func_keys': (client_vm, guest_session, params),
'leds_and_esc_keys': (client_vm, guest_session, params),
'nonus_layout': (client_vm, guest_session, params),
'leds_migration': (client_vm, guest_vm, guest_session, params)
}
try:
func = test_mapping[test_type]
args = test_parameters[test_type]
except:
raise error.TestFail("Unknown type of test")
func(*args)
#Get file with caught keycodes from guest
result_path = get_test_results(guest_vm)
#Analyze results and raise fail exp. If sent scancodes
#do not match with expected keycodes
result = analyze_results(result_path, test_type)
if result is not None:
raise error.TestFail("Testing of sending keys failed:"
" Expected keycode = %s" % result)
guest_session.close()
def run(test, params, env):
"""
Test virsh migrate-setmaxdowntime command.
1) Prepare migration environment
2) Start migration and set migrate-maxdowntime
3) Cleanup environment(migrated vm on destination)
4) Check result
"""
vm_ref = params.get("setmmdt_vm_ref", "domname")
dest_uri = params.get(
"virsh_migrate_dest_uri", "qemu+ssh://EXAMPLE/system")
src_uri = params.get(
"virsh_migrate_src_uri", "qemu+ssh://EXAMPLE/system")
pre_vm_state = params.get("pre_vm_state", "running")
status_error = "yes" == params.get("status_error", "no")
do_migrate = "yes" == params.get("do_migrate", "yes")
downtime = params.get("migrate_maxdowntime", 1000)
extra = params.get("setmmdt_extra")
# A delay between threads
delay_time = int(params.get("delay_time", 1))
# timeout of threads
thread_timeout = 180
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
# Confirm vm is running
if not vm.is_alive():
vm.start()
vm.wait_for_login()
domid = vm.get_id()
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
raise error.TestNAError("Set your destination uri first.")
if src_uri.count('///') or src_uri.count('EXAMPLE'):
raise error.TestNAError("Set your source uri first.")
if src_uri == dest_uri:
raise error.TestNAError("You should not set dest uri same as local.")
setmmdt_dargs = {'debug': True, 'ignore_status': True, 'uri': src_uri}
migrate_dargs = {'debug': True, 'ignore_status': True}
# Confirm how to reference a VM.
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
# Prepare vm state
if pre_vm_state == "paused":
vm.pause()
elif pre_vm_state == "shutoff":
vm.destroy()
try:
# Set max migration downtime must be during migration
# Using threads for synchronization
threads = []
if do_migrate:
threads.append(threading.Thread(target=thread_func_live_migration,
args=(vm, dest_uri,
migrate_dargs)))
threads.append(threading.Thread(target=thread_func_setmmdt,
args=(vm_ref, downtime, extra,
setmmdt_dargs)))
for thread in threads:
thread.start()
# Migration must be executing before setting maxdowntime
time.sleep(delay_time)
# Wait until thread is over
for thread in threads:
thread.join(thread_timeout)
finally:
# Clean up.
if do_migrate:
cleanup_dest(vm, src_uri, dest_uri)
if vm.is_paused():
vm.resume()
# Check results.
if status_error:
if ret_setmmdt:
raise error.TestFail("virsh migrate-setmaxdowntime succeed "
"but not expected.")
else:
if do_migrate and not ret_migration:
raise error.TestFail("Migration failed.")
if not ret_setmmdt:
raise error.TestFail("virsh migrate-setmaxdowntime failed.")
def run(test, params, env):
"""
Test for PCI device passthrough to libvirt guest.
a). NIC:
1. Get params.
2. Get the pci device for specific net_name.
3. Attach pci device to guest.
4. Start guest and set the ip of guest.
5. Ping the server_ip of from guest
to verify the new network device.
b). STORAGE:
1. Get params.
2. Get the pci device for specific storage_dev_name.
3. Store the result of 'fdisk -l' on guest.
3. Attach pci device to guest.
4. Start guest and get the result of 'fdisk -l' on guest.
5. Compare the result of 'fdisk -l' before and after
attaching storage pci device to guest.
"""
# get the params from params
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
device_type = params.get("libvirt_pci_device_type", "NIC")
net_name = params.get("libvirt_pci_net_name", "eth0")
server_ip = params.get("libvirt_pci_server_ip")
storage_dev_name = params.get("libvirt_pci_storage_dev_name", "/dev/sdb")
fdisk_list_before = None
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
pci_address = None
if device_type == "NIC":
# Find the pci device for given network device.
result = virsh.nodedev_list("net")
nodedev_nets = result.stdout.strip().splitlines()
device = None
for nodedev in nodedev_nets:
netxml = NodedevXML.new_from_dumpxml(nodedev)
if netxml.cap.interface == net_name:
device = nodedev
break
if not device:
raise error.TestError("There is no network device name of %s." %
net_name)
pci_dev = netxml.parent
pci_xml = NodedevXML.new_from_dumpxml(pci_dev)
pci_address = pci_xml.cap.get_address_dict()
elif device_type == "STORAGE":
# Store the result of "fdisk -l" in guest.
if not vm.is_alive():
vm.start()
session = vm.wait_for_login()
output = session.cmd_output("fdisk -l|grep \"Disk identifier:\"")
fdisk_list_before = output.splitlines()
result = virsh.nodedev_list("storage")
nodedev_storages = result.stdout.strip().splitlines()
for nodedev in nodedev_storages:
storage_xml = NodedevXML.new_from_dumpxml(nodedev)
if storage_xml.cap.block == storage_dev_name:
break
if not nodedev:
raise error.TestError("There is no block device name of %s." %
storage_dev_name)
pci_xml = NodedevXML.new_from_dumpxml(storage_xml.parent)
pci_address = pci_xml.cap.get_address_dict()
vmxml.add_hostdev(pci_address)
try:
vmxml.sync()
vm.start()
session = vm.wait_for_login()
if device_type == "NIC":
try:
session.cmd("ping -c 4 %s" % server_ip)
except aexpect.ShellError, detail:
raise error.TestFail(
"Succeed to set ip on guest, but failed "
"to ping server ip from guest.\n"
"Detail: %s.", detail)
elif device_type == "STORAGE":
# Get the result of "fdisk -l" in guest, and compare the result with
# fdisk_list_before.
output = session.cmd_output("fdisk -l|grep \"Disk identifier:\"")
fdisk_list_after = output.splitlines()
if fdisk_list_after == fdisk_list_before:
raise error.TestFail("Didn't find the disk attached to guest.")
def run(test, params, env):
"""
KVM guest stop test:
1) Log into a guest
2) Copy a file into guest
3) Stop guest
4) Check the status through monitor
5) Check the session
6) Migrat the vm to a file twice and compare them.
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=timeout)
save_path = params.get("save_path", "/tmp")
clean_save = params.get("clean_save") == "yes"
save1 = os.path.join(save_path, "save1")
save2 = os.path.join(save_path, "save2")
guest_path = params.get("guest_path", "/tmp")
file_size = params.get("file_size", "1000")
try:
utils.run("dd if=/dev/zero of=/tmp/file bs=1M count=%s" % file_size)
# Transfer file from host to guest, we didn't expect the finish of
# transfer, we just let it to be a kind of stress in guest.
bg = utils.InterruptedThread(vm.copy_files_to,
("/tmp/file", guest_path),
dict(verbose=True, timeout=60))
logging.info("Start the background transfer")
bg.start()
try:
# wait for the transfer start
time.sleep(5)
logging.info("Stop the VM")
vm.pause()
# check with monitor
logging.info("Check the status through monitor")
if not vm.monitor.verify_status("paused"):
status = str(vm.monitor.info("status"))
raise error.TestFail("Guest did not pause after sending stop,"
" guest status is %s" % status)
# check through session
logging.info("Check the session")
if session.is_responsive():
raise error.TestFail("Session still alive after sending stop")
# Check with the migration file
logging.info("Save and check the state files")
for p in [save1, save2]:
vm.save_to_file(p)
time.sleep(1)
if not os.path.isfile(p):
raise error.TestFail("VM failed to save state file %s" % p)
# Fail if we see deltas
md5_save1 = utils.hash_file(save1)
md5_save2 = utils.hash_file(save2)
if md5_save1 != md5_save2:
raise error.TestFail("The produced state files differ")
finally:
bg.join(suppress_exception=True)
finally:
session.close()
if clean_save:
logging.debug("Clean the state files")
if os.path.isfile(save1):
os.remove(save1)
if os.path.isfile(save2):
os.remove(save2)
vm.resume()
