def _saveIOSRouters(self): """ Saves the IOS routers to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, {"routers": list(self._ios_routers.values())})
def _saveQemuVMs(self): """ Saves the QEMU VMs to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, {"vms": list(self._qemu_vms.values())})
def _exportDebugCallback(self, result, error=False, **kwargs): log.info("Export debug information to %s", self._path) try: with ZipFile(self._path, 'w') as zip: zip.writestr("debug.txt", self._getDebugData()) dir = LocalConfig.instance().configDirectory() for filename in os.listdir(dir): path = os.path.join(dir, filename) if os.path.isfile(path): zip.write(path, filename) dir = os.path.join(LocalConfig.instance().configDirectory(), "debug") if os.path.exists(dir): for filename in os.listdir(dir): path = os.path.join(dir, filename) if os.path.isfile(path): zip.write(path, filename) if self._project: dir = self._project.filesDir() if dir: for filename in os.listdir(dir): path = os.path.join(dir, filename) if os.path.isfile(path): zip.write(path, filename) except OSError as e: QtWidgets.QMessageBox.critical(self, "Debug", "Can't export debug information: {}".format(str(e))) self.accept()
def _event_received(self, result, *args, **kwargs): # Log only relevant events if result["action"] not in ("ping", "compute.updated"): log.debug("Event received: %s", result) if result["action"] == "node.created": node = Topology.instance().getNodeFromUuid(result["event"]["node_id"]) if node is None: Topology.instance().createNode(result["event"]) elif result["action"] == "node.updated": node = Topology.instance().getNodeFromUuid(result["event"]["node_id"]) if node is not None: node.updateNodeCallback(result["event"]) elif result["action"] == "node.deleted": node = Topology.instance().getNodeFromUuid(result["event"]["node_id"]) if node is not None: node.delete(skip_controller=True) elif result["action"] == "link.created": link = Topology.instance().getLinkFromUuid(result["event"]["link_id"]) if link is None: Topology.instance().createLink(result["event"]) elif result["action"] == "link.updated": link = Topology.instance().getLinkFromUuid(result["event"]["link_id"]) if link is not None: link.updateLinkCallback(result["event"]) elif result["action"] == "link.deleted": link = Topology.instance().getLinkFromUuid(result["event"]["link_id"]) if link is not None: link.deleteLink(skip_controller=True) elif result["action"] == "drawing.created": drawing = Topology.instance().getDrawingFromUuid(result["event"]["drawing_id"]) if drawing is None: Topology.instance().createDrawing(result["event"]) elif result["action"] == "drawing.updated": drawing = Topology.instance().getDrawingFromUuid(result["event"]["drawing_id"]) if drawing is not None: drawing.updateDrawingCallback(result["event"]) elif result["action"] == "drawing.deleted": drawing = Topology.instance().getDrawingFromUuid(result["event"]["drawing_id"]) if drawing is not None: drawing.delete(skip_controller=True) elif result["action"] == "project.closed": Topology.instance().setProject(None) elif result["action"] == "project.updated": self._projectUpdatedCallback(result["event"]) elif result["action"] == "snapshot.restored": Topology.instance().createLoadProject({"project_id": result["event"]["project_id"]}) elif result["action"] == "log.error": log.error(result["event"]["message"]) elif result["action"] == "log.warning": log.warning(result["event"]["message"]) elif result["action"] == "log.info": log.info(result["event"]["message"], extra={"show": True}) elif result["action"] == "compute.created" or result["action"] == "compute.updated": cm = ComputeManager.instance() cm.computeDataReceivedCallback(result["event"]) elif result["action"] == "settings.updated": LocalConfig.instance().refreshConfigFromController() ApplianceManager.instance().refresh() elif result["action"] == "ping": pass
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) # save some settings to the local server config file server_settings = { "allocate_aux_console_ports": self._settings["allocate_aux_console_ports"], "ghost_ios_support": self._settings["ghost_ios_support"], "sparse_memory_support": self._settings["sparse_memory_support"], "mmap_support": self._settings["mmap_support"], } if self._settings["dynamips_path"]: server_settings["dynamips_path"] = os.path.normpath( self._settings["dynamips_path"]) config = LocalServerConfig.instance() config.saveSettings(self.__class__.__name__, server_settings)
def _saveIOUDevices(self): """ Saves the IOU devices to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, {"devices": list(self._iou_devices.values())})
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)
def _saveVirtualBoxVMs(self): """ Saves the VirtualBox VMs to the client settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, {"vms": list(self._virtualbox_vms.values())})
def __init__(self): self._id = None self._closed = True self._closing = False self._files_dir = None self._images_dir = None self._auto_start = False self._auto_open = False self._auto_close = False config = LocalConfig.instance() graphic_settings = LocalConfig.instance().loadSectionSettings( "GraphicsView", GRAPHICS_VIEW_SETTINGS) self._scene_width = graphic_settings["scene_width"] self._scene_height = graphic_settings["scene_height"] self._zoom = graphic_settings.get("zoom", None) self._show_layers = graphic_settings.get("show_layers", False) self._snap_to_grid = graphic_settings.get("snap_to_grid", False) self._show_grid = graphic_settings.get("show_grid", False) self._show_interface_labels = graphic_settings.get( "show_interface_labels", False) self._show_interface_labels_on_new_project = config.showInterfaceLabelsOnNewProject( ) self._name = "untitled" self._filename = None # Due to bug in Qt on some version we need a dedicated network manager self._notification_network_manager = QtNetwork.QNetworkAccessManager() self._notification_stream = None super().__init__()
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)
def removePushButtonClickedSlot(self): """ Remove the custom command from the custom list """ self._settings[self._console_type].pop(self.uiCommandComboBox.currentText()) LocalConfig.instance().saveSectionSettings("CustomConsoleCommands", self._settings) self._current = None self._refreshList()
def local_config(): from gns3.local_config import LocalConfig (fd, config_path) = tempfile.mkstemp() os.close(fd) LocalConfig._instance = LocalConfig(config_file=config_path) return LocalConfig.instance()
def _saveVirtualBoxVMs(self): """ Saves the VirtualBox VMs to the client settings file. """ # save the settings LocalConfig.instance().saveSectionSettings( self.__class__.__name__, {"vms": list(self._virtualbox_vms.values())})
def startLocalServer(self): """ Starts the local server process. """ self._stopping = False path = self.localServerPath() command = '"{executable}" --local'.format(executable=path) if LocalConfig.instance().profile(): command += " --profile {}".format(LocalConfig.instance().profile()) if self._settings["allow_console_from_anywhere"]: # allow connections to console from remote addresses command += " --allow" if logging.getLogger().isEnabledFor(logging.DEBUG): command += " --debug" settings_dir = self._config_directory if os.path.isdir(settings_dir): # save server logging info to a file in the settings directory logpath = os.path.join(settings_dir, "gns3_server.log") if os.path.isfile(logpath): # delete the previous log file try: os.remove(logpath) except FileNotFoundError: pass except OSError as e: log.warning( "could not delete server log file {}: {}".format( logpath, e)) command += ' --log="{}" --pid="{}"'.format(logpath, self._pid_path()) log.debug("Starting local server process with {}".format(command)) try: if sys.platform.startswith("win"): # use the string on Windows self._local_server_process = subprocess.Popen( command, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP, stderr=subprocess.PIPE) else: # use arguments on other platforms args = shlex.split(command) self._local_server_process = subprocess.Popen( args, stderr=subprocess.PIPE) except (OSError, subprocess.SubprocessError) as e: log.warning('Could not start local server "{}": {}'.format( command, e)) return False log.debug("Local server process has started (PID={})".format( self._local_server_process.pid)) return True
def _saveIOUDevices(self): """ Saves the IOU devices to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings( self.__class__.__name__, {"devices": list(self._iou_devices.values())})
def test_migrate13Config(tmpdir): config_file = str(tmpdir / "gns3_gui.conf") local_config = LocalConfig(config_file=config_file) server_config = { "allow_console_from_anywhere": True, "auth": False, "auto_start": True, "console_end_port_range": 5000, "console_start_port_range": 2001, "host": "127.0.0.1", "images_path": "/home/gns3/GNS3/images", "password": "", "path": "/bin/gns3server", "port": 8001, "projects_path": "/home/gns3/GNS3/projects", "report_errors": False, "udp_end_port_range": 20000, "udp_start_port_range": 10000, "user": "" } with open(config_file, "w+") as f: f.write(json.dumps({ "LocalServer": server_config, "RemoteServers": [ server_config ], "GUI": { "hide_getting_started_dialog": True }, "type": "settings", "version": "1.3.7"})) local_config._readConfig(config_file) local_config._migrateOldConfig() # The old config should not be erased in order to avoid losing data when rollback to 1.3 assert local_config._settings["LocalServer"] == server_config assert local_config._settings["RemoteServers"] == [server_config] assert local_config._settings["Servers"]["local_server"] == server_config assert local_config._settings["Servers"]["remote_servers"] == [server_config] assert local_config._settings["MainWindow"]["hide_getting_started_dialog"] # When the file is migrated to 1.4 we should not try to modify it with open(config_file, "w+") as f: f.write(json.dumps({ "LocalServer": {"host": "error"}, "type": "settings", "version": "1.4.2"})) local_config._readConfig(config_file) local_config._migrateOldConfig() assert local_config._settings["LocalServer"]["host"] == "error" assert local_config._settings["Servers"]["local_server"]["host"] == "127.0.0.1"
def removePushButtonClickedSlot(self): """ Remove the custom command from the custom list """ self._settings[self._console_type].pop( self.uiCommandComboBox.currentText()) LocalConfig.instance().saveSectionSettings("CustomConsoleCommands", self._settings) self._current = None self._refreshList()
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) server_settings = {"enable_hardware_acceleration": self._settings["enable_hardware_acceleration"], "require_hardware_acceleration": self._settings["require_hardware_acceleration"]} LocalServerConfig.instance().saveSettings(self.__class__.__name__, server_settings)
def savePushButtonClickedSlot(self): """ Save a custom command to the list """ name, ok = QtWidgets.QInputDialog.getText(self, "Add a command", "Command name:", QtWidgets.QLineEdit.Normal) command = self.uiCommandPlainTextEdit.toPlainText().strip() if ok and len(command) > 0: if command not in self._consoles.values(): self._settings[self._console_type][name] = command self._current = command LocalConfig.instance().saveSectionSettings("CustomConsoleCommands", self._settings) self._refreshList()
def _saveSettings(self): """ Saves the settings to the server settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) # save some settings to the local server config file if self._settings["vboxmanage_path"]: server_settings = {"vboxmanage_path": os.path.normpath(self._settings["vboxmanage_path"])} LocalServerConfig.instance().saveSettings(self.__class__.__name__, server_settings)
def test_migrate13Config(tmpdir): local_config = LocalConfig() config_file = str(tmpdir / "gns3_gui.conf") server_config = { "allow_console_from_anywhere": True, "auth": False, "auto_start": True, "console_end_port_range": 5000, "console_start_port_range": 2001, "host": "127.0.0.1", "images_path": "/home/gns3/GNS3/images", "password": "", "path": "/bin/gns3server", "port": 8001, "projects_path": "/home/gns3/GNS3/projects", "report_errors": False, "udp_end_port_range": 20000, "udp_start_port_range": 10000, "user": "" } with open(config_file, "w+") as f: f.write(json.dumps({ "LocalServer": server_config, "RemoteServers": [ server_config ], "GUI": { "hide_getting_started_dialog": True }, "type": "settings", "version": "1.3.7"})) local_config._readConfig(config_file) local_config._migrateOldConfig() # The old config should not be erased in order to avoid losing data when rollback to 1.3 assert local_config._settings["LocalServer"] == server_config assert local_config._settings["RemoteServers"] == [server_config] assert local_config._settings["Servers"]["local_server"] == server_config assert local_config._settings["Servers"]["remote_servers"] == [server_config] assert local_config._settings["MainWindow"]["hide_getting_started_dialog"] == True # When the file is migrated to 1.4 we should not try to modify it with open(config_file, "w+") as f: f.write(json.dumps({ "LocalServer": {"host": "error"}, "type": "settings", "version": "1.4.2"})) local_config._readConfig(config_file) local_config._migrateOldConfig() assert local_config._settings["LocalServer"]["host"] == "error" assert local_config._settings["Servers"]["local_server"]["host"] == "127.0.0.1"
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) if self._settings["vpcs_path"]: # save some settings to the server config file server_settings = {"vpcs_path": os.path.normpath(self._settings["vpcs_path"])} config = LocalServerConfig.instance() config.saveSettings(self.__class__.__name__, server_settings)
def _importConfigurationFileSlot(self): """ Slot to import a configuration file. """ configuration_file_path = LocalConfig.instance().configFilePath() directory = os.path.dirname(configuration_file_path) path = QtGui.QFileDialog.getOpenFileName( self, "Import configuration file", directory, "Configuration file (*.ini *.conf);;All files (*.*)") if not path: return try: with open(path, encoding="utf-8") as f: config_file = json.load(f) if "type" not in config_file or config_file["type"] != "settings": QtGui.QMessageBox.critical( self, "Import configuration file", "Not a GNS3 configuration file: {}".format(path)) return except OSError as e: QtGui.QMessageBox.critical( self, "Import configuration file", "Could not load configuration file {}: {}".format( os.path.basename(path), e)) return except ValueError as e: QtGui.QMessageBox.critical(self, "Import configuration file", "Invalid file: {}".format(e)) return try: shutil.copyfile(path, configuration_file_path) except (shutil.Error, IOError) as e: QtGui.QMessageBox.critical( self, "Import configuration file", "Cannot import configuration file: {}".format(e)) return QtGui.QMessageBox.information( self, "Configuration file", "Configuration file imported, default settings will be applied after a restart" ) # TODO: implement restart # QtCore.QProcess.startDetached(QtGui.QApplication.arguments()[0], QtGui.QApplication.arguments()) # QtGui.QApplication.quit() LocalConfig.instance().setConfigFilePath(configuration_file_path) self._preferences_dialog.reject()
def _saveSettings(self): """ Saves the settings to the server settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) # save some settings to the local server config file if self._settings["vboxmanage_path"]: server_settings = { "vboxmanage_path": os.path.normpath(self._settings["vboxmanage_path"]) } LocalServerConfig.instance().saveSettings(self.__class__.__name__, server_settings)
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) server_settings = {} if self._settings["vpcs_path"]: # save some settings to the server config file server_settings["vpcs_path"] = os.path.normpath(self._settings["vpcs_path"]) config = LocalServerConfig.instance() config.saveSettings(self.__class__.__name__, server_settings)
def savePushButtonClickedSlot(self): """ Save a custom command to the list """ name, ok = QtWidgets.QInputDialog.getText(self, "Add a command", "Command name:", QtWidgets.QLineEdit.Normal) command = self.uiCommandPlainTextEdit.toPlainText().strip() if ok and len(command) > 0: if command not in self._consoles.values(): self._settings[self._console_type][name] = command self._current = command LocalConfig.instance().saveSectionSettings( "CustomConsoleCommands", self._settings) self._refreshList()
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) # save some settings to the local server config file if sys.platform.startswith("linux"): server_settings = { "enable_kvm": self._settings["enable_kvm"], } LocalServerConfig.instance().saveSettings(self.__class__.__name__, server_settings)
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) server_settings = {} config = LocalServerConfig.instance() if self._settings["default_nat_interface"]: # save some settings to the local server config file server_settings["default_nat_interface"] = self._settings["default_nat_interface"] config.saveSettings(self.__class__.__name__, server_settings) else: config.deleteSetting(self.__class__.__name__, "default_nat_interface")
def startLocalServer(self): """ Starts the local server process. """ self._stopping = False path = self.localServerPath() command = '"{executable}" --local'.format(executable=path) if LocalConfig.instance().profile(): command += " --profile {}".format(LocalConfig.instance().profile()) if self._settings["allow_console_from_anywhere"]: # allow connections to console from remote addresses command += " --allow" if logging.getLogger().isEnabledFor(logging.DEBUG): command += " --debug" settings_dir = self._config_directory if os.path.isdir(settings_dir): # save server logging info to a file in the settings directory logpath = os.path.join(settings_dir, "gns3_server.log") if os.path.isfile(logpath): # delete the previous log file try: os.remove(logpath) except FileNotFoundError: pass except OSError as e: log.warn("could not delete server log file {}: {}".format(logpath, e)) command += ' --log="{}" --pid="{}"'.format(logpath, self._pid_path()) log.info("Starting local server process with {}".format(command)) try: if sys.platform.startswith("win"): # use the string on Windows self._local_server_process = subprocess.Popen(command, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP, stderr=subprocess.PIPE) else: # use arguments on other platforms args = shlex.split(command) self._local_server_process = subprocess.Popen(args, stderr=subprocess.PIPE) except (OSError, subprocess.SubprocessError) as e: log.warning('Could not start local server "{}": {}'.format(command, e)) return False log.info("Local server process has started (PID={})".format(self._local_server_process.pid)) return True
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the Dynamips settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in DYNAMIPS_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value(name, type=DYNAMIPS_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings(self.__class__.__name__, DYNAMIPS_SETTINGS) if not os.path.exists(self._settings["dynamips_path"]): self._settings["dynamips_path"] = self._findDynamips(self) # keep the config file sync self._saveSettings()
def _loadSettings(self): """ Loads the settings from the server settings file. """ local_config = LocalConfig.instance() # restore the VirtualBox settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in VBOX_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value( name, type=VBOX_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings( self.__class__.__name__, VBOX_SETTINGS) if not os.path.exists(self._settings["vboxmanage_path"]): self._settings["vboxmanage_path"] = self._findVBoxManage(self) # keep the config file sync self._saveSettings()
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the VPCS settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in VPCS_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value(name, type=VPCS_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings(self.__class__.__name__, VPCS_SETTINGS) if not self._settings["base_script_file"]: self._settings["base_script_file"] = get_default_base_config(get_resource(os.path.join("configs", "vpcs_base_config.txt"))) if not os.path.exists(self._settings["vpcs_path"]): self._settings["vpcs_path"] = self._findVPCS(self) # keep the config file sync self._saveSettings()
def __init__(self, parent=None): super().__init__() self.setupUi(self) self._remote_servers = {} self._preferences_dialog = parent # Display the path of the config file config_file_path = LocalConfig.instance().configFilePath() self.uiConfigurationFileLabel.setText(config_file_path) self.uiProjectsPathToolButton.clicked.connect(self._projectsPathSlot) self.uiSymbolsPathToolButton.clicked.connect(self._symbolsPathSlot) self.uiImagesPathToolButton.clicked.connect(self._imagesPathSlot) self.uiConfigsPathToolButton.clicked.connect(self._configsPathSlot) self.uiImportConfigurationFilePushButton.clicked.connect(self._importConfigurationFileSlot) self.uiExportConfigurationFilePushButton.clicked.connect(self._exportConfigurationFileSlot) self.uiRestoreDefaultsPushButton.clicked.connect(self._restoreDefaultsSlot) self.uiTelnetConsolePreconfiguredCommandPushButton.clicked.connect(self._telnetConsolePreconfiguredCommandSlot) self.uiSerialConsolePreconfiguredCommandPushButton.clicked.connect(self._serialConsolePreconfiguredCommandSlot) self.uiVNCConsolePreconfiguredCommandPushButton.clicked.connect(self._vncConsolePreconfiguredCommandSlot) self.uiDefaultLabelFontPushButton.clicked.connect(self._setDefaultLabelFontSlot) self.uiDefaultLabelColorPushButton.clicked.connect(self._setDefaultLabelColorSlot) self._default_label_color = QtGui.QColor(QtCore.Qt.black) self.uiStyleComboBox.addItems(STYLES)
def __init__(self, parent=None): if parent is None: self._main = QtWidgets.QMainWindow() self._main.hide() parent = self._main super().__init__(parent) self.setupUi(self) self.uiNewPushButton.clicked.connect(self._newPushButtonSlot) self.uiDeletePushButton.clicked.connect(self._deletePushButtonSlot) # Center on screen screen = QtWidgets.QApplication.desktop().screenGeometry() self.move(screen.center() - self.rect().center()) if sys.platform.startswith("win"): appdata = os.path.expandvars("%APPDATA%") path = os.path.join(appdata, "GNS3") else: home = os.path.expanduser("~") path = os.path.join(home, ".config", "GNS3") self.profiles_path = os.path.join(path, "profiles") self.uiShowAtStartupCheckBox.setChecked(LocalConfig.instance().multiProfiles()) self._refresh()
def _loadVMwareVMs(self): """ Load the VMware VMs from the client settings file. """ local_config = LocalConfig.instance() settings = local_config.settings() if "vms" in settings.get(self.__class__.__name__, {}): for vm in settings[self.__class__.__name__]["vms"]: name = vm.get("name") server = vm.get("server") key = "{server}:{name}".format(server=server, name=name) if key in self._vmware_vms or not name or not server: continue vm_settings = VMWARE_VM_SETTINGS.copy() vm_settings.update(vm) # for backward compatibility before version 1.4 if "symbol" not in vm_settings: vm_settings["symbol"] = vm_settings.get( "default_symbol", vm_settings["symbol"]) vm_settings["symbol"] = vm_settings[ "symbol"][:-11] + ".svg" if vm_settings[ "symbol"].endswith( "normal.svg") else vm_settings["symbol"] self._vmware_vms[key] = vm_settings
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the VPCS settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in VPCS_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value( name, type=VPCS_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings( self.__class__.__name__, VPCS_SETTINGS) if not self._settings["base_script_file"]: self._settings["base_script_file"] = get_default_base_config( get_resource(os.path.join("configs", "vpcs_base_config.txt"))) if not os.path.exists(self._settings["vpcs_path"]): self._settings["vpcs_path"] = self._findVPCS(self) # keep the config file sync self._saveSettings()
def _loadVirtualBoxVMs(self): """ Load the VirtualBox VMs from the client settings file. """ self._virtualbox_vms = {} settings = LocalConfig.instance().settings() if "vms" in settings.get(self.__class__.__name__, {}): for vm in settings[self.__class__.__name__]["vms"]: vmname = vm.get("vmname") server = vm.get("server") key = "{server}:{vmname}".format(server=server, vmname=vmname) if key in self._virtualbox_vms or not vmname or not server: continue vm_settings = VBOX_VM_SETTINGS.copy() vm_settings.update(vm) # For backward compatibility we use vmname if not vm_settings["name"]: vm_settings["name"] = vmname # for backward compatibility before version 1.4 if "symbol" not in vm_settings: vm_settings["symbol"] = vm_settings.get( "default_symbol", vm_settings["symbol"]) vm_settings["symbol"] = vm_settings[ "symbol"][:-11] + ".svg" if vm_settings[ "symbol"].endswith( "normal.svg") else vm_settings["symbol"] self._virtualbox_vms[key] = vm_settings
def _loadIOUDevices(self): """ Load the IOU devices from the persistent settings file. """ settings = LocalConfig.instance().settings() if "devices" in settings.get(self.__class__.__name__, {}): for device in settings[self.__class__.__name__]["devices"]: name = device.get("name") server = device.get("server") key = "{server}:{name}".format(server=server, name=name) if key in self._iou_devices or not name or not server: continue device_settings = IOU_DEVICE_SETTINGS.copy() device_settings.update(device) # for backward compatibility before version 1.4 if "symbol" not in device_settings: device_settings["symbol"] = device_settings[ "default_symbol"] device_settings["symbol"] = device_settings[ "symbol"][:-11] + ".svg" if device_settings[ "symbol"].endswith( "normal.svg") else device_settings["symbol"] device_settings["startup_config"] = device_settings.get( "initial_config", device_settings["startup_config"]) self._iou_devices[key] = device_settings
def _loadSettings(self): """ Loads the settings from the server settings file. """ local_config = LocalConfig.instance() # restore the VirtualBox settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in VBOX_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value(name, type=VBOX_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings(self.__class__.__name__, VBOX_SETTINGS) if not os.path.exists(self._settings["vboxmanage_path"]): self._settings["vboxmanage_path"] = self._findVBoxManage(self) # keep the config file sync self._saveSettings()
def _configurationFile(self): if sys.platform.startswith("win"): filename = "gns3_gui.ini" else: filename = "gns3_gui.conf" directory = LocalConfig.configDirectory() return os.path.join(directory, filename)
def __init__(self): self._id = None self._closed = True self._closing = False self._files_dir = None self._images_dir = None self._auto_start = False self._auto_open = False self._auto_close = False graphic_settings = LocalConfig.instance().loadSectionSettings(self.__class__.__name__, GRAPHICS_VIEW_SETTINGS) self._scene_width = graphic_settings["scene_width"] self._scene_height = graphic_settings["scene_height"] self._zoom = graphic_settings.get("zoom", None) self._show_layers = graphic_settings.get("show_layers", False) self._snap_to_grid = graphic_settings.get("snap_to_grid", False) self._show_grid = graphic_settings.get("show_grid", False) self._show_interface_labels = graphic_settings.get("show_interface_labels", False) self._name = "untitled" self._filename = None # Due to bug in Qt on some version we need a dedicated network manager self._notification_network_manager = QtNetwork.QNetworkAccessManager() self._notification_stream = None super().__init__()
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() self._settings = local_config.loadSectionSettings(self.__class__.__name__, BUILTIN_SETTINGS)
def __init__(self, parent=None): QtGui.QWidget.__init__(self) self.setupUi(self) self._remote_servers = {} self._preferences_dialog = parent # Load the pre-configured console commands for name, cmd in sorted(PRECONFIGURED_TELNET_CONSOLE_COMMANDS.items()): self.uiTelnetConsolePreconfiguredCommandComboBox.addItem(name, cmd) for name, cmd in sorted(PRECONFIGURED_SERIAL_CONSOLE_COMMANDS.items()): self.uiSerialConsolePreconfiguredCommandComboBox.addItem(name, cmd) # Display the path of the config file config_file_path = LocalConfig.instance().configFilePath() self.uiConfigurationFileLabel.setText(config_file_path) self.uiProjectsPathToolButton.clicked.connect(self._projectsPathSlot) self.uiImagesPathToolButton.clicked.connect(self._imagesPathSlot) self.uiImportConfigurationFilePushButton.clicked.connect( self._importConfigurationFileSlot) self.uiExportConfigurationFilePushButton.clicked.connect( self._exportConfigurationFileSlot) self.uiRestoreDefaultsPushButton.clicked.connect( self._restoreDefaultsSlot) self.uiTelnetConsolePreconfiguredCommandPushButton.clicked.connect( self._telnetConsolePreconfiguredCommandSlot) self.uiSerialConsolePreconfiguredCommandPushButton.clicked.connect( self._serialConsolePreconfiguredCommandSlot) self.uiDefaultLabelFontPushButton.clicked.connect( self._setDefaultLabelFontSlot) self.uiDefaultLabelColorPushButton.clicked.connect( self._setDefaultLabelColorSlot) self._default_label_color = QtGui.QColor(QtCore.Qt.black) self.uiStyleComboBox.addItems(STYLES)
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the Qemu settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in QEMU_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value( name, type=QEMU_SETTING_TYPES[name]) settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings( self.__class__.__name__, QEMU_SETTINGS) # keep the config file sync self._saveSettings()
def _saveSettings(self): """ Saves the settings to the persistent settings file. """ # save the settings LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings) # save some settings to the local server config file server_settings = { "iourc_path": self._settings["iourc_path"], "iouyap_path": self._settings["iouyap_path"], "license_check": self._settings["license_check"] } config = LocalServerConfig.instance() config.saveSettings(self.__class__.__name__, server_settings)
def __init__(self, parent=None): QtGui.QWidget.__init__(self) self.setupUi(self) self._remote_servers = {} self._preferences_dialog = parent # Load the pre-configured console commands for name, cmd in sorted(PRECONFIGURED_TELNET_CONSOLE_COMMANDS.items()): self.uiTelnetConsolePreconfiguredCommandComboBox.addItem(name, cmd) for name, cmd in sorted(PRECONFIGURED_SERIAL_CONSOLE_COMMANDS.items()): self.uiSerialConsolePreconfiguredCommandComboBox.addItem(name, cmd) # Display the path of the config file config_file_path = LocalConfig.instance().configFilePath() self.uiConfigurationFileLabel.setText(config_file_path) self.uiProjectsPathToolButton.clicked.connect(self._projectsPathSlot) self.uiImagesPathToolButton.clicked.connect(self._imagesPathSlot) self.uiImportConfigurationFilePushButton.clicked.connect(self._importConfigurationFileSlot) self.uiExportConfigurationFilePushButton.clicked.connect(self._exportConfigurationFileSlot) self.uiRestoreDefaultsPushButton.clicked.connect(self._restoreDefaultsSlot) self.uiTelnetConsolePreconfiguredCommandPushButton.clicked.connect(self._telnetConsolePreconfiguredCommandSlot) self.uiSerialConsolePreconfiguredCommandPushButton.clicked.connect(self._serialConsolePreconfiguredCommandSlot) self.uiDefaultLabelFontPushButton.clicked.connect(self._setDefaultLabelFontSlot) self.uiDefaultLabelColorPushButton.clicked.connect(self._setDefaultLabelColorSlot) self._default_label_color = QtGui.QColor(QtCore.Qt.black) self.uiStyleComboBox.addItems(STYLES)
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the IOU settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in IOU_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value( name, type=IOU_SETTING_TYPES[name]) if "iourc" in legacy_settings: legacy_settings["iourc_path"] = legacy_settings["iourc"] del legacy_settings["iourc"] settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings( self.__class__.__name__, IOU_SETTINGS) if sys.platform.startswith("linux") and not os.path.exists( self._settings["iouyap_path"]): iouyap_path = shutil.which("iouyap") if iouyap_path: self._settings["iouyap_path"] = iouyap_path # keep the config file sync self._saveSettings()
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ self._settings = LocalConfig.instance().loadSectionSettings(self.__class__.__name__, QEMU_SETTINGS) self._loadQemuVMs()
def _loadSettings(self): """ Loads the settings from the persistent settings file. """ local_config = LocalConfig.instance() # restore the IOU settings from QSettings (for backward compatibility) legacy_settings = {} settings = QtCore.QSettings() settings.beginGroup(self.__class__.__name__) for name in IOU_SETTINGS.keys(): if settings.contains(name): legacy_settings[name] = settings.value(name, type=IOU_SETTING_TYPES[name]) if "iourc" in legacy_settings: legacy_settings["iourc_path"] = legacy_settings["iourc"] del legacy_settings["iourc"] settings.remove("") settings.endGroup() if legacy_settings: local_config.saveSectionSettings(self.__class__.__name__, legacy_settings) self._settings = local_config.loadSectionSettings(self.__class__.__name__, IOU_SETTINGS) if sys.platform.startswith("linux") and not os.path.exists(self._settings["iouyap_path"]): iouyap_path = shutil.which("iouyap") if iouyap_path: self._settings["iouyap_path"] = iouyap_path # keep the config file sync self._saveSettings()
def _okButtonClickedSlot(self): path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export debug file", None, "Zip file (*.zip)", "Zip file (*.zip)") if len(path) == 0: self.reject() return log.info("Export debug information to %s", path) try: with ZipFile(path, 'w') as zip: zip.writestr("debug.txt", self._getDebugData()) dir = LocalConfig.configDirectory() for filename in os.listdir(dir): path = os.path.join(dir, filename) if os.path.isfile(path): zip.write(path, filename) dir = self._project.filesDir() if dir: for filename in os.listdir(dir): path = os.path.join(dir, filename) if os.path.isfile(path): zip.write(path, filename) except OSError as e: QtWidgets.QMessageBox.critical(self, "Debug", "Can't export debug information: {}".format(str(e))) self.accept()