def get_domiftune_parameter(params):
"""
Get the domiftune parameters
:params: the parameter dictionary
"""
vm_name = params.get("vms")
options = params.get("options")
interface = params.get("iface_dev")
result = virsh.domiftune(vm_name, interface, options=options)
status = result.exit_status
# Check status_error
status_error = params.get("status_error", "no")
if status_error == "yes":
if status:
logging.info("It's an expected error: %s", result.stderr)
else:
raise error.TestFail("%d not a expected command "
"return value", status)
elif status_error == "no":
if status:
raise error.TestFail(result.stderr)
else:
logging.info(result.stdout)
def set_domiftune_parameter(params):
"""
Set the domiftune parameters
:params: the parameter dictionary
"""
vm_name = params.get("vms")
inbound = params.get("inbound")
outbound = params.get("outbound")
options = params.get("options", None)
interface = params.get("iface_dev")
result = virsh.domiftune(vm_name, interface, options, inbound, outbound)
status = result.exit_status
# Check status_error
status_error = params.get("status_error", "no")
if status_error == "yes":
if status:
logging.info("It's an expected error: %s", result.stderr)
else:
raise error.TestFail("%d not a expected command "
"return value", status)
elif status_error == "no":
if status:
raise error.TestFail(result.stderr)
else:
if check_domiftune(params):
logging.info(result.stdout)
else:
error.TestFail("The 'inbound' or/and 'outbound' are"
" inconsistent with domiftune XML"
" and/or virsh command output")
def check_domiftune(params):
"""
Compare inbound and outbound value with guest XML configuration
and virsh command output.
@params: the parameter dictionary
"""
vm_name = params.get("vms")
vm = params.get("vm")
interface = params.get("iface_dev")
options = params.get("options")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
inbound_from_cmd_output = None
outbound_from_cmd_output = None
domiftune_params = {}
if vm and vm.is_alive():
result = virsh.domiftune(vm_name, interface, options=options)
dicts = {}
o = result.stdout.strip().split("\n")
for l in o:
if l and l.find(':'):
k, v = l.split(':')
dicts[k.strip()] = v.strip()
logging.debug(dicts)
inbound_from_cmd_output = dicts['inbound.average']
outbound_from_cmd_output = dicts['outbound.average']
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
if options == "config" and vm and vm.is_alive():
domiftune_params = virt_xml_obj.get_iftune_params(vm_name, "--inactive")
elif vm and not vm.is_alive():
logging.debug("The guest %s isn't running!", vm_name)
return True
else:
domiftune_params = virt_xml_obj.get_iftune_params(vm_name)
inbound_from_xml = domiftune_params.get("inbound")
outbound_from_xml = domiftune_params.get("outbound")
if vm and vm.is_alive() and options != "config":
if inbound and inbound != inbound_from_cmd_output:
logging.error("To expect inbound %s: %s", inbound,
inbound_from_cmd_output)
return False
if outbound and outbound != outbound_from_cmd_output:
logging.error("To expect inbound %s: %s", outbound,
outbound_from_cmd_output)
return False
if inbound and inbound_from_xml and inbound != inbound_from_xml:
logging.error("To expect outbound %s: %s", inbound,
inbound_from_xml)
return False
if outbound and outbound_from_xml and outbound != outbound_from_xml:
logging.error("To expect outbound %s: %s", outbound,
outbound_from_xml)
return False
return True
def get_domiftune_parameter(params, test):
"""
Get the domiftune parameters
:params: the parameter dictionary
"""
vm_name = params.get("main_vm")
options = params.get("options")
interface = params.get("iface_dev")
result = virsh.domiftune(vm_name, interface, options=options)
status = result.exit_status
# Check status_error
status_error = params.get("status_error", "no")
if status_error == "yes":
if status:
logging.info("It's an expected error: %s", result.stderr)
else:
test.fail("%d not a expected command return value" %
status)
elif status_error == "no":
if status:
test.fail("Unexpected result, get domiftune: %s" %
result.stderr)
else:
logging.info("getdominfo return succesfully")
def run(test, params, env):
"""
Test domiftune tuning
1) Positive testing
1.1) get the current domiftune parameters for a running guest
1.2) set the current domiftune parameters for a running guest
2) Negative testing
2.1) get domiftune parameters
2.2) set domiftune parameters
"""
# Run test case
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_error = params.get("status_error", "no")
start_vm = params.get("start_vm", "yes")
change_parameters = params.get("change_parameters", "no")
interface_ref = params.get("interface_ref", "name")
interface = []
if vm and not vm.is_alive():
vm.start()
if vm and vm.is_alive():
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
interface = virt_xml_obj.get_iface_dev(vm_name)
if_mac = interface[0]
# Get interface name
vmxml = virt_xml_obj.new_from_dumpxml(vm_name)
if_node = vmxml.get_iface_all().get(if_mac)
if_name = if_node.find('target').get('dev')
if interface_ref == "name":
interface = if_name
if interface_ref == "mac":
interface = if_mac
logging.debug("the interface is %s", interface)
test_dict = dict(params)
test_dict['vm'] = vm
if interface:
test_dict['iface_dev'] = interface
if start_vm == "no" and vm and vm.is_alive():
vm.destroy()
# positive and negative testing #########
if change_parameters == "no":
get_domiftune_parameter(test_dict, test)
else:
set_domiftune_parameter(test_dict, test)
ret = virsh.domiftune(vm_name, interface, 'current', '0', '0')
libvirt.check_exit_status(ret)
def set_domiftune_parameter(params):
"""
Set the domiftune parameters
:params: the parameter dictionary
"""
vm_name = params.get("main_vm")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
options = params.get("options", None)
interface = params.get("iface_dev")
check_clear = params.get("check_clear", "no")
status_error = params.get("status_error", "no")
test_clear = False
if check_clear == "yes":
# In libvirt 1.2.3, commit id '14973382' it will now be possible
# to pass a zero (0) as an inbound or outbound parameter to virsh
# domiftune in order to clear all the settings found. So we'll
# handle that difference here
if libvirt_version.version_compare(1, 2, 3):
test_clear = True
# Although the .cfg file has "0" for these that will
# not test whether we can clear the value. So let's
# set it to "1", then after we are sure we can set it
# we will clear it and check that it's clear
if inbound:
save_inbound = inbound
# average,peak,burst
inbound = "1,4,6"
params['inbound'] = "1"
if outbound:
save_outbound = outbound
# average,peak,burst
outbound = "1,4,6"
params['outbound'] = "1"
else:
# Prior to libvirt 1.2.3 this would be an error
# So let's just treat it as such. Leaving the
# inbound/outbound as zero should result in an
# error on the following set, but a pass for
# the test since the error is expected.
status_error = "yes"
result = virsh.domiftune(vm_name, interface, options, inbound, outbound)
status = result.exit_status
if status_error == "yes":
if status:
logging.info("It's an expected error: %s", result.stderr)
else:
raise error.TestFail("%d not a expected command return value" %
status)
elif status_error == "no":
if status:
raise error.TestFail("Unexpected set domiftune error: %s" %
result.stderr)
else:
if not check_domiftune(params, False):
raise error.TestFail("The 'inbound' or/and 'outbound' are"
" inconsistent with domiftune XML"
" and/or virsh command output")
# If supported, then here's where we reset the inbound/outbound
# back to what they were input as and then run the same domiftune
# command. That should result in a successful return and should
# clear the parameter.
if test_clear:
if inbound:
inbound = save_inbound
params['inbound'] = save_inbound
if outbound:
outbound = save_outbound
params['outbound'] = save_outbound
result = virsh.domiftune(vm_name, interface, options, inbound, outbound)
status = result.exit_status
if status:
raise error.TestFail("Unexpected failure when clearing: %s" %
result.stderr)
else:
if not check_domiftune(params, True):
raise error.TestFail("The 'inbound' or/and 'outbound' were "
"not cleared.")
def check_domiftune(params, test_clear):
"""
Compare inbound and outbound value with guest XML configuration
and virsh command output.
:params: the parameter dictionary
"""
vm_name = params.get("main_vm")
vm = params.get("vm")
interface = params.get("iface_dev")
options = params.get("options")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
inbound_from_cmd_output = None
outbound_from_cmd_output = None
peak_in_from_cmd_output = None
peak_out_from_cmd_output = None
burst_in_from_cmd_output = None
burst_out_from_cmd_output = None
domiftune_params = {}
logging.debug("Checking inbound=%s outbound=%s", inbound, outbound)
if vm and vm.is_alive():
result = virsh.domiftune(vm_name, interface, options=options)
dicts = {}
o = result.stdout.strip().split("\n")
for l in o:
if l and l.find(':'):
k, v = l.split(':')
dicts[k.strip()] = v.strip()
logging.debug(dicts)
inbound_from_cmd_output = dicts['inbound.average']
outbound_from_cmd_output = dicts['outbound.average']
logging.debug("inbound_from_cmd_output=%s, outbound_from_cmd_output=%s",
inbound_from_cmd_output, outbound_from_cmd_output)
peak_in_from_cmd_output = dicts['inbound.peak']
peak_out_from_cmd_output = dicts['outbound.peak']
burst_in_from_cmd_output = dicts['inbound.peak']
burst_out_from_cmd_output = dicts['outbound.peak']
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
if options == "config" and vm and vm.is_alive():
domiftune_params = virt_xml_obj.get_iftune_params(
vm_name, "--inactive")
elif vm and not vm.is_alive():
logging.debug("The guest %s isn't running!", vm_name)
return True
else:
domiftune_params = virt_xml_obj.get_iftune_params(vm_name)
inbound_from_xml = domiftune_params.get("inbound")
outbound_from_xml = domiftune_params.get("outbound")
logging.debug("inbound_from_xml=%s, outbound_from_xml=%s",
inbound_from_xml, outbound_from_cmd_output)
if vm and vm.is_alive() and options != "config":
if test_clear and inbound:
if inbound_from_xml is not None or \
inbound_from_cmd_output is not "0" or \
peak_in_from_cmd_output is not "0" or \
burst_in_from_cmd_output is not "0":
logging.error("Inbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s",
inbound_from_xml,
inbound_from_cmd_output,
peak_in_from_cmd_output,
burst_in_from_cmd_output)
return False
if test_clear and outbound:
if outbound_from_xml is not None or \
outbound_from_cmd_output is not "0" or \
peak_out_from_cmd_output is not "0" or \
burst_out_from_cmd_output is not "0":
logging.error("Outbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s",
outbound_from_xml,
outbound_from_cmd_output,
peak_out_from_cmd_output,
burst_out_from_cmd_output)
if test_clear:
return True
if inbound and inbound != inbound_from_cmd_output:
logging.error("To expect inbound %s: %s", inbound,
inbound_from_cmd_output)
return False
if outbound and outbound != outbound_from_cmd_output:
logging.error("To expect inbound %s: %s", outbound,
outbound_from_cmd_output)
return False
if inbound and inbound_from_xml and inbound != inbound_from_xml:
logging.error("To expect outbound %s: %s", inbound,
inbound_from_xml)
return False
if outbound and outbound_from_xml and outbound != outbound_from_xml:
logging.error("To expect outbound %s: %s", outbound,
outbound_from_xml)
return False
return True
def check_domiftune(params, test_clear):
"""
Compare inbound and outbound value with guest XML configuration
and virsh command output.
:params: the parameter dictionary
"""
vm_name = params.get("main_vm")
vm = params.get("vm")
interface = params.get("iface_dev")
options = params.get("options")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
set_clear = "yes" == params.get("set_clear", "no")
test_outbound = "yes" == params.get("test_outbound", "no")
test_inbound = "yes" == params.get("test_inbound", "no")
status_error = 'yes' == params.get("status_error", "no")
average_inbound_from_cmd_output = None
average_outbound_from_cmd_output = None
peak_inbound_from_cmd_output = None
peak_outbound_from_cmd_output = None
burst_inbound_from_cmd_output = None
burst_outbound_from_cmd_output = None
average_inbound_from_xml = None
average_outbound_from_xml = None
peak_inbound_from_xml = None
peak_outbound_from_xml = None
burst_inbound_from_xml = None
burst_outbound_from_xml = None
logging.debug("Checking inbound=%s outbound= %s", inbound, outbound)
# get inbound and outbound parameters from virsh cmd setting
if not status_error and test_inbound:
in_list = re.findall(r'[0-9]+', inbound)
inbound_average = int(in_list[0])
if len(in_list) == 3:
inbound_peak = int(in_list[1])
inbound_burst = int(in_list[2])
if not status_error and test_outbound:
out_list = re.findall(r'[0-9]+', outbound)
outbound_average = int(out_list[0])
if len(out_list) == 3:
outbound_peak = int(out_list[1])
outbound_burst = int(out_list[2])
# --config affect next boot
if options == "config":
vm.destroy()
vm.start()
# get inbound and outbound parameters from virsh cmd output
if vm and vm.is_alive():
result = virsh.domiftune(vm_name, interface, options=options)
dicts = {}
o = result.stdout.strip().split("\n")
for l in o:
if l and l.find(':'):
k, v = l.split(':')
dicts[k.strip()] = v.strip()
logging.debug(dicts)
average_inbound_from_cmd_output = int(dicts['inbound.average'])
average_outbound_from_cmd_output = int(dicts['outbound.average'])
peak_inbound_from_cmd_output = int(dicts['inbound.peak'])
peak_outbound_from_cmd_output = int(dicts['outbound.peak'])
burst_inbound_from_cmd_output = int(dicts['inbound.burst'])
burst_outbound_from_cmd_output = int(dicts['outbound.burst'])
logging.debug("inbound and outbound from cmd output:")
logging.debug("inbound: %s,%s,%s; outbound: %s,%s,%s"
% (average_inbound_from_cmd_output, peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output, average_outbound_from_cmd_output,
peak_outbound_from_cmd_output, burst_outbound_from_cmd_output))
# get inbound and outbound parameters from vm xml
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
if options == "config" and vm and vm.is_alive():
domiftune_params = virt_xml_obj.get_iftune_params(
vm_name, "--inactive")
elif vm and not vm.is_alive():
logging.debug("The guest %s isn't running!", vm_name)
return True
else:
domiftune_params = virt_xml_obj.get_iftune_params(vm_name)
try:
logging.debug("test inbound is %s, test outbound is %s" %
(test_inbound, test_outbound))
if test_inbound:
average_inbound_from_xml = int(domiftune_params.get("inbound").get("average"))
peak_inbound_from_xml = int(domiftune_params.get("inbound").get("peak"))
burst_inbound_from_xml = int(domiftune_params.get("inbound").get("burst"))
logging.debug("inbound from xml:")
logging.debug("%s, %s, %s" % (average_inbound_from_xml, peak_inbound_from_xml,
burst_inbound_from_xml))
if test_outbound:
average_outbound_from_xml = int(domiftune_params.get("outbound").get("average"))
peak_outbound_from_xml = int(domiftune_params.get("outbound").get("peak"))
burst_outbound_from_xml = int(domiftune_params.get("outbound").get("burst"))
logging.debug("outbound from xml:")
logging.debug("%s, %s, %s" % (average_outbound_from_xml, peak_outbound_from_xml,
burst_outbound_from_xml))
except AttributeError as details:
logging.error("Error in get inbound/outbound average: %s", details)
logging.debug("average_inbound_from_xml=%s, average_outbound_from_xml=%s",
average_inbound_from_xml, average_outbound_from_xml)
if vm and vm.is_alive():
if test_clear and set_clear and test_inbound:
if average_inbound_from_xml is not None or \
average_inbound_from_cmd_output != 0 or \
peak_inbound_from_cmd_output != 0 or \
burst_inbound_from_cmd_output != 0:
logging.error("Inbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s",
average_inbound_from_xml,
average_inbound_from_cmd_output,
peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output)
return False
else:
return True
if test_clear and set_clear and test_outbound:
if average_outbound_from_xml is not None or \
average_outbound_from_cmd_output != 0 or \
peak_outbound_from_cmd_output != 0 or \
burst_outbound_from_cmd_output != 0:
logging.error("Outbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s",
average_outbound_from_xml,
average_outbound_from_cmd_output,
peak_outbound_from_cmd_output,
burst_outbound_from_cmd_output)
return False
else:
return True
if test_inbound and (inbound_average != average_inbound_from_cmd_output
or inbound_peak != peak_inbound_from_cmd_output
or inbound_burst != burst_inbound_from_cmd_output):
logging.error("To expect inbound %s: but got {average: %s, peak:"
" %s, burst: %s} from cmd output", inbound,
average_inbound_from_cmd_output, peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output)
return False
if test_inbound and (inbound_average != average_inbound_from_xml
or inbound_peak != peak_inbound_from_xml
or inbound_burst != burst_inbound_from_xml):
logging.error("To expect inbound %s: but got {average: %s, peak:"
" %s, burst: %s} from xml", inbound,
average_inbound_from_xml, peak_inbound_from_xml,
burst_inbound_from_xml)
return False
if test_outbound and (outbound_average != average_outbound_from_cmd_output
or outbound_peak != peak_outbound_from_cmd_output
or outbound_burst != burst_outbound_from_cmd_output):
logging.error("To expect outbound %s: but got {average: %s, peak:"
" %s, burst: %s} from cmd output", outbound,
average_outbound_from_cmd_output, peak_outbound_from_cmd_output,
burst_outbound_from_cmd_output)
return False
if test_outbound and (outbound_average != average_outbound_from_xml or
outbound_peak != peak_outbound_from_xml or
outbound_burst != burst_outbound_from_xml):
logging.error("To expect outbound %s: but got {average: %s, peak:"
" %s, burst: %s} from xml", outbound,
average_outbound_from_xml, peak_outbound_from_xml,
burst_outbound_from_xml)
return False
return True
def check_domiftune(params, test_clear):
"""
Compare inbound and outbound value with guest XML configuration
and virsh command output.
:params: the parameter dictionary
"""
vm_name = params.get("main_vm")
vm = params.get("vm")
interface = params.get("iface_dev")
options = params.get("options")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
set_clear = "yes" == params.get("set_clear", "no")
test_outbound = "yes" == params.get("test_outbound", "no")
test_inbound = "yes" == params.get("test_inbound", "no")
status_error = 'yes' == params.get("status_error", "no")
later_start = 'yes' == params.get("later_start", "no")
average_inbound_from_cmd_output = None
average_outbound_from_cmd_output = None
peak_inbound_from_cmd_output = None
peak_outbound_from_cmd_output = None
burst_inbound_from_cmd_output = None
burst_outbound_from_cmd_output = None
floor_inbound_from_cmd_output = None
average_inbound_from_xml = None
average_outbound_from_xml = None
peak_inbound_from_xml = None
peak_outbound_from_xml = None
burst_inbound_from_xml = None
burst_outbound_from_xml = None
floor_inbound_from_xml = None
netfloor = params.get("netfloor")
logging.debug("Checking inbound=%s outbound= %s", inbound, outbound)
# get inbound and outbound parameters from virsh cmd setting
if not status_error and test_inbound:
in_list = re.findall(r'[0-9]+', inbound)
inbound_average = int(in_list[0])
if len(in_list) >= 3:
inbound_peak = int(in_list[1])
inbound_burst = int(in_list[2])
if netfloor:
inbound_floor = int(in_list[3])
if not status_error and test_outbound:
out_list = re.findall(r'[0-9]+', outbound)
outbound_average = int(out_list[0])
if len(out_list) == 3:
outbound_peak = int(out_list[1])
outbound_burst = int(out_list[2])
# --config affect next boot
if options == "config":
vm.destroy()
vm.start()
# setting for shutoff guest need start to check
if later_start:
vm.start()
# get inbound and outbound parameters from virsh cmd output
if vm and vm.is_alive():
result = virsh.domiftune(vm_name, interface, options=options)
dicts = {}
bws = result.stdout.strip().split("\n")
for bw in bws:
if bw and bw.find(':'):
k, v = bw.split(':')
dicts[k.strip()] = v.strip()
logging.debug(dicts)
average_inbound_from_cmd_output = int(dicts['inbound.average'])
average_outbound_from_cmd_output = int(dicts['outbound.average'])
peak_inbound_from_cmd_output = int(dicts['inbound.peak'])
peak_outbound_from_cmd_output = int(dicts['outbound.peak'])
burst_inbound_from_cmd_output = int(dicts['inbound.burst'])
burst_outbound_from_cmd_output = int(dicts['outbound.burst'])
floor_inbound_from_cmd_output = int(dicts['inbound.floor'])
logging.debug("inbound and outbound from cmd output:")
logging.debug(
"inbound: %s,%s,%s; outbound: %s,%s,%s",
average_inbound_from_cmd_output, peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output, average_outbound_from_cmd_output,
peak_outbound_from_cmd_output, burst_outbound_from_cmd_output)
if netfloor:
logging.debug("inbound floor: %s", floor_inbound_from_cmd_output)
# get inbound and outbound parameters from vm xml
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
if options == "config" and vm and vm.is_alive():
domiftune_params = virt_xml_obj.get_iftune_params(
vm_name, "--inactive")
elif vm and not vm.is_alive():
logging.debug("The guest %s isn't running!", vm_name)
return True
else:
domiftune_params = virt_xml_obj.get_iftune_params(vm_name)
try:
logging.debug("test inbound is %s, test outbound is %s", test_inbound,
test_outbound)
if test_inbound:
average_inbound_from_xml = int(
domiftune_params.get("inbound").get("average"))
peak_inbound_from_xml = int(
domiftune_params.get("inbound").get("peak"))
burst_inbound_from_xml = int(
domiftune_params.get("inbound").get("burst"))
logging.debug("inbound from xml:")
logging.debug("%s, %s, %s", average_inbound_from_xml,
peak_inbound_from_xml, burst_inbound_from_xml)
if netfloor:
floor_inbound_from_xml = int(
domiftune_params.get("inbound").get("floor"))
logging.debug("inbound floor from xml: %s",
floor_inbound_from_xml)
if test_outbound:
average_outbound_from_xml = int(
domiftune_params.get("outbound").get("average"))
peak_outbound_from_xml = int(
domiftune_params.get("outbound").get("peak"))
burst_outbound_from_xml = int(
domiftune_params.get("outbound").get("burst"))
logging.debug("outbound from xml:")
logging.debug("%s, %s, %s", average_outbound_from_xml,
peak_outbound_from_xml, burst_outbound_from_xml)
except AttributeError as details:
logging.error("Error in get inbound/outbound average: %s", details)
logging.debug("average_inbound_from_xml=%s, average_outbound_from_xml=%s",
average_inbound_from_xml, average_outbound_from_xml)
if vm and vm.is_alive():
if test_clear and set_clear and test_inbound:
if average_inbound_from_xml is not None or \
average_inbound_from_cmd_output != 0 or \
peak_inbound_from_cmd_output != 0 or \
burst_inbound_from_cmd_output != 0:
logging.error(
"Inbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s", average_inbound_from_xml,
average_inbound_from_cmd_output,
peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output)
return False
else:
return True
if test_clear and set_clear and test_outbound:
if average_outbound_from_xml is not None or \
average_outbound_from_cmd_output != 0 or \
peak_outbound_from_cmd_output != 0 or \
burst_outbound_from_cmd_output != 0:
logging.error(
"Outbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s", average_outbound_from_xml,
average_outbound_from_cmd_output,
peak_outbound_from_cmd_output,
burst_outbound_from_cmd_output)
return False
else:
return True
if test_inbound and (inbound_average != average_inbound_from_cmd_output
or inbound_peak != peak_inbound_from_cmd_output or
inbound_burst != burst_inbound_from_cmd_output):
logging.error(
"To expect inbound %s: but got {average: %s, peak:"
" %s, burst: %s} from cmd output", inbound,
average_inbound_from_cmd_output, peak_inbound_from_cmd_output,
burst_inbound_from_cmd_output)
return False
if netfloor and inbound_floor != floor_inbound_from_cmd_output:
logging.error(
"To expect inbound floor %s, but got %s from cmd output",
inbound_floor, floor_inbound_from_cmd_output)
return False
if test_inbound and (inbound_average != average_inbound_from_xml
or inbound_peak != peak_inbound_from_xml
or inbound_burst != burst_inbound_from_xml):
logging.error(
"To expect inbound %s: but got {average: %s, peak:"
" %s, burst: %s} from xml", inbound, average_inbound_from_xml,
peak_inbound_from_xml, burst_inbound_from_xml)
return False
if netfloor and inbound_floor != floor_inbound_from_xml:
logging.error("To expect inbound floor %s, but got %s from xml",
inbound_floor, floor_inbound_from_xml)
return False
if test_outbound and (
outbound_average != average_outbound_from_cmd_output
or outbound_peak != peak_outbound_from_cmd_output
or outbound_burst != burst_outbound_from_cmd_output):
logging.error(
"To expect outbound %s: but got {average: %s, peak:"
" %s, burst: %s} from cmd output", outbound,
average_outbound_from_cmd_output,
peak_outbound_from_cmd_output, burst_outbound_from_cmd_output)
return False
if test_outbound and (outbound_average != average_outbound_from_xml
or outbound_peak != peak_outbound_from_xml
or outbound_burst != burst_outbound_from_xml):
logging.error(
"To expect outbound %s: but got {average: %s, peak:"
" %s, burst: %s} from xml", outbound,
average_outbound_from_xml, peak_outbound_from_xml,
burst_outbound_from_xml)
return False
return True
def check_domiftune(params, test_clear):
"""
Compare inbound and outbound value with guest XML configuration
and virsh command output.
:params: the parameter dictionary
"""
vm_name = params.get("vms")
vm = params.get("vm")
interface = params.get("iface_dev")
options = params.get("options")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
inbound_from_cmd_output = None
outbound_from_cmd_output = None
peak_in_from_cmd_output = None
peak_out_from_cmd_output = None
burst_in_from_cmd_output = None
burst_out_from_cmd_output = None
domiftune_params = {}
logging.debug("Checking inbound=%s outbound=%s", inbound, outbound)
if vm and vm.is_alive():
result = virsh.domiftune(vm_name, interface, options=options)
dicts = {}
o = result.stdout.strip().split("\n")
for l in o:
if l and l.find(':'):
k, v = l.split(':')
dicts[k.strip()] = v.strip()
logging.debug(dicts)
inbound_from_cmd_output = dicts['inbound.average']
outbound_from_cmd_output = dicts['outbound.average']
logging.debug(
"inbound_from_cmd_output=%s, outbound_from_cmd_output=%s",
inbound_from_cmd_output, outbound_from_cmd_output)
peak_in_from_cmd_output = dicts['inbound.peak']
peak_out_from_cmd_output = dicts['outbound.peak']
burst_in_from_cmd_output = dicts['inbound.peak']
burst_out_from_cmd_output = dicts['outbound.peak']
virt_xml_obj = vm_xml.VMXML(virsh_instance=virsh)
if options == "config" and vm and vm.is_alive():
domiftune_params = virt_xml_obj.get_iftune_params(
vm_name, "--inactive")
elif vm and not vm.is_alive():
logging.debug("The guest %s isn't running!", vm_name)
return True
else:
domiftune_params = virt_xml_obj.get_iftune_params(vm_name)
inbound_from_xml = domiftune_params.get("inbound")
outbound_from_xml = domiftune_params.get("outbound")
logging.debug("inbound_from_xml=%s, outbound_from_xml=%s",
inbound_from_xml, outbound_from_cmd_output)
if vm and vm.is_alive() and options != "config":
if test_clear and inbound:
if inbound_from_xml is not None or \
inbound_from_cmd_output is not "0" or \
peak_in_from_cmd_output is not "0" or \
burst_in_from_cmd_output is not "0":
logging.error(
"Inbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s", inbound_from_xml,
inbound_from_cmd_output, peak_in_from_cmd_output,
burst_in_from_cmd_output)
return False
if test_clear and outbound:
if outbound_from_xml is not None or \
outbound_from_cmd_output is not "0" or \
peak_out_from_cmd_output is not "0" or \
burst_out_from_cmd_output is not "0":
logging.error(
"Outbound was not cleared, xml=%s "
"avg=%s peak=%s burst=%s", outbound_from_xml,
outbound_from_cmd_output, peak_out_from_cmd_output,
burst_out_from_cmd_output)
if test_clear:
return True
if inbound and inbound != inbound_from_cmd_output:
logging.error("To expect inbound %s: %s", inbound,
inbound_from_cmd_output)
return False
if outbound and outbound != outbound_from_cmd_output:
logging.error("To expect inbound %s: %s", outbound,
outbound_from_cmd_output)
return False
if inbound and inbound_from_xml and inbound != inbound_from_xml:
logging.error("To expect outbound %s: %s", inbound,
inbound_from_xml)
return False
if outbound and outbound_from_xml and outbound != outbound_from_xml:
logging.error("To expect outbound %s: %s", outbound,
outbound_from_xml)
return False
return True
def set_domiftune_parameter(params):
"""
Set the domiftune parameters
:params: the parameter dictionary
"""
vm_name = params.get("vms")
inbound = params.get("inbound", "")
outbound = params.get("outbound", "")
options = params.get("options", None)
interface = params.get("iface_dev")
check_clear = params.get("check_clear", "no")
status_error = params.get("status_error", "no")
test_clear = False
if check_clear == "yes":
# In libvirt 1.2.3, commit id '14973382' it will now be possible
# to pass a zero (0) as an inbound or outbound parameter to virsh
# domiftune in order to clear all the settings found. So we'll
# handle that difference here
if libvirt_version.version_compare(1, 2, 3):
test_clear = True
# Although the .cfg file has "0" for these that will
# not test whether we can clear the value. So let's
# set it to "1", then after we are sure we can set it
# we will clear it and check that it's clear
if inbound:
save_inbound = inbound
# average,peak,burst
inbound = "1,4,6"
params['inbound'] = "1"
if outbound:
save_outbound = outbound
# average,peak,burst
outbound = "1,4,6"
params['outbound'] = "1"
else:
# Prior to libvirt 1.2.3 this would be an error
# So let's just treat it as such. Leaving the
# inbound/outbound as zero should result in an
# error on the following set, but a pass for
# the test since the error is expected.
status_error = "yes"
result = virsh.domiftune(vm_name, interface, options, inbound, outbound)
status = result.exit_status
if status_error == "yes":
if status:
logging.info("It's an expected error: %s", result.stderr)
else:
raise error.TestFail("%d not a expected command return value" %
status)
elif status_error == "no":
if status:
raise error.TestFail("Unexpected set domiftune error: %s" %
result.stderr)
else:
if not check_domiftune(params, False):
raise error.TestFail("The 'inbound' or/and 'outbound' are"
" inconsistent with domiftune XML"
" and/or virsh command output")
# If supported, then here's where we reset the inbound/outbound
# back to what they were input as and then run the same domiftune
# command. That should result in a successful return and should
# clear the parameter.
if test_clear:
if inbound:
inbound = save_inbound
params['inbound'] = save_inbound
if outbound:
outbound = save_outbound
params['outbound'] = save_outbound
result = virsh.domiftune(vm_name, interface, options, inbound,
outbound)
status = result.exit_status
if status:
raise error.TestFail("Unexpected failure when clearing: %s" %
result.stderr)
else:
if not check_domiftune(params, True):
raise error.TestFail("The 'inbound' or/and 'outbound' were "
"not cleared.")
def run(test, params, env):
"""
Test domiftune tuning
1) Positive testing
1.1) get the current domiftune parameters for a running guest
1.2) set the current domiftune parameters for a running guest
2) Negative testing
2.1) get domiftune parameters
2.2) set domiftune parameters
"""
# Run test case
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_error = params.get("status_error", "no")
start_vm = params.get("start_vm", "yes")
change_parameters = params.get("change_parameters", "no")
interface_ref = params.get("interface_ref", "name")
netfloor = params.get("netfloor")
pre_vmstate = params.get("pre_vmstate")
interface = []
change_net = False
def set_netbw(netfloor, if_net, netxml):
"""
Set network bandwidth as required.
:param netfloor: action on network bandwidth, 'need' or 'delete'
:param if_net: network name acquired from guest interface
:param netxml: the network xml
"""
if netfloor == 'delete':
netxml.del_element('/bandwidth')
elif netfloor == 'need':
netxml.bandwidth_inbound = {
'average': 100,
'peak': 200,
'burst': 128
}
netxml.bandwidth_outbound = {
'average': 50,
'peak': 100,
'burst': 128
}
netxml.sync()
virsh.net_dumpxml(if_net, debug=True)
def get_iface(vm_name, if_mac):
"""
Get the first interface dev from guest xml
:param vm_name: guest name
:param if_mac: the interface mac
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if_node = vmxml.get_iface_all().get(if_mac)
return if_node
if pre_vmstate == "shutoff" and vm.is_alive():
vm.destroy()
if_mac = vm_xml.VMXML.get_first_mac_by_name(vm_name)
if netfloor:
if_node = get_iface(vm_name, if_mac)
if_net = if_node.find('source').get('network')
netxml = network_xml.NetworkXML.new_from_net_dumpxml(if_net)
netxml_backup = netxml.copy()
if netfloor == 'delete' and 'bandwidth' in str(netxml) or \
netfloor == 'need' and 'bandwidth' not in str(netxml):
set_netbw(netfloor, if_net, netxml)
change_net = True
if vm and not vm.is_alive():
vm.start()
if vm and vm.is_alive():
if_node = get_iface(vm_name, if_mac)
if_name = if_node.find('target').get('dev')
if interface_ref == "name":
interface = if_name
if interface_ref == "mac":
interface = if_mac
logging.debug("the interface is %s", interface)
test_dict = dict(params)
test_dict['vm'] = vm
if interface:
test_dict['iface_dev'] = interface
if start_vm == "no" and vm and vm.is_alive():
vm.destroy()
# positive and negative testing #########
libvirtd = utils_libvirtd.Libvirtd()
if change_parameters == "no":
get_domiftune_parameter(test_dict, test, libvirtd)
else:
set_domiftune_parameter(test_dict, test, libvirtd)
if change_parameters != "no":
if change_net:
netxml_backup.sync()
if vm.is_alive():
vm.destroy()
vm.start()
if not status_error and interface_ref == "mac":
opt = 'config'
else:
opt = 'current'
ret = virsh.domiftune(vm_name, if_mac, opt, '0', '0', debug=True)
libvirt.check_exit_status(ret)
def run(test, params, env):
"""
Test openvswitch support for network.
1.Prepare test environment,destroy or suspend a VM.
2.Edit xml and start the domain.
3.Perform test operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# install openvswitch on host.
if distro.detect().name == 'Ubuntu':
pkg = "openvswitch-switch"
else:
pkg = "openvswitch"
ovs_service = service.Factory.create_service(pkg)
if not shutil.which('ovs-vsctl') and not utils_package.package_install(
pkg):
test.cancel("Failed to install dependency package %s" " on host" % pkg)
if not ovs_service.status():
logging.debug("Restart %s service.." % pkg)
ovs_service.restart()
def check_ovs_port(ifname, brname):
"""
Check OVS port that created by libvirt
"""
pg_name = params.get("porgroup_name", "").split()
pg_vlan = params.get("portgroup_vlan", "").split()
if_source = eval(iface_source)
port_vlan = {}
if "portgroup" in if_source:
pg = if_source["portgroup"]
for (name, vlan) in zip(pg_name, pg_vlan):
if pg == name:
port_vlan = eval(vlan)
# Check bridge name by port name
_, bridge = utils_net.find_current_bridge(ifname)
assert bridge == brname
# Get port info from ovs-vsctl output
cmd = "ovs-vsctl list port %s" % ifname
output = process.run(cmd, shell=True).stdout_text
logging.debug("ovs port output: %s", output)
for line in output.splitlines():
if line.count("tag"):
tag_info = line.rsplit(':')
if ("id" in port_vlan and tag_info[0] == "tag"):
assert port_vlan["id"] == tag_info[1]
elif line.count("vlan_mode"):
mode_info = line.rsplit(':')
if ("nativeMode" in port_vlan and mode_info[0] == "vlan_mode"):
assert (port_vlan["nativeMode"] == "native-%s" %
mode_info[1])
start_error = "yes" == params.get("start_error", "no")
# network specific attributes.
net_name = params.get("net_name", "default")
net_bridge = params.get("net_bridge", "{'name':'virbr0'}")
iface_source = params.get("iface_source", "{}")
create_network = "yes" == params.get("create_network", "no")
change_iface_option = "yes" == params.get("change_iface_option", "no")
test_ovs_port = "yes" == params.get("test_ovs_port", "no")
iface_inbound = params.get("iface_bandwidth_inbound")
iface_outbound = params.get("iface_bandwidth_outbound")
test_qos = "yes" == params.get("test_qos", "no")
hotplug = "yes" == params.get("hotplug", "no")
iface_type = params.get("iface_type", "bridge")
iface_model = params.get("iface_model", "virtio")
iface_virtualport = params.get("iface_virtualport")
live_add_qos = "yes" == params.get("live_add_qos", 'no')
libvirt_version.is_libvirt_feature_supported(params)
# Destroy the guest first
if vm.is_alive():
vm.destroy(gracefully=False)
# Back up xml file.
netxml_backup = NetworkXML.new_from_net_dumpxml("default")
iface_mac = vm_xml.VMXML.get_first_mac_by_name(vm_name)
params["guest_mac"] = iface_mac
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
bridge_name = eval(net_bridge)['name']
# Build the xml and run test.
try:
# Edit the network xml or create a new one.
if create_network:
# Try to add ovs bridge first
if not utils_net.ovs_br_exists(bridge_name):
utils_net.add_ovs_bridge(bridge_name)
netxml = libvirt.create_net_xml(net_name, params)
netxml.sync()
# Edit the interface xml.
if change_iface_option:
# Try to add bridge if needed
source = eval(iface_source)
if source:
if "bridge" in source:
if not utils_net.ovs_br_exists(source["bridge"]):
utils_net.add_ovs_bridge(source["bridge"])
iface_dict = {
'type': iface_type,
'model': iface_model,
'source': iface_source,
'virtualport_type': iface_virtualport,
'inbound': iface_inbound,
'outbound': iface_outbound
}
if live_add_qos:
iface_dict.pop('inbound')
iface_dict.pop('outbound')
if not hotplug:
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
else:
iface_attach_xml = os.path.join(data_dir.get_data_dir(),
"iface_attach.xml")
shutil.copyfile(
libvirt.modify_vm_iface(vm_name, 'get_xml', iface_dict),
iface_attach_xml)
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
try:
# Start the VM.
vm.start()
if start_error:
test.fail("VM started unexpectedly")
if hotplug:
virsh.attach_device(vm_name,
iface_attach_xml,
debug=True,
ignore_status=False)
iface_name = libvirt.get_ifname_host(vm_name, iface_mac)
if test_ovs_port:
check_ovs_port(iface_name, bridge_name)
if live_add_qos:
inbound_opt = ",".join(re.findall(r'[0-9]+', iface_inbound))
outbount_opt = ",".join(re.findall(r'[0-9]+', iface_outbound))
virsh.domiftune(vm_name,
iface_name,
inbound=inbound_opt,
outbound=outbount_opt,
debug=True,
ignore_status=False)
if test_qos:
iface_mac = vm_xml.VMXML.get_first_mac_by_name(vm_name)
tap_name = libvirt.get_ifname_host(vm_name, iface_mac)
logging.info("Test inbound:")
res1 = utils_net.check_class_rules(
tap_name, "1:1", ast.literal_eval(iface_inbound))
logging.info("Test outbound:")
res2 = utils_net.check_filter_rules(
tap_name, ast.literal_eval(iface_outbound))
if not res1 or not res2:
test.fail("Qos test fail!")
except virt_vm.VMStartError as details:
logging.info(str(details))
if not start_error:
test.fail('VM failed to start:\n%s' % details)
finally:
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
logging.info("Restoring network...")
if net_name == "default":
netxml_backup.sync()
else:
# Destroy and undefine new created network
virsh.net_destroy(net_name)
virsh.net_undefine(net_name)
# Try to recovery ovs bridge
if utils_net.ovs_br_exists(bridge_name):
utils_net.del_ovs_bridge(bridge_name)
if "iface_attach_xml" in locals():
os.remove(iface_attach_xml)
vmxml_backup.sync()
