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

vantage6/cli/common/start.py

@@ -1,29 +1,41 @@
+from __future__ import annotations
+
+import enum
 import os
-from threading import Thread
+import re
+import subprocess
 import time
+from os import PathLike
+from pathlib import Path
+from threading import Thread
+
 import docker
-import enum
+from colorama import Fore, Style
 from docker.client import DockerClient
 from docker.models.containers import Container
-from colorama import Fore, Style
 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.globals import (
+    APPNAME,
     DEFAULT_ALGO_STORE_IMAGE,
+    DEFAULT_CHART_REPO,
+    DEFAULT_DOCKER_REGISTRY,
     DEFAULT_NODE_IMAGE,
     DEFAULT_SERVER_IMAGE,
     DEFAULT_UI_IMAGE,
     InstanceType,
-    APPNAME,
-    DEFAULT_DOCKER_REGISTRY,
 )
-from vantage6.common.docker.addons import check_docker_running, pull_image
-from vantage6.cli.context import AlgorithmStoreContext, ServerContext
+
 from vantage6.cli.common.utils import print_log_worker
-from vantage6.cli.utils import check_config_name_allowed
-from vantage6.cli.globals import ServerGlobals, AlgoStoreGlobals
+from vantage6.cli.context import AlgorithmStoreContext, ServerContext
+from vantage6.cli.globals import AlgoStoreGlobals, ServerGlobals
+from vantage6.cli.utils import (
+    validate_input_cmd_args,
+    check_config_name_allowed,
+)
 
 
 def check_for_start(ctx: AppContext, type_: InstanceType) -> DockerClient:
@@ -279,6 +291,8 @@ def mount_database(
     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.
@@ -304,3 +318,200 @@ def attach_logs(container: Container, type_: InstanceType) -> None:
                 f"with {Fore.RED}v6 {type_} stop{Style.RESET_ALL}"
             )
             exit(0)
+
+
+def helm_install(
+    release_name: str,
+    chart_name: str,
+    values_file: str | PathLike | None = None,
+    context: str | None = None,
+    namespace: str | None = None,
+) -> None:
+    """
+    Manage the `helm install` command.
+
+    Parameters
+    ----------
+    release_name : str
+        The name of the Helm release.
+    chart_name : str
+        The name of the Helm chart.
+    values_file : str, optional
+        A single values file to use with the `-f` flag.
+    context : str, optional
+        The Kubernetes context to use.
+    namespace : str, optional
+        The Kubernetes namespace to use.
+    """
+    # Input validation
+    validate_input_cmd_args(release_name, "release name")
+    validate_input_cmd_args(chart_name, "chart name")
+
+    values_file = Path(values_file) if values_file else None
+    if values_file and not values_file.is_file():
+        error(f"Helm chart values file does not exist: {values_file}")
+        return
+
+    validate_input_cmd_args(context, "context name", allow_none=True)
+    validate_input_cmd_args(namespace, "namespace name", allow_none=True)
+
+    # Create the command
+    command = [
+        "helm",
+        "install",
+        release_name,
+        chart_name,
+        "--repo",
+        DEFAULT_CHART_REPO,
+        "--devel",  # ensure using latest version including pre-releases
+    ]
+
+    if values_file:
+        command.extend(["-f", str(values_file)])
+
+    if context:
+        command.extend(["--kube-context", context])
+
+    if namespace:
+        command.extend(["--namespace", namespace])
+
+    try:
+        subprocess.run(
+            command,
+            stdout=subprocess.DEVNULL,
+            check=True,
+        )
+        info(
+            f"Successfully installed release '{release_name}' using chart '{chart_name}'."
+        )
+    except subprocess.CalledProcessError as e:
+        error(f"Failed to install release '{release_name}': {e.stderr}")
+    except FileNotFoundError:
+        error(
+            "Helm command not found. Please ensure Helm is installed and available in the PATH."
+        )
+
+
+def start_port_forward(
+    service_name: str,
+    service_port: int,
+    port: int,
+    ip: str | None,
+    context: str | None = None,
+    namespace: str | None = None,
+) -> None:
+    """
+    Port forward a kubernetes service.
+
+    Parameters
+    ----------
+    service_name : str
+        The name of the Kubernetes service to port forward.
+    service_port : int
+        The port on the service to forward.
+    port : int
+        The port to listen on.
+    ip : str | None
+        The IP address to listen on. If None, defaults to localhost.
+    context : str | None
+        The Kubernetes context to use.
+    namespace : str | None
+        The Kubernetes namespace to use.
+    """
+    # Input validation
+    validate_input_cmd_args(service_name, "service name")
+    if not isinstance(service_port, int) or service_port <= 0:
+        error(f"Invalid service port: {service_port}. Must be a positive integer.")
+        return
+
+    if not isinstance(port, int) or port <= 0:
+        error(f"Invalid local port: {port}. Must be a positive integer.")
+        return
+
+    if ip and not re.match(
+        r"^(localhost|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})$", ip
+    ):
+        error(f"Invalid IP address: {ip}. Must be a valid IPv4 address or 'localhost'.")
+        return
+
+    validate_input_cmd_args(context, "context name", allow_none=True)
+    validate_input_cmd_args(namespace, "namespace name", allow_none=True)
+
+    # Check if the service is ready before starting port forwarding
+    info(f"Waiting for service '{service_name}' to become ready...")
+    start_time = time.time()
+    timeout = 300  # seconds
+    while time.time() - start_time < timeout:
+        try:
+            result = (
+                subprocess.check_output(
+                    [
+                        "kubectl",
+                        "get",
+                        "endpoints",
+                        service_name,
+                        "-o",
+                        "jsonpath={.subsets[*].addresses[*].ip}",
+                    ]
+                )
+                .decode()
+                .strip()
+            )
+
+            if result:
+                info(f"Service '{service_name}' is ready.")
+                break
+        except subprocess.CalledProcessError:
+            pass  # ignore and retry
+
+        time.sleep(2)
+    else:
+        error(
+            f"Timeout: Service '{service_name}' has no ready endpoints after {timeout} seconds."
+        )
+        return
+
+    # Create the port forwarding command
+    if not ip:
+        ip = "localhost"
+
+    command = [
+        "kubectl",
+        "port-forward",
+        "--address",
+        ip,
+        f"service/{service_name}",
+        f"{port}:{service_port}",
+    ]
+
+    if context:
+        command.extend(["--context", context])
+
+    if namespace:
+        command.extend(["--namespace", namespace])
+
+    # Start the port forwarding process
+    try:
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            start_new_session=True,  # Start in new session to detach from parent
+        )
+
+        # Give the process a moment to start and check if it's still running
+        time.sleep(1)
+        if process.poll() is not None:
+            # Process has already terminated
+            e = process.stderr.read().decode() if process.stderr else "Unknown error"
+            error(f"Failed to start port forwarding: {e}")
+            return
+
+        info(
+            f"Port forwarding started: {ip}:{port} -> {service_name}:{service_port} "
+            f"(PID: {str(process.pid)})"
+        )
+        return
+    except Exception as e:
+        error(f"Failed to start port forwarding: {e}")
+        return

vantage6/cli/common/stop.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import subprocess
+
+
+from vantage6.common import error, info, warning
+from vantage6.cli.utils import validate_input_cmd_args
+
+
+def stop_port_forward(service_name: str) -> None:
+    """
+    Stop the port forwarding process for a given service name.
+
+    Parameters
+    ----------
+    service_name : str
+        The name of the service whose port forwarding process should be terminated.
+    """
+    # Input validation
+    validate_input_cmd_args(service_name, "service name")
+
+    try:
+        # Find the process ID (PID) of the port forwarding command
+        result = subprocess.run(
+            ["pgrep", "-f", f"kubectl port-forward.*{service_name}"],
+            check=True,
+            text=True,
+            capture_output=True,
+        )
+        pids = result.stdout.strip().splitlines()
+
+        if not pids:
+            warning(f"No port forwarding process found for service '{service_name}'.")
+            return
+
+        for pid in pids:
+            subprocess.run(["kill", "-9", pid], check=True)
+            info(
+                f"Terminated port forwarding process for service '{service_name}' "
+                f"(PID: {pid})"
+            )
+    except subprocess.CalledProcessError as e:
+        error(f"Failed to terminate port forwarding: {e}")
+
+
+def helm_uninstall(
+    release_name: str,
+    context: str | None = None,
+    namespace: str | None = None,
+) -> None:
+    """
+    Manage the `helm uninstall` command.
+
+    Parameters
+    ----------
+    release_name : str
+        The name of the Helm release to uninstall.
+    context : str, optional
+        The Kubernetes context to use.
+    namespace : str, optional
+        The Kubernetes namespace to use.
+    """
+    # Input validation
+    validate_input_cmd_args(release_name, "release name")
+    validate_input_cmd_args(context, "context name", allow_none=True)
+    validate_input_cmd_args(namespace, "namespace name", allow_none=True)
+
+    # Create the command
+    command = ["helm", "uninstall", release_name]
+
+    if context:
+        command.extend(["--kube-context", context])
+
+    if namespace:
+        command.extend(["--namespace", namespace])
+
+    try:
+        subprocess.run(
+            command,
+            stdout=subprocess.DEVNULL,
+            check=True,
+        )
+        info(f"Successfully uninstalled release '{release_name}'.")
+    except subprocess.CalledProcessError as e:
+        error(f"Failed to uninstall release '{release_name}': {e.stderr}")
+    except FileNotFoundError:
+        error(
+            "Helm command not found. Please ensure Helm is installed and available in "
+            "the PATH."
+        )

vantage6/cli/common/utils.py

@@ -1,14 +1,15 @@
 import enum
-import questionary as q
-from colorama import Fore, Style
-import click
+from subprocess import Popen
 from typing import Iterable
+
+import click
 import docker
-from subprocess import Popen
+import questionary as q
+from colorama import Fore, Style
 
+from vantage6.common import error, warning
+from vantage6.common.globals import APPNAME, STRING_ENCODING, InstanceType
 
-from vantage6.common import warning, error
-from vantage6.common.globals import APPNAME, InstanceType, STRING_ENCODING
 from vantage6.cli.context import select_context_class
 
 
@@ -177,6 +178,6 @@ def attach_logs(*labels: list[str]) -> None:
     labels : list[str]
         The labels to attach to
     """
-    command = ["devspace", "logs", "--follow", "--label-selector", ",".join(labels)]
+    command = ["kubectl", "logs", "--follow", "--selector", ",".join(labels)]
     process = Popen(command, stdout=None, stderr=None)
     process.wait()

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

@@ -20,17 +20,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 +41,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),
     }