vantage6 5.0.0a33__py3-none-any.whl → 5.0.0a35__py3-none-any.whl

vantage6/cli/common/utils.py

@@ -1,4 +1,6 @@
-import enum
+import json
+import subprocess
+from pathlib import Path
 from subprocess import Popen
 from typing import Iterable
 
@@ -10,7 +12,175 @@ from colorama import Fore, Style
 from vantage6.common import error, warning
 from vantage6.common.globals import APPNAME, STRING_ENCODING, InstanceType
 
+from vantage6.cli.config import CliConfig
 from vantage6.cli.context import select_context_class
+from vantage6.cli.globals import CLICommandName
+from vantage6.cli.utils import validate_input_cmd_args
+
+
+def select_context_and_namespace(
+    context: str | None = None,
+    namespace: str | None = None,
+) -> tuple[str, str]:
+    """
+    Select the context and namespace to use.
+
+    This uses the CLI config to compare the provided context and namespace with the
+    last used context and namespace. If the provided context and namespace are not
+    the same as the last used context and namespace, the CLI config is updated.
+
+    Parameters
+    ----------
+    context : str, optional
+        The Kubernetes context to use.
+    namespace : str, optional
+        The Kubernetes namespace to use.
+
+    Returns
+    -------
+    tuple[str, str]
+        The context and namespace to use
+    """
+    cli_config = CliConfig()
+
+    return cli_config.compare_changes_config(
+        context=context,
+        namespace=namespace,
+    )
+
+
+def create_directory_if_not_exists(directory: Path) -> None:
+    """
+    Create a directory.
+    """
+    try:
+        directory.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        error(f"Failed to create directory {directory}: {e}")
+        exit(1)
+
+
+def find_running_service_names(
+    instance_type: InstanceType,
+    only_system_folders: bool = False,
+    only_user_folders: bool = False,
+    context: str | None = None,
+    namespace: str | None = None,
+) -> list[str]:
+    """
+    List running Vantage6 servers.
+
+    Parameters
+    ----------
+    instance_type : InstanceType
+        The type of instance to find running services for
+    only_system_folders : bool, optional
+        Whether to look for system-based services or not. By default False.
+    only_user_folders : bool, optional
+        Whether to look for user-based services or not. By default False.
+    context : str, optional
+        The Kubernetes context to use.
+    namespace : str, optional
+        The Kubernetes namespace to use.
+
+    Returns
+    -------
+    list[str]
+        List of release names that are running
+    """
+    # Input validation
+    validate_input_cmd_args(context, "context name", allow_none=True)
+    validate_input_cmd_args(namespace, "namespace name", allow_none=True)
+    validate_input_cmd_args(instance_type, "instance type", allow_none=False)
+    if only_system_folders and only_user_folders:
+        error("Cannot use both only_system_folders and only_user_folders")
+        exit(1)
+
+    # Create the command
+    command = [
+        "helm",
+        "list",
+        "--output",
+        "json",  # Get structured output
+    ]
+
+    if context:
+        command.extend(["--kube-context", context])
+
+    if namespace:
+        command.extend(["--namespace", namespace])
+    else:
+        command.extend(["--all-namespaces"])
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        error(f"Failed to list Helm releases: {e}")
+        return []
+    except FileNotFoundError:
+        error(
+            "Helm command not found. Please ensure Helm is installed and available in "
+            "the PATH."
+        )
+        return []
+
+    try:
+        releases = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        error("Failed to parse Helm output as JSON")
+        return []
+
+    # filter services for the vantage6 services that are sought. These have
+    # the following pattern:
+    # f"{APPNAME}-{name}-{scope}-{instance_type.value}"
+
+    # filter for the instance type
+    svc_starts_with = f"{APPNAME}-"
+    if only_system_folders:
+        svc_ends_with = f"system-{instance_type.value}"
+    elif only_user_folders:
+        svc_ends_with = f"user-{instance_type.value}"
+    else:
+        svc_ends_with = f"-{instance_type.value}"
+
+    matching_services = []
+    for release in releases:
+        release_name = release.get("name", "")
+
+        # Check if this is a Vantage6 server release
+        is_matching_service = (
+            release_name.startswith(svc_starts_with)
+            and release_name.endswith(svc_ends_with)
+            and instance_type.value in release_name
+        )
+
+        if is_matching_service:
+            matching_services.append(release_name)
+
+    return matching_services
+
+
+def select_running_service(
+    running_services: list[str],
+    instance_type: InstanceType,
+) -> str:
+    """
+    Select a running service from the list of running services.
+    """
+    try:
+        name = q.select(
+            f"Select a {instance_type.value}:",
+            choices=running_services,
+        ).unsafe_ask()
+    except KeyboardInterrupt:
+        error("Aborted by user!")
+        exit(1)
+    return name
 
 
 def get_server_name(
@@ -20,30 +190,30 @@ def get_server_name(
     instance_type: InstanceType,
 ) -> str:
     """
-    Get the version of a running server.
+    Get the full name of a running server.
 
     Parameters
     ----------
     name : str
-        Name of the server to get the version from
+        Name of the server to get the full name from
     system_folders : bool
         Whether to use system folders or not
     running_server_names : list[str]
         The names of the running servers
     instance_type : InstanceType
-        The type of instance to get the running servers from
+        The type of instance to get the full name from
     """
 
     if not name:
         if not running_server_names:
             error(
-                f"No {instance_type}s are running! You can only check the version for "
-                f"{instance_type}s that are running"
+                f"No {instance_type.value}s are running! You can only check the version"
+                f" for {instance_type.value}s that are running"
             )
             exit(1)
         try:
             name = q.select(
-                f"Select the {instance_type} you wish to inspect:",
+                f"Select the {instance_type.value} you wish to inspect:",
                 choices=running_server_names,
             ).unsafe_ask()
         except KeyboardInterrupt:
@@ -73,7 +243,7 @@ def get_running_servers(
         The names of the running servers
     """
     running_servers = client.containers.list(
-        filters={"label": f"{APPNAME}-type={instance_type}"}
+        filters={"label": f"{APPNAME}-type={instance_type.value}"}
     )
     return [server.name for server in running_servers]
 
@@ -87,10 +257,9 @@ def get_server_configuration_list(instance_type: InstanceType) -> None:
     instance_type : InstanceType
         The type of instance to get the configurations for
     """
-    client = docker.from_env()
     ctx_class = select_context_class(instance_type)
 
-    running_server_names = get_running_servers(client, instance_type)
+    running_server_names = find_running_service_names(instance_type)
     header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
 
     click.echo(header)
@@ -100,28 +269,37 @@ def get_server_configuration_list(instance_type: InstanceType) -> None:
     stopped = Fore.RED + "Not running" + Style.RESET_ALL
 
     # system folders
-    configs, f1 = ctx_class.available_configurations(system_folders=True)
+    configs, failed_imports_system = ctx_class.available_configurations(
+        system_folders=True
+    )
     for config in configs:
         status = (
             running
-            if f"{APPNAME}-{config.name}-system-{instance_type}" in running_server_names
+            if f"{APPNAME}-{config.name}-system-{instance_type.value}"
+            in running_server_names
             else stopped
         )
         click.echo(f"{config.name:25}{status:25} System ")
 
     # user folders
-    configs, f2 = ctx_class.available_configurations(system_folders=False)
+    configs, failed_imports_user = ctx_class.available_configurations(
+        system_folders=False
+    )
     for config in configs:
         status = (
             running
-            if f"{APPNAME}-{config.name}-user-{instance_type}" in running_server_names
+            if f"{APPNAME}-{config.name}-user-{instance_type.value}"
+            in running_server_names
             else stopped
         )
         click.echo(f"{config.name:25}{status:25} User   ")
 
     click.echo("-" * 85)
-    if len(f1) + len(f2):
-        warning(f"{Fore.RED}Failed imports: {len(f1) + len(f2)}{Style.RESET_ALL}")
+    if len(failed_imports_system) + len(failed_imports_user):
+        warning(
+            f"{Fore.RED}Failed imports: "
+            f"{len(failed_imports_system) + len(failed_imports_user)}{Style.RESET_ALL}"
+        )
 
 
 def print_log_worker(logs_stream: Iterable[bytes]) -> None:
@@ -163,6 +341,16 @@ def get_name_from_container_name(container_name: str) -> str:
     return "-".join(container_name.split("-")[1:-1])
 
 
+def get_config_name_from_service_name(service_name: str) -> str:
+    """
+    Get the config name from a service name.
+    """
+    # helm release name is structured as:
+    # f"{APPNAME}-{name}-{scope}-{instance_type}"
+    # we want to get the name from the service name
+    return "-".join(service_name.split("-")[1:-2])
+
+
 def attach_logs(*labels: list[str]) -> None:
     """
     Attach to the logs of the given labels.
@@ -175,3 +363,52 @@ def attach_logs(*labels: list[str]) -> None:
     command = ["kubectl", "logs", "--follow", "--selector", ",".join(labels)]
     process = Popen(command, stdout=None, stderr=None)
     process.wait()
+
+
+def get_main_cli_command_name(instance_type: InstanceType) -> str:
+    """
+    Get the main CLI command name for a given instance type.
+
+    Parameters
+    ----------
+    instance_type : InstanceType
+        The type of instance to get the main CLI command name for
+    """
+    if instance_type == InstanceType.SERVER:
+        return CLICommandName.SERVER.value
+    elif instance_type == InstanceType.ALGORITHM_STORE:
+        return CLICommandName.ALGORITHM_STORE.value
+    elif instance_type == InstanceType.NODE:
+        return CLICommandName.NODE.value
+    else:
+        raise ValueError(f"Invalid instance type: {instance_type}")
+
+
+def check_running(
+    helm_release_name: str, instance_type: InstanceType, name: str, system_folders: bool
+) -> bool:
+    """
+    Check if the instance is already running.
+
+    Parameters
+    ----------
+    helm_release_name : str
+        The name of the Helm release.
+    instance_type : InstanceType
+        The type of instance to check
+    name : str
+        The name of the instance to check
+    system_folders : bool
+        Whether to use system folders or not
+
+    Returns
+    -------
+    bool
+        True if the instance is already running, False otherwise
+    """
+    running_services = find_running_service_names(
+        instance_type=instance_type,
+        only_system_folders=system_folders,
+        only_user_folders=not system_folders,
+    )
+    return helm_release_name in running_services

vantage6/cli/configuration_manager.py

@@ -1,9 +1,15 @@
 from typing import Self
 
-from schema import And, Optional, Or, Use
+from schema import And, Use
 
 from vantage6.common.configuration_manager import Configuration, ConfigurationManager
 
+from vantage6.cli.globals import (
+    ALGO_STORE_TEMPLATE_FILE,
+    NODE_TEMPLATE_FILE,
+    SERVER_TEMPLATE_FILE,
+)
+
 LOGGING_VALIDATORS = {
     "level": And(
         Use(str), lambda lvl: lvl in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
@@ -26,6 +32,15 @@ class ServerConfiguration(Configuration):
     VALIDATORS = {}
 
 
+class AlgorithmStoreConfiguration(Configuration):
+    """
+    Stores the algorithm store's configuration and defines a set of algorithm store-specific
+    validators.
+    """
+
+    VALIDATORS = {}
+
+
 class NodeConfiguration(Configuration):
     """
     Stores the node's configuration and defines a set of node-specific
@@ -33,17 +48,20 @@ class NodeConfiguration(Configuration):
     """
 
     VALIDATORS = {
-        "server_url": Use(str),
-        "port": Or(Use(int), None),
-        "task_dir": Use(str),
-        # TODO: remove `dict` validation from databases
-        "api_path": Use(str),
-        "logging": LOGGING_VALIDATORS,
-        "encryption": {"enabled": bool, Optional("private_key"): Use(str)},
-        Optional("node_extra_env"): dict,
-        Optional("node_extra_mounts"): [str],
-        Optional("node_extra_hosts"): dict,
-        Optional("share_algorithm_logs"): Use(bool),
+        # # TODO enable validators for node. To see if it works, use v6 node list
+        # "node": {
+        #     "server_url": Use(str),
+        #     "port": Or(Use(int), None),
+        #     "task_dir": Use(str),
+        #     # TODO: remove `dict` validation from databases
+        #     "api_path": Use(str),
+        #     "logging": LOGGING_VALIDATORS,
+        #     "encryption": {"enabled": bool, Optional("private_key"): Use(str)},
+        #     Optional("node_extra_env"): dict,
+        #     Optional("node_extra_mounts"): [str],
+        #     Optional("node_extra_hosts"): dict,
+        #     Optional("share_algorithm_logs"): Use(bool),
+        # }
     }
 
 
@@ -82,6 +100,12 @@ class NodeConfigurationManager(ConfigurationManager):
         """
         return super().from_file(path, conf_class=NodeConfiguration)
 
+    def get_config_template(self) -> str:
+        """
+        Get the configuration template for the node.
+        """
+        return super()._get_config_template(NODE_TEMPLATE_FILE)
+
 
 class ServerConfigurationManager(ConfigurationManager):
     """
@@ -114,6 +138,60 @@ class ServerConfigurationManager(ConfigurationManager):
         """
         return super().from_file(path, conf_class=ServerConfiguration)
 
+    def get_config_template(self) -> str:
+        """
+        Get the configuration template for the server.
+
+        Returns
+        -------
+        str
+            The configuration template for the server.
+        """
+        return super()._get_config_template(SERVER_TEMPLATE_FILE)
+
+
+class AlgorithmStoreConfigurationManager(ConfigurationManager):
+    """
+    Maintains the algorithm store's configuration.
+
+    Parameters
+    ----------
+    name : str
+        Name of the configuration file.
+    """
+
+    def __init__(self, name, *args, **kwargs) -> None:
+        super().__init__(conf_class=AlgorithmStoreConfiguration, name=name)
+
+    @classmethod
+    def from_file(cls, path: str) -> Self:
+        """
+        Create a new instance of the AlgorithmStoreConfigurationManager from a
+        configuration file.
+
+        Parameters
+        ----------
+        path : str
+            Path to the configuration file.
+
+        Returns
+        -------
+        AlgorithmStoreConfigurationManager
+            A new instance of the AlgorithmStoreConfigurationManager.
+        """
+        return super().from_file(path, conf_class=AlgorithmStoreConfiguration)
+
+    def get_config_template(self) -> str:
+        """
+        Get the configuration template for the algorithm store.
+
+        Returns
+        -------
+        str
+            The configuration template for the algorithm store.
+        """
+        return super()._get_config_template(ALGO_STORE_TEMPLATE_FILE)
+
 
 class TestingConfigurationManager(ConfigurationManager):
     def __init__(self, name, *args, **kwargs):