def mtu_set(mtu):
"""
Set server/client/host's mtu
:param mtu: mtu value to be set
"""
server_mtu_cmd = params.get("server_mtu_cmd")
client_mtu_cmd = params.get("client_mtu_cmd")
host_mtu_cmd = params.get("host_mtu_cmd")
error_context.context("Changing the MTU of guest", logging.info)
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(server_ctl, mac)
ssh_cmd(server_ctl, server_mtu_cmd % (ethname, mtu))
elif params.get("os_type") == "windows":
connection_id = utils_net.get_windows_nic_attribute(
server_ctl, "macaddress", mac, "netconnectionid")
ssh_cmd(server_ctl, server_mtu_cmd % (connection_id, mtu))
error_context.context("Changing the MTU of client", logging.info)
ssh_cmd(client,
client_mtu_cmd % (params.get("client_physical_nic"), mtu))
netdst = params.get("netdst", "switch")
host_bridges = utils_net.Bridge()
br_in_use = host_bridges.list_br()
if netdst in br_in_use:
ifaces_in_use = host_bridges.list_iface()
target_ifaces = list(ifaces_in_use + br_in_use)
error_context.context("Change all Bridge NICs MTU to %s" % mtu,
logging.info)
for iface in target_ifaces:
utils.run(host_mtu_cmd % (iface, mtu), ignore_status=False)
def test_getstructure(self):
br = utils_net.Bridge().get_structure()
self.assertEqual(
br, {
'virbr1': {
'iface': ['em1', 'virbr1-nic'],
'stp': 'yes'
},
'virbr0': {
'iface': ['virbr0-nic'],
'stp': 'yes'
}
})
br = utils_net.Bridge().get_structure()
self.assertEqual(br, {'virbr0': {"iface": [], "stp": "yes"}})
br = utils_net.Bridge().get_structure()
self.assertEqual(br, {})
br = utils_net.Bridge().get_structure()
self.assertEqual(
br, {
'virbr2': {
"iface":
['em1', 'virbr10-nic', 'virbr40-nic', 'virbr50-nic'],
"stp": "yes"
},
'virbr1': {
"iface": ['em1', 'virbr1-nic', 'virbr4-nic', 'virbr5-nic'],
"stp": "yes"
},
'virbr0': {
"iface": ['virbr0-nic', 'virbr2-nic', 'virbr3-nic'],
"stp": "yes"
}
})
def mtu_set(mtu):
"""
Set server/client/host's mtu
:param mtu: mtu value to be set
"""
server_mtu_cmd = params.get("server_mtu_cmd")
client_mtu_cmd = params.get("client_mtu_cmd")
host_mtu_cmd = params.get("host_mtu_cmd")
error_context.context("Changing the MTU of guest", logging.info)
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(server_ctl, mac)
netperf_base.ssh_cmd(server_ctl, server_mtu_cmd % (ethname, mtu))
elif params.get("os_type") == "windows":
connection_id = utils_net.get_windows_nic_attribute(
server_ctl, "macaddress", mac, "netconnectionid")
netperf_base.ssh_cmd(server_ctl,
server_mtu_cmd % (connection_id, mtu))
error_context.context("Changing the MTU of client", logging.info)
netperf_base.ssh_cmd(
client, client_mtu_cmd % (params.get("client_physical_nic"), mtu))
netdst = params.get("netdst", "switch")
host_bridges = utils_net.Bridge()
br_in_use = host_bridges.list_br()
if netdst in br_in_use:
ifaces_in_use = host_bridges.list_iface()
target_ifaces = list(ifaces_in_use + br_in_use)
if params.get("netdst_nic1") in process.system_output(
"ovs-vsctl list-br", ignore_status=True, shell=True).decode():
ovs_list = "ovs-vsctl list-ports %s" % params["netdst_nic1"]
ovs_port = process.system_output(ovs_list,
shell=True).decode().splitlines()
target_ifaces = target_ifaces + \
params.objects("netdst_nic1") + ovs_port
if vm.virtnet[0].nettype == "macvtap":
target_ifaces.extend([vm.virtnet[0].netdst, vm.get_ifname(0)])
error_context.context("Change all Bridge NICs MTU to %s" % mtu,
logging.info)
for iface in target_ifaces:
try:
process.run(host_mtu_cmd % (iface, mtu),
ignore_status=False,
shell=True)
except process.CmdError as err:
if "SIOCSIFMTU" in err.result.stderr.decode():
test.cancel("The ethenet device does not support jumbo,"
"cancel test")
def run(test, params, env):
"""
Since 3.3.0, Coalesce setting is supported.
This case is to set coalesce and check for 4 network types and each guest interface type.
Only network/bridge guest interface type take effect for setting interface coalesce.
For each host network type, guest can use bridge/network interface type to set coalesce
except macvtap network type.
Execute 'ethtool -c ${interface}|grep "rx-frames"' and anylize the output to check
whether coalesce setting take effect or not.
For macvtap network type, guest can start but query coalesce will fail.
1. For default host network
network definition is below:
<network>
<name>default</name>
<bridge name="virbr0"/>
<forward/>
<ip address="192.168.122.1" netmask="255.255.255.0">
<dhcp>
<range start="192.168.122.2" end="192.168.122.254"/>
</dhcp>
</ip>
</network>
This is default network.
1) guest interface type 'bridge' and set coalesce:
<interface type='bridge'>
<mac address='52:54:00:a7:4d:f7'/>
<source bridge='virbr0'/>
<target dev='vnet0'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='64'/>
</rx>
</coalesce>
<alias name='net0'/>
<address type='pci' domain='0x0000' bus='0x00' slot='0x03' function='0x0'/>
</interface>
2) guest interface type 'network' and set coalesce:
<interface type='network'>
<source network='default'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='32'/>
</rx>
</coalesce>
</interface>
2. For bridge host network
This mode need true bridge in host network.
'nmcli con add type bridge con-name br0 ifname br0'
1) guest interface type 'bridge' and set coalesce:
<interface type='bridge'>
<mac address='52:54:00:8e:f3:6f'/>
<source bridge='br0'/>
<target dev='vnet0'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='64'/>
</rx>
</coalesce>
<alias name='net0'/>
<address type='pci' domain='0x0000' bus='0x00' slot='0x0a' function='0x0'/>
</interface>
2) guest interface type 'network' and set coalesce:
First, define one virtual network for bridge br0
'virsh net-define net-br0.xml'
'virsh net-dumpxml net-br0'
<network>
<name>net-br0</name>
<forward mode='bridge'/>
<bridge name='br0'/>
</network>
Secondly, use this network for guest
<interface type='network'>
<source network='net-br0'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='32'/>
</rx>
</coalesce>
</interface>
3. For openvswitch bridge host network
This mode need true openvswitch bridge in host network.
'ovs-vsctl add-br ovsbr0'
1) guest interface type 'bridge' and set coalesce:
<interface type='bridge'>
<mac address='52:54:00:8e:f3:6f'/>
<source bridge='ovsbr0'/>
<virtualport type='openvswitch'/>
<target dev='vnet0'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='64'/>
</rx>
</coalesce>
<alias name='net0'/>
<address type='pci' domain='0x0000' bus='0x00' slot='0x0a' function='0x0'/>
</interface>
2) guest interface type 'network' and set coalesce:
First, define one virtual network for openvswitch bridge ovsbr0
'virsh net-define net-ovsbr0.xml'
'virsh net-dumpxml net-ovsbr0'
<network>
<name>net-ovs0</name>
<forward mode='bridge'/>
<bridge name='ovsbr0'/>
<virtualport type='openvswitch'/>
</network>
Secondly, use this network for guest
<interface type='network'>
<source network='net-ovs0'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='32'/>
</rx>
</coalesce>
</interface>
4. For macvtap bridge mode on host network
For this mode, first, create one virtual network.
Note, should set dev to one ture physical interface.
'virsh net-define net-br-macvtap.xml'
'virsh net-dumpxml net-br-macvtap'
<network>
<name>net-br-macvtap</name>
<forward dev='eno1' mode='bridge'>
<interface dev='eno1'/>
</forward>
</network>
Set guest to use this macvtap network and set coalesc
<interface type='network'>
<mac address='52:54:00:6e:f4:f1'/>
<source network='net-br-macvtap'/>
<model type='virtio'/>
<coalesce>
<rx>
<frames max='32'/>
</rx>
</coalesce>
<address type='pci' domain='0x0000' bus='0x00' slot='0x03' function='0x0'/>
</interface>
Steps in this test:
1. Prepare test environment,destroy or suspend a VM.
2. Prepare network if necessary.
3. Edit guest interface with definite network and set coalesce.
4. Start guest and check whether coalesce setting take effect.
5. Recover network and guest.
"""
if not libvirt_version.version_compare(3, 3, 0):
test.skip(
"Coalesce setting is only supported by libvirt3.3.0 and above")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
def get_first_phy_iface():
"""
Get first physical network interface from output of 'ls /sys/class/net'
#ls /sys/class/net
eno1 lo virbr0 virbr0-nic
:return: interface name
"""
interface = ''
lines = process.run('ls /sys/class/net').stdout_text.splitlines()
interfaces = lines[0].split()
for iface in interfaces:
if iface != 'lo' and 'vir' not in iface:
interface = iface
break
if interface == '':
test.fail("There is no physical network interface")
return interface
def modify_iface_xml():
"""
Modify interface xml options
Two methods to modify domain interfae:
1. modify guest xml, define it
2. attach one interface for running guest
:return: 0 for successful negative case
test.fail is fail for positive/negative case
None for successful positive case
"""
if hotplug_iface:
iface = Interface(iface_type)
else:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
xml_devices = vmxml.devices
iface_index = xml_devices.index(
xml_devices.by_device_tag("interface")[0])
iface = xml_devices[iface_index]
if iface_type == 'network':
iface.type_name = iface_type
source = {iface_type: net_name}
elif iface_type == 'bridge' and bridge_name:
iface.type_name = iface_type
source = {iface_type: bridge_name}
elif iface_type == 'direct':
iface.type_name = iface_type
source = {'dev': interface, 'mode': 'bridge'}
if source:
del iface.source
iface.source = source
iface_model = params.get("iface_model", "virtio")
iface.model = iface_model
iface.coalesce = {'max': coalesce_value}
if network_type == "ovsbridge" and iface_type == "bridge":
iface.virtualport_type = "openvswitch"
if not hotplug_iface:
vmxml.devices = xml_devices
vmxml.xmltreefile.write()
try:
vmxml.sync()
except xcepts.LibvirtXMLError as details:
if status_error:
# Expect error for negetive test
return 0
else:
test.fail("Define guest: FAIL")
else:
if not vm.is_alive():
vm.start()
# Wait guest boot completely
time.sleep(2)
try:
ret = virsh.attach_device(vm_name,
iface.xml,
ignore_status=False,
debug=True)
except process.CmdError as error:
if status_error:
# Expect error for negetive test
return 0
else:
test.fail("Define guest: FAIL")
start_error = "yes" == params.get("start_error", "no")
status_error = "yes" == params.get("status_error", "no")
# Get coalesce value.
expect_coalesce = params.get("expect_coalesce", "")
coalesce_value = params.get("coalesce", "15")
if expect_coalesce == '':
expect_coalesce = coalesce_value
# Network specific attributes.
network_type = params.get("network_type", "default")
net_name = params.get("net_name", "default")
net_bridge = params.get("net_bridge", "{'name':'virbr0'}")
# Get guest interface type
iface_type = params.get("iface_type", "network")
# Whether attach interface
hotplug_iface = "yes" == params.get("hotplug_iface", "no")
error_info = params.get("error_info", "")
# Destroy the guest first
if vm.is_alive():
vm.destroy(gracefully=False)
# Back up xml file.
netxml_backup = NetworkXML.new_from_net_dumpxml("default")
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Build the xml and run test.
try:
interface = get_first_phy_iface()
# Prepare network for specific network type.
# Create bridge/ovsbridge for host bridge/ovsbridge network type
if network_type == "default" and iface_type == "bridge":
bridge_name = "virbr0"
elif network_type == "bridge":
bridge_name = eval(net_bridge)['name']
bridge = utils_net.Bridge()
# Try to add bridge if not exist
if bridge_name not in bridge.list_br():
bridge.add_bridge(bridge_name)
elif network_type == 'ovsbridge':
bridge_name = eval(net_bridge)['name']
# Try to add ovs bridge if not exist
if not utils_net.ovs_br_exists(bridge_name):
utils_net.add_ovs_bridge(bridge_name)
if iface_type == "network":
# Define virtual network if not exist for 'network' type of guest interface
network = NetworkXML()
network.name = net_name
# Prepare virtual network required parameters
params['net_forward'] = "{'mode':'bridge'}"
if network_type == "ovsbridge":
params['net_virtualport'] = "openvswitch"
if network_type == "macvtap":
# For bridge type of macvtap network, one true physical interface shold be added
# Check whether physical interface has been added into one bridge. if yes, skip macvtap test
# If interface already added to a bridge, the output of the nmcli
# command will include "connection.slave-type: bridge"
out = process.run('nmcli dev show %s' % interface).stdout_text
con_l = re.findall(r'GENERAL.CONNECTION:(.+?)\n', out)
if not con_l:
test.cancel("no connection for the interface")
else:
con = con_l[0].strip()
if "bridge" not in process.run('nmcli con show "%s"' %
con).stdout_text:
params['forward_iface'] = interface
params[
'net_forward'] = "{'mode':'bridge', 'dev': '%s'}" % interface
else:
test.cancel(
"interface %s has been added into one brige, but macvtap"
"need also add this interface, so current network can't"
"suit macvtap testing" % interface)
if not network.exists():
netxml = libvirt.create_net_xml(net_name, params)
netxml.define()
netxml.start()
virsh.net_dumpxml(network.name, debug=True)
# Edit the interface xml.
# For successful negative case, return 0 to specify PASS result directly
ret = modify_iface_xml()
if ret == 0:
return 0
try:
# Get all interface
link_before = set(
process.run('ls /sys/class/net').stdout_text.splitlines())
# Start the VM.
vm.start()
if start_error:
raise test.fail("VM started unexpectedly")
# Get guest virtual network interface
link_after = set(
process.run('ls /sys/class/net').stdout_text.splitlines())
newinterface = (link_after - link_before).pop()
out = process.run('ethtool -c %s' % newinterface,
ignore_status=True)
if network_type == 'macvtap':
# Currently, output coalesce for macvtap is not supported
err_msg = "Cannot get device coalesce settings: Operation not supported"
std_msg = "Coalesce parameters for %s:" % newinterface
if err_msg not in out.stderr_text or std_msg not in out.stdout_text:
test.fail("coalesce setting on %s failed." % network_type)
else:
# Get coalesce value and check it is true
if out.exit_status == 0:
for line in out.stdout_text.splitlines():
if 'rx-frames:' in line:
coalesce = line.split(':')[1].strip()
if expect_coalesce != coalesce:
test.fail("coalesce setting failed for %s" %
network_type)
break
else:
test.fail("coalesce setting on %s failed." % network_type)
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 bridge
if network_type == "bridge" and bridge_name:
if bridge_name in bridge.list_br():
bridge.del_bridge(bridge_name)
elif network_type == "ovsbridge" and bridge_name:
if utils_net.ovs_br_exists(bridge_name):
utils_net.del_ovs_bridge(bridge_name)
vmxml_backup.sync()
def run_virsh_attach_detach_interface(test, params, env):
"""
Test virsh {at|de}tach-interface command.
1) Prepare test environment and its parameters
2) Attach the required interface
3) According test type(only attach or both attach and detach):
a.Go on to test detach(if attaching is correct)
b.Return GOOD or raise TestFail(if attaching is wrong)
4) Check if attached interface is correct:
a.Try to catch it in vm's XML file
b.Try to catch it in vm
5) Detach the attached interface
6) Check result
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Test parameters
uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
vm_ref = params.get("at_detach_iface_vm_ref", "domname")
options_suffix = params.get("at_detach_iface_options_suffix", "")
status_error = "yes" == params.get("status_error", "no")
start_vm = params.get("start_vm")
# Should attach must be pass for detach test.
correct_attach = "yes" == params.get("correct_attach", "no")
# Interface specific attributes.
iface_type = params.get("at_detach_iface_type", "network")
iface_source = params.get("at_detach_iface_source", "default")
iface_mac = params.get("at_detach_iface_mac", "created")
virsh_dargs = {'ignore_status': True, 'uri': uri}
# Get a bridge name for test if iface_type is bridge.
# If there is no bridge other than virbr0, raise TestNAError
if iface_type == "bridge":
host_bridge = utils_net.Bridge()
bridge_list = host_bridge.list_br()
try:
bridge_list.remove("virbr0")
except AttributeError:
pass # If no virbr0, just pass is ok
logging.debug("Useful bridges:%s", bridge_list)
# just choosing one bridge on host.
if len(bridge_list):
iface_source = bridge_list[0]
else:
raise error.TestNAError("No useful bridge on host "
"other than 'virbr0'.")
dom_uuid = vm.get_uuid()
dom_id = vm.get_id()
# To confirm vm's state
if start_vm == "no" and vm.is_alive():
vm.destroy()
# Test both detach and attach, So collect info
# both of them for result check.
# When something wrong with interface, set it to 1
fail_flag = 0
result_info = []
# Set attach-interface domain
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = dom_id
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "hexdomid" and dom_id is not None:
vm_ref = hex(int(dom_id))
# Get a mac address if iface_mac is 'created'.
if iface_mac == "created" or correct_attach:
iface_mac = utils_net.generate_mac_address_simple()
# Set attach-interface options and Start attach-interface test
if correct_attach:
options = set_options("network", "default", iface_mac, "", "attach")
attach_result = virsh.attach_interface(vm_name, options, **virsh_dargs)
else:
options = set_options(iface_type, iface_source, iface_mac,
options_suffix, "attach")
attach_result = virsh.attach_interface(vm_ref, options, **virsh_dargs)
attach_status = attach_result.exit_status
logging.debug(attach_result)
# If attach interface failed.
if attach_status:
if not status_error:
fail_flag = 1
result_info.append("Attach Failed: %s" % attach_result)
elif status_error:
# Here we just use it to exit, do not mean test failed
fail_flag = 1
# If attach interface succeeded.
else:
if status_error and not correct_attach:
fail_flag = 1
result_info.append("Attach Success with wrong command.")
if fail_flag and start_vm == "yes":
vm.destroy()
if len(result_info):
raise error.TestFail(result_info)
else:
# Exit because it is error_test for attach-interface.
return
# Check dumpxml file whether the interface is added successfully.
status, ret = check_dumpxml_iface(vm_name, iface_mac, iface_type,
iface_source)
if status:
fail_flag = 1
result_info.append(ret)
# Login to domain to check new interface.
if not vm.is_alive():
vm.start()
elif vm.state() == "paused":
vm.resume()
status, ret = login_to_check(vm, iface_mac)
if status:
fail_flag = 1
result_info.append(ret)
# Set detach-interface options
options = set_options(iface_type, None, iface_mac, options_suffix,
"detach")
# Start detach-interface test
detach_result = virsh.detach_interface(vm_ref, options, **virsh_dargs)
detach_status = detach_result.exit_status
logging.debug(detach_result)
# Clean up.
if check_dumpxml_iface(vm_name, iface_mac) is not None:
cleanup_options = "--type %s --mac %s" % (iface_type, iface_mac)
virsh.detach_interface(vm_ref, cleanup_options, **virsh_dargs)
# Shutdown vm to be afraid of cleaning up failed
if vm.is_alive():
vm.destroy()
# Check results.
if status_error:
if detach_status == 0:
raise error.TestFail("Detach Success with wrong command.")
else:
if detach_status != 0:
raise error.TestFail("Detach Failed.")
else:
if fail_flag:
raise error.TestFail("Attach-Detach Success but "
"something wrong with its "
"functional use:%s" % result_info)
def run(test, params, env):
"""
Test virsh {at|de}tach-interface command.
1) Prepare test environment and its parameters
2) Attach the required interface
3) According test type(only attach or both attach and detach):
a.Go on to test detach(if attaching is correct)
b.Return GOOD or raise TestFail(if attaching is wrong)
4) Check if attached interface is correct:
a.Try to catch it in vm's XML file
b.Try to catch it in vm
5) Detach the attached interface
6) Check result
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Test parameters
uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
vm_ref = params.get("at_detach_iface_vm_ref", "domname")
options_suffix = params.get("at_detach_iface_options_suffix", "")
status_error = "yes" == params.get("status_error", "no")
start_vm = params.get("start_vm")
# Should attach must be pass for detach test.
correct_attach = "yes" == params.get("correct_attach", "no")
readonly = ("yes" == params.get("readonly", "no"))
# Interface specific attributes.
iface_type = params.get("at_detach_iface_type", "network")
iface_source = params.get("at_detach_iface_source", "default")
iface_mode = params.get("at_detach_iface_mode", "vepa")
iface_mac = params.get("at_detach_iface_mac", "created")
iface_target = params.get("at_detach_iface_target")
iface_model = params.get("at_detach_iface_model")
iface_inbound = params.get("at_detach_iface_inbound")
iface_outbound = params.get("at_detach_iface_outbound")
iface_rom = params.get("at_detach_rom_bar")
iface_link = params.get("at_detach_link_state")
iface_boot = params.get("at_detach_boot_order")
iface_driver = params.get("at_detach_iface_driver")
iface_driver_host = params.get("at_detach_driver_host")
iface_driver_guest = params.get("at_detach_driver_guest")
iface_backend = params.get("at_detach_iface_backend")
save_restore = params.get("save_restore", "no")
restart_libvirtd = params.get("restart_libvirtd", "no")
attach_cmd = params.get("attach_cmd", "attach-interface")
virsh_dargs = {'ignore_status': True, 'debug': True, 'uri': uri}
validate_xml_result = "yes" == params.get("check_xml_result", "no")
paused_after_vm_start = "yes" == params.get("paused_after_vm_start", "no")
machine_type = params.get("machine_type")
# Get iface name if iface_type is direct
if iface_type == "direct":
iface_source = utils_net.get_net_if(state="UP")[0]
# Get a bridge name for test if iface_type is bridge.
# If there is no bridge other than virbr0, try to create one
# or fail test
if iface_type == "bridge":
host_bridge = utils_net.Bridge()
bridge_list = host_bridge.list_br()
try:
bridge_list.remove("virbr0")
except AttributeError:
pass # If no virbr0, just pass is ok
logging.debug("Useful bridges:%s", bridge_list)
if len(bridge_list):
iface_source = bridge_list[0]
else:
process.run('ip link add name br0 type bridge',
ignore_status=False)
iface_source = 'br0'
logging.debug("Added bridge br0")
# Test both detach and attach, So collect info
# both of them for result check.
# When something wrong with interface, set it to 1
fail_flag = 0
result_info = []
# Get a mac address if iface_mac is 'created'.
if iface_mac == "created" or correct_attach:
iface_mac = utils_net.generate_mac_address_simple()
names = locals()
iface_format = get_formatted_iface_dict(names, params.get("vm_arch_name"))
# for rtl8139 model, need to add pcie bridge
if iface_model == "rtl8139" and machine_type == "q35":
add_pcie_controller(vm_name)
if start_vm == "yes" and not vm.is_alive():
vm.start()
try:
# Generate xml file if using attach-device command
if attach_cmd == "attach-device":
# Change boot order to disk
libvirt.change_boot_order(vm_name, "disk", "1")
vm.destroy()
vm.start()
# Generate attached xml
new_iface = Interface(type_name=iface_type)
xml_file_tmp = libvirt.modify_vm_iface(vm_name, "get_xml",
iface_format)
new_iface.xml = xml_file_tmp
new_iface.del_address()
xml_file = new_iface.xml
# To confirm vm's state and make sure os fully started
if start_vm == "no":
if vm.is_alive():
vm.destroy()
else:
vm.wait_for_login().close()
if paused_after_vm_start:
vm.pause()
# Set attach-interface domain
dom_uuid = vm.get_uuid()
dom_id = vm.get_id()
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = dom_id
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "hexdomid" and dom_id is not None:
vm_ref = hex(int(dom_id))
# Set attach-interface options and Start attach-interface test
if correct_attach:
options = set_options("network", "default", iface_mac, "",
"attach", None, iface_model)
if readonly:
virsh_dargs.update({'readonly': True, 'debug': True})
attach_result = virsh.attach_interface(vm_name, options,
**virsh_dargs)
else:
if attach_cmd == "attach-interface":
options = set_options(iface_type, iface_source, iface_mac,
options_suffix, "attach", iface_target,
iface_model, iface_inbound,
iface_outbound)
attach_result = virsh.attach_interface(vm_ref, options,
**virsh_dargs)
elif attach_cmd == "attach-device":
attach_result = virsh.attach_device(vm_name,
xml_file,
ignore_status=True,
debug=True)
attach_status = attach_result.exit_status
logging.debug(attach_result)
# If attach interface failed.
if attach_status:
if not status_error:
fail_flag = 1
result_info.append("Attach Failed: %s" % attach_result.stderr)
elif status_error:
# Here we just use it to exit, do not mean test failed
fail_flag = 1
# If attach interface succeeded.
else:
if status_error and not correct_attach:
fail_flag = 1
result_info.append("Attach Success with wrong command.")
if fail_flag and start_vm == "yes":
vm.destroy()
if len(result_info):
test.fail(result_info)
else:
# Exit because it is error_test for attach-interface.
return
if "print-xml" in options_suffix:
iface_obj = Interface(type_name=iface_type)
iface_obj.xml = attach_result.stdout.strip()
if (iface_obj.type_name == iface_type
and iface_obj.source['dev'] == iface_source
and iface_obj.target['dev'] == iface_target
and iface_obj.model == iface_model
and iface_obj.bandwidth.inbound == eval(
iface_format['inbound'])
and iface_obj.bandwidth.outbound == eval(
iface_format['outbound'])):
logging.info("Print ml all element check pass")
else:
test.fail("Print xml do not show as expected")
# Check dumpxml file whether the interface is added successfully.
status, ret = check_dumpxml_iface(vm_name, iface_format)
if "print-xml" not in options_suffix:
# Check validate_xml_result flag to determine whether apply check_interface_xml.
if validate_xml_result:
# If options_suffix contains config, it need dump inactive xml.
is_active = True
if options_suffix.count("config"):
is_active = False
# Check dumping VM xml value.
if not check_interface_xml(vm_name, iface_type, iface_source,
iface_mac, is_active):
test.fail(
"Failed to find matched interface values in VM interface xml"
)
if status:
fail_flag = 1
result_info.append(ret)
else:
if status == 0:
test.fail(
"Attach interface effect in xml with print-xml option")
else:
return
# Login to domain to check new interface.
if not vm.is_alive():
vm.start()
elif vm.state() == "paused":
vm.resume()
vm.wait_for_login().close()
status, ret = login_to_check(vm, iface_mac)
if status:
fail_flag = 1
result_info.append(ret)
# Check on host for direct type
if iface_type == 'direct':
cmd_result = process.run(
"ip -d link show test").stdout_text.strip()
logging.info("cmd output is %s", cmd_result)
check_patten = (
"%s@%s.*\n.*%s.*\n.*macvtap.*mode.*%s" %
(iface_target, iface_source, iface_mac, iface_mode))
logging.info("check patten is %s", check_patten)
if not re.search(check_patten, cmd_result):
logging.error("Can not find %s in ip link" % check_patten)
fail_flag = 1
result_info.append(cmd_result)
# Do operation and check again
if restart_libvirtd == "yes":
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
if save_restore == "yes":
check_save_restore(vm_name)
status, ret = check_dumpxml_iface(vm_name, iface_format)
if status:
fail_flag = 1
result_info.append(ret)
# Set detach-interface options
options = set_options(iface_type, None, iface_mac, options_suffix,
"detach")
# Start detach-interface test
if save_restore == "yes" and vm_ref == dom_id:
vm_ref = vm_name
detach_result = virsh.detach_interface(vm_ref, options, **virsh_dargs)
detach_status = detach_result.exit_status
detach_msg = detach_result.stderr.strip()
logging.debug(detach_result)
if detach_status == 0 and status_error == 0:
# If command with --config parameter, ignore below checking.
if options_suffix.count("config"):
return
# Check the xml after detach and clean up if needed.
time.sleep(5)
status, _ = check_dumpxml_iface(vm_name, iface_format)
if status == 0:
detach_status = 1
detach_msg = "xml still exist after detach"
cleanup_options = "--type %s --mac %s" % (iface_type,
iface_mac)
virsh.detach_interface(vm_ref, cleanup_options, **virsh_dargs)
else:
logging.info("After detach, the interface xml disappeared")
# Check results.
if status_error:
if detach_status == 0:
test.fail("Detach Success with wrong command.")
else:
if detach_status != 0:
test.fail("Detach Failed: %s" % detach_msg)
else:
if fail_flag:
test.fail("Attach-Detach Success but "
"something wrong with its "
"functional use:%s" % result_info)
finally:
if vm.is_alive():
vm.destroy()
backup_xml.sync()
def run(test, params, env):
"""
Qemu host nic bonding test:
1) Load bonding module with mode 802.3ad
2) Bring up bond interface
3) Add nics to bond interface
4) Add a new bridge and add bond interface to it
5) Get ip address for bridge
6) Boot up guest with the bridge
7) Checking guest netowrk via ping
8) Start file transfer between guest and host
9) Disable and enable physical interfaces during file transfer
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
bond_iface = params.get("bond_iface", "bond0")
bond_br_name = params.get("bond_br_name", "br_bond0")
timeout = int(params.get("login_timeout", 240))
remote_host = params.get("dsthost")
ping_timeout = int(params.get("ping_timeout", 240))
bonding_timeout = int(params.get("bonding_timeout", 1))
bonding_mode = params.get("bonding_mode", "1")
bonding_miimon = params.get("bonding_miimon", "100")
bonding_max_bonds = params.get("bonding_max_bonds", "1")
params['netdst'] = bond_br_name
host_bridges = utils_net.Bridge()
error_context.context("Load bonding module with mode 802.3ad",
logging.info)
if not process.system("lsmod|grep bonding", ignore_status=True,
shell=True):
process.system("modprobe -r bonding")
process.system("modprobe bonding mode=%s miimon=%s max_bonds=%s" %
(bonding_mode, bonding_miimon, bonding_max_bonds))
error_context.context("Bring up %s" % bond_iface, logging.info)
host_ifaces = utils_net.get_host_iface()
if bond_iface not in host_ifaces:
test.error("Can not find %s in host" % bond_iface)
bond_iface = utils_net.Interface(bond_iface)
bond_iface.up()
bond_mac = bond_iface.get_mac()
host_ph_iface_pre = params.get("host_ph_iface_prefix", "en")
host_iface_bonding = int(params.get("host_iface_bonding", 2))
ph_ifaces = [_ for _ in host_ifaces if re.match(host_ph_iface_pre, _)]
host_ph_ifaces = [_ for _ in ph_ifaces if utils_net.Interface(_).is_up()]
ifaces_in_use = host_bridges.list_iface()
host_ph_ifaces_un = list(set(host_ph_ifaces) - set(ifaces_in_use))
if (len(host_ph_ifaces_un) < 2
or len(host_ph_ifaces_un) < host_iface_bonding):
test.cancel("Host need %s nics at least." % host_iface_bonding)
error_context.context("Add nics to %s" % bond_iface.name, logging.info)
host_ifaces_bonding = host_ph_ifaces_un[:host_iface_bonding]
ifenslave_cmd = "ifenslave %s" % bond_iface.name
op_ifaces = []
for host_iface_bonding in host_ifaces_bonding:
op_ifaces.append(utils_net.Interface(host_iface_bonding))
ifenslave_cmd += " %s" % host_iface_bonding
process.system(ifenslave_cmd)
error_context.context(
"Add a new bridge and add %s to it." % bond_iface.name, logging.info)
if bond_br_name not in host_bridges.list_br():
host_bridges.add_bridge(bond_br_name)
host_bridges.add_port(bond_br_name, bond_iface.name)
error_context.context("Get ip address for bridge", logging.info)
process.system("dhclient -r; dhclient %s" % bond_br_name, shell=True)
error_context.context("Boot up guest with bridge %s" % bond_br_name,
logging.info)
params["start_vm"] = "yes"
vm_name = params.get("main_vm")
env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
session = vm.wait_for_login(timeout=timeout)
error_context.context("Checking guest netowrk via ping.", logging.info)
ping_cmd = params.get("ping_cmd")
ping_cmd = re.sub("REMOTE_HOST", remote_host, ping_cmd)
session.cmd(ping_cmd, timeout=ping_timeout)
error_context.context("Start file transfer", logging.info)
f_transfer = utils_misc.InterruptedThread(
utils_test.run_virt_sub_test,
args=(
test,
params,
env,
),
kwargs={"sub_type": "file_transfer"})
f_transfer.start()
utils_misc.wait_for(
lambda: process.system_output("pidof scp", ignore_status=True), 30)
error_context.context(
"Disable and enable physical "
"interfaces in %s" % bond_br_name, logging.info)
while True:
for op_iface in op_ifaces:
logging.debug("Turn down %s", op_iface.name)
op_iface.down()
time.sleep(bonding_timeout)
logging.debug("Bring up %s", op_iface.name)
op_iface.up()
time.sleep(bonding_timeout)
if not f_transfer.is_alive():
break
f_transfer.join()
def run(test, params, env):
"""
This test is for macvtap nic
1. Check and backup environment
2. Configure guest, add new nic and set a static ip address
3. According to nic mode, start test
4. Recover environment
"""
vm_names = params.get("vms").split()
remote_ip = params.get("remote_ip", "ENTER.YOUR.REMOTE.IP")
iface_mode = params.get("mode", "vepa")
eth_card_no = params.get("eth_card_no", "ENTER.YOUR.DEV.NAME")
vm1_ip = params.get("vm1_ip", "ENTER.YOUR.GUEST1.IP")
vm2_ip = params.get("vm2_ip", "ENTER.YOUR.GUEST2.IP")
eth_config_file = params.get("eth_config_file",
"ENTER.YOUR.CONFIG.FILE.PATH")
persistent_net_file = params.get("persistent_net_file",
"ENTER.YOUR.RULE.FILE.PATH")
param_keys = [
"remote_ip", "vm1_ip", "vm2_ip", "eth_card_no", "eth_config_file",
"persistent_net_file"
]
param_values = [
remote_ip, vm1_ip, vm2_ip, eth_card_no, eth_config_file,
persistent_net_file
]
for key, value in zip(param_keys, param_values):
if value.count("ENTER.YOUR"):
test.cancel("Parameter '%s'(%s) is not configured." % (key, value))
vm1 = env.get_vm(vm_names[0])
vm2 = None
if len(vm_names) > 1:
vm2 = env.get_vm(vm_names[1])
if eth_card_no not in utils_net.get_net_if():
test.cancel("Device %s do not exists." % eth_card_no)
try:
iface_cls = utils_net.Interface(eth_card_no)
origin_status = iface_cls.is_up()
if not origin_status:
iface_cls.up()
except process.CmdError as detail:
test.cancel(str(detail))
br_cls = utils_net.Bridge()
if eth_card_no in br_cls.list_iface():
test.cancel("%s has been used!" % eth_card_no)
vmxml1 = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[0])
if vm2:
vmxml2 = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[1])
def guest_config(vm, ip_addr):
"""
Add a new nic to guest and set a static ip address
:param vm: Configured guest
:param ip_addr: Set ip address
"""
# Attach an interface device
# Use attach-device, not attach-interface, because attach-interface
# doesn't support 'direct'
interface_class = vm_xml.VMXML.get_device_class('interface')
interface = interface_class(type_name="direct")
interface.source = dict(dev=str(eth_card_no), mode=str(iface_mode))
interface.model = "virtio"
interface.xmltreefile.write()
if vm.is_alive():
vm.destroy(gracefully=False)
virsh.attach_device(vm.name, interface.xml, flagstr="--config")
os.remove(interface.xml)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
new_nic = vmxml.get_devices(device_type="interface")[-1]
# Modify new interface's IP
vm.start()
session = vm.wait_for_login()
eth_name = utils_net.get_linux_ifname(session, new_nic.mac_address)
eth_config_detail_list = [
'DEVICE=%s' % eth_name,
'HWADDR=%s' % new_nic.mac_address, 'ONBOOT=yes',
'BOOTPROTO=static',
'IPADDR=%s' % ip_addr
]
remote_file = remote.RemoteFile(vm.get_address(), 'scp', 'root',
params.get('password'), 22,
eth_config_file)
remote_file.truncate()
remote_file.add(eth_config_detail_list, linesep='\n')
try:
# Attached interface maybe already active
session.cmd("ifdown %s" % eth_name)
except aexpect.ShellCmdError:
test.fail("ifdown %s failed." % eth_name)
try:
session.cmd("ifup %s" % eth_name)
except aexpect.ShellCmdError:
test.fail("ifup %s failed." % eth_name)
return session
def guest_clean(vm, vmxml):
"""
Recover guest configuration
:param: Recovered guest
"""
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
session.cmd("rm -f %s" % eth_config_file)
session.cmd("sync")
try:
# Delete the last 3 lines
session.cmd('sed -i "$[$(cat %s | wc -l) - 2],$"d %s' %
(persistent_net_file, persistent_net_file))
session.cmd("sync")
except aexpect.ShellCmdError:
# This file may not exists
pass
vm.destroy()
vmxml.sync()
def vepa_test(session):
"""
vepa mode test.
Check guest can ping remote host
"""
ping_s, _ = ping(remote_ip, count=1, timeout=5, session=session)
if ping_s:
test.fail("%s ping %s failed." % (vm1.name, remote_ip))
def private_test(session):
"""
private mode test.
Check guest cannot ping other guest, but can pin remote host
"""
ping_s, _ = ping(remote_ip, count=1, timeout=5, session=session)
if ping_s:
test.fail("%s ping %s failed." % (vm1.name, remote_ip))
ping_s, _ = ping(vm2_ip, count=1, timeout=5, session=session)
if not ping_s:
test.fail("%s ping %s succeed, but expect failed." %
(vm1.name, vm2.name))
try:
iface_cls.down()
except process.CmdError as detail:
test.cancel(str(detail))
ping_s, _ = ping(vm2_ip, count=1, timeout=5, session=session)
if not ping_s:
test.fail("%s ping %s succeed, but expect failed." %
(vm1.name, remote_ip))
def passthrough_test(session):
"""
passthrough mode test.
Check guest can ping remote host.
When guest is running, local host cannot ping remote host,
When guest is poweroff, local host can ping remote host,
"""
ping_s, _ = ping(remote_ip, count=1, timeout=5, session=session)
if ping_s:
test.fail("%s ping %s failed." % (vm1.name, remote_ip))
ping_s, _ = ping(remote_ip, count=1, timeout=5)
if not ping_s:
test.fail("host ping %s succeed, but expect fail." % remote_ip)
vm1.destroy(gracefully=False)
ping_s, _ = ping(remote_ip, count=1, timeout=5)
if ping_s:
test.fail("host ping %s failed." % remote_ip)
def bridge_test(session):
"""
bridge mode test.
Check guest can ping remote host
guest can ping other guest when macvtap nic is up
guest cannot ping remote host when macvtap nic is up
"""
ping_s, _ = ping(remote_ip, count=1, timeout=5, session=session)
if ping_s:
test.fail("%s ping %s failed." % (vm1.name, remote_ip))
ping_s, _ = ping(vm2_ip, count=1, timeout=5, session=session)
if ping_s:
test.fail("%s ping %s failed." % (vm1.name, vm2.name))
try:
iface_cls.down()
except process.CmdError as detail:
test.cancel(str(detail))
ping_s, _ = ping(remote_ip, count=1, timeout=5, session=session)
if not ping_s:
test.fail("%s ping %s success, but expected fail." %
(vm1.name, remote_ip))
# Test start
try:
try:
session = guest_config(vm1, vm1_ip)
except remote.LoginTimeoutError as fail:
test.fail(str(fail))
if vm2:
try:
guest_config(vm2, vm2_ip)
except remote.LoginTimeoutError as fail:
test.fail(str(fail))
# Four mode test
if iface_mode == "vepa":
vepa_test(session)
elif iface_mode == "bridge":
bridge_test(session)
elif iface_mode == "private":
private_test(session)
elif iface_mode == "passthrough":
passthrough_test(session)
finally:
if iface_cls.is_up():
if not origin_status:
iface_cls.down()
else:
if origin_status:
iface_cls.up()
guest_clean(vm1, vmxml1)
if vm2:
guest_clean(vm2, vmxml2)
def run(test, params, env):
"""
Test virsh interface related commands.
(1) If using given exist interface for testing(eg. lo or ethX):
1.1 Dumpxml for the interface(with --inactive option)
1.2 Destroy the interface
1.3 Undefine the interface
(2) Define an interface from XML file
(3) List interfaces with '--inactive' optioin
(4) Start the interface
(5) List interfaces with no option
(6) Dumpxml for the interface
(7) Get interface MAC address by interface name
(8) Get interface name by interface MAC address
(9) Delete interface if not use the exist interface for testing
9.1 Destroy the interface
9.2 Undefine the interface
Caveat, this test may affect the host network, so using the loopback(lo)
device by default. You can specify the interface which you want, but be
careful.
"""
iface_name = params.get("iface_name")
iface_xml = params.get("iface_xml")
iface_type = params.get("iface_type", "ethernet")
iface_pro = params.get("iface_pro", "")
iface_eth = params.get("iface_eth", "")
iface_tag = params.get("iface_tag", "0")
if iface_type == "vlan":
iface_name = iface_eth + "." + iface_tag
iface_eth_using = "yes" == params.get("iface_eth_using", "no")
ping_ip = params.get("ping_ip", "localhost")
use_exist_iface = "yes" == params.get("use_exist_iface", "no")
status_error = "yes" == params.get("status_error", "no")
net_restart = "yes" == params.get("iface_net_restart", "no")
if ping_ip.count("ENTER"):
raise error.TestNAError("Please input a valid ip address")
if iface_name.count("ENTER"):
raise error.TestNAError("Please input a existing bridge/ethernet name")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
if vm:
xml_bak = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(test.tmpdir, "iface-%s.bk" % iface_name)
net_bridge = utils_net.Bridge()
if use_exist_iface:
if iface_type == "bridge":
if iface_name not in net_bridge.list_br():
raise error.TestError("Bridge '%s' not exists" % iface_name)
ifaces = net_bridge.get_structure()[iface_name]
if len(ifaces) < 1:
# In this situation, dhcp maybe cannot get ip address
# Unless you use static, we'd better skip such case
raise error.TestNAError("Bridge '%s' has no interface"
" bridged, perhaps cannot get"
" ipaddress" % iface_name)
net_iface = utils_net.Interface(name=iface_name)
iface_is_up = True
list_option = "--all"
if use_exist_iface:
if not libvirt.check_iface(iface_name, "exists", "--all"):
raise error.TestError("Interface '%s' not exists" % iface_name)
iface_xml = os.path.join(test.tmpdir, "iface.xml.tmp")
iface_is_up = net_iface.is_up()
else:
# Note, if not use the interface which already exists, iface_name must
# be equal to the value specified in XML file
if libvirt.check_iface(iface_name, "exists", "--all"):
raise error.TestError("Interface '%s' already exists" % iface_name)
if not iface_xml:
raise error.TestError("XML file is needed.")
iface_xml = os.path.join(test.tmpdir, iface_xml)
create_xml_file(iface_xml, params)
# Stop NetworkManager as which may conflict with virsh iface commands
try:
NM = utils_misc.find_command("NetworkManager")
except ValueError:
logging.debug("No NetworkManager service.")
NM = None
NM_is_running = False
if NM is not None:
NM_service = service.Factory.create_service("NetworkManager")
NM_is_running = NM_service.status()
if NM_is_running:
NM_service.stop()
# run test cases
try:
if use_exist_iface:
# back up the interface script
utils.run("cp %s %s" % (iface_script, iface_script_bk))
# step 1.1
# dumpxml for interface
xml = virsh.iface_dumpxml(iface_name,
"--inactive",
to_file=iface_xml,
debug=True)
# Step 1.2
# Destroy interface
if iface_is_up:
result = virsh.iface_destroy(iface_name, debug=True)
libvirt.check_exit_status(result, status_error)
# Step 1.3
# Undefine interface
result = virsh.iface_undefine(iface_name, debug=True)
libvirt.check_exit_status(result, status_error)
if not status_error:
if libvirt.check_iface(iface_name, "exists", list_option):
raise error.TestFail("%s is still present." % iface_name)
# Step 2
# Define interface
result = virsh.iface_define(iface_xml, debug=True)
if iface_type == "bond" and not ping_ip:
libvirt.check_exit_status(result, True)
return
else:
libvirt.check_exit_status(result, status_error)
if net_restart:
network = service.Factory.create_service("network")
network.restart()
# After network restart, (ethernet)interface will be started
if (not net_restart and iface_type in ("bridge", "ethernet")) or\
(not use_exist_iface and iface_type in ("vlan", "bond")):
# Step 3
# List inactive interfaces
list_option = "--inactive"
if not status_error:
if not libvirt.check_iface(iface_name, "exists", list_option):
raise error.TestFail("Fail to find %s." % iface_name)
# Step 4
# Start interface
result = virsh.iface_start(iface_name, debug=True)
if not net_restart and not use_exist_iface and\
(iface_type == "ethernet" and iface_pro in ["", "dhcp"] or
iface_type == "bridge" and iface_pro == "dhcp"):
libvirt.check_exit_status(result, True)
else:
libvirt.check_exit_status(result, status_error)
if not status_error:
iface_ip = net_iface.get_ip()
ping_ip = ping_ip if not iface_ip else iface_ip
if ping_ip:
if not libvirt.check_iface(iface_name, "ping", ping_ip):
raise error.TestFail("Ping %s fail." % ping_ip)
# Step 5
# List active interfaces
if use_exist_iface or\
(iface_pro != "dhcp" and iface_type == "bridge") or\
(iface_eth_using and iface_type == "vlan"):
list_option = ""
if not status_error:
if not libvirt.check_iface(iface_name, "exists", list_option):
raise error.TestFail("Fail to find %s in active "
"interface list" % iface_name)
if vm:
iface_mac_list = vm_xml.VMXML.get_iface_dev(vm_name)
# Before test, detach all interfaces in guest
for mac in iface_mac_list:
iface_info = vm_xml.VMXML.get_iface_by_mac(vm_name, mac)
type = iface_info.get('type')
virsh.detach_interface(
vm_name, "--type %s --mac %s"
" --config" % (type, mac))
virsh.attach_interface(
vm_name, "--type %s --source %s"
" --config" % (iface_type, iface_name))
vm.start()
try:
# Test if guest can be login
vm.wait_for_login()
except remote.LoginError:
raise error.TestFail("Cannot login guest with %s" %
iface_name)
# Step 6
# Dumpxml for interface
xml = virsh.iface_dumpxml(iface_name, "", to_file="", debug=True)
logging.debug("Interface '%s' XML:\n%s", iface_name, xml)
# Step 7
# Get interface MAC address by name
result = virsh.iface_mac(iface_name, debug=True)
libvirt.check_exit_status(result, status_error)
if not status_error and result.stdout.strip():
if not libvirt.check_iface(iface_name, "mac",
result.stdout.strip()):
raise error.TestFail("Mac address check fail")
# Step 8
# Get interface name by MAC address
# Bridge's Mac equal to bridged interface's mac
if iface_type not in ("bridge", "vlan") and result.stdout.strip():
iface_mac = net_iface.get_mac()
result = virsh.iface_name(iface_mac, debug=True)
libvirt.check_exit_status(result, status_error)
# Step 9
if not use_exist_iface:
# Step 9.1
# Destroy interface
result = virsh.iface_destroy(iface_name, debug=True)
if not net_restart and\
iface_type == "ethernet" and iface_pro in ["", "dhcp"] or\
iface_type == "bridge" and iface_pro == "dhcp":
libvirt.check_exit_status(result, True)
else:
libvirt.check_exit_status(result, status_error)
# Step 9.2
# Undefine interface
result = virsh.iface_undefine(iface_name, debug=True)
libvirt.check_exit_status(result, status_error)
list_option = "--all"
if not status_error:
if libvirt.check_iface(iface_name, "exists", list_option):
raise error.TestFail("%s is still present." % iface_name)
finally:
if os.path.exists(iface_xml):
os.remove(iface_xml)
if os.path.exists(iface_script):
os.remove(iface_script)
if use_exist_iface:
if not os.path.exists(iface_script):
utils.run("mv %s %s" % (iface_script_bk, iface_script))
if iface_is_up and\
not libvirt.check_iface(iface_name, "exists", ""):
# Need reload script
utils.run("ifup %s" % iface_name)
elif not iface_is_up and libvirt.check_iface(
iface_name, "exists", ""):
net_iface.down()
if vm:
xml_bak.sync()
else:
if libvirt.check_iface(iface_name, "exists", "--all"):
# Remove the interface
try:
utils_net.bring_down_ifname(iface_name)
except utils_net.TAPBringDownError:
pass
if iface_type == "bridge":
if iface_name in net_bridge.list_br():
try:
net_bridge.del_bridge(iface_name)
except IOError:
pass
if NM_is_running:
NM_service.start()
def run(test, params, env):
"""
Test the RX jumbo frame function of vnics:
1) Boot the VM.
2) Change the MTU of guest nics and host taps depending on the NIC model.
3) Add the static ARP entry for guest NIC.
4) Wait for the MTU ok.
5) Verify the path MTU using ping.
6) Ping the guest with large frames.
7) Increment size ping.
8) Flood ping the guest with large frames.
9) Verify the path MTU.
10) Recover the MTU.
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
timeout = int(params.get("login_timeout", 360))
mtu_default = 1500
mtu = params.get("mtu", "1500")
def_max_icmp_size = int(mtu) - 28
max_icmp_pkt_size = int(params.get("max_icmp_pkt_size", def_max_icmp_size))
flood_time = params.get("flood_time", "300")
os_type = params.get("os_type")
os_variant = params.get("os_variant")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
session_serial = vm.wait_for_serial_login(timeout=timeout)
ifname = vm.get_ifname(0)
guest_ip = vm.get_address(0)
if guest_ip is None:
test.error("Could not get the guest ip address")
def get_ovs_ports(ovs):
'''
get the ovs bridge all Interface list.
:param ovs: Ovs bridge name
'''
cmd = "ovs-vsctl list-ports %s" % ovs
return set(process.system_output(cmd, shell=True).splitlines())
host_mtu_cmd = "ifconfig %s mtu %s"
netdst = params.get("netdst", "switch")
host_bridges = utils_net.Bridge()
br_in_use = host_bridges.list_br()
if netdst in br_in_use:
ifaces_in_use = host_bridges.list_iface()
target_ifaces = set(ifaces_in_use) - set(br_in_use)
else:
target_ifaces = get_ovs_ports(netdst)
error_context.context("Change all Bridge NICs MTU to %s" % mtu,
logging.info)
for iface in target_ifaces:
process.run(host_mtu_cmd % (iface, mtu), shell=True)
try:
error_context.context("Changing the MTU of guest", logging.info)
# Environment preparation
mac = vm.get_mac_address(0)
if os_type == "linux":
ethname = utils_net.get_linux_ifname(session, mac)
guest_mtu_cmd = "ifconfig %s mtu %s" % (ethname, mtu)
else:
connection_id = utils_net.get_windows_nic_attribute(
session, "macaddress", mac, "netconnectionid")
index = utils_net.get_windows_nic_attribute(
session, "netconnectionid", connection_id, "index")
if os_variant == "winxp":
pnpdevice_id = utils_net.get_windows_nic_attribute(
session, "netconnectionid", connection_id, "pnpdeviceid")
cd_num = utils_misc.get_winutils_vol(session)
copy_cmd = r"xcopy %s:\devcon\wxp_x86\devcon.exe c:\ " % cd_num
session.cmd(copy_cmd)
reg_set_mtu_pattern = params.get("reg_mtu_cmd")
mtu_key_word = params.get("mtu_key", "MTU")
reg_set_mtu = reg_set_mtu_pattern % (int(index), mtu_key_word,
int(mtu))
guest_mtu_cmd = "%s " % reg_set_mtu
session.cmd(guest_mtu_cmd)
if os_type == "windows":
mode = "netsh"
if os_variant == "winxp":
connection_id = pnpdevice_id.split("&")[-1]
mode = "devcon"
utils_net.restart_windows_guest_network(session_serial,
connection_id,
mode=mode)
error_context.context("Chaning the MTU of host tap ...", logging.info)
host_mtu_cmd = "ifconfig %s mtu %s"
# Before change macvtap mtu, must set the base interface mtu
if params.get("nettype") == "macvtap":
base_if = utils_net.get_macvtap_base_iface(params.get("netdst"))
process.run(host_mtu_cmd % (base_if, mtu), shell=True)
process.run(host_mtu_cmd % (ifname, mtu), shell=True)
error_context.context("Add a temporary static ARP entry ...",
logging.info)
arp_add_cmd = "arp -s %s %s -i %s" % (guest_ip, mac, ifname)
process.run(arp_add_cmd, shell=True)
def is_mtu_ok():
status, _ = utils_test.ping(guest_ip,
1,
packetsize=max_icmp_pkt_size,
hint="do",
timeout=2)
return status == 0
def verify_mtu():
logging.info("Verify the path MTU")
status, output = utils_test.ping(guest_ip,
10,
packetsize=max_icmp_pkt_size,
hint="do",
timeout=15)
if status != 0:
logging.error(output)
test.fail("Path MTU is not as expected")
if utils_test.get_loss_ratio(output) != 0:
logging.error(output)
test.fail("Packet loss ratio during MTU "
"verification is not zero")
def flood_ping():
logging.info("Flood with large frames")
utils_test.ping(guest_ip,
packetsize=max_icmp_pkt_size,
flood=True,
timeout=float(flood_time))
def large_frame_ping(count=100):
logging.info("Large frame ping")
_, output = utils_test.ping(guest_ip,
count,
packetsize=max_icmp_pkt_size,
timeout=float(count) * 2)
ratio = utils_test.get_loss_ratio(output)
if ratio != 0:
test.fail("Loss ratio of large frame ping is %s" % ratio)
def size_increase_ping(step=random.randrange(90, 110)):
logging.info("Size increase ping")
for size in range(0, max_icmp_pkt_size + 1, step):
logging.info("Ping %s with size %s", guest_ip, size)
status, output = utils_test.ping(guest_ip,
1,
packetsize=size,
hint="do",
timeout=1)
if status != 0:
status, output = utils_test.ping(guest_ip,
10,
packetsize=size,
adaptive=True,
hint="do",
timeout=20)
fail_ratio = int(params.get("fail_ratio", 50))
if utils_test.get_loss_ratio(output) > fail_ratio:
test.fail("Ping loss ratio is greater "
"than 50% for size %s" % size)
logging.info("Waiting for the MTU to be OK")
wait_mtu_ok = 10
if not utils_misc.wait_for(is_mtu_ok, wait_mtu_ok, 0, 1):
logging.debug(
process.system_output("ifconfig -a",
verbose=False,
ignore_status=True,
shell=True))
test.error("MTU is not as expected even after %s "
"seconds" % wait_mtu_ok)
# Functional Test
error_context.context("Checking whether MTU change is ok",
logging.info)
verify_mtu()
large_frame_ping()
size_increase_ping()
# Stress test
flood_ping()
verify_mtu()
finally:
# Environment clean
if session:
session.close()
grep_cmd = "grep '%s.*%s' /proc/net/arp" % (guest_ip, ifname)
if process.system(grep_cmd, shell=True) == '0':
process.run("arp -d %s -i %s" % (guest_ip, ifname), shell=True)
logging.info("Removing the temporary ARP entry successfully")
logging.info("Change back Bridge NICs MTU to %s" % mtu_default)
for iface in target_ifaces:
process.run(host_mtu_cmd % (iface, mtu_default), shell=True)
def run(test, params, env):
"""
Test basic QinQ - 10 * 4096 with bridge backend
1) Create a private bridge
2) Boot a VM over private bridge
3) Create interfaces in guest with qinq.sh
4) Set IP on guest L1 interface and bring this interface on
5) Create 802.1ad interface on host with the private bridge
6) Start tcpdump on host
7) Do ping test
8) Check tcpdump result with vlan tag and ethertype
9) Set IP on guest L2 interface and bring this interface on
10) Create 802.1q interface on host with the 802.1ad interface
11) Start tcpdump on host
12) Do ping test
13) Check tcpdump result with vlan tag and ethertype
14) SCP file transfer between host and guest
:param test: KVM test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def copy_qinq_file(vm, guest_qinq_dir):
"""
Copy qinq file from host to guest
:param vm: guest vm
:param guest_qinq_dir: qing script dir in guest
"""
error_context.context("Copy qinq script to guest", logging.info)
host_qinq_dir = os.path.join(data_dir.get_deps_dir(),
params.get("copy_qinq_script"))
vm.copy_files_to(host_qinq_dir, guest_qinq_dir)
def check_tcpdump_result(session,
iface_name,
ethertype,
ethertype2=None,
vlan_tag=None,
vlan_tag2=None,
enable_logging=False):
"""
Check tcpdump result.
:param session: guest session
:param iface_name: the tcpdump file of the interface
:param ethertype: ethertype value need to be matched
:param ethertype2: ethertype value 2 needed to be matched if not None
:param vlan_tag: vlan tag value needed to be matched if not None
:param vlan_tag2: vlan tag value 2 needed to be matched if not None
:param enable_logging: whether to dump tcpdump results during test
"""
get_tcpdump_log_cmd = params["get_tcpdump_log_cmd"] % iface_name
tcpdump_content = session.cmd_output(get_tcpdump_log_cmd,
timeout=300).strip()
lines = tcpdump_content.splitlines()
sum = 0
for i in range(len(lines)):
if enable_logging:
logging.info("line %s: %s", i, lines[i])
if not ethertype2:
if "ICMP echo re" in lines[i] and \
ethertype in lines[i-1]:
sum += 1
if vlan_tag and vlan_tag not in lines[i - 1]:
if "too much work for irq" in lines[i - 1]:
continue
else:
test.fail(
"in %s tcpdump log, there should be vlan "
"tag %s" % (iface_name, vlan_tag))
elif not vlan_tag:
if "vlan" in lines[i - 1]:
test.fail("in %s tcpdump log, there should not be "
"vlan tag" % iface_name)
else:
if "ICMP echo re" in lines[i] and \
ethertype in lines[i-1] and \
ethertype2 in lines[i-1]:
sum += 1
if vlan_tag not in lines[i-1] or \
vlan_tag2 not in lines[i-1]:
if "too much work for irq" in lines[i - 1]:
continue
else:
test.fail(
"in %s tcpdump log, there should be vlan "
"tag %s" % (iface_name, vlan_tag))
if sum == 0:
test.fail("in %s tcpdump log, ethertype is not %s" %
(iface_name, ethertype))
def compare_host_guest_md5sum():
"""
Compare md5 value of file on host and guest
:param name: file name
"""
logging.info("Comparing md5sum on guest and host")
host_result = crypto.hash_file(host_path, algorithm="md5")
try:
output = session.cmd_output("md5sum %s" % guest_path,
120).split()[0]
guest_result = re.findall(r"\w+", output)[0]
except IndexError:
logging.error("Could not get file md5sum in guest")
return False
logging.debug("md5sum: guest(%s), host(%s)", guest_result, host_result)
return guest_result == host_result
if params["netdst"] not in utils_net.Bridge().list_br():
test.cancel("Only support Linux bridge")
login_timeout = int(params.get("login_timeout", "600"))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=login_timeout)
guest_qinq_dir = params["guest_qinq_dir"]
copy_qinq_file(vm, guest_qinq_dir)
session.close()
vm.destroy(gracefully=True)
brname = params.get("private_bridge", "tmpbr")
host_bridges = utils_net.Bridge()
if brname in host_bridges.list_br():
utils_net.Interface(brname).down()
host_bridges.del_bridge(brname)
set_ip_cmd = params["set_ip_cmd"]
logging.debug("Create private bridge %s", brname)
host_bridges.add_bridge(brname)
host_bridge_iface = utils_net.Interface(brname)
logging.debug("Bring up %s", brname)
process.system(set_ip_cmd % ("192.168.1.1", brname))
host_bridge_iface.up()
try:
login_timeout = int(params.get("login_timeout", "600"))
params['netdst'] = brname
params["start_vm"] = "yes"
params["image_snapshot"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_serial_login(timeout=login_timeout)
stop_NM_cmd = params.get("stop_NM_cmd")
session.cmd(stop_NM_cmd, ignore_all_errors=True)
mac = vm.get_mac_address()
nic_name = utils_net.get_linux_ifname(session, mac)
# Set first_nic IP in guest
ip = params["ip_vm"]
session.cmd_output(set_ip_cmd % (ip, nic_name))
# Create vlans via script qinq.sh
output = session.cmd_output("sh %sqinq.sh %s" %
(guest_qinq_dir, nic_name),
timeout=300)
logging.info("%s", output)
# Set interface v1v10 IP in guest
L1tag_iface = params["L1tag_iface"]
L1tag_iface_ip = params["L1tag_iface_ip"]
session.cmd_output(set_ip_cmd % (L1tag_iface_ip, L1tag_iface))
session.cmd("ip link set %s up" % L1tag_iface)
output = session.cmd_output("ip addr show %s" % L1tag_iface,
timeout=120)
logging.info(output)
# Start tcpdump on L1tag interface and first_nic in guest
error_context.context("Start tcpdump in %s" % params["main_vm"],
logging.info)
L1tag_tcpdump_log = params.get("tcpdump_log") % L1tag_iface
L1tag_tcpdump_cmd = params.get("tcpdump_cmd") % (L1tag_iface,
L1tag_tcpdump_log)
first_nic_tcpdump_log = params.get("tcpdump_log") % nic_name
first_nic_tcpdump_cmd = params.get("tcpdump_cmd") % (
nic_name, first_nic_tcpdump_log)
session.sendline(L1tag_tcpdump_cmd)
time.sleep(2)
session.sendline(first_nic_tcpdump_cmd)
time.sleep(5)
# Create 802.1ad vlan via bridge in host
error_context.context("Create 802.1ad vlan via bridge %s" % brname,
logging.info)
advlan_ifname = params["advlan_name"]
add_advlan_cmd = params["add_advlan_cmd"]
process.system_output(add_advlan_cmd)
advlan_iface = utils_net.Interface(advlan_ifname)
advlan_iface.set_mac(params["advlan_mac"])
process.system(set_ip_cmd % (params["advlan_ip"], advlan_ifname))
advlan_iface.up()
output = process.getoutput("ip addr show %s" % advlan_ifname)
logging.info(output)
# Ping guest from host via 802.1ad vlan interface
error_context.context(
"Start ping test from host to %s via %s" %
(L1tag_iface_ip, advlan_ifname), logging.info)
ping_count = int(params.get("ping_count"))
status, output = utils_net.ping(L1tag_iface_ip,
ping_count,
interface=advlan_ifname,
timeout=float(ping_count) * 1.5)
if status != 0:
test.fail("Ping returns non-zero value %s" % output)
package_lost = utils_test.get_loss_ratio(output)
if package_lost != 0:
test.fail("%s packeage lost when ping guest ip %s " %
(package_lost, L1tag_iface_ip))
# Stop tcpdump and check result
session.cmd_output_safe("pkill tcpdump")
check_tcpdump_result(session, L1tag_iface, "ethertype IPv4 (0x0800)")
check_tcpdump_result(session,
nic_name,
"ethertype 802.1Q-QinQ (0x88a8)",
vlan_tag="vlan 10,")
# Set IP on L2 tag on the guest interface with vid 20
L2tag_iface = params["L2tag_iface"]
L2tag_iface_ip = params["L2tag_iface_ip"]
session.cmd_output(set_ip_cmd % (L2tag_iface_ip, L2tag_iface))
session.cmd("ip link set %s up" % L2tag_iface)
output = session.cmd_output("ip addr show %s" % L2tag_iface,
timeout=120)
logging.info(output)
# Start tcpdump on L1tag and L2tag interfaces and first_nic in guest
error_context.context("Start tcpdump in %s" % params["main_vm"],
logging.info)
L2tag_tcpdump_log = params.get("tcpdump_log") % L2tag_iface
L2tag_tcpdump_cmd = params.get("tcpdump_cmd") % (L2tag_iface,
L2tag_tcpdump_log)
session.sendline(L1tag_tcpdump_cmd)
time.sleep(2)
session.sendline(L2tag_tcpdump_cmd)
time.sleep(2)
session.sendline(first_nic_tcpdump_cmd)
time.sleep(5)
# Create 802.1q vlan via 802.1ad vlan in host
error_context.context(
"Create 802.1q vlan via 802.1ad vlan %s" % advlan_ifname,
logging.info)
qvlan_ifname = params["qvlan_name"]
add_qvlan_cmd = params["add_qvlan_cmd"]
process.system_output(add_qvlan_cmd)
qvlan_iface = utils_net.Interface(qvlan_ifname)
process.system(set_ip_cmd % (params["qvlan_ip"], qvlan_ifname))
qvlan_iface.up()
output = process.getoutput("ip addr show %s" % qvlan_ifname)
logging.info(output)
# Ping guest from host via 802.1q vlan interface
error_context.context(
"Start ping test from host to %s via %s" %
(L2tag_iface_ip, qvlan_ifname), logging.info)
status, output = utils_net.ping(L2tag_iface_ip,
ping_count,
interface=qvlan_ifname,
timeout=float(ping_count) * 1.5)
if status != 0:
test.fail("Ping returns non-zero value %s" % output)
package_lost = utils_test.get_loss_ratio(output)
if package_lost >= 5:
test.fail("%s packeage lost when ping guest ip %s " %
(package_lost, L2tag_iface_ip))
# Stop tcpdump and check result
session.cmd_output_safe("pkill tcpdump")
check_tcpdump_result(session,
L1tag_iface,
"ethertype 802.1Q (0x8100)",
vlan_tag="vlan 20,")
check_tcpdump_result(session, L2tag_iface, "ethertype IPv4 (0x0800)")
check_tcpdump_result(session,
nic_name,
ethertype="ethertype 802.1Q-QinQ (0x88a8)",
ethertype2="ethertype 802.1Q",
vlan_tag="vlan 10,",
vlan_tag2="vlan 20,")
# scp file to guest with L2 vlan tag
file_size = int(params.get("file_size", "4096"))
host_path = os.path.join(test.tmpdir, "transferred_file")
guest_path = params.get("guest_path", "/var/tmp/transferred_file")
transfer_timeout = int(params.get("transfer_timeout", 1000))
cmd = "dd if=/dev/zero of=%s bs=1M count=%d" % (host_path, file_size)
error_context.context("Creating %dMB file on host" % file_size,
logging.info)
process.run(cmd)
error_context.context(
"Transferring file host -> guest, "
"timeout: %ss" % transfer_timeout, logging.info)
shell_port = int(params.get("shell_port", 22))
password = params["password"]
username = params["username"]
remote.scp_to_remote(L2tag_iface_ip, shell_port, username, password,
host_path, guest_path)
if not compare_host_guest_md5sum():
test.fail("md5sum mismatch on guest and host")
finally:
session.cmd("rm -rf %s" % guest_path)
session.close()
vm.destroy(gracefully=True)
host_bridge_iface.down()
host_bridges.del_bridge(brname)
def run(test, params, env):
"""
Test virsh iface-bridge and iface-unbridge commands.
(1) Bridge an existing network device(iface-bridge).
(2) Unbridge a network device(iface-unbridge).
"""
iface_name = params.get("iface_name")
bridge_name = params.get("bridge_name")
ping_ip = params.get("ping_ip", "")
bridge_option = params.get("bridge_option")
unbridge_option = params.get("unbridge_option")
bridge_delay = "yes" == params.get("bridge_delay", "no")
delay_num = params.get("delay_num", "0")
create_bridge = "yes" == params.get("create_bridge", "yes")
bridge_status_error = "yes" == params.get("bridge_status_error", "no")
unbridge_status_error = "yes" == params.get("unbridge_status_error", "no")
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(test.tmpdir, "iface-%s.bk" % iface_name)
if not libvirt.check_iface(iface_name, "exists", "--all"):
raise error.TestNAError("Interface '%s' not exists" % iface_name)
net_iface = utils_net.Interface(name=iface_name)
iface_is_up = net_iface.is_up()
# Make sure the interface exists
if not libvirt.check_iface(iface_name, "exists", "--all"):
raise error.TestNAError("Interface '%s' not exists" % iface_name)
# Make sure the bridge name not exists
net_bridge = utils_net.Bridge()
if bridge_name in net_bridge.list_br():
raise error.TestNAError("Bridge '%s' already exists" % bridge_name)
# Stop NetworkManager service
try:
NM = utils_misc.find_command("NetworkManager")
except ValueError:
logging.debug("No NetworkManager service.")
NM = None
NM_is_running = False
if NM is not None:
NM_service = service.Factory.create_service("NetworkManager")
NM_is_running = NM_service.status()
if NM_is_running:
NM_service.stop()
# Back up the interface script
utils.run("cp %s %s" % (iface_script, iface_script_bk))
def unbridge_check():
"""
Check the result after do unbridge.
"""
list_option = "--all"
if libvirt.check_iface(bridge_name, "exists", list_option):
raise error.TestFail("%s is still present." % bridge_name)
if "no-start" in unbridge_option:
list_option = "--inactive"
if not libvirt.check_iface(iface_name, "exists", list_option):
raise error.TestFail("%s is not present." % iface_name)
if bridge_delay:
bridge_option += " --delay %s" % delay_num
# Run test
try:
if create_bridge:
# Create bridge
result = virsh.iface_bridge(iface_name, bridge_name, bridge_option)
libvirt.check_exit_status(result, bridge_status_error)
if not bridge_status_error:
# Get the new create bridge IP address
try:
br_ip = utils_net.get_ip_address_by_interface(bridge_name)
except:
br_ip = ""
# Do ping test only bridge has IP address and ping_ip not empty
if br_ip and ping_ip:
if not libvirt.check_iface(bridge_name, "ping", ping_ip):
raise error.TestFail("Fail to ping %s from %s." %
(ping_ip, bridge_name))
else:
# Skip ping test
logging.debug("Skip ping test as %s has no IP address",
bridge_name)
list_option = ""
if "no-start" in bridge_option:
list_option = "--inactive"
if libvirt.check_iface(bridge_name, "exists", list_option):
# Unbridge
result = virsh.iface_unbridge(bridge_name, unbridge_option)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
else:
raise error.TestFail("%s is not present." % bridge_name)
else:
# Unbridge without creating bridge, only for negative test now
result = virsh.iface_unbridge(bridge_name, unbridge_option)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
finally:
if create_bridge:
if libvirt.check_iface(bridge_name, "exists", "--all"):
virsh.iface_unbridge(bridge_name)
if not os.path.exists(iface_script):
utils.run("mv %s %s" % (iface_script_bk, iface_script))
if iface_is_up:
# Need reload script
utils.run("ifup %s" % iface_name)
else:
net_iface.down()
# Clear the new create bridge if it exists
try:
utils_net.bring_down_ifname(bridge_name)
utils.run("brctl delbr %s" % bridge_name)
except utils_net.TAPBringDownError:
pass
if NM_is_running:
NM_service.start()
def run(test, params, env):
"""
Test virsh interface related commands.
(1) If using given exist interface for testing(eg. lo or ethX):
1.1 Dumpxml for the interface(with --inactive option)
1.2 Destroy the interface
1.3 Undefine the interface
(2) Define an interface from XML file
(3) List interfaces with '--inactive' option
(4) Start the interface
(5) List interfaces with no option
(6) Dumpxml for the interface
(7) Get interface MAC address by interface name
(8) Get interface name by interface MAC address
(9) Delete interface if not use the exist interface for testing
9.1 Destroy the interface
9.2 Undefine the interface
Caveat, this test may affect the host network, so using the loopback(lo)
device by default. You can specify the interface which you want, but be
careful.
"""
iface_name = params.get("iface_name", "ENTER.BRIDGE.NAME")
iface_xml = params.get("iface_xml")
iface_type = params.get("iface_type", "ethernet")
iface_pro = params.get("iface_pro", "")
iface_eth = params.get("iface_eth", "")
iface_tag = params.get("iface_tag", "0")
if iface_type == "vlan":
iface_name = iface_eth + "." + iface_tag
iface_eth_using = "yes" == params.get("iface_eth_using", "no")
ping_ip = params.get("ping_ip", "localhost")
use_exist_iface = "yes" == params.get("use_exist_iface", "no")
status_error = "yes" == params.get("status_error", "no")
net_restart = "yes" == params.get("iface_net_restart", "no")
list_dumpxml_acl = "yes" == params.get("list_dumpxml_acl", "no")
if ping_ip.count("ENTER"):
test.cancel("Please input a valid ip address")
if iface_name.count("ENTER"):
test.cancel("Please input a existing bridge/ethernet name")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user', "EXAMPLE")
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
virsh_dargs = {'debug': True}
list_dumpxml_dargs = {'debug': True}
if params.get('setup_libvirt_polkit') == 'yes':
if not list_dumpxml_acl:
virsh_dargs['uri'] = uri
virsh_dargs['unprivileged_user'] = unprivileged_user
else:
list_dumpxml_dargs['uri'] = uri
list_dumpxml_dargs['unprivileged_user'] = unprivileged_user
list_dumpxml_dargs['ignore_status'] = False
# acl api negative testing params
write_save_status_error = "yes" == params.get("write_save_status_error",
"no")
start_status_error = "yes" == params.get("start_status_error", "no")
stop_status_error = "yes" == params.get("stop_status_error", "no")
delete_status_error = "yes" == params.get("delete_status_error", "no")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
if vm:
xml_bak = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(data_dir.get_tmp_dir(),
"iface-%s.bk" % iface_name)
net_bridge = utils_net.Bridge()
if use_exist_iface:
if iface_type == "bridge":
if iface_name not in net_bridge.list_br():
test.error("Bridge '%s' not exists" % iface_name)
ifaces = net_bridge.get_structure()[iface_name]
if len(ifaces) < 1:
# In this situation, dhcp maybe cannot get ip address
# Unless you use static, we'd better skip such case
test.cancel("Bridge '%s' has no interface"
" bridged, perhaps cannot get"
" ipaddress" % iface_name)
net_iface = utils_net.Interface(name=iface_name)
iface_is_up = True
list_option = "--all"
if use_exist_iface:
if not libvirt.check_iface(iface_name, "exists", "--all"):
test.error("Interface '%s' not exists" % iface_name)
iface_xml = os.path.join(data_dir.get_tmp_dir(), "iface.xml.tmp")
iface_is_up = net_iface.is_up()
else:
# Note, if not use the interface which already exists, iface_name must
# be equal to the value specified in XML file
if libvirt.check_iface(iface_name, "exists", "--all"):
test.error("Interface '%s' already exists" % iface_name)
if not iface_xml:
test.error("XML file is needed.")
iface_xml = os.path.join(data_dir.get_tmp_dir(), iface_xml)
create_xml_file(iface_xml, params)
# Stop NetworkManager as which may conflict with virsh iface commands
try:
NM = utils_path.find_command("NetworkManager")
except utils_path.CmdNotFoundError:
logging.debug("No NetworkManager service.")
NM = None
NM_is_running = False
if NM is not None:
NM_service = service.Factory.create_service("NetworkManager")
NM_is_running = NM_service.status()
if NM_is_running:
NM_service.stop()
# run test cases
try:
if use_exist_iface:
# back up the interface script
process.run("cp %s %s" % (iface_script, iface_script_bk),
shell=True)
# step 1.1
# dumpxml for interface
if list_dumpxml_acl:
virsh.iface_list(**list_dumpxml_dargs)
xml = virsh.iface_dumpxml(iface_name,
"--inactive",
to_file=iface_xml,
**list_dumpxml_dargs)
# Step 1.2
# Destroy interface
if iface_is_up:
result = virsh.iface_destroy(iface_name, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and stop_status_error):
# acl_test negative test
libvirt.check_exit_status(result, stop_status_error)
virsh.iface_destroy(iface_name, debug=True)
else:
libvirt.check_exit_status(result, status_error)
# Step 1.3
# Undefine interface
result = virsh.iface_undefine(iface_name, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and delete_status_error):
# acl_test negative test
libvirt.check_exit_status(result, delete_status_error)
virsh.iface_undefine(iface_name, debug=True)
else:
libvirt.check_exit_status(result, status_error)
if not status_error:
if libvirt.check_iface(iface_name, "exists", list_option):
test.fail("%s is still present." % iface_name)
# Step 2
# Define interface
result = virsh.iface_define(iface_xml, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and write_save_status_error):
# acl_test negative test
libvirt.check_exit_status(result, write_save_status_error)
virsh.iface_define(iface_xml, debug=True)
elif iface_type == "bond" and not ping_ip:
libvirt.check_exit_status(result, True)
return
else:
libvirt.check_exit_status(result, status_error)
if net_restart:
network = service.Factory.create_service("network")
network.restart()
# After network restart, (ethernet)interface will be started
if (not net_restart and iface_type in ("bridge", "ethernet")) or\
(not use_exist_iface and iface_type in ("vlan", "bond")):
# Step 3
# List inactive interfaces
list_option = "--inactive"
if not status_error:
if not libvirt.check_iface(iface_name, "exists", list_option):
test.fail("Fail to find %s." % iface_name)
# Step 4
# Start interface
result = virsh.iface_start(iface_name, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and start_status_error):
# acl_test negative test
libvirt.check_exit_status(result, start_status_error)
virsh.iface_start(iface_name, debug=True)
elif (not net_restart and not use_exist_iface
and (iface_type == "ethernet" and iface_pro in ["", "dhcp"]
or iface_type == "bridge" and iface_pro == "dhcp")):
libvirt.check_exit_status(result, True)
else:
libvirt.check_exit_status(result, status_error)
if not status_error:
iface_ip = net_iface.get_ip()
ping_ip = ping_ip if not iface_ip else iface_ip
if ping_ip:
if not libvirt.check_iface(iface_name, "ping", ping_ip):
test.fail("Ping %s fail." % ping_ip)
# Step 5
# List active interfaces
if use_exist_iface or\
(iface_pro != "dhcp" and iface_type == "bridge") or\
(iface_eth_using and iface_type == "vlan"):
list_option = ""
if not status_error:
if not libvirt.check_iface(iface_name, "exists", list_option):
test.fail("Fail to find %s in active "
"interface list" % iface_name)
if vm:
if vm.is_alive():
vm.destroy()
iface_index = 0
iface_mac_list = vm_xml.VMXML.get_iface_dev(vm_name)
# Before test, detach all interfaces in guest
for mac in iface_mac_list:
iface_info = vm_xml.VMXML.get_iface_by_mac(vm_name, mac)
type = iface_info.get('type')
virsh.detach_interface(
vm_name, "--type %s --mac %s"
" --config" % (type, mac))
# After detach interface, vm.virtnet also need update, the
# easy way is free these mac addresses before start VM
vm.free_mac_address(iface_index)
iface_index += 1
virsh.attach_interface(
vm_name, "--type %s --source %s"
" --config" % (iface_type, iface_name))
vm.start()
try:
# Test if guest can be login
vm.wait_for_login()
except remote.LoginError:
test.fail("Cannot login guest with %s" % iface_name)
# Step 6
# Dumpxml for interface
if list_dumpxml_acl:
virsh.iface_list(**list_dumpxml_dargs)
xml = virsh.iface_dumpxml(iface_name,
"",
to_file="",
**list_dumpxml_dargs)
logging.debug("Interface '%s' XML:\n%s", iface_name, xml)
# Step 7
# Get interface MAC address by name
result = virsh.iface_mac(iface_name, debug=True)
libvirt.check_exit_status(result, status_error)
if not status_error and result.stdout.strip():
if not libvirt.check_iface(iface_name, "mac",
result.stdout.strip()):
test.fail("Mac address check fail")
# Step 8
# Get interface name by MAC address
# Bridge's Mac equal to bridged interface's mac
if iface_type not in ("bridge", "vlan") and result.stdout.strip():
iface_mac = net_iface.get_mac()
result = virsh.iface_name(iface_mac, debug=True)
libvirt.check_exit_status(result, status_error)
# Step 9
if not use_exist_iface:
# Step 9.0
# check if interface's state is active before destroy
if libvirt.check_iface(iface_name, "state", "--all"):
# Step 9.1
# Destroy interface
result = virsh.iface_destroy(iface_name, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and stop_status_error):
# acl_test negative test
libvirt.check_exit_status(result, stop_status_error)
virsh.iface_destroy(iface_name, debug=True)
elif (not net_restart and iface_type == "ethernet"
and iface_pro in ["", "dhcp"]
or iface_type == "bridge" and iface_pro == "dhcp"):
libvirt.check_exit_status(result, True)
else:
libvirt.check_exit_status(result, status_error)
# Step 9.2
# Undefine interface
result = virsh.iface_undefine(iface_name, **virsh_dargs)
if (params.get('setup_libvirt_polkit') == 'yes'
and delete_status_error):
# acl_test negative test
libvirt.check_exit_status(result, delete_status_error)
virsh.iface_undefine(iface_name, debug=True)
else:
libvirt.check_exit_status(result, status_error)
list_option = "--all"
if not status_error:
if libvirt.check_iface(iface_name, "exists", list_option):
test.fail("%s is still present." % iface_name)
finally:
if os.path.exists(iface_xml):
os.remove(iface_xml)
if os.path.exists(iface_script):
os.remove(iface_script)
if use_exist_iface:
if not os.path.exists(iface_script):
process.run("mv %s %s" % (iface_script_bk, iface_script),
shell=True)
if iface_is_up and\
not libvirt.check_iface(iface_name, "exists", ""):
# Need reload script
process.run("ifup %s" % iface_name, shell=True)
elif not iface_is_up and libvirt.check_iface(
iface_name, "exists", ""):
net_iface.down()
if vm:
xml_bak.sync()
else:
if libvirt.check_iface(iface_name, "exists", "--all"):
# Remove the interface
try:
utils_net.bring_down_ifname(iface_name)
except utils_net.TAPBringDownError:
pass
if iface_type == "bridge":
if iface_name in net_bridge.list_br():
try:
net_bridge.del_bridge(iface_name)
except IOError:
pass
if NM_is_running:
NM_service.start()
def run(test, params, env):
"""
Expose host MTU to guest test
1) Boot up guest with param 'host_mtu=4000' in nic part
2) Disable NetworkManager in guest
3) set mtu of guest tap (eg: tap0) and physical nic (eg: eno1) to
4000 in host
4) check the mtu in guest
5) ping from guest to external host with packet size 3972
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def get_ovs_ports(ovs):
"""
Get ovs ports
:param ovs: ovs bridge name
"""
cmd = "ovs-vsctl list-ports %s" % ovs
return process.system_output(cmd, shell=True).decode()
def is_ovs_backend(netdst):
"""
Check whether the host is OVS backend
:param netdst: netdst get from command line
"""
return netdst in process.system_output("ovs-vsctl list-br",
ignore_status=True,
shell=True).decode()
def cleanup_ovs_ports(netdst, ports):
"""
Clean up created ovs ports in this case
:param netdst: netdst get from command line
:param ports: existing ports need to be remain before this test
"""
if is_ovs_backend(netdst) is True:
ports = set(get_ovs_ports(netdst).splitlines()) - \
set(ports.splitlines())
for p in ports:
process.system("ovs-vsctl del-port %s %s" % (netdst, p))
netdst = params.get("netdst", "switch")
if netdst in utils_net.Bridge().list_br():
host_hw_interface = utils_net.Bridge().list_iface(netdst)[0]
elif is_ovs_backend(netdst) is True:
host_hw_interface = get_ovs_ports(netdst)
tmp_ports = re.findall(r"t[0-9]{1,}-[a-zA-Z0-9]{6}", host_hw_interface)
if tmp_ports:
for p in tmp_ports:
process.system_output("ovs-vsctl del-port %s %s" % (netdst, p))
host_hw_interface = get_ovs_ports(netdst)
else:
test.cancel("The host is using Macvtap backend, which is not"
" supported by now!")
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm_iface = vm.get_ifname()
# TODO, will support windows later
process.system_output(params["set_mtu_cmd"] % host_hw_interface)
process.system_output(params["set_mtu_cmd"] % vm_iface)
os_type = params.get("os_type", "linux")
login_timeout = float(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=login_timeout)
host_ip = utils_net.get_ip_address_by_interface(params["netdst"])
if os_type == "linux": # TODO, will support windows later
session.cmd_output_safe(params["nm_stop_cmd"])
guest_ifname = utils_net.get_linux_ifname(session,
vm.get_mac_address())
output = session.cmd_output_safe(params["check_guest_mtu_cmd"] %
guest_ifname)
error_context.context(output, logging.info)
match_string = "mtu %s" % params["mtu_value"]
if match_string in output:
logging.info("Host mtu %s exposed to guest as expected!" %
params["mtu_value"])
logging.info("Ping from guest to host with packet size 3972")
status, output = utils_test.ping(host_ip,
10,
packetsize=3972,
timeout=30,
session=session)
ratio = utils_test.get_loss_ratio(output)
if ratio != 0:
test.fail("Loss ratio is %s", ratio)
else:
test.fail("host mtu %s not exposed to guest" % params["mtu_value"])
cleanup_ovs_ports(netdst, host_hw_interface)
session.close()
def run(test, params, env):
"""
Test virsh iface-bridge and iface-unbridge commands.
(1) Bridge an existing network device(iface-bridge).
(2) Unbridge a network device(iface-unbridge).
"""
bridge_name = params.get("bridge_name")
ping_ip = params.get("ping_ip", "")
ping_count = int(params.get("ping_count", "3"))
ping_timeout = int(params.get("ping_timeout", "5"))
bridge_option = params.get("bridge_option")
unbridge_option = params.get("unbridge_option")
bridge_delay = "yes" == params.get("bridge_delay", "no")
delay_num = params.get("delay_num", "0")
create_bridge = "yes" == params.get("create_bridge", "yes")
bridge_status_error = "yes" == params.get("bridge_status_error", "no")
unbridge_status_error = "yes" == params.get("unbridge_status_error", "no")
iface_name = params.get("iface_name")
if iface_name == "HOST_INTERFACE":
# Get the first active nic to test
iface_name = utils_net.get_net_if(state="UP")[0]
iface_ip = utils_net.get_ip_address_by_interface(iface_name)
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(data_dir.get_tmp_dir(),
"iface-%s.bk" % iface_name)
bridge_script = NETWORK_SCRIPT + bridge_name
check_iface = "yes" == params.get("check_iface", "yes")
if check_iface:
# Make sure the interface exists
if not libvirt.check_iface(iface_name, "exists", "--all"):
test.cancel("Interface '%s' not exists" % iface_name)
# Back up the interface script
process.run("cp %s %s" % (iface_script, iface_script_bk), shell=True)
# Make sure the bridge name not exists
net_bridge = utils_net.Bridge()
if bridge_name in net_bridge.list_br():
test.cancel("Bridge '%s' already exists" % bridge_name)
# Stop NetworkManager service
NM_service = None
try:
NM = utils_path.find_command("NetworkManager")
except utils_path.CmdNotFoundError:
logging.debug("No NetworkManager service.")
NM = None
if NM is not None:
NM_service = service.Factory.create_service("NetworkManager")
NM_is_running = NM_service.status()
if NM_is_running:
logging.debug("NM_is_running:%s", NM_is_running)
logging.debug("Stop NetworkManager...")
NM_service.stop()
# Start network service
NW_service = service.Factory.create_service("network")
NW_status = NW_service.status()
if NW_status is None:
logging.debug("network service not found")
if (not utils_package.package_install('network-scripts')
or not utils_package.package_install('initscripts')):
test.cancel("Failed to install network service")
if NW_status is not True:
logging.debug("network service is not running")
logging.debug("Start network service...")
NW_service.start()
def unbridge_check():
"""
Check the result after do unbridge.
"""
list_option = "--all"
if libvirt.check_iface(bridge_name, "exists", list_option):
test.fail("%s is still present." % bridge_name)
if "no-start" in unbridge_option:
list_option = "--inactive"
if not libvirt.check_iface(iface_name, "exists", list_option):
test.fail("%s is not present." % iface_name)
if bridge_delay:
bridge_option += " --delay %s" % delay_num
# Run test
try:
if create_bridge:
# Create bridge
# Set timeout as the cmd run a long time
result = virsh.iface_bridge(iface_name,
bridge_name,
bridge_option,
timeout=240,
debug=True)
libvirt.check_exit_status(result, bridge_status_error)
if not bridge_status_error:
# Get the new create bridge IP address
try:
br_ip = utils_net.get_ip_address_by_interface(bridge_name)
except Exception:
br_ip = ""
# check IP of new bridge
if check_iface and br_ip and br_ip != iface_ip:
test.fail("bridge IP(%s) isn't the same as iface IP(%s)." %
(br_ip, iface_ip))
# check the status of STP feature
if "no-start" not in bridge_option:
if "no-stp" not in bridge_option:
if "yes" != net_bridge.get_stp_status(bridge_name):
test.fail("Fail to enable STP.")
# Do ping test only bridge has IP address and ping_ip not empty
if br_ip and ping_ip:
if not libvirt.check_iface(bridge_name,
"ping",
ping_ip,
count=ping_count,
timeout=ping_timeout):
test.fail("Fail to ping %s from %s." %
(ping_ip, bridge_name))
else:
# Skip ping test
logging.debug("Skip ping test as %s has no IP address",
bridge_name)
list_option = ""
if "no-start" in bridge_option:
list_option = "--inactive"
if libvirt.check_iface(bridge_name, "exists", list_option):
# Unbridge
result = virsh.iface_unbridge(bridge_name,
unbridge_option,
timeout=60)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
else:
test.fail("%s is not present." % bridge_name)
else:
# Unbridge without creating bridge, only for negative test now
result = virsh.iface_unbridge(bridge_name, unbridge_option)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
finally:
if create_bridge and check_iface:
if libvirt.check_iface(bridge_name, "exists", "--all"):
virsh.iface_unbridge(bridge_name, timeout=60)
if os.path.exists(iface_script_bk):
process.run("mv %s %s" % (iface_script_bk, iface_script),
shell=True)
if os.path.exists(bridge_script):
process.run("rm -rf %s" % bridge_script, shell=True)
# Clear the new create bridge if it still exists
try:
utils_net.bring_down_ifname(bridge_name)
process.run("ip link del dev %s" % bridge_name, shell=True)
except utils_net.TAPBringDownError:
pass
# Reload network configuration
NW_service.restart()
# Recover NetworkManager
if NM_is_running:
NM_service.start()
def run(test, params, env):
"""
Test virsh {at|de}tach-interface command.
1) Prepare test environment and its parameters
2) Attach the required interface
3) Perform attach and detach operation
4) Check if attached interface is correct
5) Detach the attached interface
"""
def is_attached(vmxml_devices, iface_type, iface_source, iface_mac):
"""
Check attached interface exist or not.
:param vmxml_devices: VMXMLDevices instance
:param iface_type: interface device type
:param iface_source : interface source
:param iface_mac : interface MAC address
:return: True/False if backing file and interface found
"""
ifaces = vmxml_devices.by_device_tag('interface')
for iface in ifaces:
if iface.type_name != iface_type:
continue
if iface.mac_address != iface_mac:
continue
if iface_source is not None:
if iface.xmltreefile.find('source') is not None:
if iface.source['network'] != iface_source:
continue
else:
continue
# All three conditions met
logging.debug("Find %s in given iface XML", iface_mac)
return True
logging.debug("Not find %s in given iface XML", iface_mac)
return False
def check_result(vm_name, iface_source, iface_type, iface_mac,
flags, vm_state, attach=True):
"""
Check the test result of attach/detach-device command.
"""
active_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if not attach:
utils_misc.wait_for(lambda: not is_attached(active_vmxml.devices,
iface_type, iface_source, iface_mac), 20)
active_attached = is_attached(active_vmxml.devices, iface_type,
iface_source, iface_mac)
if vm_state != "transient":
inactive_vmxml = vm_xml.VMXML.new_from_dumpxml(
vm_name, options="--inactive")
inactive_attached = is_attached(inactive_vmxml.devices,
iface_type, iface_source,
iface_mac)
if flags.count("config"):
if vm_state != "transient":
if attach:
if not inactive_attached:
raise exceptions.TestFail("Inactive domain XML not"
" updated when --config "
"options used for attachment")
else:
if inactive_attached:
raise exceptions.TestFail("Inactive domain XML not"
" updated when --config "
"options used for detachment")
if flags.count("live"):
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --live options used for"
" attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --live options used for"
" detachment")
if flags.count("current") or flags == "":
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --current options used "
"for attachment")
elif vm_state == "shutoff" and not inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated"
" when --current options used for"
" attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail("Active domain XML not updated"
" when --current options used "
"for detachment")
elif vm_state == "shutoff" and inactive_attached:
raise exceptions.TestFail("Inactive domain XML not updated "
"when --current options used for "
"detachment")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Test parameters
uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
vm_ref = params.get("at_detach_iface_vm_ref", "domname")
at_options_suffix = params.get("at_dt_iface_at_options", "")
dt_options_suffix = params.get("at_dt_iface_dt_options", "")
at_status_error = "yes" == params.get("at_status_error", "no")
dt_status_error = "yes" == params.get("dt_status_error", "no")
pre_vm_state = params.get("at_dt_iface_pre_vm_state")
# Skip if libvirt doesn't support --live/--current.
if (at_options_suffix.count("--live") or
dt_options_suffix.count("--live")):
if not libvirt_version.version_compare(1, 0, 5):
raise exceptions.TestSkipError("update-device doesn't"
" support --live")
if (at_options_suffix.count("--current") or
dt_options_suffix.count("--current")):
if not libvirt_version.version_compare(1, 0, 5):
raise exceptions.TestSkipError("virsh update-device "
"doesn't support --current")
# Interface specific attributes.
iface_type = params.get("at_detach_iface_type", "network")
if iface_type == "bridge":
try:
utils_misc.find_command("brctl")
except ValueError:
raise exceptions.TestSkipError("Command 'brctl' is missing."
" You must install it.")
iface_source = params.get("at_detach_iface_source", "default")
iface_mac = params.get("at_detach_iface_mac", "created")
virsh_dargs = {'ignore_status': True, 'uri': uri, 'debug': True}
# Check host version.
rhel6_host = False
if not process.run("grep 'Red Hat Enterprise Linux Server "
"release 6' /etc/redhat-release",
ignore_status=True, shell=True).exit_status:
rhel6_host = True
# Back up xml file.
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Get a bridge name for test if iface_type is bridge.
# If there is no bridge other than virbr0, raise TestSkipError
if iface_type == "bridge":
host_bridge = utils_net.Bridge()
bridge_list = host_bridge.list_br()
try:
bridge_list.remove("virbr0")
except AttributeError:
pass # If no virbr0, just pass is ok
logging.debug("Useful bridges:%s", bridge_list)
# just choosing one bridge on host.
if len(bridge_list):
iface_source = bridge_list[0]
else:
raise exceptions.TestSkipError("No useful bridge on host "
"other than 'virbr0'.")
# Turn VM into certain state.
if pre_vm_state == "running":
if (rhel6_host and at_options_suffix == "--config" and
dt_options_suffix == ""):
raise exceptions.TestSkipError("For bug921407, "
"won't fix on rhel6 host")
logging.info("Starting %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
elif pre_vm_state == "shutoff":
logging.info("Shuting down %s..." % vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
elif pre_vm_state == "paused":
if (rhel6_host and at_options_suffix == "--config" and
dt_options_suffix == ""):
raise exceptions.TestSkipError("For bug921407, "
"won't fix on rhel6 host")
logging.info("Pausing %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
if not vm.pause():
raise exceptions.TestSkipError("Cann't pause the domain")
elif pre_vm_state == "transient":
logging.info("Creating %s..." % vm_name)
vm.undefine()
if virsh.create(backup_xml.xml,
**virsh_dargs).exit_status:
backup_xml.define()
raise exceptions.TestSkipError("Cann't create the domain")
dom_uuid = vm.get_uuid()
dom_id = vm.get_id()
# Set attach-interface domain
if vm_ref == "domname":
vm_ref = vm_name
elif vm_ref == "domid":
vm_ref = dom_id
elif vm_ref == "domuuid":
vm_ref = dom_uuid
elif vm_ref == "hexdomid" and dom_id is not None:
vm_ref = hex(int(dom_id))
# Get a mac address if iface_mac is 'created'.
if iface_mac == "created":
iface_mac = utils_net.generate_mac_address_simple()
try:
# Set attach-interface options and
# start attach-interface test
options = set_options(iface_type, iface_source,
iface_mac, at_options_suffix,
"attach")
ret = virsh.attach_interface(vm_name, options,
**virsh_dargs)
libvirt.check_exit_status(ret, at_status_error)
# Check if the command take effect in vm
# or config file.
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
#Sleep a while for vm is stable
time.sleep(3)
if not ret.exit_status:
check_result(vm_name, iface_source,
iface_type, iface_mac,
at_options_suffix, pre_vm_state)
# Set detach-interface options
options = set_options(iface_type, None, iface_mac,
dt_options_suffix, "detach")
# Sleep for a while
time.sleep(10)
# Start detach-interface test
if pre_vm_state == "paused":
if not vm.pause():
raise exceptions.TestFail("Cann't pause the domain")
ret = virsh.detach_interface(vm_ref, options,
**virsh_dargs)
if rhel6_host and pre_vm_state in ['paused', 'running']:
if (at_options_suffix == "--config" and
dt_options_suffix == "--config"):
dt_status_error = True
libvirt.check_exit_status(ret, dt_status_error)
# Check if the command take effect
# in vm or config file.
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
#Sleep a while for vm is stable
time.sleep(10)
if not ret.exit_status:
check_result(vm_name, iface_source,
iface_type, iface_mac,
dt_options_suffix,
pre_vm_state, False)
finally:
# Restore the vm
if vm.is_alive():
vm.destroy(gracefully=False, free_mac_addresses=False)
backup_xml.sync()
def run(test, params, env):
"""
Expose host MTU to guest test
1) Boot up guest with param 'host_mtu=4000' in nic part
2) Disable NetworkManager in guest
3) set mtu of guest tap (eg: tap0) and physical nic (eg: eno1) to
4000 in host
4) check the mtu in guest
5) ping from guest to external host with packet size 3972
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def cleanup_ovs_ports(netdst, ports):
"""
Clean up created ovs ports in this case
:param netdst: netdst get from command line
:param ports: existing ports need to be remain before this test
"""
host_bridge = utils_net.find_bridge_manager(netdst)
if utils_net.ovs_br_exists(netdst) is True:
ports = set(host_bridge.list_ports(netdst)) - set(ports)
for p in ports:
utils_net.find_bridge_manager(netdst).del_port(netdst, p)
netdst = params.get("netdst", "switch")
mtu_value = params.get_numeric("mtu_value")
host_bridge = utils_net.find_bridge_manager(netdst)
localhost = LocalHost()
try:
if netdst in utils_net.Bridge().list_br():
host_hw_interface = utils_net.Bridge().list_iface(netdst)[0]
else:
host_hw_interface = host_bridge.list_ports(netdst)
tmp_ports = re.findall(r"t[0-9]{1,}-[a-zA-Z0-9]{6}",
' '.join(host_hw_interface))
if tmp_ports:
for p in tmp_ports:
host_bridge.del_port(netdst, p)
host_hw_interface = host_bridge.list_ports(netdst)
except IndexError:
host_hw_interface = netdst
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm_iface = vm.get_ifname()
# Get host interface original mtu value before setting
if netdst in utils_net.Bridge().list_br():
host_hw_iface = NetworkInterface(host_hw_interface, localhost)
elif utils_net.ovs_br_exists(netdst) is True:
host_hw_iface = NetworkInterface(' '.join(host_hw_interface),
localhost)
host_mtu_origin = host_hw_iface.get_mtu()
set_mtu_host(vm_iface, mtu_value)
host_hw_iface.set_mtu(mtu_value)
os_type = params.get("os_type", "linux")
login_timeout = float(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=login_timeout)
host_ip = utils_net.get_ip_address_by_interface(params["netdst"])
if os_type == "linux":
session.cmd_output_safe(params["nm_stop_cmd"])
guest_ifname = utils_net.get_linux_ifname(session,
vm.get_mac_address())
output = session.cmd_output_safe(params["check_linux_mtu_cmd"] %
guest_ifname)
error_context.context(output, logging.info)
match_string = "mtu %s" % params["mtu_value"]
if match_string not in output:
test.fail("host mtu %s not exposed to guest" % params["mtu_value"])
elif os_type == "windows":
connection_id = utils_net.get_windows_nic_attribute(
session, "macaddress", vm.get_mac_address(), "netconnectionid")
output = session.cmd_output_safe(params["check_win_mtu_cmd"] %
connection_id)
error_context.context(output, logging.info)
lines = output.strip().splitlines()
lines_len = len(lines)
line_table = lines[0].split(' ')
line_value = lines[2].split(' ')
while '' in line_table:
line_table.remove('')
while '' in line_value:
line_value.remove('')
index = 0
for name in line_table:
if re.findall("MTU", name):
break
index += 1
guest_mtu_value = line_value[index]
logging.info("MTU is %s", guest_mtu_value)
if not int(guest_mtu_value) == mtu_value:
test.fail("Host mtu %s is not exposed to "
"guest!" % params["mtu_value"])
logging.info("Ping from guest to host with packet size 3972")
status, output = utils_test.ping(host_ip,
10,
packetsize=3972,
timeout=30,
session=session)
ratio = utils_test.get_loss_ratio(output)
if ratio != 0:
test.fail("Loss ratio is %s", ratio)
# Restore host mtu after finish testing
set_mtu_host(vm_iface, host_mtu_origin)
host_hw_iface.set_mtu(host_mtu_origin)
if netdst not in utils_net.Bridge().list_br():
cleanup_ovs_ports(netdst, host_hw_interface)
session.close()
vm1 = env.get_vm(vm_names[0])
vm2 = None
if len(vm_names) > 1:
vm2 = env.get_vm(vm_names[1])
if eth_card_no not in utils_net.get_net_if():
raise error.TestNAError("Device %s do not exists." % eth_card_no)
try:
iface_cls = utils_net.Interface(eth_card_no)
origin_status = iface_cls.is_up()
if not origin_status:
iface_cls.up()
except error.CmdError, detail:
raise error.TestNAError(str(detail))
br_cls = utils_net.Bridge()
if eth_card_no in br_cls.list_iface():
raise error.TestNAError("%s has been used!" % eth_card_no)
vmxml1 = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[0])
if vm2:
vmxml2 = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[1])
def guest_config(vm, ip_addr):
"""
Add a new nic to guest and set a static ip address
:param vm: Configured guest
:param ip_addr: Set ip address
"""
# Attach an interface device
# Use attach-device, not attach-interface, because attach-interface
def run(test, params, env):
"""
Test virsh iface-bridge and iface-unbridge commands.
(1) Bridge an existing network device(iface-bridge).
(2) Unbridge a network device(iface-unbridge).
"""
iface_name = params.get("iface_name")
bridge_name = params.get("bridge_name")
ping_ip = params.get("ping_ip", "")
ping_count = int(params.get("ping_count", "3"))
ping_timeout = int(params.get("ping_timeout", "5"))
bridge_option = params.get("bridge_option")
unbridge_option = params.get("unbridge_option")
bridge_delay = "yes" == params.get("bridge_delay", "no")
delay_num = params.get("delay_num", "0")
create_bridge = "yes" == params.get("create_bridge", "yes")
bridge_status_error = "yes" == params.get("bridge_status_error", "no")
unbridge_status_error = "yes" == params.get("unbridge_status_error", "no")
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(data_dir.get_tmp_dir(),
"iface-%s.bk" % iface_name)
check_iface = "yes" == params.get("check_iface", "yes")
if check_iface:
# Make sure the interface exists
if not libvirt.check_iface(iface_name, "exists", "--all"):
test.cancel("Interface '%s' not exists" % iface_name)
net_iface = utils_net.Interface(name=iface_name)
iface_is_up = net_iface.is_up()
iface_ip = net_iface.get_ip()
# Back up the interface script
process.run("cp %s %s" % (iface_script, iface_script_bk), shell=True)
# Make sure the bridge name not exists
net_bridge = utils_net.Bridge()
if bridge_name in net_bridge.list_br():
test.cancel("Bridge '%s' already exists" % bridge_name)
# Stop NetworkManager service
try:
NM = utils_path.find_command("NetworkManager")
except utils_path.CmdNotFoundError:
logging.debug("No NetworkManager service.")
NM = None
NM_is_running = False
if NM is not None:
NM_service = service.Factory.create_service("NetworkManager")
NM_is_running = NM_service.status()
if NM_is_running:
NM_service.stop()
def unbridge_check():
"""
Check the result after do unbridge.
"""
list_option = "--all"
if libvirt.check_iface(bridge_name, "exists", list_option):
test.fail("%s is still present." % bridge_name)
if "no-start" in unbridge_option:
list_option = "--inactive"
if not libvirt.check_iface(iface_name, "exists", list_option):
test.fail("%s is not present." % iface_name)
if bridge_delay:
bridge_option += " --delay %s" % delay_num
# Run test
try:
if create_bridge:
# Create bridge
result = virsh.iface_bridge(iface_name, bridge_name, bridge_option)
libvirt.check_exit_status(result, bridge_status_error)
if not bridge_status_error:
# Get the new create bridge IP address
try:
br_ip = utils_net.get_ip_address_by_interface(bridge_name)
except Exception:
br_ip = ""
# check IP of new bridge
if check_iface and br_ip and br_ip != iface_ip:
test.fail("bridge IP(%s) isn't the same as iface IP(%s)." %
(br_ip, iface_ip))
# check the status of STP feature
if "no-start" not in bridge_option:
if "no-stp" not in bridge_option:
if "yes" != net_bridge.get_stp_status(bridge_name):
test.fail("Fail to enable STP.")
# Do ping test only bridge has IP address and ping_ip not empty
if br_ip and ping_ip:
if not libvirt.check_iface(bridge_name,
"ping",
ping_ip,
count=ping_count,
timeout=ping_timeout):
test.fail("Fail to ping %s from %s." %
(ping_ip, bridge_name))
else:
# Skip ping test
logging.debug("Skip ping test as %s has no IP address",
bridge_name)
list_option = ""
if "no-start" in bridge_option:
list_option = "--inactive"
if libvirt.check_iface(bridge_name, "exists", list_option):
# Unbridge
result = virsh.iface_unbridge(bridge_name, unbridge_option)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
else:
test.fail("%s is not present." % bridge_name)
else:
# Unbridge without creating bridge, only for negative test now
result = virsh.iface_unbridge(bridge_name, unbridge_option)
libvirt.check_exit_status(result, unbridge_status_error)
if not unbridge_status_error:
unbridge_check()
finally:
if create_bridge and check_iface:
if libvirt.check_iface(bridge_name, "exists", "--all"):
virsh.iface_unbridge(bridge_name)
if os.path.exists(iface_script_bk):
process.run("mv %s %s" % (iface_script_bk, iface_script),
shell=True)
if iface_is_up:
# Need reload script
process.run("ifdown %s" % iface_name, shell=True)
process.run("ifup %s" % iface_name, shell=True)
else:
net_iface.down()
# Clear the new create bridge if it exists
try:
utils_net.bring_down_ifname(bridge_name)
process.run("brctl delbr %s" % bridge_name, shell=True)
except utils_net.TAPBringDownError:
pass
if NM_is_running:
NM_service.start()