vantage6 5.0.0a37__py3-none-any.whl → 5.0.0a38__py3-none-any.whl

vantage6/cli/common/utils.py

@@ -1,19 +1,20 @@
 import json
 import subprocess
 from pathlib import Path
-from subprocess import Popen
 from typing import Iterable
 
-import click
 import docker
 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 error
+from vantage6.common.globals import (
+    APPNAME,
+    SANDBOX_SUFFIX,
+    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
 
@@ -251,60 +252,6 @@ def get_running_servers(
     return [server.name for server in running_servers]
 
 
-def get_server_configuration_list(instance_type: InstanceType) -> None:
-    """
-    Print list of available server configurations.
-
-    Parameters
-    ----------
-    instance_type : InstanceType
-        The type of instance to get the configurations for
-    """
-    ctx_class = select_context_class(instance_type)
-
-    running_server_names = find_running_service_names(instance_type)
-    header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
-
-    click.echo(header)
-    click.echo("-" * len(header))
-
-    running = Fore.GREEN + "Running" + Style.RESET_ALL
-    stopped = Fore.RED + "Not running" + Style.RESET_ALL
-
-    # system folders
-    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.value}"
-            in running_server_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25} System ")
-
-    # user folders
-    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.value}"
-            in running_server_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25} User   ")
-
-    click.echo("-" * 85)
-    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:
     """
     Print the logs from the logs stream.
@@ -354,20 +301,6 @@ def get_config_name_from_service_name(service_name: str) -> str:
     return "-".join(service_name.split("-")[1:-2])
 
 
-def attach_logs(*labels: list[str]) -> None:
-    """
-    Attach to the logs of the given labels.
-
-    Parameters
-    ----------
-    labels : list[str]
-        The labels to attach to
-    """
-    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.
@@ -419,7 +352,9 @@ def check_running(
     return helm_release_name in running_services
 
 
-def get_config_name_from_helm_release_name(helm_release_name: str) -> str:
+def get_config_name_from_helm_release_name(
+    helm_release_name: str, is_store: bool = False
+) -> str:
     """
     Get the config name from a helm release name.
 
@@ -427,6 +362,8 @@ def get_config_name_from_helm_release_name(helm_release_name: str) -> str:
     ----------
     helm_release_name : str
         The name of the Helm release
+    is_store : bool, optional
+        Whether the instance is a store or not. By default False.
 
     Returns
     -------
@@ -436,4 +373,35 @@ def get_config_name_from_helm_release_name(helm_release_name: str) -> str:
     # helm release name is structured as:
     # f"{APPNAME}-{name}-{scope}-{instance_type}"
     # we want to get the name from the service name
-    return "-".join(helm_release_name.split("-")[1:-2])
+    if is_store:
+        # for store, the instance type is `algorithm-store` which contains an additional
+        # hyphen
+        return "-".join(helm_release_name.split("-")[1:-3])
+    else:
+        return "-".join(helm_release_name.split("-")[1:-2])
+
+
+def extract_name_and_is_sandbox(name: str | None, is_sandbox: bool) -> tuple[str, bool]:
+    """
+    Extract the name and is_sandbox from the name.
+
+    Note that the name may be None: this occurs before when this function is called
+    before the user has selected a name. This scenario is fine because when the user
+    selects a name interactively, the name never ends with the .sandbox suffix.
+
+    Parameters
+    ----------
+    name : str | None
+        The name of the instance
+    is_sandbox : bool
+        Whether the instance is a sandbox instance
+
+    Returns
+    -------
+    tuple[str, bool]
+        The name and is_sandbox
+    """
+    if name and name.endswith(SANDBOX_SUFFIX):
+        return name[: -len(SANDBOX_SUFFIX)], True
+    else:
+        return name, is_sandbox

vantage6/cli/common/version.py

@@ -0,0 +1,82 @@
+from vantage6.common import error
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.utils import (
+    find_running_service_names,
+    get_config_name_from_helm_release_name,
+    select_context_and_namespace,
+    select_running_service,
+)
+from vantage6.cli.context import get_context
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+from vantage6.cli.context.node import NodeContext
+from vantage6.cli.context.server import ServerContext
+
+
+def get_and_select_ctx(
+    instance_type: InstanceType,
+    name: str,
+    system_folders: bool,
+    context: str,
+    namespace: str,
+    is_sandbox: bool,
+) -> ServerContext | NodeContext | AlgorithmStoreContext:
+    """
+    Get and select the context for the given instance type.
+
+    Parameters
+    ----------
+    instance_type : InstanceType
+        The type of instance to get the context for
+    name : str
+        The name of the instance
+    system_folders : bool
+        Whether to use system folders or not
+    context : str
+        The Kubernetes context to use
+    namespace : str
+        The Kubernetes namespace to use
+    is_sandbox : bool
+        Whether the configuration is a sandbox configuration
+
+    Returns
+    -------
+    ServerContext | NodeContext | AlgorithmStoreContext
+        The context for the given instance type
+    """
+    context, namespace = select_context_and_namespace(
+        context=context,
+        namespace=namespace,
+    )
+    running_services = find_running_service_names(
+        instance_type=instance_type,
+        only_system_folders=False,
+        only_user_folders=False,
+        context=context,
+        namespace=namespace,
+        sandbox=is_sandbox,
+    )
+
+    if not running_services:
+        error(f"No running {instance_type.value}s found.")
+        exit(1)
+
+    if not name:
+        helm_name = select_running_service(running_services, instance_type)
+
+        service_name = get_config_name_from_helm_release_name(
+            helm_name, is_store=(instance_type == InstanceType.ALGORITHM_STORE)
+        )
+        ctx = get_context(
+            instance_type, service_name, system_folders, is_sandbox=is_sandbox
+        )
+
+    else:
+        ctx = get_context(instance_type, name, system_folders, is_sandbox=is_sandbox)
+        helm_name = ctx.helm_release_name
+        service_name = ctx.name
+
+    if helm_name not in running_services:
+        error(f"The {instance_type.value} {service_name} is not running.")
+        exit(1)
+    return ctx

vantage6/cli/context/__init__.py

@@ -13,6 +13,7 @@ from colorama import Fore, Style
 from vantage6.common import error
 from vantage6.common.globals import InstanceType
 
+from vantage6.cli.common.utils import extract_name_and_is_sandbox
 from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
 from vantage6.cli.context.auth import AuthContext
 from vantage6.cli.context.node import NodeContext
@@ -74,6 +75,8 @@ def get_context(
     AppContext
         Specialized subclass context of AppContext for the given instance type
     """
+    name, is_sandbox = extract_name_and_is_sandbox(name, is_sandbox)
+
     ctx_class = select_context_class(type_)
     if not ctx_class.config_exists(name, system_folders, is_sandbox=is_sandbox):
         scope = "system" if system_folders else "user"

vantage6/cli/context/algorithm_store.py

@@ -117,7 +117,7 @@ class AlgorithmStoreContext(BaseServerContext):
 
     @classmethod
     def available_configurations(
-        cls, system_folders: bool = S_FOL
+        cls, system_folders: bool = S_FOL, is_sandbox: bool = False
     ) -> tuple[list, list]:
         """
         Find all available server configurations in the default folders.
@@ -134,5 +134,5 @@ class AlgorithmStoreContext(BaseServerContext):
             list contains invalid configuration files.
         """
         return super().available_configurations(
-            InstanceType.ALGORITHM_STORE, system_folders
+            InstanceType.ALGORITHM_STORE, system_folders, is_sandbox
         )

vantage6/cli/node/attach.py

@@ -2,13 +2,37 @@ import click
 
 from vantage6.common import info
 
-from vantage6.cli.common.utils import attach_logs
+from vantage6.cli.common.attach import attach_logs
+from vantage6.cli.context import InstanceType
+from vantage6.cli.globals import InfraComponentName
 
 
 @click.command()
-def cli_node_attach() -> None:
+@click.option("-n", "--name", default=None, help="Name of the configuration")
+@click.option("--system", "system_folders", flag_value=True, help="Use system folders")
+@click.option("--user", "system_folders", flag_value=False, help="Use user folders")
+@click.option("--context", default=None, help="Kubernetes context to use")
+@click.option("--namespace", default=None, help="Kubernetes namespace to use")
+@click.option(
+    "--sandbox", "is_sandbox", flag_value=True, help="Attach to a sandbox environment"
+)
+def cli_node_attach(
+    name: str | None,
+    system_folders: bool,
+    context: str,
+    namespace: str,
+    is_sandbox: bool,
+) -> None:
     """
     Show the node logs in the current console.
     """
     info("Attaching to node logs...")
-    attach_logs("app=node")
+    attach_logs(
+        name,
+        instance_type=InstanceType.NODE,
+        infra_component=InfraComponentName.NODE,
+        system_folders=system_folders,
+        context=context,
+        namespace=namespace,
+        is_sandbox=is_sandbox,
+    )

vantage6/cli/node/list.py

@@ -1,13 +1,8 @@
 import click
-import docker
-from colorama import Fore, Style
 
-from vantage6.common import warning
-from vantage6.common.docker.addons import check_docker_running
-from vantage6.common.globals import APPNAME
+from vantage6.common.globals import InstanceType
 
-from vantage6.cli.context.node import NodeContext
-from vantage6.cli.node.common import find_running_node_names
+from vantage6.cli.common.list import get_configuration_list
 
 
 @click.command()
@@ -18,40 +13,4 @@ def cli_node_list() -> None:
     Note that this command cannot find node configuration files in custom
     directories.
     """
-
-    check_docker_running()
-    client = docker.from_env()
-
-    running_node_names = find_running_node_names(client)
-
-    header = "\nName" + (21 * " ") + "Status" + (10 * " ") + "System/User"
-
-    click.echo(header)
-    click.echo("-" * len(header))
-
-    running = Fore.GREEN + "Running" + Style.RESET_ALL
-    stopped = Fore.RED + "Not running" + Style.RESET_ALL
-
-    # system folders
-    configs, f1 = NodeContext.available_configurations(system_folders=True)
-    for config in configs:
-        status = (
-            running
-            if f"{APPNAME}-{config.name}-system" in running_node_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25}System ")
-
-    # user folders
-    configs, f2 = NodeContext.available_configurations(system_folders=False)
-    for config in configs:
-        status = (
-            running
-            if f"{APPNAME}-{config.name}-user" in running_node_names
-            else stopped
-        )
-        click.echo(f"{config.name:25}{status:25}User   ")
-
-    click.echo("-" * 53)
-    if len(f1) + len(f2):
-        warning(f"{Fore.RED}Failed imports: {len(f1) + len(f2)}{Style.RESET_ALL}")
+    get_configuration_list(InstanceType.NODE)

vantage6/cli/node/start.py

@@ -3,6 +3,7 @@ import click
 from vantage6.common import info
 from vantage6.common.globals import InstanceType
 
+from vantage6.cli.common.attach import attach_logs
 from vantage6.cli.common.decorator import click_insert_context
 from vantage6.cli.common.start import (
     helm_install,
@@ -10,12 +11,11 @@ from vantage6.cli.common.start import (
     start_port_forward,
 )
 from vantage6.cli.common.utils import (
-    attach_logs,
     create_directory_if_not_exists,
     select_context_and_namespace,
 )
 from vantage6.cli.context.node import NodeContext
-from vantage6.cli.globals import ChartName
+from vantage6.cli.globals import ChartName, InfraComponentName
 
 from vantage6.node.globals import DEFAULT_PROXY_SERVER_PORT
 
@@ -123,4 +123,12 @@ def cli_node_start(
     )
 
     if attach:
-        attach_logs("app=node")
+        attach_logs(
+            name,
+            instance_type=InstanceType.NODE,
+            infra_component=InfraComponentName.NODE,
+            system_folders=system_folders,
+            context=context,
+            namespace=namespace,
+            is_sandbox=ctx.is_sandbox,
+        )

vantage6/cli/node/stop.py

@@ -1,20 +1,23 @@
 import click
-from kubernetes import client as k8s_client, config as k8s_config
+from kubernetes import client as k8s_client
 from kubernetes.client import ApiException
-from kubernetes.config.config_exception import ConfigException
 
 from vantage6.common import error, info, warning
 from vantage6.common.globals import APPNAME, InstanceType
 
 from vantage6.cli.common.stop import execute_stop, helm_uninstall, stop_port_forward
-from vantage6.cli.common.utils import get_config_name_from_helm_release_name
+from vantage6.cli.common.utils import (
+    extract_name_and_is_sandbox,
+    get_config_name_from_helm_release_name,
+)
 from vantage6.cli.context import get_context
 from vantage6.cli.context.node import NodeContext
 from vantage6.cli.globals import (
     DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL,
     InfraComponentName,
 )
-from vantage6.cli.node.task_cleanup import delete_job_related_pods
+from vantage6.cli.node.common.task_cleanup import delete_job_related_pods
+from vantage6.cli.utils_kubernetes import create_kubernetes_apis_with_ssl_handling
 
 
 @click.command()
@@ -50,6 +53,7 @@ def cli_node_stop(
     """
     Stop one or all running nodes.
     """
+    name, is_sandbox = extract_name_and_is_sandbox(name, is_sandbox)
     execute_stop(
         stop_function=_stop_node,
         stop_function_args={"system_folders": system_folders, "is_sandbox": is_sandbox},
@@ -142,18 +146,12 @@ def cleanup_task_jobs(
         error("Either all_nodes or node_ctx must be given to cleanup task jobs")
         return False
 
-    # Load Kubernetes configuration (in-cluster first, fallback to kubeconfig)
+    # Load Kubernetes configuration with SSL handling
     try:
-        k8s_config.load_incluster_config()
-    except ConfigException:
-        try:
-            k8s_config.load_kube_config()
-        except ConfigException as exc:
-            error(f"Failed to load Kubernetes configuration: {exc}")
-            return False
-
-    core_api = k8s_client.CoreV1Api()
-    batch_api = k8s_client.BatchV1Api()
+        core_api, batch_api = create_kubernetes_apis_with_ssl_handling()
+    except RuntimeError as exc:
+        error(f"Failed to load Kubernetes configuration: {exc}")
+        return False
 
     jobs = _get_jobs(namespace, batch_api)
 

vantage6/cli/node/version.py

@@ -1,14 +1,16 @@
 import click
-import docker
-import questionary as q
+from kubernetes import config as k8s_config
+from kubernetes.config.config_exception import ConfigException
+from kubernetes.stream import stream
 
-from vantage6.common import error
-from vantage6.common.docker.addons import check_docker_running
-from vantage6.common.globals import APPNAME
+from vantage6.common import error, info
+from vantage6.common.globals import APPNAME, InstanceType
 
 from vantage6.cli import __version__
+from vantage6.cli.common.utils import select_context_and_namespace
+from vantage6.cli.common.version import get_and_select_ctx
 from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
-from vantage6.cli.node.common import find_running_node_names
+from vantage6.cli.utils_kubernetes import get_core_api_with_ssl_handling
 
 
 @click.command()
@@ -27,36 +29,97 @@ from vantage6.cli.node.common import find_running_node_names
     help="Search for configuration in user folders rather than "
     "system folders. This is the default",
 )
-def cli_node_version(name: str, system_folders: bool) -> None:
+@click.option("--context", default=None, help="Kubernetes context to use")
+@click.option("--namespace", default=None, help="Kubernetes namespace to use")
+@click.option(
+    "--sandbox", "is_sandbox", flag_value=True, help="Is this a sandbox environment?"
+)
+def cli_node_version(
+    name: str, system_folders: bool, context: str, namespace: str, is_sandbox: bool
+) -> None:
     """
     Returns current version of a vantage6 node.
     """
-    check_docker_running()
-    client = docker.from_env()
+    context, namespace = select_context_and_namespace(
+        context=context,
+        namespace=namespace,
+    )
+    ctx = get_and_select_ctx(
+        InstanceType.NODE, name, system_folders, context, namespace, is_sandbox
+    )
+    version = _get_node_version_from_k8s(ctx.helm_release_name, namespace, context)
+    info("")
+    info(f"Node version: {version}")
+    info(f"CLI version: {__version__}")
 
-    running_node_names = find_running_node_names(client)
 
-    if not name:
-        if not running_node_names:
-            error(
-                "No nodes are running! You can only check the version for "
-                "nodes that are running"
-            )
-            exit(1)
+def _get_node_version_from_k8s(
+    helm_release: str,
+    namespace: str,
+    context: str,
+) -> str:
+    """
+    Runs 'vnode-local version' in the node pod belonging to the Helm release.
+    """
+    pod = _get_pod_name_for_helm_release(helm_release, namespace, context)
+    output = _exec_pod_command(
+        pod_name=pod,
+        namespace=namespace,
+        command=["vnode-local", "version"],
+    )
+    return output.strip()
+
+
+def _get_pod_name_for_helm_release(
+    helm_release: str,
+    namespace: str,
+    context: str,
+) -> str:
+    """
+    Returns the first pod name for a given Helm release in a namespace.
+    Looks up pods using the standard Helm label 'app.kubernetes.io/instance'.
+    """
+    try:
+        # Load kubeconfig (context optional). Falls back to in-cluster if not available.
         try:
-            name = q.select(
-                "Select the node you wish to inspect:", choices=running_node_names
-            ).unsafe_ask()
-        except KeyboardInterrupt:
-            error("Aborted by user!")
-            return
-    else:
-        post_fix = "system" if system_folders else "user"
-        name = f"{APPNAME}-{name}-{post_fix}"
-
-    if name in running_node_names:
-        container = client.containers.get(name)
-        version = container.exec_run(cmd="vnode-local version", stdout=True)
-        click.echo({"node": version.output.decode("utf-8"), "cli": __version__})
-    else:
-        error(f"Node {name} is not running! Cannot provide version...")
+            k8s_config.load_kube_config(context=context)  # desktop/dev
+        except ConfigException:
+            k8s_config.load_incluster_config()  # in-cluster
+    except ConfigException as exc:
+        raise RuntimeError(f"Failed to load Kubernetes config: {exc}") from exc
+
+    core = get_core_api_with_ssl_handling()
+    selector = f"app={APPNAME}-node,release={helm_release}"
+    pods = core.list_namespaced_pod(namespace=namespace, label_selector=selector).items
+    if not pods:
+        error(f"No pods found for Helm release '{helm_release}' in ns '{namespace}'")
+        exit(1)
+    # Prefer a Ready pod
+    for p in pods:
+        for cond in p.status.conditions or []:
+            if cond.type == "Ready" and cond.status == "True":
+                return p.metadata.name
+    # Fallback to first pod
+    return pods[0].metadata.name
+
+
+def _exec_pod_command(
+    pod_name: str,
+    namespace: str,
+    command: list[str],
+) -> str:
+    """
+    Executes a command inside the specified pod (and optional container) and returns stdout.
+    """
+    core = get_core_api_with_ssl_handling()
+    resp = stream(
+        core.connect_get_namespaced_pod_exec,
+        pod_name,
+        namespace,
+        command=command,
+        stderr=True,
+        stdin=False,
+        stdout=True,
+        tty=False,
+    )
+    return resp

vantage6/cli/sandbox/config/base.py

@@ -49,7 +49,10 @@ class BaseSandboxConfigManager:
         return {}
 
     def _create_and_get_data_dir(
-        self, instance_type: InstanceType, is_data_folder: bool = False
+        self,
+        instance_type: InstanceType,
+        is_data_folder: bool = False,
+        node_name: str | None = None,
     ) -> Path:
         """
         Create and get the data directory.
@@ -61,6 +64,8 @@ class BaseSandboxConfigManager:
         is_data_folder: bool
             Whether or not to create the data folder or a config folder. This is only
             used for node databases. Default is False.
+        node_name: str | None
+            Name of the node. Only used if is_data_folder is True.
 
         Returns
         -------
@@ -83,7 +88,10 @@ class BaseSandboxConfigManager:
             data_dir = main_data_dir / self.server_name / "store"
         elif instance_type == InstanceType.NODE:
             if is_data_folder:
-                last_subfolder = "data"
+                if node_name:
+                    last_subfolder = f"data_{node_name}"
+                else:
+                    last_subfolder = "data"
             else:
                 last_subfolder = "node"
             data_dir = main_data_dir / self.server_name / last_subfolder

vantage6/cli/sandbox/config/core.py

@@ -118,7 +118,7 @@ class CoreSandboxConfigManager(BaseSandboxConfigManager):
                 # TODO make this configurable
                 "image": (
                     self.server_image
-                    or "harbor2.vantage6.ai/infrastructure/server:5.0.0a36"
+                    or "harbor2.vantage6.ai/infrastructure/server:5.0.0a37"
                 ),
                 "algorithm_stores": [
                     {
@@ -156,7 +156,7 @@ class CoreSandboxConfigManager(BaseSandboxConfigManager):
                 # TODO: v5+ set to latest v5 image
                 # TODO: make this configurable
                 "image": (
-                    self.ui_image or "harbor2.vantage6.ai/infrastructure/ui:5.0.0a36"
+                    self.ui_image or "harbor2.vantage6.ai/infrastructure/ui:5.0.0a37"
                 ),
             },
         }
@@ -231,7 +231,7 @@ class CoreSandboxConfigManager(BaseSandboxConfigManager):
                 "vantage6ServerUri": f"{HTTP_LOCALHOST}:{self.server_port}",
                 "image": (
                     self.store_image
-                    or "harbor2.vantage6.ai/infrastructure/algorithm-store:5.0.0a36"
+                    or "harbor2.vantage6.ai/infrastructure/algorithm-store:5.0.0a37"
                 ),
                 "keycloakUrl": (
                     f"http://vantage6-{self.server_name}-auth-user-auth-keycloak."