vantage6 5.0.0a22__py3-none-any.whl → 5.0.0a29__py3-none-any.whl

vantage6/cli/config.py

@@ -0,0 +1,260 @@
+import os
+from os import PathLike
+from pathlib import Path
+
+import questionary
+import yaml
+from colorama import Fore, Style
+from kubernetes import config
+
+from vantage6.common import info, warning
+
+from vantage6.cli.globals import (
+    DEFAULT_CLI_CONFIG_FILE,
+)
+
+
+class CliConfig:
+    """
+    A class to manage CLI configuration for Kubernetes context and namespace.
+
+    The CLI configuration is stored in a `config.yaml` file located at the path
+    specified by `DEFAULT_CLI_CONFIG_FILE`.
+
+    The `config.yaml` file has the following structure:
+
+    ```yaml
+    kube:
+      last_context: <last_used_k8s_context>
+      last_namespace: <last_used_k8s_namespace>
+    ```
+
+    Attributes
+    ----------
+    config_path : PathLike
+        Path to the configuration file.
+    _cached_config : dict or None
+        Cached configuration data.
+    _cached_mtime : float or None
+        Last modification time of the configuration file.
+    """
+
+    def __init__(self, config_path: str | PathLike = DEFAULT_CLI_CONFIG_FILE) -> None:
+        """
+        Initialize the CliConfig object.
+
+        Parameters
+        ----------
+        config_path : str or PathLike, optional
+            Path to the configuration file.
+        """
+        self.config_path: PathLike = Path(config_path)
+        self._cached_config: dict | None = None
+        self._cached_mtime: float | None = None
+
+    def _load_config(self) -> dict:
+        """
+        Load the configuration from the file.
+
+        Returns
+        -------
+        dict
+            The loaded configuration data.
+        """
+        if self.config_path.exists():
+            with open(self.config_path, "r") as config_file:
+                return yaml.safe_load(config_file) or {}
+        return {}
+
+    def _save_config(self, config: dict) -> None:
+        """
+        Save the configuration to the file.
+
+        Parameters
+        ----------
+        config : dict
+            The configuration data to save.
+        """
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w") as config_file:
+            yaml.dump(config, config_file)
+
+    def _reload_cache_lazy(self) -> None:
+        """
+        Reload the configuration cache if the file has been modified.
+        """
+        if self.config_path.exists():
+            mtime = os.path.getmtime(self.config_path)
+            if self._cached_mtime != mtime:
+                self._cached_config = self._load_config()
+                self._cached_mtime = mtime
+        else:
+            self._cached_config = {}
+            self._cached_mtime = None
+
+    def get_last_context(self) -> str | None:
+        """
+        Get the last used Kubernetes context.
+
+        Returns
+        -------
+        str or None
+            The last used Kubernetes context, or None if not set.
+        """
+        self._reload_cache_lazy()
+        return self._cached_config.get("kube", {}).get("last_context")
+
+    def set_last_context(self, context: str) -> None:
+        """
+        Set the Kubernetes context.
+
+        Parameters
+        ----------
+        context : str
+            The Kubernetes context to set.
+        """
+        config = self._load_config()
+        if "kube" not in config:
+            config["kube"] = {}
+
+        if config["kube"].get("last_context") != context:
+            config["kube"]["last_context"] = context
+            self._save_config(config)
+            self._reload_cache_lazy()
+
+    def get_last_namespace(self) -> str | None:
+        """
+        Get the last used Kubernetes namespace.
+
+        Returns
+        -------
+        str or None
+            The last used Kubernetes namespace, or None if not set.
+        """
+        self._reload_cache_lazy()
+        return self._cached_config.get("kube", {}).get("last_namespace")
+
+    def set_last_namespace(self, namespace: str) -> None:
+        """
+        Set the Kubernetes namespace.
+
+        Parameters
+        ----------
+        namespace : str
+            The Kubernetes namespace to set.
+        """
+        config = self._load_config()
+        if "kube" not in config:
+            config["kube"] = {}
+
+        if config["kube"].get("last_namespace") != namespace:
+            config["kube"]["last_namespace"] = namespace
+            self._save_config(config)
+            self._reload_cache_lazy()
+
+    def remove_kube(self) -> None:
+        """
+        Remove the last used context and namespace.
+        """
+        if self.config_path.exists():
+            config = self._load_config()
+            if "kube" in config:
+                del config["kube"]
+                self._save_config(config)
+                self._reload_cache_lazy()
+
+    def get_active_settings(
+        self,
+        context: str | None,
+        namespace: str | None,
+    ) -> tuple[str, str]:
+        """
+        Get the active Kubernetes context and namespace.
+
+        Parameters
+        ----------
+        context : str or None
+            The Kubernetes context to use.
+        namespace : str or None
+            The Kubernetes namespace to use.
+
+        Returns
+        -------
+        tuple[str, str]
+            A tuple containing the active context and namespace.
+        """
+        if not context:
+            _, active_context = config.list_kube_config_contexts()
+            context = active_context["name"]
+
+        if not namespace:
+            namespace = active_context["context"].get("namespace", "default")
+
+        return context, namespace
+
+    def compare_changes_config(
+        self,
+        context: str | None = None,
+        namespace: str | None = None,
+    ) -> tuple[str, str]:
+        """
+        Compare active settings with last used settings.
+
+        Parameters
+        ----------
+        context : str or None, optional
+            The Kubernetes context to use.
+        namespace : str or None, optional
+            The Kubernetes namespace to use.
+
+        Returns
+        -------
+        tuple[str, str]
+            A tuple containing the active context and namespace.
+        """
+
+        active_context, active_namespace = self.get_active_settings(context, namespace)
+        last_context = self.get_last_context()
+        last_namespace = self.get_last_namespace()
+
+        # compare context
+        if not last_context:
+            self.set_last_context(context=active_context)
+        elif last_context != active_context:
+            warning("Are you using the correct context?")
+            warning(f"Current context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
+            warning(f"Last    context: {Fore.YELLOW}{last_context}{Style.RESET_ALL}")
+
+            active_context = questionary.select(
+                "Which context do you want to use?",
+                choices=[active_context, last_context],
+                default=active_context,
+            ).ask()
+
+            if last_context != active_context:
+                self.set_last_context(context=active_context)
+
+        # compare namespace
+        if not last_namespace:
+            self.set_last_namespace(namespace=active_namespace)
+        elif last_namespace != active_namespace:
+            warning("Are you using the correct namespace?")
+            warning(
+                f"Current namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}"
+            )
+            warning(
+                f"Last    namespace: {Fore.YELLOW}{last_namespace}{Style.RESET_ALL}"
+            )
+
+            active_namespace = questionary.select(
+                "Which namespace do you want to use?",
+                choices=[active_namespace, last_namespace],
+                default=active_namespace,
+            ).ask()
+
+            if last_namespace != active_namespace:
+                self.set_last_namespace(namespace=active_namespace)
+
+        info(f"Using    context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
+        info(f"Using  namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}")
+        return active_context, active_namespace

vantage6/cli/configuration_manager.py

@@ -1,4 +1,6 @@
-from schema import And, Or, Use, Optional
+from typing import Self
+
+from schema import And, Optional, Or, Use
 
 from vantage6.common.configuration_manager import Configuration, ConfigurationManager
 
@@ -20,17 +22,8 @@ class ServerConfiguration(Configuration):
     validators.
     """
 
-    VALIDATORS = {
-        "description": Use(str),
-        "ip": Use(str),
-        "port": Use(int),
-        Optional("api_path"): str,
-        "uri": Use(str),
-        "allow_drop_all": Use(bool),
-        "logging": {**LOGGING_VALIDATORS, "file": Use(str)},
-        Optional("server_name"): str,
-        Optional("runs_data_cleanup_days"): Use(int),
-    }
+    # TODO: explore how to validate helm values.yaml files, see issue 2105
+    VALIDATORS = {}
 
 
 class NodeConfiguration(Configuration):
@@ -50,6 +43,7 @@ class NodeConfiguration(Configuration):
         Optional("node_extra_env"): dict,
         Optional("node_extra_mounts"): [str],
         Optional("node_extra_hosts"): dict,
+        Optional("share_algorithm_logs"): Use(bool),
     }
 
 
@@ -71,7 +65,7 @@ class NodeConfigurationManager(ConfigurationManager):
         super().__init__(conf_class=NodeConfiguration, name=name)
 
     @classmethod
-    def from_file(cls, path: str) -> "NodeConfigurationManager":
+    def from_file(cls, path: str) -> Self:
         """
         Create a new instance of the NodeConfigurationManager from a
         configuration file.
@@ -103,7 +97,7 @@ class ServerConfigurationManager(ConfigurationManager):
         super().__init__(conf_class=ServerConfiguration, name=name)
 
     @classmethod
-    def from_file(cls, path) -> "ServerConfigurationManager":
+    def from_file(cls, path) -> Self:
         """
         Create a new instance of the ServerConfigurationManager from a
         configuration file.

vantage6/cli/configuration_wizard.py

@@ -1,25 +1,27 @@
 import os
 from pathlib import Path
+from typing import Any
 
 import questionary as q
 
-from vantage6.common import generate_apikey
+from vantage6.common import error, info, warning
+from vantage6.common.client.node_client import NodeClient
+from vantage6.common.context import AppContext
 from vantage6.common.globals import (
     DATABASE_TYPES,
+    DEFAULT_API_PATH,
     InstanceType,
     NodePolicy,
     Ports,
-    DEFAULT_API_PATH,
     RequiredNodeEnvVars,
 )
-from vantage6.common.client.node_client import NodeClient
-from vantage6.common.context import AppContext
-from vantage6.common import error, warning, info
-from vantage6.cli.context import select_context_class
+
+from vantage6.cli.config import CliConfig
 from vantage6.cli.configuration_manager import (
     NodeConfigurationManager,
     ServerConfigurationManager,
 )
+from vantage6.cli.context import select_context_class
 
 
 def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
@@ -54,9 +56,9 @@ def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
 
     # set default port to the https port if server_url is https
     default_port = (
-        str(Ports.HTTPS.value)
+        str(Ports.HTTPS)
         if config["server_url"].startswith("https")
-        else str(Ports.DEV_SERVER.value)
+        else str(Ports.DEV_SERVER)
     )
 
     config = config | q.unsafe_prompt(
@@ -182,8 +184,7 @@ def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
         error(f"Could not authenticate with server: {e}")
         error("Please check (1) your API key and (2) if your server is online")
         warning(
-            "If you continue, you should provide your collaboration "
-            "settings manually."
+            "If you continue, you should provide your collaboration settings manually."
         )
         if q.confirm("Do you want to abort?", default=True).unsafe_ask():
             exit(0)
@@ -312,10 +313,9 @@ def _get_common_server_config(instance_type: InstanceType, instance_name: str) -
                 "name": "port",
                 "message": "Enter port to which the server listens:",
                 "default": (
-                    # Note that .value is required in YAML to get proper str value
-                    str(Ports.DEV_SERVER.value)
+                    str(Ports.DEV_SERVER)
                     if instance_type == InstanceType.SERVER
-                    else str(Ports.DEV_ALGO_STORE.value)
+                    else str(Ports.DEV_ALGO_STORE)
                 ),
             },
         ]
@@ -368,115 +368,69 @@ def _get_common_server_config(instance_type: InstanceType, instance_name: str) -
     return config
 
 
-def server_configuration_questionaire(instance_name: str) -> dict:
+def server_configuration_questionaire(
+    instance_name: str,
+) -> dict[str, Any]:
     """
-    Questionary to generate a config file for the server instance.
+    Kubernetes-specific questionnaire to generate Helm values for server.
 
     Parameters
     ----------
     instance_name : str
-        Name of the server instance.
+        Name of the server instance
 
     Returns
     -------
-    dict
-        Dictionary with the new server configuration
+    dict[str, Any]
+        dictionary with Helm values for the server configuration
     """
+    # Get active kube namespace
+    cli_config = CliConfig()
+    kube_namespace = cli_config.get_last_namespace()
 
-    config = _get_common_server_config(InstanceType.SERVER, instance_name)
+    # Initialize config with basic structure
+    config = {"server": {}, "database": {}, "ui": {}}
 
-    constant_jwt_secret = q.confirm("Do you want a constant JWT secret?").unsafe_ask()
-    if constant_jwt_secret:
-        config["jwt_secret_key"] = generate_apikey()
-
-    is_mfa = q.confirm("Do you want to enforce two-factor authentication?").unsafe_ask()
-    if is_mfa:
-        config["two_factor_auth"] = is_mfa
+    # === Server settings ===
+    config["server"]["description"] = q.text(
+        "Enter a human-readable description:",
+        default=f"Vantage6 server {instance_name}",
+    ).unsafe_ask()
 
-    current_server_url = f"http://localhost:{config['port']}{config['api_path']}"
-    config["server_url"] = q.text(
-        "What is the server url exposed to the users? If you are running a"
-        " development server running locally, this is the same as the "
-        "server url. If you are running a production server, this is the "
-        "url that users will connect to.",
-        default=current_server_url,
+    config["server"]["image"] = q.text(
+        "Server Docker image:",
+        default="harbor2.vantage6.ai/infrastructure/server:latest",
     ).unsafe_ask()
 
-    is_add_vpn = q.confirm(
-        "Do you want to add a VPN server?", default=False
+    # === UI settings ===
+    config["ui"]["image"] = q.text(
+        "UI Docker image:",
+        default="harbor2.vantage6.ai/infrastructure/ui:latest",
     ).unsafe_ask()
-    if is_add_vpn:
-        vpn_config = q.unsafe_prompt(
-            [
-                {
-                    "type": "text",
-                    "name": "url",
-                    "message": "VPN server URL:",
-                },
-                {
-                    "type": "text",
-                    "name": "portal_username",
-                    "message": "VPN portal username:",
-                },
-                {
-                    "type": "password",
-                    "name": "portal_userpass",
-                    "message": "VPN portal password:",
-                },
-                {
-                    "type": "text",
-                    "name": "client_id",
-                    "message": "VPN client username:",
-                },
-                {
-                    "type": "password",
-                    "name": "client_secret",
-                    "message": "VPN client password:",
-                },
-                {
-                    "type": "text",
-                    "name": "redirect_url",
-                    "message": "Redirect url (should be local address of server)",
-                    "default": "http://localhost",
-                },
-            ]
-        )
-        config["vpn_server"] = vpn_config
 
-    is_add_rabbitmq = q.confirm(
-        "Do you want to add a RabbitMQ message queue?"
+    # === Database settings ===
+    config["database"]["volumePath"] = q.text(
+        "Where is your server database located on the host machine?",
+        default=f"{Path.cwd()}/dev/.db/db_pv_server",
     ).unsafe_ask()
-    if is_add_rabbitmq:
-        rabbit_uri = q.text(message="Enter the URI for your RabbitMQ:").unsafe_ask()
-        run_rabbit_locally = q.confirm(
-            "Do you want to run RabbitMQ locally? (Use only for testing)"
-        ).unsafe_ask()
-        config["rabbitmq"] = {
-            "uri": rabbit_uri,
-            "start_with_server": run_rabbit_locally,
-        }
-
-    # add algorithm stores to this server
-    is_add_community_store = q.confirm(
-        "Do you want to make the algorithms from the community algorithm store "
-        "available to your users?"
+
+    config["database"]["k8sNodeName"] = q.text(
+        "What is the name of the k8s node where the databases are running?",
+        default="docker-desktop",
     ).unsafe_ask()
-    algorithm_stores = []
-    if is_add_community_store:
-        algorithm_stores.append(
-            {"name": "Community store", "url": "https://store.cotopaxi.vantage6.ai"}
-        )
-    add_more_stores = q.confirm(
-        "Do you want to add more algorithm stores?", default=False
+
+    # === Keycloak settings ===
+    keycloak_url = f"http://vantage6-auth-keycloak.{kube_namespace}.svc.cluster.local"
+    config["server"]["keycloakUrl"] = keycloak_url
+
+    # === Other settings ===
+    log_level = q.select(
+        "Which level of logging would you like?",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
     ).unsafe_ask()
-    while add_more_stores:
-        store_name = q.text(message="Enter the name of the store:").unsafe_ask()
-        store_url = q.text(message="Enter the URL of the store:").unsafe_ask()
-        algorithm_stores.append({"name": store_name, "url": store_url})
-        add_more_stores = q.confirm(
-            "Do you want to add more algorithm stores?", default=False
-        ).unsafe_ask()
-    config["algorithm_stores"] = algorithm_stores
+
+    config["server"]["logging"] = {"level": log_level}
 
     return config
 
@@ -498,9 +452,7 @@ def algo_store_configuration_questionaire(instance_name: str) -> dict:
     """
     config = _get_common_server_config(InstanceType.ALGORITHM_STORE, instance_name)
 
-    default_v6_server_uri = (
-        f"http://localhost:{Ports.DEV_SERVER.value}{DEFAULT_API_PATH}"
-    )
+    default_v6_server_uri = f"http://localhost:{Ports.DEV_SERVER}{DEFAULT_API_PATH}"
     default_root_username = "admin"
 
     v6_server_uri = q.text(
@@ -520,7 +472,6 @@ def algo_store_configuration_questionaire(instance_name: str) -> dict:
     }
 
     # ask about openness of the algorithm store
-    config["policies"] = {"allow_localhost": False}
     is_open = q.confirm(
         "Do you want to open the algorithm store to the public? This will allow anyone "
         "to view the algorithms, but they cannot modify them.",
@@ -530,19 +481,21 @@ def algo_store_configuration_questionaire(instance_name: str) -> dict:
         open_algos_policy = "public"
     else:
         is_open_to_whitelist = q.confirm(
-            "Do you want to allow all users of whitelisted vantage6 servers to access "
+            "Do you want to allow all authenticated users to access "
             "the algorithms in the store? If not allowing this, you will have to assign"
             " the appropriate permissions to each user individually.",
             default=True,
         ).unsafe_ask()
-        open_algos_policy = "whitelisted" if is_open_to_whitelist else "private"
+        open_algos_policy = "authenticated" if is_open_to_whitelist else "private"
     config["policies"]["algorithm_view"] = open_algos_policy
 
     return config
 
 
 def configuration_wizard(
-    type_: InstanceType, instance_name: str, system_folders: bool
+    type_: InstanceType,
+    instance_name: str,
+    system_folders: bool,
 ) -> Path:
     """
     Create a configuration file for a node or server instance.
@@ -570,7 +523,9 @@ def configuration_wizard(
         config = node_configuration_questionaire(dirs, instance_name)
     elif type_ == InstanceType.SERVER:
         conf_manager = ServerConfigurationManager
-        config = server_configuration_questionaire(instance_name)
+        config = server_configuration_questionaire(
+            instance_name=instance_name,
+        )
     else:
         conf_manager = ServerConfigurationManager
         config = algo_store_configuration_questionaire(instance_name)

vantage6/cli/context/__init__.py

@@ -10,8 +10,9 @@ more.
 
 from colorama import Fore, Style
 
-from vantage6.common.globals import InstanceType
 from vantage6.common import error
+from vantage6.common.globals import InstanceType
+
 from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
 from vantage6.cli.context.node import NodeContext
 from vantage6.cli.context.server import ServerContext

vantage6/cli/context/algorithm_store.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from vantage6.common.globals import APPNAME, InstanceType
+
+from vantage6.cli._version import __version__
 from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.context.base_server import BaseServerContext
 from vantage6.cli.globals import (
     DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
-    ServerType,
     AlgoStoreGlobals,
+    ServerType,
 )
-from vantage6.cli._version import __version__
-from vantage6.cli.context.base_server import BaseServerContext
 
 
 class AlgorithmStoreContext(BaseServerContext):
@@ -28,7 +29,9 @@ class AlgorithmStoreContext(BaseServerContext):
 
     def __init__(self, instance_name: str, system_folders: bool = S_FOL):
         super().__init__(
-            InstanceType.ALGORITHM_STORE, instance_name, system_folders=system_folders
+            InstanceType.ALGORITHM_STORE,
+            instance_name,
+            system_folders=system_folders,
         )
         self.log.info("vantage6 version '%s'", __version__)
 
@@ -41,7 +44,7 @@ class AlgorithmStoreContext(BaseServerContext):
         str
             string representation of the database uri
         """
-        return super().get_database_uri(AlgoStoreGlobals.DB_URI_ENV_VAR)
+        return super().get_database_uri(AlgoStoreGlobals.DB_URI_ENV_VAR.value)
 
     @property
     def docker_container_name(self) -> str:
@@ -53,7 +56,7 @@ class AlgorithmStoreContext(BaseServerContext):
         str
             Server's docker container name
         """
-        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.ALGORITHM_STORE.value}"
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.ALGORITHM_STORE}"
 
     @classmethod
     def from_external_config_file(
@@ -79,7 +82,7 @@ class AlgorithmStoreContext(BaseServerContext):
         return super().from_external_config_file(
             path,
             ServerType.ALGORITHM_STORE,
-            AlgoStoreGlobals.CONFIG_NAME_ENV_VAR,
+            AlgoStoreGlobals.CONFIG_NAME_ENV_VAR.value,
             system_folders,
         )