feat: model IOL adapters as 4-port units like the IOU node type

IOL interfaces come in 4-port units (Ethernet0/0-3, Ethernet1/0-3, ...),
addressed like IOU as (adapter_number, port_number 0-3):

- IOLDockerVM builds EthernetAdapter(interfaces=4) per adapter and asks
  the runner for adapters x 4 interfaces (num-eth).
- DockerVM threads port_number through the NIO/capture API (the compute
  routes parsed it from the URL but dropped it); single-port adapters
  keep the historical bridge{N} names and command sequence, multi-port
  adapters get one bridge per port (bridge{a}_{p}).
- The unix-socket NIO wiring addresses sockets flat across adapters:
  adapter x ports-per-adapter + port, so single-port images keep their
  exact socket layout.
- The controller port list for GNS3_IOL_RUNNER docker nodes is generated
  by StandardPortFactory with the IOU naming (Ethernet{segment0}/{port0},
  segment size 4); plain docker nodes keep eth{N}.

tests/compute/docker/test_docker_vm.py

@@ -1198,7 +1198,7 @@ async def test_start(vm, manager, free_console_port, tmpdir):
             await vm.start()
 
     mock_query.assert_called_with("POST", "containers/e90e34656842/start")
-    vm._add_ubridge_connection.assert_called_once_with(nio, 0)
+    vm._add_ubridge_connection.assert_called_once_with(nio, 0, 0)
     assert vm._start_ubridge.called
     assert vm._start_console.called
     assert vm._start_aux.called
@@ -1253,7 +1253,7 @@ async def test_start_namespace_failed(vm, manager, free_console_port):
                                     await vm.start()
 
     mock_query.assert_any_call("POST", "containers/e90e34656842/start")
-    mock_add_ubridge_connection.assert_called_once_with(nio, 0)
+    mock_add_ubridge_connection.assert_called_once_with(nio, 0, 0)
     assert mock_start_ubridge.called
     assert vm.status == "stopped"
 

tests/compute/docker/test_iol_docker_vm.py

@@ -259,7 +259,7 @@ async def test_start_writes_iol_config(compute_project, manager):
     with open(os.path.join(vm.working_dir, "config", "iol-config.json")) as f:
         config = json.load(f)
     assert config["binary"] == "/binary.iol"
-    assert config["num-eth"] == 4
+    assert config["num-eth"] == 16  # 4 adapters, each a 4-port unit
     assert config["num-serial"] == 0
     assert config["local-app"] == 1
     assert config["remote-app"] == 2
@@ -285,7 +285,7 @@ async def test_start_rewrites_config_on_adapter_change(compute_project, manager)
             await vm.start()
 
     with open(os.path.join(vm.working_dir, "config", "iol-config.json")) as f:
-        assert json.load(f)["num-eth"] == 8
+        assert json.load(f)["num-eth"] == 32  # 8 adapters × 4 ports
 
 
 @pytest.mark.asyncio
@@ -460,6 +460,56 @@ async def test_add_ubridge_connection_without_nio_still_wires(compute_project, m
     assert "bridge start" not in flat
 
 
+# ---------------------------------------------------------------------------
+# IOU-style port model — 1 adapter = 4 ethernet ports
+# ---------------------------------------------------------------------------
+
+def test_adapters_are_four_port_units(compute_project, manager):
+
+    vm = _make_vm(compute_project, manager, adapters=2)
+    assert vm.adapters == 2
+    assert len(vm._ethernet_adapters) == 2
+    for adapter in vm._ethernet_adapters:
+        assert adapter.interfaces == 4
+        for port_number in range(4):
+            assert adapter.port_exists(port_number)
+        assert not adapter.port_exists(4)
+
+
+@pytest.mark.asyncio
+async def test_wiring_addresses_ports_within_adapters(compute_project, manager):
+
+    vm = _make_vm(compute_project, manager, adapters=2)
+    _mock_wiring(vm)
+    wiring_dir = _wiring_dir(vm)
+    os.makedirs(wiring_dir, exist_ok=True)
+    # adapter 1, port 2 -> flat interface index 6 (1 * 4 + 2)
+    open(os.path.join(wiring_dir, "s06.sock"), "w").close()
+
+    nio = manager.create_nio({"type": "nio_udp", "lport": 4242, "rport": 4343, "rhost": "127.0.0.1"})
+    await vm._add_ubridge_connection(nio, 1, port_number=2)
+
+    flat = "\n".join(str(c) for c in vm._ubridge_hypervisor.method_calls)
+    assert 'bridge add_nio_unix bridge1_2 ' in flat
+    assert f'"{os.path.join(wiring_dir, "c06.sock")}"' in flat
+    assert f'"{os.path.join(wiring_dir, "s06.sock")}"' in flat
+    assert "add_nio_udp bridge1_2 4242 127.0.0.1 4343" in flat
+    assert vm._ethernet_adapters[1].host_ifc == os.path.join(wiring_dir, "c06.sock")
+
+
+@pytest.mark.asyncio
+async def test_nio_binding_rejects_port_out_of_range(compute_project, manager):
+
+    vm = _make_vm(compute_project, manager, adapters=2)
+    nio = manager.create_nio({"type": "nio_udp", "lport": 4242, "rport": 4343, "rhost": "127.0.0.1"})
+    with pytest.raises(DockerError) as excinfo:
+        await vm.adapter_add_nio_binding(1, nio, port_number=4)
+    assert "Port 4" in str(excinfo.value)
+
+    with pytest.raises(DockerError):
+        await vm.adapter_add_nio_binding(9, nio, port_number=0)
+
+
 # ---------------------------------------------------------------------------
 # Generic GNS3_UNIX_SOCKET_NIO knob on plain VendorDockerVM
 # ---------------------------------------------------------------------------

tests/controller/test_node.py

@@ -46,6 +46,32 @@ def node(compute, project):
     return node
 
 
+def test_docker_iol_ports_grouped_in_four_port_units(compute, project):
+    """
+    IOL docker nodes (GNS3_IOL_RUNNER) model adapters as 4-port units: ports
+    are Ethernet0/0-3, Ethernet1/0-3, … addressed (adapter, port 0-3), like
+    the native IOU node type. Plain docker nodes keep the flat eth naming.
+    """
+
+    node = Node(project, compute, "iol",
+                node_id=str(uuid.uuid4()),
+                node_type="docker",
+                properties={"adapters": 2, "environment": "GNS3_IOL_RUNNER=1"})
+    ports = node.ports
+    assert [p.asdict()["name"] for p in ports] == [
+        "Ethernet0/0", "Ethernet0/1", "Ethernet0/2", "Ethernet0/3",
+        "Ethernet1/0", "Ethernet1/1", "Ethernet1/2", "Ethernet1/3",
+    ]
+    assert (ports[5].adapter_number, ports[5].port_number) == (1, 1)
+    assert ports[5].short_name == "e1/1"
+
+    node = Node(project, compute, "web",
+                node_id=str(uuid.uuid4()),
+                node_type="docker",
+                properties={"adapters": 2})
+    assert [p.asdict()["name"] for p in node.ports] == ["eth0", "eth1"]
+
+
 def test_name(compute, project):
     """
     If node use a name template generate names