Python local_server_config.LocalServerConfig类代码示例

    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"]:
                # We restart the local server only if we really need. Auth can be hot change
                settings_require_restart = ('host', 'port', 'path')
                need_restart = False
                for s in settings_require_restart:
                    if old_settings.get(s) != self._settings.get(s):
                        need_restart = True

                if need_restart:
                    self.stopLocalServer(wait=True)

                self.localServerAutoStartIfRequire()
            # If the controller is remote:
            else:
                self.stopLocalServer(wait=True)

            if self._settings.get("host") is None:
                self._http_client = None
            else:
                self._http_client = HTTPClient(self._settings)
            Controller.instance().setHttpClient(self._http_client)

def image_manager(tmpdir, images_dir):
    ImageManager._instance = None
    settings = LOCAL_SERVER_SETTINGS
    settings['images_path'] = str(images_dir)
    LocalServerConfig.instance().setConfigFile(str(tmpdir / "test.cfg"))
    with patch('gns3.local_server_config.LocalServerConfig.loadSettings', return_value=LOCAL_SERVER_SETTINGS):
        yield ImageManager.instance()
    ImageManager._instance = None

def test_loadSettings_EmptySettings(tmpdir, local_server):

    with open(str(tmpdir / "test.cfg"), "w+") as f:
        f.write("")
    LocalServerConfig.instance().setConfigFile(str(tmpdir / "test.cfg"))

    assert local_server.localServerSettings()["port"] == 3080
    assert len(local_server.localServerSettings()["password"]) == 64
    assert local_server.localServerSettings()["user"] == "admin"

def test_loadSettings(tmpdir, local_server):
    with open(str(tmpdir / "test.cfg"), "w+") as f:
        f.write("""
[Server]
auth=True
user=world
password=hello""")

    LocalServerConfig.instance().setConfigFile(str(tmpdir / "test.cfg"))
    assert local_server.localServerSettings()["password"] == "hello"

    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 local_server(local_server_path, tmpdir):
    with open(str(tmpdir / "test.cfg"), "w+") as f:
        f.write("""
[Server]
path={}""".format(local_server_path))

    LocalServerConfig.instance().setConfigFile(str(tmpdir / "test.cfg"))
    LocalServer._instance = None
    with patch("gns3.local_server.LocalServer.localServerAutoStartIfRequire"):
        local_server = LocalServer.instance()
        local_server._config_directory = str(tmpdir)
        yield local_server

    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 getDirectory(self):
        """
        Returns the images directory path.

        :returns: path to the default images directory
        """

        return copy.copy(LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)['images_path'])

def local_server_config():
    from gns3.local_server_config import LocalServerConfig

    (fd, config_path) = tempfile.mkstemp()
    os.close(fd)

    LocalServerConfig._instance = LocalServerConfig(config_file=config_path)
    return LocalServerConfig.instance()

    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 _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 localServerSettings(self):
        """
        Returns the local server settings.

        :returns: local server settings (dict)
        """

        settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
        self._settings = copy.copy(settings)

        # user & password
        if settings["auth"] is True and not settings["user"].strip():
            settings["user"] = "admin"
            settings["password"] = self._passwordGenerate()

        # local GNS3 server path
        local_server_path = shutil.which(settings["path"].strip())
        if local_server_path is None:
            default_server_path = shutil.which("gns3server")
            if default_server_path is not None:
                settings["path"] = os.path.abspath(default_server_path)
        else:
            settings["path"] = os.path.abspath(local_server_path)

        # uBridge path
        ubridge_path = shutil.which(settings["ubridge_path"].strip())
        if ubridge_path is None:
            default_ubridge_path = shutil.which("ubridge")
            if default_ubridge_path is not None:
                settings["ubridge_path"] = os.path.abspath(default_ubridge_path)
        else:
            settings["ubridge_path"] = os.path.abspath(ubridge_path)

        if self._settings != settings:
            self.updateLocalServerSettings(settings)
        return settings