def test_startLocalServer(tmpdir, local_config): local_server_path = str(tmpdir / "gns3server") open(local_server_path, "w+").close() with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump({ "Servers": { "local_server": { "path": local_server_path, } }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None with patch("gns3.local_config.LocalConfig.configDirectory") as mock_local_config: mock_local_config.return_value = str(tmpdir) process_mock = MagicMock() with patch("subprocess.Popen", return_value=process_mock) as mock: # If everything work fine the command is still running and a timeout is raised process_mock.communicate.side_effect = subprocess.TimeoutExpired("test", 1) Servers.instance().startLocalServer() mock.assert_called_with([local_server_path, '--host=127.0.0.1', '--port=3080', '--local', '--controller', '--debug', '--log=' + str(tmpdir / "gns3_server.log"), '--pid=' + str(tmpdir / "gns3_server.pid") ])
def gns3vm_server(): from gns3.servers import Servers Servers.instance().initVMServer() print(Servers.instance().vmServer()) return Servers.instance().vmServer()
def validateCurrentPage(self): """ Validates the server. """ if self.currentPage() == self.uiServerWizardPage: # FIXME: prevent users to use "cloud" if self.uiCloudRadioButton.isChecked(): QtGui.QMessageBox.critical(self, "Cloud", "Sorry not implemented yet!") return False if VirtualBox.instance().settings( )["use_local_server"] or self.uiLocalRadioButton.isChecked(): server = Servers.instance().localServer() else: if not Servers.instance().remoteServers(): QtGui.QMessageBox.critical( self, "Remote server", "There is no remote server registered in VirtualBox preferences" ) return False server = self.uiRemoteServersComboBox.itemData( self.uiRemoteServersComboBox.currentIndex()) self._server = server if self.currentPage() == self.uiVirtualBoxWizardPage: if not self.uiVMListComboBox.count(): QtGui.QMessageBox.critical( self, "VirtualBox VMs", "There is no VirtualBox VM available!") return False return True
def validateCurrentPage(self): """ Validates the server. """ if hasattr(self, "uiNameWizardPage") and self.currentPage() == self.uiNameWizardPage: name = self.uiNameLineEdit.text() for device in self._devices.values(): if device["name"] == name: QtWidgets.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False elif self.currentPage() == self.uiServerWizardPage: if self.uiRemoteRadioButton.isChecked(): if not Servers.instance().remoteServers(): QtWidgets.QMessageBox.critical(self, "Remote server", "There is no remote server registered in your preferences") return False self._server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()) elif hasattr(self, "uiVMRadioButton") and self.uiVMRadioButton.isChecked(): gns3_vm_server = Servers.instance().vmServer() if gns3_vm_server is None: QtWidgets.QMessageBox.critical(self, "GNS3 VM", "The GNS3 VM is not running") return False self._server = gns3_vm_server else: self._server = Servers.instance().localServer() return True
def initializePage(self, page_id): if self.page(page_id) == self.uiServerWizardPage: self.uiRemoteServersComboBox.clear() if len(Servers.instance().remoteServers().values()) == 0: self.uiRemoteRadioButton.setEnabled(False) else: for server in Servers.instance().remoteServers().values(): self.uiRemoteServersComboBox.addItem(server.url(), server) if hasattr( self, "uiVMRadioButton") and not GNS3VM.instance().isRunning(): self.uiVMRadioButton.setEnabled(False) if hasattr(self, "uiVMRadioButton") and GNS3VM.instance().isRunning(): self.uiVMRadioButton.setChecked(True) elif self._use_local_server and self.uiLocalRadioButton.isEnabled( ): self.uiLocalRadioButton.setChecked(True) else: if self.uiRemoteRadioButton.isEnabled(): self.uiRemoteRadioButton.setChecked(True) else: self.uiLocalRadioButton.setChecked(True)
def __init__(self, devices, use_local_server, parent): super().__init__(parent) self.setupUi(self) self.setModal(True) self._devices = devices self._use_local_server = use_local_server self.setWizardStyle(QtWidgets.QWizard.ModernStyle) if sys.platform.startswith("darwin"): # we want to see the cancel button on OSX self.setOptions(QtWidgets.QWizard.NoDefaultButton) self.uiRemoteRadioButton.toggled.connect(self._remoteServerToggledSlot) if hasattr(self, "uiVMRadioButton"): self.uiVMRadioButton.toggled.connect(self._vmToggledSlot) self.uiLocalRadioButton.toggled.connect(self._localToggledSlot) if hasattr(self, "uiLoadBalanceCheckBox"): self.uiLoadBalanceCheckBox.toggled.connect(self._loadBalanceToggledSlot) # By default we use the local server self._server = Servers.instance().localServer() self.uiLocalRadioButton.setChecked(True) self._localToggledSlot(True) if Servers.instance().isNonLocalServerConfigured() is False: # skip the server page if we use the local server self.setStartId(1)
def validateCurrentPage(self): """ Validates the server. """ if hasattr(self, "uiNamePlatformWizardPage") and self.currentPage() == self.uiNamePlatformWizardPage: name = self.uiNameLineEdit.text() for device in self._devices.values(): if device["name"] == name: QtWidgets.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False elif self.currentPage() == self.uiServerWizardPage: if self.uiRemoteRadioButton.isChecked(): if not Servers.instance().remoteServers(): QtWidgets.QMessageBox.critical(self, "Remote server", "There is no remote server registered in your preferences") return False self._server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()) elif hasattr(self, "uiVMRadioButton") and self.uiVMRadioButton.isChecked(): gns3_vm_server = Servers.instance().vmServer() if gns3_vm_server is None: QtWidgets.QMessageBox.critical(self, "GNS3 VM", "The GNS3 VM is not running") return False self._server = gns3_vm_server else: self._server = Servers.instance().localServer() return True
def test_startLocalServer(tmpdir, local_config): local_server_path = str(tmpdir / "gns3server") open(local_server_path, "w+").close() with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump({ "Servers": { "local_server": { "path": local_server_path, } }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None with patch("gns3.local_config.LocalConfig.configDirectory") as mock_local_config: mock_local_config.return_value = str(tmpdir) with patch("subprocess.Popen") as mock: Servers.instance().startLocalServer() mock.assert_called_with([local_server_path, '--host=127.0.0.1', '--port=8000', '--local', '--debug', '--log=' + str(tmpdir / "gns3_server.log"), '--pid=' + str(tmpdir / "gns3_server.pid") ])
def validateCurrentPage(self): """ Validates the server. """ if self.currentPage() == self.uiServerWizardPage: # FIXME: prevent users to use "cloud" if self.uiCloudRadioButton.isChecked(): QtGui.QMessageBox.critical(self, "Cloud", "Sorry not implemented yet!") return False if VirtualBox.instance().settings()["use_local_server"] or self.uiLocalRadioButton.isChecked(): server = Servers.instance().localServer() else: if not Servers.instance().remoteServers(): QtGui.QMessageBox.critical(self, "Remote server", "There is no remote server registered in VirtualBox preferences") return False server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()) self._server = server if self.currentPage() == self.uiVirtualBoxWizardPage: if not self.uiVMListComboBox.count(): QtGui.QMessageBox.critical(self, "VirtualBox VMs", "There is no VirtualBox VM available!") return False return True
def test_startLocalServer(tmpdir, local_config): local_server_path = str(tmpdir / "gns3server") open(local_server_path, "w+").close() with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump( { "Servers": { "local_server": { "path": local_server_path, } }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None with patch("gns3.local_config.LocalConfig.configDirectory" ) as mock_local_config: mock_local_config.return_value = str(tmpdir) with patch("subprocess.Popen") as mock: Servers.instance().startLocalServer() mock.assert_called_with([ local_server_path, '--host=127.0.0.1', '--port=8000', '--local', '--debug', '--log=' + str(tmpdir / "gns3_server.log"), '--pid=' + str(tmpdir / "gns3_server.pid") ])
def test_startLocalServer(tmpdir, local_config): local_server_path = str(tmpdir / "gns3server") open(local_server_path, "w+").close() with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump( { "Servers": { "local_server": { "path": local_server_path, } }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None with patch("gns3.local_config.LocalConfig.configDirectory" ) as mock_local_config: mock_local_config.return_value = str(tmpdir) process_mock = MagicMock() with patch("subprocess.Popen", return_value=process_mock) as mock: # If everything work fine the command is still running and a timeout is raised process_mock.communicate.side_effect = subprocess.TimeoutExpired( "test", 1) Servers.instance().startLocalServer() mock.assert_called_with([ local_server_path, '--host=127.0.0.1', '--port=8000', '--local', '--debug', '--log=' + str(tmpdir / "gns3_server.log"), '--pid=' + str(tmpdir / "gns3_server.pid") ])
def gns3vm_server(): from gns3.servers import Servers Servers.instance().initVMServer() print(Servers.instance().vmServer()) return Servers.instance().vmServer()
def validateCurrentPage(self): """ Validates the server. """ if self.currentPage() == self.uiServerWizardPage: if not self.uiCloudRadioButton.isChecked(): if Qemu.instance().settings()["use_local_server"] or self.uiLocalRadioButton.isChecked(): server = Servers.instance().localServer() elif self.uiRemoteRadioButton.isChecked(): if not Servers.instance().remoteServers(): QtGui.QMessageBox.critical(self, "Remote server", "There is no remote server registered in QEMU preferences") return False server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()) self._server = server if self.currentPage() == self.uiNameWizardPage: name = self.uiNameLineEdit.text() for qemu_vm in self._qemu_vms.values(): if qemu_vm["name"] == name: QtGui.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False if self.currentPage() == self.uiBinaryMemoryWizardPage: if not self.uiQemuListComboBox.count(): QtGui.QMessageBox.critical(self, "QEMU binaries", "Sorry, no QEMU binary has been found. Please make sure QEMU is installed before continuing") return False return True
def __init__(self, devices, use_local_server, parent): super().__init__(parent) self.setupUi(self) self.setModal(True) self._devices = devices self._use_local_server = use_local_server self.setWizardStyle(QtWidgets.QWizard.ModernStyle) if sys.platform.startswith("darwin"): # we want to see the cancel button on OSX self.setOptions(QtWidgets.QWizard.NoDefaultButton) self.uiRemoteRadioButton.toggled.connect(self._remoteServerToggledSlot) if hasattr(self, "uiVMRadioButton"): self.uiVMRadioButton.toggled.connect(self._vmToggledSlot) self.uiLocalRadioButton.toggled.connect(self._localToggledSlot) if hasattr(self, "uiLoadBalanceCheckBox"): self.uiLoadBalanceCheckBox.toggled.connect( self._loadBalanceToggledSlot) # By default we use the local server self._server = Servers.instance().localServer() self.uiLocalRadioButton.setChecked(True) self._localToggledSlot(True) if Servers.instance().isNonLocalServerConfigured() is False: # skip the server page if we use the local server self.setStartId(1)
def gns3vm_server(): from gns3.servers import Servers Servers.instance()._settings["vm"]["auto_start"] = True Servers.instance().initVMServer() assert Servers.instance().vmServer() is not None return Servers.instance().vmServer()
def gns3vm_server(): from gns3.servers import Servers Servers.instance()._settings["vm"]["auto_start"] = True Servers.instance().initVMServer() assert Servers.instance().vmServer() is not None return Servers.instance().vmServer()
def savePreferences(self): """ Saves the general preferences. """ servers = Servers.instance() local_server = Servers.instance().localServerSettings() local_server["images_path"] = self.uiImagesPathLineEdit.text() local_server["projects_path"] = self.uiProjectsPathLineEdit.text() local_server["report_errors"] = self.uiCrashReportCheckBox.isChecked() servers.setLocalServerSettings(local_server) new_settings = {} new_settings[ "auto_launch_project_dialog"] = self.uiLaunchNewProjectDialogCheckBox.isChecked( ) new_settings[ "auto_screenshot"] = self.uiAutoScreenshotCheckBox.isChecked() new_settings["style"] = self.uiStyleComboBox.currentText() new_settings[ "check_for_update"] = self.uiCheckForUpdateCheckBox.isChecked() new_settings[ "link_manual_mode"] = self.uiLinkManualModeCheckBox.isChecked() new_settings[ "slow_device_start_all"] = self.uiSlowStartAllSpinBox.value() new_settings[ "telnet_console_command"] = self.uiTelnetConsoleCommandLineEdit.text( ) new_settings[ "serial_console_command"] = self.uiSerialConsoleCommandLineEdit.text( ) new_settings[ "auto_close_console"] = self.uiCloseConsoleWindowsOnDeleteCheckBox.isChecked( ) new_settings[ "bring_console_to_front"] = self.uiBringConsoleWindowToFrontCheckBox.isChecked( ) new_settings[ "delay_console_all"] = self.uiDelayConsoleAllSpinBox.value() from ..main_window import MainWindow MainWindow.instance().setSettings(new_settings) new_settings = {} new_settings["scene_width"] = self.uiSceneWidthSpinBox.value() new_settings["scene_height"] = self.uiSceneHeightSpinBox.value() new_settings[ "draw_rectangle_selected_item"] = self.uiRectangleSelectedItemCheckBox.isChecked( ) new_settings[ "draw_link_status_points"] = self.uiDrawLinkStatusPointsCheckBox.isChecked( ) new_settings[ "default_label_font"] = self.uiDefaultLabelStylePlainTextEdit.font( ).toString() new_settings["default_label_color"] = self._default_label_color.name() MainWindow.instance().uiGraphicsView.setSettings(new_settings)
def test_killAlreadyRunningServer(tmpdir): with patch("gns3.local_config.LocalConfig.configDirectory") as mock_local_config: mock_local_config.return_value = str(tmpdir) with open(str(tmpdir / "gns3_server.pid"), "w+") as f: f.write("42") mock_process = MagicMock() with patch("psutil.Process", return_value=mock_process) as mock: Servers.instance()._killAlreadyRunningServer() mock.assert_called_with(pid=42) assert mock_process.kill.called
def test_killAlreadyRunningServer(tmpdir): with patch("gns3.local_config.LocalConfig.configDirectory") as mock_local_config: mock_local_config.return_value = str(tmpdir) with open(str(tmpdir / "gns3_server.pid"), "w+") as f: f.write("42") mock_process = MagicMock() with patch("psutil.Process", return_value=mock_process) as mock: Servers.instance()._killAlreadyRunningServer() mock.assert_called_with(pid=42) assert mock_process.kill.called
def validateCurrentPage(self): """ Validates the server. """ if self.currentPage() == self.uiServerWizardPage: #FIXME: prevent users to use "cloud" if self.uiCloudRadioButton.isChecked(): QtGui.QMessageBox.critical(self, "Cloud", "Sorry not implemented yet!") return False if Qemu.instance().settings()["use_local_server"] or self.uiLocalRadioButton.isChecked(): server = Servers.instance().localServer() else: server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()) if not server.connected() and ConnectToServer(self, server) is False: return False self._server = server if self.currentPage() == self.uiNameTypeWizardPage: name = self.uiNameLineEdit.text() for qemu_vm in self._qemu_vms.values(): if qemu_vm["name"] == name: QtGui.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False if self.currentPage() == self.uiBinaryMemoryWizardPage: if not self.uiQemuListComboBox.count(): QtGui.QMessageBox.critical(self, "QEMU binaries", "Sorry, no QEMU binary has been found. Please make sure QEMU is installed before continuing") return False return True
def _populateGeneralSettingWidgets(self, settings): """ Populates the widgets with the settings. :param settings: General settings """ local_server = Servers.instance().localServerSettings() self.uiProjectsPathLineEdit.setText(local_server["projects_path"]) self.uiImagesPathLineEdit.setText(local_server["images_path"]) self.uiStatsCheckBox.setChecked(settings["send_stats"]) self.uiCrashReportCheckBox.setChecked(local_server["report_errors"]) self.uiLaunchNewProjectDialogCheckBox.setChecked(settings["auto_launch_project_dialog"]) self.uiAutoScreenshotCheckBox.setChecked(settings["auto_screenshot"]) self.uiCheckForUpdateCheckBox.setChecked(settings["check_for_update"]) self.uiLinkManualModeCheckBox.setChecked(settings["link_manual_mode"]) self.uiSlowStartAllSpinBox.setValue(settings["slow_device_start_all"]) self.uiTelnetConsoleCommandLineEdit.setText(settings["telnet_console_command"]) self.uiTelnetConsoleCommandLineEdit.setCursorPosition(0) index = self.uiStyleComboBox.findText(settings["style"]) if index != -1: self.uiStyleComboBox.setCurrentIndex(index) index = self.uiTelnetConsolePreconfiguredCommandComboBox.findData(settings["telnet_console_command"]) if index != -1: self.uiTelnetConsolePreconfiguredCommandComboBox.setCurrentIndex(index) self.uiSerialConsoleCommandLineEdit.setText(settings["serial_console_command"]) self.uiSerialConsoleCommandLineEdit.setCursorPosition(0) index = self.uiSerialConsolePreconfiguredCommandComboBox.findData(settings["serial_console_command"]) if index != -1: self.uiSerialConsolePreconfiguredCommandComboBox.setCurrentIndex(index) self.uiCloseConsoleWindowsOnDeleteCheckBox.setChecked(settings["auto_close_console"]) self.uiBringConsoleWindowToFrontCheckBox.setChecked(settings["bring_console_to_front"]) self.uiDelayConsoleAllSpinBox.setValue(settings["delay_console_all"])
def get_default_base_config(base_config_template_path): """ Copy the default base config template to settings directory (if not already present) and returns the path. :param base_config_template_path: path to the base config template :return: path to the base config """ servers = Servers.instance() config_dir = servers.localServerSettings()["configs_path"] if base_config_template_path: try: os.makedirs(config_dir, exist_ok=True) except OSError as e: log.error("could not create the base configs directory {}: {}".format(config_dir, e)) return "" try: base_config_path = os.path.join(config_dir, os.path.basename(base_config_template_path)) if not os.path.isfile(base_config_path): shutil.copyfile(base_config_template_path, base_config_path) return os.path.normpath(base_config_path) except OSError as e: log.error("could not copy {} to {}: {}".format(base_config_template_path, base_config_path, e)) return ""
def __init__(self): super().__init__() self.setupUi(self) self._widget_slots = {0: self.uiSlot0comboBox, 1: self.uiSlot1comboBox, 2: self.uiSlot2comboBox, 3: self.uiSlot3comboBox, 4: self.uiSlot4comboBox, 5: self.uiSlot5comboBox, 6: self.uiSlot6comboBox} self._widget_wics = {0: self.uiWic0comboBox, 1: self.uiWic1comboBox, 2: self.uiWic2comboBox} self.uiStartupConfigToolButton.clicked.connect(self._startupConfigBrowserSlot) self.uiPrivateConfigToolButton.clicked.connect(self._privateConfigBrowserSlot) self.uiSymbolToolButton.clicked.connect(self._symbolBrowserSlot) self.uiIOSImageToolButton.clicked.connect(self._iosImageBrowserSlot) self._server = None self._idle_valid = False idle_pc_rgx = QtCore.QRegExp("^(0x[0-9a-fA-F]{8})?$") validator = QtGui.QRegExpValidator(idle_pc_rgx, self) self.uiIdlepcLineEdit.setValidator(validator) self.uiIdlepcLineEdit.textChanged.connect(self._idlePCValidateSlot) self.uiIdlepcLineEdit.textChanged.emit(self.uiIdlepcLineEdit.text()) self._default_configs_dir = Servers.instance().localServerSettings()["configs_path"] # add the categories for name, category in Node.defaultCategories().items(): self.uiCategoryComboBox.addItem(name, category)
def nodes(self): """ Returns all the node data necessary to represent a node in the nodes view and create a node on the scene. """ server = "local" if not self._settings["use_local_server"]: # pick up a remote server (round-robin method) remote_server = next(iter(Servers.instance())) if remote_server: server = "{}:{}".format(remote_server.host, remote_server.port) nodes = [] for node_class in VPCS.classes(): nodes.append({ "class": node_class.__name__, "name": node_class.symbolName(), "server": server, "categories": node_class.categories(), "default_symbol": node_class.defaultSymbol(), "hover_symbol": node_class.hoverSymbol() }) if ENABLE_CLOUD: nodes.append({ "class": node_class.__name__, "name": node_class.symbolName() + " (cloud)", "server": "cloud", "categories": node_class.categories(), "default_symbol": node_class.defaultSymbol(), "hover_symbol": node_class.hoverSymbol() }) return nodes
def _iosImageSaveSlot(self): """ Adds/Saves an IOS image. """ path = self.uiIOSPathLineEdit.text() startup_config = self.uiStartupConfigLineEdit.text() private_config = self.uiPrivateConfigLineEdit.text() platform = self.uiPlatformComboBox.currentText() chassis = self.uiChassisComboBox.currentText() idlepc = self.uiIdlePCLineEdit.text() ram = self.uiRAMSpinBox.value() # basename doesn't work on Unix with Windows paths if not sys.platform.startswith('win') and len(path) > 2 and path[1] == ":": import ntpath image = ntpath.basename(path) else: image = os.path.basename(path) if image.startswith("c7200p"): QtGui.QMessageBox.warning(self, "IOS Image", "This IOS image is for the c7200 platform with NPE-G2 and using it is not recommended.\nPlease use an IOS image that do not start with c7200p.") #TODO: mutiple remote server if Dynamips.instance().settings()["use_local_server"]: server = "local" else: server = server = next(iter(Servers.instance())).host #ios_images = Dynamips.instance().iosImages() key = "{server}:{image}".format(server=server, image=image) item = self.uiIOSImagesTreeWidget.currentItem() if key in self._ios_images and item and item.text(0) == image: item.setText(0, image) item.setText(1, platform) item.setText(2, server) elif key in self._ios_images: print("Image already added") return else: # add a new entry in the tree widget item = QtGui.QTreeWidgetItem(self.uiIOSImagesTreeWidget) item.setText(0, image) item.setText(1, platform) item.setText(2, server) self.uiIOSImagesTreeWidget.setCurrentItem(item) self._ios_images[key] = {"path": path, "image": image, "startup_config": startup_config, "private_config": private_config, "platform": platform, "chassis": chassis, "idlepc": idlepc, "ram": ram, "server": server} self.uiIOSImagesTreeWidget.resizeColumnToContents(0) self.uiIOSImagesTreeWidget.resizeColumnToContents(1)
def allocateServer(self, node_class, use_cloud=False): """ Allocates a server. :param node_class: Node object :returns: allocated server (HTTPClient instance) """ # allocate a server for the node servers = Servers.instance() if use_cloud: from ...topology import Topology topology = Topology.instance() top_instance = topology.anyInstance() server = servers.getCloudServer(top_instance.host, top_instance.port, top_instance.ssl_ca_file) else: if self._settings["use_local_server"]: # use the local server server = servers.localServer() else: # pick up a remote server (round-robin method) server = next(iter(servers)) if not server: raise ModuleError("No remote server is configured") return server
def createNode(self, node_class, server=None): """ Creates a new node. :param node_class: Node object :param server: optional WebSocketClient instance """ log.info("creating node {}".format(node_class)) # allocate a server for the node if none is given servers = Servers.instance() if self._settings["use_local_server"] and not server: # use the local server server = servers.localServer() elif not server: # pick up a remote server (round-robin method) server = next(iter(servers)) if not server: raise ModuleError("No remote server is configured") if not server.connected(): try: log.info("reconnecting to server {}:{}".format(server.host, server.port)) server.reconnect() except OSError as e: raise ModuleError("Could not connect to server {}:{}: {}".format(server.host, server.port, e)) if server not in self._servers: self.addServer(server) # create an instance of the node class return node_class(self, server)
def nodes(self): """ Returns all the node data necessary to represent a node in the nodes view and create a node on the scene. """ if self._settings["use_local_server"]: server = "local" elif GNS3VM.instance().isRunning(): server = "vm" else: remote_server = next(iter(Servers.instance())) if remote_server: server = remote_server.url() else: # If user has no server configured and has uncheck the checkbox # Â it's a mistake. We use the GNS3VM in order to show a correct # Â error message server = "vm" nodes = [] for node_class in VPCS.classes(): nodes.append( { "class": node_class.__name__, "name": node_class.symbolName(), "server": server, "categories": [self._settings["category"]], "symbol": self._settings["symbol"], } ) return nodes
def _configFileValid(self, path): """ Return true if it's a valid configuration file """ if not os.path.isabs(path): path = os.path.join(Servers.instance().localServerSettings()["configs_path"], path) return os.access(path, os.R_OK)
def initializePage(self, page_id): if self.page(page_id) == self.uiServerWizardPage: self.uiRemoteServersComboBox.clear() for server in Servers.instance().remoteServers().values(): self.uiRemoteServersComboBox.addItem( "{}:{}".format(server.host, server.port), server) if self.page(page_id) == self.uiBinaryMemoryWizardPage: if self.uiCloudRadioButton.isChecked(): for binary in QEMU_BINARIES_FOR_CLOUD: self.uiQemuListComboBox.addItem( "{path}".format(path=binary), binary) # Default to x86_64 for the user index = self.uiQemuListComboBox.findData( "x86_64", flags=QtCore.Qt.MatchEndsWith) if index != -1: self.uiQemuListComboBox.setCurrentIndex(index) else: try: Qemu.instance().getQemuBinariesFromServer( self._server, self._getQemuBinariesFromServerCallback) except ModuleError as e: QtGui.QMessageBox.critical( self, "Qemu binaries", "Error while getting the QEMU binaries: {}".format(e))
def test_getRemoteServer(): servers = Servers.instance() http_server = servers.getRemoteServer("http", "localhost", 3080, None) assert http_server.protocol() == "http" assert http_server.host() == "localhost" assert http_server.port() == 3080 assert http_server.user() is None
def nodes(self): """ Returns all the node data necessary to represent a node in the nodes view and create a node on the scene. """ server = "local" if not self._settings["use_local_server"]: # pick up a remote server (round-robin method) remote_server = next(iter(Servers.instance())) if remote_server: server = "{}:{}".format(remote_server.host, remote_server.port) nodes = [] for node_class in VPCS.classes(): nodes.append( {"class": node_class.__name__, "name": node_class.symbolName(), "server": server, "categories": node_class.categories(), "default_symbol": node_class.defaultSymbol(), "hover_symbol": node_class.hoverSymbol()} ) if ENABLE_CLOUD: nodes.append( {"class": node_class.__name__, "name": node_class.symbolName() + " (cloud)", "server": "cloud", "categories": node_class.categories(), "default_symbol": node_class.defaultSymbol(), "hover_symbol": node_class.hoverSymbol()} ) return nodes
def _getVMsFromServerCallback(self, result, error=False, **kwargs): """ Callback for getVMsFromServer. :param progress_dialog: QProgressDialog instance :param result: server response :param error: indicates an error (boolean) """ if error: QtWidgets.QMessageBox.critical(self, "VM List", "{}".format(result["message"])) else: self.uiVMListComboBox.clear() for vm in result: self.uiVMListComboBox.addItem(vm["vmname"], vm.get("vmx_path", "")) gns3_vm = Servers.instance().vmSettings() index = self.uiVMListComboBox.findText(gns3_vm["vmname"]) if index != -1: self.uiVMListComboBox.setCurrentIndex(index) else: index = self.uiVMListComboBox.findText("GNS3 VM") if index != -1: self.uiVMListComboBox.setCurrentIndex(index) else: QtWidgets.QMessageBox.critical(self, "GNS3 VM", "Could not find a VM named 'GNS3 VM', is it imported in VMware or VirtualBox?")
def _getVMsFromServerCallback(self, result, error=False, **kwargs): """ Callback for getVMsFromServer. :param progress_dialog: QProgressDialog instance :param result: server response :param error: indicates an error (boolean) """ if error: QtWidgets.QMessageBox.critical(self, "VM List", "{}".format(result["message"])) else: self.uiVMListComboBox.clear() for vm in result: self.uiVMListComboBox.addItem(vm["vmname"], vm.get("vmx_path", "")) gns3_vm = Servers.instance().vmSettings() index = self.uiVMListComboBox.findText(gns3_vm["vmname"]) if index != -1: self.uiVMListComboBox.setCurrentIndex(index) else: index = self.uiVMListComboBox.findText("GNS3 VM") if index != -1: self.uiVMListComboBox.setCurrentIndex(index) else: QtWidgets.QMessageBox.critical(self, "GNS3 VM", "Could not find a VM named 'GNS3 VM', is it imported in VMware or VirtualBox?")
def __init__(self, parent): super().__init__(parent) self.setupUi(self) self.setWizardStyle(QtWidgets.QWizard.ModernStyle) if sys.platform.startswith("darwin"): # we want to see the cancel button on OSX self.setOptions(QtWidgets.QWizard.NoDefaultButton) self._server = Servers.instance().localServer() self.uiGNS3VMDownloadLinkUrlLabel.setText('') self.uiRefreshPushButton.clicked.connect(self._refreshVMListSlot) self.uiVmwareRadioButton.clicked.connect(self._listVMwareVMsSlot) self.uiVirtualBoxRadioButton.clicked.connect(self._listVirtualBoxVMsSlot) self.uiVMwareBannerButton.clicked.connect(self._VMwareBannerButtonClickedSlot) settings = parent.settings() self.uiShowCheckBox.setChecked(settings["hide_setup_wizard"]) # by default all radio buttons are unchecked self.uiVmwareRadioButton.setAutoExclusive(False) self.uiVirtualBoxRadioButton.setAutoExclusive(False) self.uiVmwareRadioButton.setChecked(False) self.uiVirtualBoxRadioButton.setChecked(False) if sys.platform.startswith("darwin"): self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_fusion_banner.jpg")) else: self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_workstation_banner.jpg"))
def __init__(self, parent): super().__init__(parent) self.setupUi(self) self.setWizardStyle(QtWidgets.QWizard.ModernStyle) if sys.platform.startswith("darwin"): # we want to see the cancel button on OSX self.setOptions(QtWidgets.QWizard.NoDefaultButton) self._server = Servers.instance().localServer() self.uiGNS3VMDownloadLinkUrlLabel.setText('') self.uiRefreshPushButton.clicked.connect(self._refreshVMListSlot) self.uiVmwareRadioButton.clicked.connect(self._listVMwareVMsSlot) self.uiVirtualBoxRadioButton.clicked.connect(self._listVirtualBoxVMsSlot) self.uiVMwareBannerButton.clicked.connect(self._VMwareBannerButtonClickedSlot) settings = parent.settings() self.uiShowCheckBox.setChecked(settings["hide_setup_wizard"]) # by default all radio buttons are unchecked self.uiVmwareRadioButton.setAutoExclusive(False) self.uiVirtualBoxRadioButton.setAutoExclusive(False) self.uiVmwareRadioButton.setChecked(False) self.uiVirtualBoxRadioButton.setChecked(False) if sys.platform.startswith("darwin"): self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_fusion_banner.jpg")) else: self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_workstation_banner.jpg"))
def __init__(self): super().__init__() self.setupUi(self) self._widget_slots = {0: self.uiSlot0comboBox, 1: self.uiSlot1comboBox, 2: self.uiSlot2comboBox, 3: self.uiSlot3comboBox, 4: self.uiSlot4comboBox, 5: self.uiSlot5comboBox, 6: self.uiSlot6comboBox} self._widget_wics = {0: self.uiWic0comboBox, 1: self.uiWic1comboBox, 2: self.uiWic2comboBox} self.uiStartupConfigToolButton.clicked.connect(self._startupConfigBrowserSlot) self.uiPrivateConfigToolButton.clicked.connect(self._privateConfigBrowserSlot) self.uiSymbolToolButton.clicked.connect(self._symbolBrowserSlot) self.uiIOSImageToolButton.clicked.connect(self._iosImageBrowserSlot) self._server = None self._idle_valid = False idle_pc_rgx = QtCore.QRegExp("^(0x[0-9a-fA-F]{8})?$") validator = QtGui.QRegExpValidator(idle_pc_rgx, self) self.uiIdlepcLineEdit.setValidator(validator) self.uiIdlepcLineEdit.textChanged.connect(self._idlePCValidateSlot) self.uiIdlepcLineEdit.textChanged.emit(self.uiIdlepcLineEdit.text()) self._default_configs_dir = Servers.instance().localServerSettings()["configs_path"] # add the categories for name, category in Node.defaultCategories().items(): self.uiCategoryComboBox.addItem(name, category)
def _readBaseConfig(self, config_path): """ Returns a base config content. :param config_path: path to the configuration file. :returns: config content """ if config_path is None or len(config_path.strip()) == 0: return None if not os.path.isabs(config_path): config_path = os.path.join(Servers.instance().localServerSettings()["configs_path"], config_path) if not os.path.isfile(config_path): return None try: with open(config_path, "rb") as f: log.info("Opening configuration file: {}".format(config_path)) config = f.read().decode("utf-8") config = config.replace('\r', "") return config except OSError as e: self.error_signal.emit(self.id(), "Could not read configuration file {}: {}".format(config_path, e)) return None except UnicodeDecodeError as e: self.error_signal.emit(self.id(), "Invalid configuration file {}: {}".format(config_path, e)) return None return ""
def nodes(self): """ Returns all the node data necessary to represent a node in the nodes view and create a node on the scene. """ if self._settings["use_local_server"]: server = "local" elif GNS3VM.instance().isRunning(): server = "vm" else: remote_server = next(iter(Servers.instance())) if remote_server: server = remote_server.url() else: # If user has no server configured and has uncheck the checkbox #Â it's a mistake. We use the GNS3VM in order to show a correct #Â error message server = "vm" nodes = [] for node_class in VPCS.classes(): nodes.append({ "class": node_class.__name__, "name": node_class.symbolName(), "server": server, "categories": [self._settings["category"]], "symbol": self._settings["symbol"] }) return nodes
def _populateGeneralSettingWidgets(self, settings): """ Populates the widgets with the settings. :param settings: General settings """ local_server = Servers.instance().localServerSettings() self.uiProjectsPathLineEdit.setText(local_server["projects_path"]) self.uiSymbolsPathLineEdit.setText(local_server["symbols_path"]) self.uiImagesPathLineEdit.setText(local_server["images_path"]) self.uiConfigsPathLineEdit.setText(local_server["configs_path"]) self.uiStatsCheckBox.setChecked(settings["send_stats"]) self.uiCrashReportCheckBox.setChecked(local_server["report_errors"]) self.uiLaunchNewProjectDialogCheckBox.setChecked(settings["auto_launch_project_dialog"]) self.uiAutoScreenshotCheckBox.setChecked(settings["auto_screenshot"]) self.uiCheckForUpdateCheckBox.setChecked(settings["check_for_update"]) self.uiLinkManualModeCheckBox.setChecked(settings["link_manual_mode"]) self.uiExperimentalFeaturesCheckBox.setChecked(settings["experimental_features"]) self.uiSlowStartAllSpinBox.setValue(settings["slow_device_start_all"]) self.uiTelnetConsoleCommandLineEdit.setText(settings["telnet_console_command"]) self.uiTelnetConsoleCommandLineEdit.setCursorPosition(0) index = self.uiStyleComboBox.findText(settings["style"]) if index != -1: self.uiStyleComboBox.setCurrentIndex(index) self.uiSerialConsoleCommandLineEdit.setText(settings["serial_console_command"]) self.uiSerialConsoleCommandLineEdit.setCursorPosition(0) self.uiCloseConsoleWindowsOnDeleteCheckBox.setChecked(settings["auto_close_console"]) self.uiBringConsoleWindowToFrontCheckBox.setChecked(settings["bring_console_to_front"]) self.uiDelayConsoleAllSpinBox.setValue(settings["delay_console_all"]) self.uiVNCConsoleCommandLineEdit.setText(settings["vnc_console_command"]) self.uiVNCConsoleCommandLineEdit.setCursorPosition(0)
def initializePage(self, page_id): if self.page(page_id) == self.uiServerWizardPage: self.uiRemoteServersComboBox.clear() for server in Servers.instance().remoteServers().values(): self.uiRemoteServersComboBox.addItem("{}:{}".format(server.host, server.port), server) elif self.page(page_id) == self.uiNamePlatformWizardPage: self.uiNameLineEdit.setText(self.uiPlatformComboBox.currentText()) ios_image = self.uiIOSImageLineEdit.text() self.setWindowTitle("New IOS router - {}".format(os.path.basename(ios_image))) elif self.page(page_id) == self.uiMemoryWizardPage: # set the correct amount of RAM based on the platform from ..pages.ios_router_preferences_page import IOSRouterPreferencesPage platform = self.uiPlatformComboBox.currentText() path = self.uiIOSImageLineEdit.text() if os.path.isfile(path): minimum_required_ram = IOSRouterPreferencesPage.getMinimumRequiredRAM(path) if minimum_required_ram > PLATFORMS_DEFAULT_RAM[platform]: self.uiRamSpinBox.setValue(minimum_required_ram) else: self.uiRamSpinBox.setValue(PLATFORMS_DEFAULT_RAM[platform]) else: self.uiRamSpinBox.setValue(PLATFORMS_DEFAULT_RAM[platform]) elif self.page(page_id) == self.uiNetworkAdaptersWizardPage: platform = self.uiPlatformComboBox.currentText() chassis = self.uiChassisComboBox.currentText() if not chassis: chassis = "" self._populateAdapters(platform, chassis) if platform == "c7200": self.uiSlot0comboBox.setCurrentIndex(self.uiSlot0comboBox.findText("C7200-IO-FE"))
def validateCurrentPage(self): """ Validates the IOS name and checks validation state for Idle-PC value """ if self.currentPage() == self.uiNamePlatformWizardPage: name = self.uiNameLineEdit.text() for ios_router in self._ios_routers.values(): if ios_router["name"] == name: QtGui.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False if self.currentPage() == self.uiMemoryWizardPage and self.uiPlatformComboBox.currentText() == "c7200": if self.uiRamSpinBox.value() > 512: QtGui.QMessageBox.critical(self, "c7200 RAM requirement", "c7200 routers with NPE-400 are limited to 512MB of RAM") return False if self.currentPage() == self.uiIdlePCWizardPage: if not self._idle_valid: idle_pc = self.uiIdlepcLineEdit.text() QtGui.QMessageBox.critical(self, "Idle-PC", "{} is not a valid Idle-PC value ".format(idle_pc)) return False if self.currentPage() == self.uiServerWizardPage and self.uiRemoteRadioButton.isChecked(): if not Servers.instance().remoteServers(): QtGui.QMessageBox.critical(self, "Remote server", "There is no remote server registered in Dynamips preferences") return False return True
def allocateServer(self, node_class, use_cloud=False): """ Allocates a server. :param node_class: Node object :returns: allocated server (HTTPClient instance) """ # allocate a server for the node servers = Servers.instance() if use_cloud: from ...topology import Topology topology = Topology.instance() top_instance = topology.anyInstance() server = servers.getCloudServer(top_instance.host, top_instance.port, top_instance.ssl_ca_file) else: if self._settings["use_local_server"]: # use the local server server = servers.localServer() else: # pick up a remote server (round-robin method) server = next(iter(servers)) if not server: raise ModuleError("No remote server is configured") return server
def __init__(self): super().__init__() self.setupUi(self) self.uiSymbolToolButton.clicked.connect(self._symbolBrowserSlot) self.uiStartupConfigToolButton.clicked.connect( self._startupConfigBrowserSlot) self.uiPrivateConfigToolButton.clicked.connect( self._privateConfigBrowserSlot) self.uiIOUImageToolButton.clicked.connect(self._iouImageBrowserSlot) self.uiDefaultValuesCheckBox.stateChanged.connect( self._useDefaultValuesSlot) self._current_iou_image = "" self._server = None # location of the base config templates self._base_iou_l2_config_template = get_resource( os.path.join("configs", "iou_l2_base_startup-config.txt")) self._base_iou_l3_config_template = get_resource( os.path.join("configs", "iou_l3_base_startup-config.txt")) self._default_configs_dir = Servers.instance().localServerSettings( )["configs_path"] # add the categories for name, category in Node.defaultCategories().items(): self.uiCategoryComboBox.addItem(name, category)
def _configFileValid(self, path): """ Return true if it's a valid configuration file """ if not os.path.isabs(path): path = os.path.join(Servers.instance().localServerSettings()["configs_path"], path) return os.access(path, os.R_OK)
def __init__(self, qemu_vms, parent): QtGui.QWizard.__init__(self, parent) self.setupUi(self) self.setPixmap(QtGui.QWizard.LogoPixmap, QtGui.QPixmap(":/icons/qemu.svg")) self.setWizardStyle(QtGui.QWizard.ModernStyle) self.uiRemoteRadioButton.toggled.connect(self._remoteServerToggledSlot) self.uiHdaDiskImageToolButton.clicked.connect(self._hdaDiskImageBrowserSlot) self.uiHdbDiskImageToolButton.clicked.connect(self._hdbDiskImageBrowserSlot) self.uiInitrdToolButton.clicked.connect(self._initrdBrowserSlot) self.uiKernelImageToolButton.clicked.connect(self._kernelImageBrowserSlot) self.uiTypeComboBox.currentIndexChanged[str].connect(self._typeChangedSlot) # Available types self.uiTypeComboBox.addItems(["Default", "ASA 8.4(2)", "IDS"]) # Mandatory fields self.uiNameTypeWizardPage.registerField("vm_name*", self.uiNameLineEdit) self.uiDiskWizardPage.registerField("hda_disk_image*", self.uiHdaDiskImageLineEdit) self.uiDiskImageHdbWizardPage.registerField("hdb_disk_image*", self.uiHdbDiskImageLineEdit) self.uiASAWizardPage.registerField("initrd*", self.uiInitrdLineEdit) self.uiASAWizardPage.registerField("kernel_image*", self.uiKernelImageLineEdit) self._qemu_vms = qemu_vms if Qemu.instance().settings()["use_local_server"]: # skip the server page if we use the local server self.setStartId(1) # By default we use the local server self._server = Servers.instance().localServer()
def _readBaseConfig(self, config_path): """ Returns a base config content. :param config_path: path to the configuration file. :returns: config content """ if config_path is None or len(config_path.strip()) == 0: return None if not os.path.isabs(config_path): config_path = os.path.join(Servers.instance().localServerSettings()["configs_path"], config_path) if not os.path.isfile(config_path): return None try: with open(config_path, "rb") as f: log.info("Opening configuration file: {}".format(config_path)) config = f.read().decode("utf-8") config = config.replace('\r', "") return config except OSError as e: self.error_signal.emit(self.id(), "Could not read configuration file {}: {}".format(config_path, e)) return None except UnicodeDecodeError as e: self.error_signal.emit(self.id(), "Invalid configuration file {}: {}".format(config_path, e)) return None return ""
def _testSettingsSlot(self): QtGui.QMessageBox.critical(self, "Test settings", "Sorry, not yet implemented!") return servers = Servers.instance() if self.uiUseLocalServercheckBox.isChecked(): server = servers.localServer() else: QtGui.QMessageBox.critical(self, "Test settings", "Sorry, not yet implemented!") try: if not server.connected(): server.reconnect() except OSError as e: QtGui.QMessageBox.critical(self, "Local server", "Could not connect to the local server {host} on port {port}: {error}".format(host=server.host, port=server.port, error=e)) self._progress_dialog = QtGui.QProgressDialog("Testing settings...", "Cancel", 0, 0, parent=self) self._progress_dialog.setWindowModality(QtCore.Qt.WindowModal) self._progress_dialog.setWindowTitle("Settings") self._progress_dialog.show() iou_module = IOU.instance() if server not in iou_module.servers(): server_added = True iou_module.addServer(server) self.savePreferences() if server_added: iou_module.removeServer(server) server.send_message("iou.test_settings", None, self._testSettingsCallback)
def checkUbridgePermission(self): """Check if ubridge has the correct permission""" if not sys.platform.startswith("win") and os.geteuid() == 0: # we are root, so we should have privileged access. return (0, None) path = Servers.instance().localServerSettings().get("ubridge_path") if path is None: return (0, None) if not os.path.exists(path): return (2, "Ubridge path {path} doesn't exists".format(path=path)) request_setuid = False if sys.platform.startswith("linux"): if "security.capability" in os.listxattr(path): caps = os.getxattr(path, "security.capability") # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set if not struct.unpack("<IIIII", caps)[1] & 1 << 13: return(2, "Ubridge require CAP_NET_RAW. Run sudo setcap cap_net_admin,cap_net_raw=ep {path}".format(path=path)) else: # capabilities not supported request_setuid = True if sys.platform.startswith("darwin") or request_setuid: if os.stat(path).st_uid != 0 or not os.stat(path).st_mode & stat.S_ISUID: return (2, "Ubridge should be setuid. Run sudo chown root {path} and sudo chmod 4755 {path}".format(path=path)) return (0, None)
def test_getRemoteServer(): servers = Servers.instance() http_server = servers.getRemoteServer("http", "localhost", 8000, None) assert http_server.protocol() == "http" assert http_server.host() == "localhost" assert http_server.port() == 8000 assert http_server.user() is None
def test_loadSettingsWith13LocalServerSetting(tmpdir, local_config): with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump({ "Servers": { "local_server": { "auth": True, "user": "******", "password": "******" } }, "LocalServer": { "auth": False }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None servers = Servers.instance() local_server = local_config.loadSectionSettings("LocalServer", {}) assert local_server["auth"] == True assert local_server["user"] == "world" assert local_server["password"] == "hello"
def validateCurrentPage(self): """ Validates the IOS name and checks validation state for Idle-PC value """ if self.currentPage() == self.uiNamePlatformWizardPage: name = self.uiNameLineEdit.text() for ios_router in self._ios_routers.values(): if ios_router["name"] == name: QtGui.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name)) return False if self.currentPage() == self.uiMemoryWizardPage and self.uiPlatformComboBox.currentText() == "c7200": if self.uiRamSpinBox.value() > 512: QtGui.QMessageBox.critical(self, "c7200 RAM requirement", "c7200 routers with NPE-400 are limited to 512MB of RAM") return False if self.currentPage() == self.uiIdlePCWizardPage: if not self._idle_valid: idle_pc = self.uiIdlepcLineEdit.text() QtGui.QMessageBox.critical(self, "Idle-PC", "{} is not a valid Idle-PC value ".format(idle_pc)) return False if self.currentPage() == self.uiServerWizardPage and self.uiRemoteRadioButton.isChecked(): if not Servers.instance().remoteServers(): QtGui.QMessageBox.critical(self, "Remote server", "There is no remote server registered in Dynamips preferences") return False return True
def test_loadSettingsWith13LocalServerSetting(tmpdir, local_config): with open(str(tmpdir / "test.cfg"), "w+") as f: json.dump( { "Servers": { "local_server": { "auth": True, "user": "******", "password": "******" } }, "LocalServer": { "auth": False }, "version": "1.4" }, f) local_config.setConfigFilePath(str(tmpdir / "test.cfg")) Servers._instance = None servers = Servers.instance() local_server = local_config.loadSectionSettings("LocalServer", {}) assert local_server["auth"] == True assert local_server["user"] == "world" assert local_server["password"] == "hello"
def getSettings(self): """ Returns the settings set in this Wizard. :return: settings dict """ path = self.uiIOUImageLineEdit.text() initial_config = "" if self.uiTypeComboBox.currentText() == "L2 image": # set the default L2 base initial-config default_base_config = get_default_base_config( self._base_iou_l2_config_template) if default_base_config: initial_config = default_base_config default_symbol = ":/symbols/multilayer_switch.normal.svg" hover_symbol = ":/symbols/multilayer_switch.selected.svg" category = Node.switches ethernet_adapters = 4 serial_adapters = 0 else: # set the default L3 base initial-config default_base_config = get_default_base_config( self._base_iou_l3_config_template) if default_base_config: initial_config = default_base_config default_symbol = ":/symbols/router.normal.svg" hover_symbol = ":/symbols/router.selected.svg" category = Node.routers ethernet_adapters = 2 serial_adapters = 2 if IOU.instance().settings( )["use_local_server"] or self.uiLocalRadioButton.isChecked(): server = "local" elif self.uiRemoteRadioButton.isChecked(): if self.uiLoadBalanceCheckBox.isChecked(): server = next(iter(Servers.instance())) server = "{}:{}".format(server.host, server.port) else: server = self.uiRemoteServersComboBox.currentText() else: # Cloud is selected server = "cloud" settings = { "name": self.uiNameLineEdit.text(), "path": path, "image": os.path.basename(path), "initial_config": initial_config, "ethernet_adapters": ethernet_adapters, "serial_adapters": serial_adapters, "default_symbol": default_symbol, "category": category, "hover_symbol": hover_symbol, "server": server, } return settings
def test_handle_handleSslErrors(): """ Simulate when user accept an insecure certificate. This should be save to the configuration """ servers = Servers.instance() servers._addRemoteServer("https", "127.0.0.1", "443", user="******", password="******") servers._saveSettings() assert servers._settings["remote_servers"] == [{ 'accept_insecure_certificate': None, 'host': '127.0.0.1', 'password': '******', 'port': 443, 'protocol': 'https', 'url': 'https://[email protected]:443', 'user': '******' }] reply = MagicMock() reply.url.return_value.toDisplayString.return_value = "https://[email protected]:443/v1/version" ssl_error = MagicMock() ssl_error.certificate.return_value.digest.return_value = binascii.unhexlify( "cca0a932ced2fb1b1a18c823542cb065") errorList = [ssl_error] with patch("gns3.qt.QtWidgets.QMessageBox.warning") as message_box_mock: message_box_mock.return_value = QtWidgets.QMessageBox.Yes servers._handleSslErrors(reply, errorList) servers._saveSettings() assert len(servers._settings["remote_servers"]) == 1 assert servers._settings["remote_servers"] == [{ 'accept_insecure_certificate': 'cca0a932ced2fb1b1a18c823542cb065', 'host': '127.0.0.1', 'password': '******', 'port': 443, 'protocol': 'https', 'url': 'https://[email protected]:443', 'user': '******' }]
def test_getServerFromString_with_user(): servers = Servers.instance() server = servers.getServerFromString("http://[email protected]:4000") assert server.protocol() == "http" assert server.host() == "127.0.0.1" assert server.port() == 4000 assert server.user() == "root"
def test_getServerFromString(): servers = Servers.instance() server = servers.getServerFromString("127.0.0.1:4000") assert server.protocol() == "http" assert server.host() == "127.0.0.1" assert server.port() == 4000 assert server.user() is None
def test_getServerFromString_with_user(): servers = Servers.instance() server = servers.getServerFromString("http://[email protected]:4000") assert server.protocol() == "http" assert server.host() == "127.0.0.1" assert server.port() == 4000 assert server.user() == "root"