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

vantage6/cli/algostore/stop.py

@@ -2,12 +2,13 @@ import click
 import docker
 from colorama import Fore, Style
 
-from vantage6.common import info, warning, error
+from vantage6.common import error, info, warning
 from vantage6.common.docker.addons import (
     check_docker_running,
     remove_container_if_exists,
 )
 from vantage6.common.globals import APPNAME, InstanceType
+
 from vantage6.cli.common.decorator import click_insert_context
 from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
 
@@ -23,7 +24,7 @@ def cli_algo_store_stop(ctx: AlgorithmStoreContext, all_stores: bool):
     client = docker.from_env()
 
     running_stores = client.containers.list(
-        filters={"label": f"{APPNAME}-type={InstanceType.ALGORITHM_STORE.value}"}
+        filters={"label": f"{APPNAME}-type={InstanceType.ALGORITHM_STORE}"}
     )
 
     if not running_stores:

vantage6/cli/cli.py

@@ -24,6 +24,11 @@ from vantage6.cli.node.stop import cli_node_stop
 from vantage6.cli.node.version import cli_node_version
 from vantage6.cli.algorithm.create import cli_algorithm_create
 from vantage6.cli.algorithm.update import cli_algorithm_update
+from vantage6.cli.algorithm.generate_algorithm_json import (
+    cli_algorithm_generate_algorithm_json,
+)
+
+# from vantage6.cli.test.client_script import cli_test_client_script
 from vantage6.cli.test.feature_tester import cli_test_features
 
 # from vantage6.cli.test.integration_test import cli_test_integration
@@ -34,6 +39,8 @@ from vantage6.cli.algostore.stop import cli_algo_store_stop
 from vantage6.cli.algostore.files import cli_algo_store_files
 from vantage6.cli.algostore.list import cli_algo_store_configuration_list
 from vantage6.cli.algostore.remove import cli_algo_store_remove
+from vantage6.cli.use.context import cli_use_context
+from vantage6.cli.use.namespace import cli_use_namespace
 
 
 # Define the server group
@@ -104,6 +111,9 @@ def cli_algorithm() -> None:
 # Define the commands for the algorithm group
 cli_algorithm.add_command(cli_algorithm_create, name="create")
 cli_algorithm.add_command(cli_algorithm_update, name="update")
+cli_algorithm.add_command(
+    cli_algorithm_generate_algorithm_json, name="generate-algorithm-json"
+)
 
 
 # Define the test group
@@ -117,6 +127,7 @@ def cli_test() -> None:
 # Define the commands for the test group
 cli_test.add_command(cli_test_features, name="feature-test")
 # cli_test.add_command(cli_test_integration, name="integration-test")
+# cli_test.add_command(cli_test_client_script, name="client-script")
 
 
 # Define the algorithm-store group
@@ -137,6 +148,19 @@ cli_algo_store.add_command(cli_algo_store_configuration_list, name="list")
 cli_algo_store.add_command(cli_algo_store_remove, name="remove")
 
 
+# Add the use group
+@click.group(name="use")
+def cli_use() -> None:
+    """
+    Manage Kubernetes context and namespace.
+    """
+
+
+# Define the commands for the use group
+cli_use.add_command(cli_use_context, name="context")
+cli_use.add_command(cli_use_namespace, name="namespace")
+
+
 # Define the overall group
 @click.group(name="cli", context_settings={"show_default": True})
 def cli_complete() -> None:
@@ -155,3 +179,4 @@ cli_complete.add_command(cli_dev)
 cli_complete.add_command(cli_algorithm)
 cli_complete.add_command(cli_test)
 cli_complete.add_command(cli_algo_store)
+cli_complete.add_command(cli_use)

vantage6/cli/common/decorator.py

@@ -1,11 +1,13 @@
 from functools import wraps
 from pathlib import Path
+
 import click
 
 from vantage6.common import error
 from vantage6.common.globals import InstanceType
+
 from vantage6.cli.configuration_wizard import select_configuration_questionaire
-from vantage6.cli.context import select_context_class, get_context
+from vantage6.cli.context import get_context, select_context_class
 
 
 def click_insert_context(

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 (
+    check_config_name_allowed,
+    validate_input_cmd_args,
+)
 
 
 def check_for_start(ctx: AppContext, type_: InstanceType) -> DockerClient:
@@ -57,7 +69,7 @@ def check_for_start(ctx: AppContext, type_: InstanceType) -> DockerClient:
     )
     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")
+            error(f"Server {Fore.RED}{ctx.name}{Style.RESET_ALL} is already running")
             exit(1)
     return docker_client
 
@@ -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.
@@ -290,8 +304,6 @@ def attach_logs(container: Container, type_: InstanceType) -> None:
     type_ : InstanceType
         The type of instance to attach the logs for
     """
-    if isinstance(type_, enum.Enum):
-        type_ = type_.value
     logs = container.attach(stream=True, logs=True, stdout=True)
     Thread(target=print_log_worker, args=(logs,), daemon=True).start()
     while True:
@@ -304,3 +316,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
 
 
@@ -77,7 +78,7 @@ def get_running_servers(
     return [server.name for server in running_servers]
 
 
-def get_server_configuration_list(instance_type: InstanceType.SERVER) -> None:
+def get_server_configuration_list(instance_type: InstanceType) -> None:
     """
     Print list of available server configurations.
 
@@ -89,11 +90,7 @@ def get_server_configuration_list(instance_type: InstanceType.SERVER) -> None:
     client = docker.from_env()
     ctx_class = select_context_class(instance_type)
 
-    instance_type_value = (
-        instance_type.value if isinstance(instance_type, enum.Enum) else instance_type
-    )
-
-    running_server_names = get_running_servers(client, instance_type_value)
+    running_server_names = get_running_servers(client, instance_type)
     header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
 
     click.echo(header)
@@ -107,26 +104,24 @@ def get_server_configuration_list(instance_type: InstanceType.SERVER) -> None:
     for config in configs:
         status = (
             running
-            if f"{APPNAME}-{config.name}-system-{instance_type_value}"
-            in running_server_names
+            if f"{APPNAME}-{config.name}-system-{instance_type}" in running_server_names
             else stopped
         )
-        click.echo(f"{config.name:25}" f"{status:25} System ")
+        click.echo(f"{config.name:25}{status:25} System ")
 
     # user folders
     configs, f2 = ctx_class.available_configurations(system_folders=False)
     for config in configs:
         status = (
             running
-            if f"{APPNAME}-{config.name}-user-{instance_type_value}"
-            in running_server_names
+            if f"{APPNAME}-{config.name}-user-{instance_type}" in running_server_names
             else stopped
         )
-        click.echo(f"{config.name:25}" f"{status:25} User   ")
+        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}")
+        warning(f"{Fore.RED}Failed imports: {len(f1) + len(f2)}{Style.RESET_ALL}")
 
 
 def print_log_worker(logs_stream: Iterable[bytes]) -> None:
@@ -177,6 +172,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()