Use uBridge for VirtualBox connections plus some cleaning. Ref #267.

tests/compute/docker/test_docker_vm.py

@@ -411,7 +411,7 @@ def test_start(loop, vm, manager, free_console_port):
     vm._add_ubridge_connection = AsyncioMagicMock()
     vm._start_console = AsyncioMagicMock()
 
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
 
     with asyncio_patch("gns3server.compute.docker.Docker.query") as mock_query:
@@ -430,7 +430,7 @@ def test_start_namespace_failed(loop, vm, manager, free_console_port):
     assert vm.status != "started"
     vm.adapters = 1
 
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
 
     with asyncio_patch("gns3server.compute.docker.DockerVM._get_container_state", return_value="stopped"):
@@ -641,7 +641,7 @@ def test_close(loop, vm, port_manager):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
 
     with asyncio_patch("gns3server.compute.docker.DockerVM._get_container_state", return_value="stopped"):
@@ -685,7 +685,7 @@ def test_add_ubridge_connection(loop, vm):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     nio.startPacketCapture("/tmp/capture.pcap")
     vm._ubridge_hypervisor = MagicMock()
 
@@ -725,7 +725,7 @@ def test_add_ubridge_connection_invalid_adapter_number(loop, vm):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     with pytest.raises(DockerError):
         loop.run_until_complete(asyncio.async(vm._add_ubridge_connection(nio, 12, 42)))
 
@@ -736,7 +736,7 @@ def test_add_ubridge_connection_no_free_interface(loop, vm):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     with pytest.raises(DockerError):
 
         # We create fake ethernet interfaces for docker
@@ -753,7 +753,7 @@ def test_delete_ubridge_connection(loop, vm):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
 
     loop.run_until_complete(asyncio.async(vm._add_ubridge_connection(nio, 0, 42)))
     loop.run_until_complete(asyncio.async(vm._delete_ubridge_connection(0)))
@@ -770,7 +770,7 @@ def test_adapter_add_nio_binding(vm, loop):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     assert vm._ethernet_adapters[0].get_nio(0) == nio
 
@@ -780,7 +780,7 @@ def test_adapter_add_nio_binding_invalid_adapter(vm, loop):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     with pytest.raises(DockerError):
         loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(12, nio)))
 
@@ -790,7 +790,7 @@ def test_adapter_remove_nio_binding(vm, loop):
            "lport": 4242,
            "rport": 4343,
            "rhost": "127.0.0.1"}
-    nio = vm.manager.create_nio(0, nio)
+    nio = vm.manager.create_nio(nio)
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     with asyncio_patch("gns3server.compute.docker.DockerVM._delete_ubridge_connection") as delete_ubridge_mock:
         loop.run_until_complete(asyncio.async(vm.adapter_remove_nio_binding(0)))
@@ -833,7 +833,7 @@ def test_pull_image(loop, vm):
 def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     loop.run_until_complete(asyncio.async(vm.start_capture(0, output_file)))
     assert vm._ethernet_adapters[0].get_nio(0).capturing
@@ -842,7 +842,7 @@ def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 def test_stop_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     loop.run_until_complete(vm.start_capture(0, output_file))
     assert vm._ethernet_adapters[0].get_nio(0).capturing

tests/compute/iou/test_iou_vm.py

@@ -325,7 +325,7 @@ def test_enable_l1_keepalives(loop, vm):
 def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(vm.iouyap_path, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, 0, nio)))
     loop.run_until_complete(asyncio.async(vm.start_capture(0, 0, output_file)))
     assert vm._adapters[0].get_nio(0).capturing
@@ -334,7 +334,7 @@ def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 def test_stop_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(vm.iouyap_path, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, 0, nio)))
     loop.run_until_complete(vm.start_capture(0, 0, output_file))
     assert vm._adapters[0].get_nio(0).capturing

tests/compute/qemu/test_qemu_vm.py

@@ -128,7 +128,7 @@ def test_stop(loop, vm, running_subprocess_mock):
     process.wait.return_value = future
 
     with asyncio_patch("asyncio.create_subprocess_exec", return_value=process):
-        nio = Qemu.instance().create_nio(vm.qemu_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+        nio = Qemu.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
         vm.adapter_add_nio_binding(0, nio)
         loop.run_until_complete(asyncio.async(vm.start()))
         assert vm.is_running()
@@ -192,7 +192,7 @@ def test_suspend(loop, vm):
 
 
 def test_add_nio_binding_udp(vm, loop):
-    nio = Qemu.instance().create_nio(vm.qemu_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+    nio = Qemu.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     assert nio.lport == 4242
 
@@ -200,13 +200,13 @@ def test_add_nio_binding_udp(vm, loop):
 @pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
 def test_add_nio_binding_ethernet(vm, loop, ethernet_device):
     with patch("gns3server.compute.base_manager.BaseManager.has_privileged_access", return_value=True):
-        nio = Qemu.instance().create_nio(vm.qemu_path, {"type": "nio_ethernet", "ethernet_device": ethernet_device})
+        nio = Qemu.instance().create_nio({"type": "nio_ethernet", "ethernet_device": ethernet_device})
         loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
         assert nio.ethernet_device == ethernet_device
 
 
 def test_port_remove_nio_binding(vm, loop):
-    nio = Qemu.instance().create_nio(vm.qemu_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+    nio = Qemu.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     loop.run_until_complete(asyncio.async(vm.adapter_remove_nio_binding(0)))
     assert vm._ethernet_adapters[0].ports[0] is None

tests/compute/virtualbox/test_virtualbox_vm.py

@@ -57,7 +57,7 @@ def test_vm_invalid_virtualbox_api_version(loop, project, manager):
 
 
 def test_vm_adapter_add_nio_binding_adapter_not_exist(loop, vm, manager, free_console_port):
-    nio = manager.create_nio(manager.vboxmanage_path, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "192.168.1.2"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "192.168.1.2"})
     with pytest.raises(VirtualBoxError):
         loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(15, nio)))
 

tests/compute/vmware/test_vmware_vm.py

@@ -54,7 +54,7 @@ def test_json(vm, tmpdir, project):
 def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     vm.adapters = 1
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     loop.run_until_complete(asyncio.async(vm.start_capture(0, output_file)))
@@ -64,7 +64,7 @@ def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 def test_stop_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")
-    nio = manager.create_nio(0, {"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
+    nio = manager.create_nio({"type": "nio_udp", "lport": free_console_port, "rport": free_console_port, "rhost": "127.0.0.1"})
     vm.adapters = 1
     loop.run_until_complete(asyncio.async(vm.adapter_add_nio_binding(0, nio)))
     loop.run_until_complete(vm.start_capture(0, output_file))

tests/compute/vpcs/test_vpcs_vm.py

@@ -67,7 +67,7 @@ def test_vm_check_vpcs_version_0_6_1(loop, vm, manager):
 def test_vm_invalid_vpcs_version(loop, manager, vm):
     with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.subprocess_check_output", return_value="Welcome to Virtual PC Simulator, version 0.1"):
         with pytest.raises(VPCSError):
-            nio = manager.create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+            nio = manager.create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm._check_vpcs_version()))
             assert vm.name == "test"
@@ -77,7 +77,7 @@ def test_vm_invalid_vpcs_version(loop, manager, vm):
 def test_vm_invalid_vpcs_path(vm, manager, loop):
     with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.vpcs_path", return_value="/tmp/fake/path/vpcs"):
         with pytest.raises(VPCSError):
-            nio = manager.create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+            nio = manager.create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm.start()))
             assert vm.name == "test"
@@ -93,7 +93,7 @@ def test_start(loop, vm, async_run):
 
         with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM._check_requirements", return_value=True):
             with asyncio_patch("asyncio.create_subprocess_exec", return_value=process) as mock_exec:
-                nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+                nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
                 vm.port_add_nio_binding(0, nio)
                 loop.run_until_complete(asyncio.async(vm.start()))
                 assert mock_exec.call_args[0] == (vm.vpcs_path,
@@ -128,7 +128,7 @@ def test_start_0_6_1(loop, vm):
 
     with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM._check_requirements", return_value=True):
         with asyncio_patch("asyncio.create_subprocess_exec", return_value=process) as mock_exec:
-            nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+            nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm.start()))
             assert mock_exec.call_args[0] == (vm.vpcs_path,
@@ -159,7 +159,7 @@ def test_stop(loop, vm, async_run):
     with NotificationManager.instance().queue() as queue:
         with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM._check_requirements", return_value=True):
             with asyncio_patch("asyncio.create_subprocess_exec", return_value=process):
-                nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+                nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
                 vm.port_add_nio_binding(0, nio)
 
                 loop.run_until_complete(asyncio.async(vm.start()))
@@ -193,7 +193,7 @@ def test_reload(loop, vm):
 
     with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM._check_requirements", return_value=True):
         with asyncio_patch("asyncio.create_subprocess_exec", return_value=process):
-            nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+            nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm.start()))
             assert vm.is_running()
@@ -209,7 +209,7 @@ def test_reload(loop, vm):
 
 
 def test_add_nio_binding_udp(vm):
-    nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+    nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
     vm.port_add_nio_binding(0, nio)
     assert nio.lport == 4242
 
@@ -217,7 +217,7 @@ def test_add_nio_binding_udp(vm):
 @pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
 def test_add_nio_binding_tap(vm, ethernet_device):
     with patch("gns3server.compute.base_manager.BaseManager.has_privileged_access", return_value=True):
-        nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_tap", "tap_device": ethernet_device})
+        nio = VPCS.instance().create_nio({"type": "nio_tap", "tap_device": ethernet_device})
         vm.port_add_nio_binding(0, nio)
         assert nio.tap_device == ethernet_device
 
@@ -225,13 +225,13 @@ def test_add_nio_binding_tap(vm, ethernet_device):
 # def test_add_nio_binding_tap_no_privileged_access(vm):
 #     with patch("gns3server.compute.base_manager.BaseManager.has_privileged_access", return_value=False):
 #         with pytest.raises(aiohttp.web.HTTPForbidden):
-#             nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_tap", "tap_device": "test"})
+#             nio = VPCS.instance().create_nio({"type": "nio_tap", "tap_device": "test"})
 #             vm.port_add_nio_binding(0, nio)
 #     assert vm._ethernet_adapter.ports[0] is None
 #
 
 def test_port_remove_nio_binding(vm):
-    nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
+    nio = VPCS.instance().create_nio({"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
     vm.port_add_nio_binding(0, nio)
     vm.port_remove_nio_binding(0)
     assert vm._ethernet_adapter.ports[0] is None