add case for migrating guest with bridge interface

nanli1 · nanli1 · commit 489a1e6478f8 · 2025-09-08T19:08:50.000+08:00
xxxx-299038: [bridge] migrate guest with bridge type interface
Signed-off-by: nanli &lt;nanli@redhat.com&gt;
diff --git a/libvirt/tests/cfg/virtual_network/migrate/migrate_with_bridge_type_interface.cfg b/libvirt/tests/cfg/virtual_network/migrate/migrate_with_bridge_type_interface.cfg
@@ -0,0 +1,64 @@
+- virtual_network.migrate_with_bridge_type_interface:
+    type = migrate_with_bridge_type_interface
+    start_vm = "yes"
+    only_pty = True
+    take_regular_screendumps = no
+    ssh_timeout = 60
+    migration_setup = "yes"
+    storage_type = 'nfs'
+    setup_local_nfs = 'yes'
+    virsh_migrate_dest_state = running
+    virsh_migrate_src_state = running
+    virsh_migrate_options = "--live --p2p --verbose"
+    virsh_migrate_connect_uri = "qemu:///system"
+    migrate_vm_back = "yes"
+    bridge_name = "br0"
+    remote_ip = "www.google.com"
+    ping_count = 3
+    ping_timeout = 10
+    server_user = "root"
+    virsh_options = ""
+    iface_model = "virtio"
+    iface_queues = "5"
+    new_queues = "3"
+    disk_type = "file"
+    disk_source_protocol = "netfs"
+    ssh_remote_auth = True
+    unprivileged_user = ""
+    #migrate_dest_host = "EXAMPLE.DEST.HOST"
+    #migrate_source_host = "EXAMPLE.SOURCE.HOST"
+    migrate_dest_host = "dell-per750-63.lab.eng.pek2.redhat.com"
+    migrate_source_host = "dell-per750-62.lab.eng.pek2.redhat.com"
+    migrate_main_vm = "${main_vm}"
+    vm_ping_outside = "pass"
+    expected_xpath = "//interface/driver[@queues='${iface_queues}']"
+    variants:
+        - linux_bridge:
+            bridge_type = "linux"
+            iface_type = "bridge"
+            iface_source = "{'bridge':'${bridge_name}', 'type':'${iface_type}', 'model':'${iface_model}', 'driver':{'queues':'${iface_queues}'}}"
+        - ovs_bridge:
+            bridge_type = "ovs"
+            ovs_bridge_name = "ovsbr0"
+            network_dict = {'bridge': {'name': '${ovs_bridge_name}'}, 'forward': {'mode': 'bridge'}, 'name': 'ovs-net', 'virtualport_type': 'openvswitch'}
+            iface_type = "network"
+            iface_source = "{'network': 'ovs-net', 'type':'${iface_type}', 'model':'${iface_model}', 'driver':{'queues':'${iface_queues}'}}"
+    variants:
+        - precopy_migration:
+            migration_type = "precopy"
+            virsh_migrate_extra = ""
+        - postcopy_migration:
+            migration_type = "postcopy"
+            virsh_migrate_extra = "--postcopy"
+        - cancel_migration:
+            migration_type = "cancel"
+            cancel_migration = "yes"
+            virsh_migrate_extra = ""
+    variants:
+        - start_with_interface:
+            interface_timing = "start"
+        - hotplug_interface:
+            interface_timing = "hotplug"
+            hotplug = "yes"
+            attach_interface = "yes"
+            iface_model = "virtio"
diff --git a/libvirt/tests/src/virtual_network/migrate/migrate_with_bridge_type_interface.py b/libvirt/tests/src/virtual_network/migrate/migrate_with_bridge_type_interface.py
@@ -0,0 +1,273 @@
+import re
+
+
+from virttest import libvirt_version
+from virttest import libvirt_vm
+from virttest import migration
+from virttest import remote
+from virttest import utils_net
+from virttest import utils_package
+from virttest import virsh
+from provider.guest_os_booting import guest_os_booting_base as guest_os
+
+from virttest.libvirt_xml import vm_xml
+from virttest.utils_test import libvirt
+from virttest.utils_libvirt import libvirt_network
+from virttest.utils_libvirt import libvirt_vmxml
+from provider.virtual_network import network_base
+from provider.interface import interface_base
+from provider.migration import base_steps
+
+
+
+def run(test, params, env):
+    """
+    Test migration with bridge type interface
+    1. Setup bridge and virtual network according to bridge type
+    2. Migrate to target host
+    3. Check on target host for network functions:
+       - Guest ping outside
+       - Check for multiqueue
+       - Check multiqueues in VM live XML (should have <driver ... queues='5'>)
+    4. Migrate back from dst to src
+
+    :param test: test object
+    :param params: Dictionary with the test parameters
+    :param env: Dictionary with test environment.
+    """
+    def check_multiqueue_in_guest(vm_session):
+        """
+        Check multiqueue configuration inside the guest
+        """
+        test.log.info("Checking multiqueue configuration in guest")
+        # Get network interface name
+        guest_iface_info = vm_session.cmd_output("ip --color=never l").strip()
+        iface_name = re.findall(
+            r"^\d+: (\S+?)[@:].*state UP.*$", guest_iface_info, re.MULTILINE)[0]
+        if not iface_name:
+            test.fail("Failed to get network interface name in guest")
+
+        maximum, current = utils_net.get_channel_info(vm_session, iface_name)
+        if maximum.get("Combined", 0) != iface_queues:
+            test.fail("Expected Pre-set maximums Combined: 5, but got: %d" % maximum)
+        if current.get("Combined", 0) != iface_queues:
+            test.fail("Expected Current hardware settings Combined: 5, but got: %d" % current)
+
+        test.log.info("Setting combined queues to 3 for %s", iface_name)
+        utils_net.set_channel(vm_session, iface_name, "combined", new_queues)
+
+        _, verify_current = utils_net.get_channel_info(vm_session, iface_name).get("Combined", 0)
+        if verify_current != new_queues:
+            test.fail("Failed to set combined queues, current value: %d" % verify_current)
+
+    def setup_vm_interface():
+        """
+        Setup VM interface according to configuration
+        """
+        test.log.info("Setting up VM interface")
+        
+        # Get interface configuration from params
+        if interface_timing == "hotplug":
+            # Hot-plug interface using helper function
+            iface_xml = libvirt.modify_vm_iface(vm_name, "get_xml", iface_dict)
+            if not vm.is_alive():
+                vm.start()
+            vm.wait_for_login()
+            result = virsh.attach_device(vm_name, iface_xml, flagstr="--live", debug=True)
+            if result.exit_status:
+                test.fail("Failed to hotplug interface: %s" % result.stderr_text)
+        else:
+            # Add interface to XML using setup_attrs pattern
+            vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
+            vmxml.remove_all_device_by_type('interface')
+            
+            iface = interface_base.create_iface(iface_dict['type'], iface_dict)
+            vmxml.add_device(iface)
+            vmxml.sync()
+
+
+    def setup_test():
+        """
+        Setup test environment for migration with bridge type interface
+        """
+        test.log.info("Setting up test environment")
+        if bridge_type == "linux":
+            pass
+            # utils_net.create_linux_bridge_tmux(bridge_name)
+            # utils_net.create_linux_bridge_tmux(bridge_name, session=remote_session)
+
+        elif bridge_type == "ovs":
+            # Create OVS bridge
+            status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name, ip_options='-color=never')
+            if status:
+                test.fail("Failed to create ovs bridge on local. Status: %s, Stdout: %s" % (status, stdout))
+                
+            # Create same bridge on remote host
+            status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name, session=remote_session, ip_options='-color=never')
+            if status:
+                test.fail("Failed to create ovs bridge on remote. Status: %s, Stdout: %s" % (status, stdout))
+                
+            # Create virtual network for OVS bridge
+            libvirt_network.create_or_del_network(network_dict, remote_args=remote_virsh_dargs)
+            test.log.info("dest: network created")
+            libvirt_network.create_or_del_network(network_dict)
+            test.log.info("localhost: network created")
+
+        # Setup NFS shared storage for migration
+        migration_test.migrate_pre_setup(dest_uri, params)
+        
+        libvirt.set_vm_disk(vm, params)
+        setup_vm_interface()
+        
+        test.log.debug("Guest xml after starting:\n%s", vm_xml.VMXML.new_from_dumpxml(vm_name))
+
+    def run_test():
+        """
+        Run the main test: migration and verification
+        """
+        test.log.info("Starting migration test")
+
+        # 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)
+        
+        test.log.info("Checking VM network connectivity before migration")
+        ips = {'outside_ip': remote_ip}
+        network_base.ping_check(params, ips, vm_session)
+        
+        test.log.info("Migrating VM to target host")
+        migration_obj = base_steps.MigrationBase(test, vm, params)
+        migration_obj.setup_connection()
+        migration_obj.run_migration()
+            
+        test.log.info("Checking VM network connectivity on target host")
+        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("dhclient -r; dhclient")
+
+        test.log.info("Testing guest ping to outside")
+        ips = {'outside_ip': remote_ip}
+        network_base.ping_check(params, ips, vm_session_after_mig)
+        
+        test.log.info("Checking multiqueue in guest")
+        check_multiqueue_in_guest(vm_session_after_mig)
+        
+        test.log.info("Checking multiqueue in VM XML")
+        libvirt_vmxml.check_guest_xml_by_xpaths(
+            vm_xml.VMXML.new_from_dumpxml(vm_name, virsh_instance=virsh_session_remote),
+            expected_xpath)
+        
+        if migrate_vm_back:
+            test.log.info("Migrating VM back to source host")
+            migration_obj = base_steps.MigrationBase(test, vm, params)
+            migration_obj.run_migration_back()
+
+    def teardown_test():
+        """
+        Cleanup test environment
+        """
+        test.log.info("Cleaning up test environment")
+        vm.connect_uri = bk_uri
+        migration_test.cleanup_vm(vm, dest_uri)
+
+        # Recovery VM XML configuration
+        test.log.info("Recovery VM XML configuration")
+        orig_config_xml.sync()
+
+        # Cleanup bridges
+        if bridge_type == "linux":
+            pass
+            # utils_net.delete_linux_bridge_tmux(bridge_name)
+            # utils_net.delete_linux_bridge_tmux(bridge_name, session=remote_session)
+        elif bridge_type == "ovs":
+            utils_net.delete_ovs_bridge(ovs_bridge_name, ip_options='-color=never')
+            utils_net.delete_ovs_bridge(ovs_bridge_name, session=remote_session, ip_options='-color=never')
+
+            # Cleanup networks
+            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 migrate_vm_back:
+            ssh_connection = None
+            if 'ssh_connection' in locals():
+                ssh_connection.auto_recover = True
+            migration_test.migrate_pre_setup(src_uri, params, cleanup=True)
+
+        # Remove local NFS image
+        test.log.info("Remove local NFS image")
+        source_file = params.get("source_file")
+        if source_file:
+            libvirt.delete_local_disk("file", path=source_file)
+
+    # Initialize migration test
+    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"] = params.get("disk_type", "file")
+    params["disk_source_protocol"] = params.get("disk_source_protocol", "netfs")
+    params["mnt_path_name"] = params.get("nfs_mount_dir")
+    
+    # Local variables
+    server_ip = params.get("server_ip")
+    server_user = params.get("server_user")
+    server_pwd = params.get("server_pwd")
+    remote_ip = params.get("remote_ip")
+    bridge_name = params.get("bridge_name")
+    bridge_type = params.get("bridge_type")
+    ovs_bridge_name = params.get("ovs_bridge_name")
+    network_dict = eval(params.get("network_dict", "{}"))
+    interface_timing = params.get("interface_timing")
+    iface_queues = params.get("iface_queues")
+    new_queues = params.get("new_queues")
+
+    migrate_vm_back = "yes" == params.get("migrate_vm_back")
+    
+    remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
+                          'remote_pwd': server_pwd, 'unprivileged_user': params.get("unprivileged_user"),
+                          'ssh_remote_auth': params.get("ssh_remote_auth")}
+    
+    # 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")
+    expected_xpath = params.get("expected_xpath")
+    iface_dict = eval(params.get("iface_dict", "{}"))
+
+    vm_name = guest_os.get_vm(params)
+    vm = env.get_vm(vm_name)
+    vm.verify_alive()
+    bk_uri = vm.connect_uri
+    
+    # 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()
+    
+    # Create remote session and virsh instance
+    remote_session = remote.remote_login("ssh", server_ip, "22",
+                                        server_user, server_pwd, r'[$#%]')
+    virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs)
+
+    try:
+        setup_test()
+        run_test()
+    finally:
+        teardown_test()
+        if remote_session:
+            remote_session.close()
+        if virsh_session_remote:
+            virsh_session_remote.close_session()
