def test_networks():
"""
Start vm with VF from VF Pool with "managed=no" or default setting
1) Create VF pool
2) Prepare device xml and hot-plug to the guest
3) Detach the device from host
4) Check the driver of device
5) Start VM
6) Destroy vm then check the driver
7) Reattach the device to the host and check the driver
"""
create_vf_pool()
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
iface_dict = {
"type": "network",
"source": "{'network': '%s'}" % params.get("net_name")
}
libvirt.modify_vm_iface(vm.name, "update_iface", iface_dict)
res = virsh.start(vm.name, debug=True)
libvirt.check_exit_status(res, True)
virsh.nodedev_detach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
start_vm(vm, True, True)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.nodedev_reattach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
def set_interface(mtu_size='',
source_network='default',
iface_type='network',
iface_model='virtio',
iface_target=None):
"""
Set mtu size to a certain interface
"""
interface_type = 'bridge' if iface_type in (
'bridge', 'openvswitch') else iface_type
iface_dict = {'type': interface_type, 'model': iface_model}
if source_network:
iface_dict.update(
{'source': "{'%s': '%s'}" % (interface_type, source_network)})
if iface_type == 'openvswitch':
iface_dict.update({'virtualport_type': 'openvswitch'})
if mtu_size:
iface_dict.update({'mtu': "{'size': %s}" % mtu_size})
if iface_target:
iface_dict.update({'target': iface_target})
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_name).stdout)
def add_hostdev_iface(vm, vf_pci):
"""
Add hostdev device to VM
:param vm: VM object
:param vf_pci: PCI ID of a VF
"""
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
iface_dict = {"type": "hostdev", "managed": "yes",
"hostdev_addr": str(utils_sriov.pci_to_addr(vf_pci))}
libvirt.modify_vm_iface(vm.name, "update_iface", iface_dict)
def run(test, params, env):
"""
Negative test for virtio/virtio-non-transitional model of disk
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
status_error = params['status_error']
guest_src_url = params["guest_src_url"]
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
try:
if (params["os_variant"] == 'rhel6'
or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
try:
libvirt.set_vm_disk(vm, params)
except xcepts.LibvirtXMLError:
if status_error == 'undefinable':
return
else:
raise
else:
if status_error == 'undefinable':
test.fail("Vm is expected to fail on defining with"
" invalid model, while it succeeds")
try:
if not vm.is_alive():
vm.start()
vm.wait_for_serial_login()
except remote.LoginTimeoutError:
pass
else:
test.fail("Vm is expected to fail on booting from disk"
" with wrong model, while login successfully.")
data = vm.serial_console.get_output()
if data is None or len(data.splitlines()) < 5:
logging.warn(
"Unable to read serial console or no sufficient data in"
" serial console output to detect the kernel panic.")
else:
match = re.search('Kernel panic', data, re.S | re.M | re.I)
if not match:
test.fail("Can not find 'Kernel panic' keyword in"
" serial console output.")
finally:
backup_xml.sync()
def run(test, params, env):
"""
Negative test for virtio/virtio-non-transitional model of disk
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
status_error = params['status_error']
guest_src_url = params["guest_src_url"]
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
params["blk_source_name"] = target_path
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
try:
if (params["os_variant"] == 'rhel6' or
'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
try:
libvirt.set_vm_disk(vm, params)
except xcepts.LibvirtXMLError:
if status_error == 'undefinable':
return
else:
raise
else:
if status_error == 'undefinable':
test.fail("Vm is expected to fail on defining with"
" invalid model, while it succeeds")
try:
if not vm.is_alive():
vm.start()
vm.wait_for_serial_login()
except (remote.LoginTimeoutError, aexpect.ExpectError):
pass
else:
test.fail("Vm is expected to fail on booting from disk"
" with wrong model, while login successfully.")
finally:
backup_xml.sync()
def prepare_vmxml(vm, vm_name, direct=False):
"""
Ensure there is only 1 requested interface in the vmxml
param vm: the test vm
param vm_name: the vm'name
param direct: True or False, if True, prepare vm xml with a direct type
interface(the tap device will be named as macvtap*);
if False , prepare vm xml with a network type interface
connected to default network(the tap device will be named
as vnet* automatically instead)
:return: None
"""
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
iface_dict = prepare_iface_dict(direct)
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
def test_vf_hotplug():
"""
Hot-plug VF to VM
"""
logging.info("Preparing a running guest...")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vm.start()
vm_session = vm.wait_for_serial_login(timeout=180)
logging.info("Attaching VF to the guest...")
mac_addr = utils_net.generate_mac_address_simple()
iface_dict = eval(
params.get('iface_dict', '{"hostdev_addr": "%s"}') %
utils_sriov.pci_to_addr(vf_pci))
iface = interface.Interface("hostdev")
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", iface_dict)
virsh.attach_device(vm_name,
iface.xml,
debug=True,
ignore_status=False)
logging.info("Checking VF in the guest...")
vm_iface_types = [
iface.get_type_name() for iface in vm_xml.VMXML.new_from_dumpxml(
vm_name).devices.by_device_tag("interface")
]
if 'hostdev' not in vm_iface_types:
test.fail('Unable to get hostdev interface!')
if cmd_in_vm:
if not utils_misc.wait_for(
lambda: not vm_session.cmd_status(cmd_in_vm), 30, 10):
test.fail("Can not get the Virtual Function info on vm!")
vm_session.close()
def update_iface_xml(vmxml):
"""
Update interfaces for guest
:param vmxml: vm_xml.VMXML object
"""
vmxml.remove_all_device_by_type('interface')
vmxml.sync()
iface_dict = {"type": "network", "source": "{'network': 'host-bridge'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"persistent"}',
"alias": '{"name": "ua-backup0"}',
"inbound": '{"average":"5"}',
"outbound": '{"average":"5"}'}
iface_dict2 = {"type": "network", "source": "{'network': 'hostdev-net'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"transient", "persistent": "ua-backup0"}'}
iface = interface.Interface('network')
for ifc in (iface_dict, iface_dict2):
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", ifc)
vmxml.add_device(iface)
vmxml.sync()
def set_interface(mtu_size='', source_network='default',
iface_type='network', iface_model='virtio'):
"""
Set mtu size to a certain interface
"""
interface_type = 'bridge' if iface_type in ('bridge', 'openvswitch') else iface_type
iface_dict = {
'type': interface_type,
'source': "{'%s': '%s'}" % (interface_type, source_network),
'model': iface_model
}
if iface_type == 'openvswitch':
iface_dict.update({'virtualport_type': 'openvswitch'})
if mtu_size:
iface_dict.update({'mtu': "{'size': %s}" % mtu_size})
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_name).stdout)
def run(test, params, env):
"""
Test iface stat
"""
vm_name = params.get('main_vm')
case = params.get('case', '')
vm = env.get_vm(vm_name)
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
if case == 'compare':
host_ifname = utils_net.get_net_if(state="UP")[0]
iface_dict = {
k.replace('new_iface_', ''): v
for k, v in params.items() if k.startswith('new_iface_')
}
iface_dict['source'] = iface_dict['source'] % host_ifname
logging.debug('iface_dict is %s', iface_dict)
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
vm.start()
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface = vmxml.devices.by_device_tag("interface")[0]
iface_mac = iface.mac_address
iface_target_dev = iface.target['dev']
session = vm.wait_for_serial_login(timeout=60)
iface_in_vm = utils_net.get_linux_ifname(session, iface_mac)
session.cmd('ping www.redhat.com -4 -c 20')
host_iface_stat = get_host_iface_stat(vm_name, iface_target_dev)
vm_iface_stat = get_vm_iface_stat(session, iface_in_vm)
session.close()
if not compare_iface_stat(vm_iface_stat, host_iface_stat, bar=0.2):
test.fail('Iface stat of host and vm should be close.')
finally:
bk_xml.sync()
def update_iface_xml(vm_name, iface_dict):
"""
Update interfaces for guest
:param vm_name: The name of VM
:param iface_dict: The interface configurations params
"""
logging.debug("update iface xml")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml.remove_all_device_by_type('interface')
vmxml.sync()
iface = interface.Interface('network')
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", iface_dict)
libvirt.add_vm_device(vmxml, iface)
def create_hostdev_iface_xml(vm, mac_addr, params):
"""
Create xml of hostdev interface
:param vm: The vm object
:param mac_address: The mac address
:param params: Dictionary with the test parameters
:return: The interface xml
"""
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
hostdev_iface_dict = {
"type": "network",
"source": "{'network': '%s'}" % net_hostdev_name,
"mac": mac_addr,
"teaming": '{"type":"transient", "persistent": "ua-backup0"}'
}
return libvirt.modify_vm_iface(vm.name, "get_xml", hostdev_iface_dict,
4)
def create_bridge_iface_xml(vm, mac_addr, params):
"""
Create xml of bridge interface
:param vm: The vm object
:param mac_address: The mac address
:param params: Dictionary with the test parameters
:return: The interface xml
"""
net_bridge_name = params.get("net_bridge_name", "host-bridge")
iface_bridge_dict = {
"type": "network",
"source": "{'network': '%s'}" % net_bridge_name,
"mac": mac_addr,
"model": "virtio",
"teaming": '{"type":"persistent"}',
"alias": '{"name": "ua-backup0"}'
}
return libvirt.modify_vm_iface(vm.name, "get_xml", iface_bridge_dict)
def test_device_hotplug():
"""
Hotplug/unplug VF with managed='no'
1) Prepare a running guest
2) Check the driver of vf on host
3) Prepare a xml with "managed=no"and attach to guest
4) Detach the device from host
5) Check the driver of vf on host
6) Attach the device to guest
7) Check the interface of the guest
8) Detach the device from guest and check the driver
9) Reattach the device to the host and check the driver
"""
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
start_vm(vm)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
mac_addr = utils_net.generate_mac_address_simple()
iface_dict = eval(
params.get('iface_dict', '{"hostdev_addr": "%s"}') %
utils_sriov.pci_to_addr(vf_pci))
iface = interface.Interface("hostdev")
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", iface_dict)
res = virsh.attach_device(vm_name, iface.xml, debug=True)
libvirt.check_exit_status(res, True)
virsh.nodedev_detach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.attach_device(vm_name,
iface.xml,
debug=True,
ignore_status=False)
check_vm_iface_managed(vm_name, iface_dict)
vm.wait_for_serial_login().close()
virsh.detach_device(vm_name,
iface.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.nodedev_reattach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
def update_iface_xml(vm_name, iface_dict, virsh_instance=virsh):
"""
Update interfaces for guest
:param vm_name: The name of VM
:param iface_dict: The interface configurations params
:param virsh_instance: virsh instance object
"""
logging.debug("update iface xml")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
vmxml.remove_all_device_by_type('interface')
vm_sync(vmxml, vm_name, virsh_instance=virsh_instance)
iface = interface.Interface('network')
iface.xml = libvirt.modify_vm_iface(vm_name, "get_xml", iface_dict,
virsh_instance=virsh_instance)
vmxml.add_device(iface)
vmxml.xmltreefile.write()
vm_sync(vmxml, vm_name, virsh_instance=virsh_instance)
logging.debug("VM XML after updating interface: %s" % vmxml)
def run(test, params, env):
"""
Test interface devices update
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
network_name = params.get('network_name', 'default')
new_network_name = params.get("net_name")
expect_error = "yes" == params.get("status_error", "no")
expect_err_msg = params.get("expect_err_msg")
iface_driver = params.get("iface_driver")
iface_driver_host = params.get("iface_driver_host")
iface_driver_guest = params.get("iface_driver_guest")
iface_model = params.get("iface_model")
iface_mtu = params.get("iface_mtu")
iface_rom = params.get("iface_rom")
iface_filter = params.get("iface_filter")
iface_boot = params.get('iface_boot')
iface_coalesce = params.get('iface_coalesce')
new_iface_driver = params.get("new_iface_driver")
new_iface_driver_host = params.get("new_iface_driver_host")
new_iface_driver_guest = params.get("new_iface_driver_guest")
new_iface_model = params.get("new_iface_model")
new_iface_rom = params.get("new_iface_rom")
new_iface_inbound = params.get("new_iface_inbound")
new_iface_outbound = params.get("new_iface_outbound")
new_iface_link = params.get("new_iface_link")
new_iface_source = params.get("new_iface_source")
new_iface_target = params.get("new_iface_target")
new_iface_addr = params.get("new_iface_addr")
new_iface_filter = params.get("new_iface_filter")
new_iface_mtu = params.get("new_iface_mtu")
new_iface_type = params.get("new_iface_type")
create_new_net = "yes" == params.get("create_new_net")
new_iface_alias = params.get("new_iface_alias")
new_iface_coalesce = params.get('new_iface_coalesce')
cold_update = "yes" == params.get("cold_update", "no")
del_addr = "yes" == params.get("del_address")
del_rom = "yes" == params.get("del_rom")
del_filter = "yes" == params.get("del_filter")
check_libvirtd = "yes" == params.get("check_libvirtd")
new_iface_filter_parameters = eval(
params.get("new_iface_filter_parameters", "{}"))
rules = eval(params.get("rules", "{}"))
del_mac = "yes" == params.get("del_mac", "no")
del_coalesce = 'yes' == params.get('del_coalesce', 'no')
del_net_bandwidth = 'yes' == params.get('del_net_bandwidth', 'no')
# Backup the vm xml for recover at last
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
netxml_backup = network_xml.NetworkXML.new_from_net_dumpxml(network_name)
try:
# Prepare network
netxml = network_xml.NetworkXML.new_from_net_dumpxml(network_name)
logging.debug('Network xml before update:\n%s', netxml)
if del_net_bandwidth:
netxml.del_element('/bandwidth')
logging.debug('Network xml after update:\n%s', netxml)
# According to the different os find different file for rom
if (iface_rom and "file" in eval(iface_rom)
and "%s" in eval(iface_rom)['file']):
if rpm.RpmBackend().check_installed('ipxe-roms-qemu', '20200823'):
logging.debug("Update the file path since " "ipxe-20200823-5:")
iface_rom_new = iface_rom.replace('qemu-kvm', 'ipxe/qemu')
iface_rom = iface_rom_new
if os.path.exists(eval(iface_rom)['file'] % "pxe"):
iface_rom = iface_rom % "pxe"
elif os.path.exists(eval(iface_rom)['file'] % "efi"):
iface_rom = iface_rom % "efi"
else:
logging.error("Can not find suitable rom file")
iface_dict_bef = {}
iface_dict_aft = {}
names = locals()
# Collect need update items in 2 dicts for both start vm before and after
update_list_bef = [
"driver", 'driver_host', 'driver_guest', "model", "mtu", "rom",
"filter", 'boot', 'coalesce'
]
for update_item_bef in update_list_bef:
if names['iface_' + update_item_bef]:
iface_dict_bef.update(
{update_item_bef: names['iface_' + update_item_bef]})
update_list_aft = [
"driver", "driver_host", "driver_guest", "model", "rom", "inbound",
"outbound", "link", "source", "target", "addr", "filter", "mtu",
"type", "alias", "filter_parameters", "coalesce"
]
for update_item_aft in update_list_aft:
if names["new_iface_" + update_item_aft]:
iface_dict_aft.update(
{update_item_aft: names["new_iface_" + update_item_aft]})
logging.info("iface_dict_bef is %s, iface_dict_aft is %s",
iface_dict_bef, iface_dict_aft)
del_list = [
"del_addr", "del_rom", "del_filter", "del_mac", "del_coalesce"
]
for del_item in del_list:
if names[del_item]:
iface_dict_aft.update({del_item: names[del_item]})
# Operations before updating vm's iface xml
if iface_boot:
disk_boot = params.get('disk_book', 1)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Remove os boot config
vm_os = vmxml.os
vm_os.del_boots()
vmxml.os = vm_os
# Add boot config to disk
disk = vmxml.get_devices('disk')[0]
target_dev = disk.target.get('dev', '')
logging.debug('Will set boot order %s to device %s', disk_boot,
target_dev)
vmxml.set_boot_order_by_target_dev(target_dev, disk_boot)
vmxml.sync()
# Update vm interface with items in iface_dict_bef and start it
if iface_dict_bef:
libvirt.modify_vm_iface(vm_name, "update_iface", iface_dict_bef)
logging.info("vm xml is %s", vm.get_xml())
if not cold_update:
vm.start()
if iface_mtu:
# Do check for mtu size after start vm
target_dev = libvirt.get_interface_details(vm_name)[0]['interface']
cmd = "ip link show %s | grep 'mtu %s'" % (target_dev,
eval(iface_mtu)['size'])
def check_mtu():
"""
Check the mtu setting take effect for interface
"""
ret = process.run(cmd, ignore_status=True, shell=True)
if ret.exit_status:
test.fail("Can not find mtu setting in cmd result")
check_mtu()
utils_libvirtd.libvirtd_restart()
check_mtu()
# Create new network if need
if create_new_net:
new_net_xml = libvirt.create_net_xml(new_network_name, params)
new_net_xml.sync()
# Do update for iface_driver
logging.info('Creating new iface xml.')
new_iface_xml = libvirt.modify_vm_iface(vm_name, "get_xml",
iface_dict_aft)
bef_pid = process.getoutput("pidof -s libvirtd")
ret = virsh.update_device(vm_name,
new_iface_xml,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret, expect_error)
if check_libvirtd:
aft_pid = process.getoutput("pidof -s libvirtd")
if aft_pid != bef_pid:
test.fail("libvirtd crash after update-device!")
else:
logging.info("libvirtd do not crash after update-device!")
if expect_error:
real_err_msg = ret.stderr.strip()
if not re.search(expect_err_msg, real_err_msg, re.IGNORECASE):
test.fail("The real error msg:'%s' does not match expect one:"
'%s' % (real_err_msg, expect_err_msg))
else:
logging.info("Get expect result: %s", real_err_msg)
else:
if new_iface_inbound:
iface_bandwidth = {}
iface_bandwidth = vm_xml.VMXML.get_iftune_params(vm_name)
for bound_para in ["inbound", "outbound"]:
for tune_para in ["average", "peak", "burst"]:
get_value = iface_bandwidth.get(bound_para).get(
tune_para)
expect_value = eval(names["new_iface_" +
bound_para]).get(tune_para)
logging.info("Get value for %s:%s is %s, expect is %s",
bound_para, tune_para, get_value,
expect_value)
if get_value != expect_value:
test.fail("Get value is not equal to expect")
vmxml_aft = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_aft = list(vmxml_aft.get_iface_all().values())[0]
if new_iface_link:
iface_link_value = iface_aft.find('link').get('state')
if iface_link_value == new_iface_link:
logging.info("Find link state is %s in xml",
new_iface_link)
# Checking the statue in guest
mac_addr = iface_aft.find('mac').get('address')
state_map = "%s.*\n.*%s" % (iface_link_value.upper(),
mac_addr)
session = vm.wait_for_serial_login()
logging.info("ip link output:%s",
session.cmd_output("ip link"))
if_name = utils_net.get_net_if(runner=session.cmd_output,
state=state_map)[0]
if not check_iface_link(session, mac_addr, new_iface_link):
test.fail('iface link check inside vm failed.')
session.close()
if if_name:
logging.info("Find iface state %s for %s",
iface_link_value, mac_addr)
else:
test.fail(
"Can not find iface with mac %s and state %s" %
(mac_addr, iface_link_value))
else:
test.fail(
"Check fail to get link state, expect %s, but get %s" %
(iface_link_value, new_iface_link))
if create_new_net and new_iface_source:
iface_source_value = iface_aft.find('source').get('network')
if iface_source_value == eval(new_iface_source)['network']:
logging.info("Get %s in xml as set", iface_source_value)
else:
test.fail("Get source %s is not equal to set %s" %
(iface_source_value, new_iface_source))
if new_iface_filter:
iface_filter_value = iface_aft.find('filterref').get('filter')
if iface_filter_value == new_iface_filter:
logging.info("Get %s in xml as set", iface_filter_value)
else:
test.fail("Get filter %s is not equal to set %s" %
(iface_filter_value, new_iface_filter))
if new_iface_filter_parameters:
ebtables_outputs = process.run("ebtables -t nat -L",
shell=True).stdout_text
for rule in rules:
if rule not in ebtables_outputs:
test.fail(
"Can not find the corresponding rule after update filter with parameters!"
)
if del_filter:
# if the filter is deleted, it should not exists in the xml and the rules should be deleted as well
iface_filter_value = iface_aft.find('filterref')
if iface_filter_value is not None:
test.fail("After delete, the filter still exists: %s" %
iface_filter_value)
ebtables_outputs = process.run("ebtables -t nat -L",
shell=True).stdout_text
logging.debug("after nwfilter deleted, ebtables rules are %s" %
ebtables_outputs)
time.sleep(5)
entries_num = re.findall(r'entries:\s+(\d)', ebtables_outputs)
for i in entries_num:
if i != '0':
test.fail("After delete, the rules are still exists!")
if new_iface_alias:
iface_alias_value = iface_aft.find('alias').get('name')
if iface_alias_value == eval(new_iface_alias)['name']:
logging.info("Get %s in xml as set", iface_alias_value)
else:
test.fail("Get alias %s is not equal to set %s" %
(iface_alias_value, new_iface_alias))
if 'update_coalesce' in params['name'] or new_iface_coalesce:
iface_coalesce_val = iface_aft.find('coalesce').find(
'rx').find('frames').get('max')
if iface_coalesce_val == str(eval(new_iface_coalesce)['max']):
logging.info('coalesce update check PASS.')
else:
test.fail('coalesce value not updated.')
if del_coalesce:
if iface_aft.find('coalesce') is None:
logging.info('coalesce delete check PASS.')
else:
test.fail('coalesce not deleted.')
finally:
vmxml_backup.sync()
netxml_backup.sync()
if create_new_net:
new_net_xml.undefine()
def run(test, params, env):
"""
Test virsh nwfilter-binding-list
1)Prepare parameters
2)Run nwfilter_binding_list command
3)check result
4)Clean env
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
status_error = "yes" == params.get("status_error")
new_filter_1 = params.get("newfilter_1")
new_filter_2 = params.get("newfilter_2")
time_wait = params.get("time_wait", 10)
option = params.get("option")
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# prepare vm filterrfer parameters dict list
filter_param_list_1 = []
params_key_1 = []
filter_param_list_2 = []
params_key_2 = []
for i in params.keys():
if 'parameters_name_' in i:
params_key_1.append(i)
params_key_1.sort()
for i in range(len(params_key_1)):
params_dict = {}
params_dict['name'] = params[params_key_1[i]]
params_dict['value'] = params['parameters_value_%s' % i]
filter_param_list_1.append(params_dict)
filterref_dict_1 = {}
filterref_dict_1['name'] = new_filter_1
filterref_dict_1['parameters'] = filter_param_list_1
for i in params.keys():
if 'parameters_dhcp_' in i:
params_key_2.append(i)
params_key_2.sort()
for i in range(len(params_key_2)):
params_dict = {}
params_dict['name'] = params[params_key_2[i]]
params_dict['value'] = params['dhcp_value_%s' % i]
filter_param_list_2.append(params_dict)
filterref_dict_2 = {}
filterref_dict_2['name'] = new_filter_2
filterref_dict_2['parameters'] = filter_param_list_2
utils_package.package_install('libvirt-daemon-config-nwfilter')
def env_setting(filterref_dict_1, filterref_dict_2):
ret = virsh.attach_interface(vm_name, option)
utlv.check_exit_status(ret, status_error)
vmxml = libvirt_xml.VMXML.new_from_dumpxml(vm_name)
devices = vmxml.get_devices('interface')
iface_xml = devices[0]
logging.debug("iface_xml : %s" % iface_xml)
iface_xml_2 = devices[1]
vmxml.del_device(iface_xml)
vmxml.del_device(iface_xml_2)
new_iface_1 = interface.Interface('network')
logging.debug("new_iface_1 : %s" % new_iface_1)
new_iface_2 = interface.Interface('network')
new_iface_1.xml = iface_xml.xml
new_iface_1.type_name = "network"
logging.debug("new_iface_1 : %s" % new_iface_1)
new_iface_2.xml = iface_xml_2.xml
new_iface_1.source = {'network': "default"}
new_filterref = new_iface_1.new_filterref(**filterref_dict_1)
new_iface_1.filterref = new_filterref
new_filterref = new_iface_2.new_filterref(**filterref_dict_2)
new_iface_2.filterref = new_filterref
logging.debug("new interface xml is: %s \n %s" %
(new_iface_1, new_iface_2))
vmxml.add_device(new_iface_1)
vmxml.add_device(new_iface_2)
vmxml.sync()
return new_iface_1, new_iface_2
def attach_new_device():
newnet_iface = interface.Interface('network')
newnet_iface.source = {'network': "default"}
newnet_iface.model = 'virtio'
filterref_dict = {}
filterref_list = [{'name': "CTRL_IP_LEARNING", 'value': "dhcp"}]
filterref_dict['name'] = "clean-traffic"
filterref_dict['parameters'] = filterref_list
newnet_iface.filterref = newnet_iface.new_filterref(**filterref_dict)
ret = virsh.attach_device(domainarg=vm_name,
filearg=newnet_iface.xml,
debug=True)
utlv.check_exit_status(ret, status_error)
try:
# set env of start vm
new_iface_1, new_iface_2 = env_setting(filterref_dict_1,
filterref_dict_2)
# start vm
virsh.start(vm_name, debug=True)
# list binding port dev
logging.debug("check nwfilter binding for 2 interfaces")
ret = virsh.nwfilter_binding_list(debug=True)
utlv.check_result(ret, expected_match=[r"vnet\d+\s+clean-traffic"])
utlv.check_result(ret, expected_match=[r"vnet\d+\s+allow-dhcp-server"])
# detach a interface
option = "--type network" + " --mac " + new_iface_1.mac_address
ret = virsh.detach_interface(vm_name, option, debug=True)
time.sleep(time_wait)
utlv.check_exit_status(ret, status_error)
logging.debug("check nwfilter binding after detach one interface:")
time.sleep(3)
ret = virsh.nwfilter_binding_list(debug=True)
if re.search(r'vnet\d+\s+clean-traffic.*', ret.stdout):
test.fail(
"vnet binding clean-traffic still exists after detach the interface!"
)
utlv.check_result(ret, expected_match=[r"vnet\d+\s+allow-dhcp-server"])
# update_device to delete the filter
iface_dict = {'del_filter': True}
new_xml = utlv.modify_vm_iface(vm_name, 'get_xml', iface_dict)
virsh.update_device(domainarg=vm_name, filearg=new_xml, debug=True)
logging.debug("check nwfilter-binding after delete the only interface")
ret = virsh.nwfilter_binding_list(debug=True)
if re.search(r'vnet\d+\s+allow-dhcp-server.*', ret.stdout):
test.fail(
"vnet binding allow-dhcp-server still exists after detach the interface!"
)
utlv.check_exit_status(ret, status_error)
# attach new interface
attach_new_device()
ret = virsh.nwfilter_binding_list(debug=True)
logging.debug("Check nwfilter-binding exists after attach device")
utlv.check_result(ret, expected_match=[r"vnet\d+\s+clean-traffic"])
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_backup.sync()
def run(test, params, env):
"""
Test start domain with nwfilter rules.
1) Prepare parameters.
2) Prepare nwfilter rule and update domain interface to apply.
3) Start domain and check rule.
4) Clean env
"""
# Prepare parameters
filter_name = params.get("filter_name", "testcase")
exist_filter = params.get("exist_filter", "no-mac-spoofing")
status_error = "yes" == params.get("status_error", "no")
mount_noexec_tmp = "yes" == params.get("mount_noexec_tmp", "no")
kill_libvirtd = "yes" == params.get("kill_libvirtd", "no")
bug_url = params.get("bug_url", "")
ipset_command = params.get("ipset_command")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
username = params.get("username")
password = params.get("password")
need_vm2 = "yes" == params.get("need_vm2", "no")
add_vm_name = params.get("add_vm_name", "vm2")
vms = [vm]
dst_outside = params.get("dst_outside", "www.google.com")
ping_timeout = int(params.get("ping_timeout", "10"))
# Prepare vm filterref parameters dict list
filter_param_list = []
params_key = []
for i in params.keys():
if 'parameter_name_' in i:
params_key.append(i)
params_key.sort()
for i in range(len(params_key)):
params_dict = {}
params_dict['name'] = params[params_key[i]]
params_dict['value'] = params['parameter_value_%s' % i]
if params_dict['value'] == "MAC_of_virbr0":
virbr0_info = process.run("ip a | grep virbr0: -A1",
shell=True).stdout_text.strip()
virbr0_mac = re.search(
r'link/ether\s+(\w{2}:\w{2}:\w{2}:\w{2}:\w{2}:\w{2})',
virbr0_info, re.M | re.I).group(1)
params_dict['value'] = virbr0_mac
logging.debug("params_dict['value'] is %s " % params_dict['value'])
filter_param_list.append(params_dict)
filterref_dict = {}
filterref_dict['name'] = filter_name
filterref_dict['parameters'] = filter_param_list
params['filter_uuid'] = process.run("uuidgen",
ignore_status=True,
shell=True).stdout_text.strip()
# get all the check commands and corresponding expected results form config file and make a dictionary
cmd_list_ = params.get('check_cmd', '')
if cmd_list_:
cmd_list = cmd_list_.split(',')
expect_res = params.get('expect_match', '').split(',')
logging.debug("cmd_list is %s" % cmd_list)
logging.debug("expect_res is %s" % expect_res)
cmd_result_dict = dict(zip(cmd_list, expect_res))
logging.debug("the check dict is %s" % cmd_result_dict)
# backup vm xml
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
libvirtd = utils_libvirtd.Libvirtd("virtqemud")
device_name = None
def check_nwfilter_rules(check_cmd, expect_match):
""""check the nwfilter corresponding rule is added by iptables commands"""
ret = utils_misc.wait_for(lambda: not process.system(
check_cmd, ignore_status=True, shell=True),
timeout=30)
if not ret:
test.fail("Rum command '%s' failed" % check_cmd)
# This change anchors nwfilter_vm_start.possitive_test.new_filter.variable_notation case
# The matched destination could be ip address or hostname
if "iptables -L" in check_cmd and expect_match and 'ACCEPT' in expect_match:
# ip address that need to be replaced
replace_param = params.get("parameter_value_2")
# Get hostname by ip address.
hostname_info = None
try:
hostname_info = socket.gethostbyaddr(replace_param)
except socket.error as e:
logging.info(
"Failed to get hostname from ip address with error: %s",
str(e))
if hostname_info:
# String is used to replace ip address
replace_with = "%s|%s" % (replace_param, hostname_info[0])
expect_match = r"%s" % expect_match.replace(
replace_param, replace_with)
logging.debug("final iptables match string:%s", expect_match)
out = astring.to_text(
process.system_output(check_cmd, ignore_status=False, shell=True))
if expect_match and not re.search(expect_match, out):
test.fail("'%s' not found in output: %s" % (expect_match, out))
def clean_up_dirty_nwfilter_binding():
cmd_result = virsh.nwfilter_binding_list(debug=True)
binding_list = cmd_result.stdout_text.strip().splitlines()
binding_list = binding_list[2:]
result = []
# If binding list is not empty.
if binding_list:
for line in binding_list:
# Split on whitespace, assume 1 column
linesplit = line.split(None, 1)
result.append(linesplit[0])
logging.info("nwfilter binding list is: %s", result)
for binding_uuid in result:
try:
virsh.nwfilter_binding_delete(binding_uuid)
except Exception as e:
logging.error(
"Exception thrown while undefining nwfilter-binding: %s",
str(e))
raise
try:
# Clean up dirty nwfilter binding if there are.
clean_up_dirty_nwfilter_binding()
rule = params.get("rule")
if rule:
# Add pre-check whether nwfilter exists or not since
# utlv.create_nwfilter_xml will fail if there is no any nwfilter exists
nwfilter_list = libvirt_nwfilter.get_nwfilter_list()
if not nwfilter_list:
test.error("There is no any nwfilter existed on the host")
# Create new filter xml
filterxml = utlv.create_nwfilter_xml(params)
# Define filter xml
virsh.nwfilter_define(filterxml.xml, debug=True)
# Update first vm interface with filter
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface_xml = vmxml.get_devices('interface')[0]
vmxml.del_device(iface_xml)
new_iface = interface.Interface('network')
new_iface.xml = iface_xml.xml
new_filterref = new_iface.new_filterref(**filterref_dict)
new_iface.filterref = new_filterref
logging.debug("new interface xml is: %s" % new_iface)
vmxml.add_device(new_iface)
vmxml.sync()
if mount_noexec_tmp:
device_name = utlv.setup_or_cleanup_iscsi(is_setup=True)
utlv.mkfs(device_name, 'ext4')
cmd = "mount %s /tmp -o noexec,nosuid" % device_name
process.run(cmd, shell=True)
if ipset_command:
pkg = "ipset"
if not utils_package.package_install(pkg):
test.cancel("Can't install ipset on host")
process.run(ipset_command, shell=True)
# Run command
try:
vm.start()
if not mount_noexec_tmp:
vm.wait_for_serial_login(username=username, password=password)
vmxml = libvirt_xml.VMXML.new_from_dumpxml(vm_name)
iface_xml = vmxml.get_devices('interface')[0]
iface_target = iface_xml.target['dev']
iface_mac = iface_xml.mac_address
logging.debug("iface target dev name is %s", iface_target)
# Check iptables or ebtables on host
if need_vm2:
# Clone more vm for testing
result = virsh.dom_list('--inactive').stdout_text
if add_vm_name in result:
logging.debug("%s is already exists!" % add_vm_name)
vms.append(env.get_vm(add_vm_name))
else:
vm.destroy()
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name,
add_vm_name,
True,
timeout=360)
if ret_clone.exit_status:
test.fail("Error when clone a second vm!")
vms.append(vm.clone(add_vm_name))
vm.start()
vm2 = vms[1]
logging.debug("Now the vms is: %s", [dom.name for dom in vms])
# update the vm2 interface with the nwfilter
logging.debug("filter_params_list is %s" % filter_param_list)
iface_dict = {
"filter": filter_name,
"filter_parameters": filter_param_list,
"del_mac": True
}
if vm2.is_alive():
vm2.destroy()
utlv.modify_vm_iface(vm2.name, "update_iface", iface_dict)
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm2.name)
iface_xml = vmxml.get_devices('interface')[0]
logging.debug("iface_xml for vm2 is %s" % iface_xml)
vm2.start()
vm2_session = vm2.wait_for_serial_login()
vm2_mac = vm2.get_mac_address()
vm2_ip = utils_net.get_guest_ip_addr(vm2_session, vm2_mac)
vm.session = vm.wait_for_serial_login()
# test network functions, the 2 vms can not access to each other
gateway_ip = utils_net.get_ip_address_by_interface("virbr0")
status1, output1 = utils_net.ping(dest=vm2_ip,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
status2, output2 = utils_net.ping(dest=gateway_ip,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
status3, output3 = utils_net.ping(dest=dst_outside,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
if not status1:
test.fail(
"vm with clean-traffic-gateway ping succeed to %s %s, but it is not expected!"
% (vm2.name, vm2_ip))
if status2 or status3:
test.fail("vm ping failed! check %s \n %s" %
(output2, output3))
if cmd_list_:
loop = 0
for check_cmd_, expect_match_ in cmd_result_dict.items():
check_cmd = check_cmd_.strip()
expect_match = expect_match_.strip()
if "DEVNAME" in check_cmd:
check_cmd = check_cmd.replace("DEVNAME", iface_target)
if "VMMAC" in expect_match:
expect_match = expect_match.replace("VMMAC", iface_mac)
logging.debug(
"the check_cmd is %s, and expected result is %s" %
(check_cmd, expect_match))
check_nwfilter_rules(check_cmd, expect_match)
loop += 1
except virt_vm.VMStartError as e:
# Starting VM failed.
if not status_error:
test.fail("Test failed in positive case.\n error:"
" %s\n%s" % (e, bug_url))
if kill_libvirtd:
daemon_name = libvirtd.service_name
pid = process.run('pidof %s' % daemon_name,
shell=True).stdout_text.strip()
cmd = "kill -s TERM %s" % pid
process.run(cmd, shell=True)
ret = utils_misc.wait_for(lambda: not libvirtd.is_running(),
timeout=30)
# After libvirt 5.6.0, libvirtd is using systemd socket activation by default
if not ret and not libvirt_version.version_compare(5, 6, 0):
test.fail("Failed to kill libvirtd. %s" % bug_url)
finally:
if kill_libvirtd:
libvirtd.restart()
# Clean env
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync()
# Undefine created filter except clean-traffic as it is built-in nwfilter
if filter_name != exist_filter and filter_name != 'clean-traffic':
virsh.nwfilter_undefine(filter_name, debug=True)
if mount_noexec_tmp:
if device_name:
process.run("umount -l %s" % device_name,
ignore_status=True,
shell=True)
utlv.setup_or_cleanup_iscsi(is_setup=False)
if ipset_command:
process.run("ipset destroy blacklist", shell=True)
# Remove additional vms
if need_vm2:
result = virsh.dom_list("--all").stdout_text
if add_vm_name in result:
virsh.remove_domain(add_vm_name, "--remove-all-storage")
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):
"""
Test interface devices update
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
new_network_name = params.get("net_name")
expect_error = "yes" == params.get("status_error", "no")
expect_err_msg = params.get("expect_err_msg")
iface_driver = params.get("iface_driver")
iface_model = params.get("iface_model")
iface_mtu = params.get("iface_mtu")
iface_rom = params.get("iface_rom")
iface_filter = params.get("iface_filter")
new_iface_driver = params.get("new_iface_driver")
new_iface_driver_host = params.get("new_iface_driver_host")
new_iface_driver_guest = params.get("new_iface_driver_guest")
new_iface_model = params.get("new_iface_model")
new_iface_rom = params.get("new_iface_rom")
new_iface_inbound = params.get("new_iface_inbound")
new_iface_outbound = params.get("new_iface_outbound")
new_iface_link = params.get("new_iface_link")
new_iface_source = params.get("new_iface_source")
new_iface_target = params.get("new_iface_target")
new_iface_addr = params.get("new_iface_addr")
new_iface_filter = params.get("new_iface_filter")
new_iface_mtu = params.get("new_iface_mtu")
new_iface_type = params.get("new_iface_type")
create_new_net = "yes" == params.get("create_new_net")
new_iface_alias = params.get("new_iface_alias")
cold_update = "yes" == params.get("cold_update", "no")
del_addr = "yes" == params.get("del_address")
del_rom = "yes" == params.get("del_rom")
del_filter = "yes" == params.get("del_filter")
# Backup the vm xml for recover at last
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# According to the different os find different file for rom
if (iface_rom and "file" in eval(iface_rom)
and "%s" in eval(iface_rom)['file']):
if os.path.exists(eval(iface_rom)['file'] % "pxe"):
iface_rom = iface_rom % "pxe"
elif os.path.exists(eval(iface_rom)['file'] % "efi"):
iface_rom = iface_rom % "efi"
else:
logging.error("Can not find suitable rom file")
iface_dict_bef = {}
iface_dict_aft = {}
names = locals()
# Collect need update items in 2 dicts for both start vm before and after
update_list_bef = ["driver", "model", "mtu", "rom", "filter"]
for update_item_bef in update_list_bef:
if names['iface_' + update_item_bef]:
iface_dict_bef.update(
{update_item_bef: names['iface_' + update_item_bef]})
update_list_aft = [
"driver", "driver_host", "driver_guest", "model", "rom", "inbound",
"outbound", "link", "source", "target", "addr", "filter", "mtu",
"type", "alias"
]
for update_item_aft in update_list_aft:
if names["new_iface_" + update_item_aft]:
iface_dict_aft.update(
{update_item_aft: names["new_iface_" + update_item_aft]})
logging.info("iface_dict_bef is %s, iface_dict_aft is %s",
iface_dict_bef, iface_dict_aft)
del_list = ["del_addr", "del_rom", "del_filter"]
for del_item in del_list:
if names[del_item]:
iface_dict_aft.update({del_item: "True"})
# Update vm interface with items in iface_dict_bef and start it
if iface_dict_bef:
libvirt.modify_vm_iface(vm_name, "update_iface", iface_dict_bef)
logging.info("vm xml is %s", vm.get_xml())
if not cold_update:
vm.start()
if iface_mtu:
# Do check for mtu size after start vm
target_dev = libvirt.get_interface_details(vm_name)[0]['interface']
cmd = "ip link show %s | grep 'mtu %s'" % (target_dev,
eval(iface_mtu)['size'])
def check_mtu():
"""
Check the mtu setting take effect for interface
"""
ret = process.run(cmd, ignore_status=True, shell=True)
if ret.exit_status:
test.fail("Can not find mtu setting in cmd result")
check_mtu()
utils_libvirtd.libvirtd_restart()
check_mtu()
# Create new network if need
if create_new_net:
new_net_xml = libvirt.create_net_xml(new_network_name, params)
new_net_xml.sync()
# Do update for iface_driver
new_iface_xml = libvirt.modify_vm_iface(vm_name, "get_xml",
iface_dict_aft)
ret = virsh.update_device(vm_name,
new_iface_xml,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret, expect_error)
if expect_error:
real_err_msg = ret.stderr.strip()
if not re.search(expect_err_msg, real_err_msg, re.IGNORECASE):
test.fail("The real error msg:'%s' does not match expect one:"
'%s' % (real_err_msg, expect_err_msg))
else:
logging.info("Get expect result: %s", real_err_msg)
else:
if new_iface_inbound:
iface_bandwidth = {}
iface_bandwidth = vm_xml.VMXML.get_iftune_params(vm_name)
for bound_para in ["inbound", "outbound"]:
for tune_para in ["average", "peak", "burst"]:
get_value = iface_bandwidth.get(bound_para).get(
tune_para)
expect_value = eval(names["new_iface_" +
bound_para]).get(tune_para)
logging.info("Get value for %s:%s is %s, expect is %s",
bound_para, tune_para, get_value,
expect_value)
if get_value != expect_value:
test.fail("Get value is not equal to expect")
vmxml_aft = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_aft = list(vmxml_aft.get_iface_all().values())[0]
if new_iface_link:
iface_link_value = iface_aft.find('link').get('state')
if iface_link_value == new_iface_link:
logging.info("Find link state is %s in xml",
new_iface_link)
# Checking the statue in guest
mac_addr = iface_aft.find('mac').get('address')
state_map = "%s.*\n.*%s" % (iface_link_value.upper(),
mac_addr)
session = vm.wait_for_serial_login()
logging.info("ip link output:%s",
session.cmd_output("ip link"))
if_name = utils_net.get_net_if(runner=session.cmd_output,
state=state_map)[0]
session.close()
if if_name:
logging.info("Find iface state %s for %s",
iface_link_value, mac_addr)
else:
test.fail(
"Can not find iface with mac %s and state %s" %
(mac_addr, iface_link_value))
else:
test.fail(
"Check fail to get link state, expect %s, but get %s" %
(iface_link_value, new_iface_link))
if create_new_net and new_iface_source:
iface_source_value = iface_aft.find('source').get('network')
if iface_source_value == eval(new_iface_source)['network']:
logging.info("Get %s in xml as set", iface_source_value)
else:
test.fail("Get source %s is not equal to set %s" %
(iface_source_value, new_iface_source))
if new_iface_filter:
iface_filter_value = iface_aft.find('filterref').get('filter')
if iface_filter_value == new_iface_filter:
logging.info("Get %s in xml as set", iface_filter_value)
else:
test.fail("Get filter %s is not equal to set %s" %
(iface_filter_value, new_iface_filter))
if del_filter:
iface_filter_value = iface_aft.find('filterref')
if iface_filter_value:
logging.debug("After delete, the filter still exists: %s",
iface_filter_value)
if new_iface_alias:
iface_alias_value = iface_aft.find('alias').get('name')
if iface_alias_value == eval(new_iface_alias)['name']:
logging.info("Get %s in xml as set", iface_alias_value)
else:
test.fail("Get alias %s is not equal to set %s" %
(iface_alias_value, new_iface_alias))
finally:
vmxml_backup.sync()
if create_new_net:
new_net_xml.undefine()
def run(test, params, env):
"""
Test command: virsh domif-setlink and domif-getlink.
The command set and get link state of a virtual interface
1. Prepare test environment.
2. Perform virsh domif-setlink and domif-getlink operation.
3. Recover test environment.
4. Confirm the test result.
"""
def domif_setlink(vm, device, operation, options):
"""
Set the domain link state
:param vm : domain name
:param device : domain virtual interface
:param operation : domain virtual interface state
:param options : some options like --config
"""
return virsh.domif_setlink(vm, device, operation, options, debug=True)
def domif_getlink(vm, device, options):
"""
Get the domain link state
:param vm : domain name
:param device : domain virtual interface
:param options : some options like --config
"""
return virsh.domif_getlink(vm,
device,
options,
ignore_status=True,
debug=True)
def guest_cmd_check(cmd, session, pattern):
"""
Check cmd output with pattern in session
"""
try:
cmd_status, output = session.cmd_status_output(cmd, timeout=10)
logging.info("exit: %s, output: %s", cmd_status, output)
return re.search(pattern, output)
except (aexpect.ShellTimeoutError, aexpect.ShellStatusError) as e:
logging.debug(e)
return re.search(pattern, str(e.__str__))
def guest_if_state(if_name, session):
"""
Get the domain link state from the guest
"""
# Get link state by ethtool
cmd = "ethtool %s" % if_name
pattern = "Link detected: ([a-zA-Z]+)"
ret = guest_cmd_check(cmd, session, pattern)
if ret:
return ret.group(1) == "yes"
else:
return False
def check_update_device(vm, if_name, session):
"""
Change link state by upadte-device command, Check the results
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm.name)
# Get interface xml object
iface = vmxml.get_devices(device_type="interface")[0]
if iface.address:
del iface.address
# Change link state to up
iface.link_state = "up"
iface.xmltreefile.write()
ret = virsh.update_device(vm.name,
iface.xml,
ignore_status=True,
debug=True)
if ret.exit_status:
logging.error("Failed to update device to up state")
return False
if not utils_misc.wait_for(lambda: guest_if_state(if_name, session),
5):
logging.error("Guest link should be up now")
return False
# Change link state to down
iface.link_state = "down"
iface.xmltreefile.write()
ret = virsh.update_device(vm.name,
iface.xml,
ignore_status=True,
debug=True)
if ret.exit_status:
logging.error("Failed to update device to down state")
return False
if utils_misc.wait_for(lambda: guest_if_state(if_name, session), 5):
logging.error("Guest link should be down now")
return False
# Passed all test
return True
vm_name = []
# vm_name list:first element for original name in config
vm_name.append(params.get("main_vm", "avocado-vt-vm1"))
vm = env.get_vm(vm_name[0])
options = params.get("if_options", "--config")
start_vm = params.get("start_vm", "no")
domain = params.get("domain", "name")
if_device = params.get("if_device", "net")
if_name = params.get("if_name", "vnet0")
if_operation = params.get("if_operation", "up")
status_error = params.get("status_error", "no")
mac_address = vm.get_virsh_mac_address(0)
model_type = params.get("model_type", "virtio")
check_link_state = "yes" == params.get("check_link_state", "no")
check_link_by_update_device = "yes" == params.get("excute_update_device",
"no")
device = "vnet0"
username = params.get("username")
password = params.get("password")
post_action = params.get("post_action")
save_file = os.path.join(data_dir.get_data_dir(), "vm.save")
# Back up xml file.
vm_xml_file = os.path.join(data_dir.get_data_dir(), "vm.xml")
virsh.dumpxml(vm_name[0], extra="--inactive", to_file=vm_xml_file)
# Update model type of the interface, delete the pci address to let libvirt
# generate a new one suitable for the model
if vm.is_alive():
vm.destroy()
iface_dict = {'model': model_type, 'del_addr': 'yes'}
libvirt.modify_vm_iface(vm_name[0], "update_iface", iface_dict)
# Vm status
if start_vm == "yes" and vm.is_dead():
vm.start()
elif start_vm == "no" and vm.is_alive():
vm.destroy()
# vm_name list: second element for 'domain' in virsh command
if domain == "ID":
# Get ID for the running domain
vm_name.append(vm.get_id())
elif domain == "UUID":
# Get UUID for the domain
vm_name.append(vm.get_uuid())
elif domain == "no_match_UUID":
# Generate a random UUID
vm_name.append(uuid.uuid1())
elif domain == "no_match_name":
# Generate a random string as domain name
vm_name.append(utils_misc.generate_random_string(6))
elif domain == " ":
# Set domain name empty
vm_name.append("''")
else:
# Set domain name
vm_name.append(vm_name[0])
try:
# Test device net or mac address
if if_device == "net" and vm.is_alive():
device = if_name
# Get all vm's interface device
device = vm_xml.VMXML.get_net_dev(vm_name[0])[0]
elif if_device == "mac":
device = mac_address
# Test no exist device
if if_device == "no_exist_net":
device = "vnet-1"
elif if_device == "no_exist_mac":
# Generate random mac address for negative test
device = utils_net.VirtIface.complete_mac_address("01:02")
elif if_device == " ":
device = "''"
# Setlink opertation
result = domif_setlink(vm_name[1], device, if_operation, options)
status = result.exit_status
logging.info("Setlink done")
if post_action == "restart_libvirtd":
utils_libvirtd.libvirtd_restart()
elif post_action == "save_restore":
vm.save_to_file(save_file)
vm.restore_from_file(save_file)
# Getlink opertation
get_result = domif_getlink(vm_name[1], device, options)
getlink_output = get_result.stdout.strip()
# Check the getlink command output
if status_error == "no":
if not re.search(if_operation, getlink_output):
test.fail("Getlink result should "
"equal with setlink operation")
logging.info("Getlink done")
# Check guest xml about link status
if post_action == "save_restore":
vmxml = vm_xml.VMXML.new_from_dumpxml(vm.name)
iface = vmxml.get_devices(device_type="interface")[0]
logging.debug("Guest current interface xml is %s" % iface)
if iface.link_state != if_operation:
test.fail("link state in guest xml should be %s" %
if_operation)
# If --config or --persistent is given should restart the vm then test link status
if any(options == option
for option in ["--config", "--persistent"]) and vm.is_alive():
vm.destroy()
vm.start()
logging.info("Restart VM")
elif start_vm == "no":
vm.start()
error_msg = None
if status_error == "no" and not post_action:
# Serial login the vm to check link status
# Start vm check the link statue
session = vm.wait_for_serial_login(username=username,
password=password)
guest_if_name = utils_net.get_linux_ifname(session, mac_address)
# Check link state in guest
if check_link_state:
if (if_operation == "up"
and not guest_if_state(guest_if_name, session)):
error_msg = "Link state should be up in guest"
if (if_operation == "down"
and guest_if_state(guest_if_name, session)):
error_msg = "Link state should be down in guest"
if error_msg:
test.fail(error_msg)
# Test of setting link state by update_device command
if check_link_by_update_device:
if not check_update_device(vm, guest_if_name, session):
test.fail("Check update_device failed")
# Set the link up make host connect with vm
domif_setlink(vm_name[0], device, "up", "")
if not utils_misc.wait_for(
lambda: guest_if_state(guest_if_name, session), 5):
test.fail("Link state isn't up in guest")
# Ignore status of this one
cmd = 'ip link set %s down;' % guest_if_name
session.cmd_status_output(cmd, timeout=10)
pattern = "%s:.*state DOWN.*" % guest_if_name
pattern_cmd = 'ip addr show dev %s' % guest_if_name
guest_cmd_check(pattern_cmd, session, pattern)
cmd = 'ip link set %s up;' % guest_if_name
session.cmd_status_output(cmd, timeout=10)
pattern = "%s:.*state UP.*" % guest_if_name
if not utils_misc.wait_for(
lambda: guest_cmd_check(pattern_cmd, session, pattern),
timeout=20):
test.fail("Could not bring up interface %s inside guest" %
guest_if_name)
else: # negative test
# stop guest, so state is always consistent on next start
vm.destroy()
# Check status_error
if status_error == "yes":
if status:
logging.info("Expected error (negative testing). Output: %s",
result.stderr.strip())
else:
test.fail("Unexpected return code %d "
"(negative testing)" % status)
elif status_error != "no":
test.error("Invalid value for status_error '%s' "
"(must be 'yes' or 'no')" % status_error)
finally:
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
virsh.undefine(vm_name[0])
virsh.define(vm_xml_file)
os.remove(vm_xml_file)
if os.path.exists(save_file):
os.remove(save_file)
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of interface
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def reboot():
"""
Shutdown and restart guest, then wait for login
"""
vm.destroy()
vm.start()
return vm.wait_for_login()
def check_plug_to_pci_bridge(vm_name, mac):
"""
Check if the nic is plugged onto pcie-to-pci-bridge
:param vm_name： Vm name
:param mac: The mac address of plugged interface
:return True if plugged onto pcie-to-pci-bridge, otherwise False
"""
v_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
interface = v_xml.get_iface_all()[mac]
bus = int(eval(interface.find('address').get('bus')))
controllers = vmxml.get_controllers('pci')
for controller in controllers:
if controller.get('index') == bus:
if controller.get('model') == 'pcie-to-pci-bridge':
return True
break
return False
def detect_new_nic(mac):
"""
Detect the new interface by domiflist
:param mac: The mac address of plugged interface
:return plugged interface name
"""
def check_mac_exist():
all_infos = libvirt.get_interface_details(vm_name)
for nic_info in all_infos:
if nic_info.get('mac') == mac:
return nic_info.get('interface')
return False
plugged_nic = utils_misc.wait_for(lambda: check_mac_exist(), 5)
if not plugged_nic:
test.fail("Failed to plug device %s" % mac)
return plugged_nic
def renew_ip_address(session, mac, guest_os_type):
"""
Renew ip for plugged nic
:param session: Vm session
:param mac: The mac address of plugged interface
:param guest_os_type: Guest os type, Linux or Windows
"""
if guest_os_type == 'Windows':
utils_net.restart_windows_guest_network_by_key(
session, "macaddress", mac)
ifname = utils_net.get_linux_ifname(session, mac)
utils_net.create_network_script(ifname, mac, 'dhcp', '255.255.255.0')
utils_net.restart_guest_network(session, mac)
arp_clean = "arp -n|awk '/^[1-9]/{print \"arp -d \" $1}'|sh"
session.cmd_output_safe(arp_clean)
def get_hotplug_nic_ip(vm, nic, session, guest_os_type):
"""
Get if of the plugged interface
:param vm: Vm object
:param nic: Nic object
:param session: Vm session
:param guest_os_type: Guest os type, Linux or Windows
:return: Nic ip
"""
def __get_address():
"""
Get ip address and return it, configure a new ip if device
exists but no ip
:return: Ip address if get, otherwise None
"""
try:
index = [
_idx for _idx, _nic in enumerate(vm.virtnet) if _nic == nic
][0]
return vm.wait_for_get_address(index, timeout=90)
except IndexError:
test.error("Nic '%s' not exists in VM '%s'" %
(nic["nic_name"], vm.name))
except (virt_vm.VMIPAddressMissingError,
virt_vm.VMAddressVerificationError):
renew_ip_address(session, nic["mac"], guest_os_type)
return
# Wait for ip address is configured for the nic device
nic_ip = utils_misc.wait_for(__get_address, timeout=360)
if nic_ip:
return nic_ip
cached_ip = vm.address_cache.get(nic["mac"])
arps = process.system_output("arp -aen").decode()
logging.debug("Can't get IP address:")
logging.debug("\tCached IP: %s", cached_ip)
logging.debug("\tARP table: %s", arps)
return None
def check_nic_removed(mac, session):
"""
Get interface IP address by given MAC addrss. If try_dhclint is
True, then try to allocate IP addrss for the interface.
:param mac: The mac address of plugged interface
:param session: Vm session
"""
except_mesg = ''
try:
if guest_os_type == 'Windows':
except_mesg = "Get nic netconnectionid failed"
utils_net.restart_windows_guest_network_by_key(
session, "macaddress", mac)
else:
except_mesg = ("Failed to determine interface"
" name with mac %s" % mac)
utils_net.get_linux_ifname(session, mac)
except exceptions.TestError as e:
if except_mesg in str(e):
return True
else:
return False
def attach_nic(): # pylint: disable=W0611
"""
Attach interface, by xml or cmd, for both hot and cold plug
"""
def create_iface_xml(mac):
"""
Create interface xml file
:param mac: The mac address of nic device
"""
iface = Interface(type_name='network')
iface.source = iface_source
iface.model = iface_model
iface.mac_address = mac
logging.debug("Create new interface xml: %s", iface)
return iface
plug_method = params.get('plug_method', 'interface')
cold_plug = params.get('cold_plug', 'no')
mac = utils_net.generate_mac_address_simple()
iface_source = {'network': 'default'}
iface_model = params["virtio_model"]
options = ("network %s --model %s --mac %s" %
(iface_source['network'], iface_model, mac))
nic_params = {
'mac': mac,
'nettype': params['nettype'],
'ip_version': 'ipv4'
}
if cold_plug == "yes":
options += ' --config'
if plug_method == 'interface': # Hotplug nic vir attach-interface
ret = virsh.attach_interface(vm_name, options, ignore_status=True)
else: # Hotplug nic via attach-device
nic_xml = create_iface_xml(mac)
nic_xml.xmltreefile.write()
xml_file = nic_xml.xml
with open(xml_file) as nic_file:
logging.debug("Attach device by XML: %s", nic_file.read())
ret = virsh.attach_device(domainarg=vm_name,
filearg=xml_file,
debug=True)
libvirt.check_exit_status(ret)
if cold_plug == "yes":
reboot() # Reboot guest if it is cold plug test
detect_new_nic(mac)
if plug_method == 'interface' and cold_plug == 'no':
check_plug_to_pci_bridge(vm_name, mac)
session = vm.wait_for_login(serial=True)
# Add nic to VM object for further check
nic_name = vm.add_nic(**nic_params)["nic_name"]
nic = vm.virtnet[nic_name]
# Config ip inside guest for new added nic
if not utils_misc.wait_for(
lambda: get_hotplug_nic_ip(vm, nic, session, guest_os_type),
timeout=30):
test.fail("Does not find plugged nic %s in guest" % mac)
options = ("network %s" % mac)
if cold_plug == "yes":
options += ' --config'
# Detach nic device
if plug_method == 'interface':
ret = virsh.detach_interface(vm_name, options, ignore_status=True)
else:
with open(xml_file) as nic_file:
logging.debug("Detach device by XML: %s", nic_file.read())
ret = virsh.detach_device(domainarg=vm_name,
filearg=xml_file,
debug=True)
libvirt.check_exit_status(ret)
if cold_plug == "yes":
session = reboot() # Reboot guest if it is cold plug test
# Check if nic is removed from guest
if not utils_misc.wait_for(lambda: check_nic_removed(mac, session),
timeout=30):
test.fail("The nic %s still exist in guest after being unplugged" %
nic_name)
def save_restore(): # pylint: disable=W0611
"""
Sub test for save and restore
"""
save_path = os.path.join(data_dir.get_tmp_dir(),
'%s.save' % params['os_variant'])
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
def ping_test(restart_network=False):
"""
Basic ping test for interface
:param restart_network: True or False. Whether to restart network
:raise: test.fail if ping test fails
"""
session = vm.wait_for_login()
if restart_network:
utils_net.restart_guest_network(session)
dest = params.get('ping_dest', 'www.baidu.com')
status, output = utils_test.ping(dest, 10, session=session, timeout=20)
session.close()
if status != 0:
test.fail("Ping failed, status: %s,"
" output: %s" % (status, output))
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
guest_src_url = params.get("guest_src_url")
params['disk_model'] = params['virtio_model']
guest_os_type = params['os_type']
target_path = None
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
# Download and replace image when guest_src_url provided
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
libvirt.set_vm_disk(vm, params)
# Add pcie-to-pci-bridge when there is no one
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
cntl_add = libvirt.create_controller_xml(contr_dict)
libvirt.add_controller(vm_name, cntl_add)
try: # Update interface model as defined
iface_params = {'model': params['virtio_model']}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
if not vm.is_alive():
vm.start()
# Test if nic works well via ping
ping_test()
test_step = params.get("sub_test_step")
if test_step:
eval(test_step)()
# Test if nic still work well afeter sub steps test
ping_test(True)
finally:
vm.destroy()
backup_xml.sync()
if guest_src_url and target_path:
libvirt.delete_local_disk("file", path=target_path)
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of vsock
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
add_pcie_to_pci_bridge = params.get("add_pcie_to_pci_bridge")
guest_src_url = params.get("guest_src_url")
virtio_model = params['virtio_model']
boot_with_vsock = (params.get('boot_with_vsock', 'yes') == 'yes')
hotplug = (params.get('hotplug', 'no') == 'yes')
addr_pattern = params['addr_pattern']
device_pattern = params['device_pattern']
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
def check_vsock_inside_guest():
"""
check vsock device inside guest
"""
lspci_cmd = 'lspci'
lspci_output = session.cmd_output(lspci_cmd)
device_str = re.findall(r'%s\s%s' % (addr_pattern, device_pattern),
lspci_output)
if not device_str:
test.fail('lspci failed, no device "%s"' % device_pattern)
# Download and replace image when guest_src_url provided
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
# Add pcie-to-pci-bridge when it is required
if add_pcie_to_pci_bridge:
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
break
else:
contr_dict = {'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'}
cntl_add = libvirt.create_controller_xml(contr_dict)
libvirt.add_controller(vm_name, cntl_add)
# Generate xml for device vsock
vsock_xml = libvirt.create_vsock_xml(virtio_model)
if boot_with_vsock: # Add vsock xml to vm only when needed
libvirt.add_vm_device(vmxml, vsock_xml)
try:
if (params["os_variant"] == 'rhel6' or
'rhel6' in params.get("shortname")):
# Update interface to virtio-transitional mode for
# rhel6 guest to make it works for login
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
if hotplug:
file_arg = vsock_xml.xml
with open(file_arg) as vsock_file:
logging.debug("Attach vsock by XML: %s", vsock_file.read())
s_attach = virsh.attach_device(vm_name, file_arg, debug=True)
libvirt.check_exit_status(s_attach)
if add_pcie_to_pci_bridge:
# Check device should be plug to right bus
virtio_transitional_base.check_plug_to(vm_name, 'vsock')
session = vm.wait_for_login()
check_vsock_inside_guest()
if hotplug:
with open(file_arg) as vsock_file:
logging.debug("Detach vsock by XML: %s", vsock_file.read())
s_detach = virsh.detach_device(vm_name, file_arg, debug=True)
libvirt.check_exit_status(s_detach)
finally:
vm.destroy()
backup_xml.sync()
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of
memory balloon
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
Test steps:
1. Prepareguest domain and balloon xml use one of
virtio/virtio-non-transitional/virtio-transitional model
2. Start domain and check the device exist in guest
3. Save/Restore and check if guest works well
4. Set balloon memory and see if it works in guest
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
guest_src_url = params.get("guest_src_url")
virtio_model = params['virtio_model']
os_variant = params.get("os_variant", "")
params["disk_model"] = virtio_model
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
# Download and replace image when guest_src_url provided
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
try:
# Update disk and interface to correct model
if (os_variant == 'rhel6' or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
# The local variable "vmxml" will not be updated since set_vm_disk
# sync with another dumped xml inside the function
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Update memory balloon device to correct model
membal_dict = {
'membal_model': virtio_model,
'membal_stats_period': '10'
}
libvirt.update_memballoon_xml(vmxml, membal_dict)
if not vm.is_alive():
vm.start()
is_windows_guest = (params['os_type'] == 'Windows')
session = vm.wait_for_login()
# Check memory statistic
if libvirt_version.version_compare(6, 6, 0):
if (os_variant != 'rhel6'
or 'rhel6' not in params.get("shortname")):
rs = virsh.dommemstat(vm_name, ignore_status=True,
debug=True).stdout_text
if "available" not in rs:
test.fail("Can't get memory stats in %s model" %
virtio_model)
# Finish test for Windows guest
if is_windows_guest:
return
# Check if memory balloon device exists on guest
status = session.cmd_status_output('lspci |grep balloon')[0]
if status != 0:
test.fail("Didn't detect memory balloon device on guest.")
# Save and restore guest
sn_path = os.path.join(data_dir.get_tmp_dir(), os_variant)
session.close()
virsh.save(vm_name, sn_path)
virsh.restore(sn_path)
session = vm.wait_for_login()
# Get original memory for later balloon function check
ori_outside_mem = vm.get_max_mem()
ori_guest_mem = vm.get_current_memory_size()
# balloon half of the memory
ballooned_mem = ori_outside_mem // 2
# Set memory to test balloon function
virsh.setmem(vm_name, ballooned_mem)
# Check if memory is ballooned successfully
logging.info("Check memory status")
unusable_mem = ori_outside_mem - ori_guest_mem
gcompare_threshold = int(
params.get("guest_compare_threshold", unusable_mem))
after_mem = vm.get_current_memory_size()
act_threshold = ballooned_mem - after_mem
if (after_mem > ballooned_mem) or (abs(act_threshold) >
gcompare_threshold):
test.fail("Balloon test failed")
finally:
vm.destroy()
backup_xml.sync()
def run(test, params, env):
"""
Test interface devices update
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
new_network_name = params.get("net_name")
expect_error = "yes" == params.get("status_error", "no")
expect_err_msg = params.get("expect_err_msg")
iface_driver = params.get("iface_driver")
iface_model = params.get("iface_model")
iface_mtu = params.get("iface_mtu")
iface_rom = params.get("iface_rom")
new_iface_driver = params.get("new_iface_driver")
new_iface_driver_host = params.get("new_iface_driver_host")
new_iface_driver_guest = params.get("new_iface_driver_guest")
new_iface_model = params.get("new_iface_model")
new_iface_rom = params.get("new_iface_rom")
new_iface_inbound = params.get("new_iface_inbound")
new_iface_outbound = params.get("new_iface_outbound")
new_iface_link = params.get("new_iface_link")
new_iface_source = params.get("new_iface_source")
new_iface_target = params.get("new_iface_target")
new_iface_addr = params.get("new_iface_addr")
new_iface_filter = params.get("new_iface_filter")
new_iface_mtu = params.get("new_iface_mtu")
new_iface_type = params.get("new_iface_type")
create_new_net = "yes" == params.get("create_new_net")
new_iface_alias = params.get("new_iface_alias")
cold_update = "yes" == params.get("cold_update", "no")
del_addr = "yes" == params.get("del_address")
del_rom = "yes" == params.get("del_rom")
# Backup the vm xml for recover at last
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# According to the different os find different file for rom
if (iface_rom and "file" in eval(iface_rom)
and "%s" in eval(iface_rom)['file']):
if os.path.exists(eval(iface_rom)['file'] % "pxe"):
iface_rom = iface_rom % "pxe"
elif os.path.exists(eval(iface_rom)['file'] % "efi"):
iface_rom = iface_rom % "efi"
else:
logging.error("Can not find suitable rom file")
iface_dict_bef = {}
iface_dict_aft = {}
names = locals()
# Collect need update items in 2 dicts for both start vm before and after
update_list_bef = [
"driver", "model", "mtu", "rom"
]
for update_item_bef in update_list_bef:
if names['iface_'+update_item_bef]:
iface_dict_bef.update({update_item_bef: names['iface_'+update_item_bef]})
update_list_aft = [
"driver", "driver_host", "driver_guest", "model", "rom", "inbound",
"outbound", "link", "source", "target", "addr", "filter", "mtu", "type",
"alias"]
for update_item_aft in update_list_aft:
if names["new_iface_"+update_item_aft]:
iface_dict_aft.update({update_item_aft: names["new_iface_"+update_item_aft]})
logging.info("iface_dict_bef is %s, iface_dict_aft is %s",
iface_dict_bef, iface_dict_aft)
del_list = ["del_addr", "del_rom"]
for del_item in del_list:
if names[del_item]:
iface_dict_aft.update({del_item: "True"})
# Update vm interface with items in iface_dict_bef and start it
if iface_dict_bef:
libvirt.modify_vm_iface(vm_name, "update_iface", iface_dict_bef)
logging.info("vm xml is %s", vm.get_xml())
if not cold_update:
vm.start()
if iface_mtu:
# Do check for mtu size after start vm
target_dev = libvirt.get_interface_details(vm_name)[0]['interface']
cmd = "ip link show %s | grep 'mtu %s'" % (target_dev, eval(iface_mtu)['size'])
def check_mtu():
"""
Check the mtu setting take effect for interface
"""
ret = process.run(cmd, ignore_status=True, shell=True)
if ret.exit_status:
test.fail("Can not find mtu setting in cmd result")
check_mtu()
utils_libvirtd.libvirtd_restart()
check_mtu()
# Create new network if need
if create_new_net:
new_net_xml = libvirt.create_net_xml(new_network_name, params)
new_net_xml.sync()
# Do update for iface_driver
new_iface_xml = libvirt.modify_vm_iface(vm_name, "get_xml", iface_dict_aft)
ret = virsh.update_device(vm_name, new_iface_xml, ignore_status=True, debug=True)
libvirt.check_exit_status(ret, expect_error)
if expect_error:
real_err_msg = ret.stderr.strip()
if not re.search(expect_err_msg, real_err_msg, re.IGNORECASE):
test.fail("The real error msg:'%s' does not match expect one:"
'%s' % (real_err_msg, expect_err_msg))
else:
logging.info("Get expect result: %s", real_err_msg)
else:
if new_iface_inbound:
iface_bandwidth = {}
iface_bandwidth = vm_xml.VMXML.get_iftune_params(vm_name)
for bound_para in ["inbound", "outbound"]:
for tune_para in ["average", "peak", "burst"]:
get_value = iface_bandwidth.get(bound_para).get(tune_para)
expect_value = eval(names["new_iface_"+bound_para]).get(tune_para)
logging.info("Get value for %s:%s is %s, expect is %s",
bound_para, tune_para, get_value, expect_value)
if get_value != expect_value:
test.fail("Get value is not equal to expect")
vmxml_aft = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_aft = list(vmxml_aft.get_iface_all().values())[0]
if new_iface_link:
iface_link_value = iface_aft.find('link').get('state')
if iface_link_value == new_iface_link:
logging.info("Find link state is %s in xml", new_iface_link)
# Checking the statue in guest
mac_addr = iface_aft.find('mac').get('address')
state_map = "%s.*\n.*%s" % (iface_link_value.upper(), mac_addr)
session = vm.wait_for_serial_login()
logging.info("ip link output:%s", session.cmd_output("ip link"))
if_name = utils_net.get_net_if(runner=session.cmd_output, state=state_map)[0]
session.close()
if if_name:
logging.info("Find iface state %s for %s", iface_link_value, mac_addr)
else:
test.fail("Can not find iface with mac %s and state %s"
% (mac_addr, iface_link_value))
else:
test.fail("Check fail to get link state, expect %s, but get %s"
% (iface_link_value, new_iface_link))
if create_new_net and new_iface_source:
iface_source_value = iface_aft.find('source').get('network')
if iface_source_value == eval(new_iface_source)['network']:
logging.info("Get %s in xml as set", iface_source_value)
else:
test.fail("Get source %s is not equal to set %s"
% (iface_source_value, new_iface_source))
if new_iface_filter:
iface_filter_value = iface_aft.find('filterref').get('filter')
if iface_filter_value == new_iface_filter:
logging.info("Get %s in xml as set", iface_filter_value)
else:
test.fail("Get filter %s is not equal to set %s"
% (iface_filter_value, new_iface_filter))
if new_iface_alias:
iface_alias_value = iface_aft.find('alias').get('name')
if iface_alias_value == eval(new_iface_alias)['name']:
logging.info("Get %s in xml as set", iface_alias_value)
else:
test.fail("Get alias %s is not equal to set %s"
% (iface_alias_value, new_iface_alias))
finally:
vmxml_backup.sync()
if create_new_net:
new_net_xml.undefine()
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of rng
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def get_free_pci_slot():
"""
Get a free slot from pcie-to-pci-bridge
:return: The free slot
"""
used_slot = []
for dev in pci_devices:
address = dev.find('address')
if (address is not None and
address.get('bus') == pci_bridge_index):
used_slot.append(address.get('slot'))
for slot_index in range(1, 30):
slot = "%0#4x" % slot_index
if slot not in used_slot:
return slot
return None
def get_free_root_port():
"""
Get a free root port for rng device
:return: The bus index of free root port
"""
root_ports = set()
other_ports = set()
used_slot = set()
# Record the bus indexes for all pci controllers
for controller in pci_controllers:
if controller.get('model') == 'pcie-root-port':
root_ports.add(controller.get('index'))
else:
other_ports.add(controller.get('index'))
# Record the addresses being allocated for all pci devices
pci_devices = vmxml.xmltreefile.find('devices').getchildren()
for dev in pci_devices:
address = dev.find('address')
if address is not None:
used_slot.add(address.get('bus'))
# Find the bus address unused
for bus_index in root_ports:
bus = "%0#4x" % int(bus_index)
if bus not in used_slot:
return bus
# Add a new pcie-root-port if no free one
for index in range(1, 30):
if index not in (root_ports | other_ports):
contr_dict = {'controller_type': 'pci',
'controller_index': index,
'controller_model': 'pcie-root-port'}
cntl_add = libvirt.create_controller_xml(contr_dict)
libvirt.add_controller(vm_name, cntl_add)
return "%0#4x" % int(index)
return None
def check_plug_to(bus_type='pcie-to-pci-bridge'):
"""
Check if the nic is plugged onto pcie-to-pci-bridge
:param bus_type: The bus type been expected to plug to
:return True if plugged onto 'bus_type', otherwise False
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
rng = vmxml.xmltreefile.find('devices').find('rng')
bus = int(eval(rng.find('address').get('bus')))
controllers = vmxml.get_controllers('pci')
for controller in controllers:
if controller.get('index') == bus:
if controller.get('model') == bus_type:
return True
break
return False
def check_rng_inside_guest():
"""
check rng device inside guest
"""
check_cmd = params['check_cmd']
lspci_output = session.cmd_output(check_cmd)
session.cmd_output('pkill -9 hexdump')
if 'No such file or directory' in lspci_output and device_exists:
test.fail('Can not detect device by %s.' % check_cmd)
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
guest_src_url = params.get("guest_src_url")
virtio_model = params['virtio_model']
boot_with_rng = (params.get('boot_with_rng', 'yes') == 'yes')
hotplug = (params.get('hotplug', 'no') == 'yes')
device_exists = (params.get('device_exists', 'yes') == 'yes')
plug_to = params.get('plug_to', '')
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
# Download and update image if required
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
# Add 'pcie-to-pci-bridge' if there is no one
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
pci_bridge = controller
break
else:
contr_dict = {'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'}
pci_bridge = libvirt.create_controller_xml(contr_dict)
libvirt.add_controller(vm_name, pci_bridge)
pci_bridge_index = '%0#4x' % int(pci_bridge.get("index"))
try:
# Update nic and vm disks
if (params["os_variant"] == 'rhel6' or
'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
# vmxml will not be updated since set_vm_disk
# sync with another dumped xml inside the function
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Remove existed rng devices if there are
rng_devs = vmxml.get_devices('rng')
for rng in rng_devs:
vmxml.del_device(rng)
vmxml.xmltreefile.write()
vmxml.sync()
# General new rng xml per configurations
rng_xml = libvirt.create_rng_xml({"rng_model": virtio_model})
if params.get('specify_addr', 'no') == 'yes':
pci_devices = vmxml.xmltreefile.find('devices').getchildren()
addr = rng_xml.new_rng_address()
if plug_to == 'pcie-root-port':
bus = get_free_root_port()
addr.set_attrs({'bus': bus})
else:
slot = get_free_pci_slot()
addr.set_attrs({'bus': pci_bridge_index, 'slot': slot})
rng_xml.address = addr
if boot_with_rng: # Add to vm if required
libvirt.add_vm_device(vmxml, rng_xml)
if not vm.is_alive():
vm.start()
if hotplug: # Hotplug rng if required
file_arg = rng_xml.xml
with open(file_arg) as rng_file:
logging.debug("Attach rng by XML: %s", rng_file.read())
s_attach = virsh.attach_device(vm_name, file_arg, debug=True)
libvirt.check_exit_status(s_attach)
check_plug_to(plug_to)
session = vm.wait_for_login()
check_rng_inside_guest()
if hotplug: # Unplug rng if hotplugged previously
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
rng = vmxml.get_devices('rng')[0]
file_arg = rng.xml
with open(file_arg) as rng_file:
logging.debug("Detach rng by XML: %s", rng_file.read())
s_detach = virsh.detach_device(vm_name, file_arg, debug=True)
libvirt.check_exit_status(s_detach)
if not hotplug:
session.close()
save_path = os.path.join(
data_dir.get_tmp_dir(), '%s.save' % params['os_variant'])
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
session = vm.wait_for_login()
check_rng_inside_guest()
process.run('rm -f %s' % save_path, ignore_status=True)
finally:
vm.destroy()
backup_xml.sync()
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of disk
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def reboot():
"""
Shutdown and restart guest, then wait for login
"""
vm.destroy()
vm.start()
vm.wait_for_login()
def attach(xml, device_name, plug_method="hot"):
"""
Attach device with xml, for both hot and cold plug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for plug method
"""
device_before_plug = find_device(vm, params)
with open(xml) as disk_file:
logging.debug("Attach disk by XML: %s", disk_file.read())
file_arg = xml
if plug_method == "cold":
file_arg += ' --config'
s_attach = virsh.attach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
libvirt.check_exit_status(s_attach)
if plug_method == "cold":
reboot()
detect_time = params.get("detect_disk_time", 20)
plug_disks = utils_misc.wait_for(
lambda: get_new_device(device_before_plug, find_device(vm, params)
), detect_time)
if not plug_disks:
test.fail("Failed to hotplug device %s to guest" % device_name)
def detach(xml, device_name, unplug_method="hot"):
"""
Detach device with xml, for both hot and cold unplug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for unplug method
"""
with open(xml) as disk_file:
logging.debug("Detach device by XML: %s", disk_file.read())
file_arg = xml
if unplug_method == "cold":
file_arg = xml + ' --config'
s_detach = virsh.detach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
if unplug_method == "cold":
reboot()
libvirt.check_exit_status(s_detach)
def attach_disk(): # pylint: disable=W0611
"""
Sub test for attach disk, including hot and cold plug/unplug
"""
plug_method = params.get("plug_method", "hot")
device_source_format = params.get("at_disk_source_format", "raw")
device_target = params.get("at_disk_target", "vdb")
device_disk_bus = params.get("at_disk_bus", "virtio")
device_source_name = params.get("at_disk_source", "attach.img")
detect_time = params.get("detect_disk_time", 10)
device_source_path = os.path.join(tmp_dir, device_source_name)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1",
disk_format=device_source_format)
def _generate_disk_xml():
"""Generate xml for device hotplug/unplug usage"""
diskxml = devices.disk.Disk("file")
diskxml.device = "disk"
source_params = {"attrs": {'file': device_source}}
diskxml.source = diskxml.new_disk_source(**source_params)
diskxml.target = {'dev': device_target, 'bus': device_disk_bus}
if params.get("disk_model"):
diskxml.model = params.get("disk_model")
if pci_bridge_index and device_disk_bus == 'virtio':
addr = diskxml.new_disk_address('pci')
addr.set_attrs({'bus': pci_bridge_index, 'slot': slot})
diskxml.address = addr
return diskxml.xml
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
slot = get_free_slot(pci_bridge_index, v_xml)
disk_xml = _generate_disk_xml()
attach(disk_xml, device_target, plug_method)
if plug_method == "cold":
disk_xml = _generate_disk_xml()
detach(disk_xml, device_target, plug_method)
if not utils_misc.wait_for(
lambda: not libvirt.device_exists(vm, device_target),
detect_time):
test.fail("Detach disk failed.")
def attach_controller(): # pylint: disable=W0611
"""
Sub test for attach controller
"""
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
contr_index = len(v_xml.get_controllers('scsi'))
contr_type = params.get("controller_type", 'scsi')
contr_model = params.get("controller_model", "virtio-scsi")
contr_dict = {
'controller_type': contr_type,
'controller_model': contr_model,
'controller_index': contr_index
}
if pci_bridge_index:
slot = get_free_slot(pci_bridge_index, v_xml)
addr = '{"bus": %s, "slot": %s}' % (pci_bridge_index, slot)
contr_dict.update({'controller_addr': addr})
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
attach(xml, params['controller_model'])
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
detach(xml, params['controller_model'])
def snapshot(): # pylint: disable=W0611
"""
Sub test for snapshot
"""
for i in range(1, 4):
ret = virsh.snapshot_create_as(vm_name, "sn%s --disk-only" % i)
libvirt.check_exit_status(ret)
process.system("systemctl restart libvirtd")
save_path = os.path.join(tmp_dir, "test.save")
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
session = vm.wait_for_login()
session.close()
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
add_pcie_to_pci_bridge = params.get("add_pcie_to_pci_bridge")
pci_bridge_index = None
tmp_dir = data_dir.get_tmp_dir()
guest_src_url = params.get("guest_src_url")
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
if guest_src_url:
def _download():
download_cmd = ("wget %s -O %s" % (guest_src_url, target_path))
if process.system(download_cmd, shell=True):
test.error("Failed to download file")
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
if utils_package.package_install("wget"):
utils_misc.wait_for(_download, timeout=360)
else:
test.error("Fail to install wget")
params["blk_source_name"] = target_path
if add_pcie_to_pci_bridge:
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
pci_bridge = controller
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
pci_bridge = libvirt.create_controller_xml(contr_dict,
"add_controller",
vm_name)
pci_bridge_index = '%0#4x' % int(pci_bridge.get("index"))
try:
if (params["os_variant"] == 'rhel6'
or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
if pci_bridge_index:
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if params.get("disk_target_bus") == "scsi":
scsi_controllers = v_xml.get_controllers('scsi')
for index, controller in enumerate(scsi_controllers):
controller.find('address').set('bus', pci_bridge_index)
controller.find('address').set(
'slot', get_free_slot(pci_bridge_index, v_xml))
else:
disks = v_xml.get_devices(device_type="disk")
for index, disk in enumerate(disks):
args = {
'bus': pci_bridge_index,
'slot': get_free_slot(pci_bridge_index, v_xml)
}
libvirt.set_disk_attr(v_xml, disk.target['dev'], 'address',
args)
v_xml.xmltreefile.write()
v_xml.sync()
if not vm.is_alive():
vm.start()
vm.wait_for_login()
test_step = params.get("sub_test_step")
if test_step:
eval(test_step)()
finally:
vm.destroy()
libvirt.clean_up_snapshots(vm_name)
backup_xml.sync()
def run(test, params, env):
"""
Test bridge support from network
1) create a linux bridge and connect a physical interface to it
2) define nwfilter with "vdsm-no-mac-spoofing"
3) redefine the vm with the new create bridge and filter
4) check if guest can get public ip after vm start
5) check if guest and host can ping each other
6) check if guest and host can ping outside
7) start another vm connected to the same bridge
8) check if the 2 guests can ping each other
"""
def create_bridge(br_name, iface_name):
"""
Create a linux bridge by virsh cmd:
1. Stop NetworkManager and Start network service
2. virsh iface-bridge <iface> <name> [--no-stp]
:param br_name: bridge name
:param iface_name: physical interface name
:return: bridge created or raise exception
"""
# Make sure the bridge not exist
if libvirt.check_iface(br_name, "exists", "--all"):
test.cancel("The bridge %s already exist" % br_name)
# Create bridge
utils_package.package_install('tmux')
cmd = 'tmux -c "ip link add name {0} type bridge; ip link set {1} up;' \
' ip link set {1} master {0}; ip link set {0} up;' \
' pkill dhclient; sleep 6; dhclient {0}; ifconfig {1} 0"'.format(br_name, iface_name)
process.run(cmd, shell=True, verbose=True)
def create_bridge_network(br_name, net_name):
"""
Define and start the bridge type network
"""
# check if network with the same name already exists
output_all = virsh.net_list("--all").stdout.strip()
if re.search(net_name, output_all):
test.cancel("Network with the same name already exists!")
test_xml = network_xml.NetworkXML(network_name="%s" % net_name)
test_xml.forward = {"mode": "bridge"}
test_xml.bridge = {"name": br_name}
test_xml.create()
def define_nwfilter(filter_name):
"""
Define nwfilter vdsm-no-mac-spoofing with content like:
<filter name='vdsm-no-mac-spoofing' chain='root'>
<filterref filter='no-mac-spoofing'/>
<filterref filter='no-arp-mac-spoofing'/>
</filter>
:param filter_name: the name of nwfilter
:return: filter created or raise exception
"""
filter_uuid = params.get("filter_uuid",
"11111111-b071-6127-b4ec-111111111111")
filter_params = {
"filter_name": "vdsm-no-mac-spoofing",
"filter_chain": "root",
"filter_uuid": filter_uuid,
"filterref_name_1": "no-mac-spoofing",
"filterref_name_2": "no-arp-mac-spoofing"
}
filter_xml = libvirt.create_nwfilter_xml(filter_params).xml
# Run command
result = virsh.nwfilter_define(filter_xml,
ignore_status=True,
debug=True)
if result.exit_status:
test.fail("Failed to define nwfilter with %s" % filter_xml)
def ping(src_ip, dest_ip, ping_count, timeout, session=None):
"""
Wrap of ping
:param src_ip: source address
:param dest_ip: destination address
:param ping_count: count of icmp packet
:param timeout: timeout for the ping command
:param session: local execution or session to execute the ping command
:return: ping succeed or raise exception
"""
status, output = utils_net.ping(dest=dest_ip,
count=ping_count,
interface=src_ip,
timeout=timeout,
session=session,
force_ipv4=True)
if status:
test.fail("Fail to ping %s from %s" % (dest_ip, src_ip))
def check_net_functions(guest_ip, ping_count, ping_timeout, guest_session,
host_ip, remote_url, endpoint_ip):
# make sure host network works well
# host ping remote url
ping(host_ip, remote_url, ping_count, ping_timeout)
# host ping guest
ping(host_ip, guest_ip, ping_count, ping_timeout)
# guest ping host
ping(guest_ip,
host_ip,
ping_count,
ping_timeout,
session=guest_session)
# guest ping remote url
ping(guest_ip,
remote_url,
ping_count,
ping_timeout,
session=guest_session)
# guest ping endpoint
ping(guest_ip,
endpoint_ip,
ping_count,
ping_timeout,
session=guest_session)
# Get test params
bridge_name = params.get("bridge_name", "test_br0")
filter_name = params.get("filter_name", "vdsm-no-mac-spoofing")
ping_count = params.get("ping_count", "5")
ping_timeout = float(params.get("ping_timeout", "10"))
iface_name = utils_net.get_net_if(state="UP")[0]
bridge_script = NETWORK_SCRIPT + bridge_name
iface_script = NETWORK_SCRIPT + iface_name
iface_script_bk = os.path.join(data_dir.get_tmp_dir(),
"iface-%s.bk" % iface_name)
attach_interface = "yes" == params.get("attach_interface", "no")
iface_model = params.get("iface_model", "virtio")
iface_source = eval(params.get("iface_source", "{'bridge':'test_br0'}"))
iface_type = params.get("iface_type", None)
iface_target = params.get("iface_target", "br_target")
iface_alias = params.get("iface_alias", None)
hotplug = "yes" == params.get("hotplug", "no")
iface_driver = params.get("iface_driver", None)
start_vm2 = "yes" == params.get("start_vm2", "no")
create_network = "yes" == params.get("create_network", "no")
update_device = "yes" == params.get("update_with_diff_type", "no")
vms = params.get("vms").split()
if len(vms) <= 1:
test.cancel("Need two VMs to test")
else:
vm1_name = vms[0]
vm2_name = vms[1]
vm1 = env.get_vm(vm1_name)
vm2 = env.get_vm(vm2_name)
# Back up the interface script
process.run("cp %s %s" % (iface_script, iface_script_bk),
shell=True,
verbose=True)
# Back up vm xml
vm1_xml_bak = vm_xml.VMXML.new_from_dumpxml(vm1_name)
vm2_xml_bak = vm_xml.VMXML.new_from_dumpxml(vm2_name)
# Stop NetworkManager service
NM_service = service.Factory.create_service("NetworkManager")
NM_status = NM_service.status()
if not NM_status:
NM_service.start()
mac = utils_net.generate_mac_address_simple()
try:
create_bridge(bridge_name, iface_name)
define_nwfilter(filter_name)
if hotplug:
err_msgs = ("No more available PCI slots",
"No more available PCI addresses")
# delete the original interface on the vm before hot-plug
if vm1.is_alive():
vm1.destroy()
vmxml = vm_xml.VMXML.new_from_dumpxml(vm1_name)
iface_xml = vmxml.get_devices('interface')[0]
logging.debug("Delete the original interface")
vmxml.del_device(iface_xml)
vmxml.sync()
vm1.start()
# do hot-plug
if attach_interface:
logging.info("Try to hot-plug interface")
options = (
"%s %s --model %s --mac %s" %
(iface_type, iface_source['bridge'], iface_model, mac))
ret = virsh.attach_interface(vm1_name,
options,
ignore_status=True)
else:
logging.info("Try to hot-plug device")
if create_network:
create_bridge_network(bridge_name, iface_source["network"])
target = str({'dev': iface_target})
iface_alias = str({'name': iface_alias})
vm_iface_source = str(iface_source)
iface_params = {
"type": iface_type,
"source": vm_iface_source,
"filter": filter_name,
"mac": mac,
'alias': iface_alias,
'target': target,
'model': iface_model,
'driver': iface_driver
}
attach_xml = interface.Interface(iface_params['type'])
attach_xml.xml = libvirt.modify_vm_iface(
vm1_name, 'get_xml', iface_params)
ret = virsh.attach_device(vm1_name,
attach_xml.xml,
ignore_status=True,
debug=True)
if ret.exit_status:
if any([msg in ret.stderr for msg in err_msgs]):
test.error("No more pci slots, can't attach more devices")
else:
test.fail("Failed to attach-interface: %s" %
ret.stderr.strip())
else:
logging.debug("Hot-plug interface or device pass")
if update_device:
# As the interface type will change to actual type "bridge" in live xml, we need to ensure
# the update with original "network" type will not fail.
# Try to delete the nwfilter with original type in iface_params
update_xml = interface.Interface(iface_type)
iface_params_update = {
"del_filter": "yes",
"type": "network",
"source": vm_iface_source
}
update_xml.xml = libvirt.modify_vm_iface(
vm1_name, 'get_xml', iface_params_update)
ret = virsh.update_device(vm1_name,
update_xml.xml,
ignore_status=True,
debug=True)
libvirt.check_exit_status(ret)
else:
vm_iface_source = str(iface_source)
vm1_iface_params = {
"type": "bridge",
"source": vm_iface_source,
"filter": filter_name,
"mac": mac,
'driver': iface_driver,
"iface_model": iface_model
}
libvirt.modify_vm_iface(vm1_name, "update_iface", vm1_iface_params)
if vm1.is_alive():
vm1.destroy()
vm1.start()
# apply ip address as it may not be initialized
session1 = session2 = None
session1 = vm1.wait_for_serial_login()
utils_net.restart_guest_network(session1)
output = session1.cmd_output("ifconfig || ip a")
logging.debug("guest1 ip info %s" % output)
# Check guest's network function
host_ip = utils_net.get_ip_address_by_interface(bridge_name)
remote_url = params.get("remote_ip", "www.google.com")
try:
vm1_ip = utils_net.get_guest_ip_addr(session1, mac)
except Exception as errs:
test.fail("vm1 can't get IP with the new create bridge: %s" % errs)
if hotplug:
# reboot vm1 then check network function to ensure the interface still there and works fine
logging.info("reboot the vm")
virsh.reboot(vm1)
if session1 is None:
session1 = vm1.wait_for_serial_login()
ping(vm1_ip,
remote_url,
ping_count,
ping_timeout,
session=session1)
# restart libvirtd service then check the interface still works fine
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
vm1.cleanup_serial_console()
vm1.create_serial_console()
session1 = vm1.wait_for_serial_login()
ping(vm1_ip,
remote_url,
ping_count,
ping_timeout,
session=session1)
logging.info(
"after reboot and restart libvirtd, the network works fine")
if iface_driver:
try:
driver_dict = eval(iface_driver)
if session1 is None:
session1 = vm1.wait_for_serial_login()
guest_iface_info = session1.cmd_output("ip l").strip()
guest_iface_name = re.findall(
r"^\d+: (\S+?)[@:].*state UP.*$", guest_iface_info,
re.MULTILINE)[0]
comb_size = driver_dict.get('queues')
rx_size = driver_dict.get('rx_queue_size')
session1.cmd_status("ethtool -L %s combined %s" %
(guest_iface_name, comb_size))
ret, outp = session1.cmd_status_output("ethtool -l %s" %
guest_iface_name)
logging.debug("ethtool cmd output:%s" % outp)
if not ret:
pre_comb = re.search(
"Pre-set maximums:[\s\S]*?Combined:.*?(\d+)",
outp).group(1)
cur_comb = re.search(
"Current hardware settings:[\s\S]*?Combined:.*?(\d+)",
outp).group(1)
if int(pre_comb) != int(comb_size) or int(
cur_comb) != int(comb_size):
test.fail(
"Fail to check the combined size: setting: %s,"
"Pre-set: %s, Current-set: %s" %
(comb_size, pre_comb, cur_comb))
else:
logging.info(
"Getting correct Pre-set and Current set value"
)
else:
test.error("ethtool list fail: %s" % outp)
# as tx_queue size is only supported for vhost-user interface, only check rx_queue size
ret1, outp1 = session1.cmd_status_output("ethtool -g %s" %
guest_iface_name)
logging.debug("guest queue size setting is %s" % outp1)
if not ret1:
pre_set = re.search(r"Pre-set maximums:\s*RX:\s*(\d+)",
outp1).group(1)
cur_set = re.search(
r"Current hardware settings:\s*RX:\s*(\d+)",
outp1).group(1)
if int(pre_set) != int(rx_size) or int(cur_set) != int(
rx_size):
test.fail("Fail to check the rx_queue_size!")
except Exception as errs:
test.fail("fail to get driver info")
# hot-unplug interface/device
if attach_interface:
ret = virsh.detach_interface(vm1_name,
"bridge",
ignore_status=True)
else:
ret = virsh.detach_device(vm1_name,
attach_xml.xml,
ignore_status=True,
debug=True)
if ret.exit_status:
test.fail("Hot-unplug interface/device fail")
else:
logging.info("hot-unplug interface/device succeed")
else:
if start_vm2:
# Start vm2 connect to the same bridge
mac2 = utils_net.generate_mac_address_simple()
vm2_iface_params = {
"type": "bridge",
"source": vm_iface_source,
"filter": filter_name,
"mac": mac2
}
libvirt.modify_vm_iface(vm2_name, "update_iface",
vm2_iface_params)
if vm2.is_alive():
vm2.destroy()
vm2.start()
# Check if vm1 and vm2 can ping each other
try:
utils_net.update_mac_ip_address(vm2, timeout=120)
vm2_ip = vm2.get_address()
except Exception as errs:
test.fail(
"vm2 can't get IP with the new create bridge: %s" %
errs)
session2 = vm2.wait_for_login()
# make sure guest has got ip address
utils_net.restart_guest_network(session2)
output2 = session2.cmd_output("ifconfig || ip a")
logging.debug("guest ip info %s" % output2)
# check 2 guests' network functions
check_net_functions(vm1_ip, ping_count, ping_timeout, session1,
host_ip, remote_url, vm2_ip)
check_net_functions(vm2_ip, ping_count, ping_timeout, session2,
host_ip, remote_url, vm1_ip)
finally:
logging.debug("Start to restore")
vm1_xml_bak.sync()
vm2_xml_bak.sync()
virsh.nwfilter_undefine(filter_name, ignore_status=True)
if libvirt.check_iface(bridge_name, "exists", "--all"):
virsh.iface_unbridge(bridge_name, timeout=60, debug=True)
if os.path.exists(iface_script_bk):
process.run("mv %s %s" % (iface_script_bk, iface_script),
shell=True,
verbose=True)
if os.path.exists(bridge_script):
process.run("rm -rf %s" % bridge_script, shell=True, verbose=True)
cmd = 'tmux -c "ip link set {1} nomaster; ip link delete {0};' \
'pkill dhclient; sleep 6; dhclient {1}"'.format(bridge_name, iface_name)
process.run(cmd, shell=True, verbose=True)
# reload network configuration
NM_service.restart()
# recover NetworkManager
if NM_status is True:
NM_service.start()
if 'network' in iface_source and iface_source[
"network"] in virsh.net_state_dict():
virsh.net_destroy(iface_source["network"], ignore_status=False)
def run(test, params, env):
"""
Test network/interface function on 2 vms:
- Test settings on 2 vms
- Run ping check on 2 vms including pinging each other
...
"""
vms = params.get('vms').split()
vm_list = [env.get_vm(v_name) for v_name in vms]
if len(vm_list) != 2:
test.cancel('More or less than 2 vms is currently unsupported')
feature = params.get('feature', '')
case = params.get('case', '')
check_ping = 'yes' == params.get('check_ping')
expect_ping_host = 'yes' == params.get('expect_ping_host', 'no')
expect_ping_out = 'yes' == params.get('expect_ping_out', 'no')
expect_ping_vm = 'yes' == params.get('expect_ping_vm', 'no')
out_ip = params.get('out_ip', 'www.redhat.com')
live_update = 'yes' == params.get('live_update', 'no')
set_all = 'yes' == params.get('set_all', 'no')
rand_id = '_' + utils_misc.generate_random_string(3)
bridge_name = params.get('bridge_name', 'test_br0') + rand_id
iface_name = utils_net.get_net_if(state="UP")[0]
test_net = 'net_isolated' + rand_id
bridge_created = False
vmxml_backup_list = []
for vm_i in vm_list:
vmxml_backup_list.append(vm_xml.VMXML.new_from_inactive_dumpxml(vm_i.name))
try:
# Test feature: port isolated
if feature == 'port_isolated':
if not libvirt_version.version_compare(6, 2, 0):
test.cancel('Libvirt version should be'
' > 6.2.0 to support port isolated')
if case.startswith('set_iface'):
create_bridge(bridge_name, iface_name)
bridge_created = True
iface_type = case.split('_')[-1]
if iface_type == 'network':
net_dict = {'net_forward': "{'mode': 'bridge'}",
'net_bridge': "{'name': '%s'}" % bridge_name}
prepare_network(test_net, **net_dict)
updated_iface_dict = {
'type': iface_type,
'source': "{'network': '%s'}" % test_net,
}
elif iface_type == 'bridge':
updated_iface_dict = {
'type': iface_type,
'source': "{'bridge': '%s'}" % bridge_name,
}
else:
test.error('Unsupported iface type: %s' % iface_type)
# Set 2 vms to isolated=yes or set one to 'yes', the other to 'no'
isolated_settings = ['yes'] * 2 if set_all else ['yes', 'no']
for i in (0, 1):
vm_i = vm_list[i]
new_iface_dict = dict(
list(updated_iface_dict.items()) +
[('port', "{'isolated': '%s'}" % isolated_settings[i])]
)
libvirt.modify_vm_iface(vm_i.name, 'update_iface',
new_iface_dict)
logging.debug(virsh.dumpxml(vm_i.name).stdout_text)
if case == 'update_iface':
if params.get('iface_port'):
iface_dict = {'port': params['iface_port']}
for vm_i in vm_list:
libvirt.modify_vm_iface(vm_i.name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_i.name).stdout_text)
if live_update:
for vm_i in vm_list:
vm_i.start()
# Test Update iface with new attrs
new_iface_dict = {}
if params.get('new_iface_port'):
new_iface_dict['port'] = params['new_iface_port']
elif params.get('del_port') == 'yes':
new_iface_dict['del_port'] = True
for vm_i in vm_list:
updated_iface = libvirt.modify_vm_iface(vm_i.name, 'get_xml', new_iface_dict)
result = virsh.update_device(vm_i.name, updated_iface, debug=True)
libvirt.check_exit_status(result)
if case == 'attach_iface':
new_ifaces = {}
for vm_i in vm_list:
# Create iface xml to be attached
new_iface = interface.Interface('network')
new_iface.xml = libvirt.modify_vm_iface(
vm_i.name, 'get_xml',
{'port': params.get('new_iface_port')}
)
new_ifaces[vm_i.name] = new_iface
# Remove current ifaces on vm
vmxml_i = vm_xml.VMXML.new_from_inactive_dumpxml(vm_i.name)
vmxml_i.remove_all_device_by_type('interface')
vmxml_i.sync()
logging.debug(virsh.dumpxml(vm_i.name).stdout_text)
# Start vm for hotplug
vm_i.start()
session = vm_i.wait_for_serial_login()
# Hotplug iface
virsh.attach_device(vm_i.name, new_iface.xml, debug=True, ignore_status=False)
# Wait a few seconds for interface to be fully attached
time.sleep(5)
ip_l_before = session.cmd_output('ip l')
logging.debug(ip_l_before)
session.close()
if case == 'set_network':
create_bridge(bridge_name, iface_name)
bridge_created = True
net_dict = {
'net_forward': "{'mode': 'bridge'}",
'net_bridge': "{'name': '%s'}" % bridge_name,
'net_port': "{'isolated': '%s'}" % params.get(
'net_isolated', 'yes')}
prepare_network(test_net, **net_dict)
# Modify iface to connect to newly added network
updated_iface_dict = {'type': 'network',
'source': "{'network': '%s'}" % test_net}
for vm_i in vm_list:
libvirt.modify_vm_iface(vm_i.name, 'update_iface',
updated_iface_dict)
logging.debug(virsh.domiflist(vm_i.name).stdout_text)
# Check ping result from vm session to host, outside, the other vm
if check_ping:
for vm_i in vm_list:
if vm_i.is_dead():
vm_i.start()
host_ip = utils_net.get_host_ip_address()
ping_expect = {
host_ip: expect_ping_host,
out_ip: expect_ping_out,
}
# A map of vm session and vm's ip addr
session_n_ip = {}
for vm_i in vm_list:
mac = vm_i.get_mac_address()
sess = vm_i.wait_for_serial_login()
vm_ip = utils_net.get_guest_ip_addr(sess, mac)
session_n_ip[sess] = vm_ip
logging.debug('Vm %s ip: %s', vm_i.name, vm_ip)
# Check ping result from each vm's session
for i in (0, 1):
sess = list(session_n_ip.keys())[i]
another_sess = list(session_n_ip.keys())[1 - i]
ping_expect[session_n_ip[another_sess]] = expect_ping_vm
if not ping_func(sess, **ping_expect):
test.fail('Ping check failed')
# Remove the other session's ip from ping result, then the
# next round of ping check will not do a ping check to the vm itself
ping_expect.pop(session_n_ip[another_sess])
# Some test steps after ping check
if feature == 'port_isolated':
if case == 'attach_iface':
# Test detach of iface
for vm_name_i in new_ifaces:
virsh.detach_device(
vm_name_i,
new_ifaces[vm_name_i].xml,
wait_for_event=True,
debug=True, ignore_status=False
)
# Check whether iface successfully detached by checking 'ip l' output
for vm_i in vm_list:
session = vm_i.wait_for_serial_login()
ip_l_after = session.cmd_output('ip l')
session.close()
if len(ip_l_before.splitlines()) == len(ip_l_after.splitlines()):
test.fail('Output of "ip l" is not changed afte detach, '
'interface not successfully detached')
def run(test, params, env):
"""
Test autogenerated tap device name.
1.Prepare test environment, restart libvirtd to flush the counter.
2.start the domain.
3.check the tap device name, then destroy the vm, restart libvirtd if
needed, then start the vm again;
4.hotplug an interface and check the tap device name;
5.detach one interface, restart libvirtd if needed, then hotplug again to
check the tap device name;
6.hotplug interface of another type, check tap device name;
7.recover the env.
"""
def prepare_vmxml(vm, vm_name, direct=False):
"""
Ensure there is only 1 requested interface in the vmxml
param vm: the test vm
param vm_name: the vm'name
param direct: True or False, if True, prepare vm xml with a direct type
interface(the tap device will be named as macvtap*);
if False , prepare vm xml with a network type interface
connected to default network(the tap device will be named
as vnet* automatically instead)
:return: None
"""
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
iface_dict = prepare_iface_dict(direct)
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
def prepare_iface_dict(direct=False):
"""
Prepare the iface_dict for the function 'libvirt.modify_vm_iface()' to use
:param direct: True or False
:return: a dictionary
"""
if direct:
iface_name = utils_net.get_net_if(state="UP")[0]
source = "{'dev': '%s', 'mode': 'bridge'}" % iface_name
iface_dict = {
"model": "virtio",
'type': 'direct',
'source': source,
'del_addr': 'yes',
'del_alias': 'yes',
'del_target': 'yes'
}
else:
iface_dict = {
"model": "virtio",
'type': 'network',
'source': "{'network': 'default'}",
'del_addr': 'yes',
'del_alias': 'yes',
'del_target': 'yes'
}
return iface_dict
def check_target_name(index, direct=False):
"""
Check the auto generated tap device name on the host
param index: an integer range in {-1,}, the max index occupied, if there
is no occupied, initial index is -1
param direct: True or False.
True: the expected auto-generated tap device name should
be 'macvtap${index+1}'
False: the expected auto-generated tap device name should
be "vnet${index+1}"
:return: None
"""
cmd_output = process.run("ls /sys/class/net",
shell=True,
ignore_status=True).stdout_text
logging.debug("Current network interfaces on the host includes: %s",
cmd_output)
index_ = int(index)
if direct:
expected_name = 'macvtap' + str(index_ + 1)
else:
expected_name = "vnet" + str(index_ + 1)
if expected_name not in cmd_output:
test.fail("Can not get the expected tap: %s" % expected_name)
else:
logging.debug("Get the expected tap: %s" % expected_name)
return
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Destroy VM first
if vm.is_alive():
vm.destroy(gracefully=False)
test_macvtap = "yes" == params.get("test_macvtap", "no")
flush_with_occupation = "yes" == params.get("flush_with_occupation", "no")
flush_after_detach = "yes" == params.get("flush_after_detach", "no")
# if there is existing vnet* or macvtap* even the test vm is destroyed,
# the env is not clean, cancel the test
cmd_output = process.run("ls /sys/class/net",
shell=True,
ignore_status=True).stdout_text
if ('vnet' in cmd_output and not test_macvtap) or \
('macvtap' in cmd_output and test_macvtap):
test.cancel("The env is not clean, there is existing tap device!")
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
libvirtd = utils_libvirtd.Libvirtd()
try:
prepare_vmxml(vm, vm_name, test_macvtap)
libvirt_network.ensure_default_network()
libvirtd.restart()
# if there is no vm running, restart libvirtd will flush the counter
# to the initial value: -1
counter = -1
vm.start()
# check the auto generated tap device name after fresh initialized
logging.debug("1. Check the tap device name after initialized:")
check_target_name(counter, test_macvtap)
# if the vm start successfully and tap device create successfully,
# current counter should increase by 1
counter = counter + 1
# destroy and start the vm again
vm.destroy()
time.sleep(2)
# flush when vm down, if flushed, the counter is initialized to -1
if flush_with_occupation:
libvirtd.restart()
counter = -1
time.sleep(2)
vm.start()
logging.debug(
"2. Check tap name after destroy and start vm again with "
"libvirtd restart: %s:", flush_with_occupation)
check_target_name(counter, test_macvtap)
# new tap created after vm start, counter increase by 1
counter = counter + 1
# add another interface with the same interface type
if_dict = prepare_iface_dict(test_macvtap)
mac_addr = utils_net.generate_mac_address_simple()
if_dict['mac'] = mac_addr
iface_add_xml = libvirt.modify_vm_iface(vm_name, 'get_xml', if_dict)
virsh.attach_device(vm_name,
iface_add_xml,
debug=True,
ignore_status=False)
time.sleep(2)
logging.debug("3. Check tap name after hotplug an interface:")
check_target_name(counter, test_macvtap)
# one interface with same iface type attached, counter increase by 1
counter = counter + 1
# Make sure the guest boots up. Otherwise detach_device won't complete
vm.wait_for_serial_login(timeout=180).close()
# detach the new attached interface
virsh.detach_device(vm_name,
iface_add_xml,
wait_for_event=True,
debug=True,
ignore_status=False)
if flush_after_detach:
libvirtd.restart()
# the latest occupied name is recycled after restart
# the counter is not initialized to -1 as the vm is running and
# first tap name is occupied
counter = counter - 1
virsh.attach_device(vm_name,
iface_add_xml,
debug=True,
ignore_status=False)
logging.debug(
"4 Check tap name after detach and reattach with "
"flushed: %s:", flush_after_detach)
check_target_name(counter, test_macvtap)
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_backup.sync()
def run(test, params, env):
"""
Test virsh migrate command.
"""
def check_vm_network_accessed(session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:raise: test.error when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
s_ping, _ = utils_test.ping(vm.get_address(),
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if s_ping != 0:
if session:
session.close()
test.fail("%s did not respond after %d sec." % (vm.name, 20))
def check_migration_res(result):
"""
Check if the migration result is as expected
:param result: the output of migration
:raise: test.fail if test is failed
"""
if not result:
test.error("No migration result is returned.")
logging.info("Migration out: %s", result.stdout_text.strip())
logging.info("Migration error: %s", result.stderr_text.strip())
if status_error: # Migration should fail
if err_msg: # Special error messages are expected
if not re.search(err_msg, result.stderr_text.strip()):
test.fail("Can not find the expected patterns '%s' in "
"output '%s'" %
(err_msg, result.stderr_text.strip()))
else:
logging.debug("It is the expected error message")
else:
if int(result.exit_status) != 0:
logging.debug("Migration failure is expected result")
else:
test.fail("Migration success is unexpected result")
else:
if int(result.exit_status) != 0:
test.fail(result.stderr_text.strip())
check_parameters(test, params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
virsh_options = params.get("virsh_options", "")
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
client_ip = params.get("client_ip")
client_pwd = params.get("client_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
guest_src_url = params.get("guest_src_url")
guest_src_path = params.get("guest_src_path",
"/var/lib/libvirt/images/guest.img")
check_disk = "yes" == params.get("check_disk")
disk_model = params.get("disk_model")
disk_target = params.get("disk_target", "vda")
controller_model = params.get("controller_model")
check_interface = "yes" == params.get("check_interface")
iface_type = params.get("iface_type", "network")
iface_model = params.get("iface_model", "virtio")
iface_params = {
'type': iface_type,
'model': iface_model,
'del_addr': True,
'source': '{"network": "default"}'
}
check_memballoon = "yes" == params.get("check_memballoon")
membal_model = params.get("membal_model")
check_rng = "yes" == params.get("check_rng")
rng_model = params.get("rng_model")
migr_vm_back = "yes" == params.get("migrate_vm_back", "no")
status_error = "yes" == params.get("status_error", "no")
remote_virsh_dargs = {
'remote_ip': server_ip,
'remote_user': server_user,
'remote_pwd': server_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
xml_check_after_mig = params.get("guest_xml_check_after_mig")
err_msg = params.get("err_msg")
vm_session = None
remote_virsh_session = None
vm = None
mig_result = None
if not libvirt_version.version_compare(5, 0, 0):
test.cancel("This libvirt version doesn't support "
"virtio-transitional model.")
# Make sure all of parameters are assigned a valid value
check_parameters(test, params)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
migration_test = migration.MigrationTest()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
# download guest source and update interface model to keep guest up
if guest_src_url:
blk_source = download.get_file(guest_src_url, guest_src_path)
if not blk_source:
test.error("Fail to download image.")
params["blk_source_name"] = blk_source
if (not check_interface) and iface_model:
iface_dict = {'model': iface_model}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_dict)
if not check_disk:
params["disk_model"] = "virtio-transitional"
if check_interface:
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
if check_memballoon:
membal_dict = {'membal_model': membal_model}
dom_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
libvirt.update_memballoon_xml(dom_xml, membal_dict)
if check_rng:
rng_dict = {'rng_model': rng_model}
rng_xml = libvirt.create_rng_xml(rng_dict)
dom_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
libvirt.add_vm_device(dom_xml, rng_xml)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check local guest network connection before migration
vm_session = vm.wait_for_login(restart_network=True)
check_vm_network_accessed()
# Execute migration process
vms = [vm]
migration_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
virsh_opt=virsh_options,
extra_opts=extra)
mig_result = migration_test.ret
check_migration_res(mig_result)
if int(mig_result.exit_status) == 0:
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session)
server_session.close()
if xml_check_after_mig:
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(
**remote_virsh_dargs)
target_guest_dumpxml = (remote_virsh_session.dumpxml(
vm_name, debug=True, ignore_status=True).stdout_text.strip())
if check_disk:
check_str = disk_model if disk_model else controller_model
if check_interface:
check_str = iface_model
if check_memballoon:
check_str = membal_model
if check_rng:
check_str = rng_model
xml_check_after_mig = "%s'%s'" % (xml_check_after_mig, check_str)
if not re.search(xml_check_after_mig, target_guest_dumpxml):
test.fail("Fail to search '%s' in target guest XML:\n%s" %
(xml_check_after_mig, target_guest_dumpxml))
remote_virsh_session.close_session()
# Execute migration from remote
if migr_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migration_test.migrate_pre_setup(src_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name, virsh_options, src_uri)
logging.debug("Start migration: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
test.fail("Failed to run '%s' on remote: %s" %
(cmd, cmd_result))
finally:
logging.debug("Recover test environment")
# Clean VM on destination
vm.connect_uri = ''
migration_test.cleanup_dest_vm(vm, src_uri, dest_uri)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s", orig_config_xml.xmltreefile)
# Clean up of pre migration setup for local machine
if migr_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migration_test.migrate_pre_setup(src_uri, params, cleanup=True)
if remote_virsh_session:
remote_virsh_session.close_session()
logging.info("Remove local NFS image")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
if guest_src_url and blk_source:
libvirt.delete_local_disk("file", path=blk_source)
def run(test, params, env):
"""
Test virtio/virtio-transitional model of serial device
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def get_free_pci_slot():
"""
Get a free slot from pcie-to-pci-bridge
:return: The free slot
"""
used_slot = []
for dev in pci_devices:
address = dev.find('address')
if (address is not None
and address.get('bus') == pci_bridge_index):
used_slot.append(address.get('slot'))
for slot_index in range(1, 30):
slot = "%0#4x" % slot_index
if slot not in used_slot:
return slot
return None
def test_data_transfer(dev_type):
"""
Test data transfer between guest and host via console/serial device
:param dev_type: The device type to be tested, console or channel
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
console_xml = vmxml.xmltreefile.find('devices').find(dev_type)
host_path = console_xml.find('source').get('path')
guest_path = '/dev/hvc0' if dev_type == 'console' else '/dev/vport0p1'
test_message = 'virtiochannel'
cat_cmd = "cat %s" % host_path
logfile = "test_data_transfer-%s.log" % dev_type
host_process = aexpect.ShellSession(cat_cmd,
auto_close=False,
output_func=utils_misc.log_line,
output_params=(logfile, ))
guest_session = vm.wait_for_login()
guest_session.cmd_output('echo %s > %s' % (test_message, guest_path))
guest_session.close()
try:
host_process.read_until_last_line_matches(test_message, timeout=10)
except aexpect.exceptions.ExpectError as e:
test.fail('Did not catch the expected output from host side,'
' the detail of the failure: %s' % str(e))
finally:
host_process.close()
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
add_pcie_to_pci_bridge = params.get("add_pcie_to_pci_bridge")
guest_src_url = params.get("guest_src_url")
virtio_model = params['virtio_model']
# Download and replace image when guest_src_url provided
if guest_src_url:
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
download.get_file(guest_src_url, target_path)
params["blk_source_name"] = target_path
# Add pcie-to-pci-bridge when it is required
if add_pcie_to_pci_bridge:
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
pci_bridge = controller
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
pci_bridge = libvirt.create_controller_xml(contr_dict,
"add_controller",
vm_name)
pci_bridge_index = '%0#4x' % int(pci_bridge.get("index"))
try:
# Update interface to virtio-transitional mode for
# rhel6 guest to make it works for login
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
# vmxml will not be updated since set_vm_disk
# sync with another dumped xml inside the function
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Remove all current serial devices
vmxml.remove_all_device_by_type('serial')
vmxml.remove_all_device_by_type('channel')
vmxml.remove_all_device_by_type('console')
vmxml.del_controller('virtio-serial')
vmxml.sync()
# Add virtio-serial with right model
contr_dict = {
'controller_type': 'virtio-serial',
'controller_model': virtio_model
}
if add_pcie_to_pci_bridge:
pci_devices = vmxml.xmltreefile.find('devices').getchildren()
slot = get_free_pci_slot()
addr = '{"bus": %s, "slot": %s}' % (pci_bridge_index, slot)
contr_dict.update({'controller_addr': addr})
libvirt.create_controller_xml(contr_dict, "add_controller", vm_name)
# vmxml will not be updated since set_vm_disk
# sync with another dumped xml inside the function
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Add channel and console device attached to virtio-serial bus
target_dict = {'type': 'virtio', 'name': 'ptychannel'}
address_dict = {'type': 'virtio-serial', 'controller': '0', 'bus': '0'}
channel_xml = Channel('pty')
channel_xml.target = target_dict
channel_xml.address = address_dict
console_xml = Console()
console_xml.target_port = '0'
console_xml.target_type = 'virtio'
vmxml.add_device(channel_xml)
vmxml.add_device(console_xml)
vmxml.sync()
if vm.is_alive():
vm.destroy()
vm.start(autoconsole=False)
# Test data transfer via console and channel devices
test_data_transfer('console')
test_data_transfer('channel')
finally:
vm.destroy()
backup_xml.sync()
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")
if iface_type == "bridge":
try:
utils_path.find_command("brctl")
except utils_path.CmdNotFoundError:
test.cancel("Command 'brctl' is missing. You must "
"install it.")
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}
# 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, raise TestCancel
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:
test.cancel("No useful bridge on host "
"other than 'virbr0'.")
# 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()
# Record all iface parameters in iface_dict
iface_dict = {}
update_list = [
"driver", "driver_host", "driver_guest", "model", "rom",
"inbound", "outbound", "link", "target", "mac", "source",
"boot", "backend", "type", "mode"
]
names = locals()
for update_item in update_list:
if names["iface_"+update_item]:
iface_dict.update({update_item: names["iface_"+update_item]})
else:
iface_dict.update({update_item: None})
logging.info("iface_dict is %s", iface_dict)
# Format the params
iface_format = format_param(iface_dict)
logging.info("iface_format is %s", iface_format)
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
xml_file_tmp = libvirt.modify_vm_iface(vm_name, "get_xml", iface_format)
new_iface = Interface(type_name=iface_type)
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()
# 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")
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:
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()
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:
# 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()
