vantage6 5.0.0a37__py3-none-any.whl → 5.0.0a40__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/configuration_create.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from pathlib import Path
 
 import questionary as q
@@ -127,7 +128,7 @@ def _add_production_server_config(config: dict) -> dict:
 
 
 def make_configuration(
-    config_producing_func: callable,
+    config_producing_func: Callable,
     config_producing_func_args: tuple,
     type_: InstanceType,
     instance_name: str,
@@ -139,7 +140,7 @@ def make_configuration(
 
     Parameters
     ----------
-    config_producing_func : callable
+    config_producing_func : Callable
         Function to generate the configuration
     config_producing_func_args : tuple
         Arguments to pass to the config producing function

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/common/__init__.py

@@ -12,6 +12,7 @@ from vantage6.common.globals import (
     APPNAME,
     HTTP_LOCALHOST,
     InstanceType,
+    Ports,
     RequiredNodeEnvVars,
 )
 
@@ -21,6 +22,16 @@ from vantage6.cli.configuration_create import select_configuration_questionnaire
 from vantage6.cli.context.node import NodeContext
 
 
+def _convert_k8s_url_to_localhost(url: str) -> str:
+    """
+    Convert a Kubernetes URL to a localhost URL.
+    """
+    if "svc.cluster.local" in url:
+        port_and_api_path = url.split(":")[-1]
+        return f"{HTTP_LOCALHOST}:{port_and_api_path}"
+    return url
+
+
 def create_client(ctx: NodeContext) -> UserClient:
     """
     Create a client instance.
@@ -34,17 +45,31 @@ def create_client(ctx: NodeContext) -> UserClient:
     UserClient
         vantage6 client
     """
-    host = ctx.config["server_url"]
+    host = ctx.config["node"]["server"]["url"]
+    port = ctx.config["node"]["server"]["port"]
+    api_path = ctx.config["node"]["server"]["path"]
     # if the server is run locally, we need to use localhost here instead of
     # the host address of docker
     if host in ["http://host.docker.internal", "http://172.17.0.1"]:
         host = HTTP_LOCALHOST
-    port = ctx.config["port"]
-    api_path = ctx.config["api_path"]
-    info(f"Connecting to server at '{host}:{port}{api_path}'")
+
+    url = f"{host}:{port}{api_path}"
+
+    auth_url = ctx.config.get("node", {}).get("keycloakUrl", None) or os.environ.get(
+        RequiredNodeEnvVars.KEYCLOAK_URL.value
+    )
+    # append the port to the auth URL as it is not included in the config
+    auth_url = f"{auth_url}:{Ports.DEV_AUTH.value}"
+
+    # if the server is a Kubernetes address, we need to use localhost because here
+    # we are connecting from the CLI outside the cluster
+    url = _convert_k8s_url_to_localhost(url)
+    auth_url = _convert_k8s_url_to_localhost(auth_url)
+
+    info(f"Connecting to server at '{url}' using auth URL '{auth_url}'")
     return UserClient(
-        server_url=f"{host}:{port}{api_path}",
-        auth_url=os.environ.get(RequiredNodeEnvVars.KEYCLOAK_URL.value),
+        server_url=url,
+        auth_url=auth_url,
         log_level="warn",
     )
 

vantage6/cli/node/create_private_key.py

@@ -11,10 +11,12 @@ from vantage6.common import (
     warning,
 )
 from vantage6.common.encryption import RSACryptor
+from vantage6.common.globals import InstanceType
 
+from vantage6.cli.configuration_create import select_configuration_questionnaire
 from vantage6.cli.context.node import NodeContext
 from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
-from vantage6.cli.node.common import create_client_and_authenticate, select_node
+from vantage6.cli.node.common import create_client_and_authenticate
 
 
 @click.command()
@@ -80,12 +82,13 @@ def cli_node_create_private_key(
     if config:
         name = Path(config).stem
         ctx = NodeContext(name, system_folders, config)
-    else:
-        # retrieve context
-        name = select_node(name, system_folders)
-
-        # Create node context
-        ctx = NodeContext(name, system_folders)
+    elif not name:
+        try:
+            name = select_configuration_questionnaire(InstanceType.NODE, system_folders)
+        except Exception:
+            error("No configurations could be found!")
+            exit(1)
+    ctx = NodeContext(name, system_folders)
 
     # Authenticate with the server to obtain organization name if it wasn't
     # provided
@@ -138,9 +141,7 @@ def cli_node_create_private_key(
 
     # update config file
     info("Updating configuration")
-    # TODO v5+ this probably messes up the current config as the template is used...
-    # Fix when reimplementing this in v5
-    ctx.config["encryption"]["private_key"] = str(file_)
+    ctx.config["node"]["encryption"]["private_key"] = str(file_)
     ctx.config_manager.put(ctx.config)
     ctx.config_manager.save(ctx.config_file)
 

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/set_api_key.py

@@ -2,11 +2,14 @@ import click
 import questionary as q
 
 from vantage6.common import ensure_config_dir_writable, error, info
+from vantage6.common.globals import InstanceType
 
-from vantage6.cli.configuration_create import NodeConfigurationManager
+from vantage6.cli.configuration_create import (
+    NodeConfigurationManager,
+    select_configuration_questionnaire,
+)
 from vantage6.cli.context.node import NodeContext
 from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
-from vantage6.cli.node.common import select_node
 
 
 @click.command()
@@ -31,7 +34,12 @@ def cli_node_set_api_key(name: str, api_key: str, system_folders: bool) -> None:
     Put a new API key into the node configuration file
     """
     # select node name
-    name = select_node(name, system_folders)
+    if not name:
+        try:
+            name = select_configuration_questionnaire(InstanceType.NODE, system_folders)
+        except Exception:
+            error("No configurations could be found!")
+            exit(1)
 
     # Check that we can write in the config folder
     if not ensure_config_dir_writable(system_folders):
@@ -50,9 +58,7 @@ def cli_node_set_api_key(name: str, api_key: str, system_folders: bool) -> None:
     conf_mgr = NodeConfigurationManager.from_file(ctx.config_file)
 
     # set new api key, and save the file
-    ctx.config["api_key"] = api_key
-    # TODO v5+ this probably messes up the current config as the template is used...
-    # Fix when reimplementing this in v5
+    ctx.config["node"]["apiKey"] = api_key
     conf_mgr.put(ctx.config)
     conf_mgr.save(ctx.config_file)
     info(f"Your new API key has been uploaded to the config file {ctx.config_file}.")

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)