def attach_disk_secret(params):
"""
Attach a disk with secret to VM
:params: the parameter dictionary
:raise: test.fail when disk cannot be attached
"""
secret_string = params.get("secret_base64_no_encoded")
target_dev = params.get("target_dev", "vdb")
uuid = params.get("secret_uuid")
# TODO: support encoded data
extra = "--object secret,id=sec0,data=%s -o key-secret=sec0" % secret_string
tmp_dir = data_dir.get_tmp_dir()
disk_path = os.path.join(tmp_dir, "test.img")
libvirt.create_local_disk("file",
disk_format="luks",
path=disk_path,
size="1",
extra=extra)
new_disk_dict = {}
new_disk_dict.update({
"source_encryption_dict": {
"encryption": 'luks',
"secret": {
"type": "passphrase",
"uuid": uuid
}
}
})
result = libvirt.attach_additional_device(vm_name, target_dev,
disk_path, new_disk_dict)
if result.exit_status:
raise test.fail("Attach device %s failed." % target_dev)
def setup_file_env(params):
"""
Setup file test environment
:param params: one dict to wrap up parameters
"""
# If additional_disk is False, it means that there is no need to create additional disk
if additional_disk is False:
return
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
backstore_image_target_path = params.get("backstore_image_name")
tmp_blkpull_path.append(backstore_image_target_path)
libvirt.create_local_disk("file", backstore_image_target_path, "1",
"qcow2")
backing_chain_list.append(backstore_image_target_path)
disk_src_dict = {"attrs": {"file": backstore_image_target_path}}
file_disk = libvirt_disk.create_primitive_disk_xml(
type_name, disk_device, device_target, device_bus, device_format,
disk_src_dict, None)
logging.debug("disk xml is:\n%s" % file_disk)
# Sync VM xml.
vmxml.add_device(file_disk)
vmxml.sync()
_generate_backstore_attribute(params)
def create_attach_xml(update_xmlfile, disk_type, target_bus,
target_dev, source_iso="", disk_mode=""):
"""
Create a xml file to update a device.
:param update_xmlfile : path/file to save device XML
:param source_iso : disk's source backing file.
:param disk_type: disk's device type: cdrom or floppy
:param target_bus: disk's target bus
:param target_dev: disk's target device name
:param disk_mode: readonly or shareable
"""
if source_iso:
libvirt.create_local_disk("iso", source_iso)
disk_class = VMXML.get_device_class('disk')
disk = disk_class(type_name='file')
# Static definition for comparison in check_attach()
disk.device = disk_type
disk.target = dict(bus=target_bus, dev=target_dev)
if source_iso:
disk.driver = dict(name='qemu')
disk.source = disk.new_disk_source(attrs={'file': source_iso})
if disk_mode == "readonly":
disk.readonly = True
if disk_mode == "shareable":
disk.share = True
disk.xmltreefile.write()
shutil.copyfile(disk.xml, update_xmlfile)
def create_attach_xml(update_xmlfile,
disk_type,
target_bus,
target_dev,
source_iso="",
disk_mode=""):
"""
Create a xml file to update a device.
:param update_xmlfile : path/file to save device XML
:param source_iso : disk's source backing file.
:param disk_type: disk's device type: cdrom or floppy
:param target_bus: disk's target bus
:param target_dev: disk's target device name
:param disk_mode: readonly or shareable
"""
if source_iso:
libvirt.create_local_disk("iso", source_iso)
disk_class = VMXML.get_device_class('disk')
disk = disk_class(type_name='file')
# Static definition for comparison in check_attach()
disk.device = disk_type
disk.target = dict(bus=target_bus, dev=target_dev)
if source_iso:
disk.driver = dict(name='qemu')
disk.source = disk.new_disk_source(attrs={'file': source_iso})
if disk_mode == "readonly":
disk.readonly = True
if disk_mode == "shareable":
disk.share = True
disk.xmltreefile.write()
shutil.copyfile(disk.xml, update_xmlfile)
def create_ccw_addr_disk(params):
"""
Create one ccw address disk
:param params: dict wrapped with params
"""
type_name = params.get("type_name")
disk_device = params.get("device_type")
device_target = params.get("target_dev")
device_bus = params.get("target_bus")
device_format = params.get("target_format")
source_file_path = params.get("virt_disk_device_source")
disk_src_dict = {"attrs": {"file": source_file_path}}
addr_str = params.get("addr_attrs")
if source_file_path:
libvirt.create_local_disk("file", source_file_path, 1, device_format)
ccw_addr_disk = libvirt_disk.create_primitive_disk_xml(
type_name, disk_device, device_target, device_bus, device_format,
disk_src_dict, None)
if addr_str:
addr_dict = eval(addr_str)
ccw_addr_disk.address = ccw_addr_disk.new_disk_address(
**{"attrs": addr_dict})
logging.debug("create_ccw_addr_disk xml: %s", ccw_addr_disk)
return ccw_addr_disk
def create_same_pci_slot_disk(params):
"""
Create disk with existed pci slot
:param params: dict wrapped with params
"""
type_name = params.get("type_name")
disk_device = params.get("device_type")
device_target = params.get("target_dev")
device_bus = params.get("target_bus")
device_format = params.get("target_format")
source_file_path = params.get("virt_disk_device_source")
disk_src_dict = {"attrs": {"file": source_file_path}}
vm_name = params.get("main_vm")
if source_file_path:
libvirt.create_local_disk("file", source_file_path, 1, device_format)
pci_slot_addr_disk = libvirt_disk.create_primitive_disk_xml(
type_name, disk_device, device_target, device_bus, device_format,
disk_src_dict, None)
# Get existed disk address
addr = vm_xml.VMXML.get_disk_address(vm_name, 'vda')
if not addr:
raise Exception("Failed to get vda disk address")
pci_addr_dict = tr_pci_address_to_dict(addr)
pci_slot_addr_disk.address = pci_slot_addr_disk.new_disk_address(
**{"attrs": pci_addr_dict})
logging.debug("create_pci_slot_addr_disk xml: %s", pci_slot_addr_disk)
return pci_slot_addr_disk
def attach_device(vm_name):
"""
Attach devices to the guest for some times
:param vm_name: The guest name
:return: None
"""
attach_count = params.get("attach_count", '1')
attach_dev_type = params.get("attach_dev_type", 'disk')
attach_option = params.get("attach_option")
if attach_option.count('--address '):
index_str = "%02x" % int(auto_indexes_dict['pcie-root-port'][0])
attach_option = attach_option % index_str
for count in range(0, int(attach_count)):
if attach_dev_type == 'disk':
file_path = tempfile.mktemp(dir=data_dir.get_tmp_dir())
libvirt.create_local_disk('file', file_path, size='1')
ret = virsh.attach_disk(vm_name,
file_path,
params.get('dev_target', 'vdb'),
extra=attach_option,
**virsh_dargs)
elif attach_dev_type == 'interface':
ret = virsh.attach_interface(vm_name,
attach_option,
**virsh_dargs)
else:
logging.debug("No need to attach any device.")
break
def _extend_blkcpy_execution(sub_option,
sub_status_error,
pre_created=False):
"""
Wrap up blockcopy execution combining with various options
:params sub_option: option
:params sub_status_error: expected error or not
:params pre_created: whether pre-created
"""
tmp_copy_path = os.path.join(data_dir.get_data_dir(),
"%s_%s.img" % (vm_name, sub_option))
if os.path.exists(tmp_copy_path):
libvirt.delete_local_disk('file', tmp_copy_path)
if pre_created:
libvirt.create_local_disk('file', tmp_copy_path, '10M', 'qcow2')
tmp_option = params.get("options") % sub_option
if "default" in tmp_option:
tmp_option = " --wait --verbose"
result = virsh.blockcopy(vm_name,
device_target,
tmp_copy_path,
options=tmp_option,
ignore_status=True,
debug=True)
logging.debug(sub_status_error)
libvirt.check_exit_status(result, expect_error=sub_status_error)
def setup_file_backend_env(params):
"""
Setup iscsi test environment
:param params: one dict to wrap up parameters
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
type_name = params.get("virt_disk_device_type")
disk_device = params.get("virt_disk_device")
device_target = params.get("virt_disk_device_target")
device_bus = params.get("virt_disk_device_bus")
device_format = params.get("virt_disk_device_format")
blockcopy_image_name = params.get("blockcopy_image_name")
emulated_size = int(params.get("emulated_size", "2"))
libvirt.create_local_disk("file", blockcopy_image_name, emulated_size,
"qcow2")
disk_src_dict = {"attrs": {"file": blockcopy_image_name}}
file_disk = libvirt_disk.create_primitive_disk_xml(
type_name, disk_device, device_target, device_bus, device_format,
disk_src_dict, None)
logging.debug("guest xml after undefined and recreated:\n%s",
file_disk)
return file_disk
def create_backend_image_file(image_path):
"""
Create backend image file
:param image_path: image file path
"""
libvirt.create_local_disk("file", image_path, size="100M")
chown_cmd = "chown qemu:qemu %s" % image_path
process.run(chown_cmd, ignore_status=False, shell=True)
def create_disk(params,
test,
vm_name,
orig_iso,
disk_type,
target_dev,
disk_format="",
mode=""):
"""
Prepare image for attach and attach it to domain
:param parameters from cfg file
:param vm_name : vm_name
:param source_iso : disk's source backing file
:param disk_type: disk's device type: cdrom or floppy
:param target_dev: disk's target device name
:param disk_format: disk's target format
:param mode: readonly or shareable
"""
slice_test = "yes" == params.get("disk_slice", "no")
try:
# create slice cdrom image for slice test
if slice_test:
libvirt.create_local_disk("file",
orig_iso,
size="10",
disk_format=disk_format,
extra="-o preallocation=full")
params["input_source_file"] = orig_iso
params["disk_slice"] = {"slice": "yes"}
params["target_dev"] = "sdc"
if mode == 'readonly':
params["readonly"] = "yes"
elif mode == "shareable":
params["shareable"] = "yes"
disk_xml = libvirt.create_disk_xml(params)
else:
with open(orig_iso, 'wb') as _file:
_file.seek((1024 * 1024) - 1)
_file.write(str(0).encode())
except IOError:
test.fail("Create orig_iso failed!")
options = "--type %s --sourcetype=file --config" % disk_type
try:
if mode:
options += " --mode %s" % mode
if slice_test:
# Use attach_device to add cdrom file with slice to guest
virsh.attach_device(vm_name, disk_xml, flagstr="--config")
else:
virsh.attach_disk(vm_name, orig_iso, target_dev, options)
except Exception:
os.remove(orig_iso)
test.fail("Failed to attach")
def prepare_disk_img(test_disk):
"""
Prepare a qcow2 image for test disk
:param test_disk: The vm's disk, such as 'vdb'
:return: The path to the image
"""
image_name = "{}_image.qcow2".format(test_disk)
image_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", image_path, test_disk_size,
"qcow2")
return image_path
def prepare_disk(path, disk_format):
"""
Prepare the disk for a given disk format.
"""
disk = {}
# Check if we test with a non-existed disk.
if os.path.split(path)[-1].startswith("notexist."):
disk.update({"format": disk_format, "source": path})
elif disk_format == "scsi":
scsi_option = params.get("virt_disk_device_scsi_option", "")
disk_source = libvirt.create_scsi_disk(scsi_option)
if disk_source:
disk.update({"format": "scsi", "source": disk_source})
else:
raise error.TestNAError("Get scsi disk failed")
elif disk_format in ["iso", "floppy"]:
disk_path = libvirt.create_local_disk(disk_format, path)
disk.update({"format": disk_format, "source": disk_path})
elif disk_format == "nfs":
nfs_disk_type = params.get("nfs_disk_type", None)
disk.update(setup_nfs_disk(os.path.split(path)[-1], nfs_disk_type))
elif disk_format == "iscsi":
# Create iscsi device if needed.
disk_dev = qemu_storage.Iscsidev(params, os.path.dirname(path),
"iscsi")
device_source = disk_dev.setup()
logging.debug("iscsi dev name: %s", device_source)
# Format the disk and make file system.
open("/tmp/fdisk-cmd", "w").write("n\np\n\n\n\nw\n")
output = utils.run("fdisk %s < /tmp/fdisk-cmd" %
device_source).stdout.strip()
logging.debug("fdisk output: %s", output)
output = utils.run("mkfs.ext3 %s1" % device_source).stdout.strip()
logging.debug("mkfs output: %s", output)
device_source += "1"
disk.update({
"format": disk_format,
"disk_dev": disk_dev,
"source": device_source
})
elif disk_format in ["raw", "qcow2"]:
disk_size = params.get("virt_disk_device_size", "1")
device_source = libvirt.create_local_disk("file",
path,
disk_size,
disk_format=disk_format)
disk.update({"format": disk_format, "source": device_source})
return disk
def create_second_disk(disk_dict):
"""
Create another disk using given parameters
:param disk_dict: dict, parameters to use
:return: disk xml
"""
disk_path = disk_dict.get('source_file')
disk_format = disk_dict.get('driver_type', 'raw')
libvirt.create_local_disk('file', disk_path, '1', disk_format)
return libvirt.create_disk_xml(disk_dict)
def prepare_disk(path, disk_format):
"""
Prepare the disk for a given disk format.
"""
disk = {}
# Check if we test with a non-existed disk.
if os.path.split(path)[-1].startswith("notexist."):
disk.update({"format": disk_format,
"source": path})
elif disk_format == "scsi":
scsi_option = params.get("virt_disk_device_scsi_option", "")
disk_source = libvirt.create_scsi_disk(scsi_option)
if disk_source:
disk.update({"format": "scsi",
"source": disk_source})
else:
raise error.TestNAError("Get scsi disk failed")
elif disk_format in ["iso", "floppy"]:
disk_path = libvirt.create_local_disk(disk_format, path)
disk.update({"format": disk_format,
"source": disk_path})
elif disk_format == "nfs":
nfs_disk_type = params.get("nfs_disk_type", None)
disk.update(setup_nfs_disk(os.path.split(path)[-1], nfs_disk_type))
elif disk_format == "iscsi":
# Create iscsi device if needed.
disk_dev = qemu_storage.Iscsidev(params, os.path.dirname(path),
"iscsi")
device_source = disk_dev.setup()
logging.debug("iscsi dev name: %s", device_source)
# Format the disk and make file system.
open("/tmp/fdisk-cmd", "w").write("n\np\n\n\n\nw\n")
output = utils.run("fdisk %s < /tmp/fdisk-cmd"
% device_source).stdout.strip()
logging.debug("fdisk output: %s", output)
output = utils.run("mkfs.ext3 %s1"
% device_source).stdout.strip()
logging.debug("mkfs output: %s", output)
device_source += "1"
disk.update({"format": disk_format, "disk_dev": disk_dev,
"source": device_source})
elif disk_format in ["raw", "qcow2"]:
disk_size = params.get("virt_disk_device_size", "1")
device_source = libvirt.create_local_disk(
"file", path, disk_size, disk_format=disk_format)
disk.update({"format": disk_format,
"source": device_source})
return disk
def prepare_disk(path, disk_format):
"""
Prepare the disk for a given disk format.
"""
disk = {}
# Check if we test with a non-existed disk.
if os.path.split(path)[-1].startswith("notexist."):
disk.update({"format": disk_format,
"source": path})
elif disk_format == "scsi":
scsi_option = params.get("virt_disk_device_scsi_option", "")
disk_source = libvirt.create_scsi_disk(scsi_option)
if disk_source:
disk.update({"format": "scsi",
"source": disk_source})
else:
raise exceptions.TestSkipError("Get scsi disk failed")
elif disk_format in ["iso", "floppy"]:
disk_path = libvirt.create_local_disk(disk_format, path)
disk.update({"format": disk_format,
"source": disk_path})
elif disk_format == "nfs":
nfs_disk_type = params.get("nfs_disk_type", None)
disk.update(setup_nfs_disk(os.path.split(path)[-1], nfs_disk_type))
elif disk_format == "iscsi":
# Create iscsi device if needed.
image_size = params.get("image_size", "2G")
device_source = libvirt.setup_or_cleanup_iscsi(
is_setup=True, is_login=True, image_size=image_size)
logging.debug("iscsi dev name: %s", device_source)
# Format the disk and make file system.
libvirt.mk_label(device_source)
libvirt.mk_part(device_source)
# Run partprobe to make the change take effect.
process.run("partprobe", ignore_status=True, shell=True)
libvirt.mkfs("%s1" % device_source, "ext3")
device_source += "1"
disk.update({"format": disk_format,
"source": device_source})
elif disk_format in ["raw", "qcow2"]:
disk_size = params.get("virt_disk_device_size", "1")
device_source = libvirt.create_local_disk(
"file", path, disk_size, disk_format=disk_format)
disk.update({"format": disk_format,
"source": device_source})
return disk
def create_file_lun_source_disk(params):
"""
Create one file lun source disk
:param params: dict wrapped with params
"""
device_format = params.get("target_format")
source_file_path = params.get("virt_disk_device_source")
if source_file_path:
libvirt.create_local_disk("file", source_file_path, 1, device_format)
file_lun_source_disk = create_customized_disk(params)
return file_lun_source_disk
def prepare_disk(path, disk_format):
"""
Prepare the disk for a given disk format.
"""
disk = {}
# Check if we test with a non-existed disk.
if os.path.split(path)[-1].startswith("notexist."):
disk.update({"format": disk_format,
"source": path})
elif disk_format == "scsi":
scsi_option = params.get("virt_disk_device_scsi_option", "")
disk_source = libvirt.create_scsi_disk(scsi_option)
if disk_source:
disk.update({"format": "scsi",
"source": disk_source})
else:
raise error.TestNAError("Get scsi disk failed")
elif disk_format in ["iso", "floppy"]:
disk_path = libvirt.create_local_disk(disk_format, path)
disk.update({"format": disk_format,
"source": disk_path})
elif disk_format == "nfs":
nfs_disk_type = params.get("nfs_disk_type", None)
disk.update(setup_nfs_disk(os.path.split(path)[-1], nfs_disk_type))
elif disk_format == "iscsi":
# Create iscsi device if needed.
image_size = params.get("image_size", "2G")
device_source = libvirt.setup_or_cleanup_iscsi(
is_setup=True, is_login=True, image_size=image_size)
logging.debug("iscsi dev name: %s", device_source)
# Format the disk and make file system.
libvirt.mk_part(device_source)
# Run partprobe to make the change take effect.
utils.run("partprobe", ignore_status=True)
libvirt.mkfs("%s1" % device_source, "ext3")
device_source += "1"
disk.update({"format": disk_format,
"source": device_source})
elif disk_format in ["raw", "qcow2"]:
disk_size = params.get("virt_disk_device_size", "1")
device_source = libvirt.create_local_disk(
"file", path, disk_size, disk_format=disk_format)
disk.update({"format": disk_format,
"source": device_source})
return disk
def hotplug_disk(disk_name):
"""
hotplug a disk to guest
:param disk_name: the name of the disk be hotplugged
"""
device_source = os.path.join(data_dir.get_tmp_dir(), disk_name)
libvirt.create_local_disk("file", device_source, size='1')
try:
res = virsh.attach_disk(vm_name, device_source,
disk_target_name, debug=True)
utils_misc.wait_for(lambda: (res.stdout ==
"Disk attached successfully"), 10)
except Exception:
test.error("Can not attach %s to the guest" % disk_target_name)
def prepare_vmxml_and_test_disk():
"""
Configure the XML definition of the VM under test to include
the required starting iothread value, and prepare
a test disk for usage.
"""
iothreads = params.get("iothreads", 5)
try:
iothreads = int(iothreads)
except ValueError:
# 'iothreads' must be convertible to an integer
logging.debug("Can't convert %s to integer type", iothreads)
# Set iothreads first
vmxml_backup.iothreads = iothreads
logging.debug("Pre-test xml is %s", vmxml_backup)
vmxml_backup.sync()
device_source_name = \
params.get("virt_disk_device_source", "attach.img")
device_source_format = \
params.get("virt_disk_device_source_format", "qcow2")
device_source_path = \
os.path.join(data_dir.get_data_dir(), device_source_name)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1",
disk_format=device_source_format)
# Disk specific attributes.
device_target = params.get("virt_disk_device_target", "vdb")
return device_source_path, device_source, device_target
def create_disk(disk_type, disk_path, disk_format, disk_device_type,
disk_device, disk_target, disk_bus):
"""
Create another disk for a given path,customize some attributes.
:param disk_type: the type of disk.
:param disk_path: the path of disk.
:param disk_format: the format to disk image.
:param disk_device_type: the disk device type.
:param disk_device: the device of disk.
:param disk_target: the target of disk.
:param disk_bus: the target bus of disk.
:return: disk object if created successfully.
"""
disk_source = libvirt.create_local_disk(disk_type, disk_path, '1', disk_format)
custom_disk = Disk(type_name=disk_device_type)
custom_disk.device = disk_device
source_dict = {'file': disk_source}
custom_disk.source = custom_disk.new_disk_source(
**{"attrs": source_dict})
target_dict = {"dev": disk_target, "bus": disk_bus}
custom_disk.target = target_dict
driver_dict = {"name": "qemu", 'type': disk_format}
custom_disk.driver = driver_dict
return custom_disk
def setup_nfs_disk(disk_name, disk_type, disk_format="raw"):
"""
Setup nfs disk.
"""
mount_src = os.path.join(test.tmpdir, "nfs-export")
if not os.path.exists(mount_src):
os.mkdir(mount_src)
mount_dir = os.path.join(test.tmpdir, "nfs-mount")
if disk_type in ["file", "floppy", "iso"]:
disk_path = "%s/%s" % (mount_src, disk_name)
device_source = libvirt.create_local_disk(disk_type, disk_path, "2",
disk_format=disk_format)
#Format the disk.
if disk_type in ["file", "floppy"]:
cmd = ("mkfs.ext3 -F %s && setsebool virt_use_nfs true"
% device_source)
if utils.run(cmd, ignore_status=True).exit_status:
raise error.TestNAError("Format disk failed")
nfs_params = {"nfs_mount_dir": mount_dir, "nfs_mount_options": "ro",
"nfs_mount_src": mount_src, "setup_local_nfs": "yes",
"export_options": "rw,no_root_squash"}
nfs_obj = nfs.Nfs(nfs_params)
nfs_obj.setup()
if not nfs_obj.mount():
return None
disk = {"disk_dev": nfs_obj, "format": "nfs", "source":
"%s/%s" % (mount_dir, os.path.split(device_source)[-1])}
return disk
def setup_nfs_disk(disk_name, disk_type, disk_format="raw"):
"""
Setup nfs disk.
"""
mount_src = os.path.join(test.tmpdir, "nfs-export")
if not os.path.exists(mount_src):
os.mkdir(mount_src)
mount_dir = os.path.join(test.tmpdir, "nfs-mount")
if disk_type in ["file", "floppy", "iso"]:
disk_path = "%s/%s" % (mount_src, disk_name)
device_source = libvirt.create_local_disk(disk_type, disk_path, "2",
disk_format=disk_format)
#Format the disk.
if disk_type in ["file", "floppy"]:
cmd = ("mkfs.ext3 -F %s && setsebool virt_use_nfs true"
% device_source)
if process.system(cmd, ignore_status=True, shell=True):
raise exceptions.TestSkipError("Format disk failed")
nfs_params = {"nfs_mount_dir": mount_dir, "nfs_mount_options": "ro",
"nfs_mount_src": mount_src, "setup_local_nfs": "yes",
"export_options": "rw,no_root_squash"}
nfs_obj = nfs.Nfs(nfs_params)
nfs_obj.setup()
if not nfs_obj.mount():
return None
disk = {"disk_dev": nfs_obj, "format": "nfs", "source":
"%s/%s" % (mount_dir, os.path.split(device_source)[-1])}
return disk
def create_attach_xml(params, test, update_xmlfile, source_iso, disk_type, target_bus,
target_dev, disk_mode="", disk_alias=None):
"""
Create a xml file to update a device.
:param parameters from cfg file
:param update_xmlfile : path/file to save device XML
:param source_iso : disk's source backing file.
:param disk_type: disk's device type: cdrom or floppy
:param target_bus: disk's target bus
:param target_dev: disk's target device name
:param disk_mode: readonly or shareable
:param disk_alias: disk's alias name
"""
slice_test = "yes" == params.get("disk_slice", "no")
try:
if slice_test:
libvirt.create_local_disk("file", source_iso, size="1", disk_format="qcow2", extra="-o preallocation=full")
else:
with open(source_iso, 'wb') as _file:
_file.seek((1024 * 1024) - 1)
_file.write(str(0).encode())
except IOError:
test.fail("Create source_iso failed!")
disk_class = VMXML.get_device_class('disk')
disk = disk_class(type_name='file')
# Static definition for comparison in check_attach()`
disk.device = disk_type
disk.driver = dict(name='qemu')
disk_source = disk.new_disk_source(**{"attrs": {'file': source_iso}})
# Add slice field involved in source
if slice_test:
slice_size_param = process.run("du -b %s" % source_iso).stdout_text.strip()
slice_size = re.findall(r'[0-9]+', slice_size_param)
slice_size = ''.join(slice_size)
disk_source.slices = disk.new_slices(
**{"slice_type": "storage", "slice_offset": "0", "slice_size": slice_size})
disk.source = disk_source
disk.target = dict(bus=target_bus, dev=target_dev)
if disk_mode == "readonly":
disk.readonly = True
if disk_mode == "shareable":
disk.share = True
if disk_alias:
disk.alias = dict(name=disk_alias)
disk.xmltreefile.write()
shutil.copyfile(disk.xml, update_xmlfile)
def create_disk(vm_name, disk_iso, disk_type, target_dev, mode=""):
"""
:param vm_name : vm_name
:param disk_iso : disk's source backing file
:param disk_type: disk's device type: cdrom or floppy
:param target_dev: disk's target device name
:param mode: readonly or shareable
"""
libvirt.create_local_disk("iso", disk_iso)
options = "--type %s --sourcetype=file --config" % disk_type
if mode:
options += " --mode %s" % mode
try:
virsh.attach_disk(vm_name, disk_iso, target_dev, options)
except Exception:
os.remove(disk_iso)
raise exceptions.TestFail("Failed to attach")
def create_disk(vm_name, disk_iso, disk_type, target_dev, mode=""):
"""
:param vm_name : vm_name
:param disk_iso : disk's source backing file
:param disk_type: disk's device type: cdrom or floppy
:param target_dev: disk's target device name
:param mode: readonly or shareable
"""
libvirt.create_local_disk("iso", disk_iso)
options = "--type %s --sourcetype=file --config" % disk_type
if mode:
options += " --mode %s" % mode
try:
virsh.attach_disk(vm_name, disk_iso, target_dev, options)
except:
os.remove(disk_iso)
raise exceptions.TestFail("Failed to attach")
def add_test_disk_to_vm(self, vm):
"""
Attach a disk to vm
:param vm: The vm to attch disk to
"""
test_disk_path = os.path.join(self.tmp_dir,
self.test_disk_target + '.qcow2')
libvirt.create_local_disk('file', test_disk_path,
self.test_disk_size, 'qcow2')
test_disk_params = {'device_type': 'disk',
'type_name': 'file',
'driver_type': 'qcow2',
'target_dev': self.test_disk_target,
'source_file': test_disk_path}
test_disk_xml = libvirt.create_disk_xml(test_disk_params)
virsh.attach_device(vm.name, test_disk_xml,
flagstr='--config', debug=True)
self.test_disk_path = test_disk_path
def prepare_block_device(params, vm_name):
"""
Prepare block_device for test
:param params: dict, parameters used
:param vm_name: vm name
"""
target_dev = params.get("target_dev")
block_device = params.get("nfs_mount_dir") + '/' + params.get(
"block_device_name")
libvirt.create_local_disk("file", block_device, '1', "qcow2")
source_loop_dev = setup_loop_dev(block_device)
target_loop_dev = setup_loop_dev(block_device, remote_params=params)
# Attach block device to guest
result = virsh.attach_disk(vm_name,
source_loop_dev,
target_dev,
debug=True)
libvirt.check_exit_status(result)
return (source_loop_dev, target_loop_dev)
def setup_raw_disk_blockresize():
"""
Prepare raw disk and create snapshots.
"""
if not vm.is_alive():
vm.start()
vm.wait_for_login().close()
# Create raw type image
image_path = test_obj.tmp_dir + '/blockresize_test'
libvirt.create_local_disk("file",
path=image_path,
size='500K',
disk_format="raw")
test_obj.new_image_path = image_path
# attach new disk
virsh.attach_disk(vm.name,
source=image_path,
target=device,
extra=extra,
debug=True)
test_obj.new_dev = device
# create snap chain
test_obj.prepare_snapshot()
def setup_blockcopy_extended_l2():
"""
Prepare running domain with extended_l2=on type image.
"""
# prepare image
image_path = test_obj.tmp_dir + '/new_image'
libvirt.create_local_disk("file",
path=image_path,
size='500M',
disk_format=disk_format,
extra=disk_extras)
check_obj.check_image_info(image_path,
check_item='extended l2',
expected_value='true')
test_obj.new_image_path = image_path
# start get old parts
session = vm.wait_for_login()
test_obj.old_parts = utils_disk.get_parts_list(session)
session.close()
# attach new disk
if encryption_disk:
secret_disk_dict = eval(params.get("secret_disk_dict", '{}'))
test_obj.prepare_secret_disk(image_path, secret_disk_dict)
if not vm.is_alive():
vm.start()
else:
virsh.attach_disk(vm.name,
source=image_path,
target=device,
extra=attach_disk_extra,
debug=True,
ignore_status=False)
test_obj.new_dev = device
# clean copy file
if os.path.exists(tmp_copy_path):
process.run('rm -f %s' % tmp_copy_path)
def test_batch_cdrom_operation(vm_name, disk_format, disk_device,
device_target, device_bus, test):
"""
Test cdrom on disk with different metadata_cache size attribute
:param vm_name: domain name
:param disk_format: disk format
:param disk_device: device name
:param disk_target: the target of disk
:param device_bus: device bus
:param test: test case itself
"""
for size_type in ["100", "1000", "10"]:
disk_path = "/var/lib/libvirt/images/test_image_%s" % size_type
if size_type == "10":
disk_path = ""
if disk_path:
libvirt.create_local_disk("file", disk_path, "100M", disk_format)
disk_size = libvirt_disk.create_custom_metadata_disk(
disk_path, disk_format, disk_device, device_target, device_bus,
size_type)
virsh.update_device(vm_name,
disk_size.xml,
flagstr='--live',
ignore_status=False,
debug=True)
# Check max size value in cdrom part
cdrom_xml = virsh.dumpxml(vm_name, debug=False).stdout_text.strip()
cdrom_part_xml = re.findall(
r'(<metadata_cache)(.+)((?:\n.+)+)(metadata_cache>)', cdrom_xml)
cdrom_filter_str = ''.join(cdrom_part_xml[0])
cdrom_byte_match = "<max_size unit='bytes'>%s</max_size>" % size_type
if cdrom_byte_match not in cdrom_filter_str:
test.fail(
"Failed to generate metadata_cache in cdrom operation %s" %
cdrom_part_xml)
def prepare_local_image(image_filename):
"""
Prepare a local image.
:param image_filename: The name to the local image.
:return: The path to the image file.
"""
image_format = 'qcow2'
image_size = '10M'
image_path = os.path.join(data_dir.get_tmp_dir(), image_filename)
try:
image_path = libvirt.create_local_disk("file",
image_path,
image_size,
disk_format=image_format)
except Exception as err:
test.error("Error happens when prepare local image: %s", err)
disks_img.append(image_path)
return image_path
def attach_disk(): # pylint: disable=W0611
"""
Sub test for attach disk, including hot and cold plug/unplug
"""
plug_method = params.get("plug_method", "hot")
device_source_format = params.get("at_disk_source_format", "raw")
device_target = params.get("at_disk_target", "vdb")
device_disk_bus = params.get("at_disk_bus", "virtio")
device_source_name = params.get("at_disk_source", "attach.img")
detect_time = params.get("detect_disk_time", 10)
device_source_path = os.path.join(tmp_dir, device_source_name)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1",
disk_format=device_source_format)
def _generate_disk_xml():
"""Generate xml for device hotplug/unplug usage"""
diskxml = devices.disk.Disk("file")
diskxml.device = "disk"
source_params = {"attrs": {'file': device_source}}
diskxml.source = diskxml.new_disk_source(**source_params)
diskxml.target = {'dev': device_target, 'bus': device_disk_bus}
if params.get("disk_model"):
diskxml.model = params.get("disk_model")
if pci_bridge_index and device_disk_bus == 'virtio':
addr = diskxml.new_disk_address('pci')
addr.set_attrs({'bus': pci_bridge_index, 'slot': slot})
diskxml.address = addr
return diskxml.xml
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
slot = get_free_slot(pci_bridge_index, v_xml)
disk_xml = _generate_disk_xml()
attach(disk_xml, device_target, plug_method)
if plug_method == "cold":
disk_xml = _generate_disk_xml()
detach(disk_xml, device_target, plug_method)
if not utils_misc.wait_for(
lambda: not libvirt.device_exists(vm, device_target),
detect_time):
test.fail("Detach disk failed.")
def prepare_local_image():
"""
Prepare a local image.
:return: The path to the image file.
"""
image_filename = params.get("image_filename", "raw.img")
image_format = params.get("image_format", "raw")
image_size = params.get("image_size", "1G")
image_path = os.path.join(data_dir.get_data_dir(), image_filename)
try:
if image_format in ["raw", "qcow2"]:
image_path = libvirt.create_local_disk(
"file", image_path, image_size, disk_format=image_format)
else:
test.cancel("We only test raw & qcow2 format for now.")
except Exception as err:
test.error("Error happens when prepare local image: %s", err)
return image_path
def prepare_local_image():
"""
Prepare a local image.
:return: The path to the image file.
"""
image_filename = params.get("image_filename", "raw.img")
image_format = params.get("image_format", "raw")
image_size = params.get("image_size", "1G")
image_path = os.path.join(data_dir.get_tmp_dir(), image_filename)
try:
if image_format in ["raw", "qcow2"]:
image_path = libvirt.create_local_disk("file",
image_path, image_size,
disk_format=image_format)
else:
test.cancel("We only test raw & qcow2 format for now.")
except Exception as err:
test.error("Error happens when prepare local image: %s", err)
return image_path
def create_disk(disk_type,
path=None,
size="500M",
disk_format="raw",
extra='',
session=None):
"""
Create disk on local or remote
:param disk_type: Disk type
:param path: The path of disk
:param size: The size of disk
:param disk_format: The format of disk
:param extra: Extra parameters
:param session： Session object to a remote host or guest
:return: The path of disk
:raise: TestError if the disk can't be created
"""
if session:
if disk_type == "file":
disk_cmd = ("qemu-img create -f %s %s %s %s" %
(disk_format, extra, path, size))
else:
# TODO: Add implementation for other types
raise exceptions.TestError("Unknown disk type %s" % disk_type)
status, stdout = utils_misc.cmd_status_output(disk_cmd,
session=session)
if status:
raise exceptions.TestError(
"Failed to create img on remote: cmd: {} "
"status: {}, stdout: {}".format(disk_cmd, status, stdout))
return path
else:
return libvirt.create_local_disk(disk_type,
path=path,
size=size,
disk_format=disk_format,
extra=extra)
def run(test, params, env):
"""
Test virsh {at|de}tach-device command.
The command can attach new disk/detach device.
1.Prepare test environment,destroy or suspend a VM.
2.Perform virsh attach/detach-device operation.
3.Recover test environment.
4.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
pre_vm_state = params.get("at_dt_device_pre_vm_state", "running")
virsh_dargs = {"debug": True, "ignore_status": True}
def is_attached(vmxml_devices, disk_type, source_file, target_dev):
"""
Check attached device and disk exist or not.
:param vmxml_devices: VMXMLDevices instance
:param disk_type: disk's device type: cdrom or floppy
:param source_file : disk's source file to check
:param target_dev : target device name
:return: True/False if backing file and device found
"""
disks = vmxml_devices.by_device_tag("disk")
for disk in disks:
if disk.device != disk_type:
continue
if disk.target["dev"] != target_dev:
continue
if disk.xmltreefile.find("source") is not None:
if disk.source.attrs["file"] != source_file:
continue
else:
continue
# All three conditions met
logging.debug("Find %s in given disk XML", source_file)
return True
logging.debug("Not find %s in gievn disk XML", source_file)
return False
def check_result(disk_source, disk_type, disk_target, flags, attach=True):
"""
Check the test result of attach/detach-device command.
"""
vm_state = pre_vm_state
active_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
active_attached = is_attached(active_vmxml.devices, disk_type, disk_source, disk_target)
if vm_state != "transient":
inactive_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name, options="--inactive")
inactive_attached = is_attached(inactive_vmxml.devices, disk_type, disk_source, disk_target)
if flags.count("config") and not flags.count("live"):
if vm_state != "transient":
if attach:
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated" " when --config options used for" " attachment"
)
if vm_state != "shutoff":
if active_attached:
raise exceptions.TestFail(
"Active domain XML updated " "when --config options used " "for attachment"
)
else:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated" " when --config options used for" " detachment"
)
elif flags.count("live") and not flags.count("config"):
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated" " when --live options used for" " attachment"
)
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated " "when --live options used for" " attachment"
)
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated" " when --live options used for" " detachment"
)
elif flags.count("live") and flags.count("config"):
if attach:
if vm_state in ["paused", "running"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated" " when --live --config options" " used for attachment"
)
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated" " when --live --config options " "used for attachment"
)
else:
if vm_state in ["paused", "running"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated " "when --live --config options " "used for detachment"
)
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated " "when --live --config options" " used for detachment"
)
elif flags.count("current") or flags == "":
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated" " when --current options used " "for attachment"
)
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated " "when --current options used " "for live attachment"
)
if vm_state == "shutoff" and not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated" " when --current options used for" " attachment"
)
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated" " when --current options used " "for detachment"
)
if vm_state == "shutoff" and inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated" " when --current options used for" " detachment"
)
vm_ref = params.get("at_dt_device_vm_ref", "name")
at_status_error = "yes" == params.get("at_status_error", "no")
dt_status_error = "yes" == params.get("dt_status_error", "no")
# Disk specific attributes.
at_options = params.get("at_dt_device_at_options", "")
dt_options = params.get("at_dt_device_dt_options", "")
device = params.get("at_dt_device_device", "disk")
device_source_name = params.get("at_dt_device_source", "attach.img")
device_target = params.get("at_dt_device_target", "vdd")
if vm.is_alive():
vm.destroy(gracefully=False)
# Back up xml file.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Turn VM into certain state.
if pre_vm_state == "running":
logging.info("Starting %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
elif pre_vm_state == "shutoff":
logging.info("Shuting down %s..." % vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
elif pre_vm_state == "paused":
logging.info("Pausing %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
if not vm.pause():
raise exceptions.TestSkipError("Cann't pause the domain")
elif pre_vm_state == "transient":
logging.info("Creating %s..." % vm_name)
vm.undefine()
if virsh.create(backup_xml.xml, **virsh_dargs).exit_status:
backup_xml.define()
raise exceptions.TestSkipError("Cann't create the domain")
vm.wait_for_login().close()
# 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 = ""
try:
device_source = os.path.join(data_dir.get_tmp_dir(), device_source_name)
libvirt.create_local_disk("file", device_source, "1")
# Get disk xml file.
disk_params = {
"type_name": "file",
"device_type": device,
"target_dev": device_target,
"target_bus": "virtio",
"source_file": device_source,
"driver_name": "qemu",
"driver_type": "raw",
}
disk_xml = libvirt.create_disk_xml(disk_params)
# Attach the disk.
ret = virsh.attach_device(vm_ref, disk_xml, flagstr=at_options, debug=True)
libvirt.check_exit_status(ret, at_status_error)
# Check if command take affect config file.
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# Sleep a while for vm is stable
time.sleep(3)
if not ret.exit_status:
check_result(device_source, device, device_target, at_options)
# Detach the disk.
if pre_vm_state == "paused":
if not vm.pause():
raise exceptions.TestFail("Cann't pause the domain")
disk_xml = libvirt.create_disk_xml(disk_params)
ret = virsh.detach_device(vm_ref, disk_xml, flagstr=dt_options, debug=True)
libvirt.check_exit_status(ret, dt_status_error)
# Check if command take affect config file.
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# Sleep a while for vm is stable
time.sleep(3)
if not ret.exit_status:
check_result(device_source, device, device_target, dt_options, False)
# Try to start vm at last.
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
finally:
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml.sync()
if os.path.exists(device_source):
os.remove(device_source)
def run(test, params, env):
"""
cpu, memory, network, disk limit test:
1) prepare the guest with given topology, memory and if any devices
2) Start and login to the guest
3) Check if the guest functional
4) if given run some stress test
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
TODO: 1. Add multiple pci-bridge and pci devices respectively.
2. Get no. VM interfaces at test start and use for validation.
"""
failures = {"Failed to allocate KVM HPT of order":
"Host does no have enough cma to boot, try increasing \
kvm_cma_resv_ratio in host boot",
"unable to map backing store for guest RAM":
"Not enough memory in the host to boot the guest"}
vm_name = params.get("main_vm")
max_vcpu = current_vcpu = int(params.get("max_vcpu", 240))
vm_cores = int(params.get("limit_vcpu_cores", 240))
vm_threads = int(params.get("limit_vcpu_threads", 1))
vm_sockets = int(params.get("limit_vcpu_sockets", 1))
usermaxmem = params.get("usermaxmem", '')
default_mem = int(params.get("default_mem", 8))
maxmem = params.get("maxmem", "no") == "yes"
swap_setup = params.get("swap_setup", "yes") == "yes"
blk_partition = params.get("blk_part", '')
graphic = params.get("graphics", "no") == "yes"
vm = env.get_vm(vm_name)
guestmemory = None
max_network = params.get("max_network", "no") == "yes"
max_disk = params.get("max_disk", "no") == "yes"
num_network = int(params.get("num_network", 16))
num_disk = int(params.get("num_disk", 16))
drive_format = params.get("drive_format", "scsi")
disk_format = params.get("disk_format", "qcow2")
netdst = params.get("netdst", "virbr0")
memunit = params.get("memunit", 'G')
failed = False
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
org_xml = vmxml.copy()
# Destroy the vm
vm.destroy()
try:
# Setup swap
if swap_setup:
if not blk_partition:
test.cancel("block partition is not given")
# Check if valid partition or raise
cmd = "blkid /dev/%s|awk -F" " '{print $2}'" % blk_partition
output = process.system_output(cmd, shell=True)
if "UUID" not in output:
test.cancel("Not a valid partition given for swap creation")
# Create swap partition
cmd = "mkswap /dev/%s" % blk_partition
process.system(cmd, shell=True)
cmd = "swapon /dev/%s" % blk_partition
process.system(cmd, shell=True)
# Check for host memory and cpu levels and validate against
# requested limits, allow to max of 10X for CPU and 2.5X for memory
host_memory = int(memory.rounded_memtotal())
if maxmem:
if usermaxmem:
guestmemory = usermaxmem
else:
# Normalize to GB
guestmemory = int(2.5 * host_memory/(1024 * 1024))
else:
pass
if not guestmemory:
# assign default memory
guestmemory = default_mem
# Set the current and max memory params
vmxml.current_mem_unit = memunit
vmxml.max_mem_unit = memunit
vmxml.current_mem = int(guestmemory)
vmxml.max_mem = int(guestmemory)
vmxml.sync()
# Set vcpu and topology
libvirt_xml.VMXML.set_vm_vcpus(vm_name, max_vcpu, current_vcpu,
vm_sockets, vm_cores, vm_threads)
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Set vnc display as needed
graphics = vmxml.get_device_class('graphics')()
if graphic:
if not vmxml.get_graphics_devices("vnc"):
graphics.add_graphic(vm_name, graphic="vnc")
else:
if vmxml.get_graphics_devices("vnc"):
graphics.del_graphic(vm_name)
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
network_str = None
disk_str = None
# Set network devices
if max_network:
network_str = "ip link|grep ^[1-9]|wc -l"
for idx in range(num_network):
network = Interface(type_name="bridge")
network.mac_address = utils_net.generate_mac_address_simple()
network.source = {"bridge": netdst}
vmxml.add_device(network)
# Set disk devices
if max_disk:
for idx in range(num_disk):
disk_str = "lsblk|grep ^[s,v]|grep 1G|wc -l"
disk = Disk()
disk_path = os.path.join(data_dir.get_data_dir(), "images", "%s.qcow2" % idx)
if "scsi" in drive_format:
drive_format = "scsi"
disk_target = "sd%s" % letters[(idx % 51)+1]
else:
drive_format = "virtio"
disk_target = "vd%s" % letters[(idx % 51)+1]
disk_source = libvirt.create_local_disk("file", disk_path, '1', "qcow2")
disk.device = "disk"
disk.source = disk.new_disk_source(**{"attrs": {'file': disk_source}})
disk.target = {"dev": disk_target, "bus": drive_format}
disk.driver = {"name": "qemu", 'type': disk_format}
vmxml.add_device(disk)
vmxml.sync()
# Start VM
logging.debug("VM XML: \n%s", vmxml)
try:
vm.start()
except virt_vm.VMStartError, detail:
for msg in failures.items():
if msg[0] in detail:
test.cancel("%s", msg[1])
test.fail("%s" % detail)
# Check the memory and vcpu inside guest
memtotal = vm.get_totalmem_sys()
cpucount = vm.get_cpu_count()
session = vm.wait_for_login()
if network_str:
guestnetworks = int(session.cmd_output(network_str))
logging.debug("guestnet: %d", guestnetworks)
if (guestnetworks - 2) != num_network:
failed = True
logging.error("mismatch in guest network devices: \n"
"Expected: %d\nActual: %d", num_network,
guestnetworks)
if disk_str:
guestdisks = int(session.cmd_output(disk_str))
logging.debug("guestdisk: %d", guestdisks)
if guestdisks != num_disk:
failed = True
logging.error("mismatch in guest disk devices: \n"
"Expected: %d\nActual: %s", num_disk, guestdisks)
session.close()
guestmem = utils_misc.normalize_data_size("%s G" % guestmemory)
# TODO:512 MB threshold deviation value, need to normalize
if int(float(guestmem) - memtotal) > 512:
failed = True
logging.error("mismatch in guest memory: \nExpected: "
"%s\nActual: %s", float(guestmem), memtotal)
if cpucount != current_vcpu:
failed = True
logging.error("mismatch in guest vcpu:\nExpected: %d\nActual: "
"%d", current_vcpu, cpucount)
if failed:
test.fail("Consult previous failures")
def run(test, params, env):
"""
convert specific kvm guest to rhev
"""
for v in list(params.values()):
if "V2V_EXAMPLE" in v:
test.cancel("Please set real value for %s" % v)
if utils_v2v.V2V_EXEC is None:
raise ValueError('Missing command: virt-v2v')
hypervisor = params.get("hypervisor")
vm_name = params.get('main_vm', 'EXAMPLE')
target = params.get('target')
remote_host = params.get('remote_host', 'EXAMPLE')
input_mode = params.get("input_mode")
output_mode = params.get('output_mode')
output_format = params.get('output_format')
source_user = params.get("username", "root")
storage = params.get('output_storage')
storage_name = params.get('storage_name')
bridge = params.get('bridge')
network = params.get('network')
ntp_server = params.get('ntp_server')
vpx_dc = params.get("vpx_dc")
esx_ip = params.get("esx_hostname")
address_cache = env.get('address_cache')
pool_name = params.get('pool_name', 'v2v_test')
pool_type = params.get('pool_type', 'dir')
pool_target = params.get('pool_target_path', 'v2v_pool')
pvt = utlv.PoolVolumeTest(test, params)
v2v_opts = params.get('v2v_opts', '-v -x')
v2v_timeout = int(params.get('v2v_timeout', 3600))
skip_check = 'yes' == params.get('skip_check', 'no')
status_error = 'yes' == params.get('status_error', 'no')
checkpoint = params.get('checkpoint', '')
debug_kernel = 'debug_kernel' == checkpoint
backup_list = ['floppy', 'floppy_devmap', 'fstab_cdrom',
'sata_disk', 'network_rtl8139', 'network_e1000',
'spice', 'spice_encrypt', 'spice_qxl',
'spice_cirrus', 'vnc_qxl', 'vnc_cirrus', 'blank_2nd_disk',
'listen_none', 'listen_socket', 'only_net', 'only_br']
error_list = []
# Prepare step for different hypervisor
if hypervisor == "esx":
source_ip = params.get("vpx_hostname")
source_pwd = params.get("vpx_password")
vpx_passwd_file = params.get("vpx_passwd_file")
# Create password file to access ESX hypervisor
with open(vpx_passwd_file, 'w') as f:
f.write(source_pwd)
elif hypervisor == "xen":
source_ip = params.get("xen_hostname")
source_pwd = params.get("xen_host_passwd")
# Set up ssh access using ssh-agent and authorized_keys
ssh_key.setup_ssh_key(source_ip, source_user, source_pwd)
try:
utils_misc.add_identities_into_ssh_agent()
except Exception as e:
process.run("ssh-agent -k")
test.error("Fail to setup ssh-agent \n %s" % str(e))
elif hypervisor == "kvm":
source_ip = None
source_pwd = None
else:
test.cancel("Unspported hypervisor: %s" % hypervisor)
# Create libvirt URI
v2v_uri = utils_v2v.Uri(hypervisor)
remote_uri = v2v_uri.get_uri(source_ip, vpx_dc, esx_ip)
logging.debug("libvirt URI for converting: %s", remote_uri)
# Make sure the VM exist before convert
v2v_virsh = None
close_virsh = False
if hypervisor == 'kvm':
v2v_virsh = virsh
else:
virsh_dargs = {'uri': remote_uri,
'remote_ip': source_ip,
'remote_user': source_user,
'remote_pwd': source_pwd,
'debug': True}
v2v_virsh = virsh.VirshPersistent(**virsh_dargs)
close_virsh = True
if not v2v_virsh.domain_exists(vm_name):
test.error("VM '%s' not exist" % vm_name)
def log_fail(msg):
"""
Log error and update error list
"""
logging.error(msg)
error_list.append(msg)
def vm_shell(func):
"""
Decorator of shell session to vm
"""
def wrapper(*args, **kwargs):
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get('address_cache'))
if vm.is_dead():
logging.info('VM is down. Starting it now.')
vm.start()
session = vm.wait_for_login()
kwargs['session'] = session
kwargs['vm'] = vm
func(*args, **kwargs)
if session:
session.close()
vm.shutdown()
return wrapper
def check_disks(vmcheck):
"""
Check disk counts inside the VM
"""
# Initialize windows boot up
os_type = params.get("os_type", "linux")
expected_disks = int(params.get("ori_disks", "1"))
logging.debug("Expect %s disks im VM after convert", expected_disks)
# Get disk counts
if os_type == "linux":
cmd = "lsblk |grep disk |wc -l"
disks = int(vmcheck.session.cmd(cmd).strip())
else:
cmd = r"echo list disk > C:\list_disk.txt"
vmcheck.session.cmd(cmd)
cmd = r"diskpart /s C:\list_disk.txt"
output = vmcheck.session.cmd(cmd).strip()
logging.debug("Disks in VM: %s", output)
disks = len(re.findall('Disk\s\d', output))
logging.debug("Find %s disks in VM after convert", disks)
if disks == expected_disks:
logging.info("Disk counts is expected")
else:
log_fail("Disk counts is wrong")
def check_vmlinuz_initramfs(v2v_output):
"""
Check if vmlinuz matches initramfs on multi-kernel case
"""
logging.debug('Checking if vmlinuz matches initramfs')
kernel_strs = re.findall('(\* kernel.*?\/boot\/config){1,}', v2v_output, re.DOTALL)
if len(kernel_strs) == 0:
test.error("Not find kernel information")
# Remove duplicate items by set
logging.debug('Boots and kernel info: %s' % set(kernel_strs))
for str_i in set(kernel_strs):
# Fine all versions
kernel_vers = re.findall('((?:\d+\.){1,}\d+-(?:\d+\.){1,}\w+)', str_i)
logging.debug('kernel related versions: %s' % kernel_vers)
# kernel_vers = [kernel, vmlinuz, initramfs] and they should be same
if len(kernel_vers) < 3 or len(set(kernel_vers)) != 1:
log_fail("kernel versions does not match: %s" % kernel_vers)
def check_boot_kernel(vmcheck):
"""
Check if converted vm use the latest kernel
"""
_, current_kernel = vmcheck.run_cmd('uname -r')
if 'debug' in current_kernel:
log_fail('Current kernel is a debug kernel: %s' % current_kernel)
# 'sort -V' can satisfy our testing, even though it's not strictly perfect.
# The last one is always the latest kernel version
kernel_normal_list = vmcheck.run_cmd('rpm -q kernel | sort -V')[1].strip().splitlines()
status, kernel_debug = vmcheck.run_cmd('rpm -q kernel-debug')
if status != 0:
test.error('Not found kernel-debug package')
all_kernel_list = kernel_normal_list + kernel_debug.strip().splitlines()
logging.debug('All kernels: %s' % all_kernel_list)
if len(all_kernel_list) < 3:
test.error('Needs at least 2 normal kernels and 1 debug kernel in VM')
# The latest non-debug kernel must be kernel_normal_list[-1]
if current_kernel.strip() != kernel_normal_list[-1].lstrip('kernel-'):
log_fail('Check boot kernel failed')
def check_floppy_exist(vmcheck):
"""
Check if floppy exists after convertion
"""
blk = vmcheck.session.cmd('lsblk')
logging.info(blk)
if not re.search('fd0', blk):
log_fail('Floppy not found')
def attach_removable_media(type, source, dev):
bus = {'cdrom': 'ide', 'floppy': 'fdc', 'disk': 'virtio'}
args = {'driver': 'qemu', 'subdriver': 'raw', 'sourcetype': 'file',
'type': type, 'targetbus': bus[type]}
if type == 'cdrom':
args.update({'mode': 'readonly'})
config = ''
# Join all options together to get command line
for key in list(args.keys()):
config += ' --%s %s' % (key, args[key])
config += ' --current'
virsh.attach_disk(vm_name, source, dev, extra=config)
def change_disk_bus(dest):
"""
Change all disks' bus type to $dest
"""
bus_list = ['ide', 'sata', 'virtio']
if dest not in bus_list:
test.error('Bus type not support')
dev_prefix = ['h', 's', 'v']
dev_table = dict(list(zip(bus_list, dev_prefix)))
logging.info('Change disk bus to %s' % dest)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.get_disk_all()
index = 0
for disk in list(disks.values()):
if disk.get('device') != 'disk':
continue
target = disk.find('target')
target.set('bus', dest)
target.set('dev', dev_table[dest] + 'd' + string.ascii_lowercase[index])
disk.remove(disk.find('address'))
index += 1
vmxml.sync()
def change_network_model(model):
"""
Change network model to $model
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
network_list = vmxml.get_iface_all()
for node in list(network_list.values()):
if node.get('type') == 'network':
node.find('model').set('type', model)
vmxml.sync()
def attach_network_card(model):
"""
Attach network card based on model
"""
if model not in ('e1000', 'virtio', 'rtl8139'):
test.error('Network model not support')
options = {'type': 'network', 'source': 'default', 'model': model}
line = ''
for key in options:
line += ' --' + key + ' ' + options[key]
line += ' --current'
logging.debug(virsh.attach_interface(vm_name, option=line))
def check_multi_netcards(mac_list, virsh_instance):
"""
Check if number and type of network cards meet expectation
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
iflist = vmxml.get_iface_all()
logging.debug('MAC list before v2v: %s' % mac_list)
logging.debug('MAC list after v2v: %s' % list(iflist.keys()))
if set(mac_list).difference(list(iflist.keys())):
log_fail('Missing network interface')
for mac in iflist:
if iflist[mac].find('model').get('type') != 'virtio':
log_fail('Network not convert to virtio')
@vm_shell
def insert_floppy_devicemap(**kwargs):
"""
Add an entry of floppy to device.map
"""
session = kwargs['session']
line = '(fd0) /dev/fd0'
devmap = '/boot/grub/device.map'
if session.cmd_status('ls %s' % devmap):
devmap = '/boot/grub2/device.map'
cmd_exist = 'grep \'(fd0)\' %s' % devmap
cmd_set = 'sed -i \'2i%s\' %s' % (line, devmap)
if session.cmd_status(cmd_exist):
session.cmd(cmd_set)
def make_label(session):
"""
Label a volume, swap or root volume
"""
# swaplabel for rhel7 with xfs, e2label for rhel6 or ext*
cmd_map = {'root': 'e2label %s ROOT',
'swap': 'swaplabel -L SWAPPER %s'}
if not session.cmd_status('swaplabel --help'):
blk = 'swap'
elif not session.cmd_status('which e2label'):
blk = 'root'
else:
test.error('No tool to make label')
entry = session.cmd('blkid|grep %s' % blk).strip()
path = entry.split()[0].strip(':')
cmd_label = cmd_map[blk] % path
if 'LABEL' not in entry:
session.cmd(cmd_label)
return blk
@vm_shell
def specify_fstab_entry(type, **kwargs):
"""
Specify entry in fstab file
"""
type_list = ['cdrom', 'uuid', 'label', 'sr0', 'invalid']
if type not in type_list:
test.error('Not support %s in fstab' % type)
session = kwargs['session']
# Specify cdrom device
if type == 'cdrom':
line = '/dev/cdrom /media/CDROM auto exec'
if 'grub2' in utils_misc.get_bootloader_cfg(session):
line += ',nofail'
line += ' 0 0'
logging.debug('fstab entry is "%s"', line)
cmd = [
'mkdir -p /media/CDROM',
'mount /dev/cdrom /media/CDROM',
'echo "%s" >> /etc/fstab' % line
]
for i in range(len(cmd)):
session.cmd(cmd[i])
elif type == 'sr0':
line = params.get('fstab_content')
session.cmd('echo "%s" >> /etc/fstab' % line)
elif type == 'invalid':
line = utils_misc.generate_random_string(6)
session.cmd('echo "%s" >> /etc/fstab' % line)
else:
map = {'uuid': 'UUID', 'label': 'LABEL'}
logging.info(type)
if session.cmd_status('cat /etc/fstab|grep %s' % map[type]):
# Specify device by UUID
if type == 'uuid':
entry = session.cmd(
'blkid -s UUID|grep swap').strip().split()
# Replace path for UUID
origin = entry[0].strip(':')
replace = entry[1].replace('"', '')
# Specify device by label
elif type == 'label':
blk = make_label(session)
entry = session.cmd('blkid|grep %s' % blk).strip()
# Remove " from LABEL="****"
replace = entry.split()[1].strip().replace('"', '')
# Replace the original id/path with label
origin = entry.split()[0].strip(':')
cmd_fstab = "sed -i 's|%s|%s|' /etc/fstab" % (origin, replace)
session.cmd(cmd_fstab)
fstab = session.cmd_output('cat /etc/fstab')
logging.debug('Content of /etc/fstab:\n%s', fstab)
def create_large_file(session, left_space):
"""
Create a large file to make left space of root less than $left_space MB
"""
cmd_df = "df -m / --output=avail"
df_output = session.cmd(cmd_df).strip()
logging.debug('Command output: %s', df_output)
avail = int(df_output.strip().split('\n')[-1])
logging.info('Available space: %dM' % avail)
if avail > left_space - 1:
tmp_dir = data_dir.get_tmp_dir()
if session.cmd_status('ls %s' % tmp_dir) != 0:
session.cmd('mkdir %s' % tmp_dir)
large_file = os.path.join(tmp_dir, 'file.large')
cmd_create = 'dd if=/dev/zero of=%s bs=1M count=%d' % \
(large_file, avail - left_space + 2)
session.cmd(cmd_create, timeout=v2v_timeout)
logging.info('Available space: %sM' % session.cmd(cmd_df).strip())
@vm_shell
def corrupt_rpmdb(**kwargs):
"""
Corrupt rpm db
"""
session = kwargs['session']
# If __db.* exist, remove them, then touch _db.001 to corrupt db.
if not session.cmd_status('ls /var/lib/rpm/__db.001'):
session.cmd('rm -f /var/lib/rpm/__db.*')
session.cmd('touch /var/lib/rpm/__db.001')
if not session.cmd_status('yum update'):
test.error('Corrupt rpmdb failed')
@vm_shell
def grub_serial_terminal(**kwargs):
"""
Edit the serial and terminal lines of grub.conf
"""
session = kwargs['session']
vm = kwargs['vm']
grub_file = utils_misc.get_bootloader_cfg(session)
if 'grub2' in grub_file:
test.cancel('Skip this case on grub2')
cmd = "sed -i '1iserial -unit=0 -speed=115200\\n"
cmd += "terminal -timeout=10 serial console' %s" % grub_file
session.cmd(cmd)
@vm_shell
def set_selinux(value, **kwargs):
"""
Set selinux stat of guest
"""
session = kwargs['session']
current_stat = session.cmd_output('getenforce').strip()
logging.debug('Current selinux status: %s', current_stat)
if current_stat != value:
cmd = "sed -E -i 's/(^SELINUX=).*?/\\1%s/' /etc/selinux/config" % value
logging.info('Set selinux stat with command %s', cmd)
session.cmd(cmd)
@vm_shell
def get_firewalld_status(**kwargs):
"""
Return firewalld service status of vm
"""
session = kwargs['session']
# Example: Active: active (running) since Fri 2019-03-15 01:03:39 CST; 3min 48s ago
firewalld_status = session.cmd('systemctl status firewalld.service|grep Active:',
ok_status=[0, 3]).strip()
# Exclude the time string because time changes if vm restarts
firewalld_status = re.search('Active:\s\w*\s\(\w*\)', firewalld_status).group()
logging.info('Status of firewalld: %s', firewalld_status)
params[checkpoint] = firewalld_status
def check_firewalld_status(vmcheck, expect_status):
"""
Check if status of firewalld meets expectation
"""
firewalld_status = vmcheck.session.cmd('systemctl status '
'firewalld.service|grep Active:',
ok_status=[0, 3]).strip()
# Exclude the time string because time changes if vm restarts
firewalld_status = re.search('Active:\s\w*\s\(\w*\)', firewalld_status).group()
logging.info('Status of firewalld after v2v: %s', firewalld_status)
if firewalld_status != expect_status:
log_fail('Status of firewalld changed after conversion')
@vm_shell
def vm_cmd(cmd_list, **kwargs):
"""
Excecute a list of commands on guest.
"""
session = kwargs['session']
for cmd in cmd_list:
logging.info('Send command "%s"', cmd)
# 'chronyc waitsync' needs more than 2mins to sync clock,
# We set timeout to 300s will not have side-effects for other
# commands.
status, output = session.cmd_status_output(cmd, timeout=300)
logging.debug('Command output:\n%s', output)
if status != 0:
test.error('Command "%s" failed' % cmd)
logging.info('All commands executed')
def check_time_keep(vmcheck):
"""
Check time drift after convertion.
"""
logging.info('Check time drift')
output = vmcheck.session.cmd('chronyc tracking')
logging.debug(output)
if 'Not synchronised' in output:
log_fail('Time not synchronised')
lst_offset = re.search('Last offset *?: *(.*) ', output).group(1)
drift = abs(float(lst_offset))
logging.debug('Time drift is: %f', drift)
if drift > 3:
log_fail('Time drift exceeds 3 sec')
def check_boot():
"""
Check if guest can boot up after configuration
"""
try:
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get('address_cache'))
if vm.is_alive():
vm.shutdown()
logging.info('Booting up %s' % vm_name)
vm.start()
vm.wait_for_login()
vm.shutdown()
logging.info('%s is down' % vm_name)
except Exception as e:
test.error('Bootup guest and login failed: %s', str(e))
def check_result(result, status_error):
"""
Check virt-v2v command result
"""
utlv.check_exit_status(result, status_error)
output = result.stdout + result.stderr
if skip_check:
logging.info('Skip checking vm after conversion')
elif not status_error:
if output_mode == 'rhev':
if not utils_v2v.import_vm_to_ovirt(params, address_cache,
timeout=v2v_timeout):
test.fail('Import VM failed')
if output_mode == 'libvirt':
try:
virsh.start(vm_name, debug=True, ignore_status=False)
except Exception as e:
test.fail('Start vm failed: %s' % str(e))
# Check guest following the checkpoint document after convertion
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
if params.get('skip_check') != 'yes':
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=vmchecker.virsh_instance)
logging.debug(vmxml)
if checkpoint == 'multi_kernel':
check_boot_kernel(vmchecker.checker)
check_vmlinuz_initramfs(output)
if checkpoint == 'floppy':
# Convert to rhv will remove all removeable devices(floppy, cdrom)
if output_mode in ['local', 'libvirt']:
check_floppy_exist(vmchecker.checker)
if checkpoint == 'multi_disks':
check_disks(vmchecker.checker)
if checkpoint == 'multi_netcards':
check_multi_netcards(params['mac_address'],
vmchecker.virsh_instance)
if checkpoint.startswith(('spice', 'vnc')):
if checkpoint == 'spice_encrypt':
vmchecker.check_graphics(params[checkpoint])
else:
graph_type = checkpoint.split('_')[0]
vmchecker.check_graphics({'type': graph_type})
video_type = vmxml.get_devices('video')[0].model_type
if video_type.lower() != 'qxl':
log_fail('Video expect QXL, actual %s' % video_type)
if checkpoint.startswith('listen'):
listen_type = vmxml.get_devices('graphics')[0].listen_type
logging.info('listen type is: %s', listen_type)
if listen_type != checkpoint.split('_')[-1]:
log_fail('listen type changed after conversion')
if checkpoint.startswith('selinux'):
status = vmchecker.checker.session.cmd(
'getenforce').strip().lower()
logging.info('Selinux status after v2v:%s', status)
if status != checkpoint[8:]:
log_fail('Selinux status not match')
if checkpoint == 'guest_firewalld_status':
check_firewalld_status(vmchecker.checker, params[checkpoint])
if checkpoint in ['ntpd_on', 'sync_ntp']:
check_time_keep(vmchecker.checker)
# Merge 2 error lists
error_list.extend(vmchecker.errors)
log_check = utils_v2v.check_log(params, output)
if log_check:
log_fail(log_check)
if len(error_list):
test.fail('%d checkpoints failed: %s' %
(len(error_list), error_list))
try:
v2v_params = {
'target': target,
'hypervisor': hypervisor,
'main_vm': vm_name,
'input_mode': input_mode,
'network': network,
'bridge': bridge,
'storage': storage,
'hostname': source_ip,
'v2v_opts': v2v_opts,
'new_name': vm_name + utils_misc.generate_random_string(3)}
if vpx_dc:
v2v_params.update({"vpx_dc": vpx_dc})
if esx_ip:
v2v_params.update({"esx_ip": esx_ip})
output_format = params.get('output_format')
if output_format:
v2v_params.update({'output_format': output_format})
# Build rhev related options
if output_mode == 'rhev':
# Create different sasl_user name for different job
params.update({'sasl_user': params.get("sasl_user") +
utils_misc.generate_random_string(3)})
logging.info('sals user name is %s' % params.get("sasl_user"))
# Create SASL user on the ovirt host
user_pwd = "[['%s', '%s']]" % (params.get("sasl_user"),
params.get("sasl_pwd"))
v2v_sasl = utils_sasl.SASL(sasl_user_pwd=user_pwd)
v2v_sasl.server_ip = params.get("remote_ip")
v2v_sasl.server_user = params.get('remote_user')
v2v_sasl.server_pwd = params.get('remote_pwd')
v2v_sasl.setup(remote=True)
if output_mode == 'local':
v2v_params['storage'] = data_dir.get_tmp_dir()
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
# Set libguestfs environment variable
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
# Save origin graphic type for result checking if source is KVM
if hypervisor == 'kvm':
ori_vm_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
params['ori_graphic'] = ori_vm_xml.xmltreefile.find(
'devices').find('graphics').get('type')
backup_xml = None
# Only kvm guest's xml needs to be backup currently
if checkpoint in backup_list and hypervisor == 'kvm':
backup_xml = ori_vm_xml
if checkpoint == 'multi_disks':
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=v2v_virsh)
disk_count = 0
for disk in list(new_xml.get_disk_all().values()):
if disk.get('device') == 'disk':
disk_count += 1
if disk_count <= 1:
test.error('Not enough disk devices')
params['ori_disks'] = disk_count
if checkpoint == 'sata_disk':
change_disk_bus('sata')
if checkpoint.startswith('floppy'):
img_path = data_dir.get_tmp_dir() + '/floppy.img'
utlv.create_local_disk('floppy', img_path)
attach_removable_media('floppy', img_path, 'fda')
if checkpoint == 'floppy_devmap':
insert_floppy_devicemap()
if checkpoint.startswith('fstab'):
if checkpoint == 'fstab_cdrom':
img_path = data_dir.get_tmp_dir() + '/cdrom.iso'
utlv.create_local_disk('iso', img_path)
attach_removable_media('cdrom', img_path, 'hdc')
specify_fstab_entry(checkpoint[6:])
if checkpoint == 'running':
virsh.start(vm_name)
logging.info('VM state: %s' %
virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'paused':
virsh.start(vm_name, '--paused')
logging.info('VM state: %s' %
virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'serial_terminal':
grub_serial_terminal()
check_boot()
if checkpoint == 'no_space':
@vm_shell
def take_space(**kwargs):
create_large_file(kwargs['session'], 20)
take_space()
if checkpoint.startswith('host_no_space'):
session = aexpect.ShellSession('sh')
create_large_file(session, 1000)
if checkpoint == 'host_no_space_setcache':
logging.info('Set LIBGUESTFS_CACHEDIR=/home')
os.environ['LIBGUESTFS_CACHEDIR'] = '/home'
if checkpoint == 'corrupt_rpmdb':
corrupt_rpmdb()
if checkpoint.startswith('network'):
change_network_model(checkpoint[8:])
if checkpoint == 'multi_netcards':
params['mac_address'] = []
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=v2v_virsh)
network_list = vmxml.get_iface_all()
for mac in network_list:
if network_list[mac].get('type') in ['bridge', 'network']:
params['mac_address'].append(mac)
if len(params['mac_address']) < 2:
test.error('Not enough network interface')
logging.debug('MAC address: %s' % params['mac_address'])
if checkpoint.startswith(('spice', 'vnc')):
if checkpoint == 'spice_encrypt':
spice_passwd = {'type': 'spice',
'passwd': params.get('spice_passwd', 'redhat')}
vm_xml.VMXML.set_graphics_attr(vm_name, spice_passwd)
params[checkpoint] = {'type': 'spice',
'passwdValidTo': '1970-01-01T00:00:01'}
else:
graphic_video = checkpoint.split('_')
graphic = graphic_video[0]
logging.info('Set graphic type to %s', graphic)
vm_xml.VMXML.set_graphics_attr(vm_name, {'type': graphic})
if len(graphic_video) > 1:
video_type = graphic_video[1]
logging.info('Set video type to %s', video_type)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
video = vmxml.xmltreefile.find(
'devices').find('video').find('model')
video.set('type', video_type)
# cirrus doesn't support 'ram' and 'vgamem' attribute
if video_type == 'cirrus':
[video.attrib.pop(attr_i) for attr_i in [
'ram', 'vgamem'] if attr_i in video.attrib]
vmxml.sync()
if checkpoint.startswith('listen'):
listen_type = checkpoint.split('_')[-1]
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
listen = vmxml.xmltreefile.find(
'devices').find('graphics').find('listen')
listen.set('type', listen_type)
vmxml.sync()
if checkpoint == 'host_selinux_on':
params['selinux_stat'] = utils_selinux.get_status()
utils_selinux.set_status('enforcing')
if checkpoint.startswith('selinux'):
set_selinux(checkpoint[8:])
if checkpoint.startswith('host_firewalld'):
service_mgr = service.ServiceManager()
logging.info('Backing up firewall services status')
params['bk_firewalld_status'] = service_mgr.status('firewalld')
if 'start' in checkpoint:
service_mgr.start('firewalld')
if 'stop' in checkpoint:
service_mgr.stop('firewalld')
if checkpoint == 'guest_firewalld_status':
get_firewalld_status()
if checkpoint == 'remove_securetty':
logging.info('Remove /etc/securetty file from guest')
cmd = ['rm -f /etc/securetty']
vm_cmd(cmd)
if checkpoint == 'ntpd_on':
logging.info('Set service chronyd on')
cmd = ['yum -y install chrony',
'systemctl start chronyd',
'chronyc add server %s' % ntp_server]
vm_cmd(cmd)
if checkpoint == 'sync_ntp':
logging.info('Sync time with %s', ntp_server)
cmd = ['yum -y install chrony',
'systemctl start chronyd',
'chronyc add server %s' % ntp_server,
'chronyc waitsync']
vm_cmd(cmd)
if checkpoint == 'blank_2nd_disk':
disk_path = os.path.join(data_dir.get_tmp_dir(), 'blank.img')
logging.info('Create blank disk %s', disk_path)
process.run('truncate -s 1G %s' % disk_path)
logging.info('Attach blank disk to vm')
attach_removable_media('disk', disk_path, 'vdc')
logging.debug(virsh.dumpxml(vm_name))
if checkpoint in ['only_net', 'only_br']:
logging.info('Detatch all networks')
virsh.detach_interface(vm_name, 'network --current', debug=True)
logging.info('Detatch all bridges')
virsh.detach_interface(vm_name, 'bridge --current', debug=True)
if checkpoint == 'only_net':
logging.info('Attach network')
virsh.attach_interface(
vm_name, 'network default --current', debug=True)
v2v_params.pop('bridge')
if checkpoint == 'only_br':
logging.info('Attatch bridge')
virsh.attach_interface(
vm_name, 'bridge virbr0 --current', debug=True)
v2v_params.pop('network')
if checkpoint == 'no_libguestfs_backend':
os.environ.pop('LIBGUESTFS_BACKEND')
if checkpoint == 'file_image':
vm = env.get_vm(vm_name)
disk = vm.get_first_disk_devices()
logging.info('Disk type is %s', disk['type'])
if disk['type'] != 'file':
test.error('Guest is not with file image')
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if v2v_params.get('new_name'):
vm_name = params['main_vm'] = v2v_params['new_name']
check_result(v2v_result, status_error)
finally:
if close_virsh:
v2v_virsh.close_session()
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if backup_xml:
backup_xml.sync()
if params.get('selinux_stat') and params['selinux_stat'] != 'disabled':
utils_selinux.set_status(params['selinux_stat'])
if 'bk_firewalld_status' in params:
service_mgr = service.ServiceManager()
if service_mgr.status('firewalld') != params['bk_firewalld_status']:
if params['bk_firewalld_status']:
service_mgr.start('firewalld')
else:
service_mgr.stop('firewalld')
if checkpoint.startswith('host_no_space'):
large_file = os.path.join(data_dir.get_tmp_dir(), 'file.large')
if os.path.isfile(large_file):
os.remove(large_file)
# Cleanup constant files
utils_v2v.cleanup_constant_files(params)
def vm_stress_events(self, event, vm):
"""
Stress events
:param event: event name
:param vm: vm object
"""
dargs = {'ignore_status': True, 'debug': True}
for itr in range(self.iterations):
if "vcpupin" in event:
for vcpu in range(int(self.current_vcpu)):
result = virsh.vcpupin(vm.name, vcpu,
random.choice(self.host_cpu_list),
**dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
elif "emulatorpin" in event:
for vcpu in range(int(self.current_vcpu)):
result = virsh.emulatorpin(vm.name,
random.choice(
self.host_cpu_list),
**dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
elif "suspend" in event:
result = virsh.suspend(vm.name, **dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
time.sleep(self.event_sleep_time)
result = virsh.resume(vm.name, **dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
elif "cpuhotplug" in event:
result = virsh.setvcpus(vm.name, self.max_vcpu, "--live",
**dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
exp_vcpu = {'max_config': self.max_vcpu,
'max_live': self.max_vcpu,
'cur_config': self.current_vcpu,
'cur_live': self.max_vcpu,
'guest_live': self.max_vcpu}
utils_hotplug.check_vcpu_value(
vm, exp_vcpu, option="--live")
time.sleep(self.event_sleep_time)
result = virsh.setvcpus(vm.name, self.current_vcpu, "--live",
**dargs)
if not self.ignore_status:
libvirt.check_exit_status(result)
exp_vcpu = {'max_config': self.max_vcpu,
'max_live': self.max_vcpu,
'cur_config': self.current_vcpu,
'cur_live': self.current_vcpu,
'guest_live': self.current_vcpu}
utils_hotplug.check_vcpu_value(
vm, exp_vcpu, option="--live")
elif "reboot" in event:
vm.reboot()
elif "nethotplug" in event:
for iface_num in range(int(self.iface_num)):
logging.debug("Try to attach interface %d" % iface_num)
mac = utils_net.generate_mac_address_simple()
options = ("%s %s --model %s --mac %s %s" %
(self.iface_type, self.iface_source['network'],
self.iface_model, mac, self.attach_option))
logging.debug("VM name: %s , Options for Network attach: %s", vm.name, options)
ret = virsh.attach_interface(vm.name, options,
ignore_status=True)
time.sleep(self.event_sleep_time)
if not self.ignore_status:
libvirt.check_exit_status(ret)
if self.detach_option:
options = ("--type %s --mac %s %s" %
(self.iface_type, mac, self.detach_option))
logging.debug("VM name: %s , Options for Network detach: %s", vm.name, options)
ret = virsh.detach_interface(vm.name, options,
ignore_status=True)
if not self.ignore_status:
libvirt.check_exit_status(ret)
elif "diskhotplug" in event:
for disk_num in range(len(self.device_source_names)):
disk = {}
disk_attach_error = False
disk_name = os.path.join(self.path, vm.name, self.device_source_names[disk_num])
device_source = libvirt.create_local_disk(
self.disk_type, disk_name, self.disk_size, disk_format=self.disk_format)
disk.update({"format": self.disk_format,
"source": device_source})
disk_xml = Disk(self.disk_type)
disk_xml.device = self.disk_device
disk_xml.driver = {"name": self.disk_driver, "type": self.disk_format}
ret = virsh.attach_disk(vm.name, disk["source"], self.device_target[disk_num], self.attach_option, debug=True)
if not self.ignore_status:
libvirt.check_exit_status(ret, disk_attach_error)
if self.detach_option:
ret = virsh.detach_disk(vm.name, self.device_target[disk_num], extra=self.detach_option)
if not self.ignore_status:
libvirt.check_exit_status(ret)
libvirt.delete_local_disk(self.disk_type, disk_name)
else:
raise NotImplementedError
return True
except ShellTimeoutError, detail:
raise error.TestFail("unhotplug failed: %s, " % detail)
tmp_dir = os.path.join(data_dir.get_tmp_dir(), "usb_hotplug_files")
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
try:
result = None
dev_xml = None
opt = "--hmp"
for i in range(attach_count):
if usb_type == "storage":
path = os.path.join(tmp_dir, "%s.img" % i)
libvirt.create_local_disk("file", path, size="1M", disk_format="qcow2")
os.chmod(path, 0666)
if attach_type == "qemu_monitor":
if usb_type == "storage":
attach_cmd = "drive_add"
attach_cmd += (" 0 id=drive-usb-%s,if=none,file=%s" % (i, path))
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=opt)
if result.exit_status or (result.stdout.find("OK") == -1):
raise error.CmdError(result.command, result)
attach_cmd = "device_add usb-storage,"
attach_cmd += ("id=drive-usb-%s,bus=usb1.0,drive=drive-usb-%s" % (i, i))
else:
attach_cmd = "device_add"
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(test.tmpdir, device_source_name)
if test_block_dev:
device_source = libvirt.setup_or_cleanup_iscsi(True)
if not device_source:
# We should skip this case
raise error.TestNAError("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()
def run(test, params, env):
"""
Test pool command:virsh pool_autostart
1) Define a given type pool
2) Mark pool as autostart
3) Restart libvirtd and check pool
4) Destroy the pool
5) Unmark pool as autostart
6) Repeate step(3)
"""
# Initialize the variables
pool_name = params.get("pool_name", "temp_pool_1")
pool_type = params.get("pool_type", "dir")
pool_target = params.get("pool_target", "")
source_format = params.get("source_format", "")
source_name = params.get("pool_source_name", "gluster-vol1")
source_path = params.get("pool_source_path", "/")
ip_protocal = params.get("ip_protocal", "ipv4")
pool_ref = params.get("pool_ref", "name")
pool_uuid = params.get("pool_uuid", "")
invalid_source_path = params.get("invalid_source_path", "")
status_error = "yes" == params.get("status_error", "no")
readonly_mode = "yes" == params.get("readonly_mode", "no")
pre_def_pool = "yes" == params.get("pre_def_pool", "yes")
disk_type = params.get("disk_type", "")
vg_name = params.get("vg_name", "")
lv_name = params.get("lv_name", "")
update_policy = params.get("update_policy")
# Readonly mode
ro_flag = False
if readonly_mode:
logging.debug("Readonly mode test")
ro_flag = True
if pool_target is "":
pool_target = os.path.join(test.tmpdir, pool_target)
# The file for dumped pool xml
p_xml = os.path.join(test.tmpdir, "pool.xml.tmp")
if not libvirt_version.version_compare(1, 0, 0):
if pool_type == "gluster":
test.cancel("Gluster pool is not supported in current"
" libvirt version.")
pool_ins = libvirt_storage.StoragePool()
if pool_ins.pool_exists(pool_name):
test.fail("Pool %s already exist" % pool_name)
def check_pool(pool_name, pool_type, checkpoint,
expect_value="", expect_error=False):
"""
Check the pool after autostart it
:param pool_name: Name of the pool.
:param pool_type: Type of the pool.
:param checkpoint: Which part for checking.
:param expect_value: Expected value.
:param expect_error: Boolen value, expect command success or fail
"""
libvirt_pool = libvirt_storage.StoragePool()
virsh.pool_list(option="--all", debug=True)
if checkpoint == 'State':
actual_value = libvirt_pool.pool_state(pool_name)
if checkpoint == 'Autostart':
actual_value = libvirt_pool.pool_autostart(pool_name)
if actual_value != expect_value:
if not expect_error:
if checkpoint == 'State' and pool_type in ("dir", "scsi"):
error_msg = "Dir pool should be always active when libvirtd restart. "
error_msg += "See https://bugzilla.redhat.com/show_bug.cgi?id=1238610"
logging.error(error_msg)
test.fail("Pool %s isn't %s as expected" % (checkpoint, expect_value))
else:
logging.debug("Pool %s is %s as expected", checkpoint, actual_value)
def change_source_path(new_path, update_policy="set"):
n_poolxml = pool_xml.PoolXML()
n_poolxml = n_poolxml.new_from_dumpxml(pool_name)
s_xml = n_poolxml.get_source()
s_xml.device_path = new_path
if update_policy == "set":
n_poolxml.set_source(s_xml)
elif update_policy == "add":
n_poolxml.add_source("device", {"path": new_path})
else:
test.error("Unsupported policy type")
logging.debug("After change_source_path:\n%s" %
open(n_poolxml.xml).read())
return n_poolxml
# Run Testcase
pvt = utlv.PoolVolumeTest(test, params)
emulated_image = "emulated-image"
kwargs = {'image_size': '1G', 'pre_disk_vol': ['100M'],
'source_name': source_name, 'source_path': source_path,
'source_format': source_format, 'persistent': True,
'ip_protocal': ip_protocal}
pool = pool_name
clean_mount = False
new_device = None
try:
if pre_def_pool:
# Step(1)
# Pool define
pvt.pre_pool(pool_name, pool_type, pool_target, emulated_image,
**kwargs)
# Remove the partition for disk pool
# For sometimes the partition will cause pool start failed
if pool_type == "disk":
virsh.pool_build(pool_name, "--overwrite", debug=True)
# Get pool uuid:
if pool_ref == "uuid" and not pool_uuid:
pool = pool_ins.get_pool_uuid(pool_name)
# Setup logical block device
# Change pool source path
# Undefine pool
# Define pool with new xml
# Start pool
if update_policy:
new_device = utlv.setup_or_cleanup_iscsi(True)
lv_utils.vg_create(vg_name, new_device)
new_device = utlv.create_local_disk(disk_type, size="0.5",
vgname=vg_name, lvname=lv_name)
new_path = new_device
if invalid_source_path:
new_path = invalid_source_path
if pool_type == "fs":
utlv.mkfs(new_device, source_format)
n_poolxml = change_source_path(new_path, update_policy)
p_xml = n_poolxml.xml
if not virsh.pool_undefine(pool_name):
test.fail("Undefine pool %s failed" % pool_name)
if not virsh.pool_define(p_xml):
test.fail("Define pool %s from %s failed" % (pool_name, p_xml))
logging.debug("Start pool %s" % pool_name)
result = virsh.pool_start(pool_name, ignore_status=True, debug=True)
utlv.check_exit_status(result, status_error)
# Mount a valid fs to pool target
if pool_type == "fs":
source_list = []
mnt_cmd = ""
pool_target = n_poolxml.target_path
if invalid_source_path:
source_list.append(new_device)
else:
s_devices = n_poolxml.xmltreefile.findall("//source/device")
for dev in s_devices:
source_list.append(dev.get('path'))
try:
for src in source_list:
mnt_cmd = "mount %s %s" % (src, pool_target)
if not process.system(mnt_cmd, shell=True):
clean_mount = True
except process.CmdError:
test.error("Failed to run %s" % mnt_cmd)
# Step(2)
# Pool autostart
logging.debug("Try to mark pool %s as autostart" % pool_name)
result = virsh.pool_autostart(pool, readonly=ro_flag,
ignore_status=True, debug=True)
if not pre_def_pool:
utlv.check_exit_status(result, status_error)
if not result.exit_status:
check_pool(pool_name, pool_type, checkpoint='Autostart',
expect_value="yes", expect_error=status_error)
# Step(3)
# Restart libvirtd and check pool status
logging.info("Try to restart libvirtd")
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
check_pool(pool_name, pool_type, checkpoint="State",
expect_value="active", expect_error=status_error)
# Step(4)
# Pool destroy
if pool_ins.is_pool_active(pool_name):
virsh.pool_destroy(pool_name)
logging.debug("Pool %s destroyed" % pool_name)
# Step(5)
# Pool autostart disable
logging.debug("Try to unmark pool %s as autostart" % pool_name)
result = virsh.pool_autostart(pool, extra="--disable", debug=True,
ignore_status=True)
if not pre_def_pool:
utlv.check_exit_status(result, status_error)
if not result.exit_status:
check_pool(pool_name, pool_type, checkpoint='Autostart',
expect_value="no", expect_error=status_error)
# Repeat step (3)
logging.debug("Try to restart libvirtd")
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
check_pool(pool_name, pool_type, checkpoint='State',
expect_value="inactive", expect_error=status_error)
finally:
# Clean up
logging.debug("Try to clean up env")
try:
if clean_mount is True:
for src in source_list:
process.system("umount %s" % pool_target)
if pre_def_pool:
pvt.cleanup_pool(pool_name, pool_type, pool_target,
emulated_image, **kwargs)
if new_device:
utlv.delete_local_disk(disk_type, vgname=vg_name, lvname=lv_name)
lv_utils.vg_remove(vg_name)
utlv.setup_or_cleanup_iscsi(False)
if os.path.exists(p_xml):
os.remove(p_xml)
except test.fail as details:
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
logging.error(str(details))
def run(test, params, env):
"""
Test disk attachement of multiple disks.
1.Prepare test environment, destroy VMs.
2.Perform 'qemu-img create' operation.
3.Edit disks xml and start the domains.
4.Perform test operation.
5.Recover test environment.
6.Confirm the test result.
"""
def set_vm_controller_xml(vmxml):
"""
Set VM scsi controller xml.
:param vmxml. Domain xml object.
"""
# Add disk scsi controller
scsi_controller = Controller("controller")
scsi_controller.type = "scsi"
scsi_controller.index = "0"
scsi_controller.model = "virtio-scsi"
vmxml.add_device(scsi_controller)
# Redefine domain
vmxml.sync()
def get_vm_disk_xml(dev_type, dev_name, **options):
"""
Create a disk xml object and return it.
:param dev_type. Disk type.
:param dev_name. Disk device name.
:param options. Disk options.
:return: Disk xml object.
"""
# Create disk xml
disk_xml = Disk(type_name=dev_type)
disk_xml.device = "disk"
if options.has_key("sgio") and options["sgio"] != "":
disk_xml.sgio = options["sgio"]
disk_xml.device = "lun"
disk_xml.rawio = "no"
if dev_type == "block":
disk_attr = "dev"
else:
disk_attr = "file"
disk_xml.target = {'dev': options["target"],
'bus': options["bus"]}
disk_xml.source = disk_xml.new_disk_source(
**{'attrs': {disk_attr: dev_name}})
# Add driver options from parameters.
driver_dict = {"name": "qemu"}
if options.has_key("driver"):
for driver_option in options["driver"].split(','):
if driver_option != "":
d = driver_option.split('=')
logging.debug("disk driver option: %s=%s", d[0], d[1])
driver_dict.update({d[0].strip(): d[1].strip()})
disk_xml.driver = driver_dict
if options.has_key("share"):
if options["share"] == "shareable":
disk_xml.share = True
return disk_xml
vm_names = params.get("vms").split()
if len(vm_names) < 2:
raise error.TestNAError("No multi vms provided.")
# Disk specific attributes.
vms_sgio = params.get("virt_disk_vms_sgio", "").split()
vms_share = params.get("virt_disk_vms_share", "").split()
disk_bus = params.get("virt_disk_bus", "virtio")
disk_target = params.get("virt_disk_target", "vdb")
disk_type = params.get("virt_disk_type", "file")
disk_format = params.get("virt_disk_format", "")
scsi_options = params.get("scsi_options", "")
disk_driver_options = params.get("disk_driver_options", "")
hotplug = "yes" == params.get("virt_disk_vms_hotplug", "no")
status_error = params.get("status_error").split()
test_error_policy = "yes" == params.get("virt_disk_test_error_policy",
"no")
test_shareable = "yes" == params.get("virt_disk_test_shareable", "no")
disk_source_path = test.virtdir
# Backup vm xml files.
vms_backup = []
# We just use 2 VMs for testing.
for i in range(2):
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[i])
vms_backup.append(vmxml_backup)
try:
# Create disk images if needed.
disks = []
if disk_format == "scsi":
disk_source = libvirt.create_scsi_disk(scsi_options)
if not disk_source:
raise error.TestNAError("Get scsi disk failed.")
disks.append({"format": "scsi", "source": disk_source})
elif disk_format == "iscsi":
# Create iscsi device if neened.
image_size = params.get("image_size", "100M")
disk_source = libvirt.setup_or_cleanup_iscsi(
is_setup=True, is_login=True, image_size=image_size)
logging.debug("iscsi dev name: %s", disk_source)
# Format the disk and make the file system.
libvirt.mk_part(disk_source, size="10M")
libvirt.mkfs("%s1" % disk_source, "ext3")
disk_source += "1"
disks.append({"format": disk_format,
"source": disk_source})
elif disk_format in ["raw", "qcow2"]:
disk_path = "%s/test.%s" % (disk_source_path, disk_format)
disk_source = libvirt.create_local_disk("file", disk_path, "1",
disk_format=disk_format)
libvirt.mkfs(disk_source, "ext3")
disks.append({"format": disk_format,
"source": disk_source})
# Compose the new domain xml
vms_list = []
for i in range(2):
vm = env.get_vm(vm_names[i])
# Destroy domain first.
if vm.is_alive():
vm.destroy(gracefully=False)
# Configure vm disk options and define vm
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_names[i])
if disk_bus == "scsi":
set_vm_controller_xml(vmxml)
disk_sgio = ""
if len(vms_sgio) > i:
disk_sgio = vms_sgio[i]
shareable = ""
if len(vms_share) > i:
shareable = vms_share[i]
disk_xml = get_vm_disk_xml(disk_type, disk_source,
sgio=disk_sgio, share=shareable,
target=disk_target, bus=disk_bus,
driver=disk_driver_options)
if not hotplug:
# If we are not testing hotplug,
# add disks to domain xml and sync.
vmxml.add_device(disk_xml)
vmxml.sync()
vms_list.append({"name": vm_names[i], "vm": vm,
"status": "yes" == status_error[i],
"disk": disk_xml})
logging.debug("vms_list %s" % vms_list)
for i in range(len(vms_list)):
try:
# Try to start the domain.
vms_list[i]['vm'].start()
# Check if VM is started as expected.
if not vms_list[i]['status']:
raise error.TestFail('VM started unexpectedly.')
session = vms_list[i]['vm'].wait_for_login()
# if we are testing hotplug, it need to start domain and
# then run virsh attach-device command.
if hotplug:
vms_list[i]['disk'].xmltreefile.write()
result = virsh.attach_device(vms_list[i]['name'],
vms_list[i]['disk'].xml).exit_status
os.remove(vms_list[i]['disk'].xml)
# Check if the return code of attach-device
# command is as expected.
if 0 != result and vms_list[i]['status']:
raise error.TestFail('Failed to hotplug disk device')
elif 0 == result and not vms_list[i]['status']:
raise error.TestFail('Hotplug disk device unexpectedly.')
# Check disk error_policy option in VMs.
if test_error_policy:
error_policy = vms_list[i]['disk'].driver["error_policy"]
if i == 0:
# If we testing enospace error policy, only 1 vm used
if error_policy == "enospace":
cmd = ("mount /dev/%s /mnt && dd if=/dev/zero of=/mnt/test"
" bs=1M count=2000 2>&1 | grep 'No space left'"
% disk_target)
s, o = session.cmd_status_output(cmd)
logging.debug("error_policy in vm0 exit %s; output: %s", s, o)
if 0 != s:
raise error.TestFail("Test error_policy %s: cann't see"
" error messages")
session.close()
break
if session.cmd_status("fdisk -l /dev/%s && mount /dev/%s /mnt; ls /mnt"
% (disk_target, disk_target)):
session.close()
raise error.TestFail("Test error_policy: "
"failed to mount disk")
if i == 1:
try:
session0 = vms_list[0]['vm'].wait_for_login(timeout=10)
cmd = ("fdisk -l /dev/%s && mkfs.ext3 -F /dev/%s "
% (disk_target, disk_target))
s, o = session.cmd_status_output(cmd)
logging.debug("error_policy in vm1 exit %s; output: %s", s, o)
session.close()
cmd = ("dd if=/dev/zero of=/mnt/test bs=1M count=100 && dd if="
"/mnt/test of=/dev/null bs=1M;dmesg | grep 'I/O error'")
s, o = session0.cmd_status_output(cmd)
logging.debug("session in vm0 exit %s; output: %s", s, o)
if error_policy == "report":
if s:
raise error.TestFail("Test error_policy %s: cann't report"
" error" % error_policy)
elif error_policy == "ignore":
if 0 == s:
raise error.TestFail("Test error_policy %s: error cann't"
" be ignored" % error_policy)
session0.close()
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError), e:
if error_policy == "stop":
if not vms_list[0]['vm'].is_paused():
raise error.TestFail("Test error_policy %s: cann't stop"
" VM" % error_policy)
else:
logging.error(str(e))
raise error.TestFail("Test error_policy %s: login failed"
% error_policy)
if test_shareable:
if i == 1:
try:
test_str = "teststring"
# Try to write on vm0.
session0 = vms_list[0]['vm'].wait_for_login(timeout=10)
cmd = ("fdisk -l /dev/%s && mount /dev/%s /mnt && echo '%s' "
"> /mnt/test && umount /mnt"
% (disk_target, disk_target, test_str))
s, o = session0.cmd_status_output(cmd)
logging.debug("session in vm0 exit %s; output: %s", s, o)
if s:
raise error.TestFail("Test disk shareable on VM0 failed")
session0.close()
# Try to read on vm1.
cmd = ("fdisk -l /dev/%s && mount /dev/%s /mnt && grep %s"
" /mnt/test && umount /mnt"
% (disk_target, disk_target, test_str))
s, o = session.cmd_status_output(cmd)
logging.debug("session in vm1 exit %s; output: %s", s, o)
if s:
raise error.TestFail("Test disk shareable on VM1 failed")
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError), e:
logging.error(str(e))
raise error.TestFail("Test disk shareable: login failed")
session.close()
except virt_vm.VMStartError:
if vms_list[i]['status']:
raise error.TestFail('VM Failed to start'
' for some reason!')
disk_count = 0
for disk in new_xml.get_disk_all().values():
if disk.get('device') == 'disk':
disk_count += 1
params['ori_disks'] = disk_count
elif checkpoint in multi_kernel_list:
multi_kernel()
elif checkpoint == 'virtio_on':
change_disk_bus('virtio')
elif checkpoint == 'virtio_off':
change_disk_bus('ide')
elif checkpoint == 'sata_disk':
change_disk_bus('sata')
elif checkpoint.startswith('floppy'):
img_path = data_dir.get_tmp_dir() + '/floppy.img'
utlv.create_local_disk('floppy', img_path)
attach_removable_media('floppy', img_path, 'fda')
if checkpoint == 'floppy_devmap':
insert_floppy_devicemap()
elif checkpoint.startswith('fstab'):
if checkpoint == 'fstab_cdrom':
img_path = data_dir.get_tmp_dir() + '/cdrom.iso'
utlv.create_local_disk('iso', img_path)
attach_removable_media('cdrom', img_path, 'hdc')
elif checkpoint == 'fstab_virtio':
change_disk_bus('virtio')
specify_fstab_entry(checkpoint[6:])
elif checkpoint == 'running':
virsh.start(vm_name)
logging.info('VM state: %s' %
virsh.domstate(vm_name).stdout.strip())
# Additional disk images.
disks_img = []
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
try:
for i in range(len(disks)):
disk_xml = Disk(type_name=device_types[i])
# If we are testing image file on iscsi disk,
# mount the disk and then create the image.
if test_file_img_on_disk:
mount_path = "/tmp/diskimg"
if utils.run("mkdir -p %s && mount %s %s"
% (mount_path, disks[i]["source"],
mount_path), ignore_status=True).exit_status:
raise error.TestNAError("Prepare disk failed")
disk_path = "%s/%s.qcow2" % (mount_path, device_source_names[i])
disk_source = libvirt.create_local_disk("file", disk_path, "1",
disk_format="qcow2")
disks_img.append({"format": "qcow2",
"source": disk_source, "path": mount_path})
else:
disk_source = disks[i]["source"]
disk_xml.device = devices[i]
if device_with_source:
if device_types[i] == "file":
dev_attrs = "file"
elif device_types[i] == "dir":
dev_attrs = "dir"
else:
dev_attrs = "dev"
source_dict = {dev_attrs: disk_source}
def run(test, params, env):
"""
Test for hotplug usb device.
"""
# get the params from params
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
usb_type = params.get("usb_type", "kbd")
attach_type = params.get("attach_type", "attach_device")
attach_count = int(params.get("attach_count", "1"))
if usb_type == "storage":
model = params.get("model", "nec-xhci")
index = params.get("index", "1")
status_error = ("yes" == params.get("status_error", "no"))
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
# Set selinux of host.
backup_sestatus = utils_selinux.get_status()
utils_selinux.set_status("permissive")
if usb_type == "storage":
controllers = vm_xml.get_devices(device_type="controller")
devices = vm_xml.get_devices()
for dev in controllers:
if dev.type == "usb" and dev.index == "1":
devices.remove(dev)
controller = Controller("controller")
controller.type = "usb"
controller.index = index
controller.model = model
devices.append(controller)
vm_xml.set_devices(devices)
try:
session = vm.wait_for_login()
except (LoginError, VMError, ShellError) as e:
test.fail("Test failed: %s" % str(e))
def is_hotplug_ok():
try:
output = session.cmd_output("fdisk -l | grep -c '^Disk /dev/.* 1 M'")
if int(output.strip()) != attach_count:
return False
else:
return True
except ShellTimeoutError as detail:
test.fail("unhotplug failed: %s, " % detail)
tmp_dir = os.path.join(data_dir.get_tmp_dir(), "usb_hotplug_files")
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
try:
result = None
dev_xml = None
opt = "--hmp"
for i in range(attach_count):
if usb_type == "storage":
path = os.path.join(tmp_dir, "%s.img" % i)
libvirt.create_local_disk("file", path, size="1M", disk_format="qcow2")
os.chmod(path, 0o666)
if attach_type == "qemu_monitor":
if usb_type == "storage":
attach_cmd = "drive_add"
attach_cmd += (" 0 id=drive-usb-%s,if=none,file=%s" % (i, path))
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=opt)
if result.exit_status or (result.stdout.strip().find("OK") == -1):
raise process.CmdError(result.command, result)
attach_cmd = "device_add usb-storage,"
attach_cmd += ("id=drive-usb-%s,bus=usb1.0,drive=drive-usb-%s" % (i, i))
else:
attach_cmd = "device_add"
attach_cmd += " usb-%s,bus=usb1.0,id=%s%s" % (usb_type, usb_type, i)
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=opt)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
attributes = {'type_name': "usb", 'bus': "1", 'port': "0"}
if usb_type == "storage":
dev_xml = Disk(type_name="file")
dev_xml.device = "disk"
dev_xml.source = dev_xml.new_disk_source(**{"attrs": {'file': path}})
dev_xml.driver = {"name": "qemu", "type": 'qcow2', "cache": "none"}
dev_xml.target = {"dev": 'sdb', "bus": "usb"}
dev_xml.address = dev_xml.new_disk_address(**{"attrs": attributes})
else:
if usb_type == "mouse":
dev_xml = Input("mouse")
elif usb_type == "tablet":
dev_xml = Input("tablet")
else:
dev_xml = Input("keyboard")
dev_xml.input_bus = "usb"
dev_xml.address = dev_xml.new_input_address(**{"attrs": attributes})
result = virsh.attach_device(vm_name, dev_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
if status_error and usb_type == "storage":
if utils_misc.wait_for(is_hotplug_ok, timeout=30):
# Sometimes we meet an error but the ret in $? is 0.
test.fail("\nAttach device successfully in negative case."
"\nExcept it fail when attach count exceed maximum."
"\nDetail: %s" % result)
for i in range(attach_count):
attach_cmd = "device_del"
if attach_type == "qemu_monitor":
if usb_type == "storage":
attach_cmd += (" drive-usb-%s" % i)
else:
if usb_type == "mouse":
attach_cmd += " mouse"
elif usb_type == "tablet":
attach_cmd += " tablet"
else:
attach_cmd += " keyboard"
result = virsh.qemu_monitor_command(vm_name, attach_cmd, options=opt)
if result.exit_status:
raise process.CmdError(result.command, result)
else:
result = virsh.detach_device(vm_name, dev_xml.xml)
if result.exit_status:
raise process.CmdError(result.command, result)
except process.CmdError as e:
if not status_error:
# live attach of device 'input' is not supported
ret = result.stderr.find("Operation not supported")
if usb_type != "storage" and ret > -1:
pass
else:
test.fail("failed to attach device.\nDetail: %s." % result)
finally:
session.close()
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
utils_selinux.set_status(backup_sestatus)
vm_xml_backup.sync()
def run(test, params, env):
"""
Test command: virsh change-media.
The command changes the media used by CD or floppy drives.
Test steps:
1. Prepare test environment.
2. Perform virsh change-media operation.
3. Recover test environment.
4. Confirm the test result.
"""
def is_attached(vmxml_devices, disk_type, source_file, target_dev):
"""
Check attached device and disk exist or not.
:param vmxml_devices: VMXMLDevices instance
:param disk_type: disk's device type: cdrom or floppy
:param source_file : disk's source file to check
:param target_dev : target device name
:return: True/False if backing file and device found
"""
disks = vmxml_devices.by_device_tag('disk')
for disk in disks:
if disk.device != disk_type:
continue
if disk.target['dev'] != target_dev:
continue
if disk.xmltreefile.find('source') is not None:
if disk.source.attrs['file'] != source_file:
continue
else:
continue
# All three conditions met
logging.debug("Find %s in given disk XML", source_file)
return True
logging.debug("Not find %s in gievn disk XML", source_file)
return False
def check_result(vm_name, disk_source, disk_type, disk_target,
flags, vm_state, attach=True):
"""
Check the test result of attach/detach-device command.
"""
active_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
active_attached = is_attached(active_vmxml.devices, disk_type,
disk_source, disk_target)
if vm_state != "transient":
inactive_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name,
options="--inactive")
inactive_attached = is_attached(inactive_vmxml.devices, disk_type,
disk_source, disk_target)
if flags.count("config") and not flags.count("live"):
if vm_state != "transient":
if attach:
if not inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated"
" when --config options used for"
" attachment")
if vm_state != "shutoff":
if active_attached:
raise exceptions.TestFail("Active domain XML updated"
" when --config options used"
" for attachment")
else:
if inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated"
" when --config options used for"
" detachment")
if vm_state != "shutoff":
if not active_attached:
raise exceptions.TestFail("Active domain XML updated"
" when --config options used"
" for detachment")
elif flags.count("live") and not flags.count("config"):
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --live options used for"
" attachment")
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail("Inactive domain XML updated"
" when --live options used for"
" attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --live options used for"
" detachment")
if vm_state in ["paused", "running"]:
if not inactive_attached:
raise exceptions.TestFail("Inactive domain XML updated"
" when --live options used for"
" detachment")
elif flags.count("live") and flags.count("config"):
if attach:
if vm_state in ["paused", "running"]:
if not active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --live --config options"
" used for attachment")
if not inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated"
" when --live --config options "
"used for attachment")
else:
if vm_state in ["paused", "running"]:
if active_attached:
raise exceptions.TestFail("Active domain XML not updated "
"when --live --config options "
"used for detachment")
if inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated"
" when --live --config options "
"used for detachment")
elif flags.count("current") or flags == "":
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --current options used "
"for attachment")
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail("Inactive domain XML updated "
"when --current options used "
"for live attachment")
if vm_state == "shutoff" and not inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated "
"when --current options used for "
"attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --current options used "
"for detachment")
if vm_state in ["paused", "running"]:
if not inactive_attached:
raise exceptions.TestFail("Inactive domain XML updated "
"when --current options used "
"for live detachment")
if vm_state == "shutoff" and inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated "
"when --current options used for "
"detachment")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("change_media_vm_ref")
action = params.get("change_media_action")
action_twice = params.get("change_media_action_twice", "")
pre_vm_state = params.get("pre_vm_state")
options = params.get("change_media_options")
options_twice = params.get("change_media_options_twice", "")
device_type = params.get("change_media_device_type", "cdrom")
target_device = params.get("change_media_target_device", "hdc")
init_iso_name = params.get("change_media_init_iso")
old_iso_name = params.get("change_media_old_iso")
new_iso_name = params.get("change_media_new_iso")
virsh_dargs = {"debug": True, "ignore_status": True}
if device_type not in ['cdrom', 'floppy']:
raise exceptions.TestSkipError("Got a invalid device type:/n%s"
% device_type)
# Backup for recovery.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
old_iso = os.path.join(data_dir.get_tmp_dir(), old_iso_name)
new_iso = os.path.join(data_dir.get_tmp_dir(), new_iso_name)
if vm_ref == "name":
vm_ref = vm_name
if vm.is_alive():
vm.destroy(gracefully=False)
try:
if not init_iso_name:
init_iso = ""
else:
init_iso = os.path.join(data_dir.get_tmp_dir(),
init_iso_name)
# Prepare test files.
libvirt.create_local_disk("iso", old_iso)
libvirt.create_local_disk("iso", new_iso)
# Check domain's disk device
disk_blk = vm_xml.VMXML.get_disk_blk(vm_name)
logging.info("disk_blk %s", disk_blk)
if target_device not in disk_blk:
if vm.is_alive():
virsh.destroy(vm_name)
logging.info("Adding device")
libvirt.create_local_disk("iso", init_iso)
disk_params = {"disk_type": "file", "device_type": device_type,
"driver_name": "qemu", "driver_type": "raw",
"target_bus": "ide", "readonly": "yes"}
libvirt.attach_additional_device(vm_name, target_device,
init_iso, disk_params)
vmxml_for_test = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Turn VM into certain state.
if pre_vm_state == "running":
logging.info("Starting %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
elif pre_vm_state == "shutoff":
logging.info("Shuting down %s..." % vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
elif pre_vm_state == "paused":
logging.info("Pausing %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
if not vm.pause():
raise exceptions.TestSkipError("Cann't pause the domain")
time.sleep(5)
elif pre_vm_state == "transient":
logging.info("Creating %s..." % vm_name)
vm.undefine()
if virsh.create(vmxml_for_test.xml, **virsh_dargs).exit_status:
vmxml_backup.define()
raise exceptions.TestSkipError("Cann't create the domain")
# Libvirt will ignore --source when action is eject
attach = True
device_source = old_iso
if action == "--eject ":
source = ""
attach = False
else:
source = device_source
all_options = action + options + " " + source
ret = virsh.change_media(vm_ref, target_device,
all_options, ignore_status=True, debug=True)
status_error = False
if pre_vm_state == "shutoff":
if options.count("live"):
status_error = True
elif pre_vm_state == "transient":
if options.count("config"):
status_error = True
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# For paused vm, change_media for eject/update operation
# should be executed again for it takes effect
if ret.exit_status:
if not action.count("insert") and not options.count("force"):
ret = virsh.change_media(vm_ref, target_device, all_options,
ignore_status=True, debug=True)
if not status_error and ret.exit_status:
raise exceptions.TestFail("Please check: Bug 1289069 - Ejecting "
"locked cdrom tray using update-device"
" fails but next try succeeds")
libvirt.check_exit_status(ret, status_error)
if not ret.exit_status:
check_result(vm_name, device_source, device_type, target_device,
options, pre_vm_state, attach)
if action_twice:
if pre_vm_state == "paused":
if not vm.pause():
raise exceptions.TestFail("Cann't pause the domain")
time.sleep(5)
attach = True
device_source = new_iso
if action_twice == "--eject ":
#options_twice += " --force "
source = ""
attach = False
else:
source = device_source
all_options = action_twice + options_twice + " " + source
time.sleep(5)
ret = virsh.change_media(vm_ref, target_device, all_options,
ignore_status=True, debug=True)
status_error = False
if pre_vm_state == "shutoff":
if options_twice.count("live"):
status_error = True
elif pre_vm_state == "transient":
if options_twice.count("config"):
status_error = True
if action_twice == "--insert ":
if pre_vm_state in ["running", "paused"]:
if options in ["--force", "--current", "", "--live"]:
if options_twice.count("config"):
status_error = True
elif options == "--config":
if options_twice in ["--force", "--current", ""]:
status_error = True
elif options_twice.count("live"):
status_error = True
elif pre_vm_state == "transient":
if ret.exit_status:
status_error = True
elif pre_vm_state == "shutoff":
if options.count("live"):
status_error = True
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# For paused vm, change_media for eject/update operation
# should be executed again for it takes effect
if ret.exit_status and not action_twice.count("insert"):
ret = virsh.change_media(vm_ref, target_device, all_options,
ignore_status=True, debug=True)
if not status_error and ret.exit_status:
raise exceptions.TestFail("Please check: Bug 1289069 - Ejecting "
"locked cdrom tray using update-device"
" fails but next try succeeds")
libvirt.check_exit_status(ret, status_error)
if not ret.exit_status:
check_result(vm_name, device_source, device_type, target_device,
options_twice, pre_vm_state, attach)
# Try to start vm.
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync()
# Remove disks
if os.path.exists(init_iso):
os.remove(init_iso)
if os.path.exists(old_iso):
os.remove(old_iso)
if os.path.exists(init_iso):
os.remove(new_iso)
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 = libvirt.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 = libvirt.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 qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_cmd = params.get("status_cmd", "")
freeze_cmd = params.get("freeze_cmd", "")
thaw_cmd = params.get("thaw_cmd", "")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
def get_dirty(session, frozen=False):
"""
Get dirty data of guest
"""
try:
data_cmd = "cat /proc/meminfo | grep Dirty"
if not frozen:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) != 0,
60)
if result:
return int(session.cmd_output(data_cmd).strip().
split()[1])
else:
return 0
dirty_info = session.cmd_output(data_cmd).strip()
return int(dirty_info.split()[1])
else:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) == 0,
60)
if result:
return 0
else:
return int(session.cmd_output(data_cmd).strip().
split()[1])
except (IndexError, ValueError) as details:
test.fail("Get dirty info failed: %s" % details)
device_source_path = os.path.join(data_dir.get_tmp_dir(), "disk.img")
device_source = libvirt.create_local_disk("file", path=device_source_path,
disk_format="qcow2")
vm.prepare_guest_agent()
# Do operation before freeze guest filesystem
session = vm.wait_for_login()
tmp_file = "/mnt/test.file"
try:
# Create extra image and attach to guest, then mount
old_parts = libvirt.get_parts_list(session)
ret = virsh.attach_disk(vm_name, device_source, "vdd")
if ret.exit_status:
test.fail("Attaching device failed before testing agent:%s" % ret.stdout.strip())
time.sleep(1)
new_parts = libvirt.get_parts_list(session)
added_part = list(set(new_parts).difference(set(old_parts)))
session.cmd("mkfs.ext3 -F /dev/{0} && mount /dev/{0} /mnt".format(added_part[0]))
# Generate dirty memory
session.cmd("rm -f %s" % tmp_file)
session.cmd_output("cp /dev/zero %s 2>/dev/null &" % tmp_file)
# Get original dirty data
org_dirty_info = get_dirty(session)
fz_cmd_result = virsh.qemu_agent_command(vm_name, freeze_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(fz_cmd_result)
# Get frozen dirty data
fz_dirty_info = get_dirty(session, True)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("frozen"):
test.fail("Guest filesystem status is not frozen: %s"
% st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name, thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("thawed"):
test.fail("Guest filesystem status is not thawed: %s"
% st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
test.fail("The thawed dirty data should not be 0!")
if fz_dirty_info:
test.fail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
finally:
xml_backup.sync()
os.remove(device_source_path)