def setup_save_restore_hostdev_iface_with_teaming(): logging.info("Create hostdev network.") net_hostdev_fwd = params.get("net_hostdev_fwd", '{"mode": "hostdev", "managed": "yes"}') net_hostdev_dict = { "net_name": net_hostdev_name, "net_forward": net_hostdev_fwd, "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_hostdev_dict) libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) iface = interface.Interface("network") iface.xml = create_bridge_iface_xml(vm, mac_addr, params) vmxml.add_device(iface) iface.xml = create_hostdev_iface_xml(vm, mac_addr, params) vmxml.add_device(iface) vmxml.sync() logging.debug("VMXML after updating ifaces: %s.", vm_xml.VMXML.new_from_dumpxml(vm_name)) vm.start() vm_session = vm.wait_for_serial_login(timeout=240) ping_ip = get_ping_dest(vm_session, mac_addr) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True)
def create_vf_pool(): """ Create VF pool """ net_hostdev_dict = { "net_name": params.get("net_name"), "net_forward": params.get("net_forward"), "vf_list_attrs": "[%s]" % utils_sriov.pci_to_addr(vf_pci) } libvirt_network.create_or_del_network(net_hostdev_dict)
def teardown_max_vfs(): """ Teardown for max_vfs case 1. Disable VFs 2. Clean up networks """ pf_id_list = get_pf_id_list(pf_info, driver) for pf_pci in pf_id_list: sriov_base.recover_vf(pf_pci, params, timeout=240) net_info = get_net_dict(pf_info) for pf_dev in net_info: libvirt_network.create_or_del_network( {"net_name": net_info[pf_dev]}, True)
def create_network(net_name, pf_name, params): """ Create network :param net_name: Network name to create :param pf_name: PF device :param params: The parameters dict """ net_dict = { "net_name": net_name, "net_forward": params.get("net_forward"), "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_dict)
def create_network(params): """ Create VF pool """ net_dict = { "net_name": params.get("net_name"), "net_forward": params.get("net_forward") } net_forward_pf = "yes" == params.get("net_forward_pf") if net_forward_pf: net_dict.update( {"net_forward_pf": '{"dev": "%s"}' % params.get("pf_name")}) else: net_dict.update({"forward_iface": params.get("vf_iface")}) libvirt_network.create_or_del_network(net_dict)
def setup_hotplug_hostdev_iface_with_teaming(): logging.info("Create hostdev network.") net_hostdev_fwd = params.get("net_hostdev_fwd", '{"mode": "hostdev", "managed": "yes"}') net_hostdev_dict = { "net_name": net_hostdev_name, "net_forward": net_hostdev_fwd, "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_hostdev_dict) logging.info("Clear up VM interface.") libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vm.start() vm.wait_for_serial_login(timeout=180).close()
def setup_hotplug_hostdev_iface_with_teaming(): logging.info("Create hostdev network.") net_hostdev_fwd = params.get("net_hostdev_fwd", '{"mode": "hostdev", "managed": "yes"}') net_hostdev_dict = { "net_name": net_hostdev_name, "net_forward": net_hostdev_fwd, "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_hostdev_dict) logging.info("Clear up VM interface.") libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') iface = interface.Interface("network") iface.xml = create_bridge_iface_xml(vm, mac_addr, params) virsh.attach_device(vm_name, iface.xml, flagstr='--persistent', debug=True, ignore_status=False) vm.start() vm.wait_for_serial_login(timeout=180).close()
def run(test, params, env): """ Test interfaces attached from network """ def test_at_dt(): """ Test attach-detach interfaces """ if not pf_status: logging.info("Set pf state to down.") pf_iface_obj = utils_net.Interface(pf_name) pf_iface_obj.down() logging.info("Define network - %s.", params.get("net_name")) create_network(params) logging.debug("Remove VM's interface devices.") libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vm.start() vm_session = vm.wait_for_serial_login(timeout=240) logging.info("Hotplug an interface to VM.") iface_dict = { "model": "virtio", "source": { 'network': params.get("net_name") } } iface = create_iface(iface_dict) res = virsh.attach_device(vm_name, iface.xml, debug=True) libvirt.check_exit_status(res, status_error) if not pf_status: logging.info("Set pf state to up then check again.") pf_iface_obj.up() virsh.attach_device(vm_name, iface.xml, debug=True, ignore_status=False) libvirt_vmxml.check_guest_xml(vm.name, params["net_name"]) sriov_base.check_vm_network_accessed(vm_session) def test_connection(): """ Test network connections 1. Create a network 2. Attach the interfaces and check network connections 3. Check the network connections after detaching ifaces, restarting libvirtd and destroying the VM """ vf_no = int(params.get("vf_no", "4")) net_name = params.get("net_name") iface_type = params.get("iface_type") logging.info("Define network - %s.", net_name) create_network(params) libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') libvirt_pcicontr.reset_pci_num(vm_name) vm.start() vm.wait_for_serial_login(timeout=240) logging.info("Attach 4 interfaces to the guest.") opts = ' '.join( ["network", net_name, params.get('attach_extra_opts', "")]) for i in range(vf_no): virsh.attach_interface(vm_name, option=opts, debug=True, ignore_status=False) libvirt_network.check_network_connection(net_name, i + 1) logging.info("Try to attach one more interface.") res = virsh.attach_interface(vm_name, option=opts, debug=True) libvirt.check_exit_status(res, True) logging.info("Detach an interface.") vm_ifaces = [ iface for iface in vm_xml.VMXML.new_from_dumpxml( vm_name).devices.by_device_tag("interface") ] mac_addr = vm_ifaces[0].get_mac_address() opts = ' '.join([iface_type, "--mac %s" % mac_addr]) virsh.detach_interface(vm_name, option=opts, debug=True, wait_for_event=True, ignore_status=False) libvirt_network.check_network_connection(net_name, vf_no - 1) logging.info( "Restart libvirtd service and check the network connection.") utils_libvirtd.Libvirtd().restart() libvirt_network.check_network_connection(net_name, vf_no - 1) logging.info("Destroy the VM and check the network connection.") vm.destroy(gracefully=False) libvirt_network.check_network_connection(net_name, 0) test_case = params.get("test_case", "") run_test = eval("test_%s" % test_case) status_error = "yes" == params.get("status_error", "no") vm_name = params.get("main_vm", "avocado-vt-vm1") vm = env.get_vm(vm_name) pf_pci = utils_sriov.get_pf_pci() if not pf_pci: test.cancel("NO available pf found.") sriov_base.setup_vf(pf_pci, params) vf_pci = utils_sriov.get_vf_pci_id(pf_pci) params['vf_iface'] = utils_sriov.get_iface_name(vf_pci) pf_status = "active" == params.get("pf_status", "active") pf_name = utils_sriov.get_pf_info_by_pci(pf_pci).get('iface') params['pf_name'] = pf_name vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) orig_config_xml = vmxml.copy() try: run_test() finally: logging.info("Recover test enviroment.") if not pf_status: pf_iface_obj = utils_net.Interface(pf_name) pf_iface_obj.up() sriov_base.recover_vf(pf_pci, params) if vm.is_alive(): vm.destroy(gracefully=False) orig_config_xml.sync() libvirt_network.create_or_del_network( {"net_name": params.get("net_name")}, True)
def run(test, params, env): """ SR-IOV: managed related test. """ def start_vm(vm, test_login=False, destroy_vm=False): """ Start up VM :param vm: The vm object :param test_login: Whether to login VM :param destroy_vm: Whether to destroy VM """ if vm.is_alive(): vm.destroy() vm.start() if test_login: vm.wait_for_serial_login(timeout=180).close() if destroy_vm: vm.destroy() def create_vf_pool(): """ Create VF pool """ net_hostdev_dict = { "net_name": params.get("net_name"), "net_forward": params.get("net_forward"), "vf_list_attrs": "[%s]" % utils_sriov.pci_to_addr(vf_pci) } libvirt_network.create_or_del_network(net_hostdev_dict) def check_vm_iface_managed(vm_name, iface_dict): """ Check 'managed' in VM's iface :param vm_name: Name of VM :param iface_dict: The parameters dict :raise: TestFail if not match """ vm_iface_managed = [ iface.get("managed") for iface in vm_xml.VMXML.new_from_dumpxml( vm_name).devices.by_device_tag("interface") ][0] expr_managed = "yes" if iface_dict.get("managed", "") == "yes" else None if vm_iface_managed != expr_managed: test.fail("Unable to get the expected managed! Actual: %s, " "Expected: %s." % (vm_iface_managed, expr_managed)) 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 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) test_case = params.get("test_case", "") run_test = eval("test_%s" % test_case) vm_name = params.get("main_vm", "avocado-vt-vm1") vm = env.get_vm(vm_name) pf_pci = utils_sriov.get_pf_pci() if not pf_pci: test.cancel("NO available pf found.") default_vf = sriov_base.setup_vf(pf_pci, params) vf_pci = utils_sriov.get_vf_pci_id(pf_pci) dev_name = utils_sriov.get_device_name(vf_pci) vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) orig_config_xml = vmxml.copy() try: run_test() finally: logging.info("Recover test enviroment.") sriov_base.recover_vf(pf_pci, params, default_vf) if vm.is_alive(): vm.destroy(gracefully=False) orig_config_xml.sync() libvirt_network.create_or_del_network( {"net_name": params.get("net_name")}, True) virsh.nodedev_reattach(dev_name, debug=True)
def teardown_hotplug_hostdev_iface_with_teaming(): logging.info("Delete hostdev network.") net_hostdev_dict = {"net_name": net_hostdev_name} libvirt_network.create_or_del_network(net_hostdev_dict, is_del=True)
def run(test, params, env): """ Sriov net failover related test. """ def setup_hotplug_hostdev_iface_with_teaming(): logging.info("Create hostdev network.") net_hostdev_fwd = params.get("net_hostdev_fwd", '{"mode": "hostdev", "managed": "yes"}') net_hostdev_dict = { "net_name": net_hostdev_name, "net_forward": net_hostdev_fwd, "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_hostdev_dict) logging.info("Clear up VM interface.") libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') iface = interface.Interface("network") iface.xml = create_bridge_iface_xml(vm, mac_addr, params) virsh.attach_device(vm_name, iface.xml, flagstr='--persistent', debug=True, ignore_status=False) vm.start() vm.wait_for_serial_login(timeout=180).close() def teardown_hotplug_hostdev_iface_with_teaming(): logging.info("Delete hostdev network.") net_hostdev_dict = {"net_name": net_hostdev_name} libvirt_network.create_or_del_network(net_hostdev_dict, is_del=True) def test_hotplug_hostdev_iface_with_teaming(): logging.info("Attach a hostdev interface.") hostdev_iface_xml = create_hostdev_iface_xml(vm, mac_addr, params) virsh.attach_device(vm_name, hostdev_iface_xml, debug=True, ignore_status=False) check_ifaces(vm_name, expected_ifaces={"bridge", "hostdev"}) vm_session = vm.wait_for_serial_login(timeout=240) ping_ip = get_ping_dest(vm_session, mac_addr) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) logging.info("Detach the hostdev interface.") hostdev_iface = interface.Interface("network") for ifc in vm_xml.VMXML.new_from_dumpxml( vm_name).devices.by_device_tag("interface"): if ifc.type_name == "hostdev": ifc.del_address() hostdev_iface = ifc virsh.detach_device(vm_name, hostdev_iface.xml, wait_remove_event=True, debug=True, ignore_status=False) check_ifaces(vm_name, expected_ifaces={"hostdev"}, status_error=True) check_vm_network_accessed(vm_session, 2, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=False) libvirt_vfio.check_vfio_pci(vf_pci, status_error=True) logging.info("Re-attach the hostdev interface.") virsh.attach_device(vm_name, hostdev_iface.xml, debug=True, ignore_status=False) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) def setup_hotplug_hostdev_device_with_teaming(): libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vm.start() vm.wait_for_serial_login(timeout=240).close() def test_hotplug_hostdev_device_with_teaming(): default_vf_mac = utils_sriov.get_vf_mac(pf_name) utils_sriov.set_vf_mac(pf_name, mac_addr) logging.info("Attach the bridge interface.") brg_iface_xml = create_bridge_iface_xml(vm, mac_addr, params) virsh.attach_device(vm_name, brg_iface_xml, debug=True, ignore_status=False) # Wait for 10s before attaching the hostdev device time.sleep(10) logging.info("Attach the hostdev device.") hostdev_dev = libvirt.create_hostdev_xml(vf_pci, teaming=hostdev_teaming_dict) virsh.attach_device(vm_name, hostdev_dev.xml, debug=True, ignore_status=False) vm_session = vm.wait_for_serial_login(timeout=240) ping_ip = get_ping_dest(vm_session, mac_addr) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) logging.info("Detach the hostdev device.") virsh.detach_device(vm_name, hostdev_dev.xml, wait_remove_event=True, debug=True, ignore_status=False) logging.debug("Recover vf's mac to %s.", default_vf_mac) utils_sriov.set_vf_mac(pf_name, default_vf_mac) check_hostdev = vm_xml.VMXML.new_from_dumpxml(vm_name)\ .devices.by_device_tag('hostdev') if check_hostdev: test.fail("The hostdev device exists after detaching %s." % check_hostdev) libvirt_vfio.check_vfio_pci(vf_pci, status_error=True) check_vm_network_accessed(vm_session, 2, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=False) def setup_save_restore_hostdev_device_with_teaming(): logging.info("Start a VM with bridge iface and hostdev device.") libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) iface = interface.Interface("network") iface.xml = create_bridge_iface_xml(vm, mac_addr, params) vmxml.add_device(iface) hostdev_dev = libvirt.create_hostdev_xml(vf_pci, teaming=hostdev_teaming_dict) vmxml.add_device(hostdev_dev) vmxml.sync() vm.start() utils_sriov.set_vf_mac(pf_name, mac_addr) vm.wait_for_serial_login(timeout=240).close() def test_save_restore_hostdev_device_with_teaming(): logging.info("Save/restore VM.") save_file = os.path.join(data_dir.get_tmp_dir(), "save_file") virsh.save(vm_name, save_file, debug=True, ignore_status=False, timeout=10) if not libvirt.check_vm_state(vm_name, "shut off"): test.fail("The guest should be down after executing 'virsh save'.") virsh.restore(save_file, debug=True, ignore_status=False) if not libvirt.check_vm_state(vm_name, "running"): test.fail( "The guest should be running after executing 'virsh restore'.") vm.cleanup_serial_console() vm.create_serial_console() vm_session = vm.wait_for_serial_login() ping_ip = get_ping_dest(vm_session, mac_addr) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) logging.info("Detach the hostdev device.") hostdev_dev = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name).devices.\ by_device_tag("hostdev") virsh.detach_device(vm_name, hostdev_dev.xml, wait_remove_event=True, debug=True, ignore_status=False) check_hostdev = vm_xml.VMXML.new_from_dumpxml(vm_name)\ .devices.by_device_tag('hostdev') if check_hostdev: test.fail("The hostdev device exists after detaching %s." % check_hostdev) check_vm_network_accessed(vm_session, 2, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=False) logging.info("Attach the hostdev device.") virsh.attach_device(vm_name, hostdev_dev.xml, debug=True, ignore_status=False) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) def setup_save_restore_hostdev_iface_with_teaming(): logging.info("Create hostdev network.") net_hostdev_fwd = params.get("net_hostdev_fwd", '{"mode": "hostdev", "managed": "yes"}') net_hostdev_dict = { "net_name": net_hostdev_name, "net_forward": net_hostdev_fwd, "net_forward_pf": '{"dev": "%s"}' % pf_name } libvirt_network.create_or_del_network(net_hostdev_dict) libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface') vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) iface = interface.Interface("network") iface.xml = create_bridge_iface_xml(vm, mac_addr, params) vmxml.add_device(iface) iface.xml = create_hostdev_iface_xml(vm, mac_addr, params) vmxml.add_device(iface) vmxml.sync() logging.debug("VMXML after updating ifaces: %s.", vm_xml.VMXML.new_from_dumpxml(vm_name)) vm.start() vm_session = vm.wait_for_serial_login(timeout=240) ping_ip = get_ping_dest(vm_session, mac_addr) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) def teardown_save_restore_hostdev_iface_with_teaming(): teardown_hotplug_hostdev_iface_with_teaming() def test_save_restore_hostdev_iface_with_teaming(): logging.info("Save/restore VM.") save_file = os.path.join(data_dir.get_tmp_dir(), "save_file") virsh.save(vm_name, save_file, debug=True, ignore_status=False, timeout=10) if not libvirt.check_vm_state(vm_name, "shut off"): test.fail("The guest should be down after executing 'virsh save'.") virsh.restore(save_file, debug=True, ignore_status=False) if not libvirt.check_vm_state(vm_name, "running"): test.fail( "The guest should be running after executing 'virsh restore'.") vm.cleanup_serial_console() vm.create_serial_console() vm_session = vm.wait_for_serial_login(timeout=240) ping_ip = get_ping_dest(vm_session, mac_addr, False) logging.debug(ping_ip) check_vm_network_accessed(vm_session, ping_dest=ping_ip, tcpdump_iface=bridge_name, tcpdump_status_error=True) def check_vm_iface_num(session, exp_num=3): """ Check he number of interfaces :param session: The session to the guest :param exp_num: The expected number :return: True when interfaces' number is equal to exp_num """ p_iface = utils_net.get_remote_host_net_ifs(session)[0] logging.debug("Ifaces in VM: %s", p_iface) return len(p_iface) == exp_num def check_vm_network_accessed(vm_session, expected_iface_no=3, ping_dest="8.8.8.8", timeout=30, tcpdump_iface=None, tcpdump_status_error=False): """ Test VM's network by checking ifaces' number and the accessibility :param vm_session: The session object to the guest :param expected_iface_no: The expected number of ifaces :param ping_dest: The destination to be ping :param timeout: The timeout of the checking :param tcpdump_iface: The interface to check :param tcpdump_status_error: Whether the tcpdump's output should include the string "ICMP echo request" :raise: test.fail when ifaces' number is incorrect or ping fails. """ if not utils_misc.wait_for( lambda: check_vm_iface_num(vm_session, expected_iface_no), first=3, timeout=timeout): test.fail("%d interfaces should be found on the vm." % expected_iface_no) if tcpdump_iface: cmd = "tcpdump -i %s icmp" % tcpdump_iface tcpdump_session = aexpect.ShellSession('bash') tcpdump_session.sendline(cmd) if not utils_misc.wait_for( lambda: not utils_test.ping(ping_dest, count=3, timeout=5, output_func=logging.debug, session=vm_session)[0], first=5, timeout=timeout): test.fail("Failed to ping %s." % ping_dest) if tcpdump_iface: output = tcpdump_session.get_stripped_output() logging.debug("tcpdump's output: %s.", output) pat_str = "ICMP echo request" if re.search(pat_str, output): if tcpdump_status_error: test.fail( "Get incorrect tcpdump output: {}, it should not " "include '{}'.".format(output, pat_str)) else: if not tcpdump_status_error: test.fail("Get incorrect tcpdump output: {}, it should " "include '{}'.".format(output, pat_str)) def get_ping_dest(vm_session, mac_addr, restart_network=True): """ Get an ip address to ping :param vm_session: The session object to the guest :param mac_addr: mac address of given interface :param restart_network: Whether to restart guest's network :return: ip address """ if restart_network: utils_misc.cmd_status_output("dhclient -r; sleep 5; dhclient", shell=True, session=vm_session) vm_iface_info = utils_net.get_linux_iface_info( mac_addr, vm_session)['addr_info'][0]['local'] return re.sub('\d+$', '1', vm_iface_info) 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 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 check_ifaces(vm_name, expected_ifaces={"bridge", "hostdev"}, status_error=False): """ Check VM's interfaces :param vm_name: The name of VM :param expected_ifaces: The expected interfaces :param status_error: Whether the ifaces should be same with the expected_ifaces :raise: test.fail if the interface(s) is(are) as expected """ if not expected_ifaces: return else: expected_ifaces = set(expected_ifaces) vm_ifaces = [ iface for iface in vm_xml.VMXML.new_from_dumpxml( vm_name).devices.by_device_tag("interface") ] ifaces_net = {iface.get_type_name() for iface in vm_ifaces} if expected_ifaces.issubset(ifaces_net) == status_error: test.fail( "Unable to get expected interface. The interface %s " "should%s be %s." % (ifaces_net, ' not' if status_error else '', expected_ifaces)) else: logging.debug("{}Found iface(s) as expected: {}.".format( 'Not ' if status_error else '', expected_ifaces)) test_case = params.get("test_case", "") run_test = eval("test_%s" % test_case) setup_test = eval("setup_%s" % test_case) if "setup_%s" % test_case in \ locals() else "setup_%s" % test_case teardown_test = eval("teardown_%s" % test_case) if "teardown_%s" % \ test_case in locals() else "teardown_%s" % test_case vm_name = params.get("main_vm", "avocado-vt-vm1") vm = env.get_vm(params["main_vm"]) driver = params.get("driver", "ixgbe") bridge_name = params.get("bridge_name", "br0") net_bridge_name = params.get("net_bridge_name", "host-bridge") net_bridge_fwd = params.get("net_bridge_fwd", '{"mode": "bridge"}') net_hostdev_name = params.get("net_hostdev_name", "hostdev-net") bridge_name = params.get("bridge_name", "br0") hostdev_teaming_dict = params.get("hostdev_device_teaming_dict", '{}') default_vf = 0 try: vf_no = int(params.get("vf_no", "4")) except ValueError as e: test.error(e) libvirt_version.is_libvirt_feature_supported(params) mac_addr = utils_net.generate_mac_address_simple() pf_pci = utils_sriov.get_pf_pci() if not pf_pci: test.cancel("NO available pf found.") pf_name = utils_sriov.get_pf_info_by_pci(pf_pci).get('iface') brg_dict = {'pf_name': pf_name, 'bridge_name': bridge_name} bridge_dict = { "net_name": net_bridge_name, "net_forward": net_bridge_fwd, "net_bridge": '{"name": "%s"}' % bridge_name } pf_pci_path = utils_misc.get_pci_path(pf_pci) cmd = "cat %s/sriov_numvfs" % (pf_pci_path) default_vf = process.run(cmd, shell=True, verbose=True).stdout_text new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) orig_config_xml = new_xml.copy() try: if not utils_sriov.set_vf(pf_pci_path, vf_no): test.error("Failed to set vf.") utils_sriov.add_or_del_connection(brg_dict, is_del=False) libvirt_network.create_or_del_network(bridge_dict) vf_pci = utils_sriov.get_vf_pci_id(pf_pci) exec_function(setup_test) run_test() finally: logging.info("Recover test enviroment.") utils_sriov.add_or_del_connection(brg_dict, is_del=True) libvirt_network.create_or_del_network(bridge_dict, is_del=True) if 'pf_pci_path' in locals() and default_vf != vf_no: utils_sriov.set_vf(pf_pci_path, default_vf) if vm.is_alive(): vm.destroy(gracefully=False) try: orig_config_xml.sync() except: # FIXME: Workaround for 'save'/'managedsave' hanging issue utils_libvirtd.Libvirtd().restart() orig_config_xml.sync() exec_function(teardown_test)
def run(test, params, env): """ Test migration with special network settings 1) migrate guest with bridge type interface connected to ovs bridge :param test: test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def check_vm_network_accessed(ping_dest, session=None): """ The operations to the VM need to be done before or after migration happens :param ping_dest: The destination to be ping :param session: The session object to the host :raise: test.fail when ping fails """ # Confirm local/remote VM can be accessed through network. logging.info("Check VM network connectivity") status, output = utils_net.ping(ping_dest, count=10, timeout=20, output_func=logging.debug, session=session) if status != 0: test.fail("Ping failed, status: %s, output: %s" % (status, output)) 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) migration_test = migration.MigrationTest() migration_test.check_parameters(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} 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") virsh_options = params.get("virsh_options", "") extra = params.get("virsh_migrate_extra") options = params.get("virsh_migrate_options", "--live --p2p --verbose") func_params_exists = "yes" == params.get("func_params_exists", "no") migr_vm_back = "yes" == params.get("migr_vm_back", "no") ovs_bridge_name = params.get("ovs_bridge_name") network_dict = eval(params.get("network_dict", '{}')) iface_dict = eval(params.get("iface_dict", '{}')) remote_virsh_dargs = { 'remote_ip': server_ip, 'remote_user': server_user, 'remote_pwd': server_pwd, 'unprivileged_user': None, 'ssh_remote_auth': True } func_name = None libvirtd_conf = None mig_result = None # 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() extra_args = {} if func_params_exists: extra_args.update({'func_params': params}) postcopy_options = params.get("postcopy_options") if postcopy_options: extra = "%s %s" % (extra, postcopy_options) func_name = virsh.migrate_postcopy # 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() try: # Create a remote runner for later use runner_on_target = remote.RemoteRunner(host=server_ip, username=server_user, password=server_pwd) remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') if ovs_bridge_name: status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name) if status: test.fail("Failed to create ovs bridge on local. Status: %s" "Stdout: %s" % (status, stdout)) status, stdout = utils_net.create_ovs_bridge( ovs_bridge_name, session=remote_session) if status: test.fail("Failed to create ovs bridge on remote. Status: %s" "Stdout: %s" % (status, stdout)) if network_dict: libvirt_network.create_or_del_network( network_dict, remote_args=remote_virsh_dargs) libvirt_network.create_or_del_network(network_dict) remote_session.close() # Change domain network xml if iface_dict: if "mac" not in iface_dict: mac = utils_net.generate_mac_address_simple() iface_dict.update({'mac': mac}) else: mac = iface_dict["mac"] update_iface_xml(vm_name, iface_dict) # Change the disk of the vm libvirt.set_vm_disk(vm, params) if not vm.is_alive(): try: vm.start() except virt_vm.VMStartError as err: test.fail("Failed to start VM: %s" % err) logging.debug("Guest xml after starting:\n%s", vm_xml.VMXML.new_from_dumpxml(vm_name)) # Check local guest network connection before migration if vm.serial_console is not None: vm.cleanup_serial_console() vm.create_serial_console() vm_session = vm.wait_for_serial_login(timeout=240) utils_net.restart_guest_network(vm_session) vm_ip = utils_net.get_guest_ip_addr(vm_session, mac) logging.debug("VM IP Addr: %s", vm_ip) check_vm_network_accessed(vm_ip) # 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, func=func_name, extra_opts=extra, **extra_args) mig_result = migration_test.ret migration_test.check_result(mig_result, params) if int(mig_result.exit_status) == 0: remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') check_vm_network_accessed(vm_ip, session=remote_session) remote_session.close() # 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, 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)) logging.debug("VM is migrated back.") check_vm_network_accessed(vm_ip) finally: logging.debug("Recover test environment") # Clean VM on destination and source try: migration_test.cleanup_dest_vm(vm, vm.connect_uri, dest_uri) except Exception as err: logging.error(err) if vm.is_alive(): vm.destroy(gracefully=False) logging.info("Recovery VM XML configration") orig_config_xml.sync() remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') if network_dict: libvirt_network.create_or_del_network( network_dict, is_del=True, remote_args=remote_virsh_dargs) libvirt_network.create_or_del_network(network_dict, is_del=True) if ovs_bridge_name: utils_net.delete_ovs_bridge(ovs_bridge_name) utils_net.delete_ovs_bridge(ovs_bridge_name, session=remote_session) remote_session.close() if migr_vm_back: if 'ssh_connection' in locals(): ssh_connection.auto_recover = True migration_test.migrate_pre_setup(src_uri, params, cleanup=True) logging.info("Remove local NFS image") source_file = params.get("source_file") if source_file: libvirt.delete_local_disk("file", path=source_file)
def run(test, params, env): """ Test migration with special network settings 1) migrate guest with bridge type interface connected to ovs bridge 2) migrate guest with direct type interface when a macvtap device name exists on dest host :param test: test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def check_vm_network_accessed(ping_dest, session=None): """ The operations to the VM need to be done before or after migration happens :param ping_dest: The destination to be ping :param session: The session object to the host :raise: test.fail when ping fails """ # Confirm local/remote VM can be accessed through network. logging.info("Check VM network connectivity") status, output = utils_net.ping(ping_dest, count=10, timeout=20, output_func=logging.debug, session=session) if status != 0: test.fail("Ping failed, status: %s, output: %s" % (status, output)) def vm_sync(vmxml, vm_name=None, virsh_instance=virsh): """ A wrapper to sync vm xml on localhost and remote host :param vmxml: domain VMXML instance :param vm_name: The name of VM :param virsh_instance: virsh instance object """ if vm_name and virsh_instance != virsh: remote.scp_to_remote(server_ip, '22', server_user, server_pwd, vmxml.xml, vmxml.xml) if virsh_instance.domain_exists(vm_name): if virsh_instance.is_alive(vm_name): virsh_instance.destroy(vm_name, ignore_status=True) virsh_instance.undefine(vmxml.xml, ignore_status=True) virsh_instance.define(vmxml.xml, debug=True) else: vmxml.sync() 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 update_net_dict(net_dict, runner=utils_net.local_runner): """ Update network dict :param net_dict: The network dict to be updated :param runner: Command runner :return: Updated network dict """ if net_dict.get("net_name", "") == "direct-macvtap": logging.info("Updating network iface name") iface_name = utils_net.get_net_if(runner=runner, state="UP")[0] net_dict.update({"forward_iface": iface_name}) else: # TODO: support other types logging.info("No need to update net_dict. We only support to " "update direct-macvtap type for now.") logging.debug("net_dict is %s" % net_dict) return net_dict def get_remote_direct_mode_vm_mac(vm_name, uri): """ Get mac of remote direct mode VM :param vm_name: The name of VM :param uri: The uri on destination :return: mac :raise: test.fail when the result of virsh domiflist is incorrect """ vm_mac = None res = virsh.domiflist( vm_name, uri=uri, ignore_status=False).stdout_text.strip().split("\n") if len(res) < 2: test.fail("Unable to get remote VM's mac: %s" % res) else: vm_mac = res[-1].split()[-1] return vm_mac def create_fake_tap(remote_session): """ Create a fake macvtap on destination host. :param remote_session: The session to the destination host. :return: The new tap device """ tap_cmd = "ls /dev/tap* |awk -F 'tap' '{print $NF}'" tap_idx = remote_session.cmd_output(tap_cmd).strip() if not tap_idx: test.fail("Unable to get tap index using %s." % tap_cmd) fake_tap_dest = 'tap'+str(int(tap_idx)+1) logging.debug("creating a fake tap %s...", fake_tap_dest) cmd = "touch /dev/%s" % fake_tap_dest remote_session.cmd(cmd) return fake_tap_dest migration_test = migration.MigrationTest() migration_test.check_parameters(params) libvirt_version.is_libvirt_feature_supported(params) # 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} 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") virsh_options = params.get("virsh_options", "") extra = params.get("virsh_migrate_extra") options = params.get("virsh_migrate_options", "--live --p2p --verbose") restart_dhclient = params.get("restart_dhclient", "dhclient -r; dhclient") ping_dest = params.get("ping_dest", "www.baidu.com") extra_args = migration_test.update_virsh_migrate_extra_args(params) migrate_vm_back = "yes" == params.get("migrate_vm_back", "no") target_vm_name = params.get("target_vm_name") direct_mode = "yes" == params.get("direct_mode", "no") check_macvtap_exists = "yes" == params.get("check_macvtap_exists", "no") create_fake_tap_dest = "yes" == params.get("create_fake_tap_dest", "no") macvtap_cmd = params.get("macvtap_cmd") modify_target_vm = "yes" == params.get("modify_target_vm", "no") ovs_bridge_name = params.get("ovs_bridge_name") network_dict = eval(params.get("network_dict", '{}')) iface_dict = eval(params.get("iface_dict", '{}')) remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user, 'remote_pwd': server_pwd, 'unprivileged_user': None, 'ssh_remote_auth': True} cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd} virsh_session_remote = None libvirtd_conf = None mig_result = None target_org_xml = None target_vm_session = None target_vm = None exp_macvtap = [] fake_tap_dest = None # 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() bk_uri = vm.connect_uri postcopy_options = params.get("postcopy_options") action_during_mig = None if postcopy_options: extra = "%s %s" % (extra, postcopy_options) action_during_mig = virsh.migrate_postcopy # 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() try: # Create a remote runner for later use runner_on_target = remote.RemoteRunner(host=server_ip, username=server_user, password=server_pwd) remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs) if target_vm_name: target_vm = libvirt_vm.VM(target_vm_name, params, vm.root_dir, vm.address_cache) target_vm.connect_uri = dest_uri if not virsh_session_remote.domain_exists(target_vm_name): test.error("VM %s should be installed on %s." % (target_vm_name, server_ip)) # Backup guest's xml on remote target_org_xml = vm_xml.VMXML.new_from_inactive_dumpxml( target_vm_name, virsh_instance=virsh_session_remote) # Scp original xml to remote for restoration remote.scp_to_remote(server_ip, '22', server_user, server_pwd, target_org_xml.xml, target_org_xml.xml) logging.debug("target xml is %s" % target_org_xml) if ovs_bridge_name: status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name) if status: test.fail("Failed to create ovs bridge on local. Status: %s" "Stdout: %s" % (status, stdout)) status, stdout = utils_net.create_ovs_bridge( ovs_bridge_name, session=remote_session) if status: test.fail("Failed to create ovs bridge on remote. Status: %s" "Stdout: %s" % (status, stdout)) if network_dict: update_net_dict(network_dict, runner=remote_session.cmd) libvirt_network.create_or_del_network( network_dict, remote_args=remote_virsh_dargs) logging.info("dest: network created") update_net_dict(network_dict) libvirt_network.create_or_del_network(network_dict) logging.info("localhost: network created") if target_vm_name: if modify_target_vm and iface_dict: logging.info("Updating remote VM's interface") update_iface_xml(target_vm_name, iface_dict, virsh_instance=virsh_session_remote) target_vm.start() target_vm_session = target_vm.wait_for_serial_login(timeout=240) check_vm_network_accessed(ping_dest, session=target_vm_session) if check_macvtap_exists and macvtap_cmd: # Get macvtap device's index on remote after target_vm started idx = remote_session.cmd_output(macvtap_cmd).strip() if not idx: test.fail("Unable to get macvtap index using %s." % macvtap_cmd) # Generate the expected macvtap devices' index list exp_macvtap = ['macvtap'+idx, 'macvtap'+str(int(idx)+1)] if create_fake_tap_dest: fake_tap_dest = create_fake_tap(remote_session) remote_session.close() # Change domain network xml if iface_dict: if "mac" not in iface_dict: mac = utils_net.generate_mac_address_simple() iface_dict.update({'mac': mac}) else: mac = iface_dict["mac"] update_iface_xml(vm_name, iface_dict) # Change the disk of the vm libvirt.set_vm_disk(vm, params) if not vm.is_alive(): try: vm.start() except virt_vm.VMStartError as err: test.fail("Failed to start VM: %s" % err) logging.debug("Guest xml after starting:\n%s", vm_xml.VMXML.new_from_dumpxml(vm_name)) # Check local guest network connection before migration if vm.serial_console is not None: vm.cleanup_serial_console() vm.create_serial_console() vm_session = vm.wait_for_serial_login(timeout=240) if not utils_package.package_install('dhcp-client', session=vm_session): test.error("Failed to install dhcp-client on guest.") utils_net.restart_guest_network(vm_session) vm_ip = utils_net.get_guest_ip_addr(vm_session, mac) logging.debug("VM IP Addr: %s", vm_ip) if direct_mode: check_vm_network_accessed(ping_dest, session=vm_session) else: check_vm_network_accessed(vm_ip) # 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, func=action_during_mig, extra_opts=extra, **extra_args) mig_result = migration_test.ret # Check network accessibility after migration if int(mig_result.exit_status) == 0: vm.connect_uri = dest_uri if vm.serial_console is not None: vm.cleanup_serial_console() vm.create_serial_console() vm_session_after_mig = vm.wait_for_serial_login(timeout=240) vm_session_after_mig.cmd(restart_dhclient) check_vm_network_accessed(ping_dest, session=vm_session_after_mig) if check_macvtap_exists and macvtap_cmd: remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') # Check macvtap devices' index after migration idx = remote_session.cmd_output(macvtap_cmd) act_macvtap = ['macvtap'+i for i in idx.strip().split("\n")] if act_macvtap != exp_macvtap: test.fail("macvtap devices after migration are incorrect!" " Actual: %s, Expected: %s. " % (act_macvtap, exp_macvtap)) else: if fake_tap_dest: res = remote.run_remote_cmd("ls /dev/%s" % fake_tap_dest, params, runner_on_target) libvirt.check_exit_status(res) if target_vm_session: check_vm_network_accessed(ping_dest, session=target_vm_session) # Execute migration from remote if migrate_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, 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)) logging.debug("VM is migrated back.") vm.connect_uri = bk_uri if vm.serial_console is not None: vm.cleanup_serial_console() vm.create_serial_console() vm_session_after_mig_bak = vm.wait_for_serial_login(timeout=240) vm_session_after_mig_bak.cmd(restart_dhclient) check_vm_network_accessed(ping_dest, vm_session_after_mig_bak) finally: logging.debug("Recover test environment") vm.connect_uri = bk_uri migration_test.cleanup_vm(vm, dest_uri) logging.info("Recovery VM XML configration") orig_config_xml.sync() remote_session = remote.remote_login("ssh", server_ip, "22", server_user, server_pwd, r'[$#%]') if target_vm and target_vm.is_alive(): target_vm.destroy(gracefully=False) if target_org_xml and target_vm_name: logging.info("Recovery XML configration for %s.", target_vm_name) virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs) vm_sync(target_org_xml, vm_name=target_vm_name, virsh_instance=virsh_session_remote) virsh_session_remote.close_session() if fake_tap_dest: remote_session.cmd_output_safe("rm -rf /dev/%s" % fake_tap_dest) if network_dict: libvirt_network.create_or_del_network( network_dict, is_del=True, remote_args=remote_virsh_dargs) libvirt_network.create_or_del_network(network_dict, is_del=True) if ovs_bridge_name: utils_net.delete_ovs_bridge(ovs_bridge_name) utils_net.delete_ovs_bridge(ovs_bridge_name, session=remote_session) remote_session.close() if target_vm_session: target_vm_session.close() if virsh_session_remote: virsh_session_remote.close_session() if migrate_vm_back: if 'ssh_connection' in locals(): ssh_connection.auto_recover = True migration_test.migrate_pre_setup(src_uri, params, cleanup=True) logging.info("Remove local NFS image") source_file = params.get("source_file") if source_file: libvirt.delete_local_disk("file", path=source_file)