domid = vm.get_id()
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
elif domid and vm_ref == "hex_id":
vm_ref = hex(int(domid))
try:
# Run virsh command
cmd_result = virsh.qemu_agent_command(vm_ref,
cmd,
options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not libvirtd_inst.is_running():
raise error.TestFail("Libvirtd is not running after run command.")
if status_error:
if not status:
# Bug 853673
err_msg = "Expect fail but run successfully, please check Bug: "
err_msg += "https://bugzilla.redhat.com/show_bug.cgi?id=853673"
err_msg += " for more info"
raise error.TestFail(err_msg)
else:
def run(test, params, env):
"""
Test command: virsh qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_cmd = params.get("status_cmd", "")
freeze_cmd = params.get("freeze_cmd", "")
thaw_cmd = params.get("thaw_cmd", "")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
def get_dirty(session, frozen=False):
"""
Get dirty data of guest
"""
try:
data_cmd = "cat /proc/meminfo | grep Dirty"
if not frozen:
result = utils_misc.wait_for(
lambda: int(
session.cmd_output(data_cmd).strip().split()[1]) !=
0, 60)
if result:
return int(
session.cmd_output(data_cmd).strip().split()[1])
else:
return 0
dirty_info = session.cmd_output(data_cmd).strip()
return int(dirty_info.split()[1])
else:
result = utils_misc.wait_for(
lambda: int(
session.cmd_output(data_cmd).strip().split()[1]) ==
0, 60)
if result:
return 0
else:
return int(
session.cmd_output(data_cmd).strip().split()[1])
except (IndexError, ValueError) as details:
test.fail("Get dirty info failed: %s" % details)
device_source_path = os.path.join(data_dir.get_tmp_dir(), "disk.img")
device_source = libvirt.create_local_disk("file",
path=device_source_path,
disk_format="qcow2")
vm.prepare_guest_agent()
# Do operation before freeze guest filesystem
session = vm.wait_for_login()
tmp_file = "/mnt/test.file"
try:
# Create extra image and attach to guest, then mount
old_parts = utils_disk.get_parts_list(session)
ret = virsh.attach_disk(vm_name, device_source, "vdd")
if ret.exit_status:
test.fail("Attaching device failed before testing agent:%s" %
ret.stdout.strip())
time.sleep(1)
new_parts = utils_disk.get_parts_list(session)
added_part = list(set(new_parts).difference(set(old_parts)))
session.cmd("mkfs.ext3 -F /dev/{0} && mount /dev/{0} /mnt".format(
added_part[0]))
# Generate dirty memory
session.cmd("rm -f %s" % tmp_file)
session.cmd_output("cp /dev/zero %s 2>/dev/null &" % tmp_file)
# Get original dirty data
org_dirty_info = get_dirty(session)
fz_cmd_result = virsh.qemu_agent_command(vm_name,
freeze_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(fz_cmd_result)
# Get frozen dirty data
fz_dirty_info = get_dirty(session, True)
st_cmd_result = virsh.qemu_agent_command(vm_name,
status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("frozen"):
test.fail("Guest filesystem status is not frozen: %s" %
st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name,
thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name,
status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("thawed"):
test.fail("Guest filesystem status is not thawed: %s" %
st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
test.fail("The thawed dirty data should not be 0!")
if fz_dirty_info:
test.fail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
finally:
xml_backup.sync()
os.remove(device_source_path)
def run(test, params, env):
"""
Test command: virsh qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("vm_ref", "domname")
vm_state = params.get("vm_state", "running")
cmd = params.get("agent_cmd", "")
options = params.get("options", "")
needs_agent = "yes" == params.get("needs_agent", "yes")
status_error = "yes" == params.get("status_error", "no")
if not status_error and options:
option = options.split()[0]
test_cmd = "qemu-agent-command"
if virsh.has_command_help_match(test_cmd, option) is None:
test.cancel("The current libvirt doesn't support"
" %s option for %s" % (option, test_cmd))
guest_cpu_busy = "yes" == params.get("guest_cpu_busy", "no")
password = params.get("password", None)
domuuid = vm.get_uuid()
domid = ""
xml_file = os.path.join(data_dir.get_tmp_dir(), "vm.xml")
virsh.dumpxml(vm_name, extra="--inactive", to_file=xml_file)
libvirtd_inst = utils_libvirtd.Libvirtd()
# Prepare domain
try:
reset_domain(test, vm, vm_state, needs_agent, guest_cpu_busy, password)
except exceptions.TestCancel as details:
reset_env(vm_name, xml_file)
test.cancel(details)
except Exception as details:
reset_env(vm_name, xml_file)
test.fail(details)
if vm_state != "shut off":
domid = vm.get_id()
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
elif domid and vm_ref == "hex_id":
vm_ref = hex(int(domid))
try:
if vm_state == "running" and needs_agent:
# Check whether qemu-guest-agent is active in guest
session = vm.wait_for_login()
def verify_alive():
return utils_misc.get_guest_service_status(
session, 'qemu-guest-agent') == 'active'
if not utils_misc.wait_for(verify_alive, 30):
test.error('Service "qemu-guest-agent" is not active')
# Run virsh command
cmd_result = virsh.qemu_agent_command(vm_ref,
cmd,
options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not libvirtd_inst.is_running():
test.fail("Libvirtd is not running after run command.")
if status_error:
if not status:
# Bug 853673
err_msg = "Expect fail but run successfully, please check Bug: "
err_msg += "https://bugzilla.redhat.com/show_bug.cgi?id=853673"
err_msg += " for more info"
test.fail(err_msg)
else:
logging.debug("Command failed as expected.")
else:
if status:
if cmd_result.stderr.count("not responding"):
test.cancel(cmd_result.stderr.strip())
if cmd.count("guest-shutdown") and\
cmd_result.stderr.count("Missing monitor reply object"):
err_msg = "Please check bug: "
err_msg += "https://bugzilla.redhat.com/show_bug.cgi?id="
err_msg += "1050843 for more info"
logging.error(err_msg)
if "--async" in options:
err_msg = "Please check bug: "
err_msg += "https://bugzilla.redhat.com/show_bug.cgi?id="
err_msg += "1099060 for more info"
logging.error(err_msg)
test.fail("Expect succeed, but run fail.")
finally:
# Cleanup
reset_env(vm_name, xml_file)
if not libvirtd_inst.is_running():
libvirtd_inst.restart()
def run(test, params, env):
"""
Test command: virsh qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_cmd = params.get("status_cmd", "")
freeze_cmd = params.get("freeze_cmd", "")
thaw_cmd = params.get("thaw_cmd", "")
tmp_file = params.get("tmp_file", "/tmp/test.file")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
def get_dirty(session, frozen=False):
"""
Get dirty data of guest
"""
try:
data_cmd = "cat /proc/meminfo | grep Dirty"
if not frozen:
result = utils_misc.wait_for(
lambda: int(
session.cmd_output(data_cmd).strip().split()[1]) !=
0, 60)
if result:
return int(
session.cmd_output(data_cmd).strip().split()[1])
else:
return 0
dirty_info = session.cmd_output(data_cmd).strip()
return int(dirty_info.split()[1])
else:
result = utils_misc.wait_for(
lambda: int(
session.cmd_output(data_cmd).strip().split()[1]) ==
0, 60)
if result:
return 0
else:
return int(
session.cmd_output(data_cmd).strip().split()[1])
except (IndexError, ValueError), details:
raise error.TestFail("Get dirty info failed: %s" % details)
vm.prepare_guest_agent()
# Do operation before freeze guest filesystem
session = vm.wait_for_login()
try:
session.cmd("rm -f %s" % tmp_file)
session.cmd_output("cp /dev/zero %s 2>/dev/null &" % tmp_file)
time.sleep(5)
# Get original dirty data
org_dirty_info = get_dirty(session)
fz_cmd_result = virsh.qemu_agent_command(vm_name,
freeze_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(fz_cmd_result)
# Wait for freeze filesystem
time.sleep(1)
# Get frozen dirty data
fz_dirty_info = get_dirty(session, True)
st_cmd_result = virsh.qemu_agent_command(vm_name,
status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("frozen"):
raise error.TestFail(
"Guest filesystem status is not frozen: %s" %
st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name,
thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name,
status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("thawed"):
raise error.TestFail(
"Guest filesystem status is not thawed: %s" %
st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
raise error.TestFail("The thawed dirty data should not be 0!")
if fz_dirty_info:
raise error.TestFail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
def run(test, params, env):
"""
Test command: virsh qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_cmd = params.get("status_cmd", "")
freeze_cmd = params.get("freeze_cmd", "")
thaw_cmd = params.get("thaw_cmd", "")
tmp_file = params.get("tmp_file", "/tmp/test.file")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml.VMXML.set_agent_channel(vm_name)
vm.start()
session = vm.wait_for_login()
session.cmd("qemu-ga -d")
stat_ps = session.cmd_status("ps aux |grep [q]emu-ga")
if stat_ps:
session.close()
xml_backup.sync()
raise error.TestError("Fail to start qemu-guest-agent!")
try:
def get_dirty(session, frozen=False):
"""
Get dirty data of guest
"""
try:
data_cmd = "cat /proc/meminfo | grep Dirty"
if not frozen:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) != 0,
60)
if result:
return int(session.cmd_output(data_cmd).strip().
split()[1])
else:
return 0
dirty_info = session.cmd_output(data_cmd).strip()
return int(dirty_info.split()[1])
else:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) == 0,
60)
if result:
return 0
else:
return int(session.cmd_output(data_cmd).strip().
split()[1])
except (IndexError, ValueError), details:
raise error.TestFail("Get dirty info failed: %s" % details)
# Do operation before freeze guest filesystem
session.cmd("rm -f %s" % tmp_file)
session.cmd_output("cp /dev/zero %s 2>/dev/null &" % tmp_file)
time.sleep(5)
# Get original dirty data
org_dirty_info = get_dirty(session)
fz_cmd_result = virsh.qemu_agent_command(vm_name, freeze_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(fz_cmd_result)
# Wait for freeze filesystem
time.sleep(1)
# Get frozen dirty data
fz_dirty_info = get_dirty(session, True)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("frozen"):
raise error.TestFail("Guest filesystem status is not frozen: %s"
% st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name, thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("thawed"):
raise error.TestFail("Guest filesystem status is not thawed: %s"
% st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
raise error.TestFail("The thawed dirty data should not be 0!")
if fz_dirty_info:
raise error.TestFail("The frozen dirty data should be 0!")
raise error.TestFail("Guest filesystem status is not frozen: %s"
% st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name, thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("thawed"):
raise error.TestFail("Guest filesystem status is not thawed: %s"
% st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
raise error.TestFail("The thawed dirty data should not be 0!")
if fz_dirty_info:
raise error.TestFail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
xml_backup.sync()
def run(test, params, env):
"""
Test command: virsh qemu-agent-command.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_cmd = params.get("status_cmd", "")
freeze_cmd = params.get("freeze_cmd", "")
thaw_cmd = params.get("thaw_cmd", "")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
def get_dirty(session, frozen=False):
"""
Get dirty data of guest
"""
try:
data_cmd = "cat /proc/meminfo | grep Dirty"
if not frozen:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) != 0,
60)
if result:
return int(session.cmd_output(data_cmd).strip().
split()[1])
else:
return 0
dirty_info = session.cmd_output(data_cmd).strip()
return int(dirty_info.split()[1])
else:
result = utils_misc.wait_for(lambda:
int(session.
cmd_output(data_cmd).
strip().split()[1]) == 0,
60)
if result:
return 0
else:
return int(session.cmd_output(data_cmd).strip().
split()[1])
except (IndexError, ValueError) as details:
test.fail("Get dirty info failed: %s" % details)
device_source_path = os.path.join(data_dir.get_tmp_dir(), "disk.img")
device_source = libvirt.create_local_disk("file", path=device_source_path,
disk_format="qcow2")
vm.prepare_guest_agent()
# Do operation before freeze guest filesystem
session = vm.wait_for_login()
tmp_file = "/mnt/test.file"
try:
# Create extra image and attach to guest, then mount
old_parts = libvirt.get_parts_list(session)
ret = virsh.attach_disk(vm_name, device_source, "vdd")
if ret.exit_status:
test.fail("Attaching device failed before testing agent:%s" % ret.stdout.strip())
time.sleep(1)
new_parts = libvirt.get_parts_list(session)
added_part = list(set(new_parts).difference(set(old_parts)))
session.cmd("mkfs.ext3 -F /dev/{0} && mount /dev/{0} /mnt".format(added_part[0]))
# Generate dirty memory
session.cmd("rm -f %s" % tmp_file)
session.cmd_output("cp /dev/zero %s 2>/dev/null &" % tmp_file)
# Get original dirty data
org_dirty_info = get_dirty(session)
fz_cmd_result = virsh.qemu_agent_command(vm_name, freeze_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(fz_cmd_result)
# Get frozen dirty data
fz_dirty_info = get_dirty(session, True)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("frozen"):
test.fail("Guest filesystem status is not frozen: %s"
% st_cmd_result.stdout.strip())
tw_cmd_result = virsh.qemu_agent_command(vm_name, thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name, status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.strip().count("thawed"):
test.fail("Guest filesystem status is not thawed: %s"
% st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
test.fail("The thawed dirty data should not be 0!")
if fz_dirty_info:
test.fail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
finally:
xml_backup.sync()
os.remove(device_source_path)
if vm_state != "shut off":
domid = vm.get_id()
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = domid
elif vm_ref == "domuuid":
vm_ref = domuuid
elif domid and vm_ref == "hex_id":
vm_ref = hex(int(domid))
try:
# Run virsh command
cmd_result = virsh.qemu_agent_command(vm_ref, cmd, options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not libvirtd_inst.is_running():
raise error.TestFail("Libvirtd is not running after run command.")
if status_error:
if not status:
# Bug 853673
err_msg = "Expect fail but run successfully, please check Bug: "
err_msg += "https://bugzilla.redhat.com/show_bug.cgi?id=853673"
err_msg += " for more info"
raise error.TestFail(err_msg)
else:
logging.debug("Command failed as expected.")
tw_cmd_result = virsh.qemu_agent_command(vm_name,
thaw_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(tw_cmd_result)
# Get thawed dirty data
tw_dirty_info = get_dirty(session)
st_cmd_result = virsh.qemu_agent_command(vm_name,
status_cmd,
ignore_status=True,
debug=True)
libvirt.check_exit_status(st_cmd_result)
if not st_cmd_result.stdout.count("thawed"):
raise error.TestFail("Guest filesystem status is not thawed: %s" %
st_cmd_result.stdout.strip())
logging.info("Original dirty data: %s" % org_dirty_info)
logging.info("Frozen dirty data: %s" % fz_dirty_info)
logging.info("Thawed dirty data: %s" % tw_dirty_info)
if not tw_dirty_info or not org_dirty_info:
raise error.TestFail("The thawed dirty data should not be 0!")
if fz_dirty_info:
raise error.TestFail("The frozen dirty data should be 0!")
finally:
# Thaw the file system that remove action can be done
virsh.qemu_agent_command(vm_name, thaw_cmd, ignore_status=True)
session.cmd("rm -f %s" % tmp_file)
session.close()
xml_backup.sync()