def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
job_time = 0
while job_time < timeout:
# Check cmd execute status and report error directly if have
virsh.blockjob(vm_name,
target,
"--info",
debug=True,
ignore_status=False)
# As BZ#1359679, blockjob may disappear during the process,
# so we need check it all the time
if utl.check_blockjob(vm_name, target, 'none', '0'):
raise exceptions.TestFail("No blockjob find for '%s'" % target)
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def test_blockjob_raw():
"""
Do blockjob with raw option.
1) Prepare a running guest.
2) Do blockcopy.
3) Do blockjob with raw option twice and check cur value is changing
4) Execute with --pivot and check raw option return empty
"""
options = params.get('option_value', '')
# Confirm blockcopy not finished.
if not libvirt.check_blockjob(vm_name, dev, "progress", "100"):
res_1 = virsh.blockjob(vm_name,
dev,
options=options,
debug=True,
ignore_status=False)
cur1 = libvirt_misc.convert_to_dict(res_1.stdout_text.strip(),
pattern=r'(\S+)=(\S+)')['cur']
time.sleep(1)
res_2 = virsh.blockjob(vm_name,
dev,
options=options,
debug=True,
ignore_status=False)
cur2 = libvirt_misc.convert_to_dict(res_2.stdout_text.strip(),
pattern=r'(\S+)=(\S+)')['cur']
LOG.debug('cur1 is %s , cur2 is %s', cur1, cur2)
if int(cur1) >= int(cur2):
test.fail('Two times cur value is not changed according'
' to the progress of blockcopy.')
# Abort job and check abort success.
if utils_misc.wait_for(
lambda: libvirt.check_blockjob(vm_name, dev, "progress",
"100"), 100):
virsh.blockjob(vm_name,
dev,
options=' --pivot',
debug=True,
ignore_status=False)
else:
test.fail("Blockjob timeout in 100 sec.")
# Check no output after abort.
result = virsh.blockjob(vm_name,
dev,
options=options,
debug=True,
ignore_status=False)
if result.stdout_text.strip():
test.fail("Not return empty after pivot, but get:%s",
result.stdout_text.strip())
else:
test.error(
'Blockcopy finished too fast, unable to check raw result,\
Please consider to reduce bandwith value to retest this case.')
def start_pivot_blkcpy_on_transient_vm():
"""
Start blockcopy with pivot option
"""
external_snapshot_disks = libvirt_disk.make_external_disk_snapshots(
vm, device_target, "trans_snapshot", snapshot_take)
logging.debug("external snapshots:%s\n", external_snapshot_disks)
external_snapshot_disks.pop()
for sub_option in ["--shallow --pivot", "--pivot"]:
tmp_copy_path = os.path.join(
data_dir.get_data_dir(),
"%s_%s.img" % (vm_name, sub_option[2:5]))
tmp_blkcopy_path.append(tmp_copy_path)
if os.path.exists(tmp_copy_path):
libvirt.delete_local_disk('file', tmp_copy_path)
virsh.blockcopy(vm_name,
device_target,
tmp_copy_path,
options=sub_option,
ignore_status=False,
debug=True)
back_chain_files = libvirt_disk.get_chain_backing_files(
tmp_copy_path)
back_chain_files = back_chain_files[1:len(back_chain_files)]
logging.debug("debug blockcopy xml restore:%s and %s\n",
external_snapshot_disks, back_chain_files)
if back_chain_files != external_snapshot_disks:
test.fail("can not get identical backing chain")
utils_misc.wait_for(
lambda: libvirt.check_blockjob(vm_name, device_target), 5)
#After pivot, no backing chain exists
external_snapshot_disks = []
def check_bandwidth_progress(bandwidth_value):
"""
Check bandwidth
:param bandwidth_value: expected bandwidth value
"""
ret = utils_misc.wait_for(lambda: libvirt.check_blockjob(vm_name, device_target, "bandwidth", bandwidth_value), 30)
if not ret:
test.fail("Failed to get bandwidth limit output")
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
# Need blockjob exist
if utl.check_blockjob(vm_name, target, 'none', '0'):
raise exceptions.TestFail("No blockjob find for '%s'" % target)
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
# Need blockjob exist
if utl.check_blockjob(vm_name, target, 'none', '0'):
raise exceptions.TestFail("No blockjob find for '%s'" % target)
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
job_time = 0
while job_time < timeout:
# As BZ#1359679, blockjob may disappear during the process,
# so we need check it all the time
if utl.check_blockjob(vm_name, target, 'none', '0'):
raise exceptions.TestFail("No blockjob find for '%s'" % target)
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value of this function
"""
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise JobTimeout(timeout)
def finish_job(vm_name, target, timeout):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value
"""
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%.")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
raise error.TestFail("Blockjob timeout in %s sec." % timeout)
def finish_job(vm_name, target, timeout, test):
"""
Make sure the block copy job finish.
:param vm_name: Domain name
:param target: Domain disk target dev
:param timeout: Timeout value
"""
job_time = 0
while job_time < timeout:
if utl.check_blockjob(vm_name, target, "progress", "100"):
logging.debug("Block job progress up to 100%.")
break
else:
job_time += 2
time.sleep(2)
if job_time >= timeout:
test.fail("Blockjob timeout in %s sec." % timeout)
def test_blockcopy_operation(vm_name, disk_path, disk_format, disk_device,
device_target, device_bus, max_blockcopy_size,
blockcopy_option, test):
"""
Test virsh blockcopy operation on disk with metadatacache attribute.
:param vm_name: domain name
:param disk_path: the path of disk
:param disk_format: the format to disk image
:param disk_device: the disk device type
:param device_target: the target of disk
:param max_blockcopy_size: max blockcopy metadatacache size
:param blockcopy_option: blockcopy option
:param test: test case itself
"""
blockcopy_disk = libvirt_disk.create_custom_metadata_disk(
disk_path, disk_format, disk_device, device_target, device_bus,
max_blockcopy_size)
virsh.blockcopy(vm_name,
device_target,
"--xml %s" % blockcopy_disk.xml,
options=blockcopy_option,
debug=True,
ignore_status=False)
#Check job finished
if not utils_misc.wait_for(
lambda: libvirt.check_blockjob(vm_name, device_target, "progress",
"100"), 300):
test.fail("Blockjob timeout in 300 sec.")
# Check max size value in mirror part
blk_mirror = ("mirror type='file' file='%s' "
"format='%s' job='copy'" % (disk_path, disk_format))
dom_xml = virsh.dumpxml(vm_name, debug=False).stdout_text.strip()
if not dom_xml.count(blk_mirror):
test.fail("Can't see block job in domain xml")
virsh.blockjob(vm_name,
device_target,
" --pivot",
ignore_status=True,
debug=False)
pivot_xml = virsh.dumpxml(vm_name, debug=True).stdout_text.strip()
pivot_byte_str = "<max_size unit='bytes'>1000</max_size>"
if pivot_byte_str not in pivot_xml:
test.fail("Failed to generate metadata_cache in %s" % pivot_xml)
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
check_finish_job = "yes" == params.get("check_finish_job", "yes")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
relative_path = params.get("relative_path")
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
snapshots_take = int(params.get("snapshots_take", '0'))
external_disk_only_snapshot = "yes" == params.get(
"external_disk_only_snapshot", "no")
enable_iscsi_auth = "yes" == params.get("enable_iscsi_auth", "no")
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
if bandwidth_byte and not libvirt_version.version_compare(1, 3, 3):
raise exceptions.TestSkipError("--bytes option not supported in "
"current version")
if relative_path == "yes" and not libvirt_version.version_compare(3, 0, 0):
test.cancel(
"Forbid using relative path or file name only is added since libvirt-3.0.0"
)
if "--transient-job" in options and not libvirt_version.version_compare(
4, 5, 0):
test.cancel(
"--transient-job option is supported until libvirt 4.5.0 version")
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" %
(target, vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
options += " --bytes"
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True,
'ignore_status': True,
'timeout': timeout
}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_log_path = os.path.join(data_dir.get_tmp_dir(),
"libvirt_daemons.log")
libvirtd_conf_dict = {
"log_filter": '"3:json 1:libvirt 1:qemu"',
"log_outputs": '"1:file:%s"' % libvirtd_log_path
}
logging.debug("the libvirtd conf file content is :\n %s" %
libvirtd_conf_dict)
libvirtd_conf = utl.customize_libvirt_config(libvirtd_conf_dict)
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" %
(dest_path, expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
This is a specific bug verify, so ignore status_error here.
"""
failure_msg = ""
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
failure_msg += "Virsh cmd error happened: %s\n" % err_msg
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
failure_msg += "Libvirtd log error happened: %s\n" % err_pattern
if failure_msg:
if not libvirt_version.version_compare(1, 3, 2):
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
failure_msg += "Hit on bug: %s " % bug_url_
test.fail(failure_msg)
def _make_snapshot(snapshot_numbers_take):
"""
Make external disk snapshot
:param snapshot_numbers_take: snapshot numbers.
"""
for count in range(0, snapshot_numbers_take):
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name + "_%s" % count
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
# Remove non-storage disk such as 'cdrom'
for disk in disks:
if disk.device != 'disk':
disks.remove(disk)
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
new_file = os.path.join(tmp_dir,
"blockcopy_shallow_%s.snap" % count)
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('dev' in disk_xml.source.attrs
or 'name' in disk_xml.source.attrs
or 'pool' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block'
or disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
elif 'pool' in new_attrs:
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(
is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
nfs_cleanup = False
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if enable_iscsi_auth:
utils_secret.clean_up_secrets()
setup_auth_enabled_iscsi_disk(vm, params)
dest_path = os.path.join(tmp_dir, tmp_file)
elif with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
# Make sure the new disk show up
utils_misc.wait_for(lambda: os.path.exists(dest_path), 5)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
if disk_source_protocol == 'iscsi':
emulated_iscsi.append(emu_image)
if disk_source_protocol == 'netfs':
nfs_cleanup = True
utl.set_vm_disk(vm, params, tmp_dir, test)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow or external_disk_only_snapshot or enable_iscsi_auth:
_make_snapshot(snapshots_take)
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command to create destination file
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail: %s" %
cmd_result.stdout.strip() +
cmd_result.stderr)
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
if "--transient-job" in options:
pool = ThreadPool(processes=1)
async_result = pool.apply_async(
blockcopy_thread, (vm_name, target, dest_path, options))
kill_blockcopy_process()
utl.check_blockjob(vm_name, target)
return
# Run the real testing command
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options,
**extra_dict)
# check BZ#1197592
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
if options.count('--bytes'):
bandwidth += 'B'
else:
bandwidth += 'M'
if not (bandwidth
in ['0B', '0M']) and not utl.check_blockjob(
vm_name, target, "bandwidth", bandwidth):
raise exceptions.TestFail("Check bandwidth failed")
val = options.count("--pivot") + options.count("--finish")
# Don't wait for job finish when using --byte option
val += options.count('--bytes')
if val == 0 and check_finish_job:
try:
finish_job(vm_name, target, timeout)
except JobTimeout as excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name,
snap_opt,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name,
save_path,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
else:
raise exceptions.TestFail(cmd_result.stdout.strip() +
cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
# Commit id '4c297728' changed how virsh exits when
# unexpectedly failing due to timeout from a fail (1)
# to a success(0), so we need to look for a different
# marker to indicate the copy aborted. As "stdout: Now
# in mirroring phase" could be in stdout which fail the
# check, so also do check in libvirtd log to confirm.
if options.count("--timeout") and options.count("--wait"):
log_pattern = "Copy aborted"
if (re.search(log_pattern, cmd_result.stdout.strip())
or chk_libvirtd_log(libvirtd_log_path, log_pattern,
"debug")):
logging.debug("Found success a timed out block copy")
else:
raise exceptions.TestFail("Expect fail, but run "
"successfully: %s" % bug_url)
finally:
# Recover VM may fail unexpectedly, we need using try/except to
# proceed the following cleanup steps
try:
# Abort exist blockjob to avoid any possible lock error
virsh.blockjob(vm_name, target, '--abort', ignore_status=True)
vm.destroy(gracefully=False)
# It may take a long time to shutdown the VM which has
# blockjob running
utils_misc.wait_for(
lambda: virsh.domstate(vm_name, ignore_status=True).
exit_status, 180)
if virsh.domain_exists(vm_name):
if active_snap or with_shallow:
option = "--snapshots-metadata"
else:
option = None
original_xml.sync(option)
else:
original_xml.define()
except Exception as e:
logging.error(e)
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Clean up libvirt pool, which may be created by 'set_vm_disk'
if disk_type == 'volume':
virsh.pool_destroy(pool_name, ignore_status=True, debug=True)
# Restore libvirtd conf and restart libvirtd
libvirtd_conf.restore()
libvirtd_utl.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
# Clean up NFS
try:
if nfs_cleanup:
utl.setup_or_cleanup_nfs(is_setup=False)
except Exception as e:
logging.error(e)
# Clean up iSCSI
try:
for iscsi_n in list(set(emulated_iscsi)):
utl.setup_or_cleanup_iscsi(is_setup=False,
emulated_image=iscsi_n)
# iscsid will be restarted, so give it a break before next loop
time.sleep(5)
except Exception as e:
logging.error(e)
if os.path.exists(dest_path):
os.remove(dest_path)
if os.path.exists(snap_path):
os.remove(snap_path)
if os.path.exists(save_path):
os.remove(save_path)
# Restart virtlogd service to release VM log file lock
try:
path.find_command('virtlogd')
process.run('systemctl reset-failed virtlogd')
process.run('systemctl restart virtlogd ')
except path.CmdNotFoundError:
pass
def run(test, params, env):
"""
Test command: virsh blockjob.
This command can manage active block operations.
1. Positive testing
1.1 Query active block job for the specified disk.
1.2 Manager the active block job(cancle/pivot).
1.3 Adjust speed for the active block job.
2. Negative testing
2.1 Query active block job for a invalid disk.
2.2 Invalid bandwith test.
2.3 No active block job management.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
options = params.get("blockjob_options", "")
bandwidth = params.get("blockjob_bandwidth", "")
no_blockjob = "yes" == params.get("no_blockjob", "no")
invalid_disk = params.get("invalid_disk")
persistent_vm = "yes" == params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
target = get_disk(vm_name)
if not target:
raise error.TestFail("Require target disk to copy.")
# Prepare transient/persistent vm
original_xml = vm.backup_xml()
if not persistent_vm and vm.is_persistent():
vm.undefine()
elif persistent_vm and not vm.is_persistent():
vm.define(original_xml)
#Create a block job, e.g.: blockcopy
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
dest_path = os.path.join(data_dir.get_tmp_dir(), tmp_file)
if not no_blockjob:
cmd_result = virsh.blockcopy(vm_name, target, dest_path, "",
ignore_status=True, debug=True)
status = cmd_result.exit_status
if status != 0:
raise error.TestError("Fail to create blockcopy job.")
# This option need blockjcopy job finish first
if options.count("--pivot"):
#Set default blockcopy timeout to 300 sec
timeout = 300
finish_job(vm_name, target, timeout)
if len(bandwidth):
options += "--bandwidth %s" % bandwidth
if invalid_disk:
target = invalid_disk
# Run virsh blockjob command
cmd_result = virsh.blockjob(vm_name, target, options,
ignore_status=True, debug=True)
err = cmd_result.stderr.strip()
status = cmd_result.exit_status
# Check result
if not utils_libvirtd.libvirtd_is_running():
raise error.TestFail("Libvirtd service is dead.")
try:
if not status_error:
if status == 0:
#'abort' option check
if options.count("--abort"):
utl.check_blockjob(vm_name, target, "no_job", 0)
#'pivot' option check
if options.count("--pivot"):
if utl.check_blockjob(vm_name, target, "no_job", 0):
check_disk(vm_name, dest_path)
#'bandwidth' option check
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth", bandwidth)
else:
raise error.TestFail(err)
else:
if status:
logging.debug("Expect error: %s", err)
else:
raise error.TestFail("Expect fail, but run successfully.")
#cleanup
finally:
try:
if vm.exists():
vm.destroy()
else:
raise error.TestFail("Domain is disappeared.")
finally:
vm.define(original_xml)
if os.path.exists(dest_path):
os.remove(dest_path)
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
# check the source disk
if not target:
raise error.TestFail("Require target disk to copy")
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s.", target, vm_name)
else:
raise error.TestFail("Can't find %s in domain %s." % (target, vm_name))
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
default_timeout = params.get("default_timeout", "300")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
rerun_flag = 0
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
if not dest_path:
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += "--raw"
if len(bandwidth):
options += "--bandwidth %s" % bandwidth
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
if not copy_to_nfs:
raise error.TestNAError("Bug will not fix:"
" https://bugzilla.redhat.com/show_bug."
"cgi?id=924151")
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s.", dest_path, expect)
else:
raise error.TestFail("%s format is not %s." % (dest_path, expect))
def blockcopy_chk():
"""
Raise TestFail when blockcopy hang with state change lock
"""
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise error.TestFail("Hit on bug: %s" % bug_url)
snap_path = ''
save_path = ''
try:
# Domain disk replacement with desire type
if replace_vm_disk:
utl.set_vm_disk(vm, params, tmp_dir)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command
if rerun_flag == 1:
options1 = "--wait --raw --finish --verbose"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise error.TestFail("Run blockcopy command fail.")
elif not os.path.exists(dest_path):
raise error.TestFail("Cannot find the created copy.")
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options,
**extra_dict)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise error.TestFail("Libvirtd service is dead.")
if not status_error:
blockcopy_chk()
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise error.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target,
"bandwidth", bandwidth)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise error.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
val = options.count("--pivot") + options.count("--finish")
if val == 0:
try:
finish_job(vm_name, target, default_timeout)
except JobTimeout, excpt:
raise error.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw"):
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
else:
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise error.TestFail("Hit on bug: %s" % bug_url)
raise error.TestFail(cmd_result.stderr)
else:
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
relative_path = params.get("relative_path")
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
if bandwidth_byte and not libvirt_version.version_compare(1, 3, 3):
raise exceptions.TestSkipError("--bytes option not supported in "
"current version")
if relative_path == "yes" and not libvirt_version.version_compare(3, 0, 0):
test.cancel("Forbid using relative path or file name only is added since libvirt-3.0.0")
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" % (target,
vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
options += " --bytes"
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(data_dir.get_tmp_dir(), "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" % (dest_path,
expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
This is a specific bug verify, so ignore status_error here.
"""
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
def _make_snapshot():
"""
Make external disk snapshot
"""
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
# Remove non-storage disk such as 'cdrom'
for disk in disks:
if disk.device != 'disk':
disks.remove(disk)
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if 'file' in disk_xml.source.attrs:
new_file = os.path.join(tmp_dir, "blockcopy_shallow.snap")
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif ('dev' in disk_xml.source.attrs or
'name' in disk_xml.source.attrs or
'pool' in disk_xml.source.attrs):
if (disk_xml.type_name == 'block' or
disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if 'name' in new_attrs:
del new_attrs['name']
del new_attrs['protocol']
elif 'pool' in new_attrs:
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
nfs_cleanup = False
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
# Make sure the new disk show up
utils_misc.wait_for(lambda: os.path.exists(dest_path), 5)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
if disk_source_protocol == 'iscsi':
emulated_iscsi.append(emu_image)
if disk_source_protocol == 'netfs':
nfs_cleanup = True
utl.set_vm_disk(vm, params, tmp_dir, test)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow:
_make_snapshot()
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine("--nvram")
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command to create destination file
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail: %s" %
cmd_result.stdout.strip() + cmd_result.stderr)
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
# Run the real testing command
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
# check BZ#1197592
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
if options.count('--bytes'):
bandwidth += 'B'
else:
bandwidth += 'M'
if not utl.check_blockjob(vm_name, target, "bandwidth",
bandwidth):
raise exceptions.TestFail("Check bandwidth failed")
val = options.count("--pivot") + options.count("--finish")
# Don't wait for job finish when using --byte option
val += options.count('--bytes')
if val == 0:
try:
finish_job(vm_name, target, timeout)
except JobTimeout as excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
else:
raise exceptions.TestFail(cmd_result.stdout.strip() + cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
# Commit id '4c297728' changed how virsh exits when
# unexpectedly failing due to timeout from a fail (1)
# to a success(0), so we need to look for a different
# marker to indicate the copy aborted. As "stdout: Now
# in mirroring phase" could be in stdout which fail the
# check, so also do check in libvirtd log to confirm.
if options.count("--timeout") and options.count("--wait"):
log_pattern = "Copy aborted"
if (re.search(log_pattern, cmd_result.stdout.strip()) or
chk_libvirtd_log(libvirtd_log_path,
log_pattern, "debug")):
logging.debug("Found success a timed out block copy")
else:
raise exceptions.TestFail("Expect fail, but run "
"successfully: %s" % bug_url)
finally:
# Recover VM may fail unexpectedly, we need using try/except to
# proceed the following cleanup steps
try:
# Abort exist blockjob to avoid any possible lock error
virsh.blockjob(vm_name, target, '--abort', ignore_status=True)
vm.destroy(gracefully=False)
# It may take a long time to shutdown the VM which has
# blockjob running
utils_misc.wait_for(
lambda: virsh.domstate(vm_name,
ignore_status=True).exit_status, 180)
if virsh.domain_exists(vm_name):
if active_snap or with_shallow:
option = "--snapshots-metadata"
else:
option = None
original_xml.sync(option)
else:
original_xml.define()
except Exception as e:
logging.error(e)
for disk in snapshot_external_disks:
if os.path.exists(disk):
os.remove(disk)
# Clean up libvirt pool, which may be created by 'set_vm_disk'
if disk_type == 'volume':
virsh.pool_destroy(pool_name, ignore_status=True, debug=True)
# Restore libvirtd conf and restart libvirtd
libvirtd_conf.restore()
libvirtd_utl.restart()
if libvirtd_log_path and os.path.exists(libvirtd_log_path):
os.unlink(libvirtd_log_path)
# Clean up NFS
try:
if nfs_cleanup:
utl.setup_or_cleanup_nfs(is_setup=False)
except Exception as e:
logging.error(e)
# Clean up iSCSI
try:
for iscsi_n in list(set(emulated_iscsi)):
utl.setup_or_cleanup_iscsi(is_setup=False, emulated_image=iscsi_n)
# iscsid will be restarted, so give it a break before next loop
time.sleep(5)
except Exception as e:
logging.error(e)
if os.path.exists(dest_path):
os.remove(dest_path)
if os.path.exists(snap_path):
os.remove(snap_path)
if os.path.exists(save_path):
os.remove(save_path)
# Restart virtlogd service to release VM log file lock
try:
path.find_command('virtlogd')
process.run('systemctl reset-failed virtlogd')
process.run('systemctl restart virtlogd ')
except path.CmdNotFoundError:
pass
def run(test, params, env):
"""
Test command: virsh blockjob.
This command can manage active block operations.
1. Positive testing
1.1 Query active block job for the specified disk.
1.2 Manager the active block job(cancle/pivot).
1.3 Adjust speed for the active block job.
2. Negative testing
2.1 Query active block job for a invalid disk.
2.2 Invalid bandwith test.
2.3 No active block job management.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
options = params.get("blockjob_options", "")
bandwidth = params.get("blockjob_bandwidth", "")
no_blockjob = "yes" == params.get("no_blockjob", "no")
invalid_disk = params.get("invalid_disk")
persistent_vm = "yes" == params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
target = get_disk(vm_name, test)
if not target:
test.fail("Require target disk to copy.")
# Prepare transient/persistent vm
original_xml = vm.backup_xml()
if not persistent_vm and vm.is_persistent():
vm.undefine("--nvram")
elif persistent_vm and not vm.is_persistent():
vm.define(original_xml)
#Create a block job, e.g.: blockcopy
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
dest_path = os.path.join(data_dir.get_tmp_dir(), tmp_file)
if not no_blockjob:
cmd_result = virsh.blockcopy(vm_name,
target,
dest_path,
"",
ignore_status=True,
debug=True)
status = cmd_result.exit_status
if status != 0:
test.error("Fail to create blockcopy job.")
# This option need blockjcopy job finish first
if options.count("--pivot"):
#Set default blockcopy timeout to 300 sec
timeout = 300
finish_job(vm_name, target, timeout, test)
if len(bandwidth):
options += "--bandwidth %s" % bandwidth
if invalid_disk:
target = invalid_disk
# Wait for few seconds to be more like human activity,
# otherwise, unexpected failure may happen.
time.sleep(3)
# Run virsh blockjob command
cmd_result = virsh.blockjob(vm_name,
target,
options,
ignore_status=True,
debug=True)
err = cmd_result.stderr.strip()
status = cmd_result.exit_status
# Check result
if not utils_libvirtd.libvirtd_is_running():
test.fail("Libvirtd service is dead.")
try:
if not status_error:
if status == 0:
#'abort' option check
if options.count("--abort"):
utl.check_blockjob(vm_name, target, "no_job", 0)
#'pivot' option check
if options.count("--pivot"):
if utl.check_blockjob(vm_name, target, "no_job", 0):
check_disk(vm_name, dest_path, test)
#'bandwidth' option check
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth", bandwidth)
else:
test.fail(err)
else:
if status:
logging.debug("Expect error: %s", err)
else:
test.fail("Expect fail, but run successfully.")
#cleanup
finally:
try:
if vm.exists():
vm.destroy()
else:
test.fail("Domain is disappeared.")
finally:
vm.define(original_xml)
if os.path.exists(dest_path):
os.remove(dest_path)
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options,
ignore_status=True, debug=True)
status = cmd_result.exit_status
except Exception, detail:
logging.error(detail)
if not utils_libvirtd.libvirtd_is_running():
raise error.TestFail("Libvirtd service is dead.")
# Check_result
try:
try:
if not status_error:
if status == 0:
check_xml(vm_name, target, dest_path, options)
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth", bandwidth)
if options.count("--pivot") + options.count("--finish") == 0:
finish_job(vm_name, target, default_timeout)
if options.count("--raw"):
check_format(dest_path, "raw")
else:
raise error.TestFail(cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
raise error.TestFail("Expect fail, but run successfully.")
except JobTimeout, excpt:
if not status_error:
raise error.TestFail("Run command failed: %s" % excpt)
finally:
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
bandwidth_byte = "yes" == params.get("bandwidth_byte", "no")
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
if bandwidth_byte and not libvirt_version.version_compare(1, 3, 3):
raise exceptions.TestSkipError("--bytes option not supported in "
"current version")
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" %
(target, vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if bandwidth_byte:
options += " --bytes"
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True,
'ignore_status': True,
'timeout': timeout
}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" % libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" %
(dest_path, expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
"""
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
def _blockcopy_cmd():
"""
Run blockcopy command
"""
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options,
**extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
if cmd_result.exit_status:
return False
elif "Copy aborted" in cmd_result.stdout:
return False
else:
return cmd_result
def _make_snapshot():
"""
Make external disk snapshot
"""
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if disk_xml.source.attrs.has_key('file'):
new_file = os.path.join(tmp_dir, "blockcopy_shallow.snap")
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif (disk_xml.source.attrs.has_key('dev')
or disk_xml.source.attrs.has_key('name')
or disk_xml.source.attrs.has_key('pool')):
if (disk_xml.type_name == 'block'
or disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if new_attrs.has_key('name'):
del new_attrs['name']
del new_attrs['protocol']
elif new_attrs.has_key('pool'):
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
nfs_cleanup = False
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
utl.set_vm_disk(vm, params, tmp_dir, test)
if disk_source_protocol == 'iscsi':
emulated_iscsi.append(emu_image)
if disk_source_protocol == 'netfs':
nfs_cleanup = True
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow:
_make_snapshot()
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail")
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
cmd_result = utils_misc.wait_for(_blockcopy_cmd, 10)
if not cmd_result:
raise exceptions.TestFail("Run blockcopy command fail")
status = 0
else:
cmd_result = virsh.blockcopy(vm_name, target, dest_path, options,
**extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
if options.count('--bytes'):
bandwidth += 'B'
else:
bandwidth += 'M'
if not utl.check_blockjob(vm_name, target, "bandwidth",
bandwidth):
raise exceptions.TestFail("Check bandwidth failed")
val = options.count("--pivot") + options.count("--finish")
# Don't wait for job finish when using --byte option
val += options.count('--bytes')
if val == 0:
try:
finish_job(vm_name, target, timeout)
except JobTimeout, excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name,
snap_opt,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name,
save_path,
ignore_status=True,
debug=True)
utl.check_exit_status(ret, active_error)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
else:
raise exceptions.TestFail(cmd_result.stderr)
else:
def run(test, params, env):
"""
Test command: virsh blockcopy.
This command can copy a disk backing image chain to dest.
1. Positive testing
1.1 Copy a disk to a new image file.
1.2 Reuse existing destination copy.
1.3 Valid blockcopy timeout and bandwidth test.
2. Negative testing
2.1 Copy a disk to a non-exist directory.
2.2 Copy a disk with invalid options.
2.3 Do block copy for a persistent domain.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
target = params.get("target_disk", "")
replace_vm_disk = "yes" == params.get("replace_vm_disk", "no")
disk_source_protocol = params.get("disk_source_protocol")
disk_type = params.get("disk_type")
pool_name = params.get("pool_name")
image_size = params.get("image_size")
emu_image = params.get("emulated_image")
copy_to_nfs = "yes" == params.get("copy_to_nfs", "no")
mnt_path_name = params.get("mnt_path_name")
options = params.get("blockcopy_options", "")
bandwidth = params.get("blockcopy_bandwidth", "")
default_timeout = int(params.get("default_timeout", "300"))
reuse_external = "yes" == params.get("reuse_external", "no")
persistent_vm = params.get("persistent_vm", "no")
status_error = "yes" == params.get("status_error", "no")
active_error = "yes" == params.get("active_error", "no")
active_snap = "yes" == params.get("active_snap", "no")
active_save = "yes" == params.get("active_save", "no")
check_state_lock = "yes" == params.get("check_state_lock", "no")
with_shallow = "yes" == params.get("with_shallow", "no")
with_blockdev = "yes" == params.get("with_blockdev", "no")
setup_libvirt_polkit = "yes" == params.get('setup_libvirt_polkit')
bug_url = params.get("bug_url", "")
timeout = int(params.get("timeout", 1200))
rerun_flag = 0
blkdev_n = None
back_n = 'blockdev-backing-iscsi'
snapshot_external_disks = []
# Skip/Fail early
if with_blockdev and not libvirt_version.version_compare(1, 2, 13):
raise exceptions.TestSkipError("--blockdev option not supported in "
"current version")
if not target:
raise exceptions.TestSkipError("Require target disk to copy")
if setup_libvirt_polkit and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("API acl test not supported in current"
" libvirt version")
if copy_to_nfs and not libvirt_version.version_compare(1, 1, 1):
raise exceptions.TestSkipError("Bug will not fix: %s" % bug_url)
# Check the source disk
if vm_xml.VMXML.check_disk_exist(vm_name, target):
logging.debug("Find %s in domain %s", target, vm_name)
else:
raise exceptions.TestFail("Can't find %s in domain %s" % (target,
vm_name))
original_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
tmp_dir = data_dir.get_tmp_dir()
# Prepare dest path params
dest_path = params.get("dest_path", "")
dest_format = params.get("dest_format", "")
# Ugh... this piece of chicanery brought to you by the QemuImg which
# will "add" the 'dest_format' extension during the check_format code.
# So if we create the file with the extension and then remove it when
# doing the check_format later, then we avoid erroneous failures.
dest_extension = ""
if dest_format != "":
dest_extension = ".%s" % dest_format
# Prepare for --reuse-external option
if reuse_external:
options += "--reuse-external --wait"
# Set rerun_flag=1 to do blockcopy twice, and the first time created
# file can be reused in the second time if no dest_path given
# This will make sure the image size equal to original disk size
if dest_path == "/path/non-exist":
if os.path.exists(dest_path) and not os.path.isdir(dest_path):
os.remove(dest_path)
else:
rerun_flag = 1
# Prepare other options
if dest_format == "raw":
options += " --raw"
if with_blockdev:
options += " --blockdev"
if len(bandwidth):
options += " --bandwidth %s" % bandwidth
if with_shallow:
options += " --shallow"
# Prepare acl options
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
extra_dict = {'uri': uri, 'unprivileged_user': unprivileged_user,
'debug': True, 'ignore_status': True, 'timeout': timeout}
libvirtd_utl = utils_libvirtd.Libvirtd()
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_conf["log_filters"] = '"3:json 1:libvirt 1:qemu"'
libvirtd_log_path = os.path.join(test.tmpdir, "libvirtd.log")
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_path
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd_utl.restart()
def check_format(dest_path, dest_extension, expect):
"""
Check the image format
:param dest_path: Path of the copy to create
:param expect: Expect image format
"""
# And now because the QemuImg will add the extension for us
# we have to remove it here.
path_noext = dest_path.strip(dest_extension)
params['image_name'] = path_noext
params['image_format'] = expect
image = qemu_storage.QemuImg(params, "/", path_noext)
if image.get_format() == expect:
logging.debug("%s format is %s", dest_path, expect)
else:
raise exceptions.TestFail("%s format is not %s" % (dest_path,
expect))
def _blockjob_and_libvirtd_chk(cmd_result):
"""
Raise TestFail when blockcopy fail with block-job-complete error or
blockcopy hang with state change lock.
"""
bug_url_ = "https://bugzilla.redhat.com/show_bug.cgi?id=1197592"
err_msg = "internal error: unable to execute QEMU command"
err_msg += " 'block-job-complete'"
if err_msg in cmd_result.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
err_pattern = "Timed out during operation: cannot acquire"
err_pattern += " state change lock"
ret = chk_libvirtd_log(libvirtd_log_path, err_pattern, "error")
if ret:
raise exceptions.TestFail("Hit on bug: %s" % bug_url_)
def _blockcopy_cmd():
"""
Run blockcopy command
"""
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
if cmd_result.exit_status:
return False
elif "Copy aborted" in cmd_result.stdout:
return False
else:
return cmd_result
def _make_snapshot():
"""
Make external disk snapshot
"""
snap_xml = snapshot_xml.SnapshotXML()
snapshot_name = "blockcopy_snap"
snap_xml.snap_name = snapshot_name
snap_xml.description = "blockcopy snapshot"
# Add all disks into xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disks = vmxml.devices.by_device_tag('disk')
new_disks = []
src_disk_xml = disks[0]
disk_xml = snap_xml.SnapDiskXML()
disk_xml.xmltreefile = src_disk_xml.xmltreefile
del disk_xml.device
del disk_xml.address
disk_xml.snapshot = "external"
disk_xml.disk_name = disk_xml.target['dev']
# Only qcow2 works as external snapshot file format, update it
# here
driver_attr = disk_xml.driver
driver_attr.update({'type': 'qcow2'})
disk_xml.driver = driver_attr
new_attrs = disk_xml.source.attrs
if disk_xml.source.attrs.has_key('file'):
new_file = os.path.join(tmp_dir, "blockcopy_shallow.snap")
snapshot_external_disks.append(new_file)
new_attrs.update({'file': new_file})
hosts = None
elif (disk_xml.source.attrs.has_key('dev') or
disk_xml.source.attrs.has_key('name') or
disk_xml.source.attrs.has_key('pool')):
if (disk_xml.type_name == 'block' or
disk_source_protocol == 'iscsi'):
disk_xml.type_name = 'block'
if new_attrs.has_key('name'):
del new_attrs['name']
del new_attrs['protocol']
elif new_attrs.has_key('pool'):
del new_attrs['pool']
del new_attrs['volume']
del new_attrs['mode']
back_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size="1G",
emulated_image=back_n)
emulated_iscsi.append(back_n)
cmd = "qemu-img create -f qcow2 %s 1G" % back_path
process.run(cmd, shell=True)
new_attrs.update({'dev': back_path})
hosts = None
new_src_dict = {"attrs": new_attrs}
if hosts:
new_src_dict.update({"hosts": hosts})
disk_xml.source = disk_xml.new_disk_source(**new_src_dict)
new_disks.append(disk_xml)
snap_xml.set_disks(new_disks)
snapshot_xml_path = snap_xml.xml
logging.debug("The snapshot xml is: %s" % snap_xml.xmltreefile)
options = "--disk-only --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(
vm_name, options, debug=True)
if snapshot_result.exit_status != 0:
raise exceptions.TestFail(snapshot_result.stderr)
snap_path = ''
save_path = ''
emulated_iscsi = []
try:
# Prepare dest_path
tmp_file = time.strftime("%Y-%m-%d-%H.%M.%S.img")
tmp_file += dest_extension
if not dest_path:
if with_blockdev:
blkdev_n = 'blockdev-iscsi'
dest_path = utl.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size=image_size,
emulated_image=blkdev_n)
emulated_iscsi.append(blkdev_n)
else:
if copy_to_nfs:
tmp_dir = "%s/%s" % (tmp_dir, mnt_path_name)
dest_path = os.path.join(tmp_dir, tmp_file)
# Domain disk replacement with desire type
if replace_vm_disk:
# Calling 'set_vm_disk' is bad idea as it left lots of cleanup jobs
# after test, such as pool, volume, nfs, iscsi and so on
# TODO: remove this function in the future
utl.set_vm_disk(vm, params, tmp_dir, test)
emulated_iscsi.append(emu_image)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_shallow:
_make_snapshot()
# Prepare transient/persistent vm
if persistent_vm == "no" and vm.is_persistent():
vm.undefine()
elif persistent_vm == "yes" and not vm.is_persistent():
new_xml.define()
# Run blockcopy command
if rerun_flag == 1:
options1 = "--wait %s --finish --verbose" % dest_format
if with_blockdev:
options1 += " --blockdev"
if with_shallow:
options1 += " --shallow"
cmd_result = virsh.blockcopy(vm_name, target,
dest_path, options1,
**extra_dict)
status = cmd_result.exit_status
if status != 0:
raise exceptions.TestFail("Run blockcopy command fail")
elif not os.path.exists(dest_path):
raise exceptions.TestFail("Cannot find the created copy")
cmd_result = utils_misc.wait_for(_blockcopy_cmd, 10)
if not cmd_result:
raise exceptions.TestFail("Run blockcopy command fail")
status = 0
else:
cmd_result = virsh.blockcopy(vm_name, target, dest_path,
options, **extra_dict)
_blockjob_and_libvirtd_chk(cmd_result)
status = cmd_result.exit_status
if not libvirtd_utl.is_running():
raise exceptions.TestFail("Libvirtd service is dead")
if not status_error:
if status == 0:
ret = utils_misc.wait_for(
lambda: check_xml(vm_name, target, dest_path, options), 5)
if not ret:
raise exceptions.TestFail("Domain xml not expected after"
" blockcopy")
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth", bandwidth)
if check_state_lock:
# Run blockjob pivot in subprocess as it will hang
# for a while, run blockjob info again to check
# job state
command = "virsh blockjob %s %s --pivot" % (vm_name,
target)
session = aexpect.ShellSession(command)
ret = virsh.blockjob(vm_name, target, "--info")
err_info = "cannot acquire state change lock"
if err_info in ret.stderr:
raise exceptions.TestFail("Hit on bug: %s" % bug_url)
utl.check_exit_status(ret, status_error)
session.close()
val = options.count("--pivot") + options.count("--finish")
if val == 0:
try:
finish_job(vm_name, target, default_timeout)
except JobTimeout, excpt:
raise exceptions.TestFail("Run command failed: %s" %
excpt)
if options.count("--raw") and not with_blockdev:
check_format(dest_path, dest_extension, dest_format)
if active_snap:
snap_path = "%s/%s.snap" % (tmp_dir, vm_name)
snap_opt = "--disk-only --atomic --no-metadata "
snap_opt += "vda,snapshot=external,file=%s" % snap_path
ret = virsh.snapshot_create_as(vm_name, snap_opt,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
if active_save:
save_path = "%s/%s.save" % (tmp_dir, vm_name)
ret = virsh.save(vm_name, save_path,
ignore_statues=True,
debug=True)
utl.check_exit_status(ret, active_error)
else:
raise exceptions.TestFail(cmd_result.stderr)
else:
ignore_status=True,
debug=True)
status = cmd_result.exit_status
except Exception, detail:
logging.error(detail)
if not utils_libvirtd.libvirtd_is_running():
raise error.TestFail("Libvirtd service is dead.")
# Check_result
try:
try:
if not status_error:
if status == 0:
check_xml(vm_name, target, dest_path, options)
if options.count("--bandwidth"):
utl.check_blockjob(vm_name, target, "bandwidth",
bandwidth)
if options.count("--pivot") + options.count(
"--finish") == 0:
finish_job(vm_name, target, default_timeout)
if options.count("--raw"):
check_format(dest_path, dest_extension, dest_format)
else:
raise error.TestFail(cmd_result.stderr)
else:
if status:
logging.debug("Expect error: %s", cmd_result.stderr)
else:
# Commit id '4c297728' changed how virsh exits when
# unexpectedly failing due to timeout from a fail (1)
# to a success(0), so we need to look for a different
# marker to indicate the copy aborted
