Remove use_ubridge flag

Ref #1115

gns3server/compute/base_node.py

@@ -77,10 +77,6 @@ class BaseNode:
         self._wrap_console = wrap_console
         self._wrapper_telnet_server = None
 
-        # check if the node will use uBridge or not
-        server_config = Config.instance().get_section_config("Server")
-        self._use_ubridge = server_config.getboolean("use_ubridge")
-
         if self._console is not None:
             if console_type == "vnc":
                 self._console = self._manager.port_manager.reserve_tcp_port(self._console, self._project, port_range_start=5900, port_range_end=6000)
@@ -460,16 +456,6 @@ class BaseNode:
                                                                                         id=self.id,
                                                                                         console_type=console_type))
 
-    @property
-    def use_ubridge(self):
-        """
-        Returns if uBridge is used for this node or not
-
-        :returns: boolean
-        """
-
-        return self._use_ubridge
-
     @property
     def ubridge(self):
         """
@@ -592,7 +578,8 @@ class BaseNode:
 
     @asyncio.coroutine
     def _update_ubridge_udp_connection(self, bridge_name, source_nio, destination_nio):
-        yield from self._ubridge_apply_filters(bridge_name, destination_nio.filters)
+        if destination_nio:
+            yield from self._ubridge_apply_filters(bridge_name, destination_nio.filters)
 
     @asyncio.coroutine
     def _ubridge_apply_filters(self, bridge_name, filters):

gns3server/compute/qemu/qemu_vm.py

@@ -907,14 +907,13 @@ class QemuVM(BaseNode):
                                                                               stderr=subprocess.STDOUT,
                                                                               cwd=self.working_dir)
 
-                if self.use_ubridge:
-                    yield from self._start_ubridge()
-                    for adapter_number, adapter in enumerate(self._ethernet_adapters):
-                        nio = adapter.get_nio(0)
-                        if nio:
-                            yield from self.add_ubridge_udp_connection("QEMU-{}-{}".format(self._id, adapter_number),
-                                                                        self._local_udp_tunnels[adapter_number][1],
-                                                                        nio)
+                yield from self._start_ubridge()
+                for adapter_number, adapter in enumerate(self._ethernet_adapters):
+                    nio = adapter.get_nio(0)
+                    if nio:
+                        yield from self.add_ubridge_udp_connection("QEMU-{}-{}".format(self._id, adapter_number),
+                                                                    self._local_udp_tunnels[adapter_number][1],
+                                                                    nio)
 
                 log.info('QEMU VM "{}" started PID={}'.format(self._name, self._process.pid))
                 self.status = "started"
@@ -1131,16 +1130,15 @@ class QemuVM(BaseNode):
             raise QemuError('Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(name=self._name,
                                                                                                  adapter_number=adapter_number))
 
-        if self.ubridge:
-            try:
-                yield from self.add_ubridge_udp_connection("QEMU-{}-{}".format(self._id, adapter_number),
-                                                            self._local_udp_tunnels[adapter_number][1],
-                                                            nio)
-            except IndexError:
-                raise QemuError('Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(name=self._name,
-                                                                                                     adapter_number=adapter_number))
-        elif self.is_running():
-            raise QemuError("Sorry, adding a link to a started Qemu VM is not supported without using uBridge.")
+        if adapter_number not in self._local_udp_tunnels:
+            self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
+        try:
+            yield from self.add_ubridge_udp_connection("QEMU-{}-{}".format(self._id, adapter_number),
+                                                        self._local_udp_tunnels[adapter_number][1],
+                                                        nio)
+        except IndexError:
+            raise QemuError('Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(name=self._name,
+                                                                                                 adapter_number=adapter_number))
 
         adapter.add_nio(0, nio)
         log.info('QEMU VM "{name}" [{id}]: {nio} added to adapter {adapter_number}'.format(name=self._name,
@@ -1164,10 +1162,7 @@ class QemuVM(BaseNode):
             raise QemuError('Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(name=self._name,
                                                                                                  adapter_number=adapter_number))
 
-        if self.ubridge:
-            yield from self._ubridge_send("bridge delete {name}".format(name="QEMU-{}-{}".format(self._id, adapter_number)))
-        elif self.is_running():
-            raise QemuError("Sorry, removing a link to a started Qemu VM is not supported without using uBridge.")
+        yield from self._ubridge_send("bridge delete {name}".format(name="QEMU-{}-{}".format(self._id, adapter_number)))
 
         nio = adapter.get_nio(0)
         if isinstance(nio, NIOUDP):
@@ -1195,9 +1190,6 @@ class QemuVM(BaseNode):
             raise QemuError('Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(name=self._name,
                                                                                                  adapter_number=adapter_number))
 
-        if not self.use_ubridge:
-            raise QemuError("uBridge must be enabled in order to start packet capture")
-
         nio = adapter.get_nio(0)
 
         if not nio:
@@ -1476,13 +1468,10 @@ class QemuVM(BaseNode):
         for adapter_number, adapter in enumerate(self._ethernet_adapters):
             mac = int_to_macaddress(macaddress_to_int(self._mac_address) + adapter_number)
 
-            if self.use_ubridge:
-                # use a local UDP tunnel to connect to uBridge instead
-                if adapter_number not in self._local_udp_tunnels:
-                    self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
-                nio = self._local_udp_tunnels[adapter_number][0]
-            else:
-                nio = adapter.get_nio(0)
+            # use a local UDP tunnel to connect to uBridge instead
+            if adapter_number not in self._local_udp_tunnels:
+                self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
+            nio = self._local_udp_tunnels[adapter_number][0]
             if self._legacy_networking:
                 # legacy QEMU networking syntax (-net)
                 if nio:

gns3server/compute/virtualbox/virtualbox_vm.py

@@ -280,14 +280,13 @@ class VirtualBoxVM(BaseNode):
         # add a guest property to let the VM know about the GNS3 project directory
         yield from self.manager.execute("guestproperty", ["set", self._vmname, "ProjectDirInGNS3", self.working_dir])
 
-        if self.use_ubridge:
-            yield from self._start_ubridge()
-            for adapter_number in range(0, self._adapters):
-                nio = self._ethernet_adapters[adapter_number].get_nio(0)
-                if nio:
-                    yield from self.add_ubridge_udp_connection("VBOX-{}-{}".format(self._id, adapter_number),
-                                                                self._local_udp_tunnels[adapter_number][1],
-                                                                nio)
+        yield from self._start_ubridge()
+        for adapter_number in range(0, self._adapters):
+            nio = self._ethernet_adapters[adapter_number].get_nio(0)
+            if nio:
+                yield from self.add_ubridge_udp_connection("VBOX-{}-{}".format(self._id, adapter_number),
+                                                            self._local_udp_tunnels[adapter_number][1],
+                                                            nio)
 
         yield from self._start_console()
 
@@ -837,13 +836,10 @@ class VirtualBoxVM(BaseNode):
                 yield from self._modify_vm("--nic{} null".format(adapter_number + 1))
                 yield from self._modify_vm("--cableconnected{} off".format(adapter_number + 1))
 
-            if self.use_ubridge:
-                # use a local UDP tunnel to connect to uBridge instead
-                if adapter_number not in self._local_udp_tunnels:
-                    self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
-                nio = self._local_udp_tunnels[adapter_number][0]
-            else:
-                nio = self._ethernet_adapters[adapter_number].get_nio(0)
+            # use a local UDP tunnel to connect to uBridge instead
+            if adapter_number not in self._local_udp_tunnels:
+                self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
+            nio = self._local_udp_tunnels[adapter_number][0]
 
             if nio:
                 if not self._use_any_adapter and attachment not in ("none", "null", "generic"):
@@ -881,7 +877,7 @@ class VirtualBoxVM(BaseNode):
                     yield from self._modify_vm("--nictrace{} on".format(adapter_number + 1))
                     yield from self._modify_vm('--nictracefile{} "{}"'.format(adapter_number + 1, nio.pcap_output_file))
 
-                if self.use_ubridge and not self._ethernet_adapters[adapter_number].get_nio(0):
+                if not self._ethernet_adapters[adapter_number].get_nio(0):
                     yield from self._modify_vm("--cableconnected{} off".format(adapter_number + 1))
 
         for adapter_number in range(self._adapters, self._maximum_adapters):
@@ -972,32 +968,14 @@ class VirtualBoxVM(BaseNode):
             raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
                                                                                                             adapter_number=adapter_number))
 
-        if self.ubridge:
-            try:
-                yield from self.add_ubridge_udp_connection("VBOX-{}-{}".format(self._id, adapter_number),
-                                                            self._local_udp_tunnels[adapter_number][1],
-                                                            nio)
-            except KeyError:
-                raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
-                                                                                                                adapter_number=adapter_number))
-            yield from self._control_vm("setlinkstate{} on".format(adapter_number + 1))
-        else:
-            vm_state = yield from self._get_vm_state()
-            if vm_state == "running":
-                if isinstance(nio, NIOUDP):
-                    # dynamically configure an UDP tunnel on the VirtualBox adapter
-                    yield from self._control_vm("nic{} generic UDPTunnel".format(adapter_number + 1))
-                    yield from self._control_vm("nicproperty{} sport={}".format(adapter_number + 1, nio.lport))
-                    yield from self._control_vm("nicproperty{} dest={}".format(adapter_number + 1, nio.rhost))
-                    yield from self._control_vm("nicproperty{} dport={}".format(adapter_number + 1, nio.rport))
-                    yield from self._control_vm("setlinkstate{} on".format(adapter_number + 1))
-
-                    # check if the UDP tunnel has been correctly set
-                    vm_info = yield from self._get_vm_info()
-                    generic_driver_number = "generic{}".format(adapter_number + 1)
-                    if generic_driver_number not in vm_info and vm_info[generic_driver_number] != "UDPTunnel":
-                        log.warning("UDP tunnel has not been set on nic: {}".format(adapter_number + 1))
-                        self.project.emit("log.warning", {"message": "UDP tunnel has not been set on nic: {}".format(adapter_number + 1)})
+        try:
+            yield from self.add_ubridge_udp_connection("VBOX-{}-{}".format(self._id, adapter_number),
+                                                        self._local_udp_tunnels[adapter_number][1],
+                                                        nio)
+        except KeyError:
+            raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
+                                                                                                            adapter_number=adapter_number))
+        yield from self._control_vm("setlinkstate{} on".format(adapter_number + 1))
 
         adapter.add_nio(0, nio)
         log.info("VirtualBox VM '{name}' [{id}]: {nio} added to adapter {adapter_number}".format(name=self.name,
@@ -1021,17 +999,10 @@ class VirtualBoxVM(BaseNode):
             raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
                                                                                                             adapter_number=adapter_number))
 
-        if self.ubridge:
-            yield from self._ubridge_send("bridge delete {name}".format(name="VBOX-{}-{}".format(self._id, adapter_number)))
-            vm_state = yield from self._get_vm_state()
-            if vm_state == "running":
-                yield from self._control_vm("setlinkstate{} off".format(adapter_number + 1))
-        else:
-            vm_state = yield from self._get_vm_state()
-            if vm_state == "running":
-                # dynamically disable the VirtualBox adapter
-                yield from self._control_vm("setlinkstate{} off".format(adapter_number + 1))
-                yield from self._control_vm("nic{} null".format(adapter_number + 1))
+        yield from self._ubridge_send("bridge delete {name}".format(name="VBOX-{}-{}".format(self._id, adapter_number)))
+        vm_state = yield from self._get_vm_state()
+        if vm_state == "running":
+            yield from self._control_vm("setlinkstate{} off".format(adapter_number + 1))
 
         nio = adapter.get_nio(0)
         if isinstance(nio, NIOUDP):
@@ -1059,11 +1030,6 @@ class VirtualBoxVM(BaseNode):
             raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
                                                                                                             adapter_number=adapter_number))
 
-        if not self.use_ubridge:
-            vm_state = yield from self._get_vm_state()
-            if vm_state == "running" or vm_state == "paused" or vm_state == "stuck":
-                raise VirtualBoxError("Sorry, packet capturing on a started VirtualBox VM is not supported without using uBridge")
-
         nio = adapter.get_nio(0)
 
         if not nio:

gns3server/compute/vpcs/vpcs_vm.py

@@ -241,9 +241,6 @@ class VPCSVM(BaseNode):
         yield from self._check_requirements()
         if not self.is_running():
             nio = self._ethernet_adapter.get_nio(0)
-            if not self.use_ubridge and not nio:
-                raise VPCSError("This VPCS instance must be connected in order to start")
-
             command = self._build_command()
             try:
                 log.info("Starting VPCS: {}".format(command))
@@ -261,10 +258,9 @@ class VPCSVM(BaseNode):
                                                                               creationflags=flags)
                     monitor_process(self._process, self._termination_callback)
 
-                if self.use_ubridge:
-                    yield from self._start_ubridge()
-                    if nio:
-                        yield from self.add_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
+                yield from self._start_ubridge()
+                if nio:
+                    yield from self.add_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
 
                 yield from self.start_wrap_console()
 
@@ -378,10 +374,10 @@ class VPCSVM(BaseNode):
             raise VPCSError("Port {port_number} doesn't exist in adapter {adapter}".format(adapter=self._ethernet_adapter,
                                                                                            port_number=port_number))
 
-        if self.ubridge:
-            yield from self.add_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
-        elif self.is_running():
-            raise VPCSError("Sorry, updating a link to a started VPCS instance is not supported without using uBridge.")
+        if not self._local_udp_tunnel:
+            self._local_udp_tunnel = self._create_local_udp_tunnel()
+
+        yield from self.add_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
 
         self._ethernet_adapter.add_nio(port_number, nio)
         log.info('VPCS "{name}" [{id}]: {nio} added to port {port_number}'.format(name=self._name,
@@ -396,10 +392,9 @@ class VPCSVM(BaseNode):
         if not self._ethernet_adapter.port_exists(port_number):
             raise VPCSError("Port {port_number} doesn't exist in adapter {adapter}".format(adapter=self._ethernet_adapter,
                                                                                            port_number=port_number))
-        if self.ubridge:
-            yield from self._update_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
-        elif self.is_running():
-            raise VPCSError("Sorry, adding a link to a started VPCS instance is not supported without using uBridge.")
+        if not self._local_udp_tunnel:
+            self._local_udp_tunnel = self._create_local_udp_tunnel()
+        yield from self._update_ubridge_udp_connection("VPCS-{}".format(self._id), self._local_udp_tunnel[1], nio)
 
     @asyncio.coroutine
     def port_remove_nio_binding(self, port_number):
@@ -415,10 +410,7 @@ class VPCSVM(BaseNode):
             raise VPCSError("Port {port_number} doesn't exist in adapter {adapter}".format(adapter=self._ethernet_adapter,
                                                                                            port_number=port_number))
 
-        if self.ubridge:
-            yield from self._ubridge_send("bridge delete {name}".format(name="VPCS-{}".format(self._id)))
-        elif self.is_running():
-            raise VPCSError("Sorry, adding a link to a started VPCS instance is not supported without using uBridge.")
+        yield from self._ubridge_send("bridge delete {name}".format(name="VPCS-{}".format(self._id)))
 
         nio = self._ethernet_adapter.get_nio(port_number)
         if isinstance(nio, NIOUDP):
@@ -444,9 +436,6 @@ class VPCSVM(BaseNode):
             raise VPCSError("Port {port_number} doesn't exist in adapter {adapter}".format(adapter=self._ethernet_adapter,
                                                                                            port_number=port_number))
 
-        if not self.use_ubridge:
-            raise VPCSError("uBridge must be enabled in order to start packet capture")
-
         nio = self._ethernet_adapter.get_nio(0)
 
         if not nio:
@@ -537,13 +526,10 @@ class VPCSVM(BaseNode):
         else:
             log.warn("The VPCS relay feature could not be disabled because the VPCS version is below 0.8b")
 
-        if self.use_ubridge:
-            # use the local UDP tunnel to uBridge instead
-            if not self._local_udp_tunnel:
-                self._local_udp_tunnel = self._create_local_udp_tunnel()
-            nio = self._local_udp_tunnel[0]
-        else:
-            nio = self._ethernet_adapter.get_nio(0)
+        # use the local UDP tunnel to uBridge instead
+        if not self._local_udp_tunnel:
+            self._local_udp_tunnel = self._create_local_udp_tunnel()
+        nio = self._local_udp_tunnel[0]
         if nio:
 
             if isinstance(nio, NIOUDP):

gns3server/run.py

@@ -121,7 +121,6 @@ def parse_arguments(argv):
         "certkey": config.get("certkey", ""),
         "record": config.get("record", ""),
         "local": config.getboolean("local", False),
-        "use_ubridge": config.getboolean("use_ubridge", True),  # this enables uBridge globally
         "allow": config.getboolean("allow_remote_console", False),
         "quiet": config.getboolean("quiet", False),
         "debug": config.getboolean("debug", False),
@@ -137,7 +136,6 @@ def set_config(args):
     config = Config.instance()
     server_config = config.get_section_config("Server")
     server_config["local"] = str(args.local)
-    server_config["use_ubridge"] = str(args.no_ubridge)
     server_config["allow_remote_console"] = str(args.allow)
     server_config["host"] = args.host
     server_config["port"] = str(args.port)
@@ -225,11 +223,6 @@ def run():
     if server_config.getboolean("local"):
         log.warning("Local mode is enabled. Beware, clients will have full control on your filesystem")
 
-    if server_config.getboolean("use_ubridge"):
-        log.info("uBridge will be used to handle node connections")
-    else:
-        log.warning("uBridge will NOT be used to handle node connections")
-
     # we only support Python 3 version >= 3.4
     if sys.version_info < (3, 4):
         raise SystemExit("Python 3.4 or higher is required")