vantage6 4.0.2__py3-none-any.whl → 4.1.0b0__py3-none-any.whl

vantage6/cli/node/create_private_key.py

@@ -0,0 +1,139 @@
+from pathlib import Path
+import click
+from colorama import Fore, Style
+
+from vantage6.common import (
+    warning, error, info, debug, bytes_to_base64s,
+)
+
+from vantage6.common.encryption import RSACryptor
+from vantage6.cli.context import NodeContext
+from vantage6.cli.globals import (
+    DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+)
+from vantage6.cli.node.common import (
+    select_node, create_client_and_authenticate
+)
+
+
+@click.command()
+@click.option("-n", "--name", default=None, help="Configuration name")
+@click.option("-c", "--config", default=None,
+              help='Absolute path to configuration-file; overrides NAME')
+@click.option('--system', 'system_folders', flag_value=True,
+              help="Search for configuration in system folders rather than "
+                   "user folders")
+@click.option('--user', 'system_folders', flag_value=False, default=N_FOL,
+              help="Search for configuration in user folders rather than "
+                   "system folders. This is the default")
+@click.option('--no-upload', 'upload', flag_value=False, default=True,
+              help="Don't upload the public key to the server")
+@click.option("-o", "--organization-name", default=None,
+              help="Organization name. Used in the filename of the private key"
+                   " so that it can easily be recognized again later")
+@click.option('--overwrite', 'overwrite', flag_value=True, default=False,
+              help="Overwrite existing private key if present")
+def cli_node_create_private_key(
+        name: str, config: str, system_folders: bool, upload: bool,
+        organization_name: str, overwrite: bool) -> None:
+    """
+    Create and upload a new private key
+
+    Use this command with caution! Uploading a new key has several
+    consequences, e.g. you and other users of your organization
+    will no longer be able to read the results of tasks encrypted with current
+    key.
+    """
+    NodeContext.LOGGING_ENABLED = False
+    if config:
+        name = Path(config).stem
+        ctx = NodeContext(name, system_folders, config)
+    else:
+        # retrieve context
+        name = select_node(name, system_folders)
+
+        # Create node context
+        ctx = NodeContext(name, system_folders)
+
+    # Authenticate with the server to obtain organization name if it wasn't
+    # provided
+    if organization_name is None:
+        client = create_client_and_authenticate(ctx)
+        organization_name = client.whoami.organization_name
+
+    # create directory where private key goes if it doesn't exist yet
+    ctx.type_data_folder(system_folders).mkdir(parents=True, exist_ok=True)
+
+    # generate new key, and save it
+    filename = f"privkey_{organization_name}.pem"
+    file_ = ctx.type_data_folder(system_folders) / filename
+
+    if file_.exists():
+        warning(f"File '{Fore.CYAN}{file_}{Style.RESET_ALL}' exists!")
+
+        if overwrite:
+            warning("'--override' specified, so it will be overwritten ...")
+
+    if file_.exists() and not overwrite:
+        error("Could not create private key!")
+        warning(
+            "If you're **sure** you want to create a new key, "
+            "please run this command with the '--overwrite' flag"
+        )
+        warning("Continuing with existing key instead!")
+        private_key = RSACryptor(file_).private_key
+
+    else:
+        try:
+            info("Generating new private key")
+            private_key = RSACryptor.create_new_rsa_key(file_)
+
+        except Exception as e:
+            error(f"Could not create new private key '{file_}'!?")
+            debug(e)
+            info("Bailing out ...")
+            exit(1)
+
+        warning(f"Private key written to '{file_}'")
+        warning(
+            "If you're running multiple nodes, be sure to copy the private "
+            "key to the appropriate directories!"
+        )
+
+    # create public key
+    info("Deriving public key")
+    public_key = RSACryptor.create_public_key_bytes(private_key)
+
+    # update config file
+    info("Updating configuration")
+    ctx.config["encryption"]["private_key"] = str(file_)
+    ctx.config_manager.put(ctx.config)
+    ctx.config_manager.save(ctx.config_file)
+
+    # upload key to the server
+    if upload:
+        info(
+            "Uploading public key to the server. "
+            "This will overwrite any previously existing key!"
+        )
+
+        if 'client' not in locals():
+            client = create_client_and_authenticate(ctx)
+
+        # TODO what happens if the user doesn't have permission to upload key?
+        # Does that lead to an exception or not?
+        try:
+            client.request(
+                f"/organization/{client.whoami.organization_id}",
+                method="patch",
+                json={"public_key": bytes_to_base64s(public_key)}
+            )
+
+        except Exception as e:
+            error("Could not upload the public key!")
+            debug(e)
+            exit(1)
+    else:
+        warning("Public key not uploaded!")
+
+    info("[Done]")

vantage6/cli/node/files.py

@@ -0,0 +1,34 @@
+import click
+
+from vantage6.common import info
+from vantage6.cli.context 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:
+    """
+    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']})")

vantage6/cli/node/list.py

@@ -0,0 +1,62 @@
+import click
+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.cli.context import NodeContext
+from vantage6.cli.node.common import find_running_node_names
+
+
+@click.command()
+def cli_node_list() -> None:
+    """
+    Lists all node configurations.
+
+    Note that this command cannot find node configuration files in custom
+    directories.
+    """
+
+    check_docker_running()
+    client = docker.from_env()
+
+    running_node_names = find_running_node_names(client)
+
+    header = \
+        "\nName"+(21*" ") + \
+        "Status"+(10*" ") + \
+        "System/User"
+
+    click.echo(header)
+    click.echo("-"*len(header))
+
+    running = Fore.GREEN + "Running" + Style.RESET_ALL
+    stopped = Fore.RED + "Not running" + Style.RESET_ALL
+
+    # system folders
+    configs, f1 = NodeContext.available_configurations(
+        system_folders=True)
+    for config in configs:
+        status = running if f"{APPNAME}-{config.name}-system" in \
+            running_node_names else stopped
+        click.echo(
+            f"{config.name:25}"
+            f"{status:25}System "
+        )
+
+    # user folders
+    configs, f2 = NodeContext.available_configurations(
+        system_folders=False)
+    for config in configs:
+        status = running if f"{APPNAME}-{config.name}-user" in \
+            running_node_names else stopped
+        click.echo(
+            f"{config.name:25}"
+            f"{status:25}User   "
+        )
+
+    click.echo("-"*53)
+    if len(f1)+len(f2):
+        warning(
+             f"{Fore.RED}Failed imports: {len(f1)+len(f2)}{Style.RESET_ALL}")

vantage6/cli/node/new.py

@@ -0,0 +1,46 @@
+import click
+from colorama import Fore, Style
+
+from vantage6.common import error, info, check_config_writeable
+from vantage6.cli.context import NodeContext
+from vantage6.cli.globals import (
+    DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+)
+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="Configuration name")
+@click.option('--system', 'system_folders', flag_value=True,
+              help="Store this configuration in the system folders")
+@click.option('--user', 'system_folders', flag_value=False, default=N_FOL,
+              help="Store this configuration in the user folders. This is the "
+                   "default")
+def cli_node_new_configuration(name: str, system_folders: bool) -> 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)
+
+    # check that this config does not exist
+    if NodeContext.config_exists(name, system_folders):
+        error(f"Configuration {name} already exists!")
+        exit(1)
+
+    # Check that we can write in this folder
+    if not check_config_writeable(system_folders):
+        error("Cannot write configuration file. Exiting...")
+        exit(1)
+
+    # create config in ctx location
+    flag = "--system" if system_folders else ""
+    cfg_file = configuration_wizard("node", name, system_folders)
+    info(f"New configuration created: {Fore.GREEN}{cfg_file}{Style.RESET_ALL}")
+    info(f"You can start the node by running "
+         f"{Fore.GREEN}v6 node start {flag}{Style.RESET_ALL}")

vantage6/cli/node/remove.py

@@ -0,0 +1,103 @@
+import click
+import questionary as q
+import docker
+import os.path
+import itertools
+
+from pathlib import Path
+from shutil import rmtree
+
+from vantage6.common import (
+    error, info, debug,
+)
+from vantage6.common.globals import APPNAME
+
+from vantage6.common.globals import VPN_CONFIG_FILE
+
+
+from vantage6.cli.context import NodeContext
+from vantage6.cli.globals import (
+    DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+)
+from vantage6.cli.utils import (
+    check_if_docker_daemon_is_running, remove_file
+)
+from vantage6.cli.node.common import select_node, find_running_node_names
+
+
+@click.command()
+@click.option("-n", "--name", default=None, help="Configuration name")
+@click.option('--system', 'system_folders', flag_value=True,
+              help="Search for configuration in system folders rather than "
+                   "user folders")
+@click.option('--user', 'system_folders', flag_value=False, default=N_FOL,
+              help="Search for configuration in user folders rather than "
+                   "system folders. This is the default")
+@click.option('-f', "--force", type=bool, flag_value=True,
+              help='Don\'t ask for confirmation')
+def cli_node_remove(name: str, system_folders: bool, force: bool) -> None:
+    """
+    Delete a node permanently.
+
+    Remove the configuration file, log file, and docker volumes attached to
+    the node.
+    """
+    # select configuration name if none supplied
+    name = select_node(name, system_folders)
+
+    client = docker.from_env()
+    check_if_docker_daemon_is_running(client)
+
+    # check if node is still running, otherwise don't allow deleting it
+    running_node_names = find_running_node_names(client)
+
+    post_fix = "system" if system_folders else "user"
+    node_container_name = f"{APPNAME}-{name}-{post_fix}"
+    if node_container_name in running_node_names:
+        error(f"Node {name} is still running! Please stop the node before "
+              "deleting it.")
+        exit(1)
+
+    if not force:
+        if not q.confirm(
+            "This node will be deleted permanently including its "
+            "configuration. Are you sure?", default=False
+        ).ask():
+            info("Node will not be deleted")
+            exit(0)
+
+    # create node context
+    ctx = NodeContext(name, system_folders=system_folders)
+
+    # remove the docker volume and any temporary volumes
+    debug("Deleting docker volumes")
+    volumes = client.volumes.list()
+    for vol in volumes:
+        if vol.name.startswith(ctx.docker_volume_name):  # includes tmp volumes
+            info(f"Deleting docker volume {vol.name}")
+            vol.remove()
+        # remove docker vpn volume
+        if vol.name == ctx.docker_vpn_volume_name:
+            info(f"Deleting VPN docker volume {vol.name}")
+            vol.remove()
+
+    # remove the VPN configuration file
+    vpn_config_file = os.path.join(ctx.data_dir, 'vpn', VPN_CONFIG_FILE)
+    remove_file(vpn_config_file, 'VPN configuration')
+
+    # remove the config file
+    remove_file(ctx.config_file, 'configuration')
+
+    # remove the log file. As this process opens the log file above, the log
+    # handlers need to be closed before deleting
+    info(f"Removing log file {ctx.log_file}")
+    for handler in itertools.chain(ctx.log.handlers, ctx.log.root.handlers):
+        handler.close()
+    # remove_file(ctx.log_file, 'log')
+
+    # removes the whole folder
+    rmtree(Path(ctx.log_file.parent))
+
+    # remove the folder: if it hasn't been started yet this won't exist...
+    if Path.exists(ctx.config_dir / name):
+        rmtree(ctx.config_dir / name)

vantage6/cli/node/set_api_key.py

@@ -0,0 +1,45 @@
+import click
+import questionary as q
+
+from vantage6.common import error, info, check_config_writeable
+from vantage6.cli.context import NodeContext
+from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+from vantage6.cli.configuration_wizard import NodeConfigurationManager
+from vantage6.cli.node.common import select_node
+
+
+@click.command()
+@click.option("-n", "--name", default=None, help="Configuration name")
+@click.option("--api-key", default=None, help="New API key")
+@click.option('--system', 'system_folders', flag_value=True,
+              help="Search for configuration in system folders rather than "
+                   "user folders")
+@click.option('--user', 'system_folders', flag_value=False, default=N_FOL,
+              help="Search for configuration in user folders rather than "
+                   "system folders. This is the default")
+def cli_node_set_api_key(name: str, api_key: str,
+                         system_folders: bool) -> None:
+    """
+    Put a new API key into the node configuration file
+    """
+    # select node name
+    name = select_node(name, system_folders)
+
+    # Check that we can write in the config folder
+    if not check_config_writeable(system_folders):
+        error("Your user does not have write access to all folders. Exiting")
+        exit(1)
+
+    if not api_key:
+        api_key = q.text("Please enter your new API key:").ask()
+
+    # get configuration manager
+    ctx = NodeContext(name, system_folders=system_folders)
+    conf_mgr = NodeConfigurationManager.from_file(ctx.config_file)
+
+    # set new api key, and save the file
+    ctx.config['api_key'] = api_key
+    conf_mgr.put(ctx.config)
+    conf_mgr.save(ctx.config_file)
+    info("Your new API key has been uploaded to the config file "
+         f"{ctx.config_file}.")