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

vantage6/cli/common/start.py

@@ -1,25 +1,17 @@
 from __future__ import annotations
 
-import enum
-import os
 import re
 import subprocess
 import time
 from os import PathLike
 from pathlib import Path
-from threading import Thread
 
 import docker
-from colorama import Fore, Style
 from docker.client import DockerClient
-from docker.models.containers import Container
-from sqlalchemy.engine.url import make_url
 
 from vantage6.common import error, info, warning
-from vantage6.common.context import AppContext
-from vantage6.common.docker.addons import check_docker_running, pull_image
+from vantage6.common.docker.addons import pull_image
 from vantage6.common.globals import (
-    APPNAME,
     DEFAULT_ALGO_STORE_IMAGE,
     DEFAULT_CHART_REPO,
     DEFAULT_DOCKER_REGISTRY,
@@ -29,83 +21,8 @@ from vantage6.common.globals import (
     InstanceType,
 )
 
-from vantage6.cli.common.utils import print_log_worker
-from vantage6.cli.context import AlgorithmStoreContext, ServerContext
-from vantage6.cli.globals import AlgoStoreGlobals, ServerGlobals
-from vantage6.cli.utils import (
-    check_config_name_allowed,
-    validate_input_cmd_args,
-)
-
-
-def check_for_start(ctx: AppContext, type_: InstanceType) -> DockerClient:
-    """
-    Check if all requirements are met to start the instance.
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    type_ : InstanceType
-        The type of instance to check for
-
-    Returns
-    -------
-    DockerClient
-        A Docker client instance
-    """
-    # will print an error if not
-    check_docker_running()
-
-    info("Finding Docker daemon.")
-    docker_client = docker.from_env()
-
-    # check if name is allowed for docker volume, else exit
-    check_config_name_allowed(ctx.name)
-
-    # check that this server is not already running
-    running_servers = docker_client.containers.list(
-        filters={"label": f"{APPNAME}-type={type_}"}
-    )
-    for server in running_servers:
-        if server.name == f"{APPNAME}-{ctx.name}-{ctx.scope}-{type_}":
-            error(f"Server {Fore.RED}{ctx.name}{Style.RESET_ALL} is already running")
-            exit(1)
-    return docker_client
-
-
-def get_image(
-    image: str, ctx: AppContext, custom_image_key: str, default_image: str
-) -> str:
-    """
-    Get the image name for the given instance type.
-
-    Parameters
-    ----------
-    image : str | None
-        The image name to use if specified
-    ctx : AppContext
-        The context object
-    custom_image_key : str
-        The key to look for in the config file
-    default_image : str
-        The default image name
-
-    Returns
-    -------
-    str
-        The image name to use
-    """
-    # Determine image-name. First we check if the option --image has been used.
-    # Then we check if the image has been specified in the config file, and
-    # finally we use the default settings from the package.
-    if image is None:
-        custom_images: dict = ctx.config.get("images")
-        if custom_images:
-            image = custom_images.get(custom_image_key)
-        if not image:
-            image = f"{DEFAULT_DOCKER_REGISTRY}/{default_image}"
-    return image
+from vantage6.cli.globals import ChartName
+from vantage6.cli.utils import validate_input_cmd_args
 
 
 def pull_infra_image(
@@ -129,8 +46,8 @@ def pull_infra_image(
     try:
         pull_image(client, image, suppress_error=True)
     except docker.errors.APIError:
-        if not is_default_infra_image(image, instance_type):
-            if image_exists_locally(client, image):
+        if not _is_default_infra_image(image, instance_type):
+            if _image_exists_locally(client, image):
                 warning("Failed to pull infrastructure image! Will use local image...")
             else:
                 error("Failed to pull infrastructure image!")
@@ -141,7 +58,7 @@ def pull_infra_image(
             exit(1)
 
 
-def is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
+def _is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
     """
     Check if an infrastructure image is the default image.
 
@@ -167,7 +84,7 @@ def is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
         return image == f"{DEFAULT_DOCKER_REGISTRY}/{DEFAULT_NODE_IMAGE}"
 
 
-def image_exists_locally(client: DockerClient, image: str) -> bool:
+def _image_exists_locally(client: DockerClient, image: str) -> bool:
     """
     Check if the image exists locally.
 
@@ -190,137 +107,9 @@ def image_exists_locally(client: DockerClient, image: str) -> bool:
     return True
 
 
-def mount_config_file(ctx: AppContext, config_file: str) -> list[docker.types.Mount]:
-    """
-    Mount the config file in the container.
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    config_file : str
-        The path to the config file
-
-    Returns
-    -------
-    list[docker.types.Mount]
-        The mounts to use
-    """
-    info("Creating mounts")
-    return [docker.types.Mount(config_file, str(ctx.config_file), type="bind")]
-
-
-def mount_source(mount_src: str) -> docker.types.Mount:
-    """
-    Mount the vantage6 source code in the container.
-
-    Parameters
-    ----------
-    mount_src : str
-        The path to the source code
-
-    Returns
-    -------
-    docker.types.Mount | None
-        The mount to use
-    """
-    if mount_src:
-        mount_src = os.path.abspath(mount_src)
-        return docker.types.Mount("/vantage6", mount_src, type="bind")
-
-
-def mount_database(
-    ctx: ServerContext | AlgorithmStoreContext, type_: InstanceType
-) -> tuple[docker.types.Mount, dict]:
-    """
-    Mount database in the container if it is file-based (e.g. a SQLite DB).
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    type_ : InstanceType
-        The type of instance to mount the database for
-
-    Returns
-    -------
-    docker.types.Mount | None
-        The mount to use
-    dict | None
-        The environment variables to use
-    """
-    # FIXME: code duplication with cli_server_import()
-    # try to mount database
-    uri = ctx.config["uri"]
-    url = make_url(uri)
-    environment_vars = {}
-    mount = None
-
-    # If host is None, we're dealing with a file-based DB, like SQLite
-    if url.host is None:
-        db_path = url.database
-
-        if not os.path.isabs(db_path):
-            # We're dealing with a relative path here -> make it absolute
-            db_path = ctx.data_dir / url.database
-
-        basename = os.path.basename(db_path)
-        dirname = os.path.dirname(db_path)
-        os.makedirs(dirname, exist_ok=True)
-
-        # we're mounting the entire folder that contains the database
-        mount = docker.types.Mount("/mnt/database/", dirname, type="bind")
-
-        if type_ == InstanceType.SERVER:
-            environment_vars = {
-                ServerGlobals.DB_URI_ENV_VAR.value: f"sqlite:////mnt/database/{basename}",
-                ServerGlobals.CONFIG_NAME_ENV_VAR.value: ctx.config_file_name,
-            }
-        elif type_ == InstanceType.ALGORITHM_STORE:
-            environment_vars = {
-                AlgoStoreGlobals.DB_URI_ENV_VAR.value: f"sqlite:////mnt/database/{basename}",
-                AlgoStoreGlobals.CONFIG_NAME_ENV_VAR.value: ctx.config_file_name,
-            }
-    else:
-        warning(
-            f"Database could not be transferred, make sure {url.host} "
-            "is reachable from the Docker container"
-        )
-        info("Consider using the docker-compose method to start a server")
-
-    return mount, environment_vars
-
-
-# TODO v5+ remove this function, it is replaced by the `attach_logs` function in
-# `vantage6.cli.common.utils`
-def attach_logs(container: Container, type_: InstanceType) -> None:
-    """
-    Attach container logs to the console if specified.
-
-    Parameters
-    ----------
-    container : Container
-        The container to attach the logs from
-    type_ : InstanceType
-        The type of instance to attach the logs for
-    """
-    logs = container.attach(stream=True, logs=True, stdout=True)
-    Thread(target=print_log_worker, args=(logs,), daemon=True).start()
-    while True:
-        try:
-            time.sleep(1)
-        except KeyboardInterrupt:
-            info("Closing log file. Keyboard Interrupt.")
-            info(
-                "Note that your server is still running! Shut it down "
-                f"with {Fore.RED}v6 {type_} stop{Style.RESET_ALL}"
-            )
-            exit(0)
-
-
 def helm_install(
     release_name: str,
-    chart_name: str,
+    chart_name: ChartName,
     values_file: str | PathLike | None = None,
     context: str | None = None,
     namespace: str | None = None,
@@ -361,6 +150,7 @@ def helm_install(
         chart_name,
         "--repo",
         DEFAULT_CHART_REPO,
+        # TODO v5+ remove this flag when we have a stable release
         "--devel",  # ensure using latest version including pre-releases
     ]
 
@@ -380,14 +170,18 @@ def helm_install(
             check=True,
         )
         info(
-            f"Successfully installed release '{release_name}' using chart '{chart_name}'."
+            f"Successfully installed release '{release_name}' using chart "
+            f"'{chart_name}'."
         )
-    except subprocess.CalledProcessError as e:
-        error(f"Failed to install release '{release_name}': {e.stderr}")
+    except subprocess.CalledProcessError:
+        error(f"Failed to install release '{release_name}'.")
+        exit(1)
     except FileNotFoundError:
         error(
-            "Helm command not found. Please ensure Helm is installed and available in the PATH."
+            "Helm command not found. Please ensure Helm is installed and available in "
+            "the PATH."
         )
+        exit(1)
 
 
 def start_port_forward(

vantage6/cli/common/stop.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import subprocess
 
-
 from vantage6.common import error, info, warning
+
 from vantage6.cli.utils import validate_input_cmd_args
 
 

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,174 @@ 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.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 the {instance_type.value} you wish to inspect:",
+            choices=running_services,
+        ).unsafe_ask()
+    except KeyboardInterrupt:
+        error("Aborted by user!")
+        exit(1)
+    return name
 
 
 def get_server_name(
@@ -20,30 +189,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 +242,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 +256,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 +268,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:
@@ -175,3 +352,22 @@ 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 "server"
+    elif instance_type == InstanceType.ALGORITHM_STORE:
+        return "algorithm-store"
+    elif instance_type == InstanceType.NODE:
+        return "node"
+    else:
+        raise ValueError(f"Invalid instance type: {instance_type}")

vantage6/cli/configuration_manager.py

@@ -4,6 +4,8 @@ from schema import And, Optional, Or, Use
 
 from vantage6.common.configuration_manager import Configuration, ConfigurationManager
 
+from vantage6.cli.globals import ALGO_STORE_TEMPLATE_FILE, SERVER_TEMPLATE_FILE
+
 LOGGING_VALIDATORS = {
     "level": And(
         Use(str), lambda lvl: lvl in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
@@ -26,6 +28,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
@@ -114,6 +125,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):