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

vantage6/cli/dev/common.py

@@ -0,0 +1,34 @@
+import shutil
+import subprocess
+import sys
+
+from vantage6.common import error
+
+
+def check_devspace_installed() -> None:
+    """Check if devspace is installed. Exits if not."""
+    # Check if devspace command exists
+    if shutil.which("devspace") is None:
+        _message_devspace_not_installed()
+
+    try:
+        # Try to run devspace --version to verify it's working
+        result = subprocess.run(
+            ["devspace", "--version"], capture_output=True, text=True, timeout=10
+        )
+        if result.returncode != 0:
+            _message_devspace_not_installed()
+    except (
+        subprocess.TimeoutExpired,
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+    ):
+        _message_devspace_not_installed()
+
+
+def _message_devspace_not_installed() -> None:
+    error(
+        "❌ DevSpace command not found. Please ensure devspace is installed and in "
+        "your PATH."
+    )
+    sys.exit(1)

vantage6/cli/dev/rebuild.py

@@ -0,0 +1,39 @@
+import subprocess
+import sys
+
+import click
+
+from vantage6.common import error, info
+
+from vantage6.cli.dev.common import check_devspace_installed
+
+
+@click.command()
+@click.option("--only-server", is_flag=True, help="Rebuild the server image.")
+@click.option("--only-node", is_flag=True, help="Rebuild the node image.")
+@click.option("--only-store", is_flag=True, help="Rebuild the store image.")
+@click.option("--only-ui", is_flag=True, help="Rebuild the ui image.")
+def cli_rebuild_dev_env(
+    only_server: bool, only_node: bool, only_store: bool, only_ui: bool
+):
+    """Rebuild Docker images for your development environment."""
+    check_devspace_installed()
+
+    try:
+        info("🔄 Rebuilding development environment with devspace...")
+        cmd = ["devspace", "run", "rebuild"]
+
+        if only_server:
+            cmd.append("--server")
+        if only_node:
+            cmd.append("--node")
+        if only_store:
+            cmd.append("--store")
+        if only_ui:
+            cmd.append("--ui")
+
+        subprocess.run(cmd, check=True, capture_output=False)
+        info("✅ Development environment rebuilt successfully!")
+    except subprocess.CalledProcessError as e:
+        error(f"❌ Error rebuilding development environment: {e}")
+        sys.exit(e.returncode)

vantage6/cli/dev/start.py

@@ -0,0 +1,36 @@
+import subprocess
+import sys
+
+import click
+
+from vantage6.common import error, info
+
+from vantage6.cli.dev.common import check_devspace_installed
+
+
+@click.command()
+def cli_start_dev_env():
+    """Start the development environment using devspace."""
+    check_devspace_installed()
+
+    try:
+        info("🚀 Starting development environment with devspace...")
+
+        # Build the devspace command
+        cmd = ["devspace", "run", "start-dev"]
+
+        # Run the devspace command
+        result = subprocess.run(cmd, check=True, capture_output=False)
+
+        if result.returncode == 0:
+            info("✅ Development environment started successfully!")
+        else:
+            error("❌ Failed to start development environment.")
+            sys.exit(result.returncode)
+
+    except subprocess.CalledProcessError as e:
+        error(f"❌ Error running devspace: {e}")
+        sys.exit(e.returncode)
+    except Exception as e:
+        error(f"❌ Unexpected error: {e}")
+        sys.exit(1)

vantage6/cli/dev/stop.py

@@ -0,0 +1,23 @@
+import subprocess
+import sys
+
+import click
+
+from vantage6.common import error, info
+
+from vantage6.cli.dev.common import check_devspace_installed
+
+
+@click.command()
+def cli_stop_dev_env():
+    """Stop the development environment."""
+    check_devspace_installed()
+
+    try:
+        info("🛑 Stopping development environment with devspace...")
+        cmd = ["devspace", "run", "stop-dev"]
+        subprocess.run(cmd, check=True, capture_output=False)
+        info("✅ Development environment stopped successfully!")
+    except subprocess.CalledProcessError as e:
+        error(f"❌ Error stopping development environment: {e}")
+        sys.exit(e.returncode)

vantage6/cli/globals.py

@@ -56,11 +56,12 @@ DEFAULT_PROMETHEUS_IMAGE = "prom/prometheus"
 PROMETHEUS_CONFIG = "prometheus.yml"
 PROMETHEUS_DIR = "prometheus"
 
-# template folder
+# template configuration files
 TEMPLATE_FOLDER = PACKAGE_FOLDER / APPNAME / "cli" / "template"
 SERVER_TEMPLATE_FILE = "server_config.j2"
 NODE_TEMPLATE_FILE = "node_config.j2"
 ALGO_STORE_TEMPLATE_FILE = "algo_store_config.j2"
+AUTH_TEMPLATE_FILE = "auth_config.j2"
 
 
 # datasets included in the nodes of the dev network
@@ -85,3 +86,25 @@ class ChartName(StrEnumBase):
     ALGORITHM_STORE = "store"
     NODE = "node"
     AUTH = "auth"
+
+
+class CLICommandName(StrEnumBase):
+    """Enum containing CLI command names"""
+
+    SERVER = "server"
+    ALGORITHM_STORE = "algorithm-store"
+    NODE = "node"
+    ALGORITHM = "algorithm"
+    TEST = "test"
+    DEV = "dev"
+    USE = "use"
+    AUTH = "auth"
+
+
+class InfraComponentName(StrEnumBase):
+    """Enum containing infrastructure components"""
+
+    SERVER = "server"
+    ALGORITHM_STORE = "store"
+    NODE = "node"
+    AUTH = "auth"

vantage6/cli/node/attach.py

@@ -1,6 +1,7 @@
 import click
 
 from vantage6.common import info
+
 from vantage6.cli.common.utils import attach_logs
 
 

vantage6/cli/node/files.py

@@ -1,42 +1,29 @@
 import click
 
 from vantage6.common import info
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.decorator import click_insert_context
 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()
-@click.option("-n", "--name", default=None, help="Configuration name")
-@click.option(
-    "--system",
-    "system_folders",
-    flag_value=True,
-    help="Search for the configuration in the system folders",
-)
-@click.option(
-    "--user",
-    "system_folders",
-    flag_value=False,
-    default=N_FOL,
-    help="Search for the configuration in the user folders. This is " "the default",
-)
-def cli_node_files(name: str, system_folders: bool) -> None:
+@click_insert_context(type_=InstanceType.NODE)
+def cli_node_files(ctx: NodeContext) -> None:
     """
     Prints the location of important node files.
 
     If the specified configuration cannot be found, it exits. Otherwise
     it returns the absolute path to the output.
     """
-    name = select_node(name, system_folders)
-
-    # create node context
-    ctx = NodeContext(name, system_folders=system_folders)
-
-    # return path of the configuration
     info(f"Configuration file = {ctx.config_file}")
     info(f"Log file           = {ctx.log_file}")
     info(f"data folders       = {ctx.data_dir}")
     info("Database labels and files")
-    for db in ctx.databases:
-        info(f" - {db['label']:15} = {db['uri']} (type: {db['type']})")
+    for db in ctx.databases["fileBased"] or []:
+        info(
+            f" - {db['name']:15} = {db['volumePath']}/{db['originalName']} "
+            f"(type: {db['type']})"
+        )
+    for db in ctx.databases["serviceBased"] or []:
+        info(f" - {db['name']:15} = {db['uri']} (type: {db['type']})")

vantage6/cli/node/list.py

@@ -3,8 +3,9 @@ import docker
 from colorama import Fore, Style
 
 from vantage6.common import warning
-from vantage6.common.globals import APPNAME
 from vantage6.common.docker.addons import check_docker_running
+from vantage6.common.globals import APPNAME
+
 from vantage6.cli.context.node import NodeContext
 from vantage6.cli.node.common import find_running_node_names
 
@@ -39,7 +40,7 @@ def cli_node_list() -> None:
             if f"{APPNAME}-{config.name}-system" in running_node_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 = NodeContext.available_configurations(system_folders=False)
@@ -49,8 +50,8 @@ def cli_node_list() -> None:
             if f"{APPNAME}-{config.name}-user" in running_node_names
             else stopped
         )
-        click.echo(f"{config.name:25}" f"{status:25}User   ")
+        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}")
+        warning(f"{Fore.RED}Failed imports: {len(f1) + len(f2)}{Style.RESET_ALL}")

vantage6/cli/node/new.py

@@ -1,13 +1,22 @@
+import os
+from pathlib import Path
+
 import click
-from colorama import Fore, Style
+import questionary as q
 
-from vantage6.common import ensure_config_dir_writable, error, info
-from vantage6.common.globals import InstanceType
+from vantage6.common import error, info, warning
+from vantage6.common.client.node_client import NodeClient
+from vantage6.common.globals import (
+    FILE_BASED_DATABASE_TYPES,
+    SERVICE_BASED_DATABASE_TYPES,
+    InstanceType,
+    NodePolicy,
+    Ports,
+    RequiredNodeEnvVars,
+)
 
-from vantage6.cli.configuration_wizard import configuration_wizard
-from vantage6.cli.context.node import NodeContext
+from vantage6.cli.common.new import new
 from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
-from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
 
 
 @click.command()
@@ -23,38 +32,349 @@ from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
     "system_folders",
     flag_value=False,
     default=N_FOL,
-    help="Store this configuration in the user folders. This is the " "default",
+    help="Store this configuration in the user folders. This is the default.",
+)
+@click.option("--context", default=None, help="Kubernetes context to use")
+@click.option(
+    "--namespace",
+    default=None,
+    help="Kubernetes namespace to use",
 )
-def cli_node_new_configuration(name: str, system_folders: bool) -> None:
+def cli_node_new_configuration(
+    name: str,
+    system_folders: bool,
+    namespace: str,
+    context: str,
+) -> None:
     """
     Create a new node configuration.
 
     Checks if the configuration already exists. If this is not the case
     a questionnaire is invoked to create a new configuration file.
     """
-    name = prompt_config_name(name)
-    # check if config name is allowed docker name
-    check_config_name_allowed(name)
+    new(
+        questionnaire_function=node_configuration_questionaire,
+        name=name,
+        system_folders=system_folders,
+        namespace=namespace,
+        context=context,
+        type_=InstanceType.NODE,
+    )
+
+
+def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
+    """
+    Questionary to generate a config file for the node instance.
+
+    Parameters
+    ----------
+    dirs : dict
+        Dictionary with the directories of the node instance.
+    instance_name : str
+        Name of the node instance.
+
+    Returns
+    -------
+    dict
+        Dictionary with the new node configuration
+    """
+    config = q.unsafe_prompt(
+        [
+            {"type": "text", "name": "api_key", "message": "Enter given api-key:"},
+            {
+                "type": "text",
+                "name": "server_url",
+                "message": "The base-URL of the server:",
+                "default": "http://localhost",
+            },
+        ]
+    )
+    # remove trailing slash from server_url if entered by user
+    config["server_url"] = config["server_url"].rstrip("/")
+
+    # set default port to the https port if server_url is https
+    default_port = (
+        str(Ports.HTTPS)
+        if config["server_url"].startswith("https")
+        else str(Ports.DEV_SERVER)
+    )
+
+    config = config | q.unsafe_prompt(
+        [
+            {
+                "type": "text",
+                "name": "port",
+                "message": "Enter port to which the server listens:",
+                "default": default_port,
+            },
+            {
+                "type": "text",
+                "name": "api_path",
+                "message": "Path of the api:",
+                "default": "/api",
+            },
+            {
+                "type": "text",
+                "name": "task_dir",
+                "message": "Task directory path:",
+                "default": str(dirs["data"]),
+            },
+        ]
+    )
+
+    config["databases"] = {"fileBased": [], "serviceBased": []}
+    while q.confirm("Do you want to add a database?").unsafe_ask():
+        db_label = q.select(
+            "What type of database do you want to add?",
+            choices=["File database", "Database reachable by URI"],
+        ).unsafe_ask()
+
+        if db_label == "File database":
+            config["databases"]["fileBased"].append(_get_file_based_database_config())
+        else:
+            config["databases"]["serviceBased"].append(
+                _get_service_based_database_config()
+            )
+
+    is_policies = q.confirm(
+        "Do you want to limit the algorithms allowed to run on your node? This "
+        "should always be done for production scenarios.",
+        default=True,
+    ).unsafe_ask()
+    policies = {}
+    if is_policies:
+        info(
+            "You can limit the algorithms that can run on your node in two ways: by "
+            "allowing specific algorithms or by allowing all algorithms in a given "
+            "algorithm store."
+        )
+        ask_single_algorithms = q.confirm(
+            "Do you want to enter a list of allowed algorithms?"
+        ).unsafe_ask()
+        if ask_single_algorithms:
+            policies[NodePolicy.ALLOWED_ALGORITHMS.value] = _get_allowed_algorithms()
+        ask_algorithm_stores = q.confirm(
+            "Do you want to allow algorithms from specific algorithm stores?"
+        ).unsafe_ask()
+        if ask_algorithm_stores:
+            policies[NodePolicy.ALLOWED_ALGORITHM_STORES.value] = (
+                _get_allowed_algorithm_stores()
+            )
+        if ask_single_algorithms and ask_algorithm_stores:
+            require_both_whitelists = q.confirm(
+                "Do you want to allow only algorithms that are both in the list of "
+                "allowed algorithms *AND* are part of one of the allowed algorithm "
+                "stores? If not, algorithms will be allowed if they are in either the "
+                "list of allowed algorithms or one of the allowed algorithm stores.",
+                default=True,
+            ).unsafe_ask()
+            policies["allow_either_whitelist_or_store"] = not require_both_whitelists
+    if policies:
+        config["policies"] = policies
 
-    # check that this config does not exist
-    if NodeContext.config_exists(name, system_folders):
-        error(f"Configuration {name} already exists!")
-        exit(1)
+    res = q.select(
+        "Which level of logging would you like?",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NOTSET"],
+    ).unsafe_ask()
 
-    # Check that we can write in this folder
-    if not ensure_config_dir_writable(system_folders):
-        error("Cannot write configuration file. Exiting...")
-        exit(1)
+    config["logging"] = {
+        "level": res,
+        "use_console": True,
+        "backup_count": 5,
+        "max_size": 1024,
+        "format": "%(asctime)s - %(name)-14s - %(levelname)-8s - %(message)s",
+        "datefmt": "%Y-%m-%d %H:%M:%S",
+        "loggers": [
+            {"name": "urllib3", "level": "warning"},
+            {"name": "requests", "level": "warning"},
+            {"name": "engineio.client", "level": "warning"},
+            {"name": "docker.utils.config", "level": "warning"},
+            {"name": "docker.auth", "level": "warning"},
+        ],
+    }
 
-    # create config in ctx location
-    flag = "--system" if system_folders else ""
+    # Check if we can login to the server to retrieve collaboration settings
+    client = NodeClient(
+        instance_name,
+        config["api_key"],
+        server_url=f"{config['server_url']}:{config['port']}{config['api_path']}",
+        auth_url=os.environ.get(RequiredNodeEnvVars.KEYCLOAK_URL.value),
+    )
     try:
-        cfg_file = configuration_wizard(InstanceType.NODE, name, system_folders)
-    except KeyboardInterrupt:
-        error("Configuration creation aborted.")
-        exit(1)
-    info(f"New configuration created: {Fore.GREEN}{cfg_file}{Style.RESET_ALL}")
+        client.authenticate()
+    except Exception as e:
+        error(f"Could not authenticate with server: {e}")
+        error("Please check (1) your API key and (2) if your server is online")
+        warning(
+            "If you continue, you should provide your collaboration settings manually."
+        )
+        if q.confirm("Do you want to abort?", default=True).unsafe_ask():
+            exit(0)
+
+    if client.whoami is not None:
+        encryption = client.is_encrypted_collaboration()
+        # TODO when we build collaboration policies, update this to provide
+        # the node admin with a list of all policies, and whether or not
+        # to accept them
+        q.confirm(
+            f"Encryption is {'enabled' if encryption else 'disabled'}"
+            f" for this collaboration. Accept?",
+            default=True,
+        ).unsafe_ask()
+    else:
+        encryption = q.confirm("Enable encryption?", default=True).unsafe_ask()
+
+    private_key = (
+        "" if not encryption else q.text("Path to private key file:").unsafe_ask()
+    )
+
+    config["encryption"] = {
+        "enabled": encryption is True or encryption == "true",
+        "private_key": private_key,
+    }
+
+    # pack the entire config in a dict with the 'node' key at top level
+    return {"node": config}
+
+
+def _get_file_based_database_config() -> dict:
+    """
+    Prompt the user for the file-based database configuration
+    """
+    db_label = _get_database_label()
+    while True:
+        db_path = q.text(
+            "Path to the database file:",
+        ).unsafe_ask()
+        if Path(db_path).exists():
+            break
+        else:
+            error("The path to the database file does not exist. Please try again.")
+    db_path_resolved = Path(db_path).resolve()
+    db_dir = db_path_resolved.parent
+    db_filename = db_path_resolved.name
+    db_type = q.select("Database type:", choices=FILE_BASED_DATABASE_TYPES).unsafe_ask()
+    return {
+        "name": db_label,
+        "uri": db_path,
+        "type": db_type,
+        "volumePath": db_dir,
+        "originalName": db_filename,
+    }
+
+
+def _get_service_based_database_config() -> dict:
+    """
+    Prompt the user for the service-based database configuration
+
+    Returns
+    -------
+    dict
+        Dictionary with the service-based database configuration
+    """
+    db_label = _get_database_label()
+    db_uri = q.text(
+        "Database URI:",
+    ).unsafe_ask()
+    db_type = q.select(
+        "Database type:", choices=SERVICE_BASED_DATABASE_TYPES
+    ).unsafe_ask()
+
+    env_vars = {}
+    info("You can add environment variables to the database configuration.")
+    info("These variables will be available to the algorithms on your node.")
+    info("Example: MY_POSTGRES_USER=vantage6, MY_POSTGRES_PASSWORD=vantage6")
+    while q.confirm("Do you want to add an environment variable?").unsafe_ask():
+        env_var_name = q.text(
+            "Enter the name of the environment variable:"
+        ).unsafe_ask()
+        env_var_value = q.text(
+            "Enter the value of the environment variable:"
+        ).unsafe_ask()
+        env_vars[env_var_name] = env_var_value
+
+    return {
+        "name": db_label,
+        "uri": db_uri,
+        "type": db_type,
+        "env": env_vars,
+    }
+
+
+def _get_database_label() -> str:
+    """
+    Prompt the user for the label of the database
+    """
+    return q.text(
+        "Enter unique label for the database:",
+        default="default",
+    ).unsafe_ask()
+
+
+def _get_allowed_algorithms() -> list[str]:
+    """
+    Prompt the user for the allowed algorithms on their node
+
+    Returns
+    -------
+    list[str]
+        List of allowed algorithms or regular expressions to match them
+    """
+    info("Below you can add algorithms that are allowed to run on your node.")
+    info(
+        "You can use regular expressions to match multiple algorithms, or you can "
+        "use strings to provide one algorithm at a time."
+    )
+    info("Examples:")
+    info(r"^harbor2\.vantage6\.ai/demo/average$    Allow the demo average algorithm")
+    info(
+        r"^harbor2\.vantage6\.ai/algorithms/.*   Allow all algorithms from "
+        "harbor2.vantage6.ai/algorithms"
+    )
+    info(
+        r"^harbor2\.vantage6\.ai/demo/average@sha256:82becede...$    Allow a "
+        "specific hash of average algorithm"
+    )
+    allowed_algorithms = []
+    while True:
+        algo = q.text(message="Enter your algorithm expression:").unsafe_ask()
+        allowed_algorithms.append(algo)
+        if not q.confirm(
+            "Do you want to add another algorithm expression?", default=True
+        ).unsafe_ask():
+            break
+    return allowed_algorithms
+
+
+def _get_allowed_algorithm_stores() -> list[str]:
+    """
+    Prompt the user for the allowed algorithm stores on their node
+
+    Returns
+    -------
+    list[str]
+        List of allowed algorithm stores
+    """
+    info("Below you can add algorithm stores that are allowed to run on your node.")
+    info(
+        "You can use regular expressions to match multiple algorithm stores, or you can"
+        " use strings to provide one algorithm store at a time."
+    )
+    info("Examples:")
+    info(
+        "https://store.cotopaxi.vantage6.ai    Allow all algorithms from the "
+        "community store"
+    )
     info(
-        f"You can start the node by running "
-        f"{Fore.GREEN}v6 node start {flag}{Style.RESET_ALL}"
+        r"^https://*\.vantage6\.ai$               Allow all algorithms from any "
+        "store hosted on vantage6.ai"
     )
+    allowed_algorithm_stores = []
+    while True:
+        store = q.text(message="Enter the URL of the algorithm store:").unsafe_ask()
+        allowed_algorithm_stores.append(store)
+        if not q.confirm(
+            "Do you want to add another algorithm store?", default=True
+        ).unsafe_ask():
+            break
+    return allowed_algorithm_stores