def replace_os_disk(vm_xml, vm_name, nvram):
"""
Replace os(nvram) and disk(uefi) for x86 vtpm test
:param vm_xml: current vm's xml
:param vm_name: current vm name
:param nvram: nvram file path of vm
"""
# Add loader, nvram in <os>
nvram = nvram.replace("<VM_NAME>", vm_name)
dict_os_attrs = {"loader_readonly": "yes",
"secure": "yes",
"loader_type": "pflash",
"loader": loader,
"nvram": nvram}
vm_xml.set_os_attrs(**dict_os_attrs)
logging.debug("Set smm=on in VMFeaturesXML")
# Add smm in <features>
features_xml = vm_xml.features
features_xml.smm = "on"
vm_xml.features = features_xml
vm_xml.sync()
# Replace disk with an uefi image
if not utils_package.package_install("wget"):
test.error("Failed to install wget on host")
if uefi_disk_url.count("EXAMPLE"):
test.error("Please provide the URL %s" % uefi_disk_url)
else:
download_cmd = ("wget %s -O %s" % (uefi_disk_url, download_file_path))
process.system(download_cmd, verbose=False, shell=True)
vm = env.get_vm(vm_name)
uefi_disk = {'disk_source_name': download_file_path}
libvirt.set_vm_disk(vm, uefi_disk)
def setup_test_mem_nvdimm(vm, params, test):
"""
Setup steps for nvdimm device
:param vm: VM object
:param params: dict, test parameters
:param test: test object
"""
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if vm.is_alive():
vm.destroy(gracefully=False)
nfs_mount_dir = params.get('nfs_mount_dir')
nvdimm_file_size = params.get('nvdimm_file_size')
process.run("truncate -s {} {}/nvdimm".format(nvdimm_file_size,
nfs_mount_dir),
shell=True)
vm_attrs = eval(params.get('vm_attrs', '{}'))
guest_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
# At first remove all existing memory devices
remove_devices(guest_xml, '/devices/memory', 'nvdimm', test)
guest_xml.setup_attrs(**vm_attrs)
mem_device_attrs = eval(params.get('mem_device_attrs', '{}'))
dimm_device = Memory()
dimm_device.setup_attrs(**mem_device_attrs)
guest_xml.add_device(dimm_device)
guest_xml.sync()
vm.start()
vm_session = vm.wait_for_serial_login(timeout=240)
create_file_within_nvdimm_disk(vm_session, params.get("test_file_content"))
vm_session.close()
def setup_volume_pool_env():
"""Setup volume pool environment"""
params.update(
{"virt_disk_device_target": disk_target})
create_lvm_pool()
blk_source_image_after_converted = ("%s" % volume_path_list[0])
# Convert the image from qcow2 to volume
convert_disk_cmd = ("qemu-img convert"
" -O %s %s %s" % (disk_format, first_src_file, blk_source_image_after_converted))
process.run(convert_disk_cmd, ignore_status=False, shell=True)
params.update({'disk_source_name': blk_source_image_after_converted,
'disk_type': 'block',
'disk_format': 'qcow2',
'disk_source_protocol': 'file'})
libvirt.set_vm_disk(vm, params, tmp_dir)
vm.wait_for_login().close()
vm.destroy(gracefully=False)
replace_disk_image, backing_chain_list = libvirt_disk.make_syslink_path_backing_files(
pre_set_root_dir, volume_path_list, disk_format)
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_format': 'qcow2',
'disk_source_protocol': 'file'})
blk_source_image_after_converted = os.path.join(pre_set_root_dir, syslink_top_img)
skip_first_one = True
return replace_disk_image, blk_source_image_after_converted, skip_first_one, backing_chain_list
def run(test, params, env):
"""
Test KVM migration scenarios
"""
migrate_options = params.get("migrate_options", "")
migrate_postcopy = params.get("migrate_postcopy", "")
migrate_dest_ip = params.get("migrate_dest_host")
nfs_mount_path = params.get("nfs_mount_dir")
migrate_start_state = params.get("migrate_start_state", "paused")
postcopy_func = None
if migrate_postcopy:
postcopy_func = virsh.migrate_postcopy
migrate_type = params.get("migrate_type", "orderly")
vm_state = params.get("migrate_vm_state", "running")
ping_count = int(params.get("ping_count", 15))
vms = params.get("vms").split()
vm_list = env.get_all_vms()
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = nfs_mount_path
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params["server_ip"])
vmxml_dict = {}
migrate_setup = libvirt.MigrationTest()
try:
for vm in vm_list:
vmxml_dict[vm.name] = vm_xml.VMXML.new_from_dumpxml(vm.name)
params["source_dist_img"] = "%s-nfs-img" % vm.name
if vm.is_alive():
vm.destroy()
libvirt.set_vm_disk(vm, params)
migrate_setup.ping_vm(vm, test, params, ping_count=ping_count)
try:
migrate_setup.do_migration(vm_list,
src_uri,
dest_uri,
migrate_type,
migrate_options,
func=postcopy_func,
migrate_start_state=migrate_start_state)
except Exception, info:
test.fail(info)
for vm in vm_list:
if not migrate_setup.check_vm_state(vm, vm_state, dest_uri):
test.fail("Migrated VMs failed to be in %s state at "
"destination" % vm_state)
logging.info("Guest state is '%s' at destination is as expected",
vm_state)
migrate_setup.ping_vm(vm,
test,
params,
uri=dest_uri,
ping_count=ping_count)
def prepare_nfs_backingfile(vm, params):
"""
Create an image using nfs type backing_file
:param vm: The guest
:param params: the parameters used
"""
mnt_path_name = params.get("nfs_mount_dir", "nfs-mount")
exp_opt = params.get("export_options", "rw,no_root_squash,fsid=0")
exp_dir = params.get("export_dir", "nfs-export")
backingfile_img = params.get("source_dist_img", "nfs-img")
disk_format = params.get("disk_format", "qcow2")
img_name = params.get("img_name", "test.img")
precreation = "yes" == params.get("precreation", "yes")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
disk_xml = vmxml.devices.by_device_tag('disk')[0]
src_disk_format = disk_xml.xmltreefile.find('driver').get('type')
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
disk_img = os.path.join(os.path.dirname(blk_source), img_name)
res = libvirt.setup_or_cleanup_nfs(True, mnt_path_name, is_mount=True,
export_options=exp_opt,
export_dir=exp_dir)
mnt_path = res["mount_dir"]
params["selinux_status_bak"] = res["selinux_status_bak"]
if vm.is_alive():
vm.destroy(gracefully=False)
disk_cmd = ("qemu-img convert -f %s -O %s %s %s/%s" %
(src_disk_format, disk_format,
blk_source, mnt_path, backingfile_img))
process.run(disk_cmd, ignore_status=False, verbose=True)
local_image_list.append("%s/%s" % (mnt_path, backingfile_img))
logging.debug("Create a local image backing on NFS.")
disk_cmd = ("qemu-img create -f %s -b %s/%s %s" %
(disk_format, mnt_path, backingfile_img, disk_img))
process.run(disk_cmd, ignore_status=False, verbose=True)
local_image_list.append(disk_img)
if precreation:
logging.debug("Create an image backing on NFS on remote host.")
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
utils_misc.make_dirs(os.path.dirname(blk_source), remote_session)
status, stdout = utils_misc.cmd_status_output(
disk_cmd, session=remote_session)
logging.debug("status: {}, stdout: {}".format(status, stdout))
remote_image_list.append("%s/%s" % (mnt_path, backingfile_img))
remote_image_list.append(disk_img)
remote_session.close()
params.update({'disk_source_name': disk_img,
'disk_type': 'file',
'disk_source_protocol': 'file'})
libvirt.set_vm_disk(vm, params)
def run(test, params, env):
"""
Run tests with disk target configurations
"""
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
at_dt = params.get('at_dt')
cmds_in_guest = eval(params.get('cmds_in_guest'))
target_rotation = params.get('target_rotation')
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
if not at_dt:
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug(vm_xml.VMXML.new_from_dumpxml(vm_name))
vm_session = vm.wait_for_login()
pkg_list = params.get("install_pkgs")
if pkg_list:
install_pkg(test, eval(pkg_list), vm_session)
if at_dt:
old_parts = utils_disk.get_parts_list(vm_session)
disk_xml = create_second_disk(params)
virsh.attach_device(vm_name, disk_xml, debug=True, ignore_status=False)
pat_in_dumpxml = params.get('pattern_in_dumpxml')
libvirt_vmxml.check_guest_xml(vm_name, pat_in_dumpxml, status_error=False)
time.sleep(10)
added_parts = utils_disk.get_added_parts(vm_session, old_parts)
if not added_parts or len(added_parts) != 1:
test.error("Only one new partition is expected in the VM, "
"but found {}".format(added_parts))
cmd = cmds_in_guest[0] % added_parts[0]
run_cmd_in_guest(test, vm_session, cmd)
virsh.detach_device(vm_name, disk_xml, debug=True, ignore_status=False)
cmd = cmds_in_guest[1] % added_parts[0]
run_cmd_in_guest(test, vm_session, cmd, any_error=True)
libvirt_vmxml.check_guest_xml(vm_name, pat_in_dumpxml, status_error=True)
else:
if cmds_in_guest:
for cmd_index in range(0, len(cmds_in_guest)):
any_error = False
if not target_rotation and cmd_index == 0:
any_error = True
run_cmd_in_guest(test, vm_session, cmds_in_guest[cmd_index], any_error=any_error)
finally:
backup_xml.sync()
source_file = params.get('source_file')
if source_file:
libvirt.delete_local_disk('file', source_file)
def update_disk(vm, params):
"""
Update disk for testing.
:param vm: vm object.
:param params: the parameters used.
:return: updated images.
"""
local_image_list = []
remote_image_list = []
vm_did_list = []
# Change the disk of the vm
if storage_type == "nfs":
libvirt.set_vm_disk(vm, params)
else:
disk_format = params.get("disk_format", "qcow2")
disk_num = eval(params.get("disk_num", "1"))
blk_source = vm.get_first_disk_devices()['source']
vsize = utils_misc.get_image_info(blk_source).get("vsize")
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
# Create disk on remote host
utils_misc.make_dirs(os.path.dirname(blk_source), remote_session)
libvirt_disk.create_disk("file",
disk_format=disk_format,
path=blk_source,
size=vsize,
session=remote_session)
remote_image_list.append(blk_source)
for idx in range(2, disk_num + 1):
disk_path = os.path.join(os.path.dirname(blk_source),
"test%s.img" % str(idx))
# Create disk on local
libvirt_disk.create_disk("file",
disk_format=disk_format,
path=disk_path)
local_image_list.append(disk_path)
target_dev = 'vd' + chr(idx + ord('a') - 1)
new_disk_dict = {"driver_type": disk_format}
result = libvirt.attach_additional_device(
vm_name, target_dev, disk_path, new_disk_dict, False)
libvirt.check_exit_status(result)
libvirt_disk.create_disk("file",
disk_format=disk_format,
path=disk_path,
session=remote_session)
remote_image_list.append(disk_path)
vm_did_list.append(target_dev)
remote_session.close()
return local_image_list, remote_image_list, vm_did_list
def run(test, params, env):
"""
Negative test for virtio/virtio-non-transitional model of disk
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
status_error = params['status_error']
guest_src_url = params["guest_src_url"]
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
try:
if (params["os_variant"] == 'rhel6'
or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
try:
libvirt.set_vm_disk(vm, params)
except xcepts.LibvirtXMLError:
if status_error == 'undefinable':
return
else:
raise
else:
if status_error == 'undefinable':
test.fail("Vm is expected to fail on defining with"
" invalid model, while it succeeds")
try:
if not vm.is_alive():
vm.start()
vm.wait_for_serial_login()
except remote.LoginTimeoutError:
pass
else:
test.fail("Vm is expected to fail on booting from disk"
" with wrong model, while login successfully.")
data = vm.serial_console.get_output()
if data is None or len(data.splitlines()) < 5:
logging.warn(
"Unable to read serial console or no sufficient data in"
" serial console output to detect the kernel panic.")
else:
match = re.search('Kernel panic', data, re.S | re.M | re.I)
if not match:
test.fail("Can not find 'Kernel panic' keyword in"
" serial console output.")
finally:
backup_xml.sync()
def run(test, params, env):
"""
Negative test for virtio/virtio-non-transitional model of disk
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
status_error = params['status_error']
guest_src_url = params["guest_src_url"]
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
params["blk_source_name"] = target_path
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
try:
if (params["os_variant"] == 'rhel6' or
'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
try:
libvirt.set_vm_disk(vm, params)
except xcepts.LibvirtXMLError:
if status_error == 'undefinable':
return
else:
raise
else:
if status_error == 'undefinable':
test.fail("Vm is expected to fail on defining with"
" invalid model, while it succeeds")
try:
if not vm.is_alive():
vm.start()
vm.wait_for_serial_login()
except (remote.LoginTimeoutError, aexpect.ExpectError):
pass
else:
test.fail("Vm is expected to fail on booting from disk"
" with wrong model, while login successfully.")
finally:
backup_xml.sync()
def setup_test_mem_balloon(vm, params, test):
"""
Setup steps for memory balloon device
:param vm: VM object
:param params: dict, test parameters
:param test: test object
"""
test.log.debug("Setup for testing balloon device")
guest_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
# Update memory balloon device to correct model
membal_dict = {'membal_model': 'virtio', 'membal_stats_period': '10'}
libvirt.update_memballoon_xml(guest_xml, membal_dict)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
def update_vm_with_cluster_disk():
"""
Update vm's first disk with a image which has customized
cluster size
:return: The source image params
"""
source_img_params = params.copy()
source_img_params['image_name'] = params.get('source_image_name',
'source_image')
source_img = qemu_storage.QemuImg(source_img_params, tmp_dir, '')
source_img_path, _ = source_img.create(source_img_params)
file_to_del.append(source_img_path)
source_img_params['disk_source_name'] = source_img_path
libvirt.set_vm_disk(vm, source_img_params)
return source_img_params
def update_disk(self):
"""
Update vm disk with specific params
"""
# Get disk type
disk_type = self.params.get('disk_type')
# Check disk type
if disk_type == 'block':
if not self.vm.is_alive():
self.vm.start()
self.prepare_iscsi()
# Update vm disk
libvirt.set_vm_disk(self.vm, self.params)
def setup_test_large_mem_vm(vm, params, test):
"""
Setup steps for large memory test
:param vm: VM object
:param params: dict, test parameters
:param test: test object
"""
test.log.debug("Setup for testing large memory vm")
guest_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
memory_value = int(params.get("memory_value"))
memory_unit = params.get("memory_unit")
guest_xml.set_memory(memory_value)
guest_xml.set_memory_unit(memory_unit)
guest_xml.sync()
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
def setup_test_mem_device(vm, params, test):
"""
Setup steps for memory device
:param vm: VM object
:param params: dict, test parameters
:param test: test object
"""
test.log.debug("Setup for testing memory device")
guest_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
libvirt_cpu.add_cpu_settings(guest_xml, params)
dimm_params = {
k.replace('memdev_', ''): v
for k, v in params.items() if k.startswith('memdev_')
}
dimm_xml = utils_hotplug.create_mem_xml(**dimm_params)
libvirt.add_vm_device(guest_xml, dimm_xml)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
def run(test, params, env):
"""
Test command: virsh blockpull <domain> <path>
1) Prepare test environment.
2) Populate a disk from its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot(snapshot_take):
"""
Make external snapshots for disks only.
:param snapshot_take: snapshots taken.
"""
for count in range(1, snapshot_take + 1):
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "snapshot_test%s" % count
snap_xml.snap_name = snapshot_name
snap_xml.description = "Snapshot Test %s" % count
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
for src_disk_xml in disks:
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
# Skip cdrom
if disk_xml.device == "cdrom":
continue
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
file_name = disk_xml.source.attrs['file']
new_file = "%s.snap%s" % (file_name.split('.')[0],
count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('name' in disk_xml.source.attrs and
disk_src_protocol == 'gluster'):
src_name = disk_xml.source.attrs['name']
new_name = "%s.snap%s" % (src_name.split('.')[0],
count)
new_attrs.update({'name': new_name})
snapshot_external_disks.append(new_name)
hosts = disk_xml.source.hosts
elif ('dev' in disk_xml.source.attrs or
'name' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block' or
disk_src_protocol in ['iscsi', 'rbd']):
# Use local file as external snapshot target for block
# and iscsi network type.
# As block device will be treat as raw format by
# default, it's not fit for external disk snapshot
# target. A work around solution is use qemu-img again
# with the target.
# And external active snapshots are not supported on
# 'network' disks using 'iscsi' protocol
disk_xml.type_name = 'file'
if 'dev' in new_attrs:
del new_attrs['dev']
elif 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
new_file = "%s/blk_src_file.snap%s" % (tmp_dir, count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
test.fail(snapshot_result.stderr)
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
test.fail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
def get_first_disk_source():
"""
Get disk source of first device
:return: first disk of first device.
"""
first_device = vm.get_first_disk_devices()
firt_disk_src = first_device['source']
return firt_disk_src
def make_relative_path_backing_files():
"""
Create backing chain files of relative path.
:return: absolute path of top active file
"""
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
root_dir = os.path.dirname(first_disk_source)
cmd = "mkdir -p %s" % os.path.join(root_dir, '{b..d}')
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
# Make three external relative path backing files.
backing_file_dict = collections.OrderedDict()
backing_file_dict["b"] = "../%s" % basename
backing_file_dict["c"] = "../b/b.img"
backing_file_dict["d"] = "../c/c.img"
for key, value in list(backing_file_dict.items()):
backing_file_path = os.path.join(root_dir, key)
cmd = ("cd %s && qemu-img create -f qcow2 -o backing_file=%s,backing_fmt=qcow2 %s.img"
% (backing_file_path, value, key))
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
return os.path.join(backing_file_path, "d.img")
def check_chain_backing_files(disk_src_file, expect_backing_file=False):
"""
Check backing chain files of relative path after blockcommit.
:param disk_src_file: first disk src file.
:param expect_backing_file: whether it expect to have backing files.
"""
first_disk_source = get_first_disk_source()
# Validate source image need refer to original one after active blockcommit
if not expect_backing_file and disk_src_file not in first_disk_source:
test.fail("The disk image path:%s doesn't include the origin image: %s" % (first_disk_source, disk_src_file))
# Validate source image doesn't have backing files after active blockcommit
cmd = "qemu-img info %s --backing-chain" % first_disk_source
if qemu_img_locking_feature_support:
cmd = "qemu-img info -U %s --backing-chain" % first_disk_source
ret = process.run(cmd, shell=True).stdout_text.strip()
if expect_backing_file:
if 'backing file' not in ret:
test.fail("The disk image doesn't have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
else:
if 'backing file' in ret:
test.fail("The disk image still have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
snapshot_take = int(params.get("snapshot_take", '0'))
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", 'no')
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", 'no')
bandwidth = params.get("bandwidth", None)
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", None)
keep_relative = "yes" == params.get("keep_relative", 'no')
virsh_dargs = {'debug': True}
# Check whether qemu-img need add -U suboption since locking feature was added afterwards qemu-2.10
qemu_img_locking_feature_support = libvirt_storage.check_qemu_image_lock_support()
backing_file_relative_path = "yes" == params.get("backing_file_relative_path", "no")
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_target = params.get("disk_target", 'vda')
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", "no")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("original xml is %s", vmxml_backup)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
test.fail("There are snapshots created for %s already" % vm_name)
snapshot_external_disks = []
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ""
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
if disk_src_protocol == 'gluster':
if not libvirt_version.version_compare(1, 2, 7):
test.cancel("Snapshot on glusterfs not"
" support in current "
"version. Check more info "
" with https://bugzilla.re"
"dhat.com/show_bug.cgi?id="
"1017289")
# Set vm xml and guest agent
if replace_vm_disk:
if disk_src_protocol == "rbd" and disk_type == "network":
src_host = params.get("disk_source_host", "EXAMPLE_HOSTS")
mon_host = params.get("mon_host", "EXAMPLE_MON_HOST")
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(mon_host)
if src_host.count("EXAMPLE") or mon_host.count("EXAMPLE"):
test.cancel("Please provide ceph host first.")
if backing_file_relative_path:
if vm.is_alive():
vm.destroy(gracefully=False)
first_src_file = get_first_disk_source()
blk_source_image = os.path.basename(first_src_file)
blk_source_folder = os.path.dirname(first_src_file)
replace_disk_image = make_relative_path_backing_files()
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_src_protocol': 'file'})
vm.start()
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
# The first disk is supposed to include OS
# We will perform blockpull operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
make_disk_snapshot(snapshot_take)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
logging.debug("The domain xml after snapshot is %s" % vmxml)
# snapshot src file list
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
if snap_in_mirror:
blockpull_options = "--bandwidth 1"
else:
blockpull_options = "--wait --verbose"
if with_timeout:
blockpull_options += " --timeout 1"
if bandwidth:
blockpull_options += " --bandwidth %s" % bandwidth
if base_option == "async":
blockpull_options += " --async"
base_image = None
base_index = None
if (libvirt_version.version_compare(1, 2, 4) or
disk_src_protocol == 'gluster'):
# For libvirt is older version than 1.2.4 or source protocol is gluster
# there are various base image,which depends on base option:shallow,base,top respectively
if base_option == "shallow":
base_index = 1
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "base":
base_index = 2
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "top":
base_index = 0
base_image = "%s[%s]" % (disk_target, base_index)
else:
if base_option == "shallow":
base_image = snap_src_lst[3]
elif base_option == "base":
base_image = snap_src_lst[2]
elif base_option == "top":
base_image = snap_src_lst[4]
if base_option and base_image:
blockpull_options += " --base %s" % base_image
if keep_relative:
blockpull_options += " --keep-relative"
if backing_file_relative_path:
# Use block commit to shorten previous snapshots.
blockcommit_options = " --active --verbose --shallow --pivot --keep-relative"
for count in range(1, snapshot_take + 1):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
#Use block pull with --keep-relative flag,and reset base_index to 2.
base_index = 2
for count in range(1, snapshot_take):
# If block pull operations are more than or equal to 3,it need reset base_index to 1.
if count >= 3:
base_index = 1
base_image = "%s[%s]" % (disk_target, base_index)
blockpull_options = " --wait --verbose --base %s --keep-relative" % base_image
res = virsh.blockpull(vm_name, blk_target,
blockpull_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
# Check final backing chain files.
check_chain_backing_files(blk_source_image, True)
return
# Run test case
result = virsh.blockpull(vm_name, blk_target,
blockpull_options, **virsh_dargs)
status = result.exit_status
# If pull job aborted as timeout, the exit status is different
# on RHEL6(0) and RHEL7(1)
if with_timeout and 'Pull aborted' in result.stdout.strip():
if libvirt_version.version_compare(1, 1, 1):
status_error = True
else:
status_error = False
# Check status_error
libvirt.check_exit_status(result, status_error)
if not status and not with_timeout:
if snap_in_mirror:
snap_mirror_path = "%s/snap_mirror" % tmp_dir
snap_options = "--diskspec vda,snapshot=external,"
snap_options += "file=%s --disk-only" % snap_mirror_path
snapshot_external_disks.append(snap_mirror_path)
ret = virsh.snapshot_create_as(vm_name, snap_options,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret, snap_in_mirror_err)
return
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
logging.debug("after pull the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
err_msg = "Domain image backing chain check failed"
if not base_option or "async" in base_option:
chain_lst = snap_src_lst[-1:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail(err_msg)
elif "base" or "shallow" in base_option:
chain_lst = snap_src_lst[::-1]
if not base_index and base_image:
base_index = chain_lst.index(base_image)
val_tmp = []
for i in range(1, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail(err_msg)
# If base image is the top layer of snapshot chain,
# virsh blockpull should fail, return directly
if base_option == "top":
return
# Check flag files
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
test.fail("blockpull failed: %s" % output)
finally:
# Remove ceph configure file if created
if ceph_cfg:
os.remove(ceph_cfg)
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
# Clean ceph image if used in test
if 'mon_host' in locals():
if utils_package.package_install(["ceph-common"]):
disk_source_name = params.get("disk_source_name")
cmd = ("rbd -m {0} info {1} && rbd -m {0} rm "
"{1}".format(mon_host, disk_source_name))
cmd_result = process.run(cmd, ignore_status=True, shell=True)
logging.debug("result of rbd removal: %s", cmd_result)
else:
logging.debug('Failed to install ceph-common to clean ceph.')
if not disk_src_protocol or disk_src_protocol != 'gluster':
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
if backing_file_relative_path:
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
process.run("cd %s && rm -rf b c d" % blk_source_folder, shell=True)
libvirtd = utils_libvirtd.Libvirtd()
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
logging.info("clean gluster env")
libvirt.setup_or_cleanup_gluster(False, brick_path=brick_path, **params)
libvirtd.restart()
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test rbd disk device.
1.Prepare test environment,destroy or suspend a VM.
2.Prepare disk image.
3.Edit disks xml and start the domain.
4.Perform test operation.
5.Recover test environment.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
additional_xml_file = os.path.join(data_dir.get_tmp_dir(),
"additional_disk.xml")
def config_ceph():
"""
Write the configs to the file.
"""
src_host = disk_src_host.split()
src_port = disk_src_port.split()
conf_str = "mon_host = "
hosts = []
for host, port in zip(src_host, src_port):
hosts.append("%s:%s" % (host, port))
with open(disk_src_config, 'w') as f:
f.write(conf_str + ','.join(hosts) + '\n')
def create_pool():
"""
Define and start a pool.
"""
sp = libvirt_storage.StoragePool()
if create_by_xml:
p_xml = pool_xml.PoolXML(pool_type=pool_type)
p_xml.name = pool_name
s_xml = pool_xml.SourceXML()
s_xml.vg_name = disk_src_pool
source_host = []
for (host_name, host_port) in zip(disk_src_host.split(),
disk_src_port.split()):
source_host.append({'name': host_name, 'port': host_port})
s_xml.hosts = source_host
if auth_type:
s_xml.auth_type = auth_type
if auth_user:
s_xml.auth_username = auth_user
if auth_usage:
s_xml.secret_usage = auth_usage
p_xml.source = s_xml
logging.debug("Pool xml: %s", p_xml)
p_xml.xmltreefile.write()
ret = virsh.pool_define(p_xml.xml, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_build(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_start(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
else:
auth_opt = ""
if client_name and client_key:
auth_opt = (
"--auth-type %s --auth-username %s --secret-usage '%s'" %
(auth_type, auth_user, auth_usage))
if not sp.define_rbd_pool(
pool_name, mon_host, disk_src_pool, extra=auth_opt):
test.fail("Failed to define storage pool")
if not sp.build_pool(pool_name):
test.fail("Failed to build storage pool")
if not sp.start_pool(pool_name):
test.fail("Failed to start storage pool")
# Check pool operation
ret = virsh.pool_refresh(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_uuid(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
# pool-info
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'no':
test.fail("Failed to check pool information")
# pool-autostart
if not sp.set_pool_autostart(pool_name):
test.fail("Failed to set pool autostart")
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'yes':
test.fail("Failed to check pool information")
# pool-autostart --disable
if not sp.set_pool_autostart(pool_name, "--disable"):
test.fail("Failed to set pool autostart")
# If port is not pre-configured, port value should not be hardcoded in pool information.
if "yes" == params.get("rbd_port", "no"):
if 'port' in virsh.pool_dumpxml(pool_name):
test.fail("port attribute should not be in pool information")
# find-storage-pool-sources-as
if "yes" == params.get("find_storage_pool_sources_as", "no"):
ret = virsh.find_storage_pool_sources_as("rbd", mon_host)
libvirt.check_result(ret, skip_if=unsupported_err)
def create_vol(vol_params):
"""
Create volume.
:param p_name. Pool name.
:param vol_params. Volume parameters dict.
:return: True if create successfully.
"""
pvt = libvirt.PoolVolumeTest(test, params)
if create_by_xml:
pvt.pre_vol_by_xml(pool_name, **vol_params)
else:
pvt.pre_vol(vol_name, None, '2G', None, pool_name)
def check_vol(vol_params):
"""
Check volume information.
"""
pv = libvirt_storage.PoolVolume(pool_name)
# Supported operation
if vol_name not in pv.list_volumes():
test.fail("Volume %s doesn't exist" % vol_name)
ret = virsh.vol_dumpxml(vol_name, pool_name)
libvirt.check_exit_status(ret)
# vol-info
if not pv.volume_info(vol_name):
test.fail("Can't see volume info")
# vol-key
ret = virsh.vol_key(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume key isn't correct")
# vol-path
ret = virsh.vol_path(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume path isn't correct")
# vol-pool
ret = virsh.vol_pool("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if pool_name not in ret.stdout.strip():
test.fail("Volume pool isn't correct")
# vol-name
ret = virsh.vol_name("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if vol_name not in ret.stdout.strip():
test.fail("Volume name isn't correct")
# vol-resize
ret = virsh.vol_resize(vol_name, "2G", pool_name)
libvirt.check_exit_status(ret)
# Not supported operation
# vol-clone
ret = virsh.vol_clone(vol_name, cloned_vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-create-from
volxml = vol_xml.VolXML()
vol_params.update({"name": "%s" % create_from_cloned_volume})
v_xml = volxml.new_vol(**vol_params)
v_xml.xmltreefile.write()
ret = virsh.vol_create_from(pool_name, v_xml.xml, vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-wipe
ret = virsh.vol_wipe(vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-upload
ret = virsh.vol_upload(vol_name,
vm.get_first_disk_devices()['source'],
"--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-download
ret = virsh.vol_download(vol_name, cloned_vol_name,
"--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
def check_qemu_cmd():
"""
Check qemu command line options.
"""
cmd = ("ps -ef | grep %s | grep -v grep " % vm_name)
process.run(cmd, shell=True)
if disk_src_name:
cmd += " | grep file=rbd:%s:" % disk_src_name
if auth_user and auth_key:
cmd += ('id=%s:auth_supported=cephx' % auth_user)
if disk_src_config:
cmd += " | grep 'conf=%s'" % disk_src_config
elif mon_host:
hosts = '\:6789\;'.join(mon_host.split())
cmd += " | grep 'mon_host=%s'" % hosts
if driver_iothread:
cmd += " | grep iothread%s" % driver_iothread
# Run the command
process.run(cmd, shell=True)
def check_save_restore():
"""
Test save and restore operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(), "%s.save" % vm_name)
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
# Login to check vm status
vm.wait_for_login().close()
def check_snapshot(snap_option, target_dev='vda'):
"""
Test snapshot operation.
"""
snap_name = "s1"
snap_mem = os.path.join(data_dir.get_tmp_dir(), "rbd.mem")
snap_disk = os.path.join(data_dir.get_tmp_dir(), "rbd.disk")
xml_snap_exp = [
"disk name='%s' snapshot='external' type='file'" % target_dev
]
xml_dom_exp = [
"source file='%s'" % snap_disk,
"backingStore type='network' index='1'",
"source protocol='rbd' name='%s'" % disk_src_name
]
if snap_option.count("disk-only"):
options = ("%s --diskspec %s,file=%s --disk-only" %
(snap_name, target_dev, snap_disk))
elif snap_option.count("disk-mem"):
options = ("%s --memspec file=%s --diskspec %s,file="
"%s" % (snap_name, snap_mem, target_dev, snap_disk))
xml_snap_exp.append("memory snapshot='external' file='%s'" %
snap_mem)
else:
options = snap_name
ret = virsh.snapshot_create_as(vm_name, options)
if test_disk_internal_snapshot or test_disk_readonly:
libvirt.check_result(ret, expected_fails=unsupported_err)
else:
libvirt.check_result(ret, skip_if=unsupported_err)
# check xml file.
if not ret.exit_status:
snap_xml = virsh.snapshot_dumpxml(vm_name, snap_name,
debug=True).stdout.strip()
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
# Delete snapshots.
libvirt.clean_up_snapshots(vm_name)
if os.path.exists(snap_mem):
os.remove(snap_mem)
if os.path.exists(snap_disk):
os.remove(snap_disk)
if not all([x in snap_xml for x in xml_snap_exp]):
test.fail("Failed to check snapshot xml")
if not all([x in dom_xml for x in xml_dom_exp]):
test.fail("Failed to check domain xml")
def check_blockcopy(target):
"""
Block copy operation test.
"""
blk_file = os.path.join(data_dir.get_tmp_dir(), "blk.rbd")
if os.path.exists(blk_file):
os.remove(blk_file)
blk_mirror = ("mirror type='file' file='%s' "
"format='raw' job='copy'" % blk_file)
# Do blockcopy
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_result(ret, skip_if=unsupported_err)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count(blk_mirror):
test.fail("Can't see block job in domain xml")
# Abort
ret = virsh.blockjob(vm_name, target, "--abort")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if dom_xml.count(blk_mirror):
test.fail("Failed to abort block job")
if os.path.exists(blk_file):
os.remove(blk_file)
# Sleep for a while after abort operation.
time.sleep(5)
# Do blockcopy again
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_exit_status(ret)
# Wait for complete
def wait_func():
ret = virsh.blockjob(vm_name, target, "--info")
return ret.stderr.count("Block Copy: [100 %]")
timeout = params.get("blockjob_timeout", 600)
utils_misc.wait_for(wait_func, int(timeout))
# Pivot
ret = virsh.blockjob(vm_name, target, "--pivot")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count("source file='%s'" % blk_file):
test.fail("Failed to pivot block job")
# Remove the disk file.
if os.path.exists(blk_file):
os.remove(blk_file)
def check_in_vm(vm_obj, target, old_parts, read_only=False):
"""
Check mount/read/write disk in VM.
:param vm. VM guest.
:param target. Disk dev in VM.
:return: True if check successfully.
"""
try:
session = vm_obj.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
added_parts = list(set(new_parts).difference(set(old_parts)))
logging.info("Added parts:%s", added_parts)
if len(added_parts) != 1:
logging.error("The number of new partitions is invalid in VM")
return False
added_part = None
if target.startswith("vd"):
if added_parts[0].startswith("vd"):
added_part = added_parts[0]
elif target.startswith("hd"):
if added_parts[0].startswith("sd"):
added_part = added_parts[0]
if not added_part:
logging.error("Can't see added partition in VM")
return False
cmd = ("mount /dev/{0} /mnt && ls /mnt && (sleep 15;"
" touch /mnt/testfile; umount /mnt)".format(added_part))
s, o = session.cmd_status_output(cmd, timeout=60)
session.close()
logging.info("Check disk operation in VM:\n, %s, %s", s, o)
# Readonly fs, check the error messages.
# The command may return True, read-only
# messges can be found from the command output
if read_only:
if "Read-only file system" not in o:
return False
else:
return True
# Other errors
if s != 0:
return False
return True
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def clean_up_volume_snapshots():
"""
Get all snapshots for rbd_vol.img volume,unprotect and then clean up them.
"""
cmd = ("rbd -m {0} {1} info {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
if process.run(cmd, ignore_status=True, shell=True).exit_status:
return
# Get snapshot list.
cmd = ("rbd -m {0} {1} snap"
" list {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
snaps_out = process.run(cmd, ignore_status=True,
shell=True).stdout_text
snap_names = []
if snaps_out:
for line in snaps_out.rsplit("\n"):
if line.startswith("SNAPID") or line == "":
continue
snap_line = line.rsplit()
if len(snap_line) == 4:
snap_names.append(snap_line[1])
logging.debug("Find snapshots: %s", snap_names)
# Unprotect snapshot first,otherwise it will fail to purge volume
for snap_name in snap_names:
cmd = ("rbd -m {0} {1} snap"
" unprotect {2}@{3}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name),
snap_name))
process.run(cmd, ignore_status=True, shell=True)
# Purge volume,and then delete volume.
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
process.run(cmd, ignore_status=True, shell=True)
def make_snapshot():
"""
make external snapshots.
:return external snapshot path list
"""
logging.info("Making snapshot...")
first_disk_source = vm.get_first_disk_devices()['source']
snapshot_path_list = []
snapshot2_file = os.path.join(data_dir.get_tmp_dir(), "mem.s2")
snapshot3_file = os.path.join(data_dir.get_tmp_dir(), "mem.s3")
snapshot4_file = os.path.join(data_dir.get_tmp_dir(), "mem.s4")
snapshot4_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s4")
snapshot5_file = os.path.join(data_dir.get_tmp_dir(), "mem.s5")
snapshot5_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s5")
# Attempt to take different types of snapshots.
snapshots_param_dict = {
"s1":
"s1 --disk-only --no-metadata",
"s2":
"s2 --memspec %s --no-metadata" % snapshot2_file,
"s3":
"s3 --memspec %s --no-metadata --live" % snapshot3_file,
"s4":
"s4 --memspec %s --diskspec vda,file=%s --no-metadata" %
(snapshot4_file, snapshot4_disk_file),
"s5":
"s5 --memspec %s --diskspec vda,file=%s --live --no-metadata" %
(snapshot5_file, snapshot5_disk_file)
}
for snapshot_name in sorted(snapshots_param_dict.keys()):
ret = virsh.snapshot_create_as(vm_name,
snapshots_param_dict[snapshot_name],
**virsh_dargs)
libvirt.check_exit_status(ret)
if snapshot_name != 's4' and snapshot_name != 's5':
snapshot_path_list.append(
first_disk_source.replace('qcow2', snapshot_name))
return snapshot_path_list
def get_secret_list():
"""
Get secret list.
:return secret list
"""
logging.info("Get secret list ...")
secret_list_result = virsh.secret_list()
secret_list = results_stdout_52lts(
secret_list_result).strip().splitlines()
# First two lines contain table header followed by entries
# for each secret, such as:
#
# UUID Usage
# --------------------------------------------------------------------------------
# b4e8f6d3-100c-4e71-9f91-069f89742273 ceph client.libvirt secret
secret_list = secret_list[2:]
result = []
# If secret list is empty.
if secret_list:
for line in secret_list:
# Split on whitespace, assume 1 column
linesplit = line.split(None, 1)
result.append(linesplit[0])
return result
mon_host = params.get("mon_host")
disk_src_name = params.get("disk_source_name")
disk_src_config = params.get("disk_source_config")
disk_src_host = params.get("disk_source_host")
disk_src_port = params.get("disk_source_port")
disk_src_pool = params.get("disk_source_pool")
disk_format = params.get("disk_format", "raw")
driver_iothread = params.get("driver_iothread")
snap_name = params.get("disk_snap_name")
attach_device = "yes" == params.get("attach_device", "no")
attach_disk = "yes" == params.get("attach_disk", "no")
test_save_restore = "yes" == params.get("test_save_restore", "no")
test_snapshot = "yes" == params.get("test_snapshot", "no")
test_blockcopy = "yes" == params.get("test_blockcopy", "no")
test_qemu_cmd = "yes" == params.get("test_qemu_cmd", "no")
test_vm_parts = "yes" == params.get("test_vm_parts", "no")
additional_guest = "yes" == params.get("additional_guest", "no")
create_snapshot = "yes" == params.get("create_snapshot", "no")
convert_image = "yes" == params.get("convert_image", "no")
create_volume = "yes" == params.get("create_volume", "no")
create_by_xml = "yes" == params.get("create_by_xml", "no")
client_key = params.get("client_key")
client_name = params.get("client_name")
auth_key = params.get("auth_key")
auth_user = params.get("auth_user")
auth_type = params.get("auth_type")
auth_usage = params.get("secret_usage")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
vol_name = params.get("vol_name")
cloned_vol_name = params.get("cloned_volume", "cloned_test_volume")
create_from_cloned_volume = params.get("create_from_cloned_volume",
"create_from_cloned_test_volume")
vol_cap = params.get("vol_cap")
vol_cap_unit = params.get("vol_cap_unit")
start_vm = "yes" == params.get("start_vm", "no")
test_disk_readonly = "yes" == params.get("test_disk_readonly", "no")
test_disk_internal_snapshot = "yes" == params.get(
"test_disk_internal_snapshot", "no")
test_json_pseudo_protocol = "yes" == params.get("json_pseudo_protocol",
"no")
disk_snapshot_with_sanlock = "yes" == params.get(
"disk_internal_with_sanlock", "no")
auth_place_in_source = params.get("auth_place_in_source")
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ""
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(mon_host)
# After libvirt 3.9.0, auth element can be put into source part.
if auth_place_in_source and not libvirt_version.version_compare(3, 9, 0):
test.cancel(
"place auth in source is not supported in current libvirt version")
# Start vm and get all partions in vm.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
old_parts = utils_disk.get_parts_list(session)
session.close()
vm.destroy(gracefully=False)
if additional_guest:
guest_name = "%s_%s" % (vm_name, '1')
timeout = params.get("clone_timeout", 360)
utils_libguestfs.virt_clone_cmd(vm_name,
guest_name,
True,
timeout=timeout,
ignore_status=False)
additional_vm = vm.clone(guest_name)
if start_vm:
virsh.start(guest_name)
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
key_opt = ""
secret_uuid = None
snapshot_path = None
key_file = os.path.join(data_dir.get_tmp_dir(), "ceph.key")
img_file = os.path.join(data_dir.get_tmp_dir(), "%s_test.img" % vm_name)
front_end_img_file = os.path.join(data_dir.get_tmp_dir(),
"%s_frontend_test.img" % vm_name)
# Construct a unsupported error message list to skip these kind of tests
unsupported_err = []
if driver_iothread:
unsupported_err.append('IOThreads not supported')
if test_snapshot:
unsupported_err.append('live disk snapshot not supported')
if test_disk_readonly:
if not libvirt_version.version_compare(5, 0, 0):
unsupported_err.append('Could not create file: Permission denied')
unsupported_err.append('Permission denied')
else:
unsupported_err.append(
'unsupported configuration: external snapshot ' +
'for readonly disk vdb is not supported')
if test_disk_internal_snapshot:
unsupported_err.append(
'unsupported configuration: internal snapshot for disk ' +
'vdb unsupported for storage type raw')
if test_blockcopy:
unsupported_err.append('block copy is not supported')
if attach_disk:
unsupported_err.append('No such file or directory')
if create_volume:
unsupported_err.append("backing 'volume' disks isn't yet supported")
unsupported_err.append('this function is not supported')
try:
# Clean up dirty secrets in test environments if there have.
dirty_secret_list = get_secret_list()
if dirty_secret_list:
for dirty_secret_uuid in dirty_secret_list:
virsh.secret_undefine(dirty_secret_uuid)
# Prepare test environment.
qemu_config = LibvirtQemuConfig()
if disk_snapshot_with_sanlock:
# Install necessary package:sanlock,libvirt-lock-sanlock
if not utils_package.package_install(["sanlock"]):
test.error("fail to install sanlock")
if not utils_package.package_install(["libvirt-lock-sanlock"]):
test.error("fail to install libvirt-lock-sanlock")
# Set virt_use_sanlock
result = process.run("setsebool -P virt_use_sanlock 1", shell=True)
if result.exit_status:
test.error("Failed to set virt_use_sanlock value")
# Update lock_manager in qemu.conf
qemu_config.lock_manager = 'sanlock'
# Update qemu-sanlock.conf.
san_lock_config = LibvirtSanLockConfig()
san_lock_config.user = '******'
san_lock_config.group = 'sanlock'
san_lock_config.host_id = 1
san_lock_config.auto_disk_leases = True
process.run("mkdir -p /var/lib/libvirt/sanlock", shell=True)
san_lock_config.disk_lease_dir = "/var/lib/libvirt/sanlock"
san_lock_config.require_lease_for_disks = False
# Start sanlock service and restart libvirtd to enforce changes.
result = process.run("systemctl start wdmd", shell=True)
if result.exit_status:
test.error("Failed to start wdmd service")
result = process.run("systemctl start sanlock", shell=True)
if result.exit_status:
test.error("Failed to start sanlock service")
utils_libvirtd.Libvirtd().restart()
# Prepare lockspace and lease file for sanlock in order.
sanlock_cmd_dict = OrderedDict()
sanlock_cmd_dict[
"truncate -s 1M /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to truncate TEST_LS"
sanlock_cmd_dict[
"sanlock direct init -s TEST_LS:0:/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to sanlock direct init TEST_LS:0"
sanlock_cmd_dict[
"chown sanlock:sanlock /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to chown sanlock TEST_LS"
sanlock_cmd_dict[
"restorecon -R -v /var/lib/libvirt/sanlock"] = "Failed to restorecon sanlock"
sanlock_cmd_dict[
"truncate -s 1M /var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to truncate test-disk-resource-lock"
sanlock_cmd_dict[
"sanlock direct init -r TEST_LS:test-disk-resource-lock:" +
"/var/lib/libvirt/sanlock/test-disk-resource-lock:0"] = "Failed to sanlock direct init test-disk-resource-lock"
sanlock_cmd_dict[
"chown sanlock:sanlock " +
"/var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to chown test-disk-resource-loc"
sanlock_cmd_dict[
"sanlock client add_lockspace -s TEST_LS:1:" +
"/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to client add_lockspace -s TEST_LS:0"
for sanlock_cmd in sanlock_cmd_dict.keys():
result = process.run(sanlock_cmd, shell=True)
if result.exit_status:
test.error(sanlock_cmd_dict[sanlock_cmd])
# Create one lease device and add it to VM.
san_lock_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
lease_device = Lease()
lease_device.lockspace = 'TEST_LS'
lease_device.key = 'test-disk-resource-lock'
lease_device.target = {
'path': '/var/lib/libvirt/sanlock/test-disk-resource-lock'
}
san_lock_vmxml.add_device(lease_device)
san_lock_vmxml.sync()
# Install ceph-common package which include rbd command
if utils_package.package_install(["ceph-common"]):
if client_name and client_key:
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" % (client_name, client_key))
key_opt = "--keyring %s" % key_file
# Create secret xml
sec_xml = secret_xml.SecretXML("no", "no")
sec_xml.usage = auth_type
sec_xml.usage_name = auth_usage
sec_xml.xmltreefile.write()
logging.debug("Secret xml: %s", sec_xml)
ret = virsh.secret_define(sec_xml.xml)
libvirt.check_exit_status(ret)
secret_uuid = re.findall(r".+\S+(\ +\S+)\ +.+\S+",
ret.stdout.strip())[0].lstrip()
logging.debug("Secret uuid %s", secret_uuid)
if secret_uuid is None:
test.error("Failed to get secret uuid")
# Set secret value
auth_key = params.get("auth_key")
ret = virsh.secret_set_value(secret_uuid, auth_key,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Delete the disk if it exists
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm "
"{2}".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
else:
test.error("Failed to install ceph-common")
if disk_src_config:
config_ceph()
disk_path = ("rbd:%s:mon_host=%s" % (disk_src_name, mon_host))
if auth_user and auth_key:
disk_path += (":id=%s:key=%s" % (auth_user, auth_key))
targetdev = params.get("disk_target", "vdb")
# To be compatible with create_disk_xml function,
# some parameters need to be updated.
params.update({
"type_name": params.get("disk_type", "network"),
"target_bus": params.get("disk_target_bus"),
"target_dev": targetdev,
"secret_uuid": secret_uuid,
"source_protocol": params.get("disk_source_protocol"),
"source_name": disk_src_name,
"source_host_name": disk_src_host,
"source_host_port": disk_src_port
})
# Prepare disk image
if convert_image:
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
# Convert the image to remote storage
disk_cmd = ("rbd -m %s %s info %s 2> /dev/null|| qemu-img convert"
" -O %s %s %s" % (mon_host, key_opt, disk_src_name,
disk_format, blk_source, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
elif create_volume:
vol_params = {
"name": vol_name,
"capacity": int(vol_cap),
"capacity_unit": vol_cap_unit,
"format": disk_format
}
create_pool()
create_vol(vol_params)
check_vol(vol_params)
else:
# Create an local image and make FS on it.
disk_cmd = ("qemu-img create -f %s %s 10M && mkfs.ext4 -F %s" %
(disk_format, img_file, img_file))
process.run(disk_cmd, ignore_status=False, shell=True)
# Convert the image to remote storage
disk_cmd = (
"rbd -m %s %s info %s 2> /dev/null|| qemu-img convert -O"
" %s %s %s" % (mon_host, key_opt, disk_src_name, disk_format,
img_file, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
# Create disk snapshot if needed.
if create_snapshot:
snap_cmd = ("rbd -m %s %s snap create %s@%s" %
(mon_host, key_opt, disk_src_name, snap_name))
process.run(snap_cmd, ignore_status=False, shell=True)
if test_json_pseudo_protocol:
# Create one frontend image with the rbd backing file.
json_str = ('json:{"file.driver":"rbd",'
'"file.filename":"rbd:%s:mon_host=%s"}' %
(disk_src_name, mon_host))
# pass different json string according to the auth config
if auth_user and auth_key:
json_str = ('%s:id=%s:key=%s"}' %
(json_str[:-2], auth_user, auth_key))
disk_cmd = ("qemu-img create -f qcow2 -b '%s' %s" %
(json_str, front_end_img_file))
disk_path = front_end_img_file
process.run(disk_cmd, ignore_status=False, shell=True)
# If hot plug, start VM first, and then wait the OS boot.
# Otherwise stop VM if running.
if start_vm:
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
else:
if not vm.is_dead():
vm.destroy()
if attach_device:
if create_volume:
params.update({"source_pool": pool_name})
params.update({"type_name": "volume"})
# No need auth options for volume
if "auth_user" in params:
params.pop("auth_user")
if "auth_type" in params:
params.pop("auth_type")
if "secret_type" in params:
params.pop("secret_type")
if "secret_uuid" in params:
params.pop("secret_uuid")
if "secret_usage" in params:
params.pop("secret_usage")
# After 3.9.0,the auth element can be place in source part.
if auth_place_in_source:
params.update({"auth_in_source": auth_place_in_source})
xml_file = libvirt.create_disk_xml(params)
if additional_guest:
# Copy xml_file for additional guest VM.
shutil.copyfile(xml_file, additional_xml_file)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
if additional_guest:
# Make sure the additional VM is running
if additional_vm.is_dead():
additional_vm.start()
additional_vm.wait_for_login().close()
ret = virsh.attach_device(guest_name,
additional_xml_file,
"",
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif attach_disk:
opts = params.get("attach_option", "")
ret = virsh.attach_disk(vm_name, disk_path, targetdev, opts)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_readonly:
params.update({'readonly': "yes"})
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_internal_snapshot:
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif disk_snapshot_with_sanlock:
if vm.is_dead():
vm.start()
snapshot_path = make_snapshot()
if vm.is_alive():
vm.destroy()
elif not create_volume:
libvirt.set_vm_disk(vm, params)
if test_blockcopy:
logging.info("Creating %s...", vm_name)
vmxml_for_test = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
vm.undefine()
if virsh.create(vmxml_for_test.xml, **virsh_dargs).exit_status:
vmxml_backup.define()
test.fail("Can't create the domain")
elif vm.is_dead():
vm.start()
# Wait for vm is running
vm.wait_for_login(timeout=600).close()
if additional_guest:
if additional_vm.is_dead():
additional_vm.start()
# Check qemu command line
if test_qemu_cmd:
check_qemu_cmd()
# Check partitions in vm
if test_vm_parts:
if not check_in_vm(
vm, targetdev, old_parts, read_only=create_snapshot):
test.fail("Failed to check vm partitions")
if additional_guest:
if not check_in_vm(additional_vm, targetdev, old_parts):
test.fail("Failed to check vm partitions")
# Save and restore operation
if test_save_restore:
check_save_restore()
if test_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option)
if test_blockcopy:
check_blockcopy(targetdev)
if test_disk_readonly:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, 'vdb')
if test_disk_internal_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, targetdev)
# Detach the device.
if attach_device:
xml_file = libvirt.create_disk_xml(params)
ret = virsh.detach_device(vm_name, xml_file)
libvirt.check_exit_status(ret)
if additional_guest:
ret = virsh.detach_device(guest_name, xml_file)
libvirt.check_exit_status(ret)
elif attach_disk:
ret = virsh.detach_disk(vm_name, targetdev)
libvirt.check_exit_status(ret)
# Check disk in vm after detachment.
if attach_device or attach_disk:
session = vm.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
if len(new_parts) != len(old_parts):
test.fail("Disk still exists in vm" " after detachment")
session.close()
except virt_vm.VMStartError as details:
for msg in unsupported_err:
if msg in str(details):
test.cancel(str(details))
else:
test.fail("VM failed to start." "Error: %s" % str(details))
finally:
# Remove ceph configure file if created.
if ceph_cfg:
os.remove(ceph_cfg)
# Delete snapshots.
snapshot_lists = virsh.snapshot_list(vm_name)
if len(snapshot_lists) > 0:
libvirt.clean_up_snapshots(vm_name, snapshot_lists)
for snap in snapshot_lists:
virsh.snapshot_delete(vm_name, snap, "--metadata")
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
if additional_guest:
virsh.remove_domain(guest_name,
"--remove-all-storage",
ignore_stauts=True)
# Remove the snapshot.
if create_snapshot:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
elif create_volume:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, cloned_vol_name)))
process.run(cmd, ignore_status=True, shell=True)
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(
mon_host, key_opt,
os.path.join(disk_src_pool, create_from_cloned_volume)))
process.run(cmd, ignore_status=True, shell=True)
clean_up_volume_snapshots()
else:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
# Delete tmp files.
if os.path.exists(key_file):
os.remove(key_file)
if os.path.exists(img_file):
os.remove(img_file)
# Clean up volume, pool
if vol_name and vol_name in str(virsh.vol_list(pool_name).stdout):
virsh.vol_delete(vol_name, pool_name)
if pool_name and pool_name in virsh.pool_state_dict():
virsh.pool_destroy(pool_name, **virsh_dargs)
virsh.pool_undefine(pool_name, **virsh_dargs)
# Clean up secret
secret_list = get_secret_list()
if secret_list:
for secret_uuid in secret_list:
virsh.secret_undefine(secret_uuid)
logging.info("Restoring vm...")
vmxml_backup.sync()
if disk_snapshot_with_sanlock:
# Restore virt_use_sanlock setting.
process.run("setsebool -P virt_use_sanlock 0", shell=True)
# Restore qemu config
qemu_config.restore()
utils_libvirtd.Libvirtd().restart()
# Force shutdown sanlock service.
process.run("sanlock client shutdown -f 1", shell=True)
# Clean up lockspace folder
process.run("rm -rf /var/lib/libvirt/sanlock/*", shell=True)
if snapshot_path is not None:
for snapshot in snapshot_path:
if os.path.exists(snapshot):
os.remove(snapshot)
def run(test, params, env):
"""
Test virsh migrate command.
"""
def check_vm_network_accessed(session=None, ping_dest="www.baidu.com"):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:param ping_dest: The destination to be ping
:raise: test.fail when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
status, output = utils_test.ping(ping_dest,
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if status != 0:
test.fail("Ping failed, status: %s,"
" output: %s" % (status, output))
def get_vm_ifaces(session=None):
"""
Get interfaces of vm
:param session: The session object to the host
:return: interfaces
"""
p_iface, v_iface = utils_net.get_remote_host_net_ifs(session)
return p_iface
def check_vm_iface_num(iface_list, exp_num=3):
"""
Check he number of interfaces
:param iface_list: The interface list
:param exp_num: The expected number
:raise: test.fail when interfaces' number is not equal to exp_num
"""
if len(iface_list) != exp_num:
test.fail("%d interfaces should be found on the vm, "
"but find %s." % (exp_num, iface_list))
def create_or_del_networks(pf_name, params, remote_virsh_session=None,
is_del=False):
"""
Create or delete network on local or remote
:param params: Dictionary with the test parameters
:param pf_name: The name of PF
:param remote_virsh_session: The virsh session object to the remote host
:param is_del: Whether the networks should be deleted
:raise: test.fail when fails to define/start network
"""
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_bridge_name = params.get("net_bridge_name", "host-bridge")
net_bridge_fwd = params.get("net_bridge_fwd", '{"mode": "bridge"}')
bridge_name = params.get("bridge_name", "br0")
net_dict = {"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name}
bridge_dict = {"net_name": net_bridge_name,
"net_forward": net_bridge_fwd,
"net_bridge": '{"name": "%s"}' % bridge_name}
if not is_del:
for net_params in (net_dict, bridge_dict):
net_dev = libvirt.create_net_xml(net_params.get("net_name"),
net_params)
if not remote_virsh_session:
if net_dev.get_active():
net_dev.undefine()
net_dev.define()
net_dev.start()
else:
remote.scp_to_remote(server_ip, '22', server_user, server_pwd,
net_dev.xml, net_dev.xml, limit="",
log_filename=None, timeout=600,
interface=None)
remote_virsh_session.net_define(net_dev.xml, **virsh_args)
remote_virsh_session.net_start(net_params.get("net_name"),
**virsh_args)
else:
virsh_session = virsh
if remote_virsh_session:
virsh_session = remote_virsh_session
for nname in (net_hostdev_name, net_bridge_name):
if nname not in virsh_session.net_state_dict():
continue
virsh_session.net_destroy(nname, debug=True, ignore_status=True)
virsh_session.net_undefine(nname, debug=True, ignore_status=True)
def check_vm_network_connection(net_name, expected_conn=0):
"""
Check network connections in network xml
:param net_name: The network to be checked
:param expected_conn: The expected value
:raise: test.fail when fails
"""
output = virsh.net_dumpxml(net_name, debug=True).stdout_text
if expected_conn == 0:
reg_pattern = r"<network>"
else:
reg_pattern = r"<network connections='(\d)'>"
res = re.findall(reg_pattern, output, re.I)
if not res:
test.fail("Unable to find expected connection in %s." % net_name)
if expected_conn != 0:
if expected_conn != int(res[0]):
test.fail("Unable to get expected connection number."
"Expected: %s, Actual %s" % (expected_conn, int(res[0])))
def get_hostdev_addr_from_xml():
"""
Get VM hostdev address
:return: pci driver id
"""
address_dict = {}
for ifac in vm_xml.VMXML.new_from_dumpxml(vm_name).devices.by_device_tag("interface"):
if ifac.type_name == "hostdev":
address_dict = ifac.hostdev_address.attrs
return libvirt.pci_info_from_address(address_dict, 16, "id")
def check_vfio_pci(pci_path, status_error=False):
"""
Check if vf driver is vfio-pci
:param pci_path: The absolute path of pci device
:param status_error: Whether the driver should be vfio-pci
"""
cmd = "readlink %s/driver | awk -F '/' '{print $NF}'" % pci_path
output = process.run(cmd, shell=True, verbose=True).stdout_text.strip()
if (output == "vfio-pci") == status_error:
test.fail("Get incorrect dirver %s, it should%s be vfio-pci."
% (output, ' not' if status_error else ''))
def update_iface_xml(vmxml):
"""
Update interfaces for guest
:param vmxml: vm_xml.VMXML object
"""
vmxml.remove_all_device_by_type('interface')
vmxml.sync()
iface_dict = {"type": "network", "source": "{'network': 'host-bridge'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"persistent"}',
"alias": '{"name": "ua-backup0"}',
"inbound": '{"average":"5"}',
"outbound": '{"average":"5"}'}
iface_dict2 = {"type": "network", "source": "{'network': 'hostdev-net'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"transient", "persistent": "ua-backup0"}'}
iface = interface.Interface('network')
for ifc in (iface_dict, iface_dict2):
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", ifc)
vmxml.add_device(iface)
vmxml.sync()
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
virsh_options = params.get("virsh_options", "")
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
client_ip = params.get("client_ip")
client_pwd = params.get("client_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
bridge_name = params.get("bridge_name", "br0")
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
net_bridge_name = params.get("net_bridge_name", "host-bridge")
driver = params.get("driver", "ixgbe")
vm_tmp_file = params.get("vm_tmp_file", "/tmp/test.txt")
cmd_during_mig = params.get("cmd_during_mig")
net_failover_test = "yes" == params.get("net_failover_test", "no")
cancel_migration = "yes" == params.get("cancel_migration", "no")
try:
vf_no = int(params.get("vf_no", "4"))
except ValueError as e:
test.error(e)
migr_vm_back = "yes" == params.get("migrate_vm_back", "no")
err_msg = params.get("err_msg")
status_error = "yes" == params.get("status_error", "no")
cmd_parms = {'server_ip': server_ip, 'server_user': server_user,
'server_pwd': server_pwd}
remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
'remote_pwd': server_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
destparams_dict = copy.deepcopy(params)
remote_virsh_session = None
vm_session = None
vm = None
mig_result = None
func_name = None
extra_args = {}
default_src_vf = 0
default_dest_vf = 0
default_src_rp_filter = 1
default_dest_rp_filer = 1
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("This libvirt version doesn't support migration with "
"net failover devices.")
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if net_failover_test:
src_pf, src_pf_pci = utils_sriov.find_pf(driver)
logging.debug("src_pf is %s. src_pf_pci: %s", src_pf, src_pf_pci)
params['pf_name'] = src_pf
dest_pf, dest_pf_pci = utils_sriov.find_pf(driver, server_session)
logging.debug("dest_pf is %s. dest_pf_pci: %s", dest_pf, dest_pf_pci)
destparams_dict['pf_name'] = dest_pf
src_pf_pci_path = utils_misc.get_pci_path(src_pf_pci)
dest_pf_pci_path = utils_misc.get_pci_path(dest_pf_pci, server_session)
cmd = "cat %s/sriov_numvfs" % (src_pf_pci_path)
default_src_vf = process.run(cmd, shell=True,
verbose=True).stdout_text
cmd = "cat %s/sriov_numvfs" % (dest_pf_pci_path)
status, default_dest_vf = utils_misc.cmd_status_output(cmd,
shell=True,
session=server_session)
if status:
test.error("Unable to get default sriov_numvfs on target!"
"status: %s, output: %s" % (status, default_dest_vf))
if not utils_sriov.set_vf(src_pf_pci_path, vf_no):
test.error("Failed to set vf on source.")
if not utils_sriov.set_vf(dest_pf_pci_path, vf_no, session=server_session):
test.error("Failed to set vf on target.")
# Create PF and bridge connection on source and target host
cmd = 'cat /proc/sys/net/ipv4/conf/all/rp_filter'
default_src_rp_filter = process.run(cmd, shell=True,
verbose=True).stdout_text
status, default_dest_rp_filter = utils_misc.cmd_status_output(cmd,
shell=True,
session=server_session)
if status:
test.error("Unable to get default rp_filter on target!"
"status: %s, output: %s" % (status, default_dest_rp_filter))
cmd = 'echo 0 >/proc/sys/net/ipv4/conf/all/rp_filter'
process.run(cmd, shell=True, verbose=True)
utils_misc.cmd_status_output(cmd, shell=True, session=server_session)
utils_sriov.add_or_del_connection(params, is_del=False)
utils_sriov.add_or_del_connection(destparams_dict, is_del=False,
session=server_session)
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
create_or_del_networks(dest_pf, params,
remote_virsh_session=remote_virsh_session)
remote_virsh_session.close_session()
create_or_del_networks(src_pf, params)
# Change network interface xml
mac_addr = utils_net.generate_mac_address_simple()
update_iface_xml(new_xml)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
# Check local guest network connection before migration
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login(timeout=240)
if net_failover_test:
utils_net.restart_guest_network(vm_session)
iface_list = get_vm_ifaces(vm_session)
vm_ipv4, vm_ipv6 = utils_net.get_linux_ipaddr(vm_session, iface_list[0])
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
check_vm_iface_num(iface_list)
check_vm_network_connection(net_hostdev_name, 1)
check_vm_network_connection(net_bridge_name, 1)
hostdev_pci_id = get_hostdev_addr_from_xml()
vf_path = utils_misc.get_pci_path(hostdev_pci_id)
check_vfio_pci(vf_path)
if cmd_during_mig:
s, o = utils_misc.cmd_status_output(cmd_during_mig, shell=True,
session=vm_session)
if s:
test.fail("Failed to run %s in vm." % cmd_during_mig)
if extra.count("--postcopy"):
func_name = virsh.migrate_postcopy
extra_args.update({'func_params': params})
if cancel_migration:
func_name = migration_test.do_cancel
# Execute migration process
vms = [vm]
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_options,
func=func_name, extra_opts=extra,
**extra_args)
mig_result = migration_test.ret
migration_test.check_result(mig_result, params)
if int(mig_result.exit_status) == 0:
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session, vm_ipv4)
server_session.close()
if net_failover_test:
# Check network connection
check_vm_network_connection(net_hostdev_name)
check_vm_network_connection(net_bridge_name)
# VF driver should not be vfio-pci
check_vfio_pci(vf_path, True)
cmd_parms.update({'vm_ip': vm_ipv4,
'vm_pwd': params.get("password")})
vm_after_mig = remote.VMManager(cmd_parms)
vm_after_mig.setup_ssh_auth()
cmd = "ip link"
cmd_result = vm_after_mig.run_command(cmd)
libvirt.check_result(cmd_result)
p_iface = re.findall(r"\d+:\s+(\w+):\s+.*", cmd_result.stdout_text)
p_iface = [x for x in p_iface if x != 'lo']
check_vm_iface_num(p_iface)
# Check the output of ping command
cmd = 'cat %s' % vm_tmp_file
cmd_result = vm_after_mig.run_command(cmd)
libvirt.check_result(cmd_result)
if re.findall('Destination Host Unreachable', cmd_result.stdout_text, re.M):
test.fail("The network does not work well during "
"the migration peirod. ping output: %s"
% cmd_result.stdout_text)
# Execute migration from remote
if migr_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migration_test.migrate_pre_setup(src_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name,
virsh_options, src_uri)
logging.debug("Start migration: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
test.fail("Failed to run '%s' on remote: %s"
% (cmd, cmd_result))
logging.debug("migration back done")
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
if vm_session:
vm_session.close()
vm_session = vm.wait_for_login()
iface_list = get_vm_ifaces(vm_session)
check_vm_iface_num(iface_list)
else:
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
iface_list = get_vm_ifaces(vm_session)
check_vm_iface_num(iface_list)
finally:
logging.debug("Recover test environment")
# Clean VM on destination
migration_test.cleanup_dest_vm(vm, vm.connect_uri, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s", orig_config_xml.xmltreefile)
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if 'src_pf' in locals():
cmd = 'echo %s >/proc/sys/net/ipv4/conf/all/rp_filter' % default_src_rp_filter
process.run(cmd, shell=True, verbose=True)
utils_sriov.add_or_del_connection(params, is_del=True)
create_or_del_networks(src_pf, params, is_del=True)
if 'dest_pf' in locals():
cmd = 'echo %s >/proc/sys/net/ipv4/conf/all/rp_filter' % default_dest_rp_filter
utils_misc.cmd_status_output(cmd, shell=True, session=server_session)
utils_sriov.add_or_del_connection(destparams_dict, session=server_session,
is_del=True)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
create_or_del_networks(dest_pf, params,
remote_virsh_session,
is_del=True)
remote_virsh_session.close_session()
if 'dest_pf_pci_path' in locals() and default_dest_vf != vf_no:
utils_sriov.set_vf(dest_pf_pci_path, default_dest_vf, server_session)
if 'src_pf_pci_path' in locals() and default_src_vf != vf_no:
utils_sriov.set_vf(src_pf_pci_path, default_src_vf)
# Clean up of pre migration setup for local machine
if migr_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migration_test.migrate_pre_setup(src_uri, params,
cleanup=True)
server_session.close()
if remote_virsh_session:
remote_virsh_session.close_session()
logging.info("Remove local NFS image")
source_file = params.get("source_file")
if source_file:
libvirt.delete_local_disk("file", path=source_file)
def run(test, params, env):
"""
Run the test
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
bk_uri = vm.connect_uri
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
extra_args = migration_test.update_virsh_migrate_extra_args(params)
extra = params.get("virsh_migrate_extra")
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
dest_uri = params.get("virsh_migrate_desturi")
options = params.get("virsh_migrate_options",
"--live --p2p --persistent --verbose")
virsh_options = params.get("virsh_options", "")
stress_package = params.get("stress_package")
action_during_mig = params.get("action_during_mig")
migrate_speed = params.get("migrate_speed")
migrate_speed_again = params.get("migrate_speed_again")
migrate_again = "yes" == params.get("migrate_again", "no")
vm_state_after_abort = params.get("vm_state_after_abort")
return_port = "yes" == params.get("return_port", "no")
params['server_pwd'] = params.get("migrate_dest_pwd")
params['server_ip'] = params.get("migrate_dest_host")
params['server_user'] = params.get("remote_user", "root")
is_storage_migration = True if extra.count('--copy-storage-all') else False
setup_tls = "yes" == params.get("setup_tls", "no")
qemu_conf_dest = params.get("qemu_conf_dest", "{}")
migrate_tls_force_default = "yes" == params.get("migrate_tls_force_default", "no")
poweroff_src_vm = "yes" == params.get("poweroff_src_vm", "no")
check_port = "yes" == params.get("check_port", "no")
server_ip = params.get("migrate_dest_host")
server_user = params.get("remote_user", "root")
server_pwd = params.get("migrate_dest_pwd")
server_params = {'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd}
qemu_conf_list = eval(params.get("qemu_conf_list", "[]"))
qemu_conf_path = params.get("qemu_conf_path")
min_port = params.get("min_port")
vm_session = None
qemu_conf_remote = None
(remove_key_local, remove_key_remote) = (None, None)
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
local_both_conf_obj = None
remote_file_list = []
conn_obj_list = []
try:
# Setup default value for migrate_tls_force
if migrate_tls_force_default:
value_list = ["migrate_tls_force"]
# Setup migrate_tls_force default value on remote
server_params['file_path'] = "/etc/libvirt/qemu.conf"
remove_key_remote = libvirt_config.remove_key_in_conf(value_list,
"qemu",
remote_params=server_params)
# Setup migrate_tls_force default value on local
remove_key_local = libvirt_config.remove_key_in_conf(value_list,
"qemu")
if check_port:
server_params['file_path'] = qemu_conf_path
remove_key_remote = libvirt_config.remove_key_in_conf(qemu_conf_list,
"qemu",
remote_params=server_params)
# Update only remote qemu conf
if qemu_conf_dest:
qemu_conf_remote = libvirt_remote.update_remote_file(
server_params, qemu_conf_dest, "/etc/libvirt/qemu.conf")
# Update local or both sides configuration files
local_both_conf_obj = update_local_or_both_conf_file(params)
# Setup TLS
if setup_tls:
conn_obj_list.append(migration_base.setup_conn_obj('tls',
params,
test))
# Update guest disk xml
if not is_storage_migration:
libvirt.set_vm_disk(vm, params)
else:
remote_file_list.append(libvirt_disk.create_remote_disk_by_same_metadata(vm,
params))
if check_port:
# Create a remote runner
runner_on_target = remote_old.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
cmd = "nc -l -p %s &" % min_port
remote_old.run_remote_cmd(cmd, params, runner_on_target, ignore_status=False)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm_session = vm.wait_for_login()
if action_during_mig:
if poweroff_src_vm:
params.update({'vm_session': vm_session})
action_during_mig = migration_base.parse_funcs(action_during_mig,
test, params)
if stress_package:
migration_test.run_stress_in_vm(vm, params)
mode = 'both' if '--postcopy' in postcopy_options else 'precopy'
if migrate_speed:
migration_test.control_migrate_speed(vm_name,
int(migrate_speed),
mode)
# Execute migration process
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options, extra,
action_during_mig,
extra_args)
func_returns = dict(migration_test.func_ret)
migration_test.func_ret.clear()
logging.debug("Migration returns function results:%s", func_returns)
if return_port:
port_used = get_used_port(func_returns)
if check_port:
port_used = get_used_port(func_returns)
if int(port_used) != int(min_port) + 1:
test.fail("Wrong port for migration.")
if vm_state_after_abort:
check_vm_state_after_abort(vm_name, vm_state_after_abort,
bk_uri, dest_uri, test)
if migrate_again:
if not vm.is_alive():
vm.start()
vm_session = vm.wait_for_login()
action_during_mig = migration_base.parse_funcs(params.get('action_during_mig_again'),
test, params)
extra_args['status_error'] = params.get("migrate_again_status_error", "no")
if params.get("virsh_migrate_extra_mig_again"):
extra = params.get("virsh_migrate_extra_mig_again")
if params.get('scp_list_client_again'):
params['scp_list_client'] = params.get('scp_list_client_again')
# Recreate tlsconnection object using new parameter values
conn_obj_list.append(migration_base.setup_conn_obj('tls',
params,
test))
if migrate_speed_again:
migration_test.control_migrate_speed(vm_name,
int(migrate_speed_again),
mode)
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options,
extra, action_during_mig,
extra_args)
if return_port:
func_returns = dict(migration_test.func_ret)
logging.debug("Migration returns function "
"results:%s", func_returns)
port_second = get_used_port(func_returns)
if port_used != port_second:
test.fail("Expect same port '{}' is used as previous one, "
"but found new one '{}'".format(port_used,
port_second))
else:
logging.debug("Same port '%s' was used as "
"expected", port_second)
if int(migration_test.ret.exit_status) == 0:
migration_test.post_migration_check([vm], params, uri=dest_uri)
finally:
logging.info("Recover test environment")
vm.connect_uri = bk_uri
if vm_session:
vm_session.close()
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
# Restore remote qemu conf and restart libvirtd
if qemu_conf_remote:
logging.debug("Recover remote qemu configurations")
del qemu_conf_remote
# Restore local or both sides conf and restart libvirtd
recover_config_file(local_both_conf_obj, params)
if remove_key_remote:
del remove_key_remote
if remove_key_local:
libvirt.customize_libvirt_config(None,
config_object=remove_key_local,
config_type='qemu')
# Clean up connection object, like TLS
migration_base.cleanup_conn_obj(conn_obj_list, test)
for one_file in remote_file_list:
if one_file:
remote_old.run_remote_cmd("rm -rf %s" % one_file, params)
orig_config_xml.sync()
def run(test, params, env):
"""
Test virsh migrate command.
"""
def set_feature(vmxml, feature, value):
"""
Set guest features for PPC
:param state: the htm status
:param vmxml: guest xml
"""
features_xml = vm_xml.VMFeaturesXML()
if feature == 'hpt':
features_xml.hpt_resizing = value
elif feature == 'htm':
features_xml.htm = value
vmxml.features = features_xml
vmxml.sync()
def trigger_hpt_resize(session):
"""
Check the HPT order file and dmesg
:param session: the session to guest
:raise: test.fail if required message is not found
"""
hpt_order_path = "/sys/kernel/debug/powerpc/hpt_order"
hpt_order = session.cmd_output('cat %s' % hpt_order_path).strip()
hpt_order = int(hpt_order)
logging.info('Current hpt_order is %d', hpt_order)
hpt_order += 1
cmd = 'echo %d > %s' % (hpt_order, hpt_order_path)
cmd_result = session.cmd_status_output(cmd)
result = process.CmdResult(stderr=cmd_result[1],
stdout=cmd_result[1],
exit_status=cmd_result[0])
libvirt.check_exit_status(result)
dmesg = session.cmd('dmesg')
dmesg_content = params.get('dmesg_content').split('|')
for content in dmesg_content:
if content % hpt_order not in dmesg:
test.fail("'%s' is missing in dmesg" % (content % hpt_order))
else:
logging.info("'%s' is found in dmesg", content % hpt_order)
def check_qemu_cmd_line(content, err_ignore=False):
"""
Check the specified content in the qemu command line
:param content: the desired string to search
:param err_ignore: True to return False when fail
False to raise exception when fail
:return: True if exist, False otherwise
"""
cmd = 'ps -ef|grep qemu|grep -v grep'
qemu_line = results_stdout_52lts(process.run(cmd, shell=True))
if content not in qemu_line:
if err_ignore:
return False
else:
test.fail("Expected '%s' was not found in "
"qemu command line" % content)
return True
def check_vm_network_accessed(session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:raise: test.error when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
s_ping, _ = utils_test.ping(vm.get_address(),
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if s_ping != 0:
if session:
session.close()
test.fail("%s did not respond after %d sec." % (vm.name, 20))
def check_virsh_command_and_option(command, option=None):
"""
Check if virsh command exists
:param command: the command to be checked
:param option: the command option to be checked
"""
msg = "This version of libvirt does not support "
if not virsh.has_help_command(command):
test.cancel(msg + "virsh command '%s'" % command)
if option and not virsh.has_command_help_match(command, option):
test.cancel(msg + "virsh command '%s' with option '%s'" %
(command, option))
def add_ctrls(vm_xml, dev_type="pci", dev_index="0", dev_model="pci-root"):
"""
Add multiple devices
:param dev_type: the type of the device to be added
:param dev_index: the maximum index of the device to be added
:param dev_model: the model of the device to be added
"""
for inx in range(0, int(dev_index) + 1):
newcontroller = Controller("controller")
newcontroller.type = dev_type
newcontroller.index = inx
newcontroller.model = dev_model
logging.debug("New device is added:\n%s", newcontroller)
vm_xml.add_device(newcontroller)
vm_xml.sync()
def do_migration(vm, dest_uri, options, extra):
"""
Execute the migration with given parameters
:param vm: the guest to be migrated
:param dest_uri: the destination uri for migration
:param options: options next to 'migrate' command
:param extra: options in the end of the migrate command line
:return: CmdResult object
"""
logging.info("Sleeping 10 seconds before migration")
time.sleep(10)
# Migrate the guest.
migration_res = vm.migrate(dest_uri, options, extra, **virsh_args)
logging.info("Migration out: %s",
results_stdout_52lts(migration_res).strip())
logging.info("Migration error: %s",
results_stderr_52lts(migration_res).strip())
if int(migration_res.exit_status) != 0:
logging.error("Migration failed for %s.", vm_name)
return migration_res
if vm.is_alive(): # vm.connect_uri was updated
logging.info("VM is alive on destination %s.", dest_uri)
else:
test.fail("VM is not alive on destination %s" % dest_uri)
# Throws exception if console shows panic message
vm.verify_kernel_crash()
return migration_res
def cleanup_libvirtd_log(log_file):
"""
Remove existing libvirtd log file on source and target host.
:param log_file: log file with absolute path
"""
if os.path.exists(log_file):
logging.debug("Delete local libvirt log file '%s'", log_file)
os.remove(log_file)
cmd = "rm -f %s" % log_file
logging.debug("Delete remote libvirt log file '%s'", log_file)
run_remote_cmd(cmd)
def cleanup_dest(vm):
"""
Clean up the destination host environment
when doing the uni-direction migration.
:param vm: the guest to be cleaned up
"""
logging.info("Cleaning up VMs on %s", vm.connect_uri)
try:
if virsh.domain_exists(vm.name, uri=vm.connect_uri):
vm_state = vm.state()
if vm_state == "paused":
vm.resume()
elif vm_state == "shut off":
vm.start()
vm.destroy(gracefully=False)
if vm.is_persistent():
vm.undefine()
except Exception as detail:
logging.error("Cleaning up destination failed.\n%s", detail)
def run_remote_cmd(cmd):
"""
A function to run a command on remote host.
:param cmd: the command to be executed
:return: CmdResult object
"""
remote_runner = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
cmdResult = remote_runner.run(cmd, ignore_status=True)
if cmdResult.exit_status:
test.fail("Failed to run '%s' on remote: %s" %
(cmd, results_stderr_52lts(cmdResult).strip()))
return cmdResult
def run_stress_in_vm():
"""
The function to load stress in VM
"""
stress_args = params.get(
"stress_args", "--cpu 8 --io 4 "
"--vm 2 --vm-bytes 128M "
"--timeout 20s")
try:
vm_session.cmd('stress %s' % stress_args)
except Exception as detail:
logging.debug(detail)
def check_timeout_postcopy(params):
"""
Check the vm state on target host after timeout
when --postcopy and --timeout-postcopy are used.
The vm state is expected as running.
:param params: the parameters used
"""
timeout = int(params.get("timeout_postcopy", 10))
time.sleep(timeout + 1)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
vm_state = results_stdout_52lts(
remote_virsh_session.domstate(vm_name)).strip()
if vm_state != "running":
remote_virsh_session.close_session()
test.fail(
"After timeout '%s' seconds, "
"the vm state on target host should "
"be 'running', but '%s' found", timeout, vm_state)
remote_virsh_session.close_session()
def get_usable_compress_cache(pagesize):
"""
Get a number which is bigger than pagesize and is power of two.
:param pagesize: the given integer
:return: an integer satisfying the criteria
"""
def calculate(num):
result = num & (num - 1)
return (result == 0)
item = pagesize
found = False
while (not found):
item += 1
found = calculate(item)
logging.debug(
"%d is smallest one that is bigger than '%s' and "
"is power of 2", item, pagesize)
return item
check_parameters(test, params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"ignore_status": True, "debug": True}
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
log_file = params.get("libvirt_log", "/var/log/libvirt/libvirtd.log")
check_complete_job = "yes" == params.get("check_complete_job", "no")
config_libvirtd = "yes" == params.get("config_libvirtd", "no")
contrl_index = params.get("new_contrl_index", None)
grep_str_remote_log = params.get("grep_str_remote_log", "")
grep_str_local_log = params.get("grep_str_local_log", "")
stress_in_vm = "yes" == params.get("stress_in_vm", "no")
remote_virsh_dargs = {
'remote_ip': server_ip,
'remote_user': server_user,
'remote_pwd': server_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
hpt_resize = params.get("hpt_resize", None)
htm_state = params.get("htm_state", None)
qemu_check = params.get("qemu_check", None)
xml_check_after_mig = params.get("guest_xml_check_after_mig", None)
arch = platform.machine()
if any([hpt_resize, contrl_index, htm_state]) and 'ppc64' not in arch:
test.cancel("The case is PPC only.")
# For TLS
tls_recovery = params.get("tls_auto_recovery", "yes")
# qemu config
qemu_conf_dict = None
# libvirtd config
libvirtd_conf_dict = None
remote_virsh_session = None
vm = None
vm_session = None
libvirtd_conf = None
qemu_conf = None
mig_result = None
test_exception = None
is_TestError = False
is_TestFail = False
is_TestSkip = False
asynch_migration = False
# Objects to be cleaned up in the end
objs_list = []
tls_obj = None
# Local variables
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
if not orig_config_xml:
test.error("Backing up xmlfile failed.")
try:
# Change VM xml in below part
if contrl_index:
new_xml.remove_all_device_by_type('controller')
logging.debug("After removing controllers, current XML:\n%s\n",
new_xml)
add_ctrls(new_xml, dev_index=contrl_index)
if extra.count("--tls"):
qemu_conf_dict = {"migrate_tls_x509_verify": "1"}
# Setup TLS
tls_obj = TLSConnection(params)
if tls_recovery == "yes":
objs_list.append(tls_obj)
tls_obj.auto_recover = True
tls_obj.conn_setup()
# Setup qemu configure
logging.debug("Configure the qemu")
cleanup_libvirtd_log(log_file)
qemu_conf = libvirt.customize_libvirt_config(qemu_conf_dict,
config_type="qemu",
remote_host=True,
extra_params=params)
# Setup libvirtd
if config_libvirtd:
logging.debug("Configure the libvirtd")
cleanup_libvirtd_log(log_file)
libvirtd_conf_dict = setup_libvirtd_conf_dict(params)
libvirtd_conf = libvirt.customize_libvirt_config(
libvirtd_conf_dict, remote_host=True, extra_params=params)
if hpt_resize:
set_feature(new_xml, 'hpt', hpt_resize)
if htm_state:
set_feature(new_xml, 'htm', htm_state)
# Change the disk of the vm to shared disk and then start VM
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
if qemu_check:
check_content = qemu_check
if hpt_resize:
check_content = "%s%s" % (qemu_check, hpt_resize)
if htm_state:
check_content = "%s%s" % (qemu_check, htm_state)
check_qemu_cmd_line(check_content)
vm_session = vm.wait_for_login()
check_vm_network_accessed()
if hpt_resize and hpt_resize != 'disabled':
trigger_hpt_resize(vm_session)
if stress_in_vm:
pkg_name = 'stress'
logging.debug("Check if stress tool is installed")
pkg_mgr = utils_package.package_manager(vm_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("Stress tool will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
stress_thread = threading.Thread(target=run_stress_in_vm, args=())
stress_thread.start()
if extra.count("timeout-postcopy"):
asynch_migration = True
func_name = check_timeout_postcopy
if extra.count("comp-xbzrle-cache"):
cache = get_usable_compress_cache(memory.get_page_size())
extra = "%s %s" % (extra, cache)
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options and not extra.count(postcopy_options):
extra = "%s %s" % (extra, postcopy_options)
if not asynch_migration:
mig_result = do_migration(vm, dest_uri, options, extra)
else:
migration_test = libvirt.MigrationTest()
logging.debug("vm.connect_uri=%s", vm.connect_uri)
vms = [vm]
try:
migration_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
func=func_name,
extra_opts=extra,
func_params=params)
mig_result = migration_test.ret
except exceptions.TestFail as fail_detail:
test.fail(fail_detail)
except exceptions.TestSkipError as skip_detail:
test.cancel(skip_detail)
except exceptions.TestError as error_detail:
test.error(error_detail)
except Exception as details:
mig_result = migration_test.ret
logging.error(details)
if int(mig_result.exit_status) != 0:
test.fail(results_stderr_52lts(mig_result).strip())
if check_complete_job:
search_str_domjobinfo = params.get("search_str_domjobinfo", None)
opts = "--completed"
args = vm_name + " " + opts
check_virsh_command_and_option("domjobinfo", opts)
jobinfo = results_stdout_52lts(
virsh.domjobinfo(args, debug=True,
ignore_status=True)).strip()
logging.debug("Local job info on completion:\n%s", jobinfo)
if extra.count("comp-xbzrle-cache") and search_str_domjobinfo:
search_str_domjobinfo = "%s %s" % (search_str_domjobinfo,
cache // 1024)
if search_str_domjobinfo:
if not re.search(search_str_domjobinfo, jobinfo):
test.fail("Fail to search '%s' on local:\n%s" %
(search_str_domjobinfo, jobinfo))
# Check remote host
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(
**remote_virsh_dargs)
jobinfo = results_stdout_52lts(
remote_virsh_session.domjobinfo(args,
debug=True,
ignore_status=True)).strip()
logging.debug("Remote job info on completion:\n%s", jobinfo)
if search_str_domjobinfo:
if not re.search(search_str_domjobinfo, jobinfo):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' on remote:\n%s" %
(search_str_domjobinfo, jobinfo))
remote_virsh_session.close_session()
if grep_str_local_log:
cmd = "grep -E '%s' %s" % (grep_str_local_log, log_file)
cmdRes = process.run(cmd, shell=True, ignore_status=True)
if cmdRes.exit_status:
test.fail(results_stderr_52lts(cmdRes).strip())
if grep_str_remote_log:
cmd = "grep -E '%s' %s" % (grep_str_remote_log, log_file)
run_remote_cmd(cmd)
if xml_check_after_mig:
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(
**remote_virsh_dargs)
target_guest_dumpxml = results_stdout_52lts(
remote_virsh_session.dumpxml(vm_name,
debug=True,
ignore_status=True)).strip()
if hpt_resize:
check_str = hpt_resize
elif htm_state:
check_str = htm_state
if hpt_resize or htm_state:
xml_check_after_mig = "%s'%s'" % (xml_check_after_mig,
check_str)
if not re.search(xml_check_after_mig, target_guest_dumpxml):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' in target guest XML:\n%s" %
(xml_check_after_mig, target_guest_dumpxml))
if contrl_index:
all_ctrls = re.findall(xml_check_after_mig,
target_guest_dumpxml)
if len(all_ctrls) != int(contrl_index) + 1:
remote_virsh_session.close_session()
test.fail(
"%s pci-root controllers are expected in guest XML, "
"but found %s" %
(int(contrl_index) + 1, len(all_ctrls)))
remote_virsh_session.close_session()
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session)
server_session.close()
except exceptions.TestFail as details:
is_TestFail = True
test_exception = details
except exceptions.TestSkipError as details:
is_TestSkip = True
test_exception = details
except exceptions.TestError as details:
is_TestError = True
test_exception = details
except Exception as details:
test_exception = details
finally:
logging.debug("Recover test environment")
try:
# Clean VM on destination
vm.connect_uri = dest_uri
cleanup_dest(vm)
vm.connect_uri = src_uri
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s",
orig_config_xml.xmltreefile)
if remote_virsh_session:
remote_virsh_session.close_session()
if extra.count("--tls"):
logging.debug("Recover the qemu configuration")
libvirt.customize_libvirt_config(None,
config_type="qemu",
remote_host=True,
extra_params=params,
is_recover=True,
config_object=qemu_conf)
if config_libvirtd:
logging.debug("Recover the libvirtd configuration")
libvirt.customize_libvirt_config(None,
remote_host=True,
extra_params=params,
is_recover=True,
config_object=libvirtd_conf)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
if objs_list:
for obj in objs_list:
logging.debug("Clean up local objs")
del obj
except Exception as exception_detail:
if (not test_exception and not is_TestError and not is_TestFail
and not is_TestSkip):
raise exception_detail
else:
# if any of above exceptions has been raised, only print
# error log here to avoid of hiding the original issue
logging.error(exception_detail)
# Check result
if is_TestFail:
test.fail(test_exception)
if is_TestSkip:
test.cancel(test_exception)
if is_TestError:
test.error(test_exception)
if not test_exception:
logging.info("Case execution is done.")
else:
test.error(test_exception)
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
default_timeout = int(params.get("default_timeout", "300"))
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" % (target,
vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" % (dest_path,
expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
"""
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
def _blockcopy_cmd():
"""
Run blockcopy command
"""
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
if cmd_result.exit_status:
return False
elif "Copy aborted" in cmd_result.stdout:
return False
else:
return cmd_result
def _make_snapshot():
"""
Make external disk snapshot
"""
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if disk_xml.source.attrs.has_key('file'):
new_file = os.path.join(tmp_dir, "blockcopy_shallow.snap")
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif (disk_xml.source.attrs.has_key('dev') or
disk_xml.source.attrs.has_key('name') or
disk_xml.source.attrs.has_key('pool')):
if (disk_xml.type_name == 'block' or
disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if new_attrs.has_key('name'):
del new_attrs['name']
del new_attrs['protocol']
elif new_attrs.has_key('pool'):
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
utl.set_vm_disk(vm, params, tmp_dir, test)
emulated_iscsi.append(emu_image)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow:
_make_snapshot()
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail")
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
cmd_result = utils_misc.wait_for(_blockcopy_cmd, 10)
if not cmd_result:
raise exceptions.TestFail("Run blockcopy command fail")
status = 0
else:
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth", bandwidth)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
val = options.count("--pivot") + options.count("--finish")
if val == 0:
try:
finish_job(vm_name, target, default_timeout)
except JobTimeout, excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
else:
raise exceptions.TestFail(cmd_result.stderr)
else:
def run(test, params, env):
"""
Test virsh migrate-setmaxdowntime command.
1) Prepare migration environment
2) Start migration and set migrate-maxdowntime
3) Cleanup environment(migrated vm on destination)
4) Check result
"""
dest_uri = params.get(
"virsh_migrate_dest_uri", "qemu+ssh://MIGRATE_EXAMPLE/system")
src_uri = params.get(
"virsh_migrate_src_uri", "qemu+ssh://MIGRATE_EXAMPLE/system")
if dest_uri.count('///') or dest_uri.count('MIGRATE_EXAMPLE'):
raise error.TestNAError("Set your destination uri first.")
if src_uri.count('MIGRATE_EXAMPLE'):
raise error.TestNAError("Set your source uri first.")
if src_uri == dest_uri:
raise error.TestNAError("You should not set dest uri same as local.")
vm_ref = params.get("setmmdt_vm_ref", "domname")
pre_vm_state = params.get("pre_vm_state", "running")
status_error = "yes" == params.get("status_error", "no")
do_migrate = "yes" == params.get("do_migrate", "yes")
migrate_maxdowntime = params.get("migrate_maxdowntime", 1.000)
if (migrate_maxdowntime == ""):
downtime = ""
else:
downtime = int(float(migrate_maxdowntime)) * 1000
extra = params.get("setmmdt_extra")
# A delay between threads
delay_time = int(params.get("delay_time", 1))
# timeout of threads
thread_timeout = 180
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
grep_str_local = params.get("grep_str_from_local_libvirt_log", "")
# For safety reasons, we'd better back up original guest xml
orig_config_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if not orig_config_xml:
raise error.TestError("Backing up xmlfile failed.")
# Params to configure libvirtd.conf
log_file = "/var/log/libvirt/libvirtd.log"
log_level = "1"
log_filters = '"1:json 1:libvirt 1:qemu 1:monitor 3:remote 4:event"'
libvirtd_conf_dict = {"log_level": log_level,
"log_filters": log_filters,
"log_outputs": '"%s:file:%s"' % (log_level, log_file)}
# Update libvirtd config with new parameters
libvirtd = utils_libvirtd.Libvirtd()
libvirtd_conf = config_libvirt(libvirtd_conf_dict)
libvirtd.restart()
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Params to setup SSH connection
params["server_ip"] = params.get("migrate_dest_host")
params["server_pwd"] = params.get("migrate_dest_pwd")
params["client_ip"] = params.get("migrate_source_host")
params["client_pwd"] = params.get("migrate_source_pwd")
params["nfs_client_ip"] = params.get("migrate_dest_host")
params["nfs_server_ip"] = params.get("migrate_source_host")
# Params to enable SELinux boolean on remote host
params["remote_boolean_varible"] = "virt_use_nfs"
params["remote_boolean_value"] = "on"
params["set_sebool_remote"] = "yes"
remote_host = params.get("migrate_dest_host")
username = params.get("migrate_dest_user", "root")
password = params.get("migrate_dest_pwd")
# Config ssh autologin for remote host
ssh_key.setup_ssh_key(remote_host, username, password, port=22)
setmmdt_dargs = {'debug': True, 'ignore_status': True, 'uri': src_uri}
migrate_dargs = {'debug': True, 'ignore_status': True}
seLinuxBool = None
nfs_client = None
local_selinux_bak = ""
try:
# Update the disk using shared storage
libvirt.set_vm_disk(vm, params)
# Backup the SELinux status on local host for recovering
local_selinux_bak = params.get("selinux_status_bak", "")
# Configure NFS client on remote host
nfs_client = nfs.NFSClient(params)
nfs_client.setup()
logging.info("Enable virt NFS SELinux boolean on target host")
seLinuxBool = utils_misc.SELinuxBoolean(params)
seLinuxBool.setup()
if not vm.is_alive():
vm.start()
vm.wait_for_login()
domid = vm.get_id()
# Confirm how to reference a VM.
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
# Prepare vm state
if pre_vm_state == "paused":
vm.pause()
elif pre_vm_state == "shutoff":
vm.destroy(gracefully=False)
# Ensure VM in 'shut off' status
utils_misc.wait_for(lambda: vm.state() == "shut off", 30)
# Set max migration downtime must be during migration
# Using threads for synchronization
threads = []
if do_migrate:
threads.append(threading.Thread(target=thread_func_live_migration,
args=(vm, dest_uri,
migrate_dargs)))
threads.append(threading.Thread(target=thread_func_setmmdt,
args=(vm_ref, downtime, extra,
setmmdt_dargs)))
for thread in threads:
thread.start()
# Migration must be executing before setting maxdowntime
time.sleep(delay_time)
# Wait until thread is over
for thread in threads:
thread.join(thread_timeout)
if (status_error is False or do_migrate is False):
logging.debug("To match the expected pattern '%s' ...",
grep_str_local)
cmd = "grep -E '%s' %s" % (grep_str_local, log_file)
cmdResult = process.run(cmd, shell=True, verbose=False)
logging.debug(cmdResult)
finally:
# Clean up.
if do_migrate:
logging.debug("Cleanup VM on remote host...")
cleanup_dest(vm, src_uri, dest_uri)
if orig_config_xml:
logging.debug("Recover VM XML...")
orig_config_xml.sync()
if seLinuxBool:
logging.info("Recover NFS SELinux boolean on remote host...")
seLinuxBool.cleanup(True)
if nfs_client:
logging.info("Cleanup NFS client environment...")
nfs_client.cleanup()
logging.info("Remove the NFS image...")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
logging.info("Cleanup NFS server environment...")
exp_dir = params.get("export_dir")
mount_dir = params.get("mnt_path_name")
libvirt.setup_or_cleanup_nfs(False, export_dir=exp_dir,
mount_dir=mount_dir,
restore_selinux=local_selinux_bak)
# Recover libvirtd service configuration on local
if libvirtd_conf:
logging.debug("Recover local libvirtd configuration...")
libvirtd_conf.restore()
libvirtd.restart()
os.remove(log_file)
# Check results.
if status_error:
if ret_setmmdt:
if not do_migrate and libvirt_version.version_compare(1, 2, 9):
# https://bugzilla.redhat.com/show_bug.cgi?id=1146618
# Commit fe808d9 fix it and allow setting migration
# max downtime any time since libvirt-1.2.9
logging.info("Libvirt version is newer than 1.2.9,"
"Allow set maxdowntime while VM isn't migrating")
else:
raise error.TestFail("virsh migrate-setmaxdowntime succeed "
"but not expected.")
else:
if do_migrate and not ret_migration:
raise error.TestFail("Migration failed.")
if not ret_setmmdt:
raise error.TestFail("virsh migrate-setmaxdowntime failed.")
disk_cache = params.get("virsh_migrate_disk_cache", "none")
params["driver_cache"] = disk_cache
unsafe_test = False
if options.count("unsafe") and disk_cache != "none":
unsafe_test = True
nfs_client = None
seLinuxBool = None
exception = False
remote_viewer_pid = None
asynch_migration = False
ret_migrate = True
try:
# Change the disk of the vm to shared disk
libvirt.set_vm_disk(vm, params)
# Backup the SELinux status on local host for recovering
local_selinux_bak = params.get("selinux_status_bak")
# Configure NFS client on remote host
nfs_client = nfs.NFSClient(params)
nfs_client.setup()
logging.info("Enable virt NFS SELinux boolean on target host.")
seLinuxBool = SELinuxBoolean(params)
seLinuxBool.setup()
subdriver = utils_test.get_image_info(shared_storage)['format']
extra_attach = ("--config --driver qemu --subdriver %s --cache %s"
% (subdriver, disk_cache))
def run(test, params, env):
"""
Test KVM migration scenarios
"""
migrate_options = params.get("migrate_options", "")
migrate_postcopy = params.get("migrate_postcopy", "")
migrate_dest_ip = params.get("migrate_dest_host")
nfs_mount_path = params.get("nfs_mount_dir")
migrate_start_state = params.get("migrate_start_state", "paused")
postcopy_func = None
if migrate_postcopy:
postcopy_func = virsh.migrate_postcopy
migrate_type = params.get("migrate_type", "orderly")
vm_state = params.get("migrate_vm_state", "running")
ping_count = int(params.get("ping_count", 15))
vms = params.get("vms").split()
vm_list = env.get_all_vms()
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = nfs_mount_path
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params["server_ip"])
vmxml_dict = {}
migrate_setup = libvirt.MigrationTest()
try:
for vm in vm_list:
vmxml_dict[vm.name] = vm_xml.VMXML.new_from_dumpxml(vm.name)
params["source_dist_img"] = "%s-nfs-img" % vm.name
if vm.is_alive():
vm.destroy()
libvirt.set_vm_disk(vm, params)
migrate_setup.ping_vm(vm, test, params, ping_count=ping_count)
try:
migrate_setup.do_migration(vm_list, src_uri, dest_uri,
migrate_type, migrate_options,
func=postcopy_func,
migrate_start_state=migrate_start_state)
except Exception as info:
test.fail(info)
for vm in vm_list:
if not migrate_setup.check_vm_state(vm.name, vm_state, dest_uri):
test.fail("Migrated VMs failed to be in %s state at "
"destination" % vm_state)
logging.info("Guest state is '%s' at destination is as expected",
vm_state)
migrate_setup.ping_vm(vm, test, params, uri=dest_uri, ping_count=ping_count)
finally:
logging.debug("cleanup the migration setup in source/destination")
for vm in vm_list:
if migrate_setup:
migrate_setup.cleanup_dest_vm(vm, src_uri, dest_uri)
if vm.exists() and vm.is_persistent():
vm.undefine()
if vm.is_alive():
vm.destroy()
for source_file in params.get("source_file_list", []):
libvirt.delete_local_disk("file", path=source_file)
if vmxml_dict:
for key in vmxml_dict.keys():
vmxml_dict[key].define()
def run(test, params, env):
"""
Test command: virsh blockpull <domain> <path>
1) Prepare test environment.
2) Populate a disk from its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot(snapshot_take):
"""
Make external snapshots for disks only.
:param snapshot_take: snapshots taken.
"""
for count in range(1, snapshot_take + 1):
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "snapshot_test%s" % count
snap_xml.snap_name = snapshot_name
snap_xml.description = "Snapshot Test %s" % count
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
for src_disk_xml in disks:
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
# Skip cdrom
if disk_xml.device == "cdrom":
continue
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
file_name = disk_xml.source.attrs['file']
new_file = "%s.snap%s" % (file_name.split('.')[0],
count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('name' in disk_xml.source.attrs and
disk_src_protocol == 'gluster'):
src_name = disk_xml.source.attrs['name']
new_name = "%s.snap%s" % (src_name.split('.')[0],
count)
new_attrs.update({'name': new_name})
snapshot_external_disks.append(new_name)
hosts = disk_xml.source.hosts
elif ('dev' in disk_xml.source.attrs or
'name' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block' or
disk_src_protocol in ['iscsi', 'rbd']):
# Use local file as external snapshot target for block
# and iscsi network type.
# As block device will be treat as raw format by
# default, it's not fit for external disk snapshot
# target. A work around solution is use qemu-img again
# with the target.
# And external active snapshots are not supported on
# 'network' disks using 'iscsi' protocol
disk_xml.type_name = 'file'
if 'dev' in new_attrs:
del new_attrs['dev']
elif 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
new_file = "%s/blk_src_file.snap%s" % (tmp_dir, count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
test.fail(snapshot_result.stderr)
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
test.fail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
def get_first_disk_source():
"""
Get disk source of first device
:return: first disk of first device.
"""
first_device = vm.get_first_disk_devices()
firt_disk_src = first_device['source']
return firt_disk_src
def make_relative_path_backing_files():
"""
Create backing chain files of relative path.
:return: absolute path of top active file
"""
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
root_dir = os.path.dirname(first_disk_source)
cmd = "mkdir -p %s" % os.path.join(root_dir, '{b..d}')
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
# Make three external relative path backing files.
backing_file_dict = collections.OrderedDict()
backing_file_dict["b"] = "../%s" % basename
backing_file_dict["c"] = "../b/b.img"
backing_file_dict["d"] = "../c/c.img"
for key, value in list(backing_file_dict.items()):
backing_file_path = os.path.join(root_dir, key)
cmd = ("cd %s && qemu-img create -f qcow2 -o backing_file=%s,backing_fmt=qcow2 %s.img"
% (backing_file_path, value, key))
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
return os.path.join(backing_file_path, "d.img")
def check_chain_backing_files(disk_src_file, expect_backing_file=False):
"""
Check backing chain files of relative path after blockcommit.
:param disk_src_file: first disk src file.
:param expect_backing_file: whether it expect to have backing files.
"""
first_disk_source = get_first_disk_source()
# Validate source image need refer to original one after active blockcommit
if not expect_backing_file and disk_src_file not in first_disk_source:
test.fail("The disk image path:%s doesn't include the origin image: %s" % (first_disk_source, disk_src_file))
# Validate source image doesn't have backing files after active blockcommit
cmd = "qemu-img info %s --backing-chain" % first_disk_source
if qemu_img_locking_feature_support:
cmd = "qemu-img info -U %s --backing-chain" % first_disk_source
ret = process.run(cmd, shell=True).stdout_text.strip()
if expect_backing_file:
if 'backing file' not in ret:
test.fail("The disk image doesn't have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
else:
if 'backing file' in ret:
test.fail("The disk image still have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
snapshot_take = int(params.get("snapshot_take", '0'))
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", 'no')
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", 'no')
bandwidth = params.get("bandwidth", None)
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", None)
keep_relative = "yes" == params.get("keep_relative", 'no')
virsh_dargs = {'debug': True}
# Check whether qemu-img need add -U suboption since locking feature was added afterwards qemu-2.10
qemu_img_locking_feature_support = libvirt_storage.check_qemu_image_lock_support()
backing_file_relative_path = "yes" == params.get("backing_file_relative_path", "no")
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_target = params.get("disk_target", 'vda')
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", "no")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("original xml is %s", vmxml_backup)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
test.fail("There are snapshots created for %s already" % vm_name)
snapshot_external_disks = []
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ""
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
if disk_src_protocol == 'gluster':
if not libvirt_version.version_compare(1, 2, 7):
test.cancel("Snapshot on glusterfs not"
" support in current "
"version. Check more info "
" with https://bugzilla.re"
"dhat.com/show_bug.cgi?id="
"1017289")
# Set vm xml and guest agent
if replace_vm_disk:
if disk_src_protocol == "rbd" and disk_type == "network":
src_host = params.get("disk_source_host", "EXAMPLE_HOSTS")
mon_host = params.get("mon_host", "EXAMPLE_MON_HOST")
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(mon_host)
if src_host.count("EXAMPLE") or mon_host.count("EXAMPLE"):
test.cancel("Please provide ceph host first.")
if backing_file_relative_path:
if vm.is_alive():
vm.destroy(gracefully=False)
first_src_file = get_first_disk_source()
blk_source_image = os.path.basename(first_src_file)
blk_source_folder = os.path.dirname(first_src_file)
replace_disk_image = make_relative_path_backing_files()
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_src_protocol': 'file'})
vm.start()
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
# The first disk is supposed to include OS
# We will perform blockpull operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
make_disk_snapshot(snapshot_take)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
logging.debug("The domain xml after snapshot is %s" % vmxml)
# snapshot src file list
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
if snap_in_mirror:
blockpull_options = "--bandwidth 1"
else:
blockpull_options = "--wait --verbose"
if with_timeout:
blockpull_options += " --timeout 1"
if bandwidth:
blockpull_options += " --bandwidth %s" % bandwidth
if base_option == "async":
blockpull_options += " --async"
base_image = None
base_index = None
if (libvirt_version.version_compare(1, 2, 4) or
disk_src_protocol == 'gluster'):
# For libvirt is older version than 1.2.4 or source protocol is gluster
# there are various base image,which depends on base option:shallow,base,top respectively
if base_option == "shallow":
base_index = 1
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "base":
base_index = 2
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "top":
base_index = 0
base_image = "%s[%s]" % (disk_target, base_index)
else:
if base_option == "shallow":
base_image = snap_src_lst[3]
elif base_option == "base":
base_image = snap_src_lst[2]
elif base_option == "top":
base_image = snap_src_lst[4]
if base_option and base_image:
blockpull_options += " --base %s" % base_image
if keep_relative:
blockpull_options += " --keep-relative"
if backing_file_relative_path:
# Use block commit to shorten previous snapshots.
blockcommit_options = " --active --verbose --shallow --pivot --keep-relative"
for count in range(1, snapshot_take + 1):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
#Use block pull with --keep-relative flag,and reset base_index to 2.
base_index = 2
for count in range(1, snapshot_take):
# If block pull operations are more than or equal to 3,it need reset base_index to 1.
if count >= 3:
base_index = 1
base_image = "%s[%s]" % (disk_target, base_index)
blockpull_options = " --wait --verbose --base %s --keep-relative" % base_image
res = virsh.blockpull(vm_name, blk_target,
blockpull_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
# Check final backing chain files.
check_chain_backing_files(blk_source_image, True)
return
# Run test case
result = virsh.blockpull(vm_name, blk_target,
blockpull_options, **virsh_dargs)
status = result.exit_status
# If pull job aborted as timeout, the exit status is different
# on RHEL6(0) and RHEL7(1)
if with_timeout and 'Pull aborted' in result.stdout.strip():
if libvirt_version.version_compare(1, 1, 1):
status_error = True
else:
status_error = False
# Check status_error
libvirt.check_exit_status(result, status_error)
if not status and not with_timeout:
if snap_in_mirror:
snap_mirror_path = "%s/snap_mirror" % tmp_dir
snap_options = "--diskspec vda,snapshot=external,"
snap_options += "file=%s --disk-only" % snap_mirror_path
snapshot_external_disks.append(snap_mirror_path)
ret = virsh.snapshot_create_as(vm_name, snap_options,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret, snap_in_mirror_err)
return
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
logging.debug("after pull the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
err_msg = "Domain image backing chain check failed"
if not base_option or "async" in base_option:
chain_lst = snap_src_lst[-1:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail(err_msg)
elif "base" or "shallow" in base_option:
chain_lst = snap_src_lst[::-1]
if not base_index and base_image:
base_index = chain_lst.index(base_image)
val_tmp = []
for i in range(1, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail(err_msg)
# If base image is the top layer of snapshot chain,
# virsh blockpull should fail, return directly
if base_option == "top":
return
# Check flag files
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
test.fail("blockpull failed: %s" % output)
finally:
# Remove ceph configure file if created
if ceph_cfg:
os.remove(ceph_cfg)
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
if not disk_src_protocol or disk_src_protocol != 'gluster':
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
if backing_file_relative_path:
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
process.run("cd %s && rm -rf b c d" % blk_source_folder, shell=True)
libvirtd = utils_libvirtd.Libvirtd()
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd.restart()
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test command: virsh blockcommit <domain> <path>
1) Prepare test environment.
2) Commit changes from a snapshot down to its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot(postfix_n, snapshot_take):
"""
Make external snapshots for disks only.
:param postfix_n: postfix option
:param snapshot_take: snapshots taken.
"""
# Add all disks into command line.
disks = vm.get_disk_devices()
# Make three external snapshots for disks only
for count in range(1, snapshot_take):
options = "%s_%s %s%s-desc " % (postfix_n, count,
postfix_n, count)
options += "--disk-only --atomic --no-metadata"
if needs_agent:
options += " --quiesce"
for disk in disks:
disk_detail = disks[disk]
basename = os.path.basename(disk_detail['source'])
# Remove the original suffix if any, appending
# ".postfix_n[0-9]"
diskname = basename.split(".")[0]
snap_name = "%s.%s%s" % (diskname, postfix_n, count)
disk_external = os.path.join(tmp_dir, snap_name)
snapshot_external_disks.append(disk_external)
options += " %s,snapshot=external,file=%s" % (disk,
disk_external)
cmd_result = virsh.snapshot_create_as(vm_name, options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
if status != 0:
test.fail("Failed to make snapshots for disks!")
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
test.fail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
def get_first_disk_source():
"""
Get disk source of first device
:return: first disk of first device.
"""
first_device = vm.get_first_disk_devices()
first_disk_src = first_device['source']
return first_disk_src
def make_relative_path_backing_files():
"""
Create backing chain files of relative path.
:return: absolute path of top active file
"""
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
root_dir = os.path.dirname(first_disk_source)
cmd = "mkdir -p %s" % os.path.join(root_dir, '{b..d}')
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
# Make three external relative path backing files.
backing_file_dict = collections.OrderedDict()
backing_file_dict["b"] = "../%s" % basename
backing_file_dict["c"] = "../b/b.img"
backing_file_dict["d"] = "../c/c.img"
for key, value in list(backing_file_dict.items()):
backing_file_path = os.path.join(root_dir, key)
cmd = ("cd %s && qemu-img create -f qcow2 -o backing_file=%s,backing_fmt=qcow2 %s.img"
% (backing_file_path, value, key))
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
return os.path.join(backing_file_path, "d.img")
def check_chain_backing_files(disk_src_file, expect_backing_file=False):
"""
Check backing chain files of relative path after blockcommit.
:param disk_src_file: first disk src file.
:param expect_backing_file: whether it expect to have backing files.
"""
first_disk_source = get_first_disk_source()
# Validate source image need refer to original one after active blockcommit
if not expect_backing_file and disk_src_file not in first_disk_source:
test.fail("The disk image path:%s doesn't include the origin image: %s" % (first_disk_source, disk_src_file))
# Validate source image doesn't have backing files after active blockcommit
cmd = "qemu-img info %s --backing-chain" % first_disk_source
if qemu_img_locking_feature_support:
cmd = "qemu-img info -U %s --backing-chain" % first_disk_source
ret = process.run(cmd, shell=True).stdout_text.strip()
if expect_backing_file:
if 'backing file' not in ret:
test.fail("The disk image doesn't have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
else:
if 'backing file' in ret:
test.fail("The disk image still have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
snapshot_take = int(params.get("snapshot_take", '0'))
vm_state = params.get("vm_state", "running")
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
top_inactive = ("yes" == params.get("top_inactive"))
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", "none")
middle_base = "yes" == params.get("middle_base", "no")
pivot_opt = "yes" == params.get("pivot_opt", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", "no")
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", "no")
with_active_commit = "yes" == params.get("with_active_commit", "no")
multiple_chain = "yes" == params.get("multiple_chain", "no")
virsh_dargs = {'debug': True}
# Check whether qemu-img need add -U suboption since locking feature was added afterwards qemu-2.10
qemu_img_locking_feature_support = libvirt_storage.check_qemu_image_lock_support()
backing_file_relative_path = "yes" == params.get("backing_file_relative_path", "no")
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", 'no')
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
if not top_inactive:
if not libvirt_version.version_compare(1, 2, 4):
test.cancel("live active block commit is not supported"
" in current libvirt version.")
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
test.fail("There are snapshots created for %s already" %
vm_name)
snapshot_external_disks = []
cmd_session = None
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
# Set vm xml and guest agent
if replace_vm_disk:
if disk_src_protocol == "rbd" and disk_type == "network":
src_host = params.get("disk_source_host", "EXAMPLE_HOSTS")
mon_host = params.get("mon_host", "EXAMPLE_MON_HOST")
if src_host.count("EXAMPLE") or mon_host.count("EXAMPLE"):
test.cancel("Please provide rbd host first.")
if backing_file_relative_path:
if vm.is_alive():
vm.destroy(gracefully=False)
first_src_file = get_first_disk_source()
blk_source_image = os.path.basename(first_src_file)
blk_source_folder = os.path.dirname(first_src_file)
replace_disk_image = make_relative_path_backing_files()
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_src_protocol': 'file'})
vm.start()
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
# The first disk is supposed to include OS
# We will perform blockcommit operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
postfix_n = 'snap'
make_disk_snapshot(postfix_n, snapshot_take)
basename = os.path.basename(blk_source)
diskname = basename.split(".")[0]
snap_src_lst = [blk_source]
if multiple_chain:
snap_name = "%s.%s1" % (diskname, postfix_n)
snap_top = os.path.join(tmp_dir, snap_name)
top_index = snapshot_external_disks.index(snap_top) + 1
omit_list = snapshot_external_disks[top_index:]
vm.destroy(gracefully=False)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_xml = ''
disk_xmls = vmxml.get_devices(device_type="disk")
for disk in disk_xmls:
if disk.get('device_tag') == 'disk':
disk_xml = disk
break
vmxml.del_device(disk_xml)
disk_dict = {'attrs': {'file': snap_top}}
disk_xml.source = disk_xml.new_disk_source(**disk_dict)
vmxml.add_device(disk_xml)
vmxml.sync()
vm.start()
session = vm.wait_for_login()
postfix_n = 'new_snap'
make_disk_snapshot(postfix_n, snapshot_take)
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
logging.debug("omit list is %s", omit_list)
for i in omit_list:
snap_src_lst.remove(i)
else:
# snapshot src file list
snap_src_lst += snapshot_external_disks
backing_chain = ''
for i in reversed(list(range(snapshot_take))):
if i == 0:
backing_chain += "%s" % snap_src_lst[i]
else:
backing_chain += "%s -> " % snap_src_lst[i]
logging.debug("The backing chain is: %s" % backing_chain)
# check snapshot disk xml backingStore is expected
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
disk_xml = None
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
if disk.device != 'disk':
continue
disk_xml = disk.xmltreefile
logging.debug("the target disk xml after snapshot is %s",
disk_xml)
break
if not disk_xml:
test.fail("Can't find disk xml with target %s" %
blk_target)
elif libvirt_version.version_compare(1, 2, 4):
# backingStore element introuduced in 1.2.4
chain_lst = snap_src_lst[::-1]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain check failed")
# set blockcommit_options
top_image = None
blockcommit_options = "--wait --verbose"
if with_timeout:
blockcommit_options += " --timeout 1"
if base_option == "shallow":
blockcommit_options += " --shallow"
elif base_option == "base":
if middle_base:
snap_name = "%s.%s1" % (diskname, postfix_n)
blk_source = os.path.join(tmp_dir, snap_name)
blockcommit_options += " --base %s" % blk_source
if top_inactive:
snap_name = "%s.%s2" % (diskname, postfix_n)
top_image = os.path.join(tmp_dir, snap_name)
blockcommit_options += " --top %s" % top_image
else:
blockcommit_options += " --active"
if pivot_opt:
blockcommit_options += " --pivot"
if vm_state == "shut off":
vm.destroy(gracefully=True)
if with_active_commit:
# inactive commit follow active commit will fail with bug 1135339
cmd = "virsh blockcommit %s %s --active --pivot" % (vm_name,
blk_target)
cmd_session = aexpect.ShellSession(cmd)
if backing_file_relative_path:
blockcommit_options = " --active --verbose --shallow --pivot --keep-relative"
block_commit_index = snapshot_take
expect_backing_file = False
# Do block commit using --active
for count in range(1, snapshot_take):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
if top_inactive:
blockcommit_options = " --wait --verbose --top vda[1] --base vda[2] --keep-relative"
block_commit_index = snapshot_take - 1
expect_backing_file = True
# Do block commit with --wait if top_inactive
for count in range(1, block_commit_index):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
check_chain_backing_files(blk_source_image, expect_backing_file)
return
# Run test case
# Active commit does not support on rbd based disk with bug 1200726
result = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
# Check status_error
libvirt.check_exit_status(result, status_error)
if result.exit_status and status_error:
return
while True:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
if not top_inactive:
disk_mirror = disk_xml.find('mirror')
if '--pivot' not in blockcommit_options:
if disk_mirror is not None:
job_type = disk_mirror.get('job')
job_ready = disk_mirror.get('ready')
src_element = disk_mirror.find('source')
disk_src_file = None
for elem in ('file', 'name', 'dev'):
elem_val = src_element.get(elem)
if elem_val:
disk_src_file = elem_val
break
err_msg = "blockcommit base source "
err_msg += "%s not expected" % disk_src_file
if '--shallow' in blockcommit_options:
if not multiple_chain:
if disk_src_file != snap_src_lst[2]:
test.fail(err_msg)
else:
if disk_src_file != snap_src_lst[3]:
test.fail(err_msg)
else:
if disk_src_file != blk_source:
test.fail(err_msg)
if libvirt_version.version_compare(1, 2, 7):
# The job attribute mentions which API started the
# operation since 1.2.7.
if job_type != 'active-commit':
test.fail("blockcommit job type '%s'"
" not expected" % job_type)
if job_ready != 'yes':
# The attribute ready, if present, tracks
# progress of the job: yes if the disk is known
# to be ready to pivot, or, since 1.2.7, abort
# or pivot if the job is in the process of
# completing.
continue
else:
logging.debug("after active block commit job "
"ready for pivot, the target disk"
" xml is %s", disk_xml)
break
else:
break
else:
break
else:
if disk_mirror is None:
logging.debug(disk_xml)
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.pop(0)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing "
"chain check failed")
cmd_result = virsh.blockjob(vm_name, blk_target, '',
ignore_status=True, debug=True)
libvirt.check_exit_status(cmd_result)
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
base_index = chain_lst.index(blk_source)
chain_lst = chain_lst[base_index:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing "
"chain check failed")
break
else:
# wait pivot after commit is synced
continue
else:
logging.debug("after inactive commit the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.remove(top_image)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain "
"check failed")
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
top_index = chain_lst.index(top_image)
base_index = chain_lst.index(blk_source)
val_tmp = []
for i in range(top_index, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain "
"check failed")
break
else:
break
# Check flag files
if not vm_state == "shut off" and not multiple_chain:
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
test.fail("blockcommit failed: %s" % output)
if not pivot_opt and snap_in_mirror:
# do snapshot during mirror phase
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
snapshot_external_disks.append(snap_path)
cmd_result = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
libvirt.check_exit_status(cmd_result, snap_in_mirror_err)
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
if cmd_session:
cmd_session.close()
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
if backing_file_relative_path:
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
process.run("cd %s && rm -rf b c d" % blk_source_folder, shell=True)
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test command: virsh blockpull <domain> <path>
1) Prepare test environment.
2) Populate a disk from its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot():
# Make four external snapshots for disks only
for count in range(1, 5):
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "snapshot_test%s" % count
snap_xml.snap_name = snapshot_name
snap_xml.description = "Snapshot Test %s" % count
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
for src_disk_xml in disks:
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
# Skip cdrom
if disk_xml.device == "cdrom":
continue
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if disk_xml.source.attrs.has_key('file'):
file_name = disk_xml.source.attrs['file']
new_file = "%s.snap%s" % (file_name.split('.')[0],
count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif (disk_xml.source.attrs.has_key('name') and
disk_src_protocol == 'gluster'):
src_name = disk_xml.source.attrs['name']
new_name = "%s.snap%s" % (src_name.split('.')[0],
count)
new_attrs.update({'name': new_name})
snapshot_external_disks.append(new_name)
hosts = disk_xml.source.hosts
elif (disk_xml.source.attrs.has_key('dev') or
disk_xml.source.attrs.has_key('name')):
if (disk_xml.type_name == 'block' or
disk_src_protocol in ['iscsi', 'rbd']):
# Use local file as external snapshot target for block
# and iscsi network type.
# As block device will be treat as raw format by
# default, it's not fit for external disk snapshot
# target. A work around solution is use qemu-img again
# with the target.
# And external active snapshots are not supported on
# 'network' disks using 'iscsi' protocol
disk_xml.type_name = 'file'
if new_attrs.has_key('dev'):
del new_attrs['dev']
elif new_attrs.has_key('name'):
del new_attrs['name']
del new_attrs['protocol']
new_file = "%s/blk_src_file.snap%s" % (tmp_dir, count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise error.TestFail(snapshot_result.stderr)
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
raise error.TestFail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", 'no')
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", 'no')
bandwidth = params.get("bandwidth", None)
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", None)
keep_relative = "yes" == params.get("keep_relative", 'no')
virsh_dargs = {'debug': True}
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_target = params.get("disk_target", 'vda')
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", "no")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("original xml is %s", vmxml_backup)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
raise error.TestFail("There are snapshots created for %s already" % vm_name)
snapshot_external_disks = []
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
raise error.TestNAError("'iscsi' disk doesn't support in"
" current libvirt version.")
if disk_src_protocol == 'gluster':
if not libvirt_version.version_compare(1, 2, 7):
raise error.TestNAError("Snapshot on glusterfs not"
" support in current "
"version. Check more info "
" with https://bugzilla.re"
"dhat.com/show_bug.cgi?id="
"1017289")
# Set vm xml and guest agent
if replace_vm_disk:
if disk_src_protocol == "rbd" and disk_type == "network":
src_host = params.get("disk_source_host", "EXAMPLE_HOSTS")
mon_host = params.get("mon_host", "EXAMPLE_MON_HOST")
if src_host.count("EXAMPLE") or mon_host.count("EXAMPLE"):
raise error.TestNAError("Please provide ceph host first.")
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
# The first disk is supposed to include OS
# We will perform blockpull operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
make_disk_snapshot()
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
logging.debug("The domain xml after snapshot is %s" % vmxml)
# snapshot src file list
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
if snap_in_mirror:
blockpull_options = "--bandwidth 1"
else:
blockpull_options = "--wait --verbose"
if with_timeout:
blockpull_options += " --timeout 1"
if bandwidth:
blockpull_options += " --bandwidth %s" % bandwidth
if base_option == "async":
blockpull_options += " --async"
base_image = None
base_index = None
if (libvirt_version.version_compare(1, 2, 4) or
disk_src_protocol == 'gluster'):
if base_option == "shallow":
base_index = 1
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "base":
base_index = 2
base_image = "%s[%s]" % (disk_target, base_index)
elif base_option == "top":
base_index = 0
base_image = "%s[%s]" % (disk_target, base_index)
else:
if base_option == "shallow":
base_image = snap_src_lst[3]
elif base_option == "base":
base_image = snap_src_lst[2]
elif base_option == "top":
base_image = snap_src_lst[4]
if base_option and base_image:
blockpull_options += " --base %s" % base_image
if keep_relative:
blockpull_options += " --keep-relative"
# Run test case
result = virsh.blockpull(vm_name, blk_target,
blockpull_options, **virsh_dargs)
status = result.exit_status
# If pull job aborted as timeout, the exit status is different
# on RHEL6(0) and RHEL7(1)
if with_timeout and 'Pull aborted' in result.stdout:
if libvirt_version.version_compare(1, 1, 1):
status_error = True
else:
status_error = False
# Check status_error
libvirt.check_exit_status(result, status_error)
if not status and not with_timeout:
if snap_in_mirror:
snap_mirror_path = "%s/snap_mirror" % tmp_dir
snap_options = "--diskspec vda,snapshot=external,"
snap_options += "file=%s --disk-only" % snap_mirror_path
snapshot_external_disks.append(snap_mirror_path)
ret = virsh.snapshot_create_as(vm_name, snap_options,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret, snap_in_mirror_err)
return
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
logging.debug("after pull the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
err_msg = "Domain image backing chain check failed"
if not base_option or "async" in base_option:
chain_lst = snap_src_lst[-1:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail(err_msg)
elif "base" or "shallow" in base_option:
chain_lst = snap_src_lst[::-1]
if not base_index and base_image:
base_index = chain_lst.index(base_image)
val_tmp = []
for i in range(1, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail(err_msg)
# If base image is the top layer of snapshot chain,
# virsh blockpull should fail, return directly
if base_option == "top":
return
# Check flag files
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
raise error.TestFail("blockpull failed: %s" % output)
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
if not disk_src_protocol or disk_src_protocol != 'gluster':
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
libvirtd = utils_libvirtd.Libvirtd()
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd.restart()
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test command: virsh blockcommit <domain> <path>
1) Prepare test environment.
2) Commit changes from a snapshot down to its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot():
# Add all disks into commandline.
disks = vm.get_disk_devices()
# Make three external snapshots for disks only
for count in range(1, 4):
options = "snapshot%s snap%s-desc " \
"--disk-only --atomic --no-metadata" % (count, count)
if needs_agent:
options += " --quiesce"
for disk in disks:
disk_detail = disks[disk]
basename = os.path.basename(disk_detail['source'])
# Remove the original suffix if any, appending ".snap[0-9]"
diskname = basename.split(".")[0]
disk_external = os.path.join(tmp_dir,
"%s.snap%s" % (diskname, count))
snapshot_external_disks.append(disk_external)
options += " %s,snapshot=external,file=%s" % (disk,
disk_external)
cmd_result = virsh.snapshot_create_as(vm_name, options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
if status != 0:
raise error.TestFail("Failed to make snapshots for disks!")
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
raise error.TestFail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_state = params.get("vm_state", "running")
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
top_inactive = ("yes" == params.get("top_inactive"))
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", "none")
middle_base = "yes" == params.get("middle_base", "no")
pivot_opt = "yes" == params.get("pivot_opt", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", "no")
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", "no")
virsh_dargs = {'debug': True}
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_src_protocol = params.get("disk_source_protocol")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
if not top_inactive:
if not libvirt_version.version_compare(1, 2, 4):
raise error.TestNAError("live active block commit is not supported"
+ " in current libvirt version.")
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
raise error.TestFail("There are snapshots created for %s already" %
vm_name)
snapshot_external_disks = []
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
raise error.TestNAError("'iscsi' disk doesn't support in"
+ " current libvirt version.")
# Set vm xml and guest agent
if replace_vm_disk:
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
libvirt.set_guest_agent(vm)
# The first disk is supposed to include OS
# We will perform blockcommit operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
make_disk_snapshot()
# snapshot src file list
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
backing_chain = ''
for i in reversed(range(4)):
if i == 0:
backing_chain += "%s" % snap_src_lst[i]
else:
backing_chain += "%s -> " % snap_src_lst[i]
logging.debug("The backing chain is: %s" % backing_chain)
# check snapshot disk xml backingStore is expected
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
disk_xml = None
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
logging.debug("the target disk xml after snapshot is %s",
disk_xml)
break
if not disk_xml:
raise error.TestFail("Can't find disk xml with target %s" %
blk_target)
elif libvirt_version.version_compare(1, 2, 4):
# backingStore element introuduced in 1.2.4
chain_lst = snap_src_lst[::-1]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail("Domain image backing chain check failed")
# set blockcommit_options
top_image = None
blockcommit_options = "--wait --verbose"
basename = os.path.basename(blk_source)
diskname = basename.split(".")[0]
if with_timeout:
blockcommit_options += " --timeout 1"
if base_option == "shallow":
blockcommit_options += " --shallow"
elif base_option == "base":
if middle_base:
blk_source = os.path.join(tmp_dir, "%s.snap1" %
diskname)
blockcommit_options += " --base %s" % blk_source
if top_inactive:
top_image = os.path.join(tmp_dir, "%s.snap2" %
diskname)
blockcommit_options += " --top %s" % top_image
else:
blockcommit_options += " --active"
if pivot_opt:
blockcommit_options += " --pivot"
if vm_state == "shut off":
vm.shutdown()
# Run test case
result = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
# Check status_error
libvirt.check_exit_status(result, status_error)
if result.exit_status and status_error:
return
while True:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
if not top_inactive:
disk_mirror = disk_xml.find('mirror')
if '--pivot' not in blockcommit_options:
if disk_mirror is not None:
job_type = disk_mirror.get('job')
job_ready = disk_mirror.get('ready')
src_element = disk_mirror.find('source')
disk_src_file = None
for elem in ('file', 'name', 'dev'):
elem_val = src_element.get(elem)
if elem_val:
disk_src_file = elem_val
break
err_msg = "blockcommit base source "
err_msg += "%s not expected" % disk_src_file
if '--shallow' in blockcommit_options:
if disk_src_file != snap_src_lst[2]:
raise error.TestFail(err_msg)
else:
if disk_src_file != blk_source:
raise error.TestFail(err_msg)
if libvirt_version.version_compare(1, 2, 7):
# The job attribute mentions which API started the
# operation since 1.2.7.
if job_type != 'active-commit':
raise error.TestFail("blockcommit job type '%s'"
" not expected" % job_type)
if job_ready != 'yes':
# The attribute ready, if present, tracks
# progress of the job: yes if the disk is known
# to be ready to pivot, or, since 1.2.7, abort
# or pivot if the job is in the process of
# completing.
continue
else:
logging.debug("after active block commit job "
"ready for pivot, the target disk"
" xml is %s", disk_xml)
break
else:
break
else:
if disk_mirror is None:
logging.debug(disk_xml)
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.pop(0)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail("Domain image backing "
"chain check failed")
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
base_index = chain_lst.index(blk_source)
chain_lst = chain_lst[base_index:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail("Domain image backing "
"chain check failed")
break
else:
# wait pivot after commit is synced
continue
else:
logging.debug("after inactive commit the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.remove(top_image)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail("Domain image backing chain "
"check failed")
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
top_index = chain_lst.index(top_image)
base_index = chain_lst.index(blk_source)
val_tmp = []
for i in range(top_index, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
raise error.TestFail("Domain image backing chain "
"check failed")
break
else:
break
# Check flag files
if not vm_state == "shut off":
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
raise error.TestFail("blockcommit failed: %s" % output)
if not pivot_opt and snap_in_mirror:
# do snapshot during mirror phase
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
snapshot_external_disks.append(snap_path)
cmd_result = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
libvirt.check_exit_status(cmd_result, snap_in_mirror_err)
finally:
if vm.is_alive():
vm.destroy()
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test virsh snapshot command when disk in all kinds of type.
(1). Init the variables from params.
(2). Create a image by specifice format.
(3). Attach disk to vm.
(4). Snapshot create.
(5). Snapshot revert.
(6). cleanup.
"""
# Init variables.
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
vm_state = params.get("vm_state", "running")
image_format = params.get("snapshot_image_format", "qcow2")
snapshot_del_test = "yes" == params.get("snapshot_del_test", "no")
status_error = ("yes" == params.get("status_error", "no"))
snapshot_from_xml = ("yes" == params.get("snapshot_from_xml", "no"))
snapshot_current = ("yes" == params.get("snapshot_current", "no"))
snapshot_revert_paused = ("yes" == params.get("snapshot_revert_paused",
"no"))
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
multi_gluster_disks = "yes" == params.get("multi_gluster_disks", "no")
# Pool variables.
snapshot_with_pool = "yes" == params.get("snapshot_with_pool", "no")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
emulated_image = params.get("emulated_image", "emulated-image")
vol_format = params.get("vol_format")
lazy_refcounts = "yes" == params.get("lazy_refcounts")
options = params.get("snapshot_options", "")
export_options = params.get("export_options", "rw,no_root_squash,fsid=0")
# Set volume xml attribute dictionary, extract all params start with 'vol_'
# which are for setting volume xml, except 'lazy_refcounts'.
vol_arg = {}
for key in params.keys():
if key.startswith('vol_'):
if key[4:] in ['capacity', 'allocation', 'owner', 'group']:
vol_arg[key[4:]] = int(params[key])
else:
vol_arg[key[4:]] = params[key]
vol_arg['lazy_refcounts'] = lazy_refcounts
supported_pool_list = [
"dir", "fs", "netfs", "logical", "iscsi", "disk", "gluster"
]
if snapshot_with_pool:
if pool_type not in supported_pool_list:
raise error.TestNAError("%s not in support list %s" %
(pool_target, supported_pool_list))
# Do xml backup for final recovery
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Some variable for xmlfile of snapshot.
snapshot_memory = params.get("snapshot_memory", "internal")
snapshot_disk = params.get("snapshot_disk", "internal")
no_memory_snap = "yes" == params.get("no_memory_snap", "no")
# Skip 'qed' cases for libvirt version greater than 1.1.0
if libvirt_version.version_compare(1, 1, 0):
if vol_format == "qed" or image_format == "qed":
raise error.TestNAError("QED support changed, check bug: "
"https://bugzilla.redhat.com/show_bug.cgi"
"?id=731570")
if not libvirt_version.version_compare(1, 2, 7):
# As bug 1017289 closed as WONTFIX, the support only
# exist on 1.2.7 and higher
if disk_source_protocol == 'gluster':
raise error.TestNAError("Snapshot on glusterfs not support in "
"current version. Check more info with "
"https://bugzilla.redhat.com/buglist.cgi?"
"bug_id=1017289,1032370")
# Init snapshot_name
snapshot_name = None
snapshot_external_disk = []
snapshot_xml_path = None
del_status = None
image = None
pvt = None
# Get a tmp dir
snap_cfg_path = "/var/lib/libvirt/qemu/snapshot/%s/" % vm_name
try:
if replace_vm_disk:
utlv.set_vm_disk(vm, params, tmp_dir)
if multi_gluster_disks:
new_params = params.copy()
new_params["pool_name"] = "gluster-pool2"
new_params["vol_name"] = "gluster-vol2"
new_params["disk_target"] = "vdf"
new_params["image_convert"] = 'no'
utlv.set_vm_disk(vm, new_params, tmp_dir)
if snapshot_with_pool:
# Create dst pool for create attach vol img
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name,
pool_type,
pool_target,
emulated_image,
image_size="1G",
pre_disk_vol=["20M"],
source_name=vol_name,
export_options=export_options)
if pool_type in ["iscsi", "disk"]:
# iscsi and disk pool did not support create volume in libvirt,
# logical pool could use libvirt to create volume but volume
# format is not supported and will be 'raw' as default.
pv = libvirt_storage.PoolVolume(pool_name)
vols = pv.list_volumes().keys()
if vols:
vol_name = vols[0]
else:
raise error.TestNAError("No volume in pool: %s" %
pool_name)
else:
# Set volume xml file
volxml = libvirt_xml.VolXML()
newvol = volxml.new_vol(**vol_arg)
vol_xml = newvol['xml']
# Run virsh_vol_create to create vol
logging.debug("create volume from xml: %s" %
newvol.xmltreefile)
cmd_result = virsh.vol_create(pool_name,
vol_xml,
ignore_status=True,
debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to create attach volume.")
cmd_result = virsh.vol_path(vol_name, pool_name, debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to get volume path from pool.")
img_path = cmd_result.stdout.strip()
if pool_type in ["logical", "iscsi", "disk"]:
# Use qemu-img to format logical, iscsi and disk block device
if vol_format != "raw":
cmd = "qemu-img create -f %s %s 10M" % (vol_format,
img_path)
cmd_result = utils.run(cmd, ignore_status=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to format volume, %s" %
cmd_result.stdout.strip())
extra = "--persistent --subdriver %s" % vol_format
else:
# Create a image.
params['image_name'] = "snapshot_test"
params['image_format'] = image_format
params['image_size'] = "1M"
image = qemu_storage.QemuImg(params, tmp_dir, "snapshot_test")
img_path, _ = image.create(params)
extra = "--persistent --subdriver %s" % image_format
if not multi_gluster_disks:
# Do the attach action.
out = utils.run("qemu-img info %s" % img_path)
logging.debug("The img info is:\n%s" % out.stdout.strip())
result = virsh.attach_disk(vm_name,
source=img_path,
target="vdf",
extra=extra,
debug=True)
if result.exit_status:
raise error.TestNAError("Failed to attach disk %s to VM."
"Detail: %s." %
(img_path, result.stderr))
# Create snapshot.
if snapshot_from_xml:
snap_xml = libvirt_xml.SnapshotXML()
snapshot_name = "snapshot_test"
snap_xml.snap_name = snapshot_name
snap_xml.description = "Snapshot Test"
if not no_memory_snap:
if "--disk-only" not in options:
if snapshot_memory == "external":
memory_external = os.path.join(tmp_dir,
"snapshot_memory")
snap_xml.mem_snap_type = snapshot_memory
snap_xml.mem_file = memory_external
snapshot_external_disk.append(memory_external)
else:
snap_xml.mem_snap_type = snapshot_memory
# Add all disks into xml file.
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
for src_disk_xml in disks:
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = snapshot_disk
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
if snapshot_disk == 'external':
new_attrs = disk_xml.source.attrs
if disk_xml.source.attrs.has_key('file'):
new_file = "%s.snap" % disk_xml.source.attrs['file']
snapshot_external_disk.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif disk_xml.source.attrs.has_key('name'):
new_name = "%s.snap" % disk_xml.source.attrs['name']
new_attrs.update({'name': new_name})
hosts = disk_xml.source.hosts
elif (disk_xml.source.attrs.has_key('dev')
and disk_xml.type_name == 'block'):
# Use local file as external snapshot target for block type.
# As block device will be treat as raw format by default,
# it's not fit for external disk snapshot target. A work
# around solution is use qemu-img again with the target.
disk_xml.type_name = 'file'
del new_attrs['dev']
new_file = "%s/blk_src_file.snap" % tmp_dir
snapshot_external_disk.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
else:
del disk_xml.source
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options += " --xmlfile %s " % snapshot_xml_path
if vm_state == "shut off":
vm.destroy(gracefully=False)
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
out_err = snapshot_result.stderr.strip()
if snapshot_result.exit_status:
if status_error:
return
else:
if re.search(
"live disk snapshot not supported with this "
"QEMU binary", out_err):
raise error.TestNAError(out_err)
if libvirt_version.version_compare(1, 2, 5):
# As commit d2e668e in 1.2.5, internal active snapshot
# without memory state is rejected. Handle it as SKIP
# for now. This could be supportted in future by bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1103063
if re.search(
"internal snapshot of a running VM" +
" must include the memory state", out_err):
raise error.TestNAError("Check Bug #1083345, %s" %
out_err)
raise error.TestFail(
"Failed to create snapshot. Error:%s." % out_err)
else:
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
if snapshot_result.exit_status:
if status_error:
return
else:
raise error.TestFail(
"Failed to create snapshot. Error:%s." %
snapshot_result.stderr.strip())
snapshot_name = re.search("\d+",
snapshot_result.stdout.strip()).group(0)
if snapshot_current:
snap_xml = libvirt_xml.SnapshotXML()
new_snap = snap_xml.new_from_snapshot_dumpxml(
vm_name, snapshot_name)
# update an element
new_snap.creation_time = snapshot_name
snapshot_xml_path = new_snap.xml
options += "--redefine %s --current" % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
if snapshot_result.exit_status:
raise error.TestFail("Failed to create snapshot --current."
"Error:%s." %
snapshot_result.stderr.strip())
if status_error:
if not snapshot_del_test:
raise error.TestFail("Success to create snapshot in negative"
" case\nDetail: %s" % snapshot_result)
# Touch a file in VM.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
# Init a unique name for tmp_file.
tmp_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
tmp_file_path = tmp_file.name
tmp_file.close()
echo_cmd = "echo SNAPSHOT_DISK_TEST >> %s" % tmp_file_path
status, output = session.cmd_status_output(echo_cmd)
logging.debug("The echo output in domain is: '%s'", output)
if status:
raise error.TestFail("'%s' run failed with '%s'" %
(tmp_file_path, output))
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("File created with content: '%s'", output)
session.close()
# As only internal snapshot revert works now, let's only do revert
# with internal, and move the all skip external cases back to pass.
# After external also supported, just move the following code back.
if snapshot_disk == 'internal':
# Destroy vm for snapshot revert.
if not libvirt_version.version_compare(1, 2, 3):
virsh.destroy(vm_name)
# Revert snapshot.
revert_options = ""
if snapshot_revert_paused:
revert_options += " --paused"
revert_result = virsh.snapshot_revert(vm_name,
snapshot_name,
revert_options,
debug=True)
if revert_result.exit_status:
# Attempts to revert external snapshots will FAIL with an error
# "revert to external disk snapshot not supported yet" or "revert
# to external snapshot not supported yet" since d410e6f. Thus,
# let's check for that and handle as a SKIP for now. Check bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1071264
if re.search(
"revert to external \w* ?snapshot not supported yet",
revert_result.stderr):
raise error.TestNAError(revert_result.stderr.strip())
else:
raise error.TestFail("Revert snapshot failed. %s" %
revert_result.stderr.strip())
if vm.is_dead():
raise error.TestFail("Revert snapshot failed.")
if snapshot_revert_paused:
if vm.is_paused():
vm.resume()
else:
raise error.TestFail(
"Revert command successed, but VM is not "
"paused after reverting with --paused"
" option.")
# login vm.
session = vm.wait_for_login()
# Check the result of revert.
status, output = session.cmd_status_output("cat %s" %
tmp_file_path)
logging.debug("After revert cat file output='%s'", output)
if not status:
raise error.TestFail("Tmp file exists, revert failed.")
# Close the session.
session.close()
# Test delete snapshot without "--metadata", delete external disk
# snapshot will fail for now.
# Only do this when snapshot creat succeed which filtered in cfg file.
if snapshot_del_test:
if snapshot_name:
del_result = virsh.snapshot_delete(vm_name,
snapshot_name,
debug=True,
ignore_status=True)
del_status = del_result.exit_status
snap_xml_path = snap_cfg_path + "%s.xml" % snapshot_name
if del_status:
if not status_error:
raise error.TestFail("Failed to delete snapshot.")
else:
if not os.path.exists(snap_xml_path):
raise error.TestFail(
"Snapshot xml file %s missing" % snap_xml_path)
else:
if status_error:
err_msg = "Snapshot delete succeed but expect fail."
raise error.TestFail(err_msg)
else:
if os.path.exists(snap_xml_path):
raise error.TestFail("Snapshot xml file %s still" %
snap_xml_path + " exist")
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
virsh.detach_disk(vm_name, target="vdf", extra="--persistent")
if image:
image.remove()
if del_status and snapshot_name:
virsh.snapshot_delete(vm_name, snapshot_name, "--metadata")
for disk in snapshot_external_disk:
if os.path.exists(disk):
os.remove(disk)
vmxml_backup.sync("--snapshots-metadata")
libvirtd = utils_libvirtd.Libvirtd()
if disk_source_protocol == 'gluster':
utlv.setup_or_cleanup_gluster(False, vol_name, brick_path)
if multi_gluster_disks:
brick_path = os.path.join(tmp_dir, "gluster-pool2")
utlv.setup_or_cleanup_gluster(False, "gluster-vol2",
brick_path)
libvirtd.restart()
if snapshot_xml_path:
if os.path.exists(snapshot_xml_path):
os.unlink(snapshot_xml_path)
if pvt:
try:
pvt.cleanup_pool(pool_name,
pool_type,
pool_target,
emulated_image,
source_name=vol_name)
except error.TestFail, detail:
libvirtd.restart()
logging.error(str(detail))
def run(test, params, env):
"""
Test virsh migrate-setmaxdowntime command.
1) Prepare migration environment
2) Start migration and set migrate-maxdowntime
3) Cleanup environment(migrated vm on destination)
4) Check result
"""
dest_uri = params.get("virsh_migrate_dest_uri",
"qemu+ssh://MIGRATE_EXAMPLE/system")
src_uri = params.get("virsh_migrate_src_uri",
"qemu+ssh://MIGRATE_EXAMPLE/system")
if dest_uri.count('///') or dest_uri.count('MIGRATE_EXAMPLE'):
test.cancel("Set your destination uri first.")
if src_uri.count('MIGRATE_EXAMPLE'):
test.cancel("Set your source uri first.")
if src_uri == dest_uri:
test.cancel("You should not set dest uri same as local.")
vm_ref = params.get("setmmdt_vm_ref", "domname")
pre_vm_state = params.get("pre_vm_state", "running")
status_error = "yes" == params.get("status_error", "no")
do_migrate = "yes" == params.get("do_migrate", "yes")
migrate_maxdowntime = params.get("migrate_maxdowntime", 1.000)
if (migrate_maxdowntime == ""):
downtime = ""
else:
downtime = int(float(migrate_maxdowntime)) * 1000
extra = params.get("setmmdt_extra")
# For --postcopy enable
postcopy_options = params.get("postcopy_options", "")
# A delay between threads
delay_time = int(params.get("delay_time", 1))
# timeout of threads
thread_timeout = 180
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
grep_str_local = params.get("grep_str_from_local_libvirt_log", "")
# For safety reasons, we'd better back up original guest xml
orig_config_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if not orig_config_xml:
test.error("Backing up xmlfile failed.")
# Clean up daemon log
log_file = params.get("log_file")
cleanup_daemon_log(log_file)
# Config daemon log
log_conf_dict = eval(params.get("log_conf_dict", '{}'))
log_conf_type = params.get("log_conf_type")
log_conf = None
log_conf = update_config_file(log_conf_type,
log_conf_dict,
scp_to_remote=False,
remote_params=None)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Params to setup SSH connection
params["server_ip"] = params.get("migrate_dest_host")
params["server_pwd"] = params.get("migrate_dest_pwd")
params["client_ip"] = params.get("migrate_source_host")
params["client_pwd"] = params.get("migrate_source_pwd")
params["nfs_client_ip"] = params.get("migrate_dest_host")
params["nfs_server_ip"] = params.get("migrate_source_host")
# Params to enable SELinux boolean on remote host
params["remote_boolean_varible"] = "virt_use_nfs"
params["remote_boolean_value"] = "on"
params["set_sebool_remote"] = "yes"
remote_host = params.get("migrate_dest_host")
username = params.get("migrate_dest_user", "root")
password = params.get("migrate_dest_pwd")
# Config ssh autologin for remote host
ssh_key.setup_ssh_key(remote_host, username, password, port=22)
setmmdt_dargs = {'debug': True, 'ignore_status': True, 'uri': src_uri}
migrate_dargs = {
'debug': True,
'ignore_status': True,
'postcopy_options': postcopy_options
}
try:
# Update the disk using shared storage
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
vm.wait_for_login()
domid = vm.get_id()
# Confirm how to reference a VM.
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
# Prepare vm state
if pre_vm_state == "paused":
vm.pause()
elif pre_vm_state == "shutoff":
vm.destroy(gracefully=False)
# Ensure VM in 'shut off' status
utils_misc.wait_for(lambda: vm.state() == "shut off", 30)
# Set max migration downtime must be during migration
# Using threads for synchronization
threads = []
if do_migrate:
threads.append(
threading.Thread(target=thread_func_live_migration,
args=(vm, dest_uri, migrate_dargs)))
threads.append(
threading.Thread(target=thread_func_setmmdt,
args=(vm_ref, downtime, extra, setmmdt_dargs)))
for thread in threads:
thread.start()
# Migration must be executing before setting maxdowntime
time.sleep(delay_time)
# Wait until thread is over
for thread in threads:
thread.join(thread_timeout)
if (status_error is False or do_migrate is False):
logging.debug("To match the expected pattern '%s' ...",
grep_str_local)
cmd = "grep -E '%s' %s" % (grep_str_local, log_file)
cmdResult = process.run(cmd, shell=True, verbose=False)
logging.debug(cmdResult)
finally:
# Clean up.
if do_migrate:
logging.debug("Cleanup VM on remote host...")
cleanup_dest(vm, src_uri, dest_uri)
if orig_config_xml:
logging.debug("Recover VM XML...")
orig_config_xml.sync()
logging.info("Remove the NFS image...")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
# Recover libvirtd service configuration on local
if log_conf:
logging.debug("Recover local libvirtd configuration...")
libvirt.customize_libvirt_config(None,
remote_host=False,
extra_params=params,
is_recover=True,
config_object=log_conf)
cleanup_daemon_log(log_file)
# Check results.
if status_error:
if ret_setmmdt:
if not do_migrate and libvirt_version.version_compare(1, 2, 9):
# https://bugzilla.redhat.com/show_bug.cgi?id=1146618
# Commit fe808d9 fix it and allow setting migration
# max downtime any time since libvirt-1.2.9
logging.info("Libvirt version is newer than 1.2.9,"
"Allow set maxdowntime while VM isn't migrating")
else:
test.fail("virsh migrate-setmaxdowntime succeed "
"but not expected.")
else:
if do_migrate and not ret_migration:
test.fail("Migration failed.")
if not ret_setmmdt:
test.fail("virsh migrate-setmaxdowntime failed.")
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of interface
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def reboot():
"""
Shutdown and restart guest, then wait for login
"""
vm.destroy()
vm.start()
return vm.wait_for_login()
def check_plug_to_pci_bridge(vm_name, mac):
"""
Check if the nic is plugged onto pcie-to-pci-bridge
:param vm_name： Vm name
:param mac: The mac address of plugged interface
:return True if plugged onto pcie-to-pci-bridge, otherwise False
"""
v_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
interface = v_xml.get_iface_all()[mac]
bus = int(eval(interface.find('address').get('bus')))
controllers = vmxml.get_controllers('pci')
for controller in controllers:
if controller.get('index') == bus:
if controller.get('model') == 'pcie-to-pci-bridge':
return True
break
return False
def detect_new_nic(mac):
"""
Detect the new interface by domiflist
:param mac: The mac address of plugged interface
:return plugged interface name
"""
def check_mac_exist():
all_infos = libvirt.get_interface_details(vm_name)
for nic_info in all_infos:
if nic_info.get('mac') == mac:
return nic_info.get('interface')
return False
plugged_nic = utils_misc.wait_for(lambda: check_mac_exist(), 5)
if not plugged_nic:
test.fail("Failed to plug device %s" % mac)
return plugged_nic
def renew_ip_address(session, mac, guest_os_type):
"""
Renew ip for plugged nic
:param session: Vm session
:param mac: The mac address of plugged interface
:param guest_os_type: Guest os type, Linux or Windows
"""
if guest_os_type == 'Windows':
utils_net.restart_windows_guest_network_by_key(
session, "macaddress", mac)
ifname = utils_net.get_linux_ifname(session, mac)
utils_net.create_network_script(ifname, mac, 'dhcp', '255.255.255.0')
utils_net.restart_guest_network(session, mac)
arp_clean = "arp -n|awk '/^[1-9]/{print \"arp -d \" $1}'|sh"
session.cmd_output_safe(arp_clean)
def get_hotplug_nic_ip(vm, nic, session, guest_os_type):
"""
Get if of the plugged interface
:param vm: Vm object
:param nic: Nic object
:param session: Vm session
:param guest_os_type: Guest os type, Linux or Windows
:return: Nic ip
"""
def __get_address():
"""
Get ip address and return it, configure a new ip if device
exists but no ip
:return: Ip address if get, otherwise None
"""
try:
index = [
_idx for _idx, _nic in enumerate(vm.virtnet) if _nic == nic
][0]
return vm.wait_for_get_address(index, timeout=90)
except IndexError:
test.error("Nic '%s' not exists in VM '%s'" %
(nic["nic_name"], vm.name))
except (virt_vm.VMIPAddressMissingError,
virt_vm.VMAddressVerificationError):
renew_ip_address(session, nic["mac"], guest_os_type)
return
# Wait for ip address is configured for the nic device
nic_ip = utils_misc.wait_for(__get_address, timeout=360)
if nic_ip:
return nic_ip
cached_ip = vm.address_cache.get(nic["mac"])
arps = process.system_output("arp -aen").decode()
logging.debug("Can't get IP address:")
logging.debug("\tCached IP: %s", cached_ip)
logging.debug("\tARP table: %s", arps)
return None
def check_nic_removed(mac, session):
"""
Get interface IP address by given MAC addrss. If try_dhclint is
True, then try to allocate IP addrss for the interface.
:param mac: The mac address of plugged interface
:param session: Vm session
"""
except_mesg = ''
try:
if guest_os_type == 'Windows':
except_mesg = "Get nic netconnectionid failed"
utils_net.restart_windows_guest_network_by_key(
session, "macaddress", mac)
else:
except_mesg = ("Failed to determine interface"
" name with mac %s" % mac)
utils_net.get_linux_ifname(session, mac)
except exceptions.TestError as e:
if except_mesg in str(e):
return True
else:
return False
def attach_nic(): # pylint: disable=W0611
"""
Attach interface, by xml or cmd, for both hot and cold plug
"""
def create_iface_xml(mac):
"""
Create interface xml file
:param mac: The mac address of nic device
"""
iface = Interface(type_name='network')
iface.source = iface_source
iface.model = iface_model
iface.mac_address = mac
logging.debug("Create new interface xml: %s", iface)
return iface
plug_method = params.get('plug_method', 'interface')
cold_plug = params.get('cold_plug', 'no')
mac = utils_net.generate_mac_address_simple()
iface_source = {'network': 'default'}
iface_model = params["virtio_model"]
options = ("network %s --model %s --mac %s" %
(iface_source['network'], iface_model, mac))
nic_params = {
'mac': mac,
'nettype': params['nettype'],
'ip_version': 'ipv4'
}
if cold_plug == "yes":
options += ' --config'
if plug_method == 'interface': # Hotplug nic vir attach-interface
ret = virsh.attach_interface(vm_name, options, ignore_status=True)
else: # Hotplug nic via attach-device
nic_xml = create_iface_xml(mac)
nic_xml.xmltreefile.write()
xml_file = nic_xml.xml
with open(xml_file) as nic_file:
logging.debug("Attach device by XML: %s", nic_file.read())
ret = virsh.attach_device(domainarg=vm_name,
filearg=xml_file,
debug=True)
libvirt.check_exit_status(ret)
if cold_plug == "yes":
reboot() # Reboot guest if it is cold plug test
detect_new_nic(mac)
if plug_method == 'interface' and cold_plug == 'no':
check_plug_to_pci_bridge(vm_name, mac)
session = vm.wait_for_login(serial=True)
# Add nic to VM object for further check
nic_name = vm.add_nic(**nic_params)["nic_name"]
nic = vm.virtnet[nic_name]
# Config ip inside guest for new added nic
if not utils_misc.wait_for(
lambda: get_hotplug_nic_ip(vm, nic, session, guest_os_type),
timeout=30):
test.fail("Does not find plugged nic %s in guest" % mac)
options = ("network %s" % mac)
if cold_plug == "yes":
options += ' --config'
# Detach nic device
if plug_method == 'interface':
ret = virsh.detach_interface(vm_name, options, ignore_status=True)
else:
with open(xml_file) as nic_file:
logging.debug("Detach device by XML: %s", nic_file.read())
ret = virsh.detach_device(domainarg=vm_name,
filearg=xml_file,
debug=True)
libvirt.check_exit_status(ret)
if cold_plug == "yes":
session = reboot() # Reboot guest if it is cold plug test
# Check if nic is removed from guest
if not utils_misc.wait_for(lambda: check_nic_removed(mac, session),
timeout=30):
test.fail("The nic %s still exist in guest after being unplugged" %
nic_name)
def save_restore(): # pylint: disable=W0611
"""
Sub test for save and restore
"""
save_path = os.path.join(data_dir.get_tmp_dir(),
'%s.save' % params['os_variant'])
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
def ping_test(restart_network=False):
"""
Basic ping test for interface
:param restart_network: True or False. Whether to restart network
:raise: test.fail if ping test fails
"""
session = vm.wait_for_login()
if restart_network:
utils_net.restart_guest_network(session)
dest = params.get('ping_dest', 'www.baidu.com')
status, output = utils_test.ping(dest, 10, session=session, timeout=20)
session.close()
if status != 0:
test.fail("Ping failed, status: %s,"
" output: %s" % (status, output))
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
guest_src_url = params.get("guest_src_url")
params['disk_model'] = params['virtio_model']
guest_os_type = params['os_type']
target_path = None
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
# Download and replace image when guest_src_url provided
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
libvirt.set_vm_disk(vm, params)
# Add pcie-to-pci-bridge when there is no one
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
cntl_add = libvirt.create_controller_xml(contr_dict)
libvirt.add_controller(vm_name, cntl_add)
try: # Update interface model as defined
iface_params = {'model': params['virtio_model']}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
if not vm.is_alive():
vm.start()
# Test if nic works well via ping
ping_test()
test_step = params.get("sub_test_step")
if test_step:
eval(test_step)()
# Test if nic still work well afeter sub steps test
ping_test(True)
finally:
vm.destroy()
backup_xml.sync()
if guest_src_url and target_path:
libvirt.delete_local_disk("file", path=target_path)
def run(test, params, env):
"""
Test rbd disk device.
1.Prepare test environment,destroy or suspend a VM.
2.Prepare disk image.
3.Edit disks xml and start the domain.
4.Perform test operation.
5.Recover test environment.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
additional_xml_file = os.path.join(data_dir.get_tmp_dir(), "additional_disk.xml")
def config_ceph():
"""
Write the configs to the file.
"""
src_host = disk_src_host.split()
src_port = disk_src_port.split()
conf_str = "mon_host = "
hosts = []
for host, port in zip(src_host, src_port):
hosts.append("%s:%s" % (host, port))
with open(disk_src_config, 'w') as f:
f.write(conf_str + ','.join(hosts) + '\n')
def create_pool():
"""
Define and start a pool.
"""
sp = libvirt_storage.StoragePool()
if create_by_xml:
p_xml = pool_xml.PoolXML(pool_type=pool_type)
p_xml.name = pool_name
s_xml = pool_xml.SourceXML()
s_xml.vg_name = disk_src_pool
source_host = []
for (host_name, host_port) in zip(
disk_src_host.split(), disk_src_port.split()):
source_host.append({'name': host_name,
'port': host_port})
s_xml.hosts = source_host
if auth_type:
s_xml.auth_type = auth_type
if auth_user:
s_xml.auth_username = auth_user
if auth_usage:
s_xml.secret_usage = auth_usage
p_xml.source = s_xml
logging.debug("Pool xml: %s", p_xml)
p_xml.xmltreefile.write()
ret = virsh.pool_define(p_xml.xml, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_build(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_start(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
else:
auth_opt = ""
if client_name and client_key:
auth_opt = ("--auth-type %s --auth-username %s --secret-usage '%s'"
% (auth_type, auth_user, auth_usage))
if not sp.define_rbd_pool(pool_name, mon_host,
disk_src_pool, extra=auth_opt):
test.fail("Failed to define storage pool")
if not sp.build_pool(pool_name):
test.fail("Failed to build storage pool")
if not sp.start_pool(pool_name):
test.fail("Failed to start storage pool")
# Check pool operation
ret = virsh.pool_refresh(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_uuid(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
# pool-info
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'no':
test.fail("Failed to check pool information")
# pool-autostart
if not sp.set_pool_autostart(pool_name):
test.fail("Failed to set pool autostart")
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'yes':
test.fail("Failed to check pool information")
# pool-autostart --disable
if not sp.set_pool_autostart(pool_name, "--disable"):
test.fail("Failed to set pool autostart")
# If port is not pre-configured, port value should not be hardcoded in pool information.
if "yes" == params.get("rbd_port", "no"):
if 'port' in virsh.pool_dumpxml(pool_name):
test.fail("port attribute should not be in pool information")
# find-storage-pool-sources-as
if "yes" == params.get("find_storage_pool_sources_as", "no"):
ret = virsh.find_storage_pool_sources_as("rbd", mon_host)
libvirt.check_result(ret, skip_if=unsupported_err)
def create_vol(vol_params):
"""
Create volume.
:param p_name. Pool name.
:param vol_params. Volume parameters dict.
:return: True if create successfully.
"""
pvt = libvirt.PoolVolumeTest(test, params)
if create_by_xml:
pvt.pre_vol_by_xml(pool_name, **vol_params)
else:
pvt.pre_vol(vol_name, None, '2G', None, pool_name)
def check_vol(vol_params):
"""
Check volume information.
"""
pv = libvirt_storage.PoolVolume(pool_name)
# Supported operation
if vol_name not in pv.list_volumes():
test.fail("Volume %s doesn't exist" % vol_name)
ret = virsh.vol_dumpxml(vol_name, pool_name)
libvirt.check_exit_status(ret)
# vol-info
if not pv.volume_info(vol_name):
test.fail("Can't see volume info")
# vol-key
ret = virsh.vol_key(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume key isn't correct")
# vol-path
ret = virsh.vol_path(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume path isn't correct")
# vol-pool
ret = virsh.vol_pool("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if pool_name not in ret.stdout.strip():
test.fail("Volume pool isn't correct")
# vol-name
ret = virsh.vol_name("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if vol_name not in ret.stdout.strip():
test.fail("Volume name isn't correct")
# vol-resize
ret = virsh.vol_resize(vol_name, "2G", pool_name)
libvirt.check_exit_status(ret)
# Not supported operation
# vol-clone
ret = virsh.vol_clone(vol_name, cloned_vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-create-from
volxml = vol_xml.VolXML()
vol_params.update({"name": "%s" % create_from_cloned_volume})
v_xml = volxml.new_vol(**vol_params)
v_xml.xmltreefile.write()
ret = virsh.vol_create_from(pool_name, v_xml.xml, vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-wipe
ret = virsh.vol_wipe(vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-upload
ret = virsh.vol_upload(vol_name, vm.get_first_disk_devices()['source'],
"--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-download
ret = virsh.vol_download(vol_name, cloned_vol_name, "--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
def check_qemu_cmd():
"""
Check qemu command line options.
"""
cmd = ("ps -ef | grep %s | grep -v grep " % vm_name)
process.run(cmd, shell=True)
if disk_src_name:
cmd += " | grep file=rbd:%s:" % disk_src_name
if auth_user and auth_key:
cmd += ('id=%s:auth_supported=cephx' % auth_user)
if disk_src_config:
cmd += " | grep 'conf=%s'" % disk_src_config
elif mon_host:
hosts = '\:6789\;'.join(mon_host.split())
cmd += " | grep 'mon_host=%s'" % hosts
if driver_iothread:
cmd += " | grep iothread%s" % driver_iothread
# Run the command
process.run(cmd, shell=True)
def check_save_restore():
"""
Test save and restore operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(),
"%s.save" % vm_name)
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
# Login to check vm status
vm.wait_for_login().close()
def check_snapshot(snap_option, target_dev='vda'):
"""
Test snapshot operation.
"""
snap_name = "s1"
snap_mem = os.path.join(data_dir.get_tmp_dir(), "rbd.mem")
snap_disk = os.path.join(data_dir.get_tmp_dir(), "rbd.disk")
xml_snap_exp = ["disk name='%s' snapshot='external' type='file'" % target_dev]
xml_dom_exp = ["source file='%s'" % snap_disk,
"backingStore type='network' index='1'",
"source protocol='rbd' name='%s'" % disk_src_name]
if snap_option.count("disk-only"):
options = ("%s --diskspec %s,file=%s --disk-only" %
(snap_name, target_dev, snap_disk))
elif snap_option.count("disk-mem"):
options = ("%s --memspec file=%s --diskspec %s,file="
"%s" % (snap_name, snap_mem, target_dev, snap_disk))
xml_snap_exp.append("memory snapshot='external' file='%s'"
% snap_mem)
else:
options = snap_name
ret = virsh.snapshot_create_as(vm_name, options)
if test_disk_internal_snapshot or test_disk_readonly:
libvirt.check_result(ret, expected_fails=unsupported_err)
else:
libvirt.check_result(ret, skip_if=unsupported_err)
# check xml file.
if not ret.exit_status:
snap_xml = virsh.snapshot_dumpxml(vm_name, snap_name,
debug=True).stdout.strip()
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
# Delete snapshots.
libvirt.clean_up_snapshots(vm_name)
if os.path.exists(snap_mem):
os.remove(snap_mem)
if os.path.exists(snap_disk):
os.remove(snap_disk)
if not all([x in snap_xml for x in xml_snap_exp]):
test.fail("Failed to check snapshot xml")
if not all([x in dom_xml for x in xml_dom_exp]):
test.fail("Failed to check domain xml")
def check_blockcopy(target):
"""
Block copy operation test.
"""
blk_file = os.path.join(data_dir.get_tmp_dir(), "blk.rbd")
if os.path.exists(blk_file):
os.remove(blk_file)
blk_mirror = ("mirror type='file' file='%s' "
"format='raw' job='copy'" % blk_file)
# Do blockcopy
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_result(ret, skip_if=unsupported_err)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count(blk_mirror):
test.fail("Can't see block job in domain xml")
# Abort
ret = virsh.blockjob(vm_name, target, "--abort")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if dom_xml.count(blk_mirror):
test.fail("Failed to abort block job")
if os.path.exists(blk_file):
os.remove(blk_file)
# Sleep for a while after abort operation.
time.sleep(5)
# Do blockcopy again
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_exit_status(ret)
# Wait for complete
def wait_func():
ret = virsh.blockjob(vm_name, target, "--info")
return ret.stderr.count("Block Copy: [100 %]")
timeout = params.get("blockjob_timeout", 600)
utils_misc.wait_for(wait_func, int(timeout))
# Pivot
ret = virsh.blockjob(vm_name, target, "--pivot")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count("source file='%s'" % blk_file):
test.fail("Failed to pivot block job")
# Remove the disk file.
if os.path.exists(blk_file):
os.remove(blk_file)
def check_in_vm(vm_obj, target, old_parts, read_only=False):
"""
Check mount/read/write disk in VM.
:param vm. VM guest.
:param target. Disk dev in VM.
:return: True if check successfully.
"""
try:
session = vm_obj.wait_for_login()
new_parts = libvirt.get_parts_list(session)
added_parts = list(set(new_parts).difference(set(old_parts)))
logging.info("Added parts:%s", added_parts)
if len(added_parts) != 1:
logging.error("The number of new partitions is invalid in VM")
return False
added_part = None
if target.startswith("vd"):
if added_parts[0].startswith("vd"):
added_part = added_parts[0]
elif target.startswith("hd"):
if added_parts[0].startswith("sd"):
added_part = added_parts[0]
if not added_part:
logging.error("Can't see added partition in VM")
return False
cmd = ("mount /dev/{0} /mnt && ls /mnt && (sleep 15;"
" touch /mnt/testfile; umount /mnt)"
.format(added_part))
s, o = session.cmd_status_output(cmd, timeout=60)
session.close()
logging.info("Check disk operation in VM:\n, %s, %s", s, o)
# Readonly fs, check the error messages.
# The command may return True, read-only
# messges can be found from the command output
if read_only:
if "Read-only file system" not in o:
return False
else:
return True
# Other errors
if s != 0:
return False
return True
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def clean_up_volume_snapshots():
"""
Get all snapshots for rbd_vol.img volume,unprotect and then clean up them.
"""
cmd = ("rbd -m {0} {1} info {2}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, vol_name)))
if process.run(cmd, ignore_status=True, shell=True).exit_status:
return
# Get snapshot list.
cmd = ("rbd -m {0} {1} snap"
" list {2}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, vol_name)))
snaps_out = process.run(cmd, ignore_status=True, shell=True).stdout_text
snap_names = []
if snaps_out:
for line in snaps_out.rsplit("\n"):
if line.startswith("SNAPID") or line == "":
continue
snap_line = line.rsplit()
if len(snap_line) == 4:
snap_names.append(snap_line[1])
logging.debug("Find snapshots: %s", snap_names)
# Unprotect snapshot first,otherwise it will fail to purge volume
for snap_name in snap_names:
cmd = ("rbd -m {0} {1} snap"
" unprotect {2}@{3}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, vol_name), snap_name))
process.run(cmd, ignore_status=True, shell=True)
# Purge volume,and then delete volume.
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, vol_name)))
process.run(cmd, ignore_status=True, shell=True)
def make_snapshot():
"""
make external snapshots.
:return external snapshot path list
"""
logging.info("Making snapshot...")
first_disk_source = vm.get_first_disk_devices()['source']
snapshot_path_list = []
snapshot2_file = os.path.join(data_dir.get_tmp_dir(), "mem.s2")
snapshot3_file = os.path.join(data_dir.get_tmp_dir(), "mem.s3")
snapshot4_file = os.path.join(data_dir.get_tmp_dir(), "mem.s4")
snapshot4_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s4")
snapshot5_file = os.path.join(data_dir.get_tmp_dir(), "mem.s5")
snapshot5_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s5")
# Attempt to take different types of snapshots.
snapshots_param_dict = {"s1": "s1 --disk-only --no-metadata",
"s2": "s2 --memspec %s --no-metadata" % snapshot2_file,
"s3": "s3 --memspec %s --no-metadata --live" % snapshot3_file,
"s4": "s4 --memspec %s --diskspec vda,file=%s --no-metadata" % (snapshot4_file, snapshot4_disk_file),
"s5": "s5 --memspec %s --diskspec vda,file=%s --live --no-metadata" % (snapshot5_file, snapshot5_disk_file)}
for snapshot_name in sorted(snapshots_param_dict.keys()):
ret = virsh.snapshot_create_as(vm_name, snapshots_param_dict[snapshot_name],
**virsh_dargs)
libvirt.check_exit_status(ret)
if snapshot_name != 's4' and snapshot_name != 's5':
snapshot_path_list.append(first_disk_source.replace('qcow2', snapshot_name))
return snapshot_path_list
def get_secret_list():
"""
Get secret list.
:return secret list
"""
logging.info("Get secret list ...")
secret_list_result = virsh.secret_list()
secret_list = results_stdout_52lts(secret_list_result).strip().splitlines()
# First two lines contain table header followed by entries
# for each secret, such as:
#
# UUID Usage
# --------------------------------------------------------------------------------
# b4e8f6d3-100c-4e71-9f91-069f89742273 ceph client.libvirt secret
secret_list = secret_list[2:]
result = []
# If secret list is empty.
if secret_list:
for line in secret_list:
# Split on whitespace, assume 1 column
linesplit = line.split(None, 1)
result.append(linesplit[0])
return result
mon_host = params.get("mon_host")
disk_src_name = params.get("disk_source_name")
disk_src_config = params.get("disk_source_config")
disk_src_host = params.get("disk_source_host")
disk_src_port = params.get("disk_source_port")
disk_src_pool = params.get("disk_source_pool")
disk_format = params.get("disk_format", "raw")
driver_iothread = params.get("driver_iothread")
snap_name = params.get("disk_snap_name")
attach_device = "yes" == params.get("attach_device", "no")
attach_disk = "yes" == params.get("attach_disk", "no")
test_save_restore = "yes" == params.get("test_save_restore", "no")
test_snapshot = "yes" == params.get("test_snapshot", "no")
test_blockcopy = "yes" == params.get("test_blockcopy", "no")
test_qemu_cmd = "yes" == params.get("test_qemu_cmd", "no")
test_vm_parts = "yes" == params.get("test_vm_parts", "no")
additional_guest = "yes" == params.get("additional_guest", "no")
create_snapshot = "yes" == params.get("create_snapshot", "no")
convert_image = "yes" == params.get("convert_image", "no")
create_volume = "yes" == params.get("create_volume", "no")
create_by_xml = "yes" == params.get("create_by_xml", "no")
client_key = params.get("client_key")
client_name = params.get("client_name")
auth_key = params.get("auth_key")
auth_user = params.get("auth_user")
auth_type = params.get("auth_type")
auth_usage = params.get("secret_usage")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
vol_name = params.get("vol_name")
cloned_vol_name = params.get("cloned_volume", "cloned_test_volume")
create_from_cloned_volume = params.get("create_from_cloned_volume", "create_from_cloned_test_volume")
vol_cap = params.get("vol_cap")
vol_cap_unit = params.get("vol_cap_unit")
start_vm = "yes" == params.get("start_vm", "no")
test_disk_readonly = "yes" == params.get("test_disk_readonly", "no")
test_disk_internal_snapshot = "yes" == params.get("test_disk_internal_snapshot", "no")
test_json_pseudo_protocol = "yes" == params.get("json_pseudo_protocol", "no")
disk_snapshot_with_sanlock = "yes" == params.get("disk_internal_with_sanlock", "no")
# Create /etc/ceph/ceph.conf file to suppress false warning error message.
process.run("mkdir -p /etc/ceph", ignore_status=True, shell=True)
cmd = ("echo 'mon_host = {0}' >/etc/ceph/ceph.conf"
.format(mon_host))
process.run(cmd, ignore_status=True, shell=True)
# 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)
if additional_guest:
guest_name = "%s_%s" % (vm_name, '1')
timeout = params.get("clone_timeout", 360)
utils_libguestfs.virt_clone_cmd(vm_name, guest_name,
True, timeout=timeout,
ignore_status=False)
additional_vm = vm.clone(guest_name)
if start_vm:
virsh.start(guest_name)
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
key_opt = ""
secret_uuid = None
snapshot_path = None
key_file = os.path.join(data_dir.get_tmp_dir(), "ceph.key")
img_file = os.path.join(data_dir.get_tmp_dir(),
"%s_test.img" % vm_name)
front_end_img_file = os.path.join(data_dir.get_tmp_dir(),
"%s_frontend_test.img" % vm_name)
# Construct a unsupported error message list to skip these kind of tests
unsupported_err = []
if driver_iothread:
unsupported_err.append('IOThreads not supported')
if test_snapshot:
unsupported_err.append('live disk snapshot not supported')
if test_disk_readonly:
if not libvirt_version.version_compare(5, 0, 0):
unsupported_err.append('Could not create file: Permission denied')
unsupported_err.append('Permission denied')
else:
unsupported_err.append('unsupported configuration: external snapshot ' +
'for readonly disk vdb is not supported')
if test_disk_internal_snapshot:
unsupported_err.append('unsupported configuration: internal snapshot for disk ' +
'vdb unsupported for storage type raw')
if test_blockcopy:
unsupported_err.append('block copy is not supported')
if attach_disk:
unsupported_err.append('No such file or directory')
if create_volume:
unsupported_err.append("backing 'volume' disks isn't yet supported")
unsupported_err.append('this function is not supported')
try:
# Clean up dirty secrets in test environments if there have.
dirty_secret_list = get_secret_list()
if dirty_secret_list:
for dirty_secret_uuid in dirty_secret_list:
virsh.secret_undefine(dirty_secret_uuid)
# Prepare test environment.
qemu_config = LibvirtQemuConfig()
if disk_snapshot_with_sanlock:
# Install necessary package:sanlock,libvirt-lock-sanlock
if not utils_package.package_install(["sanlock"]):
test.error("fail to install sanlock")
if not utils_package.package_install(["libvirt-lock-sanlock"]):
test.error("fail to install libvirt-lock-sanlock")
# Set virt_use_sanlock
result = process.run("setsebool -P virt_use_sanlock 1", shell=True)
if result.exit_status:
test.error("Failed to set virt_use_sanlock value")
# Update lock_manager in qemu.conf
qemu_config.lock_manager = 'sanlock'
# Update qemu-sanlock.conf.
san_lock_config = LibvirtSanLockConfig()
san_lock_config.user = '******'
san_lock_config.group = 'sanlock'
san_lock_config.host_id = 1
san_lock_config.auto_disk_leases = True
process.run("mkdir -p /var/lib/libvirt/sanlock", shell=True)
san_lock_config.disk_lease_dir = "/var/lib/libvirt/sanlock"
san_lock_config.require_lease_for_disks = False
# Start sanlock service and restart libvirtd to enforce changes.
result = process.run("systemctl start wdmd", shell=True)
if result.exit_status:
test.error("Failed to start wdmd service")
result = process.run("systemctl start sanlock", shell=True)
if result.exit_status:
test.error("Failed to start sanlock service")
utils_libvirtd.Libvirtd().restart()
# Prepare lockspace and lease file for sanlock in order.
sanlock_cmd_dict = OrderedDict()
sanlock_cmd_dict["truncate -s 1M /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to truncate TEST_LS"
sanlock_cmd_dict["sanlock direct init -s TEST_LS:0:/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to sanlock direct init TEST_LS:0"
sanlock_cmd_dict["chown sanlock:sanlock /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to chown sanlock TEST_LS"
sanlock_cmd_dict["restorecon -R -v /var/lib/libvirt/sanlock"] = "Failed to restorecon sanlock"
sanlock_cmd_dict["truncate -s 1M /var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to truncate test-disk-resource-lock"
sanlock_cmd_dict["sanlock direct init -r TEST_LS:test-disk-resource-lock:" +
"/var/lib/libvirt/sanlock/test-disk-resource-lock:0"] = "Failed to sanlock direct init test-disk-resource-lock"
sanlock_cmd_dict["chown sanlock:sanlock " +
"/var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to chown test-disk-resource-loc"
sanlock_cmd_dict["sanlock client add_lockspace -s TEST_LS:1:" +
"/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to client add_lockspace -s TEST_LS:0"
for sanlock_cmd in sanlock_cmd_dict.keys():
result = process.run(sanlock_cmd, shell=True)
if result.exit_status:
test.error(sanlock_cmd_dict[sanlock_cmd])
# Create one lease device and add it to VM.
san_lock_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
lease_device = Lease()
lease_device.lockspace = 'TEST_LS'
lease_device.key = 'test-disk-resource-lock'
lease_device.target = {'path': '/var/lib/libvirt/sanlock/test-disk-resource-lock'}
san_lock_vmxml.add_device(lease_device)
san_lock_vmxml.sync()
# Install ceph-common package which include rbd command
if utils_package.package_install(["ceph-common"]):
if client_name and client_key:
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" %
(client_name, client_key))
key_opt = "--keyring %s" % key_file
# Create secret xml
sec_xml = secret_xml.SecretXML("no", "no")
sec_xml.usage = auth_type
sec_xml.usage_name = auth_usage
sec_xml.xmltreefile.write()
logging.debug("Secret xml: %s", sec_xml)
ret = virsh.secret_define(sec_xml.xml)
libvirt.check_exit_status(ret)
secret_uuid = re.findall(r".+\S+(\ +\S+)\ +.+\S+",
ret.stdout.strip())[0].lstrip()
logging.debug("Secret uuid %s", secret_uuid)
if secret_uuid is None:
test.error("Failed to get secret uuid")
# Set secret value
auth_key = params.get("auth_key")
ret = virsh.secret_set_value(secret_uuid, auth_key,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Delete the disk if it exists
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm "
"{2}".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
else:
test.error("Failed to install ceph-common")
if disk_src_config:
config_ceph()
disk_path = ("rbd:%s:mon_host=%s" %
(disk_src_name, mon_host))
if auth_user and auth_key:
disk_path += (":id=%s:key=%s" %
(auth_user, auth_key))
targetdev = params.get("disk_target", "vdb")
# To be compatible with create_disk_xml function,
# some parameters need to be updated.
params.update({
"type_name": params.get("disk_type", "network"),
"target_bus": params.get("disk_target_bus"),
"target_dev": targetdev,
"secret_uuid": secret_uuid,
"source_protocol": params.get("disk_source_protocol"),
"source_name": disk_src_name,
"source_host_name": disk_src_host,
"source_host_port": disk_src_port})
# Prepare disk image
if convert_image:
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
# Convert the image to remote storage
disk_cmd = ("rbd -m %s %s info %s 2> /dev/null|| qemu-img convert"
" -O %s %s %s" % (mon_host, key_opt,
disk_src_name, disk_format,
blk_source, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
elif create_volume:
vol_params = {"name": vol_name, "capacity": int(vol_cap),
"capacity_unit": vol_cap_unit, "format": disk_format}
create_pool()
create_vol(vol_params)
check_vol(vol_params)
else:
# Create an local image and make FS on it.
disk_cmd = ("qemu-img create -f %s %s 10M && mkfs.ext4 -F %s" %
(disk_format, img_file, img_file))
process.run(disk_cmd, ignore_status=False, shell=True)
# Convert the image to remote storage
disk_cmd = ("rbd -m %s %s info %s 2> /dev/null|| qemu-img convert -O"
" %s %s %s" % (mon_host, key_opt, disk_src_name,
disk_format, img_file, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
# Create disk snapshot if needed.
if create_snapshot:
snap_cmd = ("rbd -m %s %s snap create %s@%s" %
(mon_host, key_opt, disk_src_name, snap_name))
process.run(snap_cmd, ignore_status=False, shell=True)
if test_json_pseudo_protocol:
# Create one frontend image with the rbd backing file.
json_str = ('json:{"file.driver":"rbd",'
'"file.filename":"rbd:%s:mon_host=%s"}'
% (disk_src_name, mon_host))
# pass different json string according to the auth config
if auth_user and auth_key:
json_str = ('%s:id=%s:key=%s"}' % (json_str[:-2], auth_user, auth_key))
disk_cmd = ("qemu-img create -f qcow2 -b '%s' %s" %
(json_str, front_end_img_file))
disk_path = front_end_img_file
process.run(disk_cmd, ignore_status=False, shell=True)
# If hot plug, start VM first, and then wait the OS boot.
# Otherwise stop VM if running.
if start_vm:
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
else:
if not vm.is_dead():
vm.destroy()
if attach_device:
if create_volume:
params.update({"source_pool": pool_name})
params.update({"type_name": "volume"})
# No need auth options for volume
if "auth_user" in params:
params.pop("auth_user")
if "auth_type" in params:
params.pop("auth_type")
if "secret_type" in params:
params.pop("secret_type")
if "secret_uuid" in params:
params.pop("secret_uuid")
if "secret_usage" in params:
params.pop("secret_usage")
xml_file = libvirt.create_disk_xml(params)
if additional_guest:
# Copy xml_file for additional guest VM.
shutil.copyfile(xml_file, additional_xml_file)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name, xml_file,
flagstr=opts, debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
if additional_guest:
# Make sure the additional VM is running
if additional_vm.is_dead():
additional_vm.start()
additional_vm.wait_for_login().close()
ret = virsh.attach_device(guest_name, additional_xml_file,
"", debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif attach_disk:
opts = params.get("attach_option", "")
ret = virsh.attach_disk(vm_name, disk_path,
targetdev, opts)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_readonly:
params.update({'readonly': "yes"})
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name, xml_file,
flagstr=opts, debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_internal_snapshot:
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name, xml_file,
flagstr=opts, debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif disk_snapshot_with_sanlock:
if vm.is_dead():
vm.start()
snapshot_path = make_snapshot()
if vm.is_alive():
vm.destroy()
elif not create_volume:
libvirt.set_vm_disk(vm, params)
if test_blockcopy:
logging.info("Creating %s...", vm_name)
vmxml_for_test = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
vm.undefine()
if virsh.create(vmxml_for_test.xml, **virsh_dargs).exit_status:
vmxml_backup.define()
test.fail("Can't create the domain")
elif vm.is_dead():
vm.start()
# Wait for vm is running
vm.wait_for_login(timeout=600).close()
if additional_guest:
if additional_vm.is_dead():
additional_vm.start()
# Check qemu command line
if test_qemu_cmd:
check_qemu_cmd()
# Check partitions in vm
if test_vm_parts:
if not check_in_vm(vm, targetdev, old_parts,
read_only=create_snapshot):
test.fail("Failed to check vm partitions")
if additional_guest:
if not check_in_vm(additional_vm, targetdev, old_parts):
test.fail("Failed to check vm partitions")
# Save and restore operation
if test_save_restore:
check_save_restore()
if test_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option)
if test_blockcopy:
check_blockcopy(targetdev)
if test_disk_readonly:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, 'vdb')
if test_disk_internal_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, targetdev)
# Detach the device.
if attach_device:
xml_file = libvirt.create_disk_xml(params)
ret = virsh.detach_device(vm_name, xml_file)
libvirt.check_exit_status(ret)
if additional_guest:
ret = virsh.detach_device(guest_name, xml_file)
libvirt.check_exit_status(ret)
elif attach_disk:
ret = virsh.detach_disk(vm_name, targetdev)
libvirt.check_exit_status(ret)
# Check disk in vm after detachment.
if attach_device or attach_disk:
session = vm.wait_for_login()
new_parts = libvirt.get_parts_list(session)
if len(new_parts) != len(old_parts):
test.fail("Disk still exists in vm"
" after detachment")
session.close()
except virt_vm.VMStartError as details:
for msg in unsupported_err:
if msg in str(details):
test.cancel(str(details))
else:
test.fail("VM failed to start."
"Error: %s" % str(details))
finally:
# Remove /etc/ceph/ceph.conf file if exists.
if os.path.exists('/etc/ceph/ceph.conf'):
os.remove('/etc/ceph/ceph.conf')
# Delete snapshots.
snapshot_lists = virsh.snapshot_list(vm_name)
if len(snapshot_lists) > 0:
libvirt.clean_up_snapshots(vm_name, snapshot_lists)
for snap in snapshot_lists:
virsh.snapshot_delete(vm_name, snap, "--metadata")
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
if additional_guest:
virsh.remove_domain(guest_name,
"--remove-all-storage",
ignore_stauts=True)
# Remove the snapshot.
if create_snapshot:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
elif create_volume:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, cloned_vol_name)))
process.run(cmd, ignore_status=True, shell=True)
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, os.path.join(disk_src_pool, create_from_cloned_volume)))
process.run(cmd, ignore_status=True, shell=True)
clean_up_volume_snapshots()
else:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
# Delete tmp files.
if os.path.exists(key_file):
os.remove(key_file)
if os.path.exists(img_file):
os.remove(img_file)
# Clean up volume, pool
if vol_name and vol_name in str(virsh.vol_list(pool_name).stdout):
virsh.vol_delete(vol_name, pool_name)
if pool_name and pool_name in virsh.pool_state_dict():
virsh.pool_destroy(pool_name, **virsh_dargs)
virsh.pool_undefine(pool_name, **virsh_dargs)
# Clean up secret
secret_list = get_secret_list()
if secret_list:
for secret_uuid in secret_list:
virsh.secret_undefine(secret_uuid)
logging.info("Restoring vm...")
vmxml_backup.sync()
if disk_snapshot_with_sanlock:
# Restore virt_use_sanlock setting.
process.run("setsebool -P virt_use_sanlock 0", shell=True)
# Restore qemu config
qemu_config.restore()
utils_libvirtd.Libvirtd().restart()
# Force shutdown sanlock service.
process.run("sanlock client shutdown -f 1", shell=True)
# Clean up lockspace folder
process.run("rm -rf /var/lib/libvirt/sanlock/*", shell=True)
if snapshot_path is not None:
for snapshot in snapshot_path:
if os.path.exists(snapshot):
os.remove(snapshot)
def run(test, params, env):
"""
Test DAC setting in both domain xml and qemu.conf.
(1) Init variables for test.
(2) Set VM xml and qemu.conf with proper DAC label, also set
monitor socket parent dir with propoer ownership and mode.
(3) Start VM and check the context.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("host_selinux", "enforcing")
# Get variables about seclabel for VM.
sec_type = params.get("vm_sec_type", "dynamic")
vm_sec_model = params.get("vm_sec_model", "dac")
vm_sec_label = params.get("vm_sec_label", None)
vm_sec_relabel = params.get("vm_sec_relabel", "yes")
sec_dict = {'type': sec_type, 'model': vm_sec_model,
'relabel': vm_sec_relabel}
if vm_sec_label:
sec_dict['label'] = vm_sec_label
set_qemu_conf = "yes" == params.get("set_qemu_conf", "no")
# Get per-img seclabel variables
disk_type = params.get("disk_type")
disk_target = params.get('disk_target')
disk_src_protocol = params.get("disk_source_protocol")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
invalid_label = 'yes' == params.get("invalid_label", "no")
relabel = params.get("per_img_sec_relabel")
sec_label = params.get("per_img_sec_label")
per_sec_model = params.get("per_sec_model", 'dac')
per_img_dict = {'sec_model': per_sec_model, 'relabel': relabel,
'sec_label': sec_label}
params.update(per_img_dict)
# Get qemu.conf config variables
qemu_user = params.get("qemu_user", 'qemu')
qemu_group = params.get("qemu_group", 'qemu')
dynamic_ownership = "yes" == params.get("dynamic_ownership", "yes")
# Get variables about VM and get a VM object and VMXML instance.
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Set selinux of host.
backup_sestatus = utils_selinux.get_status()
if backup_sestatus == "disabled":
test.cancel("SELinux is in Disabled "
"mode. it must be in Enforcing "
"mode to run this test")
utils_selinux.set_status(host_sestatus)
qemu_sock_mod = False
qemu_sock_path = '/var/lib/libvirt/qemu/'
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
try:
if set_qemu_conf:
# Set qemu.conf for user and group
if qemu_user:
qemu_conf.user = qemu_user
if qemu_group:
qemu_conf.group = qemu_group
if dynamic_ownership:
qemu_conf.dynamic_ownership = 1
else:
qemu_conf.dynamic_ownership = 0
logging.debug("the qemu.conf content is: %s" % qemu_conf)
libvirtd.restart()
st = os.stat(qemu_sock_path)
if not bool(st.st_mode & stat.S_IWGRP):
# chmod g+w
os.chmod(qemu_sock_path, st.st_mode | stat.S_IWGRP)
qemu_sock_mod = True
# Set the context of the VM.
logging.debug("sec_dict is %s" % sec_dict)
vmxml.set_seclabel([sec_dict])
vmxml.sync()
# Get per-image seclabel in id string
if sec_label:
per_img_usr, per_img_grp = sec_label.split(':')
sec_label_id = format_user_group_str(per_img_usr, per_img_grp)
# Start VM to check the qemu process and image.
try:
# Set per-img sec context and start vm
utlv.set_vm_disk(vm, params)
# Start VM successfully.
if status_error:
if invalid_label:
# invalid label should fail, more info in bug 1165485
logging.debug("The guest failed to start as expected,"
"details see bug: bugzilla.redhat.com/show_bug.cgi"
"?id=1165485")
else:
test.fail("Test succeeded in negative case.")
# Get vm process label when VM is running.
vm_pid = vm.get_pid()
pid_stat = os.stat("/proc/%d" % vm_pid)
vm_process_uid = pid_stat.st_uid
vm_process_gid = pid_stat.st_gid
vm_context = "%s:%s" % (vm_process_uid, vm_process_gid)
logging.debug("vm process label is: %s", vm_context)
# Get vm image label when VM is running
if disk_type != "network":
disks = vm.get_blk_devices()
if libvirt_version.version_compare(3, 1, 0) and disk_type == "block":
output = to_text(process.system_output(
"nsenter -t %d -m -- ls -l %s" % (vm_pid, disks[disk_target]['source'])))
owner, group = output.strip().split()[2:4]
disk_context = format_user_group_str(owner, group)
else:
stat_re = os.stat(disks[disk_target]['source'])
disk_context = "%s:%s" % (stat_re.st_uid, stat_re.st_gid)
logging.debug("The disk dac label after vm start is: %s",
disk_context)
if sec_label and relabel == 'yes':
if disk_context != sec_label_id:
test.fail("The disk label is not equal to "
"'%s'." % sec_label_id)
except virt_vm.VMStartError as e:
# Starting VM failed.
if not status_error:
test.fail("Test failed in positive case."
"error: %s" % e)
finally:
# clean up
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml.sync()
if qemu_sock_mod:
st = os.stat(qemu_sock_path)
os.chmod(qemu_sock_path, st.st_mode ^ stat.S_IWGRP)
if set_qemu_conf:
qemu_conf.restore()
libvirtd.restart()
utils_selinux.set_status(backup_sestatus)
if disk_src_protocol == 'iscsi':
utlv.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src_protocol == 'gluster':
utlv.setup_or_cleanup_gluster(False, brick_path=brick_path, **params)
libvirtd.restart()
elif disk_src_protocol == 'netfs':
utlv.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=backup_sestatus)
def run(test, params, env):
"""
Test snapshot-create-as command
Make sure that the clean repo can be used because qemu-guest-agent need to
be installed in guest
The command create a snapshot (disk and RAM) from arguments which including
the following point
* virsh snapshot-create-as --print-xml --diskspec --name --description
* virsh snapshot-create-as --print-xml with multi --diskspec
* virsh snapshot-create-as --print-xml --memspec
* virsh snapshot-create-as --description
* virsh snapshot-create-as --no-metadata
* virsh snapshot-create-as --no-metadata --print-xml (negative test)
* virsh snapshot-create-as --atomic --disk-only
* virsh snapshot-create-as --quiesce --disk-only (positive and negative)
* virsh snapshot-create-as --reuse-external
* virsh snapshot-create-as --disk-only --diskspec
* virsh snapshot-create-as --memspec --reuse-external --atomic(negative)
* virsh snapshot-create-as --disk-only and --memspec (negative)
* Create multi snapshots with snapshot-create-as
* Create snapshot with name a--a a--a--snap1
"""
if not virsh.has_help_command('snapshot-create-as'):
raise error.TestNAError("This version of libvirt does not support "
"the snapshot-create-as test")
vm_name = params.get("main_vm")
status_error = params.get("status_error", "no")
options = params.get("snap_createas_opts")
multi_num = params.get("multi_num", "1")
diskspec_num = params.get("diskspec_num", "1")
bad_disk = params.get("bad_disk")
reuse_external = "yes" == params.get("reuse_external", "no")
start_ga = params.get("start_ga", "yes")
domain_state = params.get("domain_state")
memspec_opts = params.get("memspec_opts")
config_format = "yes" == params.get("config_format", "no")
snapshot_image_format = params.get("snapshot_image_format")
diskspec_opts = params.get("diskspec_opts")
create_autodestroy = 'yes' == params.get("create_autodestroy", "no")
unix_channel = "yes" == params.get("unix_channel", "yes")
dac_denial = "yes" == params.get("dac_denial", "no")
check_json_no_savevm = "yes" == params.get("check_json_no_savevm", "no")
disk_snapshot_attr = params.get('disk_snapshot_attr', 'external')
set_snapshot_attr = "yes" == params.get("set_snapshot_attr", "no")
# gluster related params
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", "no")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
uri = params.get("virsh_uri")
usr = params.get('unprivileged_user')
if usr:
if usr.count('EXAMPLE'):
usr = '******'
if disk_src_protocol == 'iscsi':
if not libvirt_version.version_compare(1, 0, 4):
raise error.TestNAError("'iscsi' disk doesn't support in"
" current libvirt version.")
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
if not libvirt_version.version_compare(1, 2, 7):
# As bug 1017289 closed as WONTFIX, the support only
# exist on 1.2.7 and higher
if disk_src_protocol == 'gluster':
raise error.TestNAError("Snapshot on glusterfs not support in "
"current version. Check more info with "
"https://bugzilla.redhat.com/buglist.cgi?"
"bug_id=1017289,1032370")
opt_names = locals()
if memspec_opts is not None:
mem_options = compose_disk_options(test, params, memspec_opts)
# if the parameters have the disk without "file=" then we only need to
# add testdir for it.
if mem_options is None:
mem_options = os.path.join(test.tmpdir, memspec_opts)
options += " --memspec " + mem_options
tag_diskspec = 0
dnum = int(diskspec_num)
if diskspec_opts is not None:
tag_diskspec = 1
opt_names['diskopts_1'] = diskspec_opts
# diskspec_opts[n] is used in cfg when more than 1 --diskspec is used
if dnum > 1:
tag_diskspec = 1
for i in range(1, dnum + 1):
opt_names["diskopts_%s" % i] = params.get("diskspec_opts%s" % i)
if tag_diskspec == 1:
for i in range(1, dnum + 1):
disk_options = compose_disk_options(test, params,
opt_names["diskopts_%s" % i])
options += " --diskspec " + disk_options
logging.debug("options are %s", options)
vm = env.get_vm(vm_name)
option_dict = {}
option_dict = utils_misc.valued_option_dict(options, r' --(?!-)')
logging.debug("option_dict is %s", option_dict)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("original xml is %s", vmxml_backup)
# Generate empty image for negative test
if bad_disk is not None:
bad_disk = os.path.join(test.tmpdir, bad_disk)
os.open(bad_disk, os.O_RDWR | os.O_CREAT)
# Generate external disk
if reuse_external:
disk_path = ''
for i in range(dnum):
external_disk = "external_disk%s" % i
if params.get(external_disk):
disk_path = os.path.join(test.tmpdir,
params.get(external_disk))
utils.run("qemu-img create -f qcow2 %s 1G" % disk_path)
# Only chmod of the last external disk for negative case
if dac_denial:
utils.run("chmod 500 %s" % disk_path)
qemu_conf = None
libvirtd_conf = None
libvirtd_log_path = None
libvirtd = utils_libvirtd.Libvirtd()
try:
# Config "snapshot_image_format" option in qemu.conf
if config_format:
qemu_conf = utils_config.LibvirtQemuConfig()
qemu_conf.snapshot_image_format = snapshot_image_format
logging.debug("the qemu config file content is:\n %s" % qemu_conf)
libvirtd.restart()
if check_json_no_savevm:
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_level"] = '1'
libvirtd_conf["log_filters"] = '"1:json 3:remote 4:event"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd.restart()
if replace_vm_disk:
libvirt.set_vm_disk(vm, params, tmp_dir)
if set_snapshot_attr:
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_new = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_xml = vmxml_backup.get_devices(device_type="disk")[0]
vmxml_new.del_device(disk_xml)
# set snapshot attribute in disk xml
disk_xml.snapshot = disk_snapshot_attr
new_disk = disk.Disk(type_name='file')
new_disk.xmltreefile = disk_xml.xmltreefile
vmxml_new.add_device(new_disk)
logging.debug("The vm xml now is: %s" % vmxml_new.xmltreefile)
vmxml_new.sync()
vm.start()
# Start qemu-ga on guest if have --quiesce
if unix_channel and options.find("quiesce") >= 0:
vm.prepare_guest_agent()
session = vm.wait_for_login()
if start_ga == "no":
# The qemu-ga could be running and should be killed
session.cmd("kill -9 `pidof qemu-ga`")
# Check if the qemu-ga get killed
stat_ps = session.cmd_status("ps aux |grep [q]emu-ga")
if not stat_ps:
# As managed by systemd and set as autostart, qemu-ga
# could be restarted, so use systemctl to stop it.
session.cmd("systemctl stop qemu-guest-agent")
stat_ps = session.cmd_status("ps aux |grep [q]emu-ga")
if not stat_ps:
raise error.TestNAError("Fail to stop agent in "
"guest")
if domain_state == "paused":
virsh.suspend(vm_name)
else:
# Remove channel if exist
if vm.is_alive():
vm.destroy(gracefully=False)
xml_inst = vm_xml.VMXML.new_from_dumpxml(vm_name)
xml_inst.remove_agent_channels()
vm.start()
# Record the previous snapshot-list
snaps_before = virsh.snapshot_list(vm_name)
# Attach disk before create snapshot if not print xml and multi disks
# specified in cfg
if dnum > 1 and "--print-xml" not in options:
for i in range(1, dnum):
disk_path = os.path.join(test.tmpdir, 'disk%s.qcow2' % i)
utils.run("qemu-img create -f qcow2 %s 200M" % disk_path)
virsh.attach_disk(vm_name, disk_path,
'vd%s' % list(string.lowercase)[i],
debug=True)
# Run virsh command
# May create several snapshots, according to configuration
for count in range(int(multi_num)):
if create_autodestroy:
# Run virsh command in interactive mode
vmxml_backup.undefine()
vp = virsh.VirshPersistent()
vp.create(vmxml_backup['xml'], '--autodestroy')
cmd_result = vp.snapshot_create_as(vm_name, options,
ignore_status=True,
debug=True)
vp.close_session()
vmxml_backup.define()
else:
cmd_result = virsh.snapshot_create_as(vm_name, options,
unprivileged_user=usr,
uri=uri,
ignore_status=True,
debug=True)
# for multi snapshots without specific snapshot name, the
# snapshot name is using time string with 1 second
# incremental, to avoid get snapshot failure with same name,
# sleep 1 second here.
if int(multi_num) > 1:
time.sleep(1.1)
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
else:
# Check memspec file should be removed if failed
if (options.find("memspec") >= 0 and
options.find("atomic") >= 0):
if os.path.isfile(option_dict['memspec']):
os.remove(option_dict['memspec'])
raise error.TestFail("Run failed but file %s exist"
% option_dict['memspec'])
else:
logging.info("Run failed as expected and memspec"
" file already been removed")
# Check domain xml is not updated if reuse external fail
elif reuse_external and dac_denial:
output = virsh.dumpxml(vm_name).stdout.strip()
if "reuse_external" in output:
raise error.TestFail("Domain xml should not be "
"updated with snapshot image")
else:
logging.info("Run failed as expected")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command: %s"
% output)
else:
# Check the special options
snaps_list = virsh.snapshot_list(vm_name)
logging.debug("snaps_list is %s", snaps_list)
check_snapslist(vm_name, options, option_dict, output,
snaps_before, snaps_list)
# For cover bug 872292
if check_json_no_savevm:
pattern = "The command savevm has not been found"
with open(libvirtd_log_path) as f:
for line in f:
if pattern in line and "error" in line:
raise error.TestFail("'%s' was found: %s"
% (pattern, line))
finally:
if vm.is_alive():
vm.destroy()
# recover domain xml
xml_recover(vmxml_backup)
path = "/var/lib/libvirt/qemu/snapshot/" + vm_name
if os.path.isfile(path):
raise error.TestFail("Still can find snapshot metadata")
if disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd.restart()
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(False, restart_tgtd=restart_tgtd)
# rm bad disks
if bad_disk is not None:
os.remove(bad_disk)
# rm attach disks and reuse external disks
if dnum > 1 and "--print-xml" not in options:
for i in range(dnum):
disk_path = os.path.join(test.tmpdir, 'disk%s.qcow2' % i)
if os.path.exists(disk_path):
os.unlink(disk_path)
if reuse_external:
external_disk = "external_disk%s" % i
disk_path = os.path.join(test.tmpdir,
params.get(external_disk))
if os.path.exists(disk_path):
os.unlink(disk_path)
# restore config
if config_format and qemu_conf:
qemu_conf.restore()
if libvirtd_conf:
libvirtd_conf.restore()
if libvirtd_conf or (config_format and qemu_conf):
libvirtd.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
check_finish_job = "yes" == params.get("check_finish_job", "yes")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
relative_path = params.get("relative_path")
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
snapshots_take = int(params.get("snapshots_take", '0'))
external_disk_only_snapshot = "yes" == params.get(
"external_disk_only_snapshot", "no")
enable_iscsi_auth = "yes" == params.get("enable_iscsi_auth", "no")
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
if bandwidth_byte and not libvirt_version.version_compare(1, 3, 3):
raise exceptions.TestSkipError("--bytes option not supported in "
"current version")
if relative_path == "yes" and not libvirt_version.version_compare(3, 0, 0):
test.cancel(
"Forbid using relative path or file name only is added since libvirt-3.0.0"
)
if "--transient-job" in options and not libvirt_version.version_compare(
4, 5, 0):
test.cancel(
"--transient-job option is supported until libvirt 4.5.0 version")
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" %
(target, vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
options += " --bytes"
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True,
'ignore_status': True,
'timeout': timeout
}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_log_path = os.path.join(data_dir.get_tmp_dir(),
"libvirt_daemons.log")
libvirtd_conf_dict = {
"log_filter": '"3:json 1:libvirt 1:qemu"',
"log_outputs": '"1:file:%s"' % libvirtd_log_path
}
logging.debug("the libvirtd conf file content is :\n %s" %
libvirtd_conf_dict)
libvirtd_conf = utl.customize_libvirt_config(libvirtd_conf_dict)
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" %
(dest_path, expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
This is a specific bug verify, so ignore status_error here.
"""
failure_msg = ""
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
failure_msg += "Virsh cmd error happened: %s\n" % err_msg
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
failure_msg += "Libvirtd log error happened: %s\n" % err_pattern
if failure_msg:
if not libvirt_version.version_compare(1, 3, 2):
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
failure_msg += "Hit on bug: %s " % bug_url_
test.fail(failure_msg)
def _make_snapshot(snapshot_numbers_take):
"""
Make external disk snapshot
:param snapshot_numbers_take: snapshot numbers.
"""
for count in range(0, snapshot_numbers_take):
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name + "_%s" % count
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
# Remove non-storage disk such as 'cdrom'
for disk in disks:
if disk.device != 'disk':
disks.remove(disk)
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
new_file = os.path.join(tmp_dir,
"blockcopy_shallow_%s.snap" % count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('dev' in disk_xml.source.attrs
or 'name' in disk_xml.source.attrs
or 'pool' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block'
or disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
elif 'pool' in new_attrs:
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(
is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
nfs_cleanup = False
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if enable_iscsi_auth:
utils_secret.clean_up_secrets()
setup_auth_enabled_iscsi_disk(vm, params)
dest_path = os.path.join(tmp_dir, tmp_file)
elif with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
# Make sure the new disk show up
utils_misc.wait_for(lambda: os.path.exists(dest_path), 5)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
if disk_source_protocol == 'iscsi':
emulated_iscsi.append(emu_image)
if disk_source_protocol == 'netfs':
nfs_cleanup = True
utl.set_vm_disk(vm, params, tmp_dir, test)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow or external_disk_only_snapshot or enable_iscsi_auth:
_make_snapshot(snapshots_take)
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command to create destination file
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail: %s" %
cmd_result.stdout.strip() +
cmd_result.stderr)
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
if "--transient-job" in options:
pool = ThreadPool(processes=1)
async_result = pool.apply_async(
blockcopy_thread, (vm_name, target, dest_path, options))
kill_blockcopy_process()
utl.check_blockjob(vm_name, target)
return
# Run the real testing command
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options,
**extra_dict)
# check BZ#1197592
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
if options.count('--bytes'):
bandwidth += 'B'
else:
bandwidth += 'M'
if not (bandwidth
in ['0B', '0M']) and not utl.check_blockjob(
vm_name, target, "bandwidth", bandwidth):
raise exceptions.TestFail("Check bandwidth failed")
val = options.count("--pivot") + options.count("--finish")
# Don't wait for job finish when using --byte option
val += options.count('--bytes')
if val == 0 and check_finish_job:
try:
finish_job(vm_name, target, timeout)
except JobTimeout as excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name,
snap_opt,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name,
save_path,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
else:
raise exceptions.TestFail(cmd_result.stdout.strip() +
cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
# Commit id '4c297728' changed how virsh exits when
# unexpectedly failing due to timeout from a fail (1)
# to a success(0), so we need to look for a different
# marker to indicate the copy aborted. As "stdout: Now
# in mirroring phase" could be in stdout which fail the
# check, so also do check in libvirtd log to confirm.
if options.count("--timeout") and options.count("--wait"):
log_pattern = "Copy aborted"
if (re.search(log_pattern, cmd_result.stdout.strip())
or chk_libvirtd_log(libvirtd_log_path, log_pattern,
"debug")):
logging.debug("Found success a timed out block copy")
else:
raise exceptions.TestFail("Expect fail, but run "
"successfully: %s" % bug_url)
finally:
# Recover VM may fail unexpectedly, we need using try/except to
# proceed the following cleanup steps
try:
# Abort exist blockjob to avoid any possible lock error
virsh.blockjob(vm_name, target, '--abort', ignore_status=True)
vm.destroy(gracefully=False)
# It may take a long time to shutdown the VM which has
# blockjob running
utils_misc.wait_for(
lambda: virsh.domstate(vm_name, ignore_status=True).
exit_status, 180)
if virsh.domain_exists(vm_name):
if active_snap or with_shallow:
option = "--snapshots-metadata"
else:
option = None
original_xml.sync(option)
else:
original_xml.define()
except Exception as e:
logging.error(e)
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Clean up libvirt pool, which may be created by 'set_vm_disk'
if disk_type == 'volume':
virsh.pool_destroy(pool_name, ignore_status=True, debug=True)
# Restore libvirtd conf and restart libvirtd
libvirtd_conf.restore()
libvirtd_utl.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
# Clean up NFS
try:
if nfs_cleanup:
utl.setup_or_cleanup_nfs(is_setup=False)
except Exception as e:
logging.error(e)
# Clean up iSCSI
try:
for iscsi_n in list(set(emulated_iscsi)):
utl.setup_or_cleanup_iscsi(is_setup=False,
emulated_image=iscsi_n)
# iscsid will be restarted, so give it a break before next loop
time.sleep(5)
except Exception as e:
logging.error(e)
if os.path.exists(dest_path):
os.remove(dest_path)
if os.path.exists(snap_path):
os.remove(snap_path)
if os.path.exists(save_path):
os.remove(save_path)
# Restart virtlogd service to release VM log file lock
try:
path.find_command('virtlogd')
process.run('systemctl reset-failed virtlogd')
process.run('systemctl restart virtlogd ')
except path.CmdNotFoundError:
pass
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of disk
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def reboot():
"""
Shutdown and restart guest, then wait for login
"""
vm.destroy()
vm.start()
vm.wait_for_login()
def attach(xml, device_name, plug_method="hot"):
"""
Attach device with xml, for both hot and cold plug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for plug method
"""
device_before_plug = find_device(vm, params)
with open(xml) as disk_file:
logging.debug("Attach disk by XML: %s", disk_file.read())
file_arg = xml
if plug_method == "cold":
file_arg += ' --config'
s_attach = virsh.attach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
libvirt.check_exit_status(s_attach)
if plug_method == "cold":
reboot()
detect_time = params.get("detect_disk_time", 20)
plug_disks = utils_misc.wait_for(
lambda: get_new_device(device_before_plug, find_device(vm, params)
), detect_time)
if not plug_disks:
test.fail("Failed to hotplug device %s to guest" % device_name)
def detach(xml, device_name, unplug_method="hot"):
"""
Detach device with xml, for both hot and cold unplug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for unplug method
"""
with open(xml) as disk_file:
logging.debug("Detach device by XML: %s", disk_file.read())
file_arg = xml
if unplug_method == "cold":
file_arg = xml + ' --config'
s_detach = virsh.detach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
if unplug_method == "cold":
reboot()
libvirt.check_exit_status(s_detach)
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 attach_controller(): # pylint: disable=W0611
"""
Sub test for attach controller
"""
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
contr_index = len(v_xml.get_controllers('scsi'))
contr_type = params.get("controller_type", 'scsi')
contr_model = params.get("controller_model", "virtio-scsi")
contr_dict = {
'controller_type': contr_type,
'controller_model': contr_model,
'controller_index': contr_index
}
if pci_bridge_index:
slot = get_free_slot(pci_bridge_index, v_xml)
addr = '{"bus": %s, "slot": %s}' % (pci_bridge_index, slot)
contr_dict.update({'controller_addr': addr})
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
attach(xml, params['controller_model'])
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
detach(xml, params['controller_model'])
def snapshot(): # pylint: disable=W0611
"""
Sub test for snapshot
"""
for i in range(1, 4):
ret = virsh.snapshot_create_as(vm_name, "sn%s --disk-only" % i)
libvirt.check_exit_status(ret)
process.system("systemctl restart libvirtd")
save_path = os.path.join(tmp_dir, "test.save")
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
session = vm.wait_for_login()
session.close()
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
add_pcie_to_pci_bridge = params.get("add_pcie_to_pci_bridge")
pci_bridge_index = None
tmp_dir = data_dir.get_tmp_dir()
guest_src_url = params.get("guest_src_url")
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
if guest_src_url:
def _download():
download_cmd = ("wget %s -O %s" % (guest_src_url, target_path))
if process.system(download_cmd, shell=True):
test.error("Failed to download file")
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
if utils_package.package_install("wget"):
utils_misc.wait_for(_download, timeout=360)
else:
test.error("Fail to install wget")
params["blk_source_name"] = target_path
if add_pcie_to_pci_bridge:
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
pci_bridge = controller
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
pci_bridge = libvirt.create_controller_xml(contr_dict,
"add_controller",
vm_name)
pci_bridge_index = '%0#4x' % int(pci_bridge.get("index"))
try:
if (params["os_variant"] == 'rhel6'
or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
if pci_bridge_index:
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if params.get("disk_target_bus") == "scsi":
scsi_controllers = v_xml.get_controllers('scsi')
for index, controller in enumerate(scsi_controllers):
controller.find('address').set('bus', pci_bridge_index)
controller.find('address').set(
'slot', get_free_slot(pci_bridge_index, v_xml))
else:
disks = v_xml.get_devices(device_type="disk")
for index, disk in enumerate(disks):
args = {
'bus': pci_bridge_index,
'slot': get_free_slot(pci_bridge_index, v_xml)
}
libvirt.set_disk_attr(v_xml, disk.target['dev'], 'address',
args)
v_xml.xmltreefile.write()
v_xml.sync()
if not vm.is_alive():
vm.start()
vm.wait_for_login()
test_step = params.get("sub_test_step")
if test_step:
eval(test_step)()
finally:
vm.destroy()
libvirt.clean_up_snapshots(vm_name)
backup_xml.sync()
def run(test, params, env):
"""
Test virsh migrate command.
"""
def set_feature(vmxml, feature, value):
"""
Set guest features for PPC
:param state: the htm status
:param vmxml: guest xml
"""
features_xml = vm_xml.VMFeaturesXML()
if feature == 'hpt':
features_xml.hpt_resizing = value
elif feature == 'htm':
features_xml.htm = value
vmxml.features = features_xml
vmxml.sync()
def trigger_hpt_resize(session):
"""
Check the HPT order file and dmesg
:param session: the session to guest
:raise: test.fail if required message is not found
"""
hpt_order_path = "/sys/kernel/debug/powerpc/hpt_order"
hpt_order = session.cmd_output('cat %s' % hpt_order_path).strip()
hpt_order = int(hpt_order)
logging.info('Current hpt_order is %d', hpt_order)
hpt_order += 1
cmd = 'echo %d > %s' % (hpt_order, hpt_order_path)
cmd_result = session.cmd_status_output(cmd)
result = process.CmdResult(stderr=cmd_result[1],
stdout=cmd_result[1],
exit_status=cmd_result[0])
libvirt.check_exit_status(result)
dmesg = session.cmd('dmesg')
dmesg_content = params.get('dmesg_content').split('|')
for content in dmesg_content:
if content % hpt_order not in dmesg:
test.fail("'%s' is missing in dmesg" % (content % hpt_order))
else:
logging.info("'%s' is found in dmesg", content % hpt_order)
def check_vm_network_accessed(session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:raise: test.error when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
s_ping, _ = utils_test.ping(vm.get_address(),
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if s_ping != 0:
if session:
session.close()
test.fail("%s did not respond after %d sec." % (vm.name, 20))
def check_virsh_command_and_option(command, option=None):
"""
Check if virsh command exists
:param command: the command to be checked
:param option: the command option to be checked
"""
msg = "This version of libvirt does not support "
if not virsh.has_help_command(command):
test.cancel(msg + "virsh command '%s'" % command)
if option and not virsh.has_command_help_match(command, option):
test.cancel(msg + "virsh command '%s' with option '%s'" % (command,
option))
def add_ctrls(vm_xml, dev_type="pci", dev_index="0", dev_model="pci-root"):
"""
Add multiple devices
:param dev_type: the type of the device to be added
:param dev_index: the maximum index of the device to be added
:param dev_model: the model of the device to be added
"""
for inx in range(0, int(dev_index) + 1):
newcontroller = Controller("controller")
newcontroller.type = dev_type
newcontroller.index = inx
newcontroller.model = dev_model
logging.debug("New device is added:\n%s", newcontroller)
vm_xml.add_device(newcontroller)
vm_xml.sync()
def do_migration(vm, dest_uri, options, extra):
"""
Execute the migration with given parameters
:param vm: the guest to be migrated
:param dest_uri: the destination uri for migration
:param options: options next to 'migrate' command
:param extra: options in the end of the migrate command line
:return: CmdResult object
"""
logging.info("Sleeping 10 seconds before migration")
time.sleep(10)
# Migrate the guest.
virsh_args.update({"ignore_status": True})
migration_res = vm.migrate(dest_uri, options, extra, **virsh_args)
if int(migration_res.exit_status) != 0:
logging.error("Migration failed for %s.", vm_name)
return migration_res
if vm.is_alive(): # vm.connect_uri was updated
logging.info("VM is alive on destination %s.", dest_uri)
else:
test.fail("VM is not alive on destination %s" % dest_uri)
# Throws exception if console shows panic message
vm.verify_kernel_crash()
return migration_res
def cleanup_libvirtd_log(log_file):
"""
Remove existing libvirtd log file on source and target host.
:param log_file: log file with absolute path
"""
if os.path.exists(log_file):
logging.debug("Delete local libvirt log file '%s'", log_file)
os.remove(log_file)
cmd = "rm -f %s" % log_file
logging.debug("Delete remote libvirt log file '%s'", log_file)
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
remote.run_remote_cmd(cmd, cmd_parms, runner_on_target)
def cleanup_dest(vm):
"""
Clean up the destination host environment
when doing the uni-direction migration.
:param vm: the guest to be cleaned up
"""
logging.info("Cleaning up VMs on %s", vm.connect_uri)
try:
if virsh.domain_exists(vm.name, uri=vm.connect_uri):
vm_state = vm.state()
if vm_state == "paused":
vm.resume()
elif vm_state == "shut off":
vm.start()
vm.destroy(gracefully=False)
if vm.is_persistent():
vm.undefine()
except Exception as detail:
logging.error("Cleaning up destination failed.\n%s", detail)
def run_stress_in_vm():
"""
The function to load stress in VM
"""
stress_args = params.get("stress_args", "--cpu 8 --io 4 "
"--vm 2 --vm-bytes 128M "
"--timeout 20s")
try:
vm_session.cmd('stress %s' % stress_args)
except Exception as detail:
logging.debug(detail)
def control_migrate_speed(to_speed=1):
"""
Control migration duration
:param to_speed: the speed value in Mbps to be set for migration
:return int: the new migration speed after setting
"""
virsh_args.update({"ignore_status": False})
old_speed = virsh.migrate_getspeed(vm_name, **virsh_args)
logging.debug("Current migration speed is %s MiB/s\n", old_speed.stdout.strip())
logging.debug("Set migration speed to %d MiB/s\n", to_speed)
cmd_result = virsh.migrate_setspeed(vm_name, to_speed, "", **virsh_args)
actual_speed = virsh.migrate_getspeed(vm_name, **virsh_args)
logging.debug("New migration speed is %s MiB/s\n", actual_speed.stdout.strip())
return int(actual_speed.stdout.strip())
def check_setspeed(params):
"""
Set/get migration speed
:param params: the parameters used
:raise: test.fail if speed set does not take effect
"""
expected_value = int(params.get("migrate_speed", '41943040')) // (1024 * 1024)
actual_value = control_migrate_speed(to_speed=expected_value)
params.update({'compare_to_value': actual_value})
if actual_value != expected_value:
test.fail("Migration speed is expected to be '%d MiB/s', but '%d MiB/s' "
"found" % (expected_value, actual_value))
def check_domjobinfo(params, option=""):
"""
Check given item in domjobinfo of the guest is as expected
:param params: the parameters used
:param option: options for domjobinfo
:raise: test.fail if the value of given item is unexpected
"""
def search_jobinfo(jobinfo):
"""
Find value of given item in domjobinfo
:param jobinfo: cmdResult object
:raise: test.fail if not found
"""
for item in jobinfo.stdout.splitlines():
if item.count(jobinfo_item):
groups = re.findall(r'[0-9.]+', item.strip())
logging.debug("In '%s' search '%s'\n", item, groups[0])
if (math.fabs(float(groups[0]) - float(compare_to_value)) //
float(compare_to_value) > diff_rate):
test.fail("{} {} has too much difference from "
"{}".format(jobinfo_item,
groups[0],
compare_to_value))
break
jobinfo_item = params.get("jobinfo_item")
compare_to_value = params.get("compare_to_value")
logging.debug("compare_to_value:%s", compare_to_value)
diff_rate = float(params.get("diff_rate", "0"))
if not jobinfo_item or not compare_to_value:
return
vm_ref = '{}{}'.format(vm_name, option)
jobinfo = virsh.domjobinfo(vm_ref, **virsh_args)
search_jobinfo(jobinfo)
check_domjobinfo_remote = params.get("check_domjobinfo_remote")
if check_domjobinfo_remote:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
jobinfo = remote_virsh_session.domjobinfo(vm_ref, **virsh_args)
search_jobinfo(jobinfo)
remote_virsh_session.close_session()
def check_maxdowntime(params):
"""
Set/get migration maxdowntime
:param params: the parameters used
:raise: test.fail if maxdowntime set does not take effect
"""
expected_value = int(float(params.get("migrate_maxdowntime", '0.3')) * 1000)
virsh_args.update({"ignore_status": False})
old_value = int(virsh.migrate_getmaxdowntime(vm_name).stdout.strip())
logging.debug("Current migration maxdowntime is %d ms", old_value)
logging.debug("Set migration maxdowntime to %d ms", expected_value)
virsh.migrate_setmaxdowntime(vm_name, expected_value, **virsh_args)
actual_value = int(virsh.migrate_getmaxdowntime(vm_name).stdout.strip())
logging.debug("New migration maxdowntime is %d ms", actual_value)
if actual_value != expected_value:
test.fail("Migration maxdowntime is expected to be '%d ms', but '%d ms' "
"found" % (expected_value, actual_value))
params.update({'compare_to_value': actual_value})
def do_actions_during_migrate(params):
"""
The entry point to execute action list during migration
:param params: the parameters used
"""
actions_during_migration = params.get("actions_during_migration")
if not actions_during_migration:
return
for action in actions_during_migration.split(","):
if action == 'setspeed':
check_setspeed(params)
elif action == 'domjobinfo':
check_domjobinfo(params)
elif action == 'setmaxdowntime':
check_maxdowntime(params)
time.sleep(3)
def attach_channel_xml():
"""
Create channel xml and attach it to guest configuration
"""
# Check if pty channel exists already
for elem in new_xml.devices.by_device_tag('channel'):
if elem.type_name == channel_type_name:
logging.debug("{0} channel already exists in guest. "
"No need to add new one".format(channel_type_name))
return
params = {'channel_type_name': channel_type_name,
'target_type': target_type,
'target_name': target_name}
channel_xml = libvirt.create_channel_xml(params)
virsh.attach_device(domain_opt=vm_name, file_opt=channel_xml.xml,
flagstr="--config", ignore_status=False)
logging.debug("New VMXML with channel:\n%s", virsh.dumpxml(vm_name))
def check_timeout_postcopy(params):
"""
Check the vm state on target host after timeout
when --postcopy and --timeout-postcopy are used.
The vm state is expected as running.
:param params: the parameters used
"""
timeout = int(params.get("timeout_postcopy", 10))
time.sleep(timeout + 1)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
vm_state = results_stdout_52lts(remote_virsh_session.domstate(vm_name)).strip()
if vm_state != "running":
remote_virsh_session.close_session()
test.fail("After timeout '%s' seconds, "
"the vm state on target host should "
"be 'running', but '%s' found",
timeout, vm_state)
remote_virsh_session.close_session()
def get_usable_compress_cache(pagesize):
"""
Get a number which is bigger than pagesize and is power of two.
:param pagesize: the given integer
:return: an integer satisfying the criteria
"""
def calculate(num):
result = num & (num - 1)
return (result == 0)
item = pagesize
found = False
while (not found):
item += 1
found = calculate(item)
logging.debug("%d is smallest one that is bigger than '%s' and "
"is power of 2", item, pagesize)
return item
def check_migration_res(result):
"""
Check if the migration result is as expected
:param result: the output of migration
:raise: test.fail if test is failed
"""
logging.info("Migration out: %s", results_stdout_52lts(result).strip())
logging.info("Migration error: %s", results_stderr_52lts(result).strip())
if status_error: # Migration should fail
if err_msg: # Special error messages are expected
if not re.search(err_msg, results_stderr_52lts(result).strip()):
test.fail("Can not find the expected patterns '%s' in "
"output '%s'" % (err_msg,
results_stderr_52lts(result).strip()))
else:
logging.debug("It is the expected error message")
else:
if int(result.exit_status) != 0:
logging.debug("Migration failure is expected result")
else:
test.fail("Migration success is unexpected result")
else:
if int(result.exit_status) != 0:
test.fail(results_stderr_52lts(result).strip())
check_parameters(test, params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
virsh_opt = params.get("virsh_opt", "")
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
log_file = params.get("libvirt_log", "/var/log/libvirt/libvirtd.log")
check_complete_job = "yes" == params.get("check_complete_job", "no")
config_libvirtd = "yes" == params.get("config_libvirtd", "no")
contrl_index = params.get("new_contrl_index", None)
asynch_migration = "yes" == params.get("asynch_migrate", "no")
grep_str_remote_log = params.get("grep_str_remote_log", "")
grep_str_local_log = params.get("grep_str_local_log", "")
disable_verify_peer = "yes" == params.get("disable_verify_peer", "no")
status_error = "yes" == params.get("status_error", "no")
stress_in_vm = "yes" == params.get("stress_in_vm", "no")
low_speed = params.get("low_speed", None)
remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
'remote_pwd': server_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
hpt_resize = params.get("hpt_resize", None)
htm_state = params.get("htm_state", None)
# For pty channel test
add_channel = "yes" == params.get("add_channel", "no")
channel_type_name = params.get("channel_type_name", None)
target_type = params.get("target_type", None)
target_name = params.get("target_name", None)
cmd_run_in_remote_guest = params.get("cmd_run_in_remote_guest", None)
cmd_run_in_remote_guest_1 = params.get("cmd_run_in_remote_guest_1", None)
cmd_run_in_remote_host = params.get("cmd_run_in_remote_host", None)
cmd_run_in_remote_host_1 = params.get("cmd_run_in_remote_host_1", None)
cmd_run_in_remote_host_2 = params.get("cmd_run_in_remote_host_2", None)
# For qemu command line checking
qemu_check = params.get("qemu_check", None)
xml_check_after_mig = params.get("guest_xml_check_after_mig", None)
# params for cache matrix test
cache = params.get("cache")
remove_cache = "yes" == params.get("remove_cache", "no")
err_msg = params.get("err_msg")
arch = platform.machine()
if any([hpt_resize, contrl_index, htm_state]) and 'ppc64' not in arch:
test.cancel("The case is PPC only.")
# For TLS
tls_recovery = params.get("tls_auto_recovery", "yes")
# qemu config
qemu_conf_dict = None
# libvirtd config
libvirtd_conf_dict = None
remote_virsh_session = None
vm = None
vm_session = None
libvirtd_conf = None
qemu_conf = None
mig_result = None
test_exception = None
is_TestError = False
is_TestFail = False
is_TestSkip = False
# Objects to be cleaned up in the end
objs_list = []
tls_obj = None
# Local variables
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
if not orig_config_xml:
test.error("Backing up xmlfile failed.")
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
# Change the configuration files if needed before starting guest
# For qemu.conf
if extra.count("--tls"):
# Setup TLS
tls_obj = TLSConnection(params)
if tls_recovery == "yes":
objs_list.append(tls_obj)
tls_obj.auto_recover = True
tls_obj.conn_setup()
if not disable_verify_peer:
qemu_conf_dict = {"migrate_tls_x509_verify": "1"}
# Setup qemu configure
logging.debug("Configure the qemu")
cleanup_libvirtd_log(log_file)
qemu_conf = libvirt.customize_libvirt_config(qemu_conf_dict,
config_type="qemu",
remote_host=True,
extra_params=params)
# Setup libvirtd
if config_libvirtd:
logging.debug("Configure the libvirtd")
cleanup_libvirtd_log(log_file)
libvirtd_conf_dict = setup_libvirtd_conf_dict(params)
libvirtd_conf = libvirt.customize_libvirt_config(libvirtd_conf_dict,
remote_host=True,
extra_params=params)
# Prepare required guest xml before starting guest
if contrl_index:
new_xml.remove_all_device_by_type('controller')
logging.debug("After removing controllers, current XML:\n%s\n", new_xml)
add_ctrls(new_xml, dev_index=contrl_index)
if add_channel:
attach_channel_xml()
if hpt_resize:
set_feature(new_xml, 'hpt', hpt_resize)
if htm_state:
set_feature(new_xml, 'htm', htm_state)
if cache:
params["driver_cache"] = cache
if remove_cache:
params["enable_cache"] = "no"
# Change the disk of the vm to shared disk and then start VM
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s", vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check qemu command line after guest is started
if qemu_check:
check_content = qemu_check
if hpt_resize:
check_content = "%s%s" % (qemu_check, hpt_resize)
if htm_state:
check_content = "%s%s" % (qemu_check, htm_state)
libvirt.check_qemu_cmd_line(check_content)
# Check local guest network connection before migration
vm_session = vm.wait_for_login()
check_vm_network_accessed()
# Preparation for the running guest before migration
if hpt_resize and hpt_resize != 'disabled':
trigger_hpt_resize(vm_session)
if low_speed:
control_migrate_speed(int(low_speed))
if stress_in_vm:
pkg_name = 'stress'
logging.debug("Check if stress tool is installed")
pkg_mgr = utils_package.package_manager(vm_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("Stress tool will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
stress_thread = threading.Thread(target=run_stress_in_vm,
args=())
stress_thread.start()
if extra.count("timeout-postcopy"):
func_name = check_timeout_postcopy
if params.get("actions_during_migration"):
func_name = do_actions_during_migrate
if extra.count("comp-xbzrle-cache"):
cache = get_usable_compress_cache(memory.get_page_size())
extra = "%s %s" % (extra, cache)
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
# Execute migration process
if not asynch_migration:
mig_result = do_migration(vm, dest_uri, options, extra)
else:
migration_test = libvirt.MigrationTest()
logging.debug("vm.connect_uri=%s", vm.connect_uri)
vms = [vm]
try:
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_opt,
func=func_name, extra_opts=extra,
func_params=params)
mig_result = migration_test.ret
except exceptions.TestFail as fail_detail:
test.fail(fail_detail)
except exceptions.TestSkipError as skip_detail:
test.cancel(skip_detail)
except exceptions.TestError as error_detail:
test.error(error_detail)
except Exception as details:
mig_result = migration_test.ret
logging.error(details)
check_migration_res(mig_result)
if add_channel:
# Get the channel device source path of remote guest
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
file_path = tempfile.mktemp(dir=data_dir.get_tmp_dir())
remote_virsh_session.dumpxml(vm_name, to_file=file_path,
debug=True,
ignore_status=True)
local_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
local_vmxml.xmltreefile = xml_utils.XMLTreeFile(file_path)
for elem in local_vmxml.devices.by_device_tag('channel'):
logging.debug("Found channel device {}".format(elem))
if elem.type_name == channel_type_name:
host_source = elem.source.get('path')
logging.debug("Remote guest uses {} for channel device".format(host_source))
break
remote_virsh_session.close_session()
if not host_source:
test.fail("Can not find source for %s channel on remote host" % channel_type_name)
# Prepare to wait for message on remote host from the channel
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
cmd_result = remote.run_remote_cmd(cmd_run_in_remote_host % host_source,
cmd_parms,
runner_on_target)
# Send message from remote guest to the channel file
remote_vm_obj = utils_test.RemoteVMManager(cmd_parms)
vm_ip = vm.get_address()
vm_pwd = params.get("password")
remote_vm_obj.setup_ssh_auth(vm_ip, vm_pwd)
cmd_result = remote_vm_obj.run_command(vm_ip, cmd_run_in_remote_guest_1)
remote_vm_obj.run_command(vm_ip, cmd_run_in_remote_guest % results_stdout_52lts(cmd_result).strip())
logging.debug("Sending message is done")
# Check message on remote host from the channel
remote.run_remote_cmd(cmd_run_in_remote_host_1, cmd_parms, runner_on_target)
logging.debug("Receiving message is done")
remote.run_remote_cmd(cmd_run_in_remote_host_2, cmd_parms, runner_on_target)
if check_complete_job:
opts = " --completed"
check_virsh_command_and_option("domjobinfo", opts)
if extra.count("comp-xbzrle-cache"):
params.update({'compare_to_value': cache // 1024})
check_domjobinfo(params, option=opts)
if grep_str_local_log:
cmd = "grep -E '%s' %s" % (grep_str_local_log, log_file)
cmdRes = process.run(cmd, shell=True, ignore_status=True)
if cmdRes.exit_status:
test.fail(results_stderr_52lts(cmdRes).strip())
if grep_str_remote_log:
cmd = "grep -E '%s' %s" % (grep_str_remote_log, log_file)
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
remote.run_remote_cmd(cmd, cmd_parms, runner_on_target)
if xml_check_after_mig:
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
target_guest_dumpxml = results_stdout_52lts(
remote_virsh_session.dumpxml(vm_name,
debug=True,
ignore_status=True)).strip()
if hpt_resize:
check_str = hpt_resize
elif htm_state:
check_str = htm_state
if hpt_resize or htm_state:
xml_check_after_mig = "%s'%s'" % (xml_check_after_mig, check_str)
if not re.search(xml_check_after_mig, target_guest_dumpxml):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' in target guest XML:\n%s"
% (xml_check_after_mig, target_guest_dumpxml))
if contrl_index:
all_ctrls = re.findall(xml_check_after_mig, target_guest_dumpxml)
if len(all_ctrls) != int(contrl_index) + 1:
remote_virsh_session.close_session()
test.fail("%s pci-root controllers are expected in guest XML, "
"but found %s" % (int(contrl_index) + 1, len(all_ctrls)))
remote_virsh_session.close_session()
if int(mig_result.exit_status) == 0:
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session)
server_session.close()
except exceptions.TestFail as details:
is_TestFail = True
test_exception = details
except exceptions.TestSkipError as details:
is_TestSkip = True
test_exception = details
except exceptions.TestError as details:
is_TestError = True
test_exception = details
except Exception as details:
test_exception = details
finally:
logging.debug("Recover test environment")
try:
# Clean VM on destination
vm.connect_uri = dest_uri
cleanup_dest(vm)
vm.connect_uri = src_uri
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s", orig_config_xml.xmltreefile)
if remote_virsh_session:
remote_virsh_session.close_session()
if extra.count("--tls") and not disable_verify_peer:
logging.debug("Recover the qemu configuration")
libvirt.customize_libvirt_config(None,
config_type="qemu",
remote_host=True,
extra_params=params,
is_recover=True,
config_object=qemu_conf)
if config_libvirtd:
logging.debug("Recover the libvirtd configuration")
libvirt.customize_libvirt_config(None,
remote_host=True,
extra_params=params,
is_recover=True,
config_object=libvirtd_conf)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
if objs_list:
for obj in objs_list:
logging.debug("Clean up local objs")
del obj
except Exception as exception_detail:
if (not test_exception and not is_TestError and
not is_TestFail and not is_TestSkip):
raise exception_detail
else:
# if any of above exceptions has been raised, only print
# error log here to avoid of hiding the original issue
logging.error(exception_detail)
# Check result
if is_TestFail:
test.fail(test_exception)
if is_TestSkip:
test.cancel(test_exception)
if is_TestError:
test.error(test_exception)
if not test_exception:
logging.info("Case execution is done.")
else:
test.error(test_exception)
def run(test, params, env):
"""
Test DAC setting in both domain xml and qemu.conf.
(1) Init variables for test.
(2) Set VM xml and qemu.conf with proper DAC label, also set
monitor socket parent dir with propoer ownership and mode.
(3) Start VM and check the context.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("host_selinux", "enforcing")
# Get variables about seclabel for VM.
sec_type = params.get("vm_sec_type", "dynamic")
vm_sec_model = params.get("vm_sec_model", "dac")
vm_sec_label = params.get("vm_sec_label", None)
vm_sec_relabel = params.get("vm_sec_relabel", "yes")
sec_dict = {'type': sec_type, 'model': vm_sec_model,
'relabel': vm_sec_relabel}
if vm_sec_label:
sec_dict['label'] = vm_sec_label
set_qemu_conf = "yes" == params.get("set_qemu_conf", "no")
# Get per-img seclabel variables
disk_type = params.get("disk_type")
disk_target = params.get('disk_target')
disk_src_protocol = params.get("disk_source_protocol")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
invalid_label = 'yes' == params.get("invalid_label", "no")
relabel = params.get("per_img_sec_relabel")
sec_label = params.get("per_img_sec_label")
per_sec_model = params.get("per_sec_model", 'dac')
per_img_dict = {'sec_model': per_sec_model, 'relabel': relabel,
'sec_label': sec_label}
params.update(per_img_dict)
# Get qemu.conf config variables
qemu_user = params.get("qemu_user", 'qemu')
qemu_group = params.get("qemu_group", 'qemu')
dynamic_ownership = "yes" == params.get("dynamic_ownership", "yes")
# Get variables about VM and get a VM object and VMXML instance.
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Set selinux of host.
backup_sestatus = utils_selinux.get_status()
utils_selinux.set_status(host_sestatus)
qemu_sock_mod = False
qemu_sock_path = '/var/lib/libvirt/qemu/'
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
try:
if set_qemu_conf:
# Set qemu.conf for user and group
if qemu_user:
qemu_conf.user = qemu_user
if qemu_group:
qemu_conf.group = qemu_group
if dynamic_ownership:
qemu_conf.dynamic_ownership = 1
else:
qemu_conf.dynamic_ownership = 0
logging.debug("the qemu.conf content is: %s" % qemu_conf)
libvirtd.restart()
st = os.stat(qemu_sock_path)
if not bool(st.st_mode & stat.S_IWGRP):
# chmod g+w
os.chmod(qemu_sock_path, st.st_mode | stat.S_IWGRP)
qemu_sock_mod = True
# Set the context of the VM.
logging.debug("sec_dict is %s" % sec_dict)
vmxml.set_seclabel([sec_dict])
vmxml.sync()
# Get per-image seclabel in id string
if sec_label:
per_img_usr, per_img_grp = sec_label.split(':')
sec_label_id = format_user_group_str(per_img_usr, per_img_grp)
# Start VM to check the qemu process and image.
try:
# Set per-img sec context and start vm
utlv.set_vm_disk(vm, params)
# Start VM successfully.
if status_error:
if invalid_label:
# invalid label should fail, more info in bug 1165485
raise error.TestNAError("The label or model not valid, "
"check more info in bug: https://"
"bugzilla.redhat.com/show_bug.cgi"
"?id=1165485")
else:
raise error.TestFail("Test succeeded in negative case.")
# Get vm process label when VM is running.
vm_pid = vm.get_pid()
pid_stat = os.stat("/proc/%d" % vm_pid)
vm_process_uid = pid_stat.st_uid
vm_process_gid = pid_stat.st_gid
vm_context = "%s:%s" % (vm_process_uid, vm_process_gid)
logging.debug("vm process label is: %s", vm_context)
# Get vm image label when VM is running
if disk_type != "network":
disks = vm.get_blk_devices()
f = os.open(disks[disk_target]['source'], 0)
stat_re = os.fstat(f)
disk_context = "%s:%s" % (stat_re.st_uid, stat_re.st_gid)
os.close(f)
logging.debug("The disk dac label after vm start is: %s",
disk_context)
if sec_label and relabel == 'yes':
if disk_context != sec_label_id:
raise error.TestFail("The disk label is not equal to "
"'%s'." % sec_label_id)
except virt_vm.VMStartError, e:
# Starting VM failed.
if not status_error:
raise error.TestFail("Test failed in positive case."
"error: %s" % e)
finally:
# clean up
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml.sync()
if qemu_sock_mod:
st = os.stat(qemu_sock_path)
os.chmod(qemu_sock_path, st.st_mode ^ stat.S_IWGRP)
if set_qemu_conf:
qemu_conf.restore()
libvirtd.restart()
utils_selinux.set_status(backup_sestatus)
if disk_src_protocol == 'iscsi':
utlv.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src_protocol == 'gluster':
utlv.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd.restart()
elif disk_src_protocol == 'netfs':
utlv.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=backup_sestatus)
def run(test, params, env):
"""
Test scenarios: virsh blockcommit with relative path
1) Prepare test environment.
2) Create relative path backing chain
3) Do virsh blockcommit
4) Check result.
5) Recover the environments
"""
def check_chain_backing_files(disk_src_file, expect_backing_list):
"""
Check backing chain files of relative path after blockcommit.
:param disk_src_file: first disk src file.
:param expect_backing_list: backing chain lists.
"""
# Validate source image doesn't have backing files after active blockcommit
qemu_img_info_backing_chain = libvirt_disk.get_chain_backing_files(disk_src_file)
logging.debug("The actual qemu-img qemu_img_info_backing_chain:%s\n", qemu_img_info_backing_chain)
logging.debug("The actual qemu-img expect_backing_list:%s\n", expect_backing_list)
if qemu_img_info_backing_chain != expect_backing_list:
test.fail("The backing files by qemu-img is not identical in expected backing list")
def check_top_image_in_xml(expected_top_image):
"""
check top image in src file
:param expected_top_image: expect top image
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
disk_xml = None
for disk in disks:
if disk.target['dev'] == disk_target:
disk_xml = disk.xmltreefile
break
logging.debug("disk xml in top: %s\n", disk_xml)
for attr in ['file', 'name', 'dev']:
src_file = disk_xml.find('source').get(attr)
if src_file:
break
if src_file not in expected_top_image:
test.fail("Current top img %s is not the same with expected: %s" % (src_file, expected_top_image))
def check_blockcommit_with_bandwidth(chain_list):
"""
Check blockcommit with bandwidth
param chain_list: list, expected backing chain list
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
disk_xml = None
for disk in disks:
if disk.target['dev'] == disk_target:
disk_xml = disk
break
logging.debug("disk xml in check_blockcommit_with_bandwidth: %s\n", disk_xml.xmltreefile)
backingstore_list = disk_xml.get_backingstore_list()
parse_source_file_list = [elem.find('source').get('file') or elem.find('source').get('name') for elem in backingstore_list]
logging.debug("expected backing chain list is %s", chain_list)
logging.debug("parse source list is %s", parse_source_file_list)
# Check whether relative path has been kept
for i in range(0, len(chain_list)-1):
if chain_list[i] not in parse_source_file_list[i]:
test.fail("The relative path parsed from disk xml is different with pre-expected ones")
def check_file_not_exists(root_dir, file_name, reverse=False):
"""
Check whether file exists in certain folder
:param root_dir: preset root directory
:param file_name: input file name
:param reverse: whether reverse the condition
"""
files_path = [os.path.join(root_dir, f) for f in os.listdir(root_dir)
if os.path.isfile(os.path.join(root_dir, f))
]
logging.debug("all files in folder: %s \n", files_path)
if not files_path:
test.fail("Failed to get snapshot files in preset folder")
elif reverse:
if file_name not in files_path:
test.fail("snapshot file:%s can not be found" % file_name)
else:
if file_name in files_path:
test.fail("snapshot file:%s can not be deleted" % file_name)
def check_backing_chain_file_not_exists(disk_src_file, file_name, reverse=False):
"""
Check whether file exists in source file's backing chain
:param disk_src_file: disk source with backing chain files
:param file_name: input file name
:param reverse: whether reverse this condition
"""
qemu_img_info_backing_chain = libvirt_disk.get_chain_backing_files(disk_src_file)
if reverse:
if file_name not in qemu_img_info_backing_chain:
test.fail("%s can not be found in backing chain file" % file_name)
else:
if file_name in qemu_img_info_backing_chain:
test.fail("%s should not be in backing chain file" % file_name)
def fill_vm_with_contents():
""" Fill contents in VM """
logging.info("Filling VM contents...")
try:
session = vm.wait_for_login()
status, output = session.cmd_status_output(
"dd if=/dev/urandom of=/tmp/bigfile bs=1M count=200")
logging.info("Fill contents in VM:\n%s", output)
session.close()
except Exception as e:
logging.error(str(e))
def create_lvm_pool():
""" create lvm pool"""
pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_image)
pvt.pre_pool(**params)
capacity = "5G"
for i in range(1, 5):
vol_name = 'vol%s' % i
path = "%s/%s" % (pool_target, vol_name)
virsh.vol_create_as(vol_name, pool_name, capacity, capacity, "qcow2", debug=True)
cmd = "qemu-img create -f %s %s %s" % ("qcow2", path, capacity)
process.run(cmd, ignore_status=False, shell=True)
volume_path_list.append(path)
capacity = "2G"
def setup_iscsi_env():
""" Setup iscsi environment"""
libvirt.setup_or_cleanup_iscsi(is_setup=False)
emulated_size = params.get("image_size", "10G")
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=False,
image_size=emulated_size,
portal_ip="127.0.0.1")
cmd = ("qemu-img create -f qcow2 iscsi://%s:%s/%s/%s %s"
% ("127.0.0.1", "3260", iscsi_target, lun_num, emulated_size))
process.run(cmd, shell=True)
blk_source_image_after_converted = "iscsi://%s:%s/%s/%s" % ("127.0.0.1", "3260", iscsi_target, lun_num)
# Convert the image from qcow2 to raw
convert_disk_cmd = ("qemu-img convert"
" -O %s %s %s" % (disk_format, first_src_file, blk_source_image_after_converted))
process.run(convert_disk_cmd, ignore_status=False, shell=True)
replace_disk_image, backing_chain_list = libvirt_disk.make_relative_path_backing_files(
vm, pre_set_root_dir, blk_source_image_after_converted, disk_format)
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_source_protocol': 'file'})
return replace_disk_image, blk_source_image_after_converted, backing_chain_list
def setup_rbd_env():
""" Set up rbd environment"""
params.update(
{"virt_disk_device_target": disk_target,
"ceph_image_file": first_src_file})
libvirt_ceph_utils.create_or_cleanup_ceph_backend_vm_disk(vm, params, is_setup=True)
ceph_mon_ip = params.get("ceph_mon_ip", "EXAMPLE_MON_HOST")
ceph_disk_name = params.get("ceph_disk_name", "EXAMPLE_SOURCE_NAME")
blk_source_image_after_converted = ("rbd:%s:mon_host=%s" %
(ceph_disk_name, ceph_mon_ip))
replace_disk_image, backing_chain_list = libvirt_disk.make_relative_path_backing_files(
vm, pre_set_root_dir, blk_source_image_after_converted, disk_format)
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_format': 'qcow2',
'disk_source_protocol': 'file'})
return replace_disk_image, blk_source_image_after_converted, backing_chain_list
def setup_volume_pool_env():
"""Setup volume pool environment"""
params.update(
{"virt_disk_device_target": disk_target})
create_lvm_pool()
blk_source_image_after_converted = ("%s" % volume_path_list[0])
# Convert the image from qcow2 to volume
convert_disk_cmd = ("qemu-img convert"
" -O %s %s %s" % (disk_format, first_src_file, blk_source_image_after_converted))
process.run(convert_disk_cmd, ignore_status=False, shell=True)
params.update({'disk_source_name': blk_source_image_after_converted,
'disk_type': 'block',
'disk_format': 'qcow2',
'disk_source_protocol': 'file'})
libvirt.set_vm_disk(vm, params, tmp_dir)
vm.wait_for_login().close()
vm.destroy(gracefully=False)
replace_disk_image, backing_chain_list = libvirt_disk.make_syslink_path_backing_files(
pre_set_root_dir, volume_path_list, disk_format)
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_format': 'qcow2',
'disk_source_protocol': 'file'})
blk_source_image_after_converted = os.path.join(pre_set_root_dir, syslink_top_img)
skip_first_one = True
return replace_disk_image, blk_source_image_after_converted, skip_first_one, backing_chain_list
def validate_blockcommit_after_libvirtd_restart():
"""Validate blockcommit after libvirtd restart"""
logging.debug("phase three blockcommit .....")
counts = 1
phase_three_blockcommit_options = " --active"
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', phase_three_blockcommit_options, counts)
time.sleep(3)
# Before restart libvirtd
mirror_content_before_restart = libvirt_disk.get_mirror_part_in_xml(vm, disk_target)
logging.debug(mirror_content_before_restart)
utils_libvirtd.libvirtd_restart()
# After restart libvirtd
mirror_content_after_restart = libvirt_disk.get_mirror_part_in_xml(vm, disk_target)
logging.debug(mirror_content_after_restart)
# Check whether mirror content is identical with previous one
if mirror_content_before_restart != mirror_content_after_restart:
test.fail("The mirror part content changed after libvirtd restarted")
virsh.blockjob(vm_name, disk_target, '--abort', ignore_status=True)
def prepare_case_scenarios(snap_del_disks, base_file):
"""
Prepare case scenarios
:param snap_del_disks: snapshot list
:param base_file: base file for snapshot
"""
index = len(snap_del_disks) - 1
option = "--top %s --base %s --delete --verbose --wait"
scenarios = {}
scenarios.update({"middle-to-middle": {'blkcomopt':
option % (snap_del_disks[index - 1], snap_del_disks[index - 2]),
'top': snap_del_disks[index - 1],
'base': snap_del_disks[index - 2]}})
scenarios.update({"middle-to-base": {'blkcomopt':
option % (snap_del_disks[index - 1], base_file),
'top': snap_del_disks[index - 1],
'base': base_file}})
scenarios.update({"top-to-middle": {'blkcomopt':
option % (snap_del_disks[index], snap_del_disks[index - 2]) + " --active",
'top': snap_del_disks[index],
'base': snap_del_disks[index - 2]}})
scenarios.update({"top-to-base": {'blkcomopt':
"--top %s --delete --verbose --wait --active --pivot"
% (snap_del_disks[index]),
"top": snap_del_disks[index],
"base": snap_del_disks[index]}})
scenarios.update({"abort-top-job": {'blkcomopt':
"--top %s --delete --verbose --wait --active --pivot --bandwidth 1"
% (snap_del_disks[index]),
"top": snap_del_disks[index],
"base": snap_del_disks[index]}})
return scenarios
def loop_case_in_scenarios(scenarios):
"""
Loop case scenarios
:param scenarios: scenario list
"""
# loop each scenario
for case, opt in list(scenarios.items()):
logging.debug("Begin scenario: %s testing....................", case)
reverse = False
if vm.is_alive():
vm.destroy(gracefully=False)
# Reset VM to initial state
vmxml_backup.sync("--snapshots-metadata")
vm.start()
snap_del_disks = libvirt_disk.make_external_disk_snapshots(vm, disk_target, snapshot_prefix, snapshot_take)
tmp_option = opt.get('blkcomopt')
top_file = opt.get('top')
base_file = opt.get('base')
if 'abort' in case:
fill_vm_with_contents()
ignite_blockcommit_thread = threading.Thread(target=virsh.blockcommit,
args=(vm_name, disk_target, tmp_option,),
kwargs={'ignore_status': True, 'debug': True})
ignite_blockcommit_thread.start()
ignite_blockcommit_thread.join(2)
virsh.blockjob(vm_name, disk_target, " --abort", ignore_status=False)
reverse = True
else:
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', tmp_option, 1)
# Need pivot to make effect
if "--active" in tmp_option and "--pivot" not in tmp_option:
virsh.blockjob(vm_name, disk_target, '--pivot', ignore_status=True)
check_file_not_exists(pre_set_root_dir, top_file, reverse=reverse)
if 'top' not in case:
check_backing_chain_file_not_exists(snap_del_disks[len(snap_del_disks) - 1], top_file)
libvirt_disk.cleanup_snapshots(vm, snap_del_disks)
del snap_del_disks[:]
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_state = params.get("vm_state", "running")
virsh_dargs = {'debug': True}
status_error = ("yes" == params.get("status_error", "no"))
restart_libvirtd = ("yes" == params.get("restart_libvirtd", "no"))
validate_delete_option = ("yes" == params.get("validate_delete_option", "no"))
tmp_dir = data_dir.get_data_dir()
top_inactive = ("yes" == params.get("top_inactive"))
base_option = params.get("base_option", "none")
bandwidth = params.get("blockcommit_bandwidth", "")
disk_target = params.get("disk_target", "vda")
disk_format = params.get("disk_format", "qcow2")
disk_type = params.get("disk_type")
disk_src_protocol = params.get("disk_source_protocol")
pool_name = params.get("pool_name")
pool_target = params.get("pool_target")
pool_type = params.get("pool_type")
emulated_image = params.get("emulated_image")
syslink_top_img = params.get("syslink_top_img")
snapshot_take = int(params.get("snapshot_take", "4"))
snapshot_prefix = params.get("snapshot_prefix", "snapshot")
first_src_file = libvirt_disk.get_first_disk_source(vm)
blk_source_image = os.path.basename(first_src_file)
pre_set_root_dir = os.path.dirname(first_src_file)
snapshot_external_disks = []
skip_first_one = False
snap_del_disks = []
volume_path_list = []
kkwargs = params.copy()
pvt = libvirt.PoolVolumeTest(test, params)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
test.fail("There are snapshots created for %s already" %
vm_name)
try:
if vm.is_alive():
vm.destroy(gracefully=False)
if disk_src_protocol == 'iscsi':
replace_disk_image, blk_source_image_after_converted, backing_chain_list = setup_iscsi_env()
if disk_src_protocol == "rbd":
replace_disk_image, blk_source_image_after_converted, backing_chain_list = setup_rbd_env()
if disk_src_protocol == "pool":
replace_disk_image, blk_source_image_after_converted, skip_first_one, backing_chain_list = setup_volume_pool_env()
libvirt.set_vm_disk(vm, params, tmp_dir)
# get a vm session before snapshot
session = vm.wait_for_login()
old_parts = utils_disk.get_parts_list(session)
# Check backing files
check_chain_backing_files(replace_disk_image, backing_chain_list)
if vm_state == "paused":
vm.pause()
# Do phase one blockcommit
phase_one_blockcommit_options = "--active --verbose --shallow --pivot --keep-relative"
counts = len(backing_chain_list)
if bandwidth and base_option == "base":
phase_one_blockcommit_options = "--top vda[1] --base vda[3] --keep-relative --bandwidth %s --active" % bandwidth
if restart_libvirtd:
utils_libvirtd.libvirtd_restart()
if base_option == "shallow":
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', phase_one_blockcommit_options, counts)
elif base_option == "base":
counts = 1
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', phase_one_blockcommit_options, counts)
check_blockcommit_with_bandwidth(backing_chain_list[::-1])
virsh.blockjob(vm_name, disk_target, '--abort', ignore_status=True)
# Pivot commits to bottom one of backing chain
phase_one_blockcommit_options = "--active --verbose --shallow --pivot --keep-relative"
counts = len(backing_chain_list)
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', phase_one_blockcommit_options, counts)
#Check top image after phase one block commit
check_top_image_in_xml(blk_source_image_after_converted)
# Do snapshots
_, snapshot_external_disks = libvirt_disk.create_reuse_external_snapshots(
vm, pre_set_root_dir, skip_first_one, disk_target)
# Set blockcommit_options
phase_two_blockcommit_options = "--verbose --keep-relative --shallow --active --pivot"
# Run phase two blockcommit with snapshots
counts = len(snapshot_external_disks) - 1
libvirt_disk.do_blockcommit_repeatedly(vm, 'vda', phase_two_blockcommit_options, counts)
#Check top image after phase two block commit
check_top_image_in_xml(snapshot_external_disks)
# Run dependent restart_libvirtd case
if restart_libvirtd:
validate_blockcommit_after_libvirtd_restart()
# Run dependent validate_delete_option case
if validate_delete_option:
# Run blockcommit with snapshots to validate delete option
# Test scenarios can be referred from https://bugzilla.redhat.com/show_bug.cgi?id=1008350
logging.debug("Blockcommit with delete option .....")
base_file = first_src_file
# Get first attempt snapshot lists
if vm.is_alive():
vm.destroy(gracefully=False)
# Reset VM to initial state
vmxml_backup.sync("--snapshots-metadata")
vm.start()
snap_del_disks = libvirt_disk.make_external_disk_snapshots(vm, disk_target, snapshot_prefix, snapshot_take)
scenarios = prepare_case_scenarios(snap_del_disks, base_file)
libvirt_disk.cleanup_snapshots(vm, snap_del_disks)
del snap_del_disks[:]
loop_case_in_scenarios(scenarios)
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
# Delete reuse external disk if exists
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Delete snapshot disk
libvirt_disk.cleanup_snapshots(vm, snap_del_disks)
# Clean up created folders
for folder in [chr(letter) for letter in range(ord('a'), ord('a') + 4)]:
rm_cmd = "rm -rf %s" % os.path.join(pre_set_root_dir, folder)
process.run(rm_cmd, shell=True)
# Remove ceph config file if created
if disk_src_protocol == "rbd":
libvirt_ceph_utils.create_or_cleanup_ceph_backend_vm_disk(vm, params, is_setup=False)
elif disk_src_protocol == 'iscsi' or 'iscsi_target' in locals():
libvirt.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src_protocol == 'pool':
pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_image)
rm_cmd = "rm -rf %s" % pool_target
process.run(rm_cmd, shell=True)
# Recover images xattr if having some
dirty_images = libvirt_disk.get_images_with_xattr(vm)
if dirty_images:
libvirt_disk.clean_images_with_xattr(dirty_images)
test.error("VM's image(s) having xattr left")
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
# check the source disk
if not target:
raise error.TestFail("Require target disk to copy")
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s.", target, vm_name)
else:
raise error.TestFail("Can't find %s in domain %s." % (target, vm_name))
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
default_timeout = params.get("default_timeout", "300")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
rerun_flag = 0
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
if not dest_path:
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += "--raw"
if len(bandwidth):
options += "--bandwidth %s" % bandwidth
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
if not copy_to_nfs:
raise error.TestNAError("Bug will not fix:"
" https://bugzilla.redhat.com/show_bug."
"cgi?id=924151")
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s.", dest_path, expect)
else:
raise error.TestFail("%s format is not %s." % (dest_path, expect))
def blockcopy_chk():
"""
Raise TestFail when blockcopy hang with state change lock
"""
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise error.TestFail("Hit on bug: %s" % bug_url)
snap_path = ''
save_path = ''
try:
# Domain disk replacement with desire type
if replace_vm_disk:
utl.set_vm_disk(vm, params, tmp_dir)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command
if rerun_flag == 1:
options1 = "--wait --raw --finish --verbose"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise error.TestFail("Run blockcopy command fail.")
elif not os.path.exists(dest_path):
raise error.TestFail("Cannot find the created copy.")
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options,
**extra_dict)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise error.TestFail("Libvirtd service is dead.")
if not status_error:
blockcopy_chk()
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise error.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target,
"bandwidth", bandwidth)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise error.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
val = options.count("--pivot") + options.count("--finish")
if val == 0:
try:
finish_job(vm_name, target, default_timeout)
except JobTimeout, excpt:
raise error.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw"):
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
else:
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise error.TestFail("Hit on bug: %s" % bug_url)
raise error.TestFail(cmd_result.stderr)
else:
def run(test, params, env):
"""
Test migration with glusterfs.
"""
def create_or_clean_backend_dir(g_uri,
params,
session=None,
is_clean=False):
"""
Create/cleanup backend directory
:params g_uri: glusterfs uri
:params params: the parameters to be checked
:params session: VM/remote session object
:params is_cleanup: True for cleanup backend directory;
False for create one.
:return: gluster_img if is_clean is equal to True
"""
mount_point = params.get("gluster_mount_dir")
is_symlink = params.get("gluster_create_symlink") == "yes"
symlink_name = params.get("gluster_symlink")
gluster_img = None
if not is_clean:
if not utils_misc.check_exists(mount_point, session):
utils_misc.make_dirs(mount_point, session)
if gluster.glusterfs_is_mounted(mount_point, session):
gluster.glusterfs_umount(g_uri, mount_point, session)
gluster.glusterfs_mount(g_uri, mount_point, session)
gluster_img = os.path.join(mount_point, disk_img)
if is_symlink:
utils_misc.make_symlink(mount_point, symlink_name)
utils_misc.make_symlink(mount_point, symlink_name,
remote_session)
gluster_img = os.path.join(symlink_name, disk_img)
return gluster_img
else:
if is_symlink:
utils_misc.rm_link(symlink_name, session)
gluster.glusterfs_umount(g_uri, mount_point, session)
if utils_misc.check_exists(mount_point, session):
utils_misc.safe_rmdir(gluster_mount_dir, session=session)
# Local variables
virsh_args = {"debug": True}
server_ip = params["server_ip"] = params.get("remote_ip")
server_user = params["server_user"] = params.get("remote_user", "root")
server_pwd = params["server_pwd"] = params.get("remote_pwd")
client_ip = params["client_ip"] = params.get("local_ip")
client_pwd = params["client_pwd"] = params.get("local_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options", "--live --p2p --verbose")
virsh_options = params.get("virsh_options", "")
vol_name = params.get("vol_name")
disk_format = params.get("disk_format", "qcow2")
gluster_mount_dir = params.get("gluster_mount_dir")
status_error = "yes" == params.get("status_error", "no")
err_msg = params.get("err_msg")
host_ip = params.get("gluster_server_ip", "")
migrate_vm_back = params.get("migrate_vm_back", "no") == "yes"
selinux_local = params.get('set_sebool_local', 'yes') == "yes"
selinux_remote = params.get('set_sebool_remote', 'no') == "yes"
sebool_fusefs_local = params.get('set_sebool_fusefs_local', 'yes')
sebool_fusefs_remote = params.get('set_sebool_fusefs_remote', 'yes')
test_dict = dict(params)
test_dict["local_boolean_varible"] = "virt_use_fusefs"
test_dict["remote_boolean_varible"] = "virt_use_fusefs"
remote_dargs = {
'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd,
'file_path': "/etc/libvirt/libvirt.conf"
}
remove_pkg = False
seLinuxBool = None
seLinuxfusefs = None
gluster_uri = None
mig_result = None
remove_dict = {}
remote_libvirt_file = None
src_libvirt_file = None
# Make sure all of parameters are assigned a valid value
migrate_test = migration.MigrationTest()
migrate_test.check_parameters(params)
extra_args = migrate_test.update_virsh_migrate_extra_args(params)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (virsh_options, postcopy_options)
func_name = virsh.migrate_postcopy
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# Back up xml file.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
# Configure selinux
if selinux_local or selinux_remote:
seLinuxBool = utils_misc.SELinuxBoolean(params)
seLinuxBool.setup()
if sebool_fusefs_local or sebool_fusefs_remote:
seLinuxfusefs = utils_misc.SELinuxBoolean(test_dict)
seLinuxfusefs.setup()
# Setup glusterfs
disk_img = "gluster.%s" % disk_format
params['disk_img'] = disk_img
host_ip = gluster.setup_or_cleanup_gluster(is_setup=True, **params)
logging.debug("host ip: %s ", host_ip)
# Check if gluster server is deployed locally
if not host_ip:
logging.debug("Enable port 24007 and 49152:49216")
migrate_test.migrate_pre_setup(src_uri, params, ports="24007")
migrate_test.migrate_pre_setup(src_uri, params)
gluster_uri = "{}:{}".format(client_ip, vol_name)
else:
gluster_uri = "{}:{}".format(host_ip, vol_name)
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if gluster_mount_dir:
# The package 'glusterfs-fuse' is not installed on target
# which makes issue when trying to 'mount -t glusterfs'
pkg_name = 'glusterfs-fuse'
logging.debug("Check if glusterfs-fuse is installed")
pkg_mgr = utils_package.package_manager(remote_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("glusterfs-fuse will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
else:
remove_pkg = True
gluster_img = create_or_clean_backend_dir(gluster_uri, params)
create_or_clean_backend_dir(gluster_uri, params, remote_session)
# Get the image path
image_source = vm.get_first_disk_devices()['source']
image_info = utils_misc.get_image_info(image_source)
if image_info["format"] == disk_format:
disk_cmd = "cp -f %s %s" % (image_source, gluster_img)
else:
# Convert the disk format
disk_cmd = ("qemu-img convert -f %s -O %s %s %s" %
(image_info["format"], disk_format, image_source,
gluster_img))
process.run("%s; chmod a+rw %s" % (disk_cmd, gluster_mount_dir),
shell=True)
logging.debug("Gluster Image is %s", gluster_img)
gluster_backend_disk = {'disk_source_name': gluster_img}
# Update disk xml with gluster image in backend dir
libvirt.set_vm_disk(vm, gluster_backend_disk)
remote_session.close()
vm_xml_cxt = virsh.dumpxml(vm_name).stdout_text.strip()
logging.debug("The VM XML with gluster disk source: \n%s", vm_xml_cxt)
vm.wait_for_login().close()
migrate_test.ping_vm(vm, params)
remove_dict = {"do_search": '{"%s": "ssh:/"}' % dest_uri}
src_libvirt_file = libvirt_config.remove_key_for_modular_daemon(
remove_dict)
vms = [vm]
migrate_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
virsh_opt=virsh_options,
extra_opts=extra,
**extra_args)
migrate_test.ping_vm(vm, params, dest_uri)
if migrate_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migrate_test.migrate_pre_setup(src_uri, params)
remove_dict = {"do_search": ('{"%s": "ssh:/"}' % src_uri)}
remote_libvirt_file = libvirt_config\
.remove_key_for_modular_daemon(remove_dict, remote_dargs)
cmd = "virsh migrate %s %s %s %s" % (vm_name, options,
virsh_options, src_uri)
logging.debug("Start migrating: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
destroy_cmd = "virsh destroy %s" % vm_name
remote.run_remote_cmd(destroy_cmd,
params,
runner_on_target,
ignore_status=False)
test.fail("Failed to run '%s' on remote: %s" %
(cmd, cmd_result))
finally:
logging.info("Recover test environment")
migrate_test.cleanup_vm(vm, dest_uri)
orig_config_xml.sync()
if src_libvirt_file:
src_libvirt_file.restore()
if remote_libvirt_file:
del remote_libvirt_file
# Clean up of pre migration setup for local machine
if migrate_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migrate_test.migrate_pre_setup(src_uri, params, cleanup=True)
# Cleanup selinu configuration
if seLinuxBool:
seLinuxBool.cleanup()
if seLinuxfusefs:
seLinuxfusefs.cleanup()
# Disable ports 24007 and 49152:49216
if not host_ip:
logging.debug("Disable 24007 and 49152:49216 in Firewall")
migrate_test.migrate_pre_setup(src_uri,
params,
cleanup=True,
ports="24007")
migrate_test.migrate_pre_setup(src_uri, params, cleanup=True)
gluster.setup_or_cleanup_gluster(False, **params)
# Cleanup backend directory/symlink
if gluster_mount_dir and gluster_uri:
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
create_or_clean_backend_dir(gluster_uri, params, is_clean=True)
create_or_clean_backend_dir(gluster_uri, params, remote_session,
True)
if remove_pkg:
pkg_mgr = utils_package.package_manager(
remote_session, pkg_name)
if pkg_mgr.is_installed(pkg_name):
logging.debug("glusterfs-fuse will be uninstalled")
if not pkg_mgr.remove():
logging.error("Package '%s' un-installation fails",
pkg_name)
remote_session.close()
def run(test, params, env):
"""
Test command: virsh blockcommit <domain> <path>
1) Prepare test environment.
2) Commit changes from a snapshot down to its backing image.
3) Recover test environment.
4) Check result.
"""
def make_disk_snapshot(postfix_n, snapshot_take, is_check_snapshot_tree=False):
"""
Make external snapshots for disks only.
:param postfix_n: postfix option
:param snapshot_take: snapshots taken.
"""
# Add all disks into command line.
disks = vm.get_disk_devices()
# Make three external snapshots for disks only
for count in range(1, snapshot_take):
options = "%s_%s %s%s-desc " % (postfix_n, count,
postfix_n, count)
options += "--disk-only --atomic --no-metadata"
if needs_agent:
options += " --quiesce"
for disk in disks:
disk_detail = disks[disk]
basename = os.path.basename(disk_detail['source'])
# Remove the original suffix if any, appending
# ".postfix_n[0-9]"
diskname = basename.split(".")[0]
snap_name = "%s.%s%s" % (diskname, postfix_n, count)
disk_external = os.path.join(tmp_dir, snap_name)
snapshot_external_disks.append(disk_external)
options += " %s,snapshot=external,file=%s" % (disk,
disk_external)
if is_check_snapshot_tree:
options = options.replace("--no-metadata", "")
cmd_result = virsh.snapshot_create_as(vm_name, options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
if status != 0:
test.fail("Failed to make snapshots for disks!")
# Create a file flag in VM after each snapshot
flag_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
file_path = flag_file.name
flag_file.close()
status, output = session.cmd_status_output("touch %s" % file_path)
if status:
test.fail("Touch file in vm failed. %s" % output)
snapshot_flag_files.append(file_path)
def check_snapshot_tree():
"""
Check whether predefined snapshot names are equals to
snapshot names by virsh snapshot-list --tree
"""
predefined_snapshot_name_list = []
for count in range(1, snapshot_take):
predefined_snapshot_name_list.append("%s_%s" % (postfix_n, count))
snapshot_list_cmd = "virsh snapshot-list %s --tree" % vm_name
result_output = process.run(snapshot_list_cmd,
ignore_status=True, shell=True).stdout_text
virsh_snapshot_name_list = []
for line in result_output.rsplit("\n"):
strip_line = line.strip()
if strip_line and "|" not in strip_line:
virsh_snapshot_name_list.append(strip_line)
# Compare two lists in their order and values, all need to be same.
compare_list = [out_p for out_p, out_v in zip(predefined_snapshot_name_list, virsh_snapshot_name_list)
if out_p not in out_v]
if compare_list:
test.fail("snapshot tree not correctly returned.")
# If check_snapshot_tree is True, check snapshot tree output.
if is_check_snapshot_tree:
check_snapshot_tree()
def get_first_disk_source():
"""
Get disk source of first device
:return: first disk of first device.
"""
first_device = vm.get_first_disk_devices()
first_disk_src = first_device['source']
return first_disk_src
def make_relative_path_backing_files():
"""
Create backing chain files of relative path.
:return: absolute path of top active file
"""
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
root_dir = os.path.dirname(first_disk_source)
cmd = "mkdir -p %s" % os.path.join(root_dir, '{b..d}')
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
# Make three external relative path backing files.
backing_file_dict = collections.OrderedDict()
backing_file_dict["b"] = "../%s" % basename
backing_file_dict["c"] = "../b/b.img"
backing_file_dict["d"] = "../c/c.img"
for key, value in list(backing_file_dict.items()):
backing_file_path = os.path.join(root_dir, key)
cmd = ("cd %s && qemu-img create -f qcow2 -o backing_file=%s,backing_fmt=qcow2 %s.img"
% (backing_file_path, value, key))
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
return os.path.join(backing_file_path, "d.img")
def check_chain_backing_files(disk_src_file, expect_backing_file=False):
"""
Check backing chain files of relative path after blockcommit.
:param disk_src_file: first disk src file.
:param expect_backing_file: whether it expect to have backing files.
"""
first_disk_source = get_first_disk_source()
# Validate source image need refer to original one after active blockcommit
if not expect_backing_file and disk_src_file not in first_disk_source:
test.fail("The disk image path:%s doesn't include the origin image: %s" % (first_disk_source, disk_src_file))
# Validate source image doesn't have backing files after active blockcommit
cmd = "qemu-img info %s --backing-chain" % first_disk_source
if qemu_img_locking_feature_support:
cmd = "qemu-img info -U %s --backing-chain" % first_disk_source
ret = process.run(cmd, shell=True).stdout_text.strip()
if expect_backing_file:
if 'backing file' not in ret:
test.fail("The disk image doesn't have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
else:
if 'backing file' in ret:
test.fail("The disk image still have backing files")
else:
logging.debug("The actual qemu-img output:%s\n", ret)
# MAIN TEST CODE ###
# Process cartesian parameters
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
snapshot_take = int(params.get("snapshot_take", '0'))
vm_state = params.get("vm_state", "running")
needs_agent = "yes" == params.get("needs_agent", "yes")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
top_inactive = ("yes" == params.get("top_inactive"))
with_timeout = ("yes" == params.get("with_timeout_option", "no"))
status_error = ("yes" == params.get("status_error", "no"))
base_option = params.get("base_option", "none")
middle_base = "yes" == params.get("middle_base", "no")
pivot_opt = "yes" == params.get("pivot_opt", "no")
snap_in_mirror = "yes" == params.get("snap_in_mirror", "no")
snap_in_mirror_err = "yes" == params.get("snap_in_mirror_err", "no")
with_active_commit = "yes" == params.get("with_active_commit", "no")
multiple_chain = "yes" == params.get("multiple_chain", "no")
virsh_dargs = {'debug': True}
check_snapshot_tree = "yes" == params.get("check_snapshot_tree", "no")
# Check whether qemu-img need add -U suboption since locking feature was added afterwards qemu-2.10
qemu_img_locking_feature_support = libvirt_storage.check_qemu_image_lock_support()
backing_file_relative_path = "yes" == params.get("backing_file_relative_path", "no")
# Process domain disk device parameters
disk_type = params.get("disk_type")
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", 'no')
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
if not top_inactive:
if not libvirt_version.version_compare(1, 2, 4):
test.cancel("live active block commit is not supported"
" in current libvirt version.")
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Abort the test if there are snapshots already
exsiting_snaps = virsh.snapshot_list(vm_name)
if len(exsiting_snaps) != 0:
test.fail("There are snapshots created for %s already" %
vm_name)
snapshot_external_disks = []
cmd_session = None
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ''
try:
if disk_src_protocol == 'iscsi' and disk_type == 'network':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
# Set vm xml and guest agent
if replace_vm_disk:
if disk_src_protocol == "rbd" and disk_type == "network":
src_host = params.get("disk_source_host", "EXAMPLE_HOSTS")
mon_host = params.get("mon_host", "EXAMPLE_MON_HOST")
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(mon_host)
if src_host.count("EXAMPLE") or mon_host.count("EXAMPLE"):
test.cancel("Please provide rbd host first.")
if backing_file_relative_path:
if vm.is_alive():
vm.destroy(gracefully=False)
first_src_file = get_first_disk_source()
blk_source_image = os.path.basename(first_src_file)
blk_source_folder = os.path.dirname(first_src_file)
replace_disk_image = make_relative_path_backing_files()
params.update({'disk_source_name': replace_disk_image,
'disk_type': 'file',
'disk_src_protocol': 'file'})
vm.start()
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
# The first disk is supposed to include OS
# We will perform blockcommit operation for it.
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
blk_target = first_disk['target']
snapshot_flag_files = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
postfix_n = 'snap'
make_disk_snapshot(postfix_n, snapshot_take, check_snapshot_tree)
basename = os.path.basename(blk_source)
diskname = basename.split(".")[0]
snap_src_lst = [blk_source]
if multiple_chain:
snap_name = "%s.%s1" % (diskname, postfix_n)
snap_top = os.path.join(tmp_dir, snap_name)
top_index = snapshot_external_disks.index(snap_top) + 1
omit_list = snapshot_external_disks[top_index:]
vm.destroy(gracefully=False)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_xml = ''
disk_xmls = vmxml.get_devices(device_type="disk")
for disk in disk_xmls:
if disk.get('device_tag') == 'disk':
disk_xml = disk
break
vmxml.del_device(disk_xml)
disk_dict = {'attrs': {'file': snap_top}}
disk_xml.source = disk_xml.new_disk_source(**disk_dict)
vmxml.add_device(disk_xml)
vmxml.sync()
vm.start()
session = vm.wait_for_login()
postfix_n = 'new_snap'
make_disk_snapshot(postfix_n, snapshot_take)
snap_src_lst = [blk_source]
snap_src_lst += snapshot_external_disks
logging.debug("omit list is %s", omit_list)
for i in omit_list:
snap_src_lst.remove(i)
else:
# snapshot src file list
snap_src_lst += snapshot_external_disks
backing_chain = ''
for i in reversed(list(range(snapshot_take))):
if i == 0:
backing_chain += "%s" % snap_src_lst[i]
else:
backing_chain += "%s -> " % snap_src_lst[i]
logging.debug("The backing chain is: %s" % backing_chain)
# check snapshot disk xml backingStore is expected
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
disk_xml = None
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
if disk.device != 'disk':
continue
disk_xml = disk.xmltreefile
logging.debug("the target disk xml after snapshot is %s",
disk_xml)
break
if not disk_xml:
test.fail("Can't find disk xml with target %s" %
blk_target)
elif libvirt_version.version_compare(1, 2, 4):
# backingStore element introuduced in 1.2.4
chain_lst = snap_src_lst[::-1]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain check failed")
# set blockcommit_options
top_image = None
blockcommit_options = "--wait --verbose"
if with_timeout:
blockcommit_options += " --timeout 1"
if base_option == "shallow":
blockcommit_options += " --shallow"
elif base_option == "base":
if middle_base:
snap_name = "%s.%s1" % (diskname, postfix_n)
blk_source = os.path.join(tmp_dir, snap_name)
blockcommit_options += " --base %s" % blk_source
if top_inactive:
snap_name = "%s.%s2" % (diskname, postfix_n)
top_image = os.path.join(tmp_dir, snap_name)
blockcommit_options += " --top %s" % top_image
else:
blockcommit_options += " --active"
if pivot_opt:
blockcommit_options += " --pivot"
if vm_state == "shut off":
vm.destroy(gracefully=True)
if with_active_commit:
# inactive commit follow active commit will fail with bug 1135339
cmd = "virsh blockcommit %s %s --active --pivot" % (vm_name,
blk_target)
cmd_session = aexpect.ShellSession(cmd)
if backing_file_relative_path:
blockcommit_options = " --active --verbose --shallow --pivot --keep-relative"
block_commit_index = snapshot_take
expect_backing_file = False
# Do block commit using --active
for count in range(1, snapshot_take):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
if top_inactive:
blockcommit_options = " --wait --verbose --top vda[1] --base vda[2] --keep-relative"
block_commit_index = snapshot_take - 1
expect_backing_file = True
# Do block commit with --wait if top_inactive
for count in range(1, block_commit_index):
res = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
check_chain_backing_files(blk_source_image, expect_backing_file)
return
# Run test case
# Active commit does not support on rbd based disk with bug 1200726
result = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
# Check status_error
libvirt.check_exit_status(result, status_error)
if result.exit_status and status_error:
return
while True:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
for disk in disks:
if disk.target['dev'] != blk_target:
continue
else:
disk_xml = disk.xmltreefile
break
if not top_inactive:
disk_mirror = disk_xml.find('mirror')
if '--pivot' not in blockcommit_options:
if disk_mirror is not None:
job_type = disk_mirror.get('job')
job_ready = disk_mirror.get('ready')
src_element = disk_mirror.find('source')
disk_src_file = None
for elem in ('file', 'name', 'dev'):
elem_val = src_element.get(elem)
if elem_val:
disk_src_file = elem_val
break
err_msg = "blockcommit base source "
err_msg += "%s not expected" % disk_src_file
if '--shallow' in blockcommit_options:
if not multiple_chain:
if disk_src_file != snap_src_lst[2]:
test.fail(err_msg)
else:
if disk_src_file != snap_src_lst[3]:
test.fail(err_msg)
else:
if disk_src_file != blk_source:
test.fail(err_msg)
if libvirt_version.version_compare(1, 2, 7):
# The job attribute mentions which API started the
# operation since 1.2.7.
if job_type != 'active-commit':
test.fail("blockcommit job type '%s'"
" not expected" % job_type)
if job_ready != 'yes':
# The attribute ready, if present, tracks
# progress of the job: yes if the disk is known
# to be ready to pivot, or, since 1.2.7, abort
# or pivot if the job is in the process of
# completing.
continue
else:
logging.debug("after active block commit job "
"ready for pivot, the target disk"
" xml is %s", disk_xml)
break
else:
break
else:
break
else:
if disk_mirror is None:
logging.debug(disk_xml)
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.pop(0)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing "
"chain check failed")
cmd_result = virsh.blockjob(vm_name, blk_target, '',
ignore_status=True, debug=True)
libvirt.check_exit_status(cmd_result)
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
base_index = chain_lst.index(blk_source)
chain_lst = chain_lst[base_index:]
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing "
"chain check failed")
break
else:
# wait pivot after commit is synced
continue
else:
logging.debug("after inactive commit the disk xml is: %s"
% disk_xml)
if libvirt_version.version_compare(1, 2, 4):
if "--shallow" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
chain_lst.remove(top_image)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain "
"check failed")
elif "--base" in blockcommit_options:
chain_lst = snap_src_lst[::-1]
top_index = chain_lst.index(top_image)
base_index = chain_lst.index(blk_source)
val_tmp = []
for i in range(top_index, base_index):
val_tmp.append(chain_lst[i])
for i in val_tmp:
chain_lst.remove(i)
ret = check_chain_xml(disk_xml, chain_lst)
if not ret:
test.fail("Domain image backing chain "
"check failed")
break
else:
break
# Check flag files
if not vm_state == "shut off" and not multiple_chain:
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
test.fail("blockcommit failed: %s" % output)
if not pivot_opt and snap_in_mirror:
# do snapshot during mirror phase
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
snapshot_external_disks.append(snap_path)
cmd_result = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
libvirt.check_exit_status(cmd_result, snap_in_mirror_err)
finally:
# Remove ceph configure file if created
if ceph_cfg:
os.remove(ceph_cfg)
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
# Clean ceph image if used in test
if 'mon_host' in locals():
if utils_package.package_install(["ceph-common"]):
disk_source_name = params.get("disk_source_name")
cmd = ("rbd -m {0} info {1} && rbd -m {0} rm "
"{1}".format(mon_host, disk_source_name))
cmd_result = process.run(cmd, ignore_status=True, shell=True)
logging.debug("result of rbd removal: %s", cmd_result)
else:
logging.debug('Failed to install ceph-common to clean ceph.')
if cmd_session:
cmd_session.close()
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
if backing_file_relative_path:
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
process.run("cd %s && rm -rf b c d" % blk_source_folder, shell=True)
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
libvirt.setup_or_cleanup_gluster(False, vol_name, brick_path)
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
elif disk_src_protocol == 'netfs':
restore_selinux = params.get('selinux_status_bak')
libvirt.setup_or_cleanup_nfs(is_setup=False,
restore_selinux=restore_selinux)
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
def check_file_own(file_path, exp_uid, exp_gid):
"""
Check the uid and gid of file_path
:param file_path: The file path
:param exp_uid: The expected uid
:param exp_gid: The expected gid
:raise: test.fail if the uid and gid of file are not expected
"""
fstat_res = os.stat(file_path)
if fstat_res.st_uid != exp_uid or fstat_res.st_gid != exp_gid:
test.fail("The uid.gid {}.{} is not expected, it should be {}.{}.".
format(fstat_res.st_uid, fstat_res.st_gid, exp_uid,
exp_gid))
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
time_before_save = int(params.get('time_before_save', 0))
setup_nfs = "yes" == params.get("setup_nfs", "no")
setup_iscsi = "yes" == params.get("setup_iscsi", "no")
check_log = params.get("check_log")
check_str_not_in_log = params.get("check_str_not_in_log")
qemu_conf_dict = eval(params.get("qemu_conf_dict", "{}"))
vm_ref_uid = None
vm_ref_gid = None
qemu_conf = None
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
try:
if "--xml" in extra_param:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name,
options="--migratable")
backup_xml = vmxml.copy()
# Grant more priveledge on the file in order for un-priveledge user
# to access.
os.chmod(vmxml.xml, stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
if not setup_nfs:
extra_param = "--xml %s" % vmxml.xml
dict_os_attrs = {}
if "hd" in vmxml.os.boots:
dict_os_attrs.update({"boots": ["cdrom"]})
vmxml.set_os_attrs(**dict_os_attrs)
else:
test.cancel("Please add 'hd' in boots for --xml testing")
logging.info("vmxml os is %s after update" %
vmxml.os.xmltreefile)
else:
params["mnt_path_name"] = params.get("nfs_mount_dir")
vm_ref_uid = params["change_file_uid"] = pwd.getpwnam(
"qemu").pw_uid
vm_ref_gid = params["change_file_gid"] = grp.getgrnam(
"qemu").gr_gid
libvirt.set_vm_disk(vm, params)
session = vm.wait_for_login()
# Clear log file
if check_log:
cmd = "> %s" % check_log
process.run(cmd, shell=True, verbose=True)
if qemu_conf_dict:
logging.debug("Update qemu configuration file.")
qemu_conf = libvirt.customize_libvirt_config(
qemu_conf_dict, "qemu")
process.run("cat /etc/libvirt/qemu.conf", shell=True, verbose=True)
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref,
extra_param,
debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
test.fail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(data_dir.get_tmp_dir(), "save.file")
if setup_iscsi:
tmp_file = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size='1G')
time.sleep(time_before_save)
ret = virsh.save(vm_name, tmp_file, debug=True)
libvirt.check_exit_status(ret)
if vm_ref == "saved_file" or setup_iscsi:
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(data_dir.get_tmp_dir(), "new.file")
with open(tmp_file, 'w') as tmp:
pass
vm_ref = tmp_file
# Change the ownership of the saved file
if vm_ref_uid and vm_ref_gid:
os.chown(vm_ref, vm_ref_uid, vm_ref_gid)
tmpdir = data_dir.get_tmp_dir()
dump_xml = os.path.join(tmpdir, "test.xml")
virsh.save_image_dumpxml(vm_ref, "> %s" % dump_xml)
extra_param = "--xml %s" % dump_xml
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref,
extra_param,
debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(
5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("Run successfully with wrong command!")
else:
if status:
test.fail("Run failed with right command")
if not re.search(vm_name, list_output):
test.fail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
if (extra_param.count("running") or extra_param.count("xml")
or not extra_param):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be" " running after restore")
if extra_param.count("xml"):
if not setup_nfs:
aft_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
boots_list = aft_vmxml.os.boots
if "hd" in boots_list or "cdrom" not in boots_list:
test.fail("Update xml with restore failed")
else:
if vm_ref_uid and vm_ref_gid:
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
vm.destroy()
check_file_own(vm_ref, vm_ref_uid, vm_ref_gid)
if check_str_not_in_log and check_log:
libvirt.check_logfile(check_str_not_in_log, check_log, False)
finally:
if vm.is_paused():
virsh.resume(vm_name)
if "--xml" in extra_param:
backup_xml.sync()
if setup_nfs:
libvirt.setup_or_cleanup_nfs(is_setup=False,
mount_dir=params.get("mnt_path_name"),
export_dir=params.get("export_dir"),
rm_export_dir=False)
if setup_iscsi:
libvirt.setup_or_cleanup_iscsi(False)
def run(test, params, env):
"""
Test virsh snapshot command when disk in all kinds of type.
(1). Init the variables from params.
(2). Create a image by specifice format.
(3). Attach disk to vm.
(4). Snapshot create.
(5). Snapshot revert.
(6). cleanup.
"""
# Init variables.
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
vm_state = params.get("vm_state", "running")
image_format = params.get("snapshot_image_format", "qcow2")
snapshot_del_test = "yes" == params.get("snapshot_del_test", "no")
status_error = ("yes" == params.get("status_error", "no"))
snapshot_from_xml = ("yes" == params.get("snapshot_from_xml", "no"))
snapshot_current = ("yes" == params.get("snapshot_current", "no"))
snapshot_revert_paused = ("yes" == params.get("snapshot_revert_paused",
"no"))
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
multi_gluster_disks = "yes" == params.get("multi_gluster_disks", "no")
# Pool variables.
snapshot_with_pool = "yes" == params.get("snapshot_with_pool", "no")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
emulated_image = params.get("emulated_image", "emulated-image")
vol_format = params.get("vol_format")
lazy_refcounts = "yes" == params.get("lazy_refcounts")
options = params.get("snapshot_options", "")
export_options = params.get("export_options", "rw,no_root_squash")
# Set volume xml attribute dictionary, extract all params start with 'vol_'
# which are for setting volume xml, except 'lazy_refcounts'.
vol_arg = {}
for key in list(params.keys()):
if key.startswith('vol_'):
if key[4:] in ['capacity', 'allocation', 'owner', 'group']:
vol_arg[key[4:]] = int(params[key])
else:
vol_arg[key[4:]] = params[key]
vol_arg['lazy_refcounts'] = lazy_refcounts
supported_pool_list = ["dir", "fs", "netfs", "logical", "iscsi",
"disk", "gluster"]
if snapshot_with_pool:
if pool_type not in supported_pool_list:
test.cancel("%s not in support list %s" %
(pool_target, supported_pool_list))
# Do xml backup for final recovery
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Some variable for xmlfile of snapshot.
snapshot_memory = params.get("snapshot_memory", "internal")
snapshot_disk = params.get("snapshot_disk", "internal")
no_memory_snap = "yes" == params.get("no_memory_snap", "no")
# Skip 'qed' cases for libvirt version greater than 1.1.0
if libvirt_version.version_compare(1, 1, 0):
if vol_format == "qed" or image_format == "qed":
test.cancel("QED support changed, check bug: "
"https://bugzilla.redhat.com/show_bug.cgi"
"?id=731570")
if not libvirt_version.version_compare(1, 2, 7):
# As bug 1017289 closed as WONTFIX, the support only
# exist on 1.2.7 and higher
if disk_source_protocol == 'gluster':
test.cancel("Snapshot on glusterfs not support in "
"current version. Check more info with "
"https://bugzilla.redhat.com/buglist.cgi?"
"bug_id=1017289,1032370")
# Init snapshot_name
snapshot_name = None
snapshot_external_disk = []
snapshot_xml_path = None
del_status = None
image = None
pvt = None
# Get a tmp dir
snap_cfg_path = "/var/lib/libvirt/qemu/snapshot/%s/" % vm_name
try:
if replace_vm_disk:
utlv.set_vm_disk(vm, params, tmp_dir)
if multi_gluster_disks:
new_params = params.copy()
new_params["pool_name"] = "gluster-pool2"
new_params["vol_name"] = "gluster-vol2"
new_params["disk_target"] = "vdf"
new_params["image_convert"] = 'no'
utlv.set_vm_disk(vm, new_params, tmp_dir)
if snapshot_with_pool:
# Create dst pool for create attach vol img
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name, pool_type, pool_target,
emulated_image, image_size="1G",
pre_disk_vol=["20M"],
source_name=vol_name,
export_options=export_options)
if pool_type in ["iscsi", "disk"]:
# iscsi and disk pool did not support create volume in libvirt,
# logical pool could use libvirt to create volume but volume
# format is not supported and will be 'raw' as default.
pv = libvirt_storage.PoolVolume(pool_name)
vols = list(pv.list_volumes().keys())
if vols:
vol_name = vols[0]
else:
test.cancel("No volume in pool: %s" % pool_name)
else:
# Set volume xml file
volxml = libvirt_xml.VolXML()
newvol = volxml.new_vol(**vol_arg)
vol_xml = newvol['xml']
# Run virsh_vol_create to create vol
logging.debug("create volume from xml: %s" % newvol.xmltreefile)
cmd_result = virsh.vol_create(pool_name, vol_xml,
ignore_status=True,
debug=True)
if cmd_result.exit_status:
test.cancel("Failed to create attach volume.")
cmd_result = virsh.vol_path(vol_name, pool_name, debug=True)
if cmd_result.exit_status:
test.cancel("Failed to get volume path from pool.")
img_path = cmd_result.stdout.strip()
if pool_type in ["logical", "iscsi", "disk"]:
# Use qemu-img to format logical, iscsi and disk block device
if vol_format != "raw":
cmd = "qemu-img create -f %s %s 10M" % (vol_format,
img_path)
cmd_result = process.run(cmd, ignore_status=True, shell=True)
if cmd_result.exit_status:
test.cancel("Failed to format volume, %s" %
cmd_result.stdout_text.strip())
extra = "--persistent --subdriver %s" % vol_format
else:
# Create a image.
params['image_name'] = "snapshot_test"
params['image_format'] = image_format
params['image_size'] = "1M"
image = qemu_storage.QemuImg(params, tmp_dir, "snapshot_test")
img_path, _ = image.create(params)
extra = "--persistent --subdriver %s" % image_format
if not multi_gluster_disks:
# Do the attach action.
out = process.run("qemu-img info %s" % img_path, shell=True)
logging.debug("The img info is:\n%s" % out.stdout.strip())
result = virsh.attach_disk(vm_name, source=img_path, target="vdf",
extra=extra, debug=True)
if result.exit_status:
test.cancel("Failed to attach disk %s to VM."
"Detail: %s." % (img_path, result.stderr))
# Create snapshot.
if snapshot_from_xml:
snap_xml = libvirt_xml.SnapshotXML()
snapshot_name = "snapshot_test"
snap_xml.snap_name = snapshot_name
snap_xml.description = "Snapshot Test"
if not no_memory_snap:
if "--disk-only" not in options:
if snapshot_memory == "external":
memory_external = os.path.join(tmp_dir,
"snapshot_memory")
snap_xml.mem_snap_type = snapshot_memory
snap_xml.mem_file = memory_external
snapshot_external_disk.append(memory_external)
else:
snap_xml.mem_snap_type = snapshot_memory
# Add all disks into xml file.
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
# Remove non-storage disk such as 'cdrom'
for disk in disks:
if disk.device != 'disk':
disks.remove(disk)
new_disks = []
for src_disk_xml in disks:
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = snapshot_disk
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
if snapshot_disk == 'external':
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
new_file = "%s.snap" % disk_xml.source.attrs['file']
snapshot_external_disk.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif 'name' in disk_xml.source.attrs:
new_name = "%s.snap" % disk_xml.source.attrs['name']
new_attrs.update({'name': new_name})
hosts = disk_xml.source.hosts
elif ('dev' in disk_xml.source.attrs and
disk_xml.type_name == 'block'):
# Use local file as external snapshot target for block type.
# As block device will be treat as raw format by default,
# it's not fit for external disk snapshot target. A work
# around solution is use qemu-img again with the target.
disk_xml.type_name = 'file'
del new_attrs['dev']
new_file = "%s/blk_src_file.snap" % tmp_dir
snapshot_external_disk.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
else:
del disk_xml.source
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options += " --xmlfile %s " % snapshot_xml_path
if vm_state == "shut off":
vm.destroy(gracefully=False)
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
out_err = snapshot_result.stderr.strip()
if snapshot_result.exit_status:
if status_error:
return
else:
if re.search("live disk snapshot not supported with this "
"QEMU binary", out_err):
test.cancel(out_err)
if libvirt_version.version_compare(1, 2, 5):
# As commit d2e668e in 1.2.5, internal active snapshot
# without memory state is rejected. Handle it as SKIP
# for now. This could be supportted in future by bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1103063
if re.search("internal snapshot of a running VM" +
" must include the memory state",
out_err):
test.cancel("Check Bug #1083345, %s" %
out_err)
test.fail("Failed to create snapshot. Error:%s."
% out_err)
else:
snapshot_result = virsh.snapshot_create(vm_name, options,
debug=True)
if snapshot_result.exit_status:
if status_error:
return
else:
test.fail("Failed to create snapshot. Error:%s."
% snapshot_result.stderr.strip())
snapshot_name = re.search(
"\d+", snapshot_result.stdout.strip()).group(0)
if snapshot_current:
snap_xml = libvirt_xml.SnapshotXML()
new_snap = snap_xml.new_from_snapshot_dumpxml(vm_name,
snapshot_name)
# update an element
new_snap.creation_time = snapshot_name
snapshot_xml_path = new_snap.xml
options += "--redefine %s --current" % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options, debug=True)
if snapshot_result.exit_status:
test.fail("Failed to create snapshot --current."
"Error:%s." %
snapshot_result.stderr.strip())
if status_error:
if not snapshot_del_test:
test.fail("Success to create snapshot in negative"
" case\nDetail: %s" % snapshot_result)
# Touch a file in VM.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
# Init a unique name for tmp_file.
tmp_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
tmp_file_path = tmp_file.name
tmp_file.close()
echo_cmd = "echo SNAPSHOT_DISK_TEST >> %s" % tmp_file_path
status, output = session.cmd_status_output(echo_cmd)
logging.debug("The echo output in domain is: '%s'", output)
if status:
test.fail("'%s' run failed with '%s'" %
(tmp_file_path, output))
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("File created with content: '%s'", output)
session.close()
# As only internal snapshot revert works now, let's only do revert
# with internal, and move the all skip external cases back to pass.
# After external also supported, just move the following code back.
if snapshot_disk == 'internal':
# Destroy vm for snapshot revert.
if not libvirt_version.version_compare(1, 2, 3):
virsh.destroy(vm_name)
# Revert snapshot.
revert_options = ""
if snapshot_revert_paused:
revert_options += " --paused"
revert_result = virsh.snapshot_revert(vm_name, snapshot_name,
revert_options,
debug=True)
if revert_result.exit_status:
# Attempts to revert external snapshots will FAIL with an error
# "revert to external disk snapshot not supported yet" or "revert
# to external snapshot not supported yet" since d410e6f. Thus,
# let's check for that and handle as a SKIP for now. Check bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1071264
if re.search("revert to external \w* ?snapshot not supported yet",
revert_result.stderr):
test.cancel(revert_result.stderr.strip())
else:
test.fail("Revert snapshot failed. %s" %
revert_result.stderr.strip())
if vm.is_dead():
test.fail("Revert snapshot failed.")
if snapshot_revert_paused:
if vm.is_paused():
vm.resume()
else:
test.fail("Revert command successed, but VM is not "
"paused after reverting with --paused"
" option.")
# login vm.
session = vm.wait_for_login()
# Check the result of revert.
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("After revert cat file output='%s'", output)
if not status:
test.fail("Tmp file exists, revert failed.")
# Close the session.
session.close()
# Test delete snapshot without "--metadata", delete external disk
# snapshot will fail for now.
# Only do this when snapshot creat succeed which filtered in cfg file.
if snapshot_del_test:
if snapshot_name:
del_result = virsh.snapshot_delete(vm_name, snapshot_name,
debug=True,
ignore_status=True)
del_status = del_result.exit_status
snap_xml_path = snap_cfg_path + "%s.xml" % snapshot_name
if del_status:
if not status_error:
test.fail("Failed to delete snapshot.")
else:
if not os.path.exists(snap_xml_path):
test.fail("Snapshot xml file %s missing"
% snap_xml_path)
else:
if status_error:
err_msg = "Snapshot delete succeed but expect fail."
test.fail(err_msg)
else:
if os.path.exists(snap_xml_path):
test.fail("Snapshot xml file %s still"
% snap_xml_path + " exist")
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
virsh.detach_disk(vm_name, target="vdf", extra="--persistent")
if image:
image.remove()
if del_status and snapshot_name:
virsh.snapshot_delete(vm_name, snapshot_name, "--metadata")
for disk in snapshot_external_disk:
if os.path.exists(disk):
os.remove(disk)
vmxml_backup.sync("--snapshots-metadata")
libvirtd = utils_libvirtd.Libvirtd()
if disk_source_protocol == 'gluster':
utlv.setup_or_cleanup_gluster(False, vol_name, brick_path)
if multi_gluster_disks:
brick_path = os.path.join(tmp_dir, "gluster-pool2")
utlv.setup_or_cleanup_gluster(False, "gluster-vol2", brick_path)
libvirtd.restart()
if snapshot_xml_path:
if os.path.exists(snapshot_xml_path):
os.unlink(snapshot_xml_path)
if pvt:
try:
pvt.cleanup_pool(pool_name, pool_type, pool_target,
emulated_image, source_name=vol_name)
except exceptions.TestFail as detail:
libvirtd.restart()
logging.error(str(detail))
def run(test, params, env):
"""
Test snapshot-create-as command
Make sure that the clean repo can be used because qemu-guest-agent need to
be installed in guest
The command create a snapshot (disk and RAM) from arguments which including
the following point
* virsh snapshot-create-as --print-xml --diskspec --name --description
* virsh snapshot-create-as --print-xml with multi --diskspec
* virsh snapshot-create-as --print-xml --memspec
* virsh snapshot-create-as --description
* virsh snapshot-create-as --no-metadata
* virsh snapshot-create-as --no-metadata --print-xml (negative test)
* virsh snapshot-create-as --atomic --disk-only
* virsh snapshot-create-as --quiesce --disk-only (positive and negative)
* virsh snapshot-create-as --reuse-external
* virsh snapshot-create-as --disk-only --diskspec
* virsh snapshot-create-as --memspec --reuse-external --atomic(negative)
* virsh snapshot-create-as --disk-only and --memspec (negative)
* Create multi snapshots with snapshot-create-as
* Create snapshot with name a--a a--a--snap1
"""
if not virsh.has_help_command('snapshot-create-as'):
test.cancel("This version of libvirt does not support "
"the snapshot-create-as test")
vm_name = params.get("main_vm")
status_error = params.get("status_error", "no")
options = params.get("snap_createas_opts")
multi_num = params.get("multi_num", "1")
diskspec_num = params.get("diskspec_num", "1")
bad_disk = params.get("bad_disk")
reuse_external = "yes" == params.get("reuse_external", "no")
start_ga = params.get("start_ga", "yes")
domain_state = params.get("domain_state")
memspec_opts = params.get("memspec_opts")
config_format = "yes" == params.get("config_format", "no")
snapshot_image_format = params.get("snapshot_image_format")
diskspec_opts = params.get("diskspec_opts")
create_autodestroy = 'yes' == params.get("create_autodestroy", "no")
unix_channel = "yes" == params.get("unix_channel", "yes")
dac_denial = "yes" == params.get("dac_denial", "no")
check_json_no_savevm = "yes" == params.get("check_json_no_savevm", "no")
disk_snapshot_attr = params.get('disk_snapshot_attr', 'external')
set_snapshot_attr = "yes" == params.get("set_snapshot_attr", "no")
# gluster related params
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_src_protocol = params.get("disk_source_protocol")
restart_tgtd = params.get("restart_tgtd", "no")
vol_name = params.get("vol_name")
tmp_dir = data_dir.get_tmp_dir()
pool_name = params.get("pool_name", "gluster-pool")
brick_path = os.path.join(tmp_dir, pool_name)
uri = params.get("virsh_uri")
usr = params.get('unprivileged_user')
if usr:
if usr.count('EXAMPLE'):
usr = '******'
if disk_src_protocol == 'iscsi':
if not libvirt_version.version_compare(1, 0, 4):
test.cancel("'iscsi' disk doesn't support in"
" current libvirt version.")
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
if not libvirt_version.version_compare(1, 2, 7):
# As bug 1017289 closed as WONTFIX, the support only
# exist on 1.2.7 and higher
if disk_src_protocol == 'gluster':
test.cancel("Snapshot on glusterfs not support in "
"current version. Check more info with "
"https://bugzilla.redhat.com/buglist.cgi?"
"bug_id=1017289,1032370")
if libvirt_version.version_compare(5, 5, 0):
# libvirt-5.5.0-2 commit 68e1a05f starts to allow --no-metadata and
# --print-xml to be used together.
if "--no-metadata" in options and "--print-xml" in options:
logging.info("--no-metadata and --print-xml can be used together "
"in this libvirt version. Not expecting a failure.")
status_error = "no"
opt_names = locals()
if memspec_opts is not None:
mem_options = compose_disk_options(test, params, memspec_opts)
# if the parameters have the disk without "file=" then we only need to
# add testdir for it.
if mem_options is None:
mem_options = os.path.join(data_dir.get_tmp_dir(), memspec_opts)
options += " --memspec " + mem_options
tag_diskspec = 0
dnum = int(diskspec_num)
if diskspec_opts is not None:
tag_diskspec = 1
opt_names['diskopts_1'] = diskspec_opts
# diskspec_opts[n] is used in cfg when more than 1 --diskspec is used
if dnum > 1:
tag_diskspec = 1
for i in range(1, dnum + 1):
opt_names["diskopts_%s" % i] = params.get("diskspec_opts%s" % i)
if tag_diskspec == 1:
for i in range(1, dnum + 1):
disk_options = compose_disk_options(test, params,
opt_names["diskopts_%s" % i])
options += " --diskspec " + disk_options
logging.debug("options are %s", options)
vm = env.get_vm(vm_name)
option_dict = {}
option_dict = utils_misc.valued_option_dict(options, r' --(?!-)')
logging.debug("option_dict is %s", option_dict)
# A backup of original vm
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("original xml is %s", vmxml_backup)
# Generate empty image for negative test
if bad_disk is not None:
bad_disk = os.path.join(data_dir.get_tmp_dir(), bad_disk)
with open(bad_disk, 'w') as bad_file:
pass
# Generate external disk
if reuse_external:
disk_path = ''
for i in range(dnum):
external_disk = "external_disk%s" % i
if params.get(external_disk):
disk_path = os.path.join(data_dir.get_tmp_dir(),
params.get(external_disk))
process.run("qemu-img create -f qcow2 %s 1G" % disk_path,
shell=True)
# Only chmod of the last external disk for negative case
if dac_denial:
process.run("chmod 500 %s" % disk_path, shell=True)
qemu_conf = None
libvirtd_conf = None
libvirtd_log_path = None
libvirtd = utils_libvirtd.Libvirtd()
try:
# Config "snapshot_image_format" option in qemu.conf
if config_format:
qemu_conf = utils_config.LibvirtQemuConfig()
qemu_conf.snapshot_image_format = snapshot_image_format
logging.debug("the qemu config file content is:\n %s" % qemu_conf)
libvirtd.restart()
if check_json_no_savevm:
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_level"] = '1'
libvirtd_conf["log_filters"] = '"1:json 3:remote 4:event"'
libvirtd_log_path = os.path.join(data_dir.get_tmp_dir(),
"libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd.restart()
if replace_vm_disk:
libvirt.set_vm_disk(vm, params, tmp_dir)
if set_snapshot_attr:
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_new = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_xml = vmxml_backup.get_devices(device_type="disk")[0]
vmxml_new.del_device(disk_xml)
# set snapshot attribute in disk xml
disk_xml.snapshot = disk_snapshot_attr
new_disk = disk.Disk(type_name='file')
new_disk.xmltreefile = disk_xml.xmltreefile
vmxml_new.add_device(new_disk)
logging.debug("The vm xml now is: %s" % vmxml_new.xmltreefile)
vmxml_new.sync()
vm.start()
# Start qemu-ga on guest if have --quiesce
if unix_channel and options.find("quiesce") >= 0:
vm.prepare_guest_agent()
session = vm.wait_for_login()
if start_ga == "no":
# The qemu-ga could be running and should be killed
session.cmd("kill -9 `pidof qemu-ga`")
# Check if the qemu-ga get killed
stat_ps = session.cmd_status("ps aux |grep [q]emu-ga")
if not stat_ps:
# As managed by systemd and set as autostart, qemu-ga
# could be restarted, so use systemctl to stop it.
session.cmd("systemctl stop qemu-guest-agent")
stat_ps = session.cmd_status("ps aux |grep [q]emu-ga")
if not stat_ps:
test.cancel("Fail to stop agent in " "guest")
if domain_state == "paused":
virsh.suspend(vm_name)
else:
# Remove channel if exist
if vm.is_alive():
vm.destroy(gracefully=False)
xml_inst = vm_xml.VMXML.new_from_dumpxml(vm_name)
xml_inst.remove_agent_channels()
vm.start()
# Record the previous snapshot-list
snaps_before = virsh.snapshot_list(vm_name)
# Attach disk before create snapshot if not print xml and multi disks
# specified in cfg
if dnum > 1 and "--print-xml" not in options:
for i in range(1, dnum):
disk_path = os.path.join(data_dir.get_tmp_dir(),
'disk%s.qcow2' % i)
process.run("qemu-img create -f qcow2 %s 200M" % disk_path,
shell=True)
virsh.attach_disk(vm_name,
disk_path,
'vd%s' % list(string.ascii_lowercase)[i],
debug=True)
# Run virsh command
# May create several snapshots, according to configuration
for count in range(int(multi_num)):
if create_autodestroy:
# Run virsh command in interactive mode
vmxml_backup.undefine()
vp = virsh.VirshPersistent()
vp.create(vmxml_backup['xml'], '--autodestroy')
cmd_result = vp.snapshot_create_as(vm_name,
options,
ignore_status=True,
debug=True)
vp.close_session()
vmxml_backup.define()
else:
cmd_result = virsh.snapshot_create_as(vm_name,
options,
unprivileged_user=usr,
uri=uri,
ignore_status=True,
debug=True)
# for multi snapshots without specific snapshot name, the
# snapshot name is using time string with 1 second
# incremental, to avoid get snapshot failure with same name,
# sleep 1 second here.
if int(multi_num) > 1:
time.sleep(1.1)
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# check status_error
if status_error == "yes":
if status == 0:
test.fail("Run successfully with wrong command!")
else:
# Check memspec file should be removed if failed
if (options.find("memspec") >= 0
and options.find("atomic") >= 0):
if os.path.isfile(option_dict['memspec']):
os.remove(option_dict['memspec'])
test.fail("Run failed but file %s exist" %
option_dict['memspec'])
else:
logging.info("Run failed as expected and memspec"
" file already been removed")
# Check domain xml is not updated if reuse external fail
elif reuse_external and dac_denial:
output = virsh.dumpxml(vm_name).stdout.strip()
if "reuse_external" in output:
test.fail("Domain xml should not be "
"updated with snapshot image")
else:
logging.info("Run failed as expected")
elif status_error == "no":
if status != 0:
test.fail("Run failed with right command: %s" % output)
else:
# Check the special options
snaps_list = virsh.snapshot_list(vm_name)
logging.debug("snaps_list is %s", snaps_list)
check_snapslist(test, vm_name, options, option_dict,
output, snaps_before, snaps_list)
# For cover bug 872292
if check_json_no_savevm:
pattern = "The command savevm has not been found"
with open(libvirtd_log_path) as f:
for line in f:
if pattern in line and "error" in line:
test.fail("'%s' was found: %s" %
(pattern, line))
finally:
if vm.is_alive():
vm.destroy()
# recover domain xml
xml_recover(vmxml_backup)
path = "/var/lib/libvirt/qemu/snapshot/" + vm_name
if os.path.isfile(path):
test.fail("Still can find snapshot metadata")
if disk_src_protocol == 'gluster':
gluster.setup_or_cleanup_gluster(False,
brick_path=brick_path,
**params)
libvirtd.restart()
if disk_src_protocol == 'iscsi':
libvirt.setup_or_cleanup_iscsi(False, restart_tgtd=restart_tgtd)
# rm bad disks
if bad_disk is not None:
os.remove(bad_disk)
# rm attach disks and reuse external disks
if dnum > 1 and "--print-xml" not in options:
for i in range(dnum):
disk_path = os.path.join(data_dir.get_tmp_dir(),
'disk%s.qcow2' % i)
if os.path.exists(disk_path):
os.unlink(disk_path)
if reuse_external:
external_disk = "external_disk%s" % i
disk_path = os.path.join(data_dir.get_tmp_dir(),
params.get(external_disk))
if os.path.exists(disk_path):
os.unlink(disk_path)
# restore config
if config_format and qemu_conf:
qemu_conf.restore()
if libvirtd_conf:
libvirtd_conf.restore()
if libvirtd_conf or (config_format and qemu_conf):
libvirtd.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
relative_path = params.get("relative_path")
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
if bandwidth_byte and not libvirt_version.version_compare(1, 3, 3):
raise exceptions.TestSkipError("--bytes option not supported in "
"current version")
if relative_path == "yes" and not libvirt_version.version_compare(3, 0, 0):
test.cancel("Forbid using relative path or file name only is added since libvirt-3.0.0")
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" % (target,
vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
options += " --bytes"
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(data_dir.get_tmp_dir(), "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" % (dest_path,
expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
This is a specific bug verify, so ignore status_error here.
"""
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
def _make_snapshot():
"""
Make external disk snapshot
"""
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
# Remove non-storage disk such as 'cdrom'
for disk in disks:
if disk.device != 'disk':
disks.remove(disk)
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
new_file = os.path.join(tmp_dir, "blockcopy_shallow.snap")
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('dev' in disk_xml.source.attrs or
'name' in disk_xml.source.attrs or
'pool' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block' or
disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
elif 'pool' in new_attrs:
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
nfs_cleanup = False
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
# Make sure the new disk show up
utils_misc.wait_for(lambda: os.path.exists(dest_path), 5)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
if disk_source_protocol == 'iscsi':
emulated_iscsi.append(emu_image)
if disk_source_protocol == 'netfs':
nfs_cleanup = True
utl.set_vm_disk(vm, params, tmp_dir, test)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow:
_make_snapshot()
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine("--nvram")
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command to create destination file
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail: %s" %
cmd_result.stdout.strip() + cmd_result.stderr)
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
# Run the real testing command
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
# check BZ#1197592
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
if options.count('--bytes'):
bandwidth += 'B'
else:
bandwidth += 'M'
if not utl.check_blockjob(vm_name, target, "bandwidth",
bandwidth):
raise exceptions.TestFail("Check bandwidth failed")
val = options.count("--pivot") + options.count("--finish")
# Don't wait for job finish when using --byte option
val += options.count('--bytes')
if val == 0:
try:
finish_job(vm_name, target, timeout)
except JobTimeout as excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
else:
raise exceptions.TestFail(cmd_result.stdout.strip() + cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
# Commit id '4c297728' changed how virsh exits when
# unexpectedly failing due to timeout from a fail (1)
# to a success(0), so we need to look for a different
# marker to indicate the copy aborted. As "stdout: Now
# in mirroring phase" could be in stdout which fail the
# check, so also do check in libvirtd log to confirm.
if options.count("--timeout") and options.count("--wait"):
log_pattern = "Copy aborted"
if (re.search(log_pattern, cmd_result.stdout.strip()) or
chk_libvirtd_log(libvirtd_log_path,
log_pattern, "debug")):
logging.debug("Found success a timed out block copy")
else:
raise exceptions.TestFail("Expect fail, but run "
"successfully: %s" % bug_url)
finally:
# Recover VM may fail unexpectedly, we need using try/except to
# proceed the following cleanup steps
try:
# Abort exist blockjob to avoid any possible lock error
virsh.blockjob(vm_name, target, '--abort', ignore_status=True)
vm.destroy(gracefully=False)
# It may take a long time to shutdown the VM which has
# blockjob running
utils_misc.wait_for(
lambda: virsh.domstate(vm_name,
ignore_status=True).exit_status, 180)
if virsh.domain_exists(vm_name):
if active_snap or with_shallow:
option = "--snapshots-metadata"
else:
option = None
original_xml.sync(option)
else:
original_xml.define()
except Exception as e:
logging.error(e)
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Clean up libvirt pool, which may be created by 'set_vm_disk'
if disk_type == 'volume':
virsh.pool_destroy(pool_name, ignore_status=True, debug=True)
# Restore libvirtd conf and restart libvirtd
libvirtd_conf.restore()
libvirtd_utl.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
# Clean up NFS
try:
if nfs_cleanup:
utl.setup_or_cleanup_nfs(is_setup=False)
except Exception as e:
logging.error(e)
# Clean up iSCSI
try:
for iscsi_n in list(set(emulated_iscsi)):
utl.setup_or_cleanup_iscsi(is_setup=False, emulated_image=iscsi_n)
# iscsid will be restarted, so give it a break before next loop
time.sleep(5)
except Exception as e:
logging.error(e)
if os.path.exists(dest_path):
os.remove(dest_path)
if os.path.exists(snap_path):
os.remove(snap_path)
if os.path.exists(save_path):
os.remove(save_path)
# Restart virtlogd service to release VM log file lock
try:
path.find_command('virtlogd')
process.run('systemctl reset-failed virtlogd')
process.run('systemctl restart virtlogd ')
except path.CmdNotFoundError:
pass
