def test_blockcommit_operation(vm_name, device_target, blockcommit_option,
test):
"""
Test blockcommit on disk with metadata_cache size attribute
:param vm_name: domain name
:param disk_target: the target of disk
:param blockcommit_option: blockcommit option
:param test: test case itself
"""
virsh.blockcommit(vm_name,
device_target,
blockcommit_option,
ignore_status=False,
debug=True)
# Check max size value in mirror part
mirror_xml = virsh.dumpxml(vm_name, debug=False).stdout_text.strip()
mirror_part_xml = re.findall(r'(<mirror)(.+)((?:\n.+)+)(mirror>)',
mirror_xml)
mirror_filter_str = ''.join(mirror_part_xml[0])
mirror_byte_match = "<max_size unit='bytes'>1000</max_size>"
if mirror_byte_match not in mirror_filter_str:
test.fail(
"Failed to generate metadata_cache in blockcommit operation %s" %
mirror_filter_str)
virsh.blockjob(vm_name,
device_target,
" --pivot",
ignore_status=True,
debug=True)
pivot_xml = virsh.dumpxml(vm_name, debug=False).stdout_text.strip()
if mirror_byte_match not in pivot_xml:
test.fail("Failed to generate metadata_cache in blockcommit %s" %
pivot_xml)
def do_blockcommit_repeatedly(vm, device_target, options, repeated_counts):
"""
Do blockcommit repeatedly
:param vm: VM instance
:param device_target: device target
:param options: blockcommit options
:param repeated_counts: repeated counts for executing blockcommit
"""
for count in range(repeated_counts):
virsh.blockcommit(vm.name,
device_target,
options,
ignore_status=False,
debug=True)
def test_commit_top_to_base():
"""
Do blockcommit from top to base after creating external
disk-only snapshot with specific disk type
"""
commit_options = " --top %s --pivot " % (test_obj.snap_path_list[-1])
virsh.blockcommit(vm.name,
test_obj.new_dev,
commit_options,
ignore_status=False,
debug=True)
# Check result after block commit
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
check_obj.check_block_operation_result(
vmxml, 'blockcommit', test_obj.new_dev,
test_obj.snap_path_list[::-1] + [test_obj.src_path])
def do_blockcommit_pivot_repeatedly():
"""
Validate bugzilla:https://bugzilla.redhat.com/show_bug.cgi?id=1857735
"""
# Make external snapshot,pivot and delete snapshot file repeatedly.
tmp_snapshot_name = "external_snapshot_" + "repeated.qcow2"
block_target = 'vda'
for count in range(0, 5):
options = "%s " % tmp_snapshot_name
options += "--disk-only --atomic"
disk_external = os.path.join(tmp_dir, tmp_snapshot_name)
options += " --diskspec %s,snapshot=external,file=%s" % (block_target, disk_external)
virsh.snapshot_create_as(vm_name, options,
ignore_status=False, debug=True)
virsh.blockcommit(vm_name, block_target,
" --active --pivot ", ignore_status=False, debug=True)
virsh.snapshot_delete(vm_name, tmp_snapshot_name, " --metadata")
libvirt.delete_local_disk('file', disk_external)
def trigger_block_commit(vm_name, target, blockcommit_options, **virsh_dargs):
"""
Trigger blockcommit.
:param vm_name: VM name
:param target: Disk dev in VM.
:param blockcommit_options: blockcommit option
:param virsh_dargs: additional parameters
"""
result = virsh.blockcommit(vm_name, target,
blockcommit_options, ignore_status=False, **virsh_dargs)
def test_domblkthreshold_inactivate_layer():
"""
Do domblkthreshold for a device which is not the active layer image
"""
# Get backingstore index value and set domblkthreshold
bs_index = ''
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
for disk in vmxml.devices.by_device_tag('disk'):
if disk.target['dev'] == primary_target:
bs_index = disk.xmltreefile.find('backingStore').get('index')
virsh.domblkthreshold(vm_name,
'%s[%s]' % (primary_target, bs_index),
domblk_threshold,
debug=True,
ignore_status=False)
# Create some data in active layer image
session = vm.wait_for_login()
utils_disk.dd_data_to_vm_disk(session,
'/tmp/file',
bs='1M',
count='100')
session.close()
# Check blockcommit will trigger threshold event
event = r"\'block-threshold\' for domain .*%s.*: dev: %s\[%s\].*%s.*" \
% (vm_name, primary_target, bs_index, domblk_threshold)
LOG.debug('Checking event pattern is :%s ', event)
event_session = virsh.EventTracker.start_get_event(vm_name)
virsh.blockcommit(vm.name,
primary_target,
commit_options,
ignore_status=False,
debug=True)
event_output = virsh.EventTracker.finish_get_event(event_session)
if not re.search(event, event_output):
test.fail('Not find: %s from event output:%s' %
(event, event_output))
def run_blockcommit():
"""
Run blockcommit command.
"""
if from_to == "top_to_base":
# Do blockcommit from top layer to base layer
cmd_option = (
"--top {0}[{1}] --base {0}[{2}] --active --pivot "
"--wait".format(original_disk_target, top_layer_index,
base_layer_index))
elif from_to == "mid_to_mid":
# Do blockcommit from middle layer to another middle layer
if len(indice) < 4:
test.fail(
"At lease 4 layers required for the test 'mid_to_mid'")
cmd_option = ("--top {0}[{1}] --base {0}[{2}] "
"--wait".format(original_disk_target,
middle_layer1_index,
middle_layer2_index))
elif from_to == "top_to_mid":
# Do blockcommit from top layer to middle layer
cmd_option = (
"--top {0}[{1}] --base {0}[{2}] --active --pivot "
"--wait".format(original_disk_target, top_layer_index,
middle_layer1_index))
elif from_to == "mid_to_base":
# Do blockcommit from middle layer to base layer
cmd_option = ("--top {0}[{1}] --base {0}[{2}] "
"--wait".format(original_disk_target,
middle_layer1_index,
base_layer_index))
virsh.blockcommit(vm_name,
original_disk_target,
cmd_option,
debug=True,
ignore_stauts=False)
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 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 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 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 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, is_create_image_file_in_vm=False):
"""
Make external snapshots for disks only.
:param postfix_n: postfix option
:param snapshot_take: snapshots taken.
:param is_create_image_file_in_vm: create image file in VM.
"""
# 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)
clean_snap_file(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!")
if is_create_image_file_in_vm:
create_file_cmd = "dd if=/dev/urandom of=/mnt/snapshot_%s.img bs=1M count=2" % count
session.cmd_status_output(create_file_cmd)
created_image_files_in_vm.append("snapshot_%s.img" % count)
# 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 check_vm_disk_file(vm):
"""
Check current vm disk source.
:param vm: The vm to be checked
"""
image_name1, image_format = params.get("image_name", "image"), params.get("image_format", "qcow2")
image_dir = os.path.join(data_dir.get_data_dir(), image_name1)
original_image_path = image_dir + "." + image_format
logging.debug("Source file should be : %s", original_image_path)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm.name)
disk = vmxml.get_devices('disk')[0]
logging.debug("Current disk info is : %s", disk)
if disk.source.attrs['file'] != original_image_path:
test.error("Please check current vm disk source")
def clean_snap_file(snap_path):
"""
Clean the existed duplicate snap file.
:param snap_path: snap file path
"""
if os.path.exists(snap_path):
os.remove(snap_path)
logging.debug("Cleaned snap file before creating :%s" % snap_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(pre_set_root_dir=None):
"""
Create backing chain files of relative path.
:param pre_set_root_dir: preset root dir
:return: absolute path of top active file
"""
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
if pre_set_root_dir is None:
root_dir = os.path.dirname(first_disk_source)
else:
root_dir = pre_set_root_dir
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"
if pre_set_root_dir:
backing_file_dict["b"] = "%s" % first_disk_source
backing_file_dict["c"] = "%s/b/b.img" % root_dir
backing_file_dict["d"] = "%s/c/c.img" % root_dir
disk_format = params.get("disk_format", "qcow2")
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 %s -o backing_file=%s,backing_fmt=%s %s.img"
% (backing_file_path, "qcow2", value, disk_format, key))
ret = process.run(cmd, shell=True)
disk_format = "qcow2"
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)
def create_reuse_external_snapshots(pre_set_root_dir=None):
"""
Create reuse external snapshots
:param pre_set_root_dir: preset root directory
:return: absolute path of base file
"""
if pre_set_root_dir is None:
first_disk_source = get_first_disk_source()
basename = os.path.basename(first_disk_source)
root_dir = os.path.dirname(first_disk_source)
else:
root_dir = pre_set_root_dir
meta_options = " --reuse-external --disk-only --no-metadata"
# Make three external relative path backing files.
backing_file_dict = collections.OrderedDict()
backing_file_dict["b"] = "b.img"
backing_file_dict["c"] = "c.img"
backing_file_dict["d"] = "d.img"
for key, value in list(backing_file_dict.items()):
backing_file_path = os.path.join(root_dir, key)
external_snap_shot = "%s/%s" % (backing_file_path, value)
snapshot_external_disks.append(external_snap_shot)
options = "%s --diskspec %s,file=%s" % (meta_options, disk_target, external_snap_shot)
cmd_result = virsh.snapshot_create_as(vm_name, options,
ignore_status=False,
debug=True)
libvirt.check_exit_status(cmd_result)
logging.debug('reuse external snapshots:%s' % snapshot_external_disks)
return root_dir
def check_file_in_vm():
"""
Check whether certain image files exists in VM internal.
"""
for img_file in created_image_files_in_vm:
status, output = session.cmd_status_output("ls -l /mnt/%s" % img_file)
logging.debug(output)
if status:
test.fail("blockcommit from top to base failed when ls image file in VM: %s" % output)
def do_blockcommit_pivot_repeatedly():
"""
Validate bugzilla:https://bugzilla.redhat.com/show_bug.cgi?id=1857735
"""
# Make external snapshot,pivot and delete snapshot file repeatedly.
tmp_snapshot_name = "external_snapshot_" + "repeated.qcow2"
block_target = 'vda'
for count in range(0, 5):
options = "%s " % tmp_snapshot_name
options += "--disk-only --atomic"
disk_external = os.path.join(tmp_dir, tmp_snapshot_name)
options += " --diskspec %s,snapshot=external,file=%s" % (block_target, disk_external)
virsh.snapshot_create_as(vm_name, options,
ignore_status=False, debug=True)
virsh.blockcommit(vm_name, block_target,
" --active --pivot ", ignore_status=False, debug=True)
virsh.snapshot_delete(vm_name, tmp_snapshot_name, " --metadata")
libvirt.delete_local_disk('file', disk_external)
# 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"))
cmd_timeout = params.get("cmd_timeout", "1")
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")
bandwidth = params.get("blockcommit_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
disk_target = params.get("disk_target", "vda")
disk_format = params.get("disk_format", "qcow2")
reuse_external_snapshot = "yes" == params.get("reuse_external_snapshot", "no")
restart_vm_before_commit = "yes" == params.get("restart_vm_before_commit", "no")
check_image_file_in_vm = "yes" == params.get("check_image_file_in_vm", "no")
pre_set_root_dir = None
blk_source_folder = None
convert_qcow2_image_to_raw = "yes" == params.get("convert_qcow2_image_to_raw", "no")
repeatedly_do_blockcommit_pivot = "yes" == params.get("repeatedly_do_blockcommit_pivot", "no")
from_top_without_active_option = "yes" == params.get("from_top_without_active_option", "no")
top_to_middle_keep_overlay = "yes" == params.get("top_to_middle_keep_overlay", "no")
block_disk_type_based_on_file_backing_file = "yes" == params.get("block_disk_type_based_on_file_backing_file", "no")
block_disk_type_based_on_gluster_backing_file = "yes" == params.get("block_disk_type_based_on_gluster_backing_file", "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_data_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)
check_vm_disk_file(vm)
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 == 'block' and reuse_external_snapshot:
first_disk = vm.get_first_disk_devices()
pre_set_root_dir = os.path.dirname(first_disk['source'])
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.")
params.update(
{"disk_source_name": os.path.join(
pool_name, 'rbd_'+utils_misc.generate_random_string(4)+'.img')})
if utils_package.package_install(["ceph-common"]):
ceph.rbd_image_rm(mon_host, *params.get("disk_source_name").split('/'))
else:
test.error('Failed to install ceph-common to clean image.')
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()
if convert_qcow2_image_to_raw:
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)
blk_source_image_after_converted = "%s/converted_%s" % (blk_source_folder, blk_source_image)
# 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)
params.update({'disk_source_name': blk_source_image_after_converted,
'disk_type': 'file',
'disk_src_protocol': 'file'})
libvirt.set_vm_disk(vm, params, tmp_dir)
if needs_agent:
vm.prepare_guest_agent()
if repeatedly_do_blockcommit_pivot:
do_blockcommit_pivot_repeatedly()
# Create block type disk on file backing file
if block_disk_type_based_on_file_backing_file or block_disk_type_based_on_gluster_backing_file:
if not vm.is_alive():
vm.start()
first_src_file = get_first_disk_source()
libvirt.setup_or_cleanup_iscsi(is_setup=False)
iscsi_target = libvirt.setup_or_cleanup_iscsi(is_setup=True)
block_type_backstore = iscsi_target
if block_disk_type_based_on_file_backing_file:
first_src_file = get_first_disk_source()
if block_disk_type_based_on_gluster_backing_file:
first_src_file = "gluster://%s/%s/gluster.qcow2" % (params.get("gluster_server_ip"), params.get("vol_name"))
backing_file_create_cmd = ("qemu-img create -f %s -o backing_file=%s,backing_fmt=%s %s"
% ("qcow2", first_src_file, "qcow2", block_type_backstore))
process.run(backing_file_create_cmd, ignore_status=False, shell=True)
meta_options = " --reuse-external --disk-only --no-metadata"
options = "%s --diskspec %s,file=%s,stype=block" % (meta_options, 'vda', block_type_backstore)
virsh.snapshot_create_as(vm_name, options,
ignore_status=False,
debug=True)
# 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 = []
created_image_files_in_vm = []
# get a vm session before snapshot
session = vm.wait_for_login()
# do snapshot
postfix_n = 'snap'
if reuse_external_snapshot:
make_relative_path_backing_files(pre_set_root_dir)
blk_source_folder = create_reuse_external_snapshots(pre_set_root_dir)
else:
make_disk_snapshot(postfix_n, snapshot_take, check_snapshot_tree, check_image_file_in_vm)
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)
if libvirt_version.version_compare(6, 0, 0):
bs_source = {'file': blk_source}
bs_dict = {"type": params.get("disk_type", "file"),
"format": {'type': params.get("disk_format", "qcow2")}}
new_bs = disk_xml.new_backingstore(**bs_dict)
new_bs["source"] = disk_xml.backingstore.new_source(**bs_source)
disk_xml.backingstore = new_bs
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 introduced 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 %s" % cmd_timeout
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 len(bandwidth):
blockcommit_options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
blockcommit_options += " --bytes"
if top_inactive:
snap_name = "%s.%s2" % (diskname, postfix_n)
top_image = os.path.join(tmp_dir, snap_name)
if reuse_external_snapshot:
index = len(snapshot_external_disks) - 2
top_image = snapshot_external_disks[index]
blockcommit_options += " --top %s" % top_image
else:
blockcommit_options += " --active"
if pivot_opt:
blockcommit_options += " --pivot"
if from_top_without_active_option:
blockcommit_options = blockcommit_options.replace("--active", "")
if top_to_middle_keep_overlay:
blockcommit_options = blockcommit_options.replace("--active", "")
blockcommit_options = blockcommit_options.replace("--pivot", "")
blockcommit_options += " --keep-overlay"
if restart_vm_before_commit:
top = 2
base = len(snapshot_external_disks)
blockcommit_options = ("--top %s[%d] --base %s[%d] --verbose --wait --keep-relative"
% (disk_target, top, disk_target, base))
vm.destroy(gracefully=True)
vm.start()
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:
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
top_index = 1
try:
top_index = disk_xml.backingstore.index
except AttributeError:
pass
else:
top_index = int(top_index)
block_commit_index = snapshot_take - 1
expect_backing_file = True
for count in range(1, block_commit_index):
# Do block commit with --wait if top_inactive
if top_inactive:
blockcommit_options = (" --wait --verbose --top vda[%d] "
"--base vda[%d] --keep-relative"
% (top_index, top_index+1))
if not libvirt_version.version_compare(6, 0, 0):
top_index = 1
else:
top_index += 1
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
if reuse_external_snapshot and not top_inactive:
block_commit_index = len(snapshot_external_disks) - 1
for index in range(block_commit_index):
# Do block commit with --shallow --wait
external_blockcommit_options = (" --shallow --wait --verbose --top %s "
% (snapshot_external_disks[index]))
res = virsh.blockcommit(vm_name, blk_target,
external_blockcommit_options, **virsh_dargs)
libvirt.check_exit_status(res, status_error)
# Do blockcommit with top active
result = virsh.blockcommit(vm_name, blk_target,
blockcommit_options, **virsh_dargs)
# Check status_error
libvirt.check_exit_status(result, status_error)
return
# Start one thread to check the bandwidth in output
if bandwidth and bandwidth_byte:
bandwidth += 'B'
pool = ThreadPool(processes=1)
pool.apply_async(check_bandwidth_thread, (libvirt.check_blockjob, vm_name, blk_target, bandwidth, test))
# 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)
# Skip check chain file as per test case description
if restart_vm_before_commit:
return
if check_image_file_in_vm:
check_file_in_vm()
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)
# 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.')
# Recover xml of vm.
vmxml_backup.sync("--snapshots-metadata")
# Remove ceph configure file if created
if ceph_cfg:
os.remove(ceph_cfg)
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 or reuse_external_snapshot:
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
if blk_source_folder:
process.run("cd %s && rm -rf b c d" % blk_source_folder, shell=True)
if disk_src_protocol == 'iscsi' or 'iscsi_target' in locals():
libvirt.setup_or_cleanup_iscsi(is_setup=False,
restart_tgtd=restart_tgtd)
elif disk_src_protocol == 'gluster':
gluster.setup_or_cleanup_gluster(False, brick_path=brick_path, **params)
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)
# Recover images xattr if having some
dirty_images = get_images_with_xattr(vm)
if dirty_images:
clean_images_with_xattr(dirty_images)
test.fail("VM's image(s) having xattr left")
def trigger_events(dom, events_list=[]):
"""
Trigger various events in events_list
:param dom: the vm objects corresponding to the domain
:return: the expected output that virsh event command prints out
"""
expected_events_list = []
save_path = os.path.join(tmpdir, "%s_event.save" % dom.name)
print(dom.name)
xmlfile = dom.backup_xml()
new_disk = os.path.join(tmpdir, "%s_new_disk.img" % dom.name)
dest_path = os.path.join(data_dir.get_data_dir(), "copy")
try:
for event in events_list:
logging.debug("Current event is: %s", event)
if event in ['start', 'restore', 'create', 'edit', 'define',
'undefine', 'crash', 'device-removal-failed',
'watchdog', 'io-error']:
if dom.is_alive():
dom.destroy()
if event in ['create', 'define']:
dom.undefine()
else:
if not dom.is_alive():
dom.start()
dom.wait_for_login().close()
if event == "resume":
dom.pause()
if event == "undefine":
virsh.undefine(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Undefined Removed")
elif event == "create":
virsh.create(xmlfile, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
expected_events_list.append("'lifecycle' for %s:"
" Started Booted")
elif event == "destroy":
virsh.destroy(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Destroyed")
elif event == "define":
virsh.define(xmlfile, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Defined Added")
elif event == "start":
virsh.start(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
expected_events_list.append("'lifecycle' for %s:"
" Started Booted")
dom.wait_for_login().close()
elif event == "suspend":
virsh.suspend(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
if not libvirt_version.version_compare(5, 3, 0):
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
elif event == "resume":
virsh.resume(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
elif event == "save":
virsh.save(dom.name, save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
expected_events_list.append("'lifecycle' for %s:"
" Stopped Saved")
elif event == "restore":
if not os.path.exists(save_path):
logging.error("%s not exist", save_path)
else:
virsh.restore(save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Started Restored")
expected_events_list.append("'lifecycle' for %s:"
" Resumed Snapshot")
elif event == "edit":
#Check whether 'description' element exists.
domxml = virsh.dumpxml(dom.name).stdout.strip()
find_desc = parseString(domxml).getElementsByTagName("description")
if find_desc == []:
#If not exists, add one for it.
logging.info("Adding <description> to guest")
virsh.desc(dom.name, "--config", "Added desc for testvm", **virsh_dargs)
#The edit operation is to delete 'description' element.
edit_cmd = [r":g/<description.*<\/description>/d"]
utlv.exec_virsh_edit(dom.name, edit_cmd)
expected_events_list.append("'lifecycle' for %s:"
" Defined Updated")
elif event == "shutdown":
if signal_name is None:
virsh.shutdown(dom.name, **virsh_dargs)
# Wait a few seconds for shutdown finish
time.sleep(3)
if utils_misc.compare_qemu_version(2, 9, 0):
#Shutdown reason distinguished from qemu_2.9.0-9
expected_events_list.append("'lifecycle' for %s:"
" Shutdown Finished after guest request")
else:
os.kill(dom.get_pid(), getattr(signal, signal_name))
if utils_misc.compare_qemu_version(2, 9, 0):
expected_events_list.append("'lifecycle' for %s:"
" Shutdown Finished after host request")
if not utils_misc.compare_qemu_version(2, 9, 0):
expected_events_list.append("'lifecycle' for %s:"
" Shutdown Finished")
wait_for_shutoff(dom)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Shutdown")
elif event == "crash":
if not vmxml.xmltreefile.find('devices').findall('panic'):
# Set panic device
panic_dev = Panic()
panic_dev.model = panic_model
panic_dev.addr_type = addr_type
panic_dev.addr_iobase = addr_iobase
vmxml.add_device(panic_dev)
vmxml.on_crash = "coredump-restart"
vmxml.sync()
logging.info("Guest xml now is: %s", vmxml)
dom.start()
session = dom.wait_for_login()
# Stop kdump in the guest
session.cmd("systemctl stop kdump", ignore_all_errors=True)
# Enable sysRq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
try:
# Crash the guest
session.cmd("echo c > /proc/sysrq-trigger", timeout=90)
except (ShellTimeoutError, ShellProcessTerminatedError) as details:
logging.info(details)
session.close()
expected_events_list.append("'lifecycle' for %s:"
" Crashed Panicked")
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
elif event == "reset":
virsh.reset(dom.name, **virsh_dargs)
expected_events_list.append("'reboot' for %s")
elif event == "vcpupin":
virsh.vcpupin(dom.name, '0', '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.vcpupin0: 0")
elif event == "emulatorpin":
virsh.emulatorpin(dom.name, '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.emulatorpin: 0")
elif event == "setmem":
mem_size = int(params.get("mem_size", 512000))
virsh.setmem(dom.name, mem_size, **virsh_dargs)
expected_events_list.append("'balloon-change' for %s:")
elif event == "device-added-removed":
add_disk(dom.name, new_disk, 'vdb', '')
expected_events_list.append("'device-added' for %s:"
" virtio-disk1")
virsh.detach_disk(dom.name, 'vdb', **virsh_dargs)
expected_events_list.append("'device-removed' for %s:"
" virtio-disk1")
iface_xml_obj = create_iface_xml()
iface_xml_obj.xmltreefile.write()
virsh.detach_device(dom.name, iface_xml_obj.xml, **virsh_dargs)
expected_events_list.append("'device-removed' for %s:"
" net0")
time.sleep(2)
virsh.attach_device(dom.name, iface_xml_obj.xml, **virsh_dargs)
expected_events_list.append("'device-added' for %s:"
" net0")
elif event == "block-threshold":
add_disk(dom.name, new_disk, 'vdb', '', format=disk_format)
logging.debug(process.run('qemu-img info %s -U' % new_disk))
virsh.domblkthreshold(vm_name, 'vdb', '100M')
session = dom.wait_for_login()
session.cmd("mkfs.ext4 /dev/vdb && mount /dev/vdb /mnt && ls /mnt && "
"dd if=/dev/urandom of=/mnt/bigfile bs=1M count=300 && sync")
time.sleep(5)
session.close()
expected_events_list.append("'block-threshold' for %s:"
" dev: vdb(%s) 104857600 29368320")
virsh.detach_disk(dom.name, 'vdb', **virsh_dargs)
elif event == "change-media":
target_device = "hdc"
device_target_bus = params.get("device_target_bus", "ide")
disk_blk = vm_xml.VMXML.get_disk_blk(dom.name)
logging.info("disk_blk %s", disk_blk)
if target_device not in disk_blk:
logging.info("Adding cdrom to guest")
if dom.is_alive():
dom.destroy()
add_disk(dom.name, new_disk, target_device,
("--type cdrom --sourcetype file --driver qemu " +
"--config --targetbus %s" % device_target_bus))
dom.start()
all_options = new_disk + " --insert"
virsh.change_media(dom.name, target_device,
all_options, **virsh_dargs)
expected_events_list.append("'tray-change' for %s disk" + " .*%s.*:" % device_target_bus +
" opened")
expected_events_list.append("'tray-change' for %s disk" + " .*%s.*:" % device_target_bus +
" closed")
all_options = new_disk + " --eject"
virsh.change_media(dom.name, target_device,
all_options, **virsh_dargs)
expected_events_list.append("'tray-change' for %s disk" + " .*%s.*:" % device_target_bus +
" opened")
elif event == "hwclock":
session = dom.wait_for_login()
try:
session.cmd("hwclock --systohc", timeout=60)
except (ShellTimeoutError, ShellProcessTerminatedError) as details:
logging.info(details)
session.close()
expected_events_list.append("'rtc-change' for %s:")
elif event == "metadata_set":
metadata_uri = params.get("metadata_uri")
metadata_key = params.get("metadata_key")
metadata_value = params.get("metadata_value")
virsh.metadata(dom.name,
metadata_uri,
options="",
key=metadata_key,
new_metadata=metadata_value,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
elif event == "metadata_edit":
metadata_uri = "http://herp.derp/"
metadata_key = "herp"
metadata_value = "<derp xmlns:foobar='http://foo.bar/'>foo<bar></bar></derp>"
virsh_cmd = r"virsh metadata %s --uri %s --key %s %s"
virsh_cmd = virsh_cmd % (dom.name, metadata_uri,
metadata_key, "--edit")
session = aexpect.ShellSession("sudo -s")
logging.info("Running command: %s", virsh_cmd)
try:
session.sendline(virsh_cmd)
session.sendline(r":insert")
session.sendline(metadata_value)
session.sendline(".")
session.send('ZZ')
remote.handle_prompts(session, None, None, r"[\#\$]\s*$",
debug=True, timeout=60)
except Exception as e:
test.error("Error occured: %s" % e)
session.close()
# Check metadata after edit
virsh.metadata(dom.name,
metadata_uri,
options="",
key=metadata_key,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
elif event == "metadata_remove":
virsh.metadata(dom.name,
metadata_uri,
options="--remove",
key=metadata_key,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
elif event == "blockcommit":
disk_path = dom.get_blk_devices()['vda']['source']
virsh.snapshot_create_as(dom.name, "s1 --disk-only --no-metadata", **virsh_dargs)
snapshot_path = dom.get_blk_devices()['vda']['source']
virsh.blockcommit(dom.name, "vda", "--active --pivot", **virsh_dargs)
expected_events_list.append("'block-job' for %s: "
"Active Block Commit for " + "%s" % snapshot_path + " ready")
expected_events_list.append("'block-job-2' for %s: "
"Active Block Commit for vda ready")
expected_events_list.append("'block-job' for %s: "
"Active Block Commit for " + "%s" % disk_path + " completed")
expected_events_list.append("'block-job-2' for %s: "
"Active Block Commit for vda completed")
os.unlink(snapshot_path)
elif event == "blockcopy":
disk_path = dom.get_blk_devices()['vda']['source']
dom.undefine()
virsh.blockcopy(dom.name, "vda", dest_path, "--pivot", **virsh_dargs)
expected_events_list.append("'block-job' for %s: "
"Block Copy for " + "%s" % disk_path + " ready")
expected_events_list.append("'block-job-2' for %s: "
"Block Copy for vda ready")
expected_events_list.append("'block-job' for %s: "
"Block Copy for " + "%s" % dest_path + " completed")
expected_events_list.append("'block-job-2' for %s: "
"Block Copy for vda completed")
elif event == "detach-dimm":
prepare_vmxml_mem(vmxml)
tg_size = params.get("dimm_size")
tg_sizeunit = params.get("dimm_unit")
dimm_xml = utils_hotplug.create_mem_xml(tg_size, None, None, tg_sizeunit)
virsh.attach_device(dom.name, dimm_xml.xml,
flagstr="--config", **virsh_dargs)
vmxml_dimm = vm_xml.VMXML.new_from_dumpxml(dom.name)
logging.debug("Current vmxml with plugged dimm dev is %s\n" % vmxml_dimm)
virsh.start(dom.name, **virsh_dargs)
dom.wait_for_login().close()
result = virsh.detach_device(dom.name, dimm_xml.xml, debug=True, ignore_status=True)
expected_fails = params.get("expected_fails")
utlv.check_result(result, expected_fails)
vmxml_live = vm_xml.VMXML.new_from_dumpxml(dom.name)
logging.debug("Current vmxml after hot-unplug dimm is %s\n" % vmxml_live)
expected_events_list.append("'device-removal-failed' for %s: dimm0")
elif event == "watchdog":
vmxml.remove_all_device_by_type('watchdog')
watchdog_dev = Watchdog()
watchdog_dev.model_type = params.get("watchdog_model")
action = params.get("action")
watchdog_dev.action = action
vmxml.add_device(watchdog_dev)
vmxml.sync()
logging.debug("Current vmxml with watchdog dev is %s\n" % vmxml)
virsh.start(dom.name, **virsh_dargs)
session = dom.wait_for_login()
try:
session.cmd("echo 0 > /dev/watchdog")
except (ShellTimeoutError, ShellProcessTerminatedError) as details:
test.fail("Failed to trigger watchdog: %s" % details)
session.close()
# watchdog acts slowly, waiting for it.
time.sleep(30)
expected_events_list.append("'watchdog' for %s: " + "%s" % action)
if action == 'pause':
expected_events_list.append("'lifecycle' for %s: Suspended Watchdog")
virsh.resume(dom.name, **virsh_dargs)
else:
# action == 'reset'
expected_events_list.append("'reboot' for %s")
elif event == "io-error":
part_size = params.get("part_size")
resume_event = params.get("resume_event")
suspend_event = params.get("suspend_event")
process.run("truncate -s %s %s" % (part_size, small_part), shell=True)
utlv.mkfs(small_part, part_format)
utils_misc.mount(small_part, mount_point, None)
add_disk(dom.name, new_disk, 'vdb', '--subdriver qcow2 --config', 'qcow2')
dom.start()
session = dom.wait_for_login()
session.cmd("mkfs.ext4 /dev/vdb && mount /dev/vdb /mnt && ls /mnt && "
"dd if=/dev/zero of=/mnt/test.img bs=1M count=50", ignore_all_errors=True)
time.sleep(5)
session.close()
expected_events_list.append("'io-error' for %s: " + "%s" % new_disk + r" \(virtio-disk1\) pause")
expected_events_list.append("'io-error-reason' for %s: " + "%s" % new_disk + r" \(virtio-disk1\) pause due to enospc")
expected_events_list.append(suspend_event)
process.run("df -hT")
virsh.resume(dom.name, **virsh_dargs)
time.sleep(5)
expected_events_list.append(resume_event)
expected_events_list.append("'io-error' for %s: " + "%s" % new_disk + r" \(virtio-disk1\) pause")
expected_events_list.append("'io-error-reason' for %s: " + "%s" % new_disk + r" \(virtio-disk1\) pause due to enospc")
expected_events_list.append(suspend_event)
ret = virsh.domstate(dom.name, "--reason", **virsh_dargs)
if ret.stdout.strip() != "paused (I/O error)":
test.fail("Domain state should still be paused due to I/O error!")
else:
test.error("Unsupported event: %s" % event)
# Event may not received immediately
time.sleep(3)
finally:
if os.path.exists(save_path):
os.unlink(save_path)
if os.path.exists(new_disk):
os.unlink(new_disk)
if os.path.exists(dest_path):
os.unlink(dest_path)
return [(dom.name, event) for event in expected_events_list]
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):
# Add all disks into commandline.
disks = vm.get_disk_devices()
# Make three external snapshots for disks only
for count in range(1, 4):
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:
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")
with_active_commit = "yes" == params.get("with_active_commit", "no")
multiple_chain = "yes" == params.get("multiple_chain", "no")
virsh_dargs = {'debug': True}
# 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):
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 = []
cmd_session = None
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:
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)
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 = vmxml.get_devices(device_type="disk")[0]
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)
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(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"
if with_timeout:
blockcommit_options += " --timeout 2"
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)
# 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 not multiple_chain:
if disk_src_file != snap_src_lst[2]:
raise error.TestFail(err_msg)
else:
if disk_src_file != snap_src_lst[3]:
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:
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" and not multiple_chain:
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(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 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(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():
# 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)
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)
session = vm.wait_for_login()
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")
virsh_dargs = {'debug': True}
# 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)
try:
# Get a tmp_dir.
tmp_dir = data_dir.get_tmp_dir()
# The first disk is supposed to include OS
# We will perform blockcommit operation for it.
first_disk = vm.get_first_disk_devices()
snapshot_external_disks = []
snapshot_flag_files = []
make_disk_snapshot()
top_image = None
base_image = None
blockcommit_options = "--wait --verbose"
if with_timeout:
blockcommit_options += " --timeout 1"
if base_option == "shallow":
blockcommit_options += " --shallow"
elif base_option == "base":
blockcommit_options += " --base %s" % first_disk['source']
if top_inactive:
basename = os.path.basename(first_disk['source'])
diskname = basename.split(".")[0]
top_image = os.path.join(tmp_dir, "%s.snap2" %
diskname)
blockcommit_options += " --top %s" % top_image
# Run test case
result = virsh.blockcommit(vm_name, first_disk['target'],
blockcommit_options, **virsh_dargs)
status = result.exit_status
# Check status_error
if status_error and status == 0:
raise error.TestFail("Expect fail, but run successfully!")
elif not status_error and status != 0:
raise error.TestFail("Run failed with right command")
# If top layer is active, virsh should be in failure,
# return not necessary to check
if not top_inactive:
return
# Check flag files
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
raise error.TestFail("blockcommit failed: %s" % output)
finally:
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Recover xml of vm.
vmxml_backup.sync()
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)
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)
session = vm.wait_for_login()
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")
virsh_dargs = {'debug': True}
# 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)
try:
# Get a tmp_dir.
tmp_dir = data_dir.get_tmp_dir()
# The first disk is supposed to include OS
# We will perform blockcommit operation for it.
first_disk = vm.get_first_disk_devices()
snapshot_external_disks = []
snapshot_flag_files = []
make_disk_snapshot()
top_image = None
base_image = None
blockcommit_options = "--wait --verbose"
basename = os.path.basename(first_disk['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:
base_image = os.path.join(tmp_dir, "%s.snap1" %
diskname)
blockcommit_options += " --base %s" % base_image
else:
blockcommit_options += " --base %s" % first_disk['source']
if top_inactive:
top_image = os.path.join(tmp_dir, "%s.snap2" %
diskname)
blockcommit_options += " --top %s" % top_image
# Run test case
result = virsh.blockcommit(vm_name, first_disk['target'],
blockcommit_options, **virsh_dargs)
status = result.exit_status
# Check status_error
if status_error and status == 0:
raise error.TestFail("Expect fail, but run successfully!")
elif not status_error and status != 0:
raise error.TestFail("Run failed with right command")
# If top layer is active, virsh should be in failure,
# return not necessary to check
if not top_inactive:
return
# Check flag files
for flag in snapshot_flag_files:
status, output = session.cmd_status_output("cat %s" % flag)
if status:
raise error.TestFail("blockcommit failed: %s" % output)
finally:
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Recover xml of vm.
vmxml_backup.sync()
