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

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."

vantage6/cli/sandbox/config/node.py

@@ -214,7 +214,7 @@ class NodeSandboxConfigManager(BaseSandboxConfigManager):
         config_name = f"{self.server_name}-{node_name}"
 
         path_to_data_dir = self._create_and_get_data_dir(
-            InstanceType.NODE, is_data_folder=True
+            InstanceType.NODE, is_data_folder=True, node_name=node_name
         )
 
         # delete old node config if it exists
@@ -262,7 +262,7 @@ class NodeSandboxConfigManager(BaseSandboxConfigManager):
                 "image": (
                     self.node_image
                     # TODO v5+ update
-                    or "harbor2.vantage6.ai/infrastructure/node:5.0.0a36"
+                    or "harbor2.vantage6.ai/infrastructure/node:5.0.0a37"
                 ),
                 "logging": {
                     "level": "DEBUG",
@@ -272,9 +272,6 @@ class NodeSandboxConfigManager(BaseSandboxConfigManager):
                     f"http://vantage6-{self.server_name}-auth-user-auth-keycloak."
                     f"{self.namespace}.svc.cluster.local"
                 ),
-                "dev": {
-                    "task_dir_extension": str(path_to_data_dir),
-                },
                 "persistence": {
                     "tasks": {
                         "hostPath": str(path_to_data_dir),

vantage6/cli/sandbox/remove.py

@@ -4,19 +4,18 @@ from shutil import rmtree
 
 import click
 
-from vantage6.common import error, info
+from vantage6.common import error, warning
 from vantage6.common.globals import InstanceType
 
+from vantage6.cli.auth.remove import auth_remove
 from vantage6.cli.common.remove import execute_remove
 from vantage6.cli.configuration_create import select_configuration_questionnaire
 from vantage6.cli.context import get_context
 from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
 from vantage6.cli.context.auth import AuthContext
 from vantage6.cli.context.node import NodeContext
-from vantage6.cli.context.server import ServerContext
 from vantage6.cli.globals import InfraComponentName
 from vantage6.cli.server.remove import cli_server_remove
-from vantage6.cli.utils import remove_file
 
 
 @click.command()
@@ -60,28 +59,6 @@ def cli_sandbox_remove(
 
     ctx = get_context(InstanceType.SERVER, name, system_folders=False, is_sandbox=True)
 
-    # remove the server
-    # Note that this also checks if the server is running. Therefore, it is prevented
-    # that a running sandbox is removed.
-    for handler in itertools.chain(ctx.log.handlers, ctx.log.root.handlers):
-        handler.close()
-    click_ctx.invoke(
-        cli_server_remove, ctx=ctx, name=name, system_folders=False, force=True
-    )
-
-    # removing the server import config
-    info("Deleting demo import config file")
-    server_configs = ServerContext.instance_folders(
-        InstanceType.SERVER, ctx.name, system_folders=False
-    )
-    import_config_to_del = Path(server_configs["dev"]) / f"{ctx.name}.yaml"
-    remove_file(import_config_to_del, "import_configuration")
-
-    # also remove the server folder
-    server_folder = server_configs["data"]
-    if server_folder.is_dir():
-        rmtree(server_folder)
-
     # remove the store folder
     store_configs = AlgorithmStoreContext.instance_folders(
         InstanceType.ALGORITHM_STORE,
@@ -117,20 +94,13 @@ def cli_sandbox_remove(
     if auth_folder.is_dir():
         rmtree(auth_folder)
 
-    # remove the auth config file
+    # remove the auth service
     auth_ctx = AuthContext(
         instance_name=f"{ctx.name}-auth",
         system_folders=False,
         is_sandbox=True,
     )
-    execute_remove(
-        auth_ctx,
-        InstanceType.AUTH,
-        InfraComponentName.AUTH,
-        f"{ctx.name}-auth",
-        system_folders=False,
-        force=True,
-    )
+    auth_remove(auth_ctx, f"{ctx.name}-auth", system_folders=False, force=True)
 
     # remove the nodes
     NodeContext.LOGGING_ENABLED = False
@@ -168,6 +138,18 @@ def cli_sandbox_remove(
 
     # remove data files attached to the network
     data_dirs_nodes = NodeContext.instance_folders("node", "", False)["dev"]
-    rmtree(Path(data_dirs_nodes / ctx.name))
+    try:
+        rmtree(Path(data_dirs_nodes / ctx.name))
+    except Exception as e:
+        warning(f"Failed to delete data directory {data_dirs_nodes / ctx.name}: {e}")
 
+    # remove the server last - if anything goes wrong, the server is still there so the
+    # user can still retry the removal.
+    # Note that this also checks if the server is running. Therefore, it is prevented
+    # that a running sandbox is removed.
+    for handler in itertools.chain(ctx.log.handlers, ctx.log.root.handlers):
+        handler.close()
+    click_ctx.invoke(
+        cli_server_remove, ctx=ctx, name=name, system_folders=False, force=True
+    )
     # TODO remove the right data in the custom data directory if it is provided

vantage6/cli/sandbox/start.py

@@ -44,6 +44,12 @@ from vantage6.cli.server.start import cli_server_start
     help="Generate this number of nodes in the development network. Only used if "
     "--re-initialize flag is provided.",
 )
+@click.option(
+    "--node-image",
+    type=str,
+    default=None,
+    help="Node image to use. Only used if --re-initialize flag is provided.",
+)
 @click.option(
     "--extra-node-config",
     type=click.Path("rb"),
@@ -80,6 +86,7 @@ def cli_sandbox_start(
     local_chart_dir: Path | None,
     re_initialize: bool,
     num_nodes: int,
+    node_image: str | None,
     extra_node_config: Path | None,
     add_dataset: tuple[str, Path] | None,
     custom_data_dir: Path | None,
@@ -101,6 +108,7 @@ def cli_sandbox_start(
         namespace=namespace,
         num_nodes=num_nodes,
         initialize=re_initialize,
+        node_image=node_image,
         extra_node_config=extra_node_config,
         add_dataset=add_dataset,
         custom_data_dir=custom_data_dir,

vantage6/cli/sandbox/stop.py

@@ -83,7 +83,7 @@ def cli_sandbox_stop(
         is_sandbox=True,
     )
 
-    # TODO: stop the auth service
+    # stop the auth service
     cmd = [
         "v6",
         "auth",

vantage6/cli/server/attach.py

@@ -2,13 +2,38 @@ 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_server_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_server_attach(
+    name: str | None,
+    system_folders: bool,
+    context: str,
+    namespace: str,
+    is_sandbox: bool,
+) -> None:
     """
     Show the server logs in the current console.
     """
     info("Attaching to server logs...")
-    attach_logs("app=vantage6-server", "component=vantage6-server")
+    attach_logs(
+        name,
+        instance_type=InstanceType.SERVER,
+        infra_component=InfraComponentName.SERVER,
+        system_folders=system_folders,
+        context=context,
+        namespace=namespace,
+        is_sandbox=is_sandbox,
+        additional_labels="component=vantage6-server",
+    )

vantage6/cli/server/import_.py

@@ -1,6 +1,7 @@
 import click
 import requests
 import yaml
+from marshmallow import Schema, ValidationError, fields, post_load
 
 from vantage6.common import error, info
 from vantage6.common.globals import (
@@ -64,7 +65,8 @@ def cli_server_import(ctx: ServerContext, file: str, drop_all: bool) -> None:
     info("Loading and validating import file")
     with open(file, "r") as f:
         import_data = yaml.safe_load(f)
-    # TODO: validate import file
+
+    _check_import_file(import_data)
 
     client = UserClient(
         server_url=f"{ctx.config['server']['baseUrl']}{ctx.config['server']['apiPath']}",
@@ -77,7 +79,9 @@ def cli_server_import(ctx: ServerContext, file: str, drop_all: bool) -> None:
     info("Authenticate using admin credentials (opens browser for login)")
     client.authenticate()
 
-    # TODO: validate that the user has the correct permissions to import data
+    # Note: we do not validate that the user has the correct permissions to import data.
+    # As the user has access to the `v6 server import` command, they already have
+    # access to the server+database.
 
     if drop_all:
         info("Dropping all existing data")
@@ -91,11 +95,12 @@ def cli_server_import(ctx: ServerContext, file: str, drop_all: bool) -> None:
     for organization in import_data["organizations"]:
         org = client.organization.create(
             name=organization["name"],
-            address1=organization["address1"] or "",
-            address2=organization["address2"] or "",
-            zipcode=organization["zipcode"] or "",
-            country=organization["country"] or "",
-            domain=organization["domain"] or "",
+            address1=organization.get("address1", ""),
+            address2=organization.get("address2", ""),
+            zipcode=str(organization.get("zipcode", "")),
+            country=organization.get("country", ""),
+            domain=organization.get("domain", ""),
+            public_key=organization.get("public_key", ""),
         )
         organizations.append(org)
 
@@ -152,16 +157,79 @@ def _drop_all(client: UserClient) -> None:
             info(f"Deleting collaboration {collaboration['name']}")
             client.collaboration.delete(collaboration["id"], delete_dependents=True)
 
-    # TODO: For some reason, the `delete_dependents` parameter is not working for users,
-    # so we delete them here first.
-    while users := [u for u in client.user.list()["data"] if u["username"] != "admin"]:
-        for user in users:
-            info(f"Deleting user {user['username']}")
-            client.user.delete(user["id"])
-
-    while orgs := [
-        o for o in client.organization.list()["data"] if o["name"] != "root"
-    ]:
+    # remove all organizations but keep the root organization
+    while orgs := [o for o in client.organization.list()["data"] if o["id"] != 1]:
         for org in orgs:
             info(f"Deleting organization {org['name']}")
             client.organization.delete(org["id"], delete_dependents=True)
+
+
+class StrOrInt(fields.Field):
+    """Field that can be a string or an integer"""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        if isinstance(value, str):
+            return value
+        elif isinstance(value, int):
+            return str(value)
+        else:
+            raise ValidationError("Value must be a string or an integer")
+
+
+class UserSchema(Schema):
+    username = fields.Str(required=True)
+    password = fields.Str(required=True)
+
+
+class OrganizationSchema(Schema):
+    name = fields.Str(required=True)
+    address1 = fields.Str(missing="")
+    address2 = fields.Str(missing="")
+    zipcode = StrOrInt(missing="")
+    country = fields.Str(missing="")
+    domain = fields.Str(missing="")
+    public_key = fields.Str(missing="")
+    users = fields.List(fields.Nested(UserSchema), missing=[])
+
+
+class ParticipantSchema(Schema):
+    name = fields.Str(required=True)
+
+
+class CollaborationSchema(Schema):
+    name = fields.Str(required=True)
+    participants = fields.List(fields.Nested(ParticipantSchema), required=True)
+    encrypted = fields.Bool(missing=False)
+
+
+class ImportDataSchema(Schema):
+    organizations = fields.List(fields.Nested(OrganizationSchema), missing=[])
+    collaborations = fields.List(fields.Nested(CollaborationSchema), missing=[])
+
+    @post_load
+    def validate_participants_exist(self, data, **kwargs):
+        """Validate that all participants exist in organizations"""
+        org_names = {org["name"] for org in data.get("organizations", [])}
+
+        for collaboration in data.get("collaborations", []):
+            for participant in collaboration.get("participants", []):
+                if participant["name"] not in org_names:
+                    raise ValidationError(
+                        f"Participant {participant['name']} not found in organizations",
+                        field_name="collaborations",
+                    )
+        return data
+
+
+def _check_import_file(import_data: dict) -> dict:
+    """
+    Validate import file using Marshmallow schemas.
+    Returns the validated and cleaned data.
+    """
+    schema = ImportDataSchema()
+    try:
+        return schema.load(import_data)
+    except ValidationError as err:
+        # Handle validation errors gracefully
+        error(f"Validation error: {err.messages}")
+        exit(1)

vantage6/cli/server/list.py

@@ -2,7 +2,7 @@ import click
 
 from vantage6.common.globals import InstanceType
 
-from vantage6.cli.common.utils import get_server_configuration_list
+from vantage6.cli.common.list import get_configuration_list
 
 
 @click.command()
@@ -10,4 +10,4 @@ def cli_server_configuration_list() -> None:
     """
     Print the available server configurations.
     """
-    get_server_configuration_list(InstanceType.SERVER)
+    get_configuration_list(InstanceType.SERVER)

vantage6/cli/server/start.py

@@ -3,6 +3,7 @@ import click
 from vantage6.common import info
 from vantage6.common.globals import InstanceType, Ports
 
+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.server import ServerContext
-from vantage6.cli.globals import ChartName
+from vantage6.cli.globals import ChartName, InfraComponentName
 
 
 @click.command()
@@ -95,4 +95,12 @@ def cli_server_start(
     )
 
     if attach:
-        attach_logs("app=vantage6-server", "component=vantage6-server")
+        attach_logs(
+            name,
+            instance_type=InstanceType.SERVER,
+            infra_component=InfraComponentName.SERVER,
+            system_folders=system_folders,
+            context=context,
+            namespace=namespace,
+            is_sandbox=ctx.is_sandbox,
+        )

vantage6/cli/server/version.py

@@ -1,12 +1,11 @@
 import click
-import docker
+import requests
 
-from vantage6.common import error
-from vantage6.common.docker.addons import check_docker_running
+from vantage6.common import error, info
 from vantage6.common.globals import InstanceType
 
 from vantage6.cli import __version__
-from vantage6.cli.common.utils import get_running_servers, get_server_name
+from vantage6.cli.common.version import get_and_select_ctx
 from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
 
 
@@ -16,22 +15,36 @@ from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
 @click.option(
     "--user", "system_folders", flag_value=False, default=DEFAULT_SERVER_SYSTEM_FOLDERS
 )
-def cli_server_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_server_version(
+    name: str, system_folders: bool, context: str, namespace: str, is_sandbox: bool
+) -> None:
     """
     Print the version of the vantage6 server.
     """
-    check_docker_running()
-    client = docker.from_env()
-
-    running_server_names = get_running_servers(client, InstanceType.SERVER)
-
-    name = get_server_name(
-        name, system_folders, running_server_names, InstanceType.SERVER
+    ctx = get_and_select_ctx(
+        InstanceType.SERVER, name, system_folders, context, namespace, is_sandbox
     )
+    server_config = ctx.config.get("server", {})
+    base_url = server_config.get("baseUrl", "")
+    api_path = server_config.get("apiPath", "")
+    if not base_url:
+        error("No base URL found in server configuration.")
+        return
+    if not api_path:
+        error("No API path found in server configuration.")
+        return
+
+    response = requests.get(f"{base_url}{api_path}/version")
+    if response.status_code != 200:
+        error("Failed to get server version.")
+        return
+    server_version = response.json().get("version", "")
 
-    if name in running_server_names:
-        container = client.containers.get(name)
-        version = container.exec_run(cmd="vserver-local version", stdout=True)
-        click.echo({"server": version.output.decode("utf-8"), "cli": __version__})
-    else:
-        error(f"Server {name} is not running! Cannot provide version...")
+    info("")
+    info(f"Server version: {server_version}")
+    info(f"CLI version: {__version__}")