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

vantage6/cli/node/stop.py

@@ -1,13 +1,23 @@
 import click
+from kubernetes import client as k8s_client
+from kubernetes.client import ApiException
 
-from vantage6.common import info
-from vantage6.common.globals import InstanceType
+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 (
+    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.common.task_cleanup import delete_job_related_pods
+from vantage6.cli.utils_kubernetes import create_kubernetes_apis_with_ssl_handling
 
 
 @click.command()
@@ -29,18 +39,24 @@ from vantage6.cli.globals import (
     "system folders. This is the default.",
 )
 @click.option("--all", "all_nodes", flag_value=True, help="Stop all running nodes")
+@click.option(
+    "--sandbox", "is_sandbox", flag_value=True, help="Stop a sandbox environment"
+)
 def cli_node_stop(
     name: str,
     context: str,
     namespace: str,
     system_folders: bool,
     all_nodes: bool,
+    is_sandbox: bool,
 ) -> None:
     """
     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},
         instance_type=InstanceType.NODE,
         infra_component=InfraComponentName.NODE,
         stop_all=all_nodes,
@@ -48,24 +64,152 @@ def cli_node_stop(
         namespace=namespace,
         context=context,
         system_folders=system_folders,
+        is_sandbox=is_sandbox,
     )
 
 
-def _stop_node(node_name: str, namespace: str, context: str) -> None:
+def _stop_node(
+    node_helm_name: str,
+    namespace: str,
+    context: str,
+    system_folders: bool,
+    is_sandbox: bool,
+) -> None:
     """
     Stop a node
 
     Parameters
     ----------
-    node_name : str
+    node_helm_name : str
         Name of the node to stop
     namespace : str
         Kubernetes namespace to use
     context : str
         Kubernetes context to use
+    system_folders: bool
+        Whether to use the system folders or not
+    is_sandbox: bool
+        Whether node is a sandbox node or not
     """
-    helm_uninstall(release_name=node_name, context=context, namespace=namespace)
+    helm_uninstall(release_name=node_helm_name, context=context, namespace=namespace)
+
+    stop_port_forward(service_name=f"{node_helm_name}-node-service")
+
+    _stop_node_tasks(node_helm_name, system_folders, is_sandbox)
+
+    info(f"Node {node_helm_name} stopped successfully.")
+
+
+def _stop_node_tasks(
+    node_helm_name: str, system_folders: bool, is_sandbox: bool
+) -> None:
+    """
+    Stop the tasks of a node
+    """
+    node_name = get_config_name_from_helm_release_name(node_helm_name)
+    node_ctx = get_context(
+        InstanceType.NODE, node_name, system_folders, is_sandbox=is_sandbox
+    )
+
+    task_namespace = node_ctx.config.get("node", {}).get("taskNamespace")
+    if not task_namespace:
+        warning("Could not find node's task namespace. Node tasks will not be stopped.")
+        return
+
+    # detect tasks from the task namespace that this node is assigned to
+    cleanup_task_jobs(task_namespace, node_ctx, all_nodes=False)
+
+
+def cleanup_task_jobs(
+    namespace: str, node_ctx: NodeContext | None = None, all_nodes: bool = False
+) -> bool:
+    """
+    Cleanup Vantage6 task jobs in a given namespace.
+
+    Parameters
+    ----------
+    namespace: str
+        Namespace to cleanup
+    node_ctx: NodeContext | None
+        Node context to cleanup. If not given, all_nodes must be True.
+    all_nodes: bool
+        Cleanup all nodes. If not given, node_name must be given.
+
+    Returns
+    -------
+    bool
+        True if cleanup was successful, False otherwise
+    """
+    info(f"Cleaning up Vantage6 task jobs in namespace '{namespace}'")
+
+    if not all_nodes and not node_ctx:
+        error("Either all_nodes or node_ctx must be given to cleanup task jobs")
+        return False
+
+    # Load Kubernetes configuration with SSL handling
+    try:
+        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)
+
+    deletions = 0
+    for job in jobs:
+        if not all_nodes and job.metadata.labels.get("node_id") != node_ctx.identifier:
+            # if all_nodes is False, we should only delete jobs assigned to the current
+            # node
+            continue
+        elif all_nodes and not _is_vantage6_task_job(job):
+            # if all_nodes is True, we should only delete vantage6 task jobs, not other
+            # jobs
+            continue
+
+        run_id = _get_job_run_id(job)
+        if run_id is None:
+            error(f"Job '{job.metadata.name}' has no run_id annotation, skipping...")
+            continue
+
+        # Use shared cleanup to delete job, pods and related secret
+        job_name = job.metadata.name
+        info(f"Deleting job '{job_name}' (run_id={run_id})")
+        delete_job_related_pods(
+            run_id=run_id,
+            container_name=f"{APPNAME}-run-{run_id}",
+            namespace=namespace,
+            core_api=core_api,
+            batch_api=batch_api,
+        )
+        deletions += 1
+
+    if deletions == 0:
+        info(f"No Vantage6 task jobs found to delete in namespace '{namespace}'")
+    else:
+        info(f"Deleted {deletions} Vantage6 task job(s) in namespace '{namespace}'")
+    return True
+
+
+def _is_vantage6_task_job(job: k8s_client.V1Job) -> bool:
+    # Vantage6 task jobs can be identified by their name, which is of the form
+    # "vantage6-run-<run_id>"
+    return job.metadata.name.startswith(f"{APPNAME}-run-")
+
+
+def _get_jobs(
+    namespace: str, batch_api: k8s_client.BatchV1Api
+) -> list[k8s_client.V1Job]:
+    try:
+        return batch_api.list_namespaced_job(namespace=namespace).items
+    except ApiException as exc:
+        error(f"Failed to list jobs in namespace {namespace}: {exc}")
+        return []
 
-    stop_port_forward(service_name=f"{node_name}-vantage6-node-service")
 
-    info(f"Node {node_name} stopped successfully.")
+def _get_job_run_id(job: k8s_client.V1Job) -> int | None:
+    annotations = job.metadata.annotations or {}
+    try:
+        return int(annotations.get("run_id"))
+    except ValueError:
+        error(f"Job '{job.metadata.name}' has no run_id annotation, skipping")
+        return None

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

@@ -0,0 +1,109 @@
+from pathlib import Path
+
+import yaml
+
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.context import select_context_class
+from vantage6.cli.sandbox.populate.helpers.utils import replace_wsl_path
+
+
+class BaseSandboxConfigManager:
+    """
+    Base class for sandbox configuration managers.
+
+    Parameters
+    ----------
+    server_name : str
+        Name of the server.
+    custom_data_dir : Path | None
+        Path to the custom data directory. Useful on WSL because of mount issues for
+        default directories.
+    """
+
+    def __init__(self, server_name: str, custom_data_dir: Path | None) -> None:
+        self.server_name = server_name
+        self.custom_data_dir = Path(custom_data_dir) if custom_data_dir else None
+
+    @staticmethod
+    def _read_extra_config_file(extra_config_file: Path | None) -> dict:
+        """Reads extra configuration file.
+
+        Parameters
+        ----------
+        extra_config_file : Path | None
+            Path to file with additional configuration.
+
+        Returns
+        -------
+        dict
+            Extra configuration parsed from YAML. Empty dict if none provided.
+        """
+        if extra_config_file:
+            with open(extra_config_file, "r", encoding="utf-8") as f:
+                loaded = yaml.safe_load(f) or {}
+                if not isinstance(loaded, dict):
+                    # Ensure we always return a dictionary
+                    return {"value": loaded}
+                return loaded
+        return {}
+
+    def _create_and_get_data_dir(
+        self,
+        instance_type: InstanceType,
+        is_data_folder: bool = False,
+        node_name: str | None = None,
+    ) -> Path:
+        """
+        Create and get the data directory.
+
+        Parameters
+        ----------
+        instance_type: InstanceType
+            Type of vantage6 component
+        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
+        -------
+        Path
+            Path to the data directory
+        """
+        ctx_class = select_context_class(instance_type)
+        folders = ctx_class.instance_folders(
+            instance_type=InstanceType.SERVER,
+            instance_name=self.server_name,
+            system_folders=False,
+        )
+        main_data_dir = (
+            Path(folders["dev"]) if not self.custom_data_dir else self.custom_data_dir
+        )
+
+        if instance_type == InstanceType.SERVER:
+            data_dir = main_data_dir / self.server_name / "server"
+        elif instance_type == InstanceType.ALGORITHM_STORE:
+            data_dir = main_data_dir / self.server_name / "store"
+        elif instance_type == InstanceType.NODE:
+            if is_data_folder:
+                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
+        else:
+            raise ValueError(f"Invalid instance type to get data dir: {instance_type}")
+
+        # For the directory to be created, ensure that if a WSL path is used, the path
+        # is converted to /mnt/wsl to create the directory on the host (not
+        # /run/desktop/mnt/host/wsl as will raise non-existent directory errors)
+        data_dir = replace_wsl_path(data_dir, to_mnt_wsl=True)
+        data_dir.mkdir(parents=True, exist_ok=True)
+        # now ensure that the wsl path is properly replaced to /run/desktop/mnt/host/wsl
+        # if it is a WSL path, because that path will be used in the node configuration
+        # files and is required to successfully mount the volumes.
+        return replace_wsl_path(data_dir, to_mnt_wsl=False)