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

vantage6/cli/server/start.py

@@ -1,149 +1,110 @@
-import os
-from threading import Thread
-import time
-
 import click
 import docker
-from colorama import (Fore, Style)
-from sqlalchemy.engine.url import make_url
 from docker.client import DockerClient
 
 from vantage6.common import info, warning, error
-from vantage6.common.docker.addons import (
-    pull_if_newer, check_docker_running
-)
 from vantage6.common.docker.network_manager import NetworkManager
 from vantage6.common.globals import (
     APPNAME,
-    DEFAULT_DOCKER_REGISTRY,
     DEFAULT_SERVER_IMAGE,
-    DEFAULT_UI_IMAGE
+    DEFAULT_UI_IMAGE,
+    InstanceType,
 )
 
-from vantage6.cli.globals import DEFAULT_UI_PORT
-from vantage6.cli.context import ServerContext
-from vantage6.cli.utils import check_config_name_allowed
+from vantage6.cli.globals import DEFAULT_UI_PORT, ServerGlobals
+from vantage6.cli.context.server import ServerContext
 from vantage6.cli.rabbitmq.queue_manager import RabbitMQManager
-from vantage6.cli.server.common import (
-    click_insert_context, print_log_worker, stop_ui
+from vantage6.cli.server.common import click_insert_context, stop_ui
+from vantage6.cli.common.start import (
+    attach_logs,
+    check_for_start,
+    get_image,
+    mount_database,
+    mount_source,
+    pull_image,
 )
 
 
 @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="Server Docker image to use")
-@click.option('--with-ui', 'start_ui', flag_value=True, default=False,
-              help="Start the graphical User Interface as well")
-@click.option('--ui-port', default=None, type=int,
-              help="Port to listen on for the User Interface")
-@click.option('--with-rabbitmq', 'start_rabbitmq', flag_value=True,
-              default=False, help="Start RabbitMQ message broker as local "
-              "container - use in development only")
-@click.option('--rabbitmq-image', default=None,
-              help="RabbitMQ docker image to use")
-@click.option('--keep/--auto-remove', default=False,
-              help="Keep image after server has 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")
+@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="Server Docker image to use")
+@click.option(
+    "--with-ui",
+    "start_ui",
+    flag_value=True,
+    default=False,
+    help="Start the graphical User Interface as well",
+)
+@click.option(
+    "--ui-port", default=None, type=int, help="Port to listen on for the User Interface"
+)
+@click.option(
+    "--with-rabbitmq",
+    "start_rabbitmq",
+    flag_value=True,
+    default=False,
+    help="Start RabbitMQ message broker as local "
+    "container - use in development only",
+)
+@click.option("--rabbitmq-image", default=None, help="RabbitMQ docker image to use")
+@click.option(
+    "--keep/--auto-remove",
+    default=False,
+    help="Keep image after server has 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",
+)
 @click_insert_context
-def cli_server_start(ctx: ServerContext, ip: str, port: int, image: str,
-                     start_ui: bool, ui_port: int, start_rabbitmq: bool,
-                     rabbitmq_image: str, keep: bool, mount_src: str,
-                     attach: bool) -> None:
+def cli_server_start(
+    ctx: ServerContext,
+    ip: str,
+    port: int,
+    image: str,
+    start_ui: bool,
+    ui_port: int,
+    start_rabbitmq: bool,
+    rabbitmq_image: str,
+    keep: bool,
+    mount_src: str,
+    attach: bool,
+) -> None:
     """
     Start the server.
     """
-    # will print an error if not
-    check_docker_running()
-
     info("Starting server...")
-    info("Finding Docker daemon.")
-    docker_client = docker.from_env()
+    docker_client = check_for_start(ctx, InstanceType.SERVER)
 
-    # 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=server"})
-    for server in running_servers:
-        if server.name == f"{APPNAME}-{ctx.name}-{ctx.scope}-server":
-            error(f"Server {Fore.RED}{ctx.name}{Style.RESET_ALL} "
-                  "is already running")
-            exit(1)
+    image = get_image(image, ctx, "server", DEFAULT_SERVER_IMAGE)
 
     # check that log directory exists - or create it
     ctx.log_dir.mkdir(parents=True, exist_ok=True)
 
-    # 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('server')
-        if not image:
-            image = f"{DEFAULT_DOCKER_REGISTRY}/{DEFAULT_SERVER_IMAGE}"
-
-    info(f"Pulling latest server image '{image}'.")
-    try:
-        pull_if_newer(docker.from_env(), image)
-        # docker_client.images.pull(image)
-    except Exception as e:
-        warning(' ... Getting latest server image failed:')
-        warning(f"     {e}")
-    else:
-        info(" ... success!")
+    pull_image(docker_client, image)
 
     info("Creating mounts")
     config_file = "/mnt/config.yaml"
     mounts = [
-        docker.types.Mount(
-            config_file, str(ctx.config_file), type="bind"
-        ), docker.types.Mount(
-            "/mnt/log/", str(ctx.log_dir), type="bind"
-        )
+        docker.types.Mount(config_file, str(ctx.config_file), type="bind"),
+        docker.types.Mount("/mnt/log/", str(ctx.log_dir), type="bind"),
     ]
 
-    if mount_src:
-        mount_src = os.path.abspath(mount_src)
-        mounts.append(docker.types.Mount("/vantage6", mount_src, type="bind"))
-    # FIXME: code duplication with cli_server_import()
-    # try to mount database
-    uri = ctx.config['uri']
-    url = make_url(uri)
-    environment_vars = 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
-        mounts.append(docker.types.Mount(
-            "/mnt/database/", dirname, type="bind"
-        ))
-
-        environment_vars = {
-            "VANTAGE6_DB_URI": f"sqlite:////mnt/database/{basename}",
-            "VANTAGE6_CONFIG_NAME": ctx.config_file_name
-        }
+    src_mount = mount_source(mount_src)
+    if src_mount:
+        mounts.append(src_mount)
 
-    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")
+    mount, environment_vars = mount_database(ctx, InstanceType.SERVER)
+    if mount:
+        mounts.append(mount)
 
     # Create a docker network for the server and other services like RabbitMQ
     # to reside in
@@ -152,70 +113,66 @@ def cli_server_start(ctx: ServerContext, ip: str, port: int, image: str,
     )
     server_network_mgr.create_network(is_internal=False)
 
-    if start_rabbitmq or ctx.config.get('rabbitmq') and \
-            ctx.config['rabbitmq'].get('start_with_server', False):
+    if (
+        start_rabbitmq
+        or ctx.config.get("rabbitmq")
+        and ctx.config["rabbitmq"].get("start_with_server", False)
+    ):
         # Note that ctx.data_dir has been created at this point, which is
         # required for putting some RabbitMQ configuration files inside
-        info('Starting RabbitMQ container')
+        info("Starting RabbitMQ container")
         _start_rabbitmq(ctx, rabbitmq_image, server_network_mgr)
-    elif ctx.config.get('rabbitmq'):
-        info("RabbitMQ is provided in the config file as external service. "
-             "Assuming this service is up and running.")
+    elif ctx.config.get("rabbitmq"):
+        info(
+            "RabbitMQ is provided in the config file as external service. "
+            "Assuming this service is up and running."
+        )
     else:
-        warning('Message queue disabled! This means that the vantage6 server '
-                'cannot be scaled horizontally!')
+        warning(
+            "Message queue disabled! This means that the vantage6 server "
+            "cannot be scaled horizontally!"
+        )
 
     # start the UI if requested
-    if start_ui or ctx.config.get('ui') and ctx.config['ui'].get('enabled'):
+    if start_ui or ctx.config.get("ui") and ctx.config["ui"].get("enabled"):
         _start_ui(docker_client, ctx, ui_port)
 
     # 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-server/vantage6/server/wsgi.py '
-        f'--pyargv {config_file}'
+        f"uwsgi --http :{internal_port} --gevent 1000 --http-websockets "
+        "--master --callable app --disable-logging "
+        "--wsgi-file /vantage6/vantage6-server/vantage6/server/wsgi.py "
+        f"--pyargv {config_file}"
     )
     info(cmd)
 
     info("Run Docker container")
-    port_ = str(port or ctx.config["port"] or 5000)
+    port_ = str(port or ctx.config["port"] or ServerGlobals.PORT)
     container = docker_client.containers.run(
         image,
         command=cmd,
         mounts=mounts,
         detach=True,
-        labels={
-            f"{APPNAME}-type": "server",
-            "name": ctx.config_file_name
-        },
+        labels={f"{APPNAME}-type": InstanceType.SERVER, "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,
-        network=server_network_mgr.network_name
+        network=server_network_mgr.network_name,
     )
 
     info(f"Success! container id = {container.id}")
 
     if attach:
-        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 server stop{Style.RESET_ALL}")
-                exit(0)
+        attach_logs(container, InstanceType.SERVER)
 
 
-def _start_rabbitmq(ctx: ServerContext, rabbitmq_image: str,
-                    network_mgr: NetworkManager) -> None:
+def _start_rabbitmq(
+    ctx: ServerContext, rabbitmq_image: str, network_mgr: NetworkManager
+) -> None:
     """
     Start the RabbitMQ container if it is not already running.
 
@@ -228,14 +185,15 @@ def _start_rabbitmq(ctx: ServerContext, rabbitmq_image: str,
     network_mgr : NetworkManager
         Network manager object
     """
-    rabbit_uri = ctx.config['rabbitmq'].get('uri')
+    rabbit_uri = ctx.config["rabbitmq"].get("uri")
     if not rabbit_uri:
-        error("No RabbitMQ URI found in the configuration file! Please add"
-              "a 'uri' key to the 'rabbitmq' section of the configuration.")
+        error(
+            "No RabbitMQ URI found in the configuration file! Please add"
+            "a 'uri' key to the 'rabbitmq' section of the configuration."
+        )
         exit(1)
     # kick off RabbitMQ container
-    rabbit_mgr = RabbitMQManager(
-        ctx=ctx, network_mgr=network_mgr, image=rabbitmq_image)
+    rabbit_mgr = RabbitMQManager(ctx=ctx, network_mgr=network_mgr, image=rabbitmq_image)
     rabbit_mgr.start()
 
 
@@ -253,34 +211,23 @@ def _start_ui(client: DockerClient, ctx: ServerContext, ui_port: int) -> None:
         Port to expose the UI on
     """
     # if no port is specified, check if config contains a port
-    ui_config = ctx.config.get('ui')
+    ui_config = ctx.config.get("ui")
     if ui_config and not ui_port:
-        ui_port = ui_config.get('port')
+        ui_port = ui_config.get("port")
 
     # check if the port is valid
     # TODO make function to check if port is valid, and use in more places
     if not isinstance(ui_port, int) or not 0 < ui_port < 65536:
-        warning(f"UI port '{ui_port}' is not valid! Using default port "
-                f"{DEFAULT_UI_PORT}")
+        warning(
+            f"UI port '{ui_port}' is not valid! Using default port "
+            f"{DEFAULT_UI_PORT}"
+        )
         ui_port = DEFAULT_UI_PORT
 
     # find image to use
-    custom_images: dict = ctx.config.get('images')
-    image = None
-    if custom_images:
-        image = custom_images.get('ui')
-    if not image:
-        image = f"{DEFAULT_DOCKER_REGISTRY}/{DEFAULT_UI_IMAGE}"
+    image = get_image(None, ctx, "ui", DEFAULT_UI_IMAGE)
 
-    info(f"Pulling latest UI image '{image}'.")
-    try:
-        pull_if_newer(docker.from_env(), image)
-        # docker_client.images.pull(image)
-    except Exception as e:
-        warning(' ... Getting latest node image failed:')
-        warning(f"     {e}")
-    else:
-        info(" ... success!")
+    pull_image(client, image)
 
     # set environment variables
     env_vars = {
@@ -291,16 +238,13 @@ def _start_ui(client: DockerClient, ctx: ServerContext, ui_port: int) -> None:
     # stop the UI container if it is already running
     stop_ui(client, ctx)
 
-    info(f'Starting User Interface at port {ui_port}')
+    info(f"Starting User Interface at port {ui_port}")
     ui_container_name = f"{APPNAME}-{ctx.name}-{ctx.scope}-ui"
     client.containers.run(
         image,
         detach=True,
-        labels={
-            f"{APPNAME}-type": "ui",
-            "name": ctx.config_file_name
-        },
-        ports={"80/tcp": (ctx.config.get('ip'), ui_port)},
+        labels={f"{APPNAME}-type": "ui", "name": ctx.config_file_name},
+        ports={"80/tcp": (ctx.config.get("ip"), ui_port)},
         name=ui_container_name,
         environment=env_vars,
         tty=True,

vantage6/cli/server/stop.py

@@ -1,16 +1,21 @@
 import click
 import questionary as q
 import docker
-from colorama import (Fore, Style)
+from colorama import Fore, Style
 from docker.client import DockerClient
 
 from vantage6.common import info, warning, error
 from vantage6.common.docker.addons import (
-    check_docker_running, remove_container,
-    get_server_config_name, get_container, get_num_nonempty_networks,
-    get_network, delete_network, remove_container_if_exists
+    check_docker_running,
+    remove_container,
+    get_server_config_name,
+    get_container,
+    get_num_nonempty_networks,
+    get_network,
+    delete_network,
+    remove_container_if_exists,
 )
-from vantage6.common.globals import APPNAME
+from vantage6.common.globals import APPNAME, InstanceType
 from vantage6.cli.rabbitmq import split_rabbitmq_uri
 
 from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
@@ -19,10 +24,11 @@ from vantage6.cli.server.common import get_server_context, stop_ui
 
 @click.command()
 @click.option("-n", "--name", default=None, help="Configuration name")
-@click.option('--system', 'system_folders', flag_value=True)
-@click.option('--user', 'system_folders', flag_value=False,
-              default=DEFAULT_SERVER_SYSTEM_FOLDERS)
-@click.option('--all', 'all_servers', flag_value=True, help="Stop all servers")
+@click.option("--system", "system_folders", flag_value=True)
+@click.option(
+    "--user", "system_folders", flag_value=False, default=DEFAULT_SERVER_SYSTEM_FOLDERS
+)
+@click.option("--all", "all_servers", flag_value=True, help="Stop all servers")
 def cli_server_stop(name: str, system_folders: bool, all_servers: bool):
     """
     Stop one or all running server(s).
@@ -31,7 +37,8 @@ def cli_server_stop(name: str, system_folders: bool, all_servers: bool):
     client = docker.from_env()
 
     running_servers = client.containers.list(
-        filters={"label": f"{APPNAME}-type=server"})
+        filters={"label": f"{APPNAME}-type={InstanceType.SERVER}"}
+    )
 
     if not running_servers:
         warning("No servers are currently running.")
@@ -46,11 +53,12 @@ def cli_server_stop(name: str, system_folders: bool, all_servers: bool):
 
     # make sure we have a configuration name to work with
     if not name:
-        container_name = q.select("Select the server you wish to stop:",
-                                  choices=running_server_names).ask()
+        container_name = q.select(
+            "Select the server you wish to stop:", choices=running_server_names
+        ).ask()
     else:
         post_fix = "system" if system_folders else "user"
-        container_name = f"{APPNAME}-{name}-{post_fix}-server"
+        container_name = f"{APPNAME}-{name}-{post_fix}-{InstanceType.SERVER}"
 
     if container_name not in running_server_names:
         error(f"{Fore.RED}{name}{Style.RESET_ALL} is not running!")
@@ -59,8 +67,9 @@ def cli_server_stop(name: str, system_folders: bool, all_servers: bool):
     _stop_server_containers(client, container_name, system_folders)
 
 
-def _stop_server_containers(client: DockerClient, container_name: str,
-                            system_folders: bool) -> None:
+def _stop_server_containers(
+    client: DockerClient, container_name: str, system_folders: bool
+) -> None:
     """
     Given a server's name, kill its docker container and related (RabbitMQ)
     containers.
@@ -79,7 +88,6 @@ def _stop_server_containers(client: DockerClient, container_name: str,
     info(f"Stopped the {Fore.GREEN}{container_name}{Style.RESET_ALL} server.")
 
     # find the configuration name from the docker container name
-    # server name is formatted as f"{APPNAME}-{self.name}-{self.scope}-server"
     scope = "system" if system_folders else "user"
     config_name = get_server_config_name(container_name, scope)
 
@@ -95,13 +103,13 @@ def _stop_server_containers(client: DockerClient, container_name: str,
 
     # kill RabbitMQ if it exists and no other servers are using to it (i.e. it
     # is not in other docker networks with other containers)
-    rabbit_uri = ctx.config.get('rabbitmq', {}).get('uri')
+    rabbit_uri = ctx.config.get("rabbitmq", {}).get("uri")
     if rabbit_uri:
-        rabbit_container_name = split_rabbitmq_uri(
-            rabbit_uri=rabbit_uri)['host']
+        rabbit_container_name = split_rabbitmq_uri(rabbit_uri=rabbit_uri)["host"]
         rabbit_container = get_container(client, name=rabbit_container_name)
-        if rabbit_container and \
-                get_num_nonempty_networks(rabbit_container) == 0:
+        if rabbit_container and get_num_nonempty_networks(rabbit_container) == 0:
             remove_container(rabbit_container, kill=True)
-            info(f"Stopped the {Fore.GREEN}{rabbit_container_name}"
-                 f"{Style.RESET_ALL} container.")
+            info(
+                f"Stopped the {Fore.GREEN}{rabbit_container_name}"
+                f"{Style.RESET_ALL} container."
+            )

vantage6/cli/server/version.py

@@ -4,16 +4,17 @@ import docker
 
 from vantage6.common import error
 from vantage6.common.docker.addons import check_docker_running
-from vantage6.common.globals import APPNAME
+from vantage6.common.globals import APPNAME, InstanceType
 from vantage6.cli.globals import DEFAULT_SERVER_SYSTEM_FOLDERS
 from vantage6.cli import __version__
 
 
 @click.command()
 @click.option("-n", "--name", default=None, help="Configuration name")
-@click.option('--system', 'system_folders', flag_value=True)
-@click.option('--user', 'system_folders', flag_value=False,
-              default=DEFAULT_SERVER_SYSTEM_FOLDERS)
+@click.option("--system", "system_folders", flag_value=True)
+@click.option(
+    "--user", "system_folders", flag_value=False, default=DEFAULT_SERVER_SYSTEM_FOLDERS
+)
 def cli_server_version(name: str, system_folders: bool) -> None:
     """
     Print the version of the vantage6 server.
@@ -22,25 +23,27 @@ def cli_server_version(name: str, system_folders: bool) -> None:
     client = docker.from_env()
 
     running_servers = client.containers.list(
-        filters={"label": f"{APPNAME}-type=server"})
+        filters={"label": f"{APPNAME}-type={InstanceType.SERVER}"}
+    )
     running_server_names = [server.name for server in running_servers]
 
     if not name:
         if not running_server_names:
-            error("No servers are running! You can only check the version for "
-                  "servers that are running")
+            error(
+                "No servers are running! You can only check the version for "
+                "servers that are running"
+            )
             exit(1)
-        name = q.select("Select the server you wish to inspect:",
-                        choices=running_server_names).ask()
+        name = q.select(
+            "Select the server you wish to inspect:", choices=running_server_names
+        ).ask()
     else:
         post_fix = "system" if system_folders else "user"
         name = f"{APPNAME}-{name}-{post_fix}"
 
     if name in running_server_names:
         container = client.containers.get(name)
-        version = container.exec_run(cmd='vserver-local version',
-                                     stdout=True)
-        click.echo({"server": version.output.decode('utf-8'),
-                    "cli": __version__})
+        version = container.exec_run(cmd="vserver-local version", stdout=True)
+        click.echo({"server": version.output.decode("utf-8"), "cli": __version__})
     else:
         error(f"Server {name} is not running! Cannot provide version...")