vantage6 4.2.2__py3-none-any.whl → 4.3.0b3__py3-none-any.whl

tests_cli/test_node_cli.py

@@ -39,7 +39,7 @@ class NodeCLITest(unittest.TestCase):
         # check exit code
         self.assertEqual(result.exit_code, 1)
 
-    @patch("vantage6.cli.context.NodeContext.available_configurations")
+    @patch("vantage6.cli.context.node.NodeContext.available_configurations")
     @patch("docker.DockerClient.ping")
     @patch("docker.DockerClient.containers")
     def test_list(self, containers, docker_ping, available_configurations):

tests_cli/test_server_cli.py

@@ -4,7 +4,7 @@ from unittest.mock import MagicMock, patch
 from pathlib import Path
 from click.testing import CliRunner
 
-from vantage6.cli.globals import APPNAME
+from vantage6.common.globals import APPNAME, InstanceType
 from vantage6.cli.server.start import cli_server_start
 from vantage6.cli.server.list import cli_server_configuration_list
 from vantage6.cli.server.files import cli_server_files
@@ -18,10 +18,10 @@ class ServerCLITest(unittest.TestCase):
     @patch("vantage6.cli.server.start.NetworkManager")
     @patch("vantage6.cli.server.start.docker.types.Mount")
     @patch("os.makedirs")
-    @patch("vantage6.cli.server.start.pull_if_newer")
+    @patch("vantage6.cli.common.start.pull_if_newer")
     @patch("vantage6.cli.server.common.ServerContext")
     @patch("vantage6.cli.server.start.docker.from_env")
-    @patch("vantage6.cli.server.start.check_docker_running", return_value=True)
+    @patch("vantage6.cli.common.start.check_docker_running", return_value=True)
     def test_start(
         self,
         docker_check,
@@ -131,7 +131,7 @@ class ServerCLITest(unittest.TestCase):
         """Stop server without errors."""
 
         container1 = MagicMock()
-        container1.name = f"{APPNAME}-iknl-system-server"
+        container1.name = f"{APPNAME}-iknl-system-{InstanceType.SERVER}"
         containers.containers.list.return_value = [container1]
 
         runner = CliRunner()
@@ -145,7 +145,7 @@ class ServerCLITest(unittest.TestCase):
     def test_attach(self, containers, sleep):
         """Attach log to the console without errors."""
         container1 = MagicMock()
-        container1.name = f"{APPNAME}-iknl-system-server"
+        container1.name = f"{APPNAME}-iknl-system-{InstanceType.SERVER}"
         containers.list.return_value = [container1]
 
         sleep.side_effect = KeyboardInterrupt("Boom!")

tests_cli/test_wizard.py

@@ -9,6 +9,7 @@ from vantage6.cli.configuration_wizard import (
     configuration_wizard,
     select_configuration_questionaire,
 )
+from vantage6.common.globals import InstanceType
 
 module_path = "vantage6.cli.configuration_wizard"
 
@@ -86,29 +87,27 @@ class WizardTest(unittest.TestCase):
     @patch(f"{module_path}.server_configuration_questionaire")
     @patch(f"{module_path}.ServerConfigurationManager")
     @patch(f"{module_path}.NodeConfigurationManager")
-    @patch(f"{module_path}.NodeContext")
+    @patch("vantage6.cli.configuration_wizard.AppContext")
     def test_configuration_wizard_interface(
         self, context, node_m, server_m, server_q, node_q
     ):
         context.instance_folders.return_value = {"config": "/some/path/"}
 
-        file_ = configuration_wizard("node", "vtg6", False)
+        file_ = configuration_wizard(InstanceType.NODE, "vtg6", False)
         self.assertEqual(Path("/some/path/vtg6.yaml"), file_)
 
-        file_ = configuration_wizard("server", "vtg6", True)
+        file_ = configuration_wizard(InstanceType.SERVER, "vtg6", True)
         self.assertEqual(Path("/some/path/vtg6.yaml"), file_)
 
-    @patch(f"{module_path}.NodeContext")
-    @patch(f"{module_path}.ServerContext")
-    def test_select_configuration(self, server_c, node_c):
+    @patch("vantage6.cli.configuration_wizard.AppContext.available_configurations")
+    def test_select_configuration(self, available_configurations):
         config = MagicMock()
         config.name = "vtg6"
 
-        server_c.available_configurations.return_value = [[config], []]
-        node_c.available_configurations.return_value = [[config], []]
+        available_configurations.return_value = [[config], []]
 
         with patch(f"{module_path}.q") as q:
             q.select.return_value.ask.return_value = "vtg6"
-            name = select_configuration_questionaire("node", True)
+            name = select_configuration_questionaire(InstanceType.NODE, True)
 
         self.assertEqual(name, "vtg6")

vantage6/cli/__build__

@@ -1 +1 @@
-0
+3

vantage6/cli/_version.py

@@ -7,7 +7,7 @@ with open(os.path.join(here, "__build__")) as fp:
     __build__ = json.load(fp)
 
 # Module version
-version_info = (4, 2, 2, "final", __build__, 0)
+version_info = (4, 3, 0, "beta", __build__, 0)
 
 # Module version stage suffix map
 _specifier_ = {"alpha": "a", "beta": "b", "candidate": "rc", "final": ""}

vantage6/cli/algostore/attach.py

@@ -0,0 +1,32 @@
+import click
+import docker
+
+from colorama import Fore, Style
+
+from vantage6.common import error
+from vantage6.common.docker.addons import check_docker_running
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.common.decorator import insert_context
+from vantage6.cli.common.start import attach_logs
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+
+
+@click.command()
+@insert_context(InstanceType.ALGORITHM_STORE)
+def cli_algo_store_attach(ctx: AlgorithmStoreContext) -> None:
+    """
+    Show the server logs in the current console.
+    """
+    check_docker_running()
+    client = docker.from_env()
+
+    running_servers = client.containers.list(
+        filters={"label": f"{APPNAME}-type={InstanceType.ALGORITHM_STORE}"}
+    )
+    running_server_names = [container.name for container in running_servers]
+
+    if ctx.docker_container_name in running_server_names:
+        container = client.containers.get(ctx.docker_container_name)
+        attach_logs(container, InstanceType.ALGORITHM_STORE)
+    else:
+        error(f"{Fore.RED}{ctx.name}{Style.RESET_ALL} is not running!")

vantage6/cli/algostore/new.py

@@ -0,0 +1,55 @@
+import click
+from colorama import Fore, Style
+
+from vantage6.common import info, error, check_config_writeable
+from vantage6.common.globals import InstanceType
+from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+from vantage6.cli.configuration_wizard import configuration_wizard
+from vantage6.cli.utils import check_config_name_allowed, prompt_config_name
+
+
+@click.command()
+@click.option(
+    "-n", "--name", default=None, help="name of the configuration you want to use."
+)
+@click.option("--system", "system_folders", flag_value=True)
+@click.option(
+    "--user", "system_folders", flag_value=False, default=DEFAULT_SERVER_SYSTEM_FOLDERS
+)
+def cli_algo_store_new(name: str, system_folders: bool) -> None:
+    """
+    Create a new server configuration.
+    """
+    name = prompt_config_name(name)
+
+    # check if name is allowed for docker volume, else exit
+    check_config_name_allowed(name)
+
+    # check that this config does not exist
+    try:
+        if AlgorithmStoreContext.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)
+
+    # Check that we can write in this folder
+    if not check_config_writeable(system_folders):
+        error("Your user does not have write access to all folders. Exiting")
+        info(
+            f"Create a new server using '{Fore.GREEN}v6 algorithm-store new "
+            f"--user{Style.RESET_ALL}' instead!"
+        )
+        exit(1)
+
+    # create config in ctx location
+    cfg_file = configuration_wizard(InstanceType.ALGORITHM_STORE, name, system_folders)
+    info(f"New configuration created: {Fore.GREEN}{cfg_file}{Style.RESET_ALL}")
+
+    flag = "" if system_folders else "--user"
+    info(
+        f"You can start the algorithm store by running {Fore.GREEN}v6 "
+        f"algorithm-store start {flag}{Style.RESET_ALL}"
+    )

vantage6/cli/algostore/start.py

@@ -0,0 +1,102 @@
+import click
+
+from vantage6.common import info
+from vantage6.common.globals import APPNAME, DEFAULT_ALGO_STORE_IMAGE, InstanceType
+from vantage6.cli.common.start import (
+    attach_logs,
+    check_for_start,
+    get_image,
+    mount_config_file,
+    mount_database,
+    mount_source,
+    pull_image,
+)
+from vantage6.cli.globals import AlgoStoreGlobals
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+from vantage6.cli.common.decorator import insert_context
+
+
+@click.command()
+@click.option("--ip", default=None, help="IP address to listen on")
+@click.option("-p", "--port", default=None, type=int, help="Port to listen on")
+@click.option("-i", "--image", default=None, help="Algorithm store Docker image to use")
+@click.option(
+    "--keep/--auto-remove",
+    default=False,
+    help="Keep image after algorithm store has been stopped. Useful " "for debugging",
+)
+@click.option(
+    "--mount-src",
+    default="",
+    help="Override vantage6 source code in container with the source"
+    " code in this path",
+)
+@click.option(
+    "--attach/--detach",
+    default=False,
+    help="Print server logs to the console after start",
+)
+@insert_context(InstanceType.ALGORITHM_STORE)
+def cli_algo_store_start(
+    ctx: AlgorithmStoreContext,
+    ip: str,
+    port: int,
+    image: str,
+    keep: bool,
+    mount_src: str,
+    attach: bool,
+) -> None:
+    """
+    Start the algorithm store server.
+    """
+    info("Starting algorithm store...")
+    docker_client = check_for_start(ctx, InstanceType.ALGORITHM_STORE)
+
+    image = get_image(image, ctx, "algorithm-store", DEFAULT_ALGO_STORE_IMAGE)
+
+    pull_image(docker_client, image)
+
+    config_file = "/mnt/config.yaml"
+    mounts = mount_config_file(ctx, config_file)
+
+    src_mount = mount_source(mount_src)
+    if src_mount:
+        mounts.append(src_mount)
+
+    mount, environment_vars = mount_database(ctx, InstanceType.ALGORITHM_STORE)
+    if mount:
+        mounts.append(mount)
+
+    # The `ip` and `port` refer here to the ip and port within the container.
+    # So we do not really care that is it listening on all interfaces.
+    internal_port = 5000
+    cmd = (
+        f"uwsgi --http :{internal_port} --gevent 1000 --http-websockets "
+        "--master --callable app --disable-logging "
+        "--wsgi-file /vantage6/vantage6-algorithm-store/vantage6/algorithm"
+        f"/store/wsgi.py --pyargv {config_file}"
+    )
+    info(cmd)
+
+    info("Run Docker container")
+    port_ = str(port or ctx.config["port"] or AlgoStoreGlobals.PORT)
+    container = docker_client.containers.run(
+        image,
+        command=cmd,
+        mounts=mounts,
+        detach=True,
+        labels={
+            f"{APPNAME}-type": InstanceType.ALGORITHM_STORE,
+            "name": ctx.config_file_name,
+        },
+        environment=environment_vars,
+        ports={f"{internal_port}/tcp": (ip, port_)},
+        name=ctx.docker_container_name,
+        auto_remove=not keep,
+        tty=True,
+    )
+
+    info(f"Success! container id = {container.id}")
+
+    if attach:
+        attach_logs(container, InstanceType.ALGORITHM_STORE)

vantage6/cli/algostore/stop.py

@@ -0,0 +1,60 @@
+import click
+import docker
+from colorama import Fore, Style
+
+from vantage6.common import info, warning, error
+from vantage6.common.docker.addons import (
+    check_docker_running,
+    remove_container_if_exists,
+)
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.common.decorator import insert_context
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+
+
+@click.command()
+@insert_context(InstanceType.ALGORITHM_STORE)
+@click.option("--all", "all_servers", flag_value=True, help="Stop all servers")
+def cli_algo_store_stop(ctx: AlgorithmStoreContext, all_servers: bool):
+    """
+    Stop one or all running server(s).
+    """
+    check_docker_running()
+    client = docker.from_env()
+
+    running_servers = client.containers.list(
+        filters={"label": f"{APPNAME}-type={InstanceType.ALGORITHM_STORE}"}
+    )
+
+    if not running_servers:
+        warning("No servers are currently running.")
+        return
+
+    running_server_names = [server.name for server in running_servers]
+
+    if all_servers:
+        for container_name in running_server_names:
+            _stop_algorithm_store(client, container_name)
+        return
+
+    container_name = ctx.docker_container_name
+    if container_name not in running_server_names:
+        error(f"{Fore.RED}{ctx.name}{Style.RESET_ALL} is not running!")
+        return
+
+    _stop_algorithm_store(client, container_name)
+
+
+def _stop_algorithm_store(client, container_name) -> None:
+    """
+    Stop the algorithm store server.
+
+    Parameters
+    ----------
+    client : DockerClient
+        The docker client
+    container_name : str
+        The name of the container to stop
+    """
+    remove_container_if_exists(client, name=container_name)
+    info(f"Stopped the {Fore.GREEN}{container_name}{Style.RESET_ALL} server.")

vantage6/cli/cli.py

@@ -29,6 +29,10 @@ from vantage6.cli.algorithm.create import cli_algorithm_create
 from vantage6.cli.algorithm.update import cli_algorithm_update
 from vantage6.cli.test.feature_tester import cli_test_features
 from vantage6.cli.test.integration_test import cli_test_integration
+from vantage6.cli.algostore.attach import cli_algo_store_attach
+from vantage6.cli.algostore.new import cli_algo_store_new
+from vantage6.cli.algostore.start import cli_algo_store_start
+from vantage6.cli.algostore.stop import cli_algo_store_stop
 
 
 # Define the server group
@@ -117,6 +121,21 @@ cli_test.add_command(cli_test_features, name="feature-test")
 cli_test.add_command(cli_test_integration, name="integration-test")
 
 
+# Define the algorithm-store group
+@click.group(name="algorithm-store")
+def cli_algo_store() -> None:
+    """
+    Manage your vantage6 algorithm store server instances.
+    """
+
+
+# Define the commands for the test group
+cli_algo_store.add_command(cli_algo_store_attach, name="attach")
+cli_algo_store.add_command(cli_algo_store_new, name="new")
+cli_algo_store.add_command(cli_algo_store_start, name="start")
+cli_algo_store.add_command(cli_algo_store_stop, name="stop")
+
+
 # Define the overall group
 @click.group(name="cli")
 def cli_complete() -> None:
@@ -134,3 +153,4 @@ cli_complete.add_command(cli_server)
 cli_complete.add_command(cli_dev)
 cli_complete.add_command(cli_algorithm)
 cli_complete.add_command(cli_test)
+cli_complete.add_command(cli_algo_store)

vantage6/cli/common/decorator.py

@@ -0,0 +1,92 @@
+from functools import wraps
+import click
+
+from vantage6.common import error
+from vantage6.common.globals import InstanceType
+from vantage6.cli.configuration_wizard import select_configuration_questionaire
+from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
+from vantage6.cli.context import select_context_class, get_context
+
+
+# TODO to make this decorator usable by nodes as well, we should make the
+# default for --user/--system configurable
+def insert_context(type_: InstanceType) -> callable:
+    """
+    Supply the Click function with an additional context parameter. The context
+    is passed to the function as the first argument.
+
+    Parameters
+    ----------
+    type_ : InstanceType
+        The type of instance for which the context should be inserted
+
+    Returns
+    -------
+    Callable
+        Click function with context
+
+    Examples
+    --------
+    >>> @insert_context(InstanceType.SERVER)
+    >>> def cli_server_start(ctx: ServerContext, *args, **kwargs) -> None:
+    >>>     pass
+    """
+
+    def protection_decorator(func: callable) -> callable:
+        @click.option("-n", "--name", default=None, help="Name of the configuration.")
+        @click.option(
+            "-c",
+            "--config",
+            default=None,
+            help="Absolute path to " "configuration-file; overrides --name",
+        )
+        @click.option(
+            "--system",
+            "system_folders",
+            flag_value=True,
+            help="Use system folders instead of user folders. This " "is the default",
+        )
+        @click.option(
+            "--user",
+            "system_folders",
+            flag_value=False,
+            default=DEFAULT_SERVER_SYSTEM_FOLDERS,
+            help="Use user folders instead of system folders",
+        )
+        @wraps(func)
+        def decorator(
+            name: str, config: str, system_folders: bool, *args, **kwargs
+        ) -> callable:
+            """
+            Decorator function that adds the context to the function.
+
+            Returns
+            -------
+            Callable
+                Decorated function
+            """
+            ctx_class = select_context_class(type_)
+            # path to configuration file always overrides name
+            if config:
+                ctx = ctx_class.from_external_config_file(config, system_folders)
+            elif "ctx" in kwargs:
+                # if ctx is already in kwargs (typically when one click command
+                # calls another internally), use that existing ctx
+                ctx = kwargs.pop("ctx")
+            else:
+                # in case no name, ctx or config file is supplied, ask the user
+                # to select an existing config by name
+                if not name:
+                    try:
+                        # select configuration if none supplied
+                        name = select_configuration_questionaire(type_, system_folders)
+                    except Exception:
+                        error("No configurations could be found!")
+                        exit(1)
+
+                ctx = get_context(type_, name, system_folders)
+            return func(ctx, *args, **kwargs)
+
+        return decorator
+
+    return protection_decorator