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

vantage6/cli/common/decorator.py

@@ -4,9 +4,9 @@ from pathlib import Path
 import click
 
 from vantage6.common import error
-from vantage6.common.globals import InstanceType
+from vantage6.common.globals import SANDBOX_SUFFIX, InstanceType
 
-from vantage6.cli.configuration_wizard import select_configuration_questionaire
+from vantage6.cli.configuration_create import select_configuration_questionnaire
 from vantage6.cli.context import get_context, select_context_class
 
 
@@ -14,6 +14,8 @@ def click_insert_context(
     type_: InstanceType,
     include_name: bool = False,
     include_system_folders: bool = False,
+    is_sandbox: bool = False,
+    sandbox_param: str | None = None,
 ) -> callable:
     """
     Supply the Click function with an additional context parameter. The context
@@ -27,6 +29,12 @@ def click_insert_context(
         Include the name of the configuration as an argument
     include_system_folders : bool
         Include whether or not to use the system folders as an argument
+    is_sandbox : bool
+        Include whether or not to use the sandbox configurations as an argument
+    sandbox_param : str | None
+        Name of a Click option/parameter in the command function whose boolean
+        value should determine sandbox mode at runtime. If provided, this value
+        overrides the static is_sandbox parameter.
 
     Returns
     -------
@@ -58,7 +66,7 @@ def click_insert_context(
             "--user",
             "system_folders",
             flag_value=False,
-            default=False if type_ == InstanceType.NODE else True,
+            default=False if type_ == InstanceType.NODE or is_sandbox else True,
             help="Use user folders instead of system folders",
         )
         @wraps(func)
@@ -74,6 +82,15 @@ def click_insert_context(
                 Decorated function
             """
             ctx_class = select_context_class(type_)
+
+            # Determine sandbox mode, preferring runtime option when provided
+            runtime_is_sandbox = is_sandbox
+            if sandbox_param is not None:
+                # Pop to avoid passing unknown kwarg to the wrapped function
+                runtime_is_sandbox = bool(kwargs.pop(sandbox_param, False))
+            if runtime_is_sandbox and name and name.endswith(SANDBOX_SUFFIX):
+                name = name[: -len(SANDBOX_SUFFIX)]
+
             # path to configuration file always overrides name
             if config:
                 ctx = ctx_class.from_external_config_file(config, system_folders)
@@ -87,12 +104,14 @@ def click_insert_context(
                 if not name:
                     try:
                         # select configuration if none supplied
-                        name = select_configuration_questionaire(type_, system_folders)
+                        name = select_configuration_questionnaire(
+                            type_, system_folders, runtime_is_sandbox
+                        )
                     except Exception:
                         error("No configurations could be found!")
                         exit(1)
 
-                ctx = get_context(type_, name, system_folders)
+                ctx = get_context(type_, name, system_folders, runtime_is_sandbox)
             extra_args = []
             if include_name:
                 if not name:

vantage6/cli/common/new.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 from colorama import Fore, Style
 
 from vantage6.common import ensure_config_dir_writable, error, info
@@ -5,26 +7,30 @@ from vantage6.common.globals import InstanceType
 
 from vantage6.cli.common.utils import get_main_cli_command_name
 from vantage6.cli.config import CliConfig
-from vantage6.cli.configuration_wizard import configuration_wizard
+from vantage6.cli.configuration_create import make_configuration
 from vantage6.cli.context import select_context_class
 from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
 
 
 def new(
-    questionnaire_function: callable,
+    config_producing_func: callable,
+    config_producing_func_args: tuple,
     name: str,
     system_folders: bool,
     namespace: str,
     context: str,
     type_: InstanceType,
-) -> None:
+    is_sandbox: bool = False,
+) -> Path | None:
     """
     Create a new configuration.
 
     Parameters
     ----------
-    questionnaire_function : callable
+    config_producing_func : callable
         Function to generate the configuration
+    config_producing_func_args : tuple
+        Arguments to pass to the config producing function
     name : str
         Name of the configuration
     system_folders : bool
@@ -35,6 +41,13 @@ def new(
         Context to use
     type_ : InstanceType
         Type of the configuration (node, server, algorithm store, etc)
+    is_sandbox : bool
+        Whether to create a sandbox configuration or not
+
+    Returns
+    -------
+    Path | None
+        Path to the configuration file. None if the process is aborted for any reason.
     """
     cli_config = CliConfig()
     context, namespace = cli_config.compare_changes_config(
@@ -50,11 +63,12 @@ def new(
     # check that this config does not exist
     ctx_class = select_context_class(type_)
     try:
-        if ctx_class.config_exists(name, system_folders):
+        if ctx_class.config_exists(name, system_folders, is_sandbox):
             error(f"Configuration {Fore.RED}{name}{Style.RESET_ALL} already exists!")
             exit(1)
     except Exception as e:
         error(e)
+
         exit(1)
 
     command_name = get_main_cli_command_name(type_)
@@ -70,8 +84,13 @@ def new(
 
     # create config in ctx location
     try:
-        cfg_file = configuration_wizard(
-            questionnaire_function, type_, name, system_folders
+        cfg_file = make_configuration(
+            config_producing_func=config_producing_func,
+            config_producing_func_args=config_producing_func_args,
+            type_=type_,
+            instance_name=name,
+            system_folders=system_folders,
+            is_sandbox=is_sandbox,
         )
     except KeyboardInterrupt:
         error("Configuration creation aborted.")
@@ -83,3 +102,4 @@ def new(
         f"You can start the {command_name} by running {Fore.GREEN}v6 {command_name} "
         f"start {flag}{Style.RESET_ALL}"
     )
+    return cfg_file

vantage6/cli/common/start.py

@@ -19,13 +19,11 @@ from vantage6.common.globals import (
     DEFAULT_NODE_IMAGE,
     DEFAULT_SERVER_IMAGE,
     DEFAULT_UI_IMAGE,
+    LOCALHOST,
     InstanceType,
 )
 
-from vantage6.cli.common.utils import (
-    check_running,
-    select_context_and_namespace,
-)
+from vantage6.cli.common.utils import check_running
 from vantage6.cli.globals import ChartName
 from vantage6.cli.utils import check_config_name_allowed, validate_input_cmd_args
 
@@ -35,8 +33,6 @@ def prestart_checks(
     instance_type: InstanceType,
     name: str,
     system_folders: bool,
-    context: str,
-    namespace: str,
 ) -> None:
     """
     Run pre-start checks for an instance.
@@ -48,11 +44,6 @@ def prestart_checks(
         error(f"Instance '{name}' is already running.")
         exit(1)
 
-    context, namespace = select_context_and_namespace(
-        context=context,
-        namespace=namespace,
-    )
-
 
 def pull_infra_image(
     client: DockerClient, image: str, instance_type: InstanceType
@@ -142,6 +133,7 @@ def helm_install(
     values_file: str | PathLike | None = None,
     context: str | None = None,
     namespace: str | None = None,
+    local_chart_dir: str | None = None,
 ) -> None:
     """
     Manage the `helm install` command.
@@ -158,6 +150,8 @@ def helm_install(
         The Kubernetes context to use.
     namespace : str, optional
         The Kubernetes namespace to use.
+    local_chart_dir : str, optional
+        The local directory containing the Helm charts.
     """
     # Input validation
     validate_input_cmd_args(release_name, "release name")
@@ -171,17 +165,28 @@ def helm_install(
     validate_input_cmd_args(context, "context name", allow_none=True)
     validate_input_cmd_args(namespace, "namespace name", allow_none=True)
 
+    if local_chart_dir and local_chart_dir.rstrip("/").endswith(chart_name.value):
+        local_chart_dir = str(Path(local_chart_dir).parent)
+
     # Create the command
-    command = [
-        "helm",
-        "install",
-        release_name,
-        chart_name,
-        "--repo",
-        DEFAULT_CHART_REPO,
-        # TODO v5+ remove this flag when we have a stable release
-        "--devel",  # ensure using latest version including pre-releases
-    ]
+    if local_chart_dir:
+        command = [
+            "helm",
+            "install",
+            release_name,
+            f"{local_chart_dir}/{chart_name.value}",
+        ]
+    else:
+        command = [
+            "helm",
+            "install",
+            release_name,
+            chart_name,
+            "--repo",
+            DEFAULT_CHART_REPO,
+            # TODO v5+ remove this flag when we have a stable release
+            "--devel",
+        ]
 
     if values_file:
         command.extend(["-f", str(values_file)])
@@ -200,7 +205,7 @@ def helm_install(
         )
         info(
             f"Successfully installed release '{release_name}' using chart "
-            f"'{chart_name}'."
+            f"'{chart_name.value}'."
         )
     except subprocess.CalledProcessError:
         error(f"Failed to install release '{release_name}'.")
@@ -217,7 +222,7 @@ def start_port_forward(
     service_name: str,
     service_port: int,
     port: int,
-    ip: str | None,
+    ip: str = LOCALHOST,
     context: str | None = None,
     namespace: str | None = None,
 ) -> None:
@@ -232,8 +237,8 @@ def start_port_forward(
         The port on the service to forward.
     port : int
         The port to listen on.
-    ip : str | None
-        The IP address to listen on. If None, defaults to localhost.
+    ip : str
+        The IP address to listen on. Defaults to localhost.
     context : str | None
         The Kubernetes context to use.
     namespace : str | None
@@ -264,20 +269,22 @@ def start_port_forward(
     timeout = 300  # seconds
     while time.time() - start_time < timeout:
         try:
-            result = (
-                subprocess.check_output(
-                    [
-                        "kubectl",
-                        "get",
-                        "endpoints",
-                        service_name,
-                        "-o",
-                        "jsonpath={.subsets[*].addresses[*].ip}",
-                    ]
-                )
-                .decode()
-                .strip()
-            )
+            command = [
+                "kubectl",
+                "get",
+                "endpoints",
+                service_name,
+                "-o",
+                "jsonpath={.subsets[*].addresses[*].ip}",
+            ]
+
+            if context:
+                command.extend(["--context", context])
+
+            if namespace:
+                command.extend(["--namespace", namespace])
+
+            result = subprocess.check_output(command).decode().strip()
 
             if result:
                 info(f"Service '{service_name}' is ready.")
@@ -288,13 +295,14 @@ def start_port_forward(
         time.sleep(2)
     else:
         error(
-            f"Timeout: Service '{service_name}' has no ready endpoints after {timeout} seconds."
+            f"Timeout: Service '{service_name}' has no ready endpoints after {timeout} "
+            "seconds."
         )
         return
 
     # Create the port forwarding command
     if not ip:
-        ip = "localhost"
+        ip = LOCALHOST
 
     command = [
         "kubectl",

vantage6/cli/common/stop.py

@@ -5,7 +5,7 @@ import subprocess
 from colorama import Fore, Style
 
 from vantage6.common import error, info, warning
-from vantage6.common.globals import InstanceType
+from vantage6.common.globals import SANDBOX_SUFFIX, InstanceType
 
 from vantage6.cli.common.utils import (
     find_running_service_names,
@@ -26,6 +26,8 @@ def execute_stop(
     namespace: str,
     context: str,
     system_folders: bool,
+    is_sandbox: bool = False,
+    stop_function_args: dict | None = None,
 ):
     """
     Execute the stop function for a given instance type and infra component.
@@ -41,19 +43,25 @@ def execute_stop(
     stop_all : bool
         Whether to stop all services.
     to_stop : str | None
-        The name of the service to stop.
+        The name of the service to stop. If None, the user will be asked to select a
+        service.
     namespace : str
         The namespace of the service.
     context : str
         The context of the service.
     system_folders : bool
         Whether to use system folders.
+    is_sandbox : bool
+        Whether the configuration is a sandbox configuration, by default False
+    stop_function_args : dict | None
+        Additional arguments to pass to the stop function
     """
+    if stop_function_args is None:
+        stop_function_args = {}
     context, namespace = select_context_and_namespace(
         context=context,
         namespace=namespace,
     )
-
     running_services = find_running_service_names(
         instance_type=instance_type,
         only_system_folders=system_folders,
@@ -73,11 +81,21 @@ def execute_stop(
         if not to_stop:
             helm_name = select_running_service(running_services, instance_type)
         else:
-            ctx = get_context(instance_type, to_stop, system_folders)
+            if to_stop.endswith(SANDBOX_SUFFIX):
+                to_stop = to_stop[: -len(SANDBOX_SUFFIX)]
+                is_sandbox = True
+            elif is_sandbox:
+                warning(
+                    "Sandbox configuration detected, but no sandbox suffix found. "
+                    "This may lead to issues."
+                )
+            ctx = get_context(
+                instance_type, to_stop, system_folders, is_sandbox=is_sandbox
+            )
             helm_name = ctx.helm_release_name
 
         if helm_name in running_services:
-            stop_function(helm_name, namespace, context)
+            stop_function(helm_name, namespace, context, **stop_function_args)
             info(
                 f"Stopped the {Fore.GREEN}{helm_name}{Style.RESET_ALL} {infra_component.value}."
             )

vantage6/cli/common/utils.py

@@ -66,6 +66,7 @@ def find_running_service_names(
     only_user_folders: bool = False,
     context: str | None = None,
     namespace: str | None = None,
+    sandbox: bool = False,
 ) -> list[str]:
     """
     List running Vantage6 servers.
@@ -82,6 +83,8 @@ def find_running_service_names(
         The Kubernetes context to use.
     namespace : str, optional
         The Kubernetes namespace to use.
+    sandbox : bool, optional
+        Whether to look for sandbox services or not. By default False.
 
     Returns
     -------
@@ -380,6 +383,8 @@ def get_main_cli_command_name(instance_type: InstanceType) -> str:
         return CLICommandName.ALGORITHM_STORE.value
     elif instance_type == InstanceType.NODE:
         return CLICommandName.NODE.value
+    elif instance_type == InstanceType.AUTH:
+        return CLICommandName.AUTH.value
     else:
         raise ValueError(f"Invalid instance type: {instance_type}")
 
@@ -412,3 +417,23 @@ def check_running(
         only_user_folders=not system_folders,
     )
     return helm_release_name in running_services
+
+
+def get_config_name_from_helm_release_name(helm_release_name: str) -> str:
+    """
+    Get the config name from a helm release name.
+
+    Parameters
+    ----------
+    helm_release_name : str
+        The name of the Helm release
+
+    Returns
+    -------
+    str
+        The config name
+    """
+    # 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])

vantage6/cli/config.py

@@ -13,6 +13,8 @@ from vantage6.cli.globals import (
     DEFAULT_CLI_CONFIG_FILE,
 )
 
+_CONTEXT_INFO_PRINTED = False
+
 
 class CliConfig:
     """
@@ -255,6 +257,12 @@ class CliConfig:
             if last_namespace != active_namespace:
                 self.set_last_namespace(namespace=active_namespace)
 
-        info(f"Using    context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
-        info(f"Using  namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}")
+        # only print the context and namespace once. This is to avoid printing it many
+        # times, e.g. in sandbox commands
+        global _CONTEXT_INFO_PRINTED
+        if not _CONTEXT_INFO_PRINTED:
+            info(f"Using    context: {Fore.YELLOW}{active_context}{Style.RESET_ALL}")
+            info(f"Using  namespace: {Fore.YELLOW}{active_namespace}{Style.RESET_ALL}")
+            _CONTEXT_INFO_PRINTED = True
+
         return active_context, active_namespace

vantage6/cli/{configuration_wizard.py → configuration_create.py}

@@ -12,6 +12,7 @@ from vantage6.common.globals import (
 
 from vantage6.cli.configuration_manager import (
     AlgorithmStoreConfigurationManager,
+    AuthConfigurationManager,
     NodeConfigurationManager,
     ServerConfigurationManager,
 )
@@ -125,25 +126,31 @@ def _add_production_server_config(config: dict) -> dict:
     return config
 
 
-def configuration_wizard(
-    questionnaire_function: callable,
+def make_configuration(
+    config_producing_func: callable,
+    config_producing_func_args: tuple,
     type_: InstanceType,
     instance_name: str,
     system_folders: bool,
+    is_sandbox: bool = False,
 ) -> Path:
     """
     Create a configuration file for a node or server instance.
 
     Parameters
     ----------
-    questionnaire_function : callable
+    config_producing_func : callable
         Function to generate the configuration
+    config_producing_func_args : tuple
+        Arguments to pass to the config producing function
     type_ : InstanceType
         Type of the instance to create a configuration for
     instance_name : str
         Name of the instance
     system_folders : bool
         Whether to use the system folders or not
+    is_sandbox : bool
+        Whether to create a sandbox configuration or not
 
     Returns
     -------
@@ -153,11 +160,10 @@ def configuration_wizard(
     # for defaults and where to save the config
     dirs = AppContext.instance_folders(type_, instance_name, system_folders)
 
-    # invoke questionaire to create configuration file
-    if type_ == InstanceType.NODE:
-        config = questionnaire_function(dirs, instance_name)
-    else:
-        config = questionnaire_function(instance_name)
+    # invoke function to create configuration file. Usually this is a questionaire
+    # but it can also be a function that immediately returns a dict with the
+    # configuration.
+    config = config_producing_func(*config_producing_func_args)
 
     # in the case of an environment we need to add it to the current
     # configuration. In the case of application we can simply overwrite this
@@ -167,21 +173,27 @@ def configuration_wizard(
         conf_manager = NodeConfigurationManager
     elif type_ == InstanceType.SERVER:
         conf_manager = ServerConfigurationManager
-    else:
+    elif type_ == InstanceType.ALGORITHM_STORE:
         conf_manager = AlgorithmStoreConfigurationManager
+    elif type_ == InstanceType.AUTH:
+        conf_manager = AuthConfigurationManager
+    else:
+        raise ValueError(f"Invalid instance type: {type_}")
 
     if Path(config_file).exists():
-        config_manager = conf_manager.from_file(config_file)
+        config_manager = conf_manager.from_file(config_file, is_sandbox=is_sandbox)
     else:
-        config_manager = conf_manager(instance_name)
+        config_manager = conf_manager(instance_name, is_sandbox=is_sandbox)
 
     config_manager.put(config)
-    config_manager.save(config_file)
+    config_file = config_manager.save(config_file)
 
     return config_file
 
 
-def select_configuration_questionaire(type_: InstanceType, system_folders: bool) -> str:
+def select_configuration_questionnaire(
+    type_: InstanceType, system_folders: bool, is_sandbox: bool = False
+) -> str:
     """
     Ask which configuration the user wants to use. It shows only configurations
     that are in the default folder.
@@ -192,14 +204,15 @@ def select_configuration_questionaire(type_: InstanceType, system_folders: bool)
         Type of the instance to create a configuration for
     system_folders : bool
         Whether to use the system folders or not
-
+    is_sandbox : bool
+        Whether to show only the sandbox configurations or not
     Returns
     -------
     str
         Name of the configuration
     """
     context = select_context_class(type_)
-    configs, _ = context.available_configurations(system_folders)
+    configs, _ = context.available_configurations(system_folders, is_sandbox)
 
     # each collection (file) can contain multiple configs. (e.g. test,
     # dev)