def run(test, params, env):
"""
Test command: virsh domxml-to-native.
Convert domain XML config to a native guest configuration format.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domxml-from-native operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
def buildcmd(arglist):
"""
Return a list of arguments of qemu command.
Return a list based on the input string where each list element
is put together with care to pair up options with their argument
rather than being on separate lines. Thus rather than having
"-option" "argument" in separate list elements, they will be in
one element "-option argument". Take care to note the argument to
an option may not be required. This will make it easier to determine
what is causing the failure when printing error messages.
"""
# First separate everything by the first space into a list
elems = arglist.split("\x20")
# Peruse the list to build up a formatted output retlist
retlist = []
i = 0
skip = False
for e in elems:
# If 'skip' is True, then we've appended an option and argument
if skip:
skip = False
i = i + 1
continue
# Need a peek at the next element
enext = elems[i + 1]
# If current and next element starts with "-", then the
# is not an argument to the current, thus we just append.
# Same for anything we find that doesn't start with a "-"
if (e[0] == "-" and enext[0] == "-") or e[0] != "-":
retlist.append(e)
else:
# Append this and the next and set our skip flag
retlist.append(e + " " + enext)
skip = True
i = i + 1
# Now build a list where the
return retlist
def filtlist(arglist):
"""
Return a filtered list of arguments.
Walk through the supplied list to filter out things that will be
known to be different depending on the running environment.
"""
retlist = []
for arg in arglist:
if re.search("mode=readline", arg):
continue
elif re.search("mac=", arg):
continue
elif re.search("127.0.0.1:", arg):
continue
elif re.search("tap", arg):
continue
# Upstream libvirt commit id 'e8400564':
# XMLToNative: Don't show -S
elif re.search("-S", arg):
continue
retlist.append(arg)
return retlist
def compare(conv_arg):
"""
Compare converted information with vm's information.
:param conv_arg : Converted information.
:return: True if converted information has no different from
vm's information.
"""
pid = vm.get_pid()
cmdline_tmp = utils.system_output("cat -v /proc/%d/cmdline" % pid)
# Output has a trailing '^@' which gets converted into an empty
# element when spliting by '\x20', so strip it on the end.
cmdline = re.sub(r"\^@", " ", cmdline_tmp).strip(" ")
# Fedora 19 replaces the /usr/bin/qemu-kvm with the string
# "/usr/bin/qemu-system-x86_64 -machine accel=kvm", so let's
# do the same if we find "/usr/bin/qemu-kvm" in the incoming
# argument list and we find "qemu-system-x86_64 -machine accel=kvm"
# in the running guest's cmdline
if (
conv_arg.find("/usr/bin/qemu-kvm") != 1
and cmdline.find("/usr/bin/qemu-system-x86_64 -machine accel=kvm") != -1
):
cmdline = re.sub(r"/usr/bin/qemu-system-x86_64 -machine accel=kvm", "/usr/bin/qemu-kvm", cmdline)
# Now prepend the various environment variables that will be in
# the conv_arg, but not in the actual command
tmp = (
re.search("LC_ALL.[^\s]\s", conv_arg).group(0)
+ re.search("PATH.[^\s]+\s", conv_arg).group(0)
+ re.search("QEMU_AUDIO_DRV.[^\s]+\s", conv_arg).group(0)
)
qemu_arg = tmp + cmdline
conv_arg_lines = buildcmd(conv_arg)
qemu_arg_lines = buildcmd(qemu_arg)
diff1 = filtlist(tuple(x for x in conv_arg_lines if x not in set(qemu_arg_lines)))
if diff1:
logging.debug("Found the following in conv_arg not in qemu_arg:")
for elem in diff1:
logging.debug("\t%s", elem)
diff2 = filtlist(tuple(x for x in qemu_arg_lines if x not in set(conv_arg_lines)))
if diff2:
logging.debug("Found the following in qemu_arg not in conv_arg:")
for elem in diff2:
logging.debug("\t%s", elem)
if diff1 or diff2:
return False
return True
# run test case
dtn_format = params.get("dtn_format")
file_xml = params.get("dtn_file_xml")
extra_param = params.get("dtn_extra_param")
libvirtd = params.get("libvirtd")
status_error = params.get("status_error")
virsh.dumpxml(vm_name, extra="", to_file=file_xml)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
ret = virsh.domxml_to_native(dtn_format, file_xml, extra_param, ignore_status=True)
status = ret.exit_status
conv_arg = ret.stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# clean up
if os.path.exists(file_xml):
os.remove(file_xml)
# check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
if compare(conv_arg) is not True:
raise error.TestFail("Test failed!")
def run(test, params, env):
"""
Test command: virsh domxml-to-native.
Convert domain XML config to a native guest configuration format.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domxml-from-native operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
def buildcmd(arglist):
"""
Return a list of arguments of qemu command.
Return a list based on the input string where each list element
is put together with care to pair up options with their argument
rather than being on separate lines. Thus rather than having
"-option" "argument" in separate list elements, they will be in
one element "-option argument". Take care to note the argument to
an option may not be required. This will make it easier to determine
what is causing the failure when printing error messages.
"""
# First separate everything by the first space into a list
elems = arglist.split('\x20')
# Peruse the list to build up a formatted output retlist
retlist = []
i = 0
skip = False
for e in elems:
# If 'skip' is True, then we've appended an option and argument
if skip:
skip = False
i = i + 1
continue
# Need a peek at the next element
enext = elems[i + 1]
# If current and next element starts with "-", then the
# is not an argument to the current, thus we just append.
# Same for anything we find that doesn't start with a "-"
if (e[0] == '-' and enext[0] == '-') or e[0] != '-':
retlist.append(e)
else:
# Append this and the next and set our skip flag
retlist.append(e + " " + enext)
skip = True
i = i + 1
# Now build a list where the
return retlist
def filtlist(arglist):
"""
Return a filtered list of arguments.
Walk through the supplied list to filter out things that will be
known to be different depending on the running environment.
"""
retlist = []
for arg in arglist:
if re.search("mode=readline", arg):
continue
elif re.search("mac=", arg):
continue
elif re.search("127.0.0.1:", arg):
continue
elif re.search("tap", arg):
continue
# Upstream libvirt commit id 'e8400564':
# XMLToNative: Don't show -S
elif re.search("-S", arg):
continue
elif re.search("socket,id=", arg):
continue
retlist.append(arg)
return retlist
def compare(conv_arg):
"""
Compare converted information with vm's information.
:param conv_arg : Converted information.
:return: True if converted information has no different from
vm's information.
"""
pid = vm.get_pid()
cmdline_tmp = utils.system_output("cat -v /proc/%d/cmdline" % pid)
# Output has a trailing '^@' which gets converted into an empty
# element when spliting by '\x20', so strip it on the end.
cmdline = re.sub(r'\^@', ' ', cmdline_tmp).strip(' ')
# Fedora 19 replaces the /usr/bin/qemu-kvm with the string
# "/usr/bin/qemu-system-x86_64 -machine accel=kvm", so let's
# do the same if we find "/usr/bin/qemu-kvm" in the incoming
# argument list and we find "qemu-system-x86_64 -machine accel=kvm"
# in the running guest's cmdline
if conv_arg.find("/usr/bin/qemu-kvm") != 1 and \
cmdline.find("/usr/bin/qemu-system-x86_64 -machine accel=kvm") != -1:
cmdline = re.sub(r"/usr/bin/qemu-system-x86_64 -machine accel=kvm",
"/usr/bin/qemu-kvm", cmdline)
# Now prepend the various environment variables that will be in
# the conv_arg, but not in the actual command
tmp = re.search('LC_ALL.[^\s]\s', conv_arg).group(0) +\
re.search('PATH.[^\s]+\s', conv_arg).group(0) +\
re.search('QEMU_AUDIO_DRV.[^\s]+\s', conv_arg).group(0)
qemu_arg = tmp + cmdline
conv_arg_lines = buildcmd(conv_arg)
qemu_arg_lines = buildcmd(qemu_arg)
diff1 = filtlist(tuple(x for x in conv_arg_lines
if x not in set(qemu_arg_lines)))
if diff1:
logging.debug("Found the following in conv_arg not in qemu_arg:")
for elem in diff1:
logging.debug("\t%s", elem)
diff2 = filtlist(tuple(x for x in qemu_arg_lines
if x not in set(conv_arg_lines)))
if diff2:
logging.debug("Found the following in qemu_arg not in conv_arg:")
for elem in diff2:
logging.debug("\t%s", elem)
if diff1 or diff2:
return False
return True
# run test case
dtn_format = params.get("dtn_format")
file_xml = params.get("dtn_file_xml")
extra_param = params.get("dtn_extra_param")
libvirtd = params.get("libvirtd")
status_error = params.get("status_error")
virsh.dumpxml(vm_name, extra="", to_file=file_xml)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
ret = virsh.domxml_to_native(dtn_format, file_xml, extra_param,
ignore_status=True)
status = ret.exit_status
conv_arg = ret.stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# clean up
if os.path.exists(file_xml):
os.remove(file_xml)
# check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
if compare(conv_arg) is not True:
raise error.TestFail("Test failed!")
def run_virsh_domxml_to_native(test, params, env):
"""
Test command: virsh domxml-to-native.
Convert domain XML config to a native guest configuration format.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domxml-from-native operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
def compare(conv_arg):
"""
Compare converted infomation with vm's infomation.
@param: conv_arg : Converted infomation.
@return: True if converted infomation has no diffrent from
vm's infomation.
"""
pid = vm.get_pid()
cmdline_tmp = utils.system_output("cat -v /proc/%d/cmdline" % pid)
cmdline = re.sub(r'\^@', ' ', cmdline_tmp)
tmp = re.search('LC_ALL.[^\s]\s', conv_arg).group(0) +\
re.search('PATH.[^\s]+\s', conv_arg).group(0) +\
re.search('QEMU_AUDIO_DRV.[^\s]+\s', conv_arg).group(0)
qemu_arg = tmp + cmdline
conv_arg_lines = conv_arg.split('\x20')
qemu_arg_lines = qemu_arg.split('\x20')
i = 0
result = True
for arg in conv_arg_lines:
print arg
print qemu_arg_lines[i]
if re.search("mode=readline", arg):
i += 1
continue
elif re.search("mac=00:00:00:00:00:00", arg):
i += 1
continue
elif re.search("127.0.0.1:0", arg):
i += 1
continue
elif re.search("tap", arg):
i += 1
continue
if arg != qemu_arg_lines[i]:
result = False
i += 1
return result
#run test case
dtn_format = params.get("dtn_format")
file_xml = params.get("dtn_file_xml")
extra_param = params.get("dtn_extra_param")
libvirtd = params.get("libvirtd")
status_error = params.get("status_error")
virsh.dumpxml(vm_name, extra="", to_file=file_xml)
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
ret = virsh.domxml_to_native(dtn_format, file_xml, extra_param,
ignore_status = True)
status = ret.exit_status
conv_arg = ret.stdout.strip()
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
#clean up
if os.path.exists(file_xml):
os.remove(file_xml)
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
if compare(conv_arg) != True:
raise error.TestFail("Test failed!")
def run(test, params, env):
"""
Test command: virsh domxml-to-native.
Convert domain XML config to a native guest configuration format.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domxml-from-native operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
def buildcmd(arglist):
"""
Return a list of arguments of qemu command.
Return a list based on the input string where each list element
is put together with care to pair up options with their argument
rather than being on separate lines. Thus rather than having
"-option" "argument" in separate list elements, they will be in
one element "-option argument". Take care to note the argument to
an option may not be required. This will make it easier to determine
what is causing the failure when printing error messages.
"""
# First separate everything by the first space into a list
elems = arglist.split('\x20')
# Peruse the list to build up a formatted output retlist
retlist = []
i = 0
skip = False
for e in elems:
# If 'skip' is True, then we've appended an option and argument
if skip:
skip = False
i = i + 1
continue
# Need a peek at the next element
enext = elems[i + 1]
# If current and next element starts with "-", then the
# is not an argument to the current, thus we just append.
# Same for anything we find that doesn't start with a "-"
if (e[0] == '-' and enext[0] == '-') or e[0] != '-':
retlist.append(e)
else:
# -blockdev '{"driver":"file",...,"discard":"unmap"}' should be
# turned into
# -blockdev {"driver":"file",...,"discard":"unmap"} in order to
# match the qemu command line format
if e in ['-blockdev', '-object']:
enext = enext.strip("'")
# Append this and the next and set our skip flag
retlist.append(e + " " + enext)
skip = True
i = i + 1
# Now build a list where the
return retlist
def filtlist(arglist):
"""
Return a filtered list of arguments.
Walk through the supplied list to filter out things that will be
known to be different depending on the running environment.
"""
retlist = []
for arg in arglist:
if re.search("mode=readline", arg):
continue
elif re.search("mac=", arg):
continue
elif re.search("127.0.0.1:", arg):
continue
elif re.search("tap", arg):
continue
# Upstream libvirt commit id 'e8400564':
# XMLToNative: Don't show -S
elif re.search("-S", arg):
continue
elif re.search("socket,id=", arg):
continue
elif re.search("secret,id=", arg):
continue
elif re.search("-cpu", arg):
continue
# libvirt commit id 'd96fb5cb'
elif re.search("master-key.aes", arg):
continue
retlist.append(arg)
return retlist
def prepend_expected_env_vars(conv_arg, cmdline):
"""
Prepend the various environment variables that will be in
the conv_arg, but not in the actual command
:param conv_arg : Converted information
:param cmdline: Command line qemu has been called with
:return: cmdline prepended by expected environment variable values
"""
expected_env_vars = ['LC_ALL', 'PATH']
if not libvirt_version.version_compare(7, 3, 0):
expected_env_vars += ['QEMU_AUDIO_DRV']
if libvirt_version.version_compare(5, 2, 0):
expected_env_vars += [
'HOME',
'XDG_DATA_HOME',
'XDG_CACHE_HOME',
'XDG_CONFIG_HOME',
]
valmatcher = '.[^\\s]+\\s'
def matchf(x):
return re.search(x + valmatcher, conv_arg).group(0)
return "".join(map(matchf, expected_env_vars)) + cmdline
def compare(conv_arg):
"""
Compare converted information with vm's information.
:param conv_arg : Converted information.
:return: True if converted information has no different from
vm's information.
"""
pid = vm.get_pid()
cmdline_tmp = process.run("cat -v /proc/%d/cmdline" % pid,
shell=True).stdout_text
# Output has a trailing '^@' which gets converted into an empty
# element when spliting by '\x20', so strip it on the end.
cmdline = re.sub(r'\^@', ' ', cmdline_tmp).strip(' ')
# Fedora 19 replaces the /usr/bin/qemu-kvm with the string
# "/usr/bin/qemu-system-x86_64 -machine accel=kvm", so let's
# do the same if we find "/usr/bin/qemu-kvm" in the incoming
# argument list and we find "qemu-system-x86_64 -machine accel=kvm"
# in the running guest's cmdline
# ubuntu uses /usr/bin/kvm as qemu binary
# RHEL uses /usr/libexec/qemu-kvm as qemu binary
qemu_bin = [
"/usr/bin/qemu-kvm", "/usr/bin/kvm", "/usr/libexec/qemu-kvm"
]
arch_bin = [
"/usr/bin/qemu-system-x86_64 -machine accel=kvm",
"/usr/bin/qemu-system-ppc64 -machine accel=kvm",
"qemu-system-ppc64 -enable-kvm"
]
qemu_kvm_bin = ""
for each_bin in qemu_bin:
if conv_arg.find(each_bin) != -1:
qemu_kvm_bin = each_bin
if qemu_kvm_bin:
for arch in arch_bin:
if cmdline.find(arch) != -1:
cmdline = re.sub(arch, qemu_kvm_bin, cmdline)
else:
logging.warning("qemu-kvm binary is not identified: '%s'",
qemu_kvm_bin)
qemu_arg = prepend_expected_env_vars(conv_arg, cmdline)
conv_arg_lines = buildcmd(conv_arg)
qemu_arg_lines = buildcmd(qemu_arg)
diff1 = filtlist(
tuple(x for x in conv_arg_lines if x not in set(qemu_arg_lines)))
if diff1:
logging.debug("Found the following in conv_arg not in qemu_arg:")
for elem in diff1:
logging.debug("\t%s", elem)
diff2 = filtlist(
tuple(x for x in qemu_arg_lines if x not in set(conv_arg_lines)))
if diff2:
logging.debug("Found the following in qemu_arg not in conv_arg:")
for elem in diff2:
logging.debug("\t%s", elem)
if diff1 or diff2:
return False
return True
# prepare
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
if not vm.is_dead():
vm.destroy()
vm.start()
if not vm.is_alive():
test.fail("VM start failed")
domid = vm.get_id()
domuuid = vm.get_uuid()
dtn_format = params.get("dtn_format")
file_xml = params.get("dtn_file_xml", "")
extra_param = params.get("dtn_extra_param")
extra = params.get("dtn_extra", "")
libvirtd = params.get("libvirtd")
status_error = params.get("status_error", "no")
vm_id = params.get("dtn_vm_id", "")
readonly = ("yes" == params.get("readonly", "no"))
# For positive_test
if status_error == "no":
if vm_id == "id":
vm_id = domid
elif vm_id == "uuid":
vm_id = domuuid
elif vm_id == "name":
vm_id = "%s %s" % (vm_name, extra)
if file_xml == "":
extra_param = extra_param + vm_id
virsh.dumpxml(vm_name, extra="", to_file=file_xml)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# run test case
ret = virsh.domxml_to_native(dtn_format,
file_xml,
extra_param,
readonly=readonly,
ignore_status=True,
debug=True)
status = ret.exit_status
conv_arg = ret.stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# clean up
if os.path.exists(file_xml):
os.remove(file_xml)
# check status_error
if status_error == "yes":
if status == 0:
if libvirtd == "off" and libvirt_version.version_compare(5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
test.fail("Run failed with right command")
if compare(conv_arg) is not True:
test.fail("Test failed!")
def run_virsh_domxml_to_native(test, params, env):
"""
Test command: virsh domxml-to-native.
Convert domain XML config to a native guest configuration format.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domxml-from-native operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
def compare(conv_arg):
"""
Compare converted infomation with vm's infomation.
@param: conv_arg : Converted infomation.
@return: True if converted infomation has no diffrent from
vm's infomation.
"""
pid = vm.get_pid()
cmdline_tmp = utils.system_output("cat -v /proc/%d/cmdline" % pid)
cmdline = re.sub(r'\^@', ' ', cmdline_tmp)
tmp = re.search('LC_ALL.[^\s]\s', conv_arg).group(0) +\
re.search('PATH.[^\s]+\s', conv_arg).group(0) +\
re.search('QEMU_AUDIO_DRV.[^\s]+\s', conv_arg).group(0)
qemu_arg = tmp + cmdline
conv_arg_lines = conv_arg.split('\x20')
qemu_arg_lines = qemu_arg.split('\x20')
i = 0
result = True
for arg in conv_arg_lines:
print arg
print qemu_arg_lines[i]
if re.search("mode=readline", arg):
i += 1
continue
elif re.search("mac=00:00:00:00:00:00", arg):
i += 1
continue
elif re.search("127.0.0.1:0", arg):
i += 1
continue
elif re.search("tap", arg):
i += 1
continue
if arg != qemu_arg_lines[i]:
result = False
i += 1
return result
#run test case
dtn_format = params.get("dtn_format")
file_xml = params.get("dtn_file_xml")
extra_param = params.get("dtn_extra_param")
libvirtd = params.get("libvirtd")
status_error = params.get("status_error")
virsh.dumpxml(vm_name, file_xml)
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
ret = virsh.domxml_to_native(dtn_format,
file_xml,
extra_param,
ignore_status=True)
status = ret.exit_status
conv_arg = ret.stdout.strip()
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
#clean up
if os.path.exists(file_xml):
os.remove(file_xml)
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
if compare(conv_arg) != True:
raise error.TestFail("Test failed!")
