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

vantage6/cli/common/new.py

@@ -0,0 +1,85 @@
+from colorama import Fore, Style
+
+from vantage6.common import ensure_config_dir_writable, error, info
+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.context import select_context_class
+from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
+
+
+def new(
+    questionnaire_function: callable,
+    name: str,
+    system_folders: bool,
+    namespace: str,
+    context: str,
+    type_: InstanceType,
+) -> None:
+    """
+    Create a new configuration.
+
+    Parameters
+    ----------
+    questionnaire_function : callable
+        Function to generate the configuration
+    name : str
+        Name of the configuration
+    system_folders : bool
+        Whether to store the configuration in the system folders
+    namespace : str
+        Namespace to use
+    context : str
+        Context to use
+    type_ : InstanceType
+        Type of the configuration (node, server, algorithm store, etc)
+    """
+    cli_config = CliConfig()
+    context, namespace = cli_config.compare_changes_config(
+        context=context,
+        namespace=namespace,
+    )
+
+    name = prompt_config_name(name)
+
+    # check if name is valid
+    check_config_name_allowed(name)
+
+    # check that this config does not exist
+    ctx_class = select_context_class(type_)
+    try:
+        if ctx_class.config_exists(name, system_folders):
+            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_)
+
+    # Check that we can write in this folder
+    if not ensure_config_dir_writable(system_folders):
+        error("Your user does not have write access to all folders. Exiting")
+        info(
+            f"Create a new {command_name} using '{Fore.GREEN}v6 {command_name} new "
+            f"--user{Style.RESET_ALL}' instead!"
+        )
+        exit(1)
+
+    # create config in ctx location
+    try:
+        cfg_file = configuration_wizard(
+            questionnaire_function, type_, name, system_folders
+        )
+    except KeyboardInterrupt:
+        error("Configuration creation aborted.")
+        exit(1)
+    info(f"New configuration created: {Fore.GREEN}{cfg_file}{Style.RESET_ALL}")
+
+    flag = "" if system_folders else "--user"
+    info(
+        f"You can start the {command_name} by running {Fore.GREEN}v6 {command_name} "
+        f"start {flag}{Style.RESET_ALL}"
+    )

vantage6/cli/common/remove.py

@@ -0,0 +1,54 @@
+import itertools
+from pathlib import Path
+from shutil import rmtree
+
+import questionary as q
+
+from vantage6.common import (
+    error,
+    info,
+)
+from vantage6.common.context import AppContext
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.utils import check_running
+from vantage6.cli.globals import InfraComponentName
+from vantage6.cli.utils import remove_file
+
+
+def execute_remove(
+    ctx: AppContext,
+    instance_type: InstanceType,
+    infra_component: InfraComponentName,
+    name: str,
+    system_folders: bool,
+    force: bool,
+) -> None:
+    if check_running(ctx.helm_release_name, instance_type, name, system_folders):
+        error(
+            f"The {infra_component.value} {name} is still running! Please stop the "
+            f"{infra_component.value} before deleting it."
+        )
+        exit(1)
+
+    if not force:
+        if not q.confirm(
+            f"This {infra_component.value} will be deleted permanently including its "
+            "configuration. Are you sure?",
+            default=False,
+        ).ask():
+            info(f"The {infra_component.value} {name} will not be deleted")
+            exit(0)
+
+    # remove the config file
+    remove_file(ctx.config_file, "configuration")
+
+    # ensure log files are closed before removing
+    log_dir = Path(ctx.log_file.parent)
+    if log_dir.exists():
+        info(f"Removing log directory: {log_dir}")
+        for handler in itertools.chain(ctx.log.handlers, ctx.log.root.handlers):
+            handler.close()
+        # remove the whole folder with all the log files. This may also still contain
+        # other files like (for the server) RabbitMQ configuration etc
+        rmtree(log_dir)

vantage6/cli/common/start.py

@@ -1,25 +1,18 @@
 from __future__ import annotations
 
-import enum
-import os
 import re
 import subprocess
 import time
 from os import PathLike
 from pathlib import Path
-from threading import Thread
 
 import docker
-from colorama import Fore, Style
 from docker.client import DockerClient
-from docker.models.containers import Container
-from sqlalchemy.engine.url import make_url
 
 from vantage6.common import error, info, warning
 from vantage6.common.context import AppContext
-from vantage6.common.docker.addons import check_docker_running, pull_image
+from vantage6.common.docker.addons import pull_image
 from vantage6.common.globals import (
-    APPNAME,
     DEFAULT_ALGO_STORE_IMAGE,
     DEFAULT_CHART_REPO,
     DEFAULT_DOCKER_REGISTRY,
@@ -29,83 +22,36 @@ from vantage6.common.globals import (
     InstanceType,
 )
 
-from vantage6.cli.common.utils import print_log_worker
-from vantage6.cli.context import AlgorithmStoreContext, ServerContext
-from vantage6.cli.globals import AlgoStoreGlobals, ServerGlobals
-from vantage6.cli.utils import (
-    check_config_name_allowed,
-    validate_input_cmd_args,
+from vantage6.cli.common.utils import (
+    check_running,
+    select_context_and_namespace,
 )
+from vantage6.cli.globals import ChartName
+from vantage6.cli.utils import check_config_name_allowed, validate_input_cmd_args
 
 
-def check_for_start(ctx: AppContext, type_: InstanceType) -> DockerClient:
+def prestart_checks(
+    ctx: AppContext,
+    instance_type: InstanceType,
+    name: str,
+    system_folders: bool,
+    context: str,
+    namespace: str,
+) -> None:
     """
-    Check if all requirements are met to start the instance.
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    type_ : InstanceType
-        The type of instance to check for
-
-    Returns
-    -------
-    DockerClient
-        A Docker client instance
+    Run pre-start checks for an instance.
     """
-    # will print an error if not
-    check_docker_running()
-
-    info("Finding Docker daemon.")
-    docker_client = docker.from_env()
 
-    # check if name is allowed for docker volume, else exit
     check_config_name_allowed(ctx.name)
 
-    # check that this server is not already running
-    running_servers = docker_client.containers.list(
-        filters={"label": f"{APPNAME}-type={type_}"}
-    )
-    for server in running_servers:
-        if server.name == f"{APPNAME}-{ctx.name}-{ctx.scope}-{type_}":
-            error(f"Server {Fore.RED}{ctx.name}{Style.RESET_ALL} is already running")
-            exit(1)
-    return docker_client
-
-
-def get_image(
-    image: str, ctx: AppContext, custom_image_key: str, default_image: str
-) -> str:
-    """
-    Get the image name for the given instance type.
-
-    Parameters
-    ----------
-    image : str | None
-        The image name to use if specified
-    ctx : AppContext
-        The context object
-    custom_image_key : str
-        The key to look for in the config file
-    default_image : str
-        The default image name
+    if check_running(ctx.helm_release_name, instance_type, name, system_folders):
+        error(f"Instance '{name}' is already running.")
+        exit(1)
 
-    Returns
-    -------
-    str
-        The image name to use
-    """
-    # Determine image-name. First we check if the option --image has been used.
-    # Then we check if the image has been specified in the config file, and
-    # finally we use the default settings from the package.
-    if image is None:
-        custom_images: dict = ctx.config.get("images")
-        if custom_images:
-            image = custom_images.get(custom_image_key)
-        if not image:
-            image = f"{DEFAULT_DOCKER_REGISTRY}/{default_image}"
-    return image
+    context, namespace = select_context_and_namespace(
+        context=context,
+        namespace=namespace,
+    )
 
 
 def pull_infra_image(
@@ -129,8 +75,8 @@ def pull_infra_image(
     try:
         pull_image(client, image, suppress_error=True)
     except docker.errors.APIError:
-        if not is_default_infra_image(image, instance_type):
-            if image_exists_locally(client, image):
+        if not _is_default_infra_image(image, instance_type):
+            if _image_exists_locally(client, image):
                 warning("Failed to pull infrastructure image! Will use local image...")
             else:
                 error("Failed to pull infrastructure image!")
@@ -141,7 +87,7 @@ def pull_infra_image(
             exit(1)
 
 
-def is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
+def _is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
     """
     Check if an infrastructure image is the default image.
 
@@ -167,7 +113,7 @@ def is_default_infra_image(image: str, instance_type: InstanceType) -> bool:
         return image == f"{DEFAULT_DOCKER_REGISTRY}/{DEFAULT_NODE_IMAGE}"
 
 
-def image_exists_locally(client: DockerClient, image: str) -> bool:
+def _image_exists_locally(client: DockerClient, image: str) -> bool:
     """
     Check if the image exists locally.
 
@@ -190,137 +136,9 @@ def image_exists_locally(client: DockerClient, image: str) -> bool:
     return True
 
 
-def mount_config_file(ctx: AppContext, config_file: str) -> list[docker.types.Mount]:
-    """
-    Mount the config file in the container.
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    config_file : str
-        The path to the config file
-
-    Returns
-    -------
-    list[docker.types.Mount]
-        The mounts to use
-    """
-    info("Creating mounts")
-    return [docker.types.Mount(config_file, str(ctx.config_file), type="bind")]
-
-
-def mount_source(mount_src: str) -> docker.types.Mount:
-    """
-    Mount the vantage6 source code in the container.
-
-    Parameters
-    ----------
-    mount_src : str
-        The path to the source code
-
-    Returns
-    -------
-    docker.types.Mount | None
-        The mount to use
-    """
-    if mount_src:
-        mount_src = os.path.abspath(mount_src)
-        return docker.types.Mount("/vantage6", mount_src, type="bind")
-
-
-def mount_database(
-    ctx: ServerContext | AlgorithmStoreContext, type_: InstanceType
-) -> tuple[docker.types.Mount, dict]:
-    """
-    Mount database in the container if it is file-based (e.g. a SQLite DB).
-
-    Parameters
-    ----------
-    ctx : AppContext
-        The context object
-    type_ : InstanceType
-        The type of instance to mount the database for
-
-    Returns
-    -------
-    docker.types.Mount | None
-        The mount to use
-    dict | None
-        The environment variables to use
-    """
-    # FIXME: code duplication with cli_server_import()
-    # try to mount database
-    uri = ctx.config["uri"]
-    url = make_url(uri)
-    environment_vars = {}
-    mount = None
-
-    # If host is None, we're dealing with a file-based DB, like SQLite
-    if url.host is None:
-        db_path = url.database
-
-        if not os.path.isabs(db_path):
-            # We're dealing with a relative path here -> make it absolute
-            db_path = ctx.data_dir / url.database
-
-        basename = os.path.basename(db_path)
-        dirname = os.path.dirname(db_path)
-        os.makedirs(dirname, exist_ok=True)
-
-        # we're mounting the entire folder that contains the database
-        mount = docker.types.Mount("/mnt/database/", dirname, type="bind")
-
-        if type_ == InstanceType.SERVER:
-            environment_vars = {
-                ServerGlobals.DB_URI_ENV_VAR.value: f"sqlite:////mnt/database/{basename}",
-                ServerGlobals.CONFIG_NAME_ENV_VAR.value: ctx.config_file_name,
-            }
-        elif type_ == InstanceType.ALGORITHM_STORE:
-            environment_vars = {
-                AlgoStoreGlobals.DB_URI_ENV_VAR.value: f"sqlite:////mnt/database/{basename}",
-                AlgoStoreGlobals.CONFIG_NAME_ENV_VAR.value: ctx.config_file_name,
-            }
-    else:
-        warning(
-            f"Database could not be transferred, make sure {url.host} "
-            "is reachable from the Docker container"
-        )
-        info("Consider using the docker-compose method to start a server")
-
-    return mount, environment_vars
-
-
-# TODO v5+ remove this function, it is replaced by the `attach_logs` function in
-# `vantage6.cli.common.utils`
-def attach_logs(container: Container, type_: InstanceType) -> None:
-    """
-    Attach container logs to the console if specified.
-
-    Parameters
-    ----------
-    container : Container
-        The container to attach the logs from
-    type_ : InstanceType
-        The type of instance to attach the logs for
-    """
-    logs = container.attach(stream=True, logs=True, stdout=True)
-    Thread(target=print_log_worker, args=(logs,), daemon=True).start()
-    while True:
-        try:
-            time.sleep(1)
-        except KeyboardInterrupt:
-            info("Closing log file. Keyboard Interrupt.")
-            info(
-                "Note that your server is still running! Shut it down "
-                f"with {Fore.RED}v6 {type_} stop{Style.RESET_ALL}"
-            )
-            exit(0)
-
-
 def helm_install(
     release_name: str,
-    chart_name: str,
+    chart_name: ChartName,
     values_file: str | PathLike | None = None,
     context: str | None = None,
     namespace: str | None = None,
@@ -361,6 +179,7 @@ def helm_install(
         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
     ]
 
@@ -380,14 +199,18 @@ def helm_install(
             check=True,
         )
         info(
-            f"Successfully installed release '{release_name}' using chart '{chart_name}'."
+            f"Successfully installed release '{release_name}' using chart "
+            f"'{chart_name}'."
         )
-    except subprocess.CalledProcessError as e:
-        error(f"Failed to install release '{release_name}': {e.stderr}")
+    except subprocess.CalledProcessError:
+        error(f"Failed to install release '{release_name}'.")
+        exit(1)
     except FileNotFoundError:
         error(
-            "Helm command not found. Please ensure Helm is installed and available in the PATH."
+            "Helm command not found. Please ensure Helm is installed and available in "
+            "the PATH."
         )
+        exit(1)
 
 
 def start_port_forward(

vantage6/cli/common/stop.py

@@ -2,11 +2,89 @@ from __future__ import annotations
 
 import subprocess
 
+from colorama import Fore, Style
 
 from vantage6.common import error, info, warning
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.utils import (
+    find_running_service_names,
+    select_context_and_namespace,
+    select_running_service,
+)
+from vantage6.cli.context import get_context
+from vantage6.cli.globals import InfraComponentName
 from vantage6.cli.utils import validate_input_cmd_args
 
 
+def execute_stop(
+    stop_function: callable,
+    instance_type: InstanceType,
+    infra_component: InfraComponentName,
+    stop_all: bool,
+    to_stop: str | None,
+    namespace: str,
+    context: str,
+    system_folders: bool,
+):
+    """
+    Execute the stop function for a given instance type and infra component.
+
+    Parameters
+    ----------
+    stop_function : callable
+        The function to stop the service.
+    instance_type : InstanceType
+        The instance type of the service.
+    infra_component : InfraComponentName
+        The infra component of the service.
+    stop_all : bool
+        Whether to stop all services.
+    to_stop : str | None
+        The name of the service to stop.
+    namespace : str
+        The namespace of the service.
+    context : str
+        The context of the service.
+    system_folders : bool
+        Whether to use system folders.
+    """
+    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,
+        only_user_folders=not system_folders,
+        context=context,
+        namespace=namespace,
+    )
+
+    if not running_services:
+        error(f"No running {infra_component.value}s found.")
+        return
+
+    if stop_all:
+        for service in running_services:
+            stop_function(service, namespace, context)
+    else:
+        if not to_stop:
+            helm_name = select_running_service(running_services, instance_type)
+        else:
+            ctx = get_context(instance_type, to_stop, system_folders)
+            helm_name = ctx.helm_release_name
+
+        if helm_name in running_services:
+            stop_function(helm_name, namespace, context)
+            info(
+                f"Stopped the {Fore.GREEN}{helm_name}{Style.RESET_ALL} {infra_component.value}."
+            )
+        else:
+            error(f"{Fore.RED}{to_stop}{Style.RESET_ALL} is not running?!")
+
+
 def stop_port_forward(service_name: str) -> None:
     """
     Stop the port forwarding process for a given service name.