def set_vm_block_domblkthreshold(vm_name, target_device, threshold, **dargs):
"""
Set VM block threshold on specific target device.
:param vm_name: VM name.
:param target_device: target device in VM
:param threshold: threshold value with specific unit such as 100M
:param dargs: mutable parameter dict
"""
ret = virsh.domblkthreshold(vm_name, target_device, threshold, **dargs)
libvirt.check_exit_status(ret)
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(test, params, env):
"""
Test the pull-mode backup function
Steps:
1. create a vm with extra disk vdb
2. create some data on vdb
3. start a pull mode full backup on vdb
4. monitor block-threshold event on scratch file/dev
5. create some data on vdb's same position as step 2 to trigger event
6. check the block-threshold event captured
"""
# Basic case config
hotplug_disk = "yes" == params.get("hotplug_disk", "no")
original_disk_size = params.get("original_disk_size", "100M")
original_disk_type = params.get("original_disk_type", "local")
original_disk_target = params.get("original_disk_target", "vdb")
event_type = params.get("event_type")
usage_threshold = params.get("usage_threshold", "100")
tmp_dir = data_dir.get_tmp_dir()
local_hostname = params.get("loal_hostname", "localhost")
# Backup config
scratch_type = params.get("scratch_type", "file")
reuse_scratch_file = "yes" == params.get("reuse_scratch_file")
scratch_blkdev_size = params.get("scratch_blkdev_size", original_disk_size)
# NBD service config
nbd_protocol = params.get("nbd_protocol", "unix")
nbd_socket = params.get("nbd_socket", "/tmp/pull_backup.socket")
nbd_tcp_port = params.get("nbd_tcp_port", "10809")
nbd_hostname = local_hostname
# LUKS config
scratch_luks_encrypted = "yes" == params.get("scratch_luks_encrypted")
luks_passphrase = params.get("luks_passphrase", "password")
# Open a new virsh session for event monitor
virsh_session = aexpect.ShellSession(virsh.VIRSH_EXEC, auto_close=True)
# Cancel the test if libvirt support related functions
if not libvirt_version.version_compare(7, 0, 0):
test.cancel("Current libvirt version doesn't support "
"event monitor for incremental backup.")
def get_backup_disk_index(vm_name, disk_name):
"""
Get the index of the backup disk to be monitored by the virsh event
:param vm_name: vm name
:param disk_name: virtual disk name, such as 'vdb'
:return: the index of the virtual disk in backup xml
"""
backup_xml = virsh.backup_dumpxml(vm_name).stdout.strip()
logging.debug("%s's current backup xml is: %s" % (vm_name, backup_xml))
backup_xml_dom = xml_utils.XMLTreeFile(backup_xml)
index_xpath = "/disks/disk"
for disk_element in backup_xml_dom.findall(index_xpath):
if disk_element.get("name") == disk_name:
return disk_element.get("index")
def is_event_captured(virsh_session, re_pattern):
"""
Check if event captured
:param virsh_session: the virsh session of the event monitor
:param re_pattern: the re pattern used to represent the event
:return: True means event captured, False means not
"""
ret_output = virsh_session.get_stripped_output()
if (not re.search(re_pattern, ret_output, re.IGNORECASE)):
return False
logging.debug("event monitor output: %s", ret_output)
return True
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Make sure thedisk_element.getre is no checkpoint metadata before test
utils_backup.clean_checkpoints(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
utils_backup.enable_inc_backup_for_vm(vm)
# Prepare libvirt secret
if scratch_luks_encrypted:
utils_secret.clean_up_secrets()
luks_secret_uuid = libvirt.create_secret(params)
virsh.secret_set_value(luks_secret_uuid,
luks_passphrase,
encode=True,
debug=True)
# Prepare the disk to be backuped.
disk_params = {}
disk_path = ""
image_name = "{}_image.qcow2".format(original_disk_target)
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, original_disk_size,
"qcow2")
disk_params = {
"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": original_disk_target,
"source_file": disk_path
}
disk_params["target_dev"] = original_disk_target
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name, disk_xml, flagstr="--config", debug=True)
vm.start()
session = vm.wait_for_login()
new_disks_in_vm = list(utils_disk.get_linux_disks(session).keys())
session.close()
if len(new_disks_in_vm) != 1:
test.fail("Test disk not prepared in vm")
# Use the newly added disk as the test disk
test_disk_in_vm = "/dev/" + new_disks_in_vm[0]
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
vm_disks = list(vmxml.get_disk_all().keys())
checkpoint_list = []
backup_file_list = []
# Prepare backup xml
backup_params = {"backup_mode": "pull"}
# Set libvirt default nbd export name and bitmap name
nbd_export_name = original_disk_target
nbd_bitmap_name = "backup-" + original_disk_target
backup_server_dict = {}
if nbd_protocol == "unix":
backup_server_dict["transport"] = "unix"
backup_server_dict["socket"] = nbd_socket
else:
backup_server_dict["name"] = nbd_hostname
backup_server_dict["port"] = nbd_tcp_port
backup_params["backup_server"] = backup_server_dict
backup_disk_xmls = []
for vm_disk in vm_disks:
backup_disk_params = {"disk_name": vm_disk}
if vm_disk != original_disk_target:
backup_disk_params["enable_backup"] = "no"
else:
backup_disk_params["enable_backup"] = "yes"
backup_disk_params["disk_type"] = scratch_type
# Prepare nbd scratch file/dev params
scratch_params = {"attrs": {}}
scratch_path = None
if scratch_type == "file":
scratch_file_name = "scratch_file"
scratch_path = os.path.join(tmp_dir, scratch_file_name)
if reuse_scratch_file:
libvirt.create_local_disk("file", scratch_path,
original_disk_size, "qcow2")
scratch_params["attrs"]["file"] = scratch_path
elif scratch_type == "block":
scratch_path = libvirt.setup_or_cleanup_iscsi(
is_setup=True, image_size=scratch_blkdev_size)
scratch_params["attrs"]["dev"] = scratch_path
else:
test.fail("We do not support backup scratch type: '%s'" %
scratch_type)
if scratch_luks_encrypted:
encryption_dict = {
"encryption": "luks",
"secret": {
"type": "passphrase",
"uuid": luks_secret_uuid
}
}
scratch_params["encryption"] = encryption_dict
logging.debug("scratch params: %s", scratch_params)
backup_disk_params["backup_scratch"] = scratch_params
backup_disk_xml = utils_backup.create_backup_disk_xml(
backup_disk_params)
backup_disk_xmls.append(backup_disk_xml)
logging.debug("disk list %s", backup_disk_xmls)
backup_xml = utils_backup.create_backup_xml(backup_params,
backup_disk_xmls)
logging.debug("Backup Xml: %s", backup_xml)
# Prepare checkpoint xml
checkpoint_name = "checkpoint"
checkpoint_list.append(checkpoint_name)
cp_params = {"checkpoint_name": checkpoint_name}
cp_params["checkpoint_desc"] = params.get("checkpoint_desc",
"desc of cp")
disk_param_list = []
for vm_disk in vm_disks:
cp_disk_param = {"name": vm_disk}
if vm_disk != original_disk_target:
cp_disk_param["checkpoint"] = "no"
else:
cp_disk_param["checkpoint"] = "bitmap"
cp_disk_bitmap = params.get("cp_disk_bitmap")
if cp_disk_bitmap:
cp_disk_param["bitmap"] = cp_disk_bitmap
disk_param_list.append(cp_disk_param)
checkpoint_xml = utils_backup.create_checkpoint_xml(
cp_params, disk_param_list)
logging.debug("Checkpoint Xml: %s", checkpoint_xml)
# Generate some random data in vm's test disk
def dd_data_to_testdisk():
"""
Generate some data to vm's test disk
"""
dd_count = "1"
dd_seek = "10"
dd_bs = "1M"
session = vm.wait_for_login()
utils_disk.dd_data_to_vm_disk(session, test_disk_in_vm, dd_bs,
dd_seek, dd_count)
session.close()
dd_data_to_testdisk()
# Start backup
backup_options = backup_xml.xml + " " + checkpoint_xml.xml
if reuse_scratch_file:
backup_options += " --reuse-external"
backup_result = virsh.backup_begin(vm_name, backup_options, debug=True)
# Start to monitor block-threshold of backup disk's scratch file/dev
backup_disk_index = get_backup_disk_index(vm_name,
original_disk_target)
if not backup_disk_index:
test.fail("Backup xml has no index for disks.")
backup_disk_obj = original_disk_target + "[%s]" % backup_disk_index
virsh.domblkthreshold(
vm_name, original_disk_target + "[%s]" % backup_disk_index,
usage_threshold)
event_cmd = "event %s %s --loop" % (vm_name, event_type)
virsh_session.sendline(event_cmd)
# Generate some random data to same position of vm's test disk
dd_data_to_testdisk()
# Check if the block-threshold event captured by monitor
if event_type == "block-threshold":
event_pattern = (".*block-threshold.*%s.*%s\[%s\].* %s .*" %
(vm_name, original_disk_target, backup_disk_index,
usage_threshold))
if not utils_misc.wait_for(
lambda: is_event_captured(virsh_session, event_pattern), 10):
test.fail("Event not captured by event monitor")
# Abort backup job
virsh.domjobabort(vm_name, debug=True)
finally:
# Remove checkpoints
if "checkpoint_list" in locals() and checkpoint_list:
for checkpoint_name in checkpoint_list:
virsh.checkpoint_delete(vm_name, checkpoint_name)
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
# Remove libvirt secret
if "luks_secret_uuid" in locals():
virsh.secret_undefine(luks_secret_uuid, ignore_status=True)
# Remove iscsi devices
if scratch_type == "block":
libvirt.setup_or_cleanup_iscsi(False)
# Remove scratch file
if "scratch_path" in locals():
if scratch_type == "file" and os.path.exists(scratch_path):
os.remove(scratch_path)
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 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()
try:
for event in events_list:
logging.debug("Current event is: %s", event)
if event in ['start', 'restore', 'create', 'edit', 'define', 'undefine', 'crash']:
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=60)
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, "''", 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/")
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)
return [(dom.name, event) for event in expected_events_list]