Allow connection to a remote controller

Ref GNS3#1280

Author: julien-duponchelle

gns3/controller.py

@@ -22,7 +22,6 @@
 from .qt import QtCore, QtGui, qpartial
 from .symbol import Symbol
 
-
 import logging
 log = logging.getLogger(__name__)
 
@@ -37,6 +36,7 @@ def __init__(self):
         super().__init__()
         self._connected = False
         self._cache_directory = tempfile.TemporaryDirectory()
+        self._http_client = None
 
     def connected(self):
         """
@@ -55,8 +55,10 @@ def setHttpClient(self, http_client):
         :param http_client: Instance of HTTP client to communicate with the server
         """
         self._http_client = http_client
-        self._http_client.connection_connected_signal.connect(self._httpClientConnectedSlot)
-        self.get('/version', None)
+        if self._http_client:
+            self._http_client.connection_connected_signal.connect(self._httpClientConnectedSlot)
+            self._connected = False
+            self.get('/version', None)
 
     def _httpClientConnectedSlot(self):
         if not self._connected:

gns3/dialogs/setup_wizard.py

@@ -254,15 +254,6 @@ def validateCurrentPage(self):
                 return False
 
             LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            LocalServer.instance().stopLocalServer(wait=True)
-            if LocalServer.instance().startLocalServer():
-                worker = WaitForConnectionWorker(local_server_settings["host"], local_server_settings["port"])
-                dialog = ProgressDialog(worker, "Local server", "Connecting...", "Cancel", busy=True, parent=self)
-                dialog.show()
-                dialog.exec_()
-                Controller.instance().setHttpClient(LocalServer.instance().httpClient())
-            else:
-                QtWidgets.QMessageBox.critical(self, "Local server", "Could not start the local server process: {}".format(local_server_settings["path"]))
 
         elif self.currentPage() == self.uiSummaryWizardPage:
             use_local_server = self.uiLocalRadioButton.isChecked()

gns3/local_server.py

@@ -40,6 +40,7 @@
 from gns3.utils.http import getSynchronous
 from gns3.utils.sudo import sudo
 from gns3.http_client import HTTPClient
+from gns3.controller import Controller
 
 
 import logging
@@ -75,7 +76,7 @@ def cancel(self):
         return
 
 
-class LocalServer():
+class LocalServer(QtCore.QObject):
     """
     Manage the local server process
     """
@@ -84,13 +85,14 @@ def __init__(self, parent=None):
 
         super().__init__()
         self._parent = parent
-        self._http_client = None
         self._local_server_path = ""
         self._local_server_process = None
         self._config_directory = LocalConfig.instance().configDirectory()
         self._pid_path = os.path.join(self._config_directory, "gns3_server.pid")
         self.localServerSettings()
         self._port = self._settings["port"]
+        self._http_client = HTTPClient(self._settings)
+        Controller.instance().setHttpClient(self._http_client)
 
     def parent(self):
         """
@@ -206,13 +208,32 @@ def updateLocalServerSettings(self, new_settings):
         """
         Update the local server settings. Keep the key not in new_settings
         """
+        old_settings = copy.copy(self._settings)
         if not self._settings:
             self._settings = new_settings
         else:
             self._settings.update(new_settings)
         self._port = self._settings["port"]
         LocalServerConfig.instance().saveSettings("Server", self._settings)
 
+        # Settings have changed we need to restart the server
+        if old_settings != self._settings:
+            if self._settings["auto_start"]:
+                self.stopLocalServer(wait=True)
+                if self.startLocalServer():
+                    worker = WaitForConnectionWorker(new_local_server_settings["host"], new_local_server_settings["port"])
+                    dialog = ProgressDialog(worker, "Local server", "Connecting...", "Cancel", busy=True, parent=self.parent())
+                    dialog.show()
+                    dialog.exec_()
+                else:
+                    QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not start the local server process: {}".format(new_local_server_settings["path"]))
+            # If the controller is remote:
+            else:
+                self.stopLocalServer(wait=True)
+
+            self._http_client = HTTPClient(self._settings)
+            Controller.instance().setHttpClient(self._http_client)
+
     def shouldLocalServerAutoStart(self):
         """
         Returns either the local server
@@ -357,11 +378,6 @@ def _findUnusedLocalPort(self, host):
             s.bind((host, 0))
             return s.getsockname()[1]
 
-    def httpClient(self):
-        if self._http_client is None:
-            self._http_client = HTTPClient(self._settings)
-        return self._http_client
-
     def startLocalServer(self):
         """
         Starts the local server process.

gns3/main_window.py

@@ -969,7 +969,6 @@ def startupLoading(self):
 
         # start and connect to the local server if needed
         LocalServer.instance().localServerAutoStart()
-        Controller.instance().setHttpClient(LocalServer.instance().httpClient())
 
         # start the GNS3 VM
         # FIXME: run in a thead to wait for the VM to be started
@@ -986,7 +985,6 @@ def startupLoading(self):
         #         if progress_dialog.exec_():
         #             pass
         #             #gns3_vm.adjustLocalServerIP()
-        #     Controller.instance().setHttpClient(gns3_vm.httpClient())
 
         # show the setup wizard
         if not self._settings["hide_setup_wizard"]:# and not gns3_vm.isRunning():

gns3/pages/server_preferences_page.py

@@ -32,7 +32,6 @@
 from ..topology import Topology
 from ..utils.message_box import MessageBox
 from ..utils.progress_dialog import ProgressDialog
-from ..utils.wait_for_connection_worker import WaitForConnectionWorker
 from ..settings import LOCAL_SERVER_SETTINGS, SERVERS_SETTINGS
 from ..gns3_vm import GNS3VM
 from ..dialogs.edit_compute_dialog import EditComputeDialog
@@ -75,9 +74,6 @@ def __init__(self, parent=None):
         # load all available addresses
         for address in QtNetwork.QNetworkInterface.allAddresses():
             address_string = address.toString()
-            # if address.protocol() == QtNetwork.QAbstractSocket.IPv6Protocol:
-            # we do not want the scope id when using an IPv6 address...
-            # address.setScopeId("")
             self.uiLocalServerHostComboBox.addItem(address_string, address.toString())
 
         # default is 127.0.0.1
@@ -185,17 +181,19 @@ def _useLocalServerAutoStartSlot(self, state):
         """
 
         if state:
-            self.uiGeneralSettingsGroupBox.setEnabled(True)
-            self.uiConsolePortRangeGroupBox.setEnabled(True)
-            self.uiUDPPortRangeGroupBox.setEnabled(True)
+            self.uiGeneralSettingsGroupBox.setVisible(True)
+            self.uiConsolePortRangeGroupBox.setVisible(True)
+            self.uiUDPPortRangeGroupBox.setVisible(True)
+            self.uiRemoteMainServerGroupBox.setVisible(False)
         else:
             if self.uiEnableVMCheckBox.isChecked() and not self.uiRemoteRadioButton.isChecked():
                 QtWidgets.QMessageBox.critical(self, "Local GNS3 VM", "The local server need to be enable in order to use a local GNS3 VM. Please deactivate the local GNS3 VM before turning off the local server.")
                 self.uiLocalServerAutoStartCheckBox.setChecked(True)
                 return
-            self.uiGeneralSettingsGroupBox.setEnabled(False)
-            self.uiConsolePortRangeGroupBox.setEnabled(False)
-            self.uiUDPPortRangeGroupBox.setEnabled(False)
+            self.uiRemoteMainServerGroupBox.setVisible(True)
+            self.uiGeneralSettingsGroupBox.setVisible(False)
+            self.uiConsolePortRangeGroupBox.setVisible(False)
+            self.uiUDPPortRangeGroupBox.setVisible(False)
 
     def _restoreDefaultsSlot(self):
         """
@@ -293,7 +291,16 @@ def _populateWidgets(self, servers_settings, vm_settings):
         if index != -1:
             self.uiLocalServerHostComboBox.setCurrentIndex(index)
         self.uiLocalServerPortSpinBox.setValue(servers_settings["port"])
+
+        self.uiRemoteMainServerHostLineEdit.setText(servers_settings["host"])
+        self.uiRemoteMainServerPortSpinBox.setValue(servers_settings["port"])
+        self.uiRemoteMainServerUserLineEdit.setText(servers_settings["user"])
+        self.uiRemoteMainServerPasswordLineEdit.setText(servers_settings["password"])
+        self.uiRemoteMainServerProtocolComboBox.setCurrentText(servers_settings["protocol"])
+
         self.uiLocalServerAutoStartCheckBox.setChecked(servers_settings["auto_start"])
+        self._useLocalServerAutoStartSlot(servers_settings["auto_start"])
+
         self.uiLocalServerAuthCheckBox.setChecked(servers_settings["auth"])
         self.uiConsoleConnectionsToAnyIPCheckBox.setChecked(servers_settings["allow_console_from_anywhere"])
         self.uiConsoleStartPortSpinBox.setValue(servers_settings["console_start_port_range"])
@@ -410,10 +417,13 @@ def savePreferences(self):
                     MessageBox(self, "Local server", "Please close your project or delete all the nodes running on the local server before changing the local server settings")
                     return
                 LocalServer.instance().updateLocalServerSettings(new_local_server_settings)
-                restart_local_server = True
         else:
+            new_local_server_settings["host"] = self.uiRemoteMainServerHostLineEdit.text()
+            new_local_server_settings["port"] = self.uiRemoteMainServerPortSpinBox.value()
+            new_local_server_settings["protocol"] = self.uiRemoteMainServerProtocolComboBox.currentText()
+            new_local_server_settings["user"] = self.uiRemoteMainServerUserLineEdit.text()
+            new_local_server_settings["password"] = self.uiRemoteMainServerPasswordLineEdit.text()
             LocalServer.instance().updateLocalServerSettings(new_local_server_settings)
-            LocalServer.instance().stopLocalServer(wait=True)
 
         # save the GNS3 VM preferences
         # new_gns3vm_settings = servers_settings["vm"].copy()
@@ -471,15 +481,7 @@ def savePreferences(self):
         #                     restart_local_server = True
         #                     self.uiLocalServerHostComboBox.setCurrentIndex(index)
         #
-        # start or restart the local server if required
-        if restart_local_server:
-            LocalServer.instance().stopLocalServer(wait=True)
-            if LocalServer.instance().startLocalServer():
-                worker = WaitForConnectionWorker(new_local_server_settings["host"], new_local_server_settings["port"])
-                dialog = ProgressDialog(worker, "Local server", "Connecting...", "Cancel", busy=True, parent=self)
-                dialog.show()
-                dialog.exec_()
-            else:
-                QtWidgets.QMessageBox.critical(self, "Local server", "Could not start the local server process: {}".format(new_local_server_settings["path"]))
+
+
 
         self.loadPreferences()

gns3/settings.py

@@ -297,6 +297,7 @@
     "auth": True,
     "user": "",
     "password": "",
+    "protocol": "http",
     "console_start_port_range": 5000,
     "console_end_port_range": 10000,
     "udp_start_port_range": 10000,

gns3/topology.py

@@ -40,7 +40,7 @@
 from .modules.module_error import ModuleError
 from .items.node_item import NodeItem
 from .compute_manager import ComputeManager
-
+from .controller import Controller
 
 import logging
 log = logging.getLogger(__name__)
@@ -65,6 +65,14 @@ def __init__(self):
         self._images = []
         self._project = None
         self._main_window = None
+        Controller.instance().connected_signal.connect(self._controllerConnectedSlot)
+
+    def _controllerConnectedSlot(self):
+        """
+        We reset current project because the remote controller could have
+        change location
+        """
+        self.setProject(None)
 
     def setMainWindow(self, main_window):
         self._main_window = main_window