feat: migrate builtin EthernetSwitch from Dynamips ethsw to ubridge brctl

Replace the builtin EthernetSwitch stub with a Linux kernel bridge backed by uBridge's brctl module. Each switch node creates one kernel bridge (gns3br{N}) with VLAN filtering; each port is a persistent TAP enslaved to the bridge, relayed by a per-port uBridge bridge (nio_tap <-> nio_udp). - Access/dot1q/qinq port modes translated to brctl vlan primitives - Compute router repointed from Dynamips to Builtin manager - Tests updated: 21 router-level tests + 215 surrounding tests pass - Real-kernel e2e verified: access 100 PVID untagged, dot1q trunk VIDs 1-4094 + native 1, qinq 802.1ad proto + 200 PVID Ethertype 0x9100/0x9200 handling and port-count guard relaxation are deferred pending resolution.
2026-11-03 05:51:15 +02:00 · 2026-07-18 00:21:19 +08:00
1 parent 22a1026633
commit fd4ac4460d
@@ -21,34 +21,48 @@ import pytest_asyncio
 from fastapi import FastAPI, status
 from httpx import AsyncClient
 from tests.utils import asyncio_patch, AsyncioMagicMock
-from unittest.mock import call
+from unittest.mock import call, MagicMock

 from gns3server.compute.project import Project

+# The builtin Ethernet switch talks to uBridge (brctl/bridge modules) instead of
+# the Dynamips hypervisor. These are the seams we stub so the routes can be
+# exercised without launching a real uBridge / creating kernel interfaces.
+_NODE = "gns3server.compute.builtin.nodes.ethernet_switch.EthernetSwitch"
+
 pytestmark = pytest.mark.asyncio


 class TestEthernetSwitchNodesRoutes:

+    @pytest_asyncio.fixture(autouse=True)
+    async def stub_ubridge(self):
+        """Keep uBridge from really starting and capture every command."""
+        with asyncio_patch(f"{_NODE}._start_ubridge"), asyncio_patch(f"{_NODE}._stop_ubridge"), \
+                asyncio_patch(f"{_NODE}._ubridge_send"):
+            yield
+
    @pytest_asyncio.fixture
    async def ethernet_switch(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> dict:

        params = {"name": "Ethernet Switch"}
-        with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock:
-            response = await compute_client.post(
-                app.url_path_for("compute:create_ethernet_switch", project_id=compute_project.id),
-                json=params
-            )
-            assert mock.called
-            assert response.status_code == status.HTTP_201_CREATED
+        response = await compute_client.post(
+            app.url_path_for("compute:create_ethernet_switch", project_id=compute_project.id),
+            json=params
+        )
+        assert response.status_code == status.HTTP_201_CREATED

        json_response = response.json()
        node = compute_project.get_node(json_response["node_id"])
-        node._hypervisor = AsyncioMagicMock()
-        node._hypervisor.send = AsyncioMagicMock()
-        node._hypervisor.version = "0.2.16"
+        # Pretend uBridge is up so the is_running() guards in remove/close pass.
+        node._ubridge_hypervisor = MagicMock()
+        node._ubridge_hypervisor.is_running.return_value = True
+        node._ubridge_send.reset_mock()
        return json_response

+    @staticmethod
+    def _udp_params() -> dict:
+        return {"type": "nio_udp", "lport": 4242, "rport": 4343, "rhost": "127.0.0.1"}

    async def test_ethernet_switch_create(
            self, app: FastAPI,
@@ -57,16 +71,22 @@ class TestEthernetSwitchNodesRoutes:
    ) -> None:

        params = {"name": "Ethernet Switch 1"}
-        with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock:
-            response = await compute_client.post(
-                app.url_path_for("compute:create_ethernet_switch", project_id=compute_project.id),
-                json=params
-            )
-            assert mock.called
-            assert response.status_code == status.HTTP_201_CREATED
-            assert response.json()["name"] == "Ethernet Switch 1"
-            assert response.json()["project_id"] == compute_project.id
+        response = await compute_client.post(
+            app.url_path_for("compute:create_ethernet_switch", project_id=compute_project.id),
+            json=params
+        )
+        assert response.status_code == status.HTTP_201_CREATED
+        assert response.json()["name"] == "Ethernet Switch 1"
+        assert response.json()["project_id"] == compute_project.id
+        assert response.json()["status"] == "started"

+        # creation stands up the kernel bridge with VLAN filtering
+        node = compute_project.get_node(response.json()["node_id"])
+        br = node._bridge_name
+        node._ubridge_send.assert_has_calls([
+            call(f'brctl create "{br}"'),
+            call(f'brctl vlanfiltering "{br}" on'),
+        ])

    async def test_ethernet_switch_get(
            self, app: FastAPI,
@@ -87,7 +107,6 @@ class TestEthernetSwitchNodesRoutes:
        assert response.json()["project_id"] == compute_project.id
        assert response.json()["status"] == "started"

-
    async def test_ethernet_switch_duplicate(
            self,
            app: FastAPI,
@@ -98,15 +117,11 @@ class TestEthernetSwitchNodesRoutes:

        # create destination switch first
        params = {"name": "Ethernet Switch 2"}
-        with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock:
-            response = await compute_client.post(
-                app.url_path_for(
-                    "compute:create_ethernet_switch",
-                    project_id=compute_project.id),
-                json=params
-            )
-            assert mock.called
-            assert response.status_code == status.HTTP_201_CREATED
+        response = await compute_client.post(
+            app.url_path_for("compute:create_ethernet_switch", project_id=compute_project.id),
+            json=params
+        )
+        assert response.status_code == status.HTTP_201_CREATED

        params = {"destination_node_id": response.json()["node_id"]}
        response = await compute_client.post(
@@ -117,7 +132,6 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_201_CREATED

-
    async def test_ethernet_switch_update(
            self,
            app: FastAPI,
@@ -126,10 +140,7 @@ class TestEthernetSwitchNodesRoutes:
            ethernet_switch: dict
    ) -> None:

-        params = {
-            "name": "test",
-            "console_type": "telnet"
-        }
+        params = {"name": "test", "console_type": "none"}

        response = await compute_client.put(
            app.url_path_for(
@@ -141,11 +152,12 @@ class TestEthernetSwitchNodesRoutes:

        assert response.status_code == status.HTTP_200_OK
        assert response.json()["name"] == "test"
+        # renaming a builtin switch does not touch uBridge (the kernel bridge is
+        # name-independent); nothing should have been sent.
        node = compute_project.get_node(ethernet_switch["node_id"])
-        node._hypervisor.send.assert_called_with("ethsw rename \"Ethernet Switch\" \"test\"")
+        node._ubridge_send.assert_not_called()

-
-    async def test_ethernet_switch_update_ports(
+    async def test_ethernet_switch_update_ports_qinq_proto(
            self,
            app: FastAPI,
            compute_client: AsyncClient,
@@ -153,33 +165,11 @@ class TestEthernetSwitchNodesRoutes:
            ethernet_switch: dict
    ) -> None:

+        # a QinQ port with the 802.1ad ethertype must switch the bridge protocol
        port_params = {
            "ports_mapping": [
-                {
-                    "name": "Ethernet0",
-                    "port_number": 0,
-                    "type": "qinq",
-                    "vlan": 1
-                },
-                {
-                    "name": "Ethernet1",
-                    "port_number": 1,
-                    "type": "qinq",
-                    "vlan": 2,
-                    "ethertype": "0x88A8"
-                },
-                {
-                    "name": "Ethernet2",
-                    "port_number": 2,
-                    "type": "dot1q",
-                    "vlan": 3,
-                },
-                {
-                    "name": "Ethernet3",
-                    "port_number": 3,
-                    "type": "access",
-                    "vlan": 4,
-                }
+                {"name": "Ethernet0", "port_number": 0, "type": "qinq", "vlan": 2, "ethertype": "0x88A8"},
+                {"name": "Ethernet1", "port_number": 1, "type": "access", "vlan": 4},
            ],
        }

@@ -192,90 +182,20 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_200_OK

-        nio_params = {
-            "type": "nio_udp",
-            "lport": 4242,
-            "rport": 4343,
-            "rhost": "127.0.0.1"
-        }
-
-        for port_mapping in port_params["ports_mapping"]:
-            port_number = port_mapping["port_number"]
-            vlan = port_mapping["vlan"]
-            port_type = port_mapping["type"]
-            ethertype = port_mapping.get("ethertype", "")
-            url = app.url_path_for(
-                "compute:create_ethernet_switch_nio",
-                project_id=ethernet_switch["project_id"],
-                node_id=ethernet_switch["node_id"],
-                adapter_number="0",
-                port_number=f"{port_number}"
-            )
-            await compute_client.post(url, json=nio_params)
-
-            node = compute_project.get_node(ethernet_switch["node_id"])
-            nio = node.get_nio(port_number)
-            calls = [
-                call.send(f'nio create_udp {nio.name} 4242 127.0.0.1 4343'),
-                call.send(f'ethsw add_nio "Ethernet Switch" {nio.name}'),
-                call.send(f'ethsw set_{port_type}_port "Ethernet Switch" {nio.name} {vlan} {ethertype}'.strip())
-            ]
-            node._hypervisor.send.assert_has_calls(calls)
-            node._hypervisor.send.reset_mock()
-
+        node = compute_project.get_node(ethernet_switch["node_id"])
+        node._ubridge_send.assert_any_call(f'brctl setvlanproto "{node._bridge_name}" 0x88a8')

    @pytest.mark.parametrize(
        "ports_settings",
        (
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "dot42q",  # invalid port type
-                            "vlan": 1,
-                        }
-                ),
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "access",  # missing vlan field
-                        }
-                ),
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "dot1q",
-                            "vlan": 1,
-                            "ethertype": "0x88A8"  # EtherType is only for QinQ
-                        }
-                ),
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "qinq",
-                            "vlan": 1,
-                            "ethertype": "0x4242"  # not a valid EtherType
-                        }
-                ),
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "access",
-                            "vlan": 0,  # minimum vlan number is 1
-                        }
-                ),
-                (
-                        {
-                            "name": "Ethernet0",
-                            "port_number": 0,
-                            "type": "access",
-                            "vlan": 4242,  # maximum vlan number is 4094
-                        }
-                ),
+                {"name": "Ethernet0", "port_number": 0, "type": "dot42q", "vlan": 1},          # bad type
+                {"name": "Ethernet0", "port_number": 0, "type": "access"},                     # missing vlan
+                {"name": "Ethernet0", "port_number": 0, "type": "dot1q", "vlan": 1,
+                 "ethertype": "0x88A8"},                                                       # ethertype only for qinq
+                {"name": "Ethernet0", "port_number": 0, "type": "qinq", "vlan": 1,
+                 "ethertype": "0x4242"},                                                        # bad ethertype
+                {"name": "Ethernet0", "port_number": 0, "type": "access", "vlan": 0},          # vlan < 1
+                {"name": "Ethernet0", "port_number": 0, "type": "access", "vlan": 4242},       # vlan > 4094
        )
    )
    async def test_ethernet_switch_update_ports_invalid(
@@ -286,20 +206,15 @@ class TestEthernetSwitchNodesRoutes:
            ports_settings: dict,
    ) -> None:

-        port_params = {
-            "ports_mapping": [ports_settings]
-        }
-
        response = await compute_client.put(
            app.url_path_for(
                "compute:update_ethernet_switch",
                project_id=ethernet_switch["project_id"],
                node_id=ethernet_switch["node_id"]),
-            json=port_params
+            json={"ports_mapping": [ports_settings]}
        )
        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT

-
    async def test_ethernet_switch_delete(
            self, app: FastAPI,
            compute_client: AsyncClient,
@@ -315,12 +230,7 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_204_NO_CONTENT

-
-    async def test_ethernet_switch_start(
-            self, app: FastAPI,
-            compute_client: AsyncClient,
-            ethernet_switch: dict
-    ) -> None:
+    async def test_ethernet_switch_start(self, app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None:

        response = await compute_client.post(
            app.url_path_for(
@@ -331,12 +241,7 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED

-
-    async def test_ethernet_switch_stop(
-            self, app: FastAPI,
-            compute_client: AsyncClient,
-            ethernet_switch: dict
-    ) -> None:
+    async def test_ethernet_switch_stop(self, app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None:

        response = await compute_client.post(
            app.url_path_for(
@@ -347,12 +252,7 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED

-
-    async def test_ethernet_switch_suspend(
-            self, app: FastAPI,
-            compute_client: AsyncClient,
-            ethernet_switch: dict
-    ) -> None:
+    async def test_ethernet_switch_suspend(self, app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None:

        response = await compute_client.post(
            app.url_path_for(
@@ -363,12 +263,7 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED

-
-    async def test_ethernet_switch_reload(
-            self, app: FastAPI,
-            compute_client: AsyncClient,
-            ethernet_switch: dict
-    ) -> None:
+    async def test_ethernet_switch_reload(self, app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None:

        response = await compute_client.post(
            app.url_path_for(
@@ -379,8 +274,7 @@ class TestEthernetSwitchNodesRoutes:
        )
        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED

-
-    async def test_ethernet_switch_create_udp(
+    async def test_ethernet_switch_create_udp_access(
            self,
            app: FastAPI,
            compute_client: AsyncClient,
@@ -388,13 +282,6 @@ class TestEthernetSwitchNodesRoutes:
            ethernet_switch: dict
    ) -> None:

-        params = {
-            "type": "nio_udp",
-            "lport": 4242,
-            "rport": 4343,
-            "rhost": "127.0.0.1"
-        }
-
        url = app.url_path_for(
            "compute:create_ethernet_switch_nio",
            project_id=ethernet_switch["project_id"],
@@ -402,19 +289,66 @@ class TestEthernetSwitchNodesRoutes:
            adapter_number="0",
            port_number="0"
        )
-        response = await compute_client.post(url, json=params)
+        response = await compute_client.post(url, json=self._udp_params())
        assert response.status_code == status.HTTP_201_CREATED
        assert response.json()["type"] == "nio_udp"

        node = compute_project.get_node(ethernet_switch["node_id"])
        nio = node.get_nio(0)
-        calls = [
-            call.send(f'nio create_udp {nio.name} 4242 127.0.0.1 4343'),
-            call.send(f'ethsw add_nio "Ethernet Switch" {nio.name}'),
-            call.send(f'ethsw set_access_port "Ethernet Switch" {nio.name} 1')
-        ]
-        node._hypervisor.send.assert_has_calls(calls)
+        br = node._bridge_name
+        tap = f"{br}-0"
+        relay = f"{node.id}-0"
+        # access VLAN 1 (default): drop default PVID 1, re-add 1 as PVID/untagged
+        node._ubridge_send.assert_has_calls([
+            call(f"bridge create {relay}"),
+            call(f'bridge add_nio_tap {relay} "{tap}"'),
+            call(f'brctl addif "{br}" "{tap}"'),
+            call(f'brctl vlan_del "{br}" "{tap}" 1'),
+            call(f'brctl vlan_add "{br}" "{tap}" 1 pvid untagged'),
+            call(f"bridge add_nio_udp {relay} {nio.lport} {nio.rhost} {nio.rport}"),
+            call(f"bridge reset_packet_filters {relay}"),
+            call(f"bridge start {relay}"),
+        ])

+    async def test_ethernet_switch_create_udp_dot1q(
+            self,
+            app: FastAPI,
+            compute_client: AsyncClient,
+            compute_project: Project,
+            ethernet_switch: dict
+    ) -> None:
+
+        # make port 0 a dot1q trunk with native VLAN 10
+        await compute_client.put(
+            app.url_path_for(
+                "compute:update_ethernet_switch",
+                project_id=ethernet_switch["project_id"],
+                node_id=ethernet_switch["node_id"]),
+            json={"ports_mapping": [
+                {"name": "Ethernet0", "port_number": 0, "type": "dot1q", "vlan": 10},
+            ]}
+        )
+        node = compute_project.get_node(ethernet_switch["node_id"])
+        node._ubridge_send.reset_mock()
+
+        url = app.url_path_for(
+            "compute:create_ethernet_switch_nio",
+            project_id=ethernet_switch["project_id"],
+            node_id=ethernet_switch["node_id"],
+            adapter_number="0",
+            port_number="0"
+        )
+        response = await compute_client.post(url, json=self._udp_params())
+        assert response.status_code == status.HTTP_201_CREATED
+
+        br = node._bridge_name
+        tap = f"{br}-0"
+        # trunk: drop default 1, admit all VIDs tagged, mark native 10 PVID/untagged
+        node._ubridge_send.assert_has_calls([
+            call(f'brctl vlan_del "{br}" "{tap}" 1'),
+            call(f'brctl vlan_add "{br}" "{tap}" 1 vid 4094'),
+            call(f'brctl vlan_add "{br}" "{tap}" 10 pvid untagged'),
+        ])

    async def test_ethernet_switch_delete_nio(
            self,
@@ -424,13 +358,6 @@ class TestEthernetSwitchNodesRoutes:
            ethernet_switch: dict
    ) -> None:

-        params = {
-            "type": "nio_udp",
-            "lport": 4242,
-            "rport": 4343,
-            "rhost": "127.0.0.1"
-        }
-
        url = app.url_path_for(
            "compute:create_ethernet_switch_nio",
            project_id=ethernet_switch["project_id"],
@@ -438,11 +365,10 @@ class TestEthernetSwitchNodesRoutes:
            adapter_number="0",
            port_number="0"
        )
-        await compute_client.post(url, json=params)
+        await compute_client.post(url, json=self._udp_params())

        node = compute_project.get_node(ethernet_switch["node_id"])
-        node._hypervisor.send.reset_mock()
-        nio = node.get_nio(0)
+        node._ubridge_send.reset_mock()

        url = app.url_path_for(
            "compute:delete_ethernet_switch_nio",
@@ -454,52 +380,86 @@ class TestEthernetSwitchNodesRoutes:
        response = await compute_client.delete(url)
        assert response.status_code == status.HTTP_204_NO_CONTENT

-        calls = [
-            call(f'ethsw remove_nio "Ethernet Switch" {nio.name}'),
-            call(f'nio delete {nio.name}')
-        ]
-        node._hypervisor.send.assert_has_calls(calls)
-
+        br = node._bridge_name
+        tap = f"{br}-0"
+        relay = f"{node.id}-0"
+        node._ubridge_send.assert_has_calls([
+            call(f'brctl delif "{br}" "{tap}"'),
+            call(f"bridge delete {relay}"),
+        ])

    async def test_ethernet_switch_start_capture(
            self,
            app: FastAPI,
            compute_client: AsyncClient,
+            compute_project: Project,
            ethernet_switch: dict
    ) -> None:

-        params = {
-            "capture_file_name": "test.pcap",
-            "data_link_type": "DLT_EN10MB"
-        }
+        # capture needs a wired port
+        url = app.url_path_for(
+            "compute:create_ethernet_switch_nio",
+            project_id=ethernet_switch["project_id"],
+            node_id=ethernet_switch["node_id"],
+            adapter_number="0",
+            port_number="0"
+        )
+        await compute_client.post(url, json=self._udp_params())

+        node = compute_project.get_node(ethernet_switch["node_id"])
+        node._ubridge_send.reset_mock()
+
+        params = {"capture_file_name": "test.pcap", "data_link_type": "DLT_EN10MB"}
        url = app.url_path_for("compute:start_ethernet_switch_capture",
                               project_id=ethernet_switch["project_id"],
                               node_id=ethernet_switch["node_id"],
                               adapter_number="0",
                               port_number="0")

-        with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.start_capture") as mock:
-            response = await compute_client.post(url, json=params)
-            assert response.status_code == status.HTTP_200_OK
-            assert mock.called
-            assert "test.pcap" in response.json()["pcap_file_path"]
-
+        response = await compute_client.post(url, json=params)
+        assert response.status_code == status.HTTP_200_OK
+        assert "test.pcap" in response.json()["pcap_file_path"]
+        relay = f"{node.id}-0"
+        node._ubridge_send.assert_any_call(f'bridge start_capture {relay} "{node.get_nio(0).pcap_output_file}"')

    async def test_ethernet_switch_stop_capture(
            self,
            app: FastAPI,
            compute_client: AsyncClient,
+            compute_project: Project,
            ethernet_switch: dict
    ) -> None:

-        url = app.url_path_for("compute:stop_ethernet_switch_capture",
-                               project_id=ethernet_switch["project_id"],
-                               node_id=ethernet_switch["node_id"],
-                               adapter_number="0",
-                               port_number="0")
+        # start a capture first
+        await compute_client.post(
+            app.url_path_for(
+                "compute:create_ethernet_switch_nio",
+                project_id=ethernet_switch["project_id"],
+                node_id=ethernet_switch["node_id"],
+                adapter_number="0",
+                port_number="0"
+            ),
+            json=self._udp_params()
+        )
+        await compute_client.post(
+            app.url_path_for("compute:start_ethernet_switch_capture",
+                             project_id=ethernet_switch["project_id"],
+                             node_id=ethernet_switch["node_id"],
+                             adapter_number="0",
+                             port_number="0"),
+            json={"capture_file_name": "test.pcap", "data_link_type": "DLT_EN10MB"}
+        )

-        with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.stop_capture") as mock:
-            response = await compute_client.post(url)
-            assert response.status_code == status.HTTP_204_NO_CONTENT
-            assert mock.called
+        node = compute_project.get_node(ethernet_switch["node_id"])
+        node._ubridge_send.reset_mock()
+        relay = f"{node.id}-0"
+
+        response = await compute_client.post(
+            app.url_path_for("compute:stop_ethernet_switch_capture",
+                             project_id=ethernet_switch["project_id"],
+                             node_id=ethernet_switch["node_id"],
+                             adapter_number="0",
+                             port_number="0")
+        )
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+        node._ubridge_send.assert_any_call(f"bridge stop_capture {relay}")