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

vantage6/cli/configuration_wizard.py

@@ -3,14 +3,16 @@ import questionary as q
 from pathlib import Path
 
 from vantage6.common import generate_apikey
-from vantage6.common.globals import DATABASE_TYPES
+from vantage6.common.globals import DATABASE_TYPES, InstanceType
 from vantage6.common.client.node_client import NodeClient
+from vantage6.common.context import AppContext
 from vantage6.common import error, warning
-from vantage6.cli.context import NodeContext, ServerContext
+from vantage6.cli.context import select_context_class
 from vantage6.cli.configuration_manager import (
     NodeConfigurationManager,
-    ServerConfigurationManager
+    ServerConfigurationManager,
 )
+from vantage6.cli.globals import AlgoStoreGlobals, ServerGlobals
 
 
 def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
@@ -29,75 +31,69 @@ def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
     dict
         Dictionary with the new node configuration
     """
-    config = q.prompt([
-        {
-            "type": "text",
-            "name": "api_key",
-            "message": "Enter given api-key:"
-        },
-        {
-            "type": "text",
-            "name": "server_url",
-            "message": "The base-URL of the server:",
-            "default": "http://localhost"
-        },
-        {
-            "type": "text",
-            "name": "port",
-            "message": "Enter port to which the server listens:",
-            "default": "5000"
-        },
-        {
-            "type": "text",
-            "name": "api_path",
-            "message": "Path of the api:",
-            "default": "/api"
-        },
-        {
-            "type": "text",
-            "name": "task_dir",
-            "message": "Task directory path:",
-            "default": str(dirs["data"])
-        }
-    ])
-
-    config["databases"] = list()
-    while q.confirm("Do you want to add a database?").ask():
-        db_label = q.prompt([
+    config = q.prompt(
+        [
+            {"type": "text", "name": "api_key", "message": "Enter given api-key:"},
             {
                 "type": "text",
-                "name": "label",
-                "message": "Enter unique label for the database:",
-                "default": "default"
-            }
-        ])
-        db_path = q.prompt([
+                "name": "server_url",
+                "message": "The base-URL of the server:",
+                "default": "http://localhost",
+            },
+            {
+                "type": "text",
+                "name": "port",
+                "message": "Enter port to which the server listens:",
+                "default": "5000",
+            },
             {
                 "type": "text",
-                "name": "uri",
-                "message": "Database URI:"
-            }
-        ])
+                "name": "api_path",
+                "message": "Path of the api:",
+                "default": "/api",
+            },
+            {
+                "type": "text",
+                "name": "task_dir",
+                "message": "Task directory path:",
+                "default": str(dirs["data"]),
+            },
+        ]
+    )
+
+    config["databases"] = list()
+    while q.confirm("Do you want to add a database?").ask():
+        db_label = q.prompt(
+            [
+                {
+                    "type": "text",
+                    "name": "label",
+                    "message": "Enter unique label for the database:",
+                    "default": "default",
+                }
+            ]
+        )
+        db_path = q.prompt(
+            [{"type": "text", "name": "uri", "message": "Database URI:"}]
+        )
         db_type = q.select("Database type:", choices=DATABASE_TYPES).ask()
 
         config["databases"].append(
-            {
-                "label": db_label.get("label"),
-                "uri": db_path.get("uri"),
-                "type": db_type
-            }
+            {"label": db_label.get("label"), "uri": db_path.get("uri"), "type": db_type}
         )
 
-    res = q.select("Which level of logging would you like?",
-                   choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL",
-                            "NOTSET"]).ask()
+    res = q.select(
+        "Which level of logging would you like?",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NOTSET"],
+    ).ask()
 
     is_add_vpn = q.confirm(
-        "Do you want to connect to a VPN server?", default=False).ask()
+        "Do you want to connect to a VPN server?", default=False
+    ).ask()
     if is_add_vpn:
-        config['vpn_subnet'] = q.text(
+        config["vpn_subnet"] = q.text(
             message="Subnet of the VPN server you want to connect to:",
-            default='10.76.0.0/16'
+            default="10.76.0.0/16",
         ).ask()
 
     config["logging"] = {
@@ -113,19 +109,20 @@ def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
             {"name": "engineio.client", "level": "warning"},
             {"name": "docker.utils.config", "level": "warning"},
             {"name": "docker.auth", "level": "warning"},
-        ]
+        ],
     }
 
     # Check if we can login to the server to retrieve collaboration settings
-    client = NodeClient(config['server_url'], config['port'],
-                        config['api_path'])
+    client = NodeClient(config["server_url"], config["port"], config["api_path"])
     try:
-        client.authenticate(config['api_key'])
+        client.authenticate(config["api_key"])
     except Exception as e:
         error(f"Could not authenticate with server: {e}")
         error("Please check (1) your API key and (2) if your server is online")
-        warning("If you continue, you should provide your collaboration "
-                "settings manually.")
+        warning(
+            "If you continue, you should provide your collaboration "
+            "settings manually."
+        )
         if q.confirm("Do you want to abort?", default=True).ask():
             exit(0)
 
@@ -134,140 +131,102 @@ def node_configuration_questionaire(dirs: dict, instance_name: str) -> dict:
         # TODO when we build collaboration policies, update this to provide
         # the node admin with a list of all policies, and whether or not
         # to accept them
-        q.confirm(f"Encryption is {'enabled' if encryption else 'disabled'}"
-                  f" for this collaboration. Accept?", default=True).ask()
+        q.confirm(
+            f"Encryption is {'enabled' if encryption else 'disabled'}"
+            f" for this collaboration. Accept?",
+            default=True,
+        ).ask()
     else:
         encryption = q.confirm("Enable encryption?", default=True).ask()
 
-    private_key = "" if not encryption else \
-        q.text("Path to private key file:").ask()
+    private_key = "" if not encryption else q.text("Path to private key file:").ask()
 
-    config["encryption"] = {
-        "enabled": encryption == "true",
-        "private_key": private_key
-    }
+    config["encryption"] = {"enabled": encryption == "true", "private_key": private_key}
 
     return config
 
 
-def server_configuration_questionaire(instance_name: str) -> dict:
+def _get_common_server_config(
+    instance_type: InstanceType, instance_name: str, include_api_path: bool = True
+) -> dict:
     """
-    Questionary to generate a config file for the node instance.
+    Part of the questionaire that is common to all server types (vantage6
+    server and algorithm store server).
 
     Parameters
     ----------
+    instance_type : InstanceType
+        Type of server instance.
     instance_name : str
-        Name of the node instance.
+        Name of the server instance.
+    include_api_path : bool
+        Whether to include the api path in the questionaire.
 
     Returns
     -------
     dict
-        Dictionary with the new server configuration
+        Dictionary with new (partial) server configuration
     """
-
-    config = q.prompt([
-        {
-            "type": "text",
-            "name": "description",
-            "message": "Enter a human-readable description:"
-        },
-        {
-            "type": "text",
-            "name": "ip",
-            "message": "ip:",
-            "default": "0.0.0.0"
-        },
-        {
-            "type": "text",
-            "name": "port",
-            "message": "Enter port to which the server listens:",
-            "default": "5000"
-        },
-        {
-            "type": "text",
-            "name": "api_path",
-            "message": "Path of the api:",
-            "default": "/api"
-        },
-        {
-            "type": "text",
-            "name": "uri",
-            "message": "Database URI:",
-            "default": "sqlite:///default.sqlite"
-        },
-        {
-            "type": "select",
-            "name": "allow_drop_all",
-            "message": "Allowed to drop all tables: ",
-            "choices": ["True", "False"]
-        }
-    ])
-
-    constant_jwt_secret = q.confirm("Do you want a constant JWT secret?").ask()
-    if constant_jwt_secret:
-        config["jwt_secret_key"] = generate_apikey()
-
-    res = q.select("Which level of logging would you like?",
-                   choices=["DEBUG", "INFO", "WARNING", "ERROR",
-                            "CRITICAL", "NOTSET"]).ask()
-
-    is_mfa = q.confirm(
-        "Do you want to enforce two-factor authentication?"
-    ).ask()
-    if is_mfa:
-        config['two_factor_auth'] = is_mfa
-
-    is_add_vpn = q.confirm(
-        "Do you want to add a VPN server?", default=False).ask()
-    if is_add_vpn:
-        vpn_config = q.prompt([
-            {
-                "type": "text",
-                "name": "url",
-                "message": "VPN server URL:",
-            },
+    config = q.prompt(
+        [
             {
                 "type": "text",
-                "name": "portal_username",
-                "message": "VPN portal username:",
-            },
-            {
-                "type": "password",
-                "name": "portal_userpass",
-                "message": "VPN portal password:",
+                "name": "description",
+                "message": "Enter a human-readable description:",
             },
+            {"type": "text", "name": "ip", "message": "ip:", "default": "0.0.0.0"},
             {
                 "type": "text",
-                "name": "client_id",
-                "message": "VPN client username:",
+                "name": "port",
+                "message": "Enter port to which the server listens:",
+                "default": (
+                    # Note that .value is required in YAML to get proper str value
+                    ServerGlobals.PORT.value
+                    if instance_type == InstanceType.SERVER
+                    else AlgoStoreGlobals.PORT.value
+                ),
             },
-            {
-                "type": "password",
-                "name": "client_secret",
-                "message": "VPN client password:",
-            },
-            {
-                "type": "text",
-                "name": "redirect_url",
-                "message": "Redirect url (should be local address of server)",
-                "default": "http://localhost"
-            }
-        ])
-        config['vpn_server'] = vpn_config
-
-    is_add_rabbitmq = q.confirm(
-        "Do you want to add a RabbitMQ message queue?").ask()
-    if is_add_rabbitmq:
-        rabbit_uri = q.text(
-            message='Enter the URI for your RabbitMQ:'
-        ).ask()
-        run_rabbit_locally = q.confirm(
-            "Do you want to run RabbitMQ locally? (Use only for testing)"
-        ).ask()
-        config['rabbitmq'] = {
-            'uri': rabbit_uri,
-            'start_with_server': run_rabbit_locally
-        }
+        ]
+    )
+
+    # TODO v5+ remove api_path. It complicates configuration
+    if include_api_path:
+        config.update(
+            q.prompt(
+                [
+                    {
+                        "type": "text",
+                        "name": "api_path",
+                        "message": "Path of the api:",
+                        "default": "/api",
+                    }
+                ]
+            )
+        )
+
+    config.update(
+        q.prompt(
+            [
+                {
+                    "type": "text",
+                    "name": "uri",
+                    "message": "Database URI:",
+                    "default": "sqlite:///default.sqlite",
+                },
+                {
+                    "type": "select",
+                    "name": "allow_drop_all",
+                    "message": "Allowed to drop all tables: ",
+                    "choices": ["True", "False"],
+                },
+            ]
+        )
+    )
+
+    res = q.select(
+        "Which level of logging would you like?",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NOTSET"],
+    ).ask()
 
     config["logging"] = {
         "level": res,
@@ -284,21 +243,123 @@ def server_configuration_questionaire(instance_name: str) -> dict:
             {"name": "engineio.server", "level": "warning"},
             {"name": "sqlalchemy.engine", "level": "warning"},
             {"name": "requests_oauthlib.oauth2_session", "level": "warning"},
-        ]
+        ],
     }
 
     return config
 
 
-def configuration_wizard(type_: str, instance_name: str,
-                         system_folders: bool) -> Path:
+def server_configuration_questionaire(instance_name: str) -> dict:
+    """
+    Questionary to generate a config file for the server instance.
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the server instance.
+
+    Returns
+    -------
+    dict
+        Dictionary with the new server configuration
+    """
+
+    config = _get_common_server_config(
+        InstanceType.SERVER, instance_name, include_api_path=True
+    )
+
+    constant_jwt_secret = q.confirm("Do you want a constant JWT secret?").ask()
+    if constant_jwt_secret:
+        config["jwt_secret_key"] = generate_apikey()
+
+    is_mfa = q.confirm("Do you want to enforce two-factor authentication?").ask()
+    if is_mfa:
+        config["two_factor_auth"] = is_mfa
+
+    is_add_vpn = q.confirm("Do you want to add a VPN server?", default=False).ask()
+    if is_add_vpn:
+        vpn_config = q.prompt(
+            [
+                {
+                    "type": "text",
+                    "name": "url",
+                    "message": "VPN server URL:",
+                },
+                {
+                    "type": "text",
+                    "name": "portal_username",
+                    "message": "VPN portal username:",
+                },
+                {
+                    "type": "password",
+                    "name": "portal_userpass",
+                    "message": "VPN portal password:",
+                },
+                {
+                    "type": "text",
+                    "name": "client_id",
+                    "message": "VPN client username:",
+                },
+                {
+                    "type": "password",
+                    "name": "client_secret",
+                    "message": "VPN client password:",
+                },
+                {
+                    "type": "text",
+                    "name": "redirect_url",
+                    "message": "Redirect url (should be local address of server)",
+                    "default": "http://localhost",
+                },
+            ]
+        )
+        config["vpn_server"] = vpn_config
+
+    is_add_rabbitmq = q.confirm("Do you want to add a RabbitMQ message queue?").ask()
+    if is_add_rabbitmq:
+        rabbit_uri = q.text(message="Enter the URI for your RabbitMQ:").ask()
+        run_rabbit_locally = q.confirm(
+            "Do you want to run RabbitMQ locally? (Use only for testing)"
+        ).ask()
+        config["rabbitmq"] = {
+            "uri": rabbit_uri,
+            "start_with_server": run_rabbit_locally,
+        }
+
+    return config
+
+
+def algo_store_configuration_questionaire(instance_name: str) -> dict:
+    """
+    Questionary to generate a config file for the algorithm store server
+    instance.
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the server instance.
+
+    Returns
+    -------
+    dict
+        Dictionary with the new server configuration
+    """
+    config = _get_common_server_config(
+        InstanceType.ALGORITHM_STORE, instance_name, include_api_path=False
+    )
+    return config
+
+
+def configuration_wizard(
+    type_: InstanceType, instance_name: str, system_folders: bool
+) -> Path:
     """
     Create a configuration file for a node or server instance.
 
     Parameters
     ----------
-    type_ : str
-        Type of the instance. Either "node" or "server"
+    type_ : InstanceType
+        Type of the instance to create a configuration for
     instance_name : str
         Name of the instance
     system_folders : bool
@@ -310,15 +371,18 @@ def configuration_wizard(type_: str, instance_name: str,
         Path to the configuration file
     """
     # for defaults and where to save the config
-    dirs = NodeContext.instance_folders(type_, instance_name, system_folders)
+    dirs = AppContext.instance_folders(type_, instance_name, system_folders)
 
     # invoke questionaire to create configuration file
-    if type_ == "node":
+    if type_ == InstanceType.NODE:
         conf_manager = NodeConfigurationManager
         config = node_configuration_questionaire(dirs, instance_name)
-    else:
+    elif type_ == InstanceType.SERVER:
         conf_manager = ServerConfigurationManager
         config = server_configuration_questionaire(instance_name)
+    else:
+        conf_manager = ServerConfigurationManager
+        config = algo_store_configuration_questionaire(instance_name)
 
     # 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
@@ -336,15 +400,15 @@ def configuration_wizard(type_: str, instance_name: str,
     return config_file
 
 
-def select_configuration_questionaire(type_: str, system_folders: bool) -> str:
+def select_configuration_questionaire(type_: InstanceType, system_folders: bool) -> str:
     """
     Ask which configuration the user wants to use. It shows only configurations
     that are in the default folder.
 
     Parameters
     ----------
-    type_ : str
-        Type of the instance. Either "node" or "server"
+    type_ : InstanceType
+        Type of the instance to create a configuration for
     system_folders : bool
         Whether to use the system folders or not
 
@@ -353,21 +417,19 @@ def select_configuration_questionaire(type_: str, system_folders: bool) -> str:
     str
         Name of the configuration
     """
-    context = NodeContext if type_ == "node" else ServerContext
+    context = select_context_class(type_)
     configs, _ = context.available_configurations(system_folders)
 
     # each collection (file) can contain multiple configs. (e.g. test,
     # dev)
     choices = []
     for config_collection in configs:
-        choices.append(q.Choice(
-            title=f"{config_collection.name:25}",
-            value=config_collection.name
-        ))
+        choices.append(
+            q.Choice(title=f"{config_collection.name:25}", value=config_collection.name)
+        )
 
     if not choices:
         raise Exception("No configurations could be found!")
 
     # pop the question
-    return q.select("Select the configuration you want to use:",
-                    choices=choices).ask()
+    return q.select("Select the configuration you want to use:", choices=choices).ask()

vantage6/cli/context/__init__.py

@@ -0,0 +1,86 @@
+"""
+The context module in the CLI package contains the Context classes of instances
+started from the CLI, such as nodes and servers. These contexts are related to
+the host system and therefore part of the CLI package.
+
+All classes are derived from the abstract AppContext class and provide the
+vantage6 applications with naming conventions, standard file locations, and
+more.
+"""
+from colorama import Fore, Style
+
+from vantage6.common.globals import InstanceType
+from vantage6.common import error
+from vantage6.cli.context.algorithm_store import AlgorithmStoreContext
+from vantage6.cli.context.node import NodeContext
+from vantage6.cli.context.server import ServerContext
+
+
+def select_context_class(
+    type_: InstanceType,
+) -> ServerContext | NodeContext | AlgorithmStoreContext:
+    """
+    Select the context class based on the type of instance.
+
+    Parameters
+    ----------
+    type_ : InstanceType
+        The type of instance for which the context should be inserted
+
+    Returns
+    -------
+    ServerContext | NodeContext | AlgorithmStoreContext
+        Specialized subclass of AppContext for the given instance type
+
+    Raises
+    ------
+    NotImplementedError
+        If the type_ is not implemented
+    """
+    if type_ == InstanceType.SERVER:
+        return ServerContext
+    elif type_ == InstanceType.ALGORITHM_STORE:
+        return AlgorithmStoreContext
+    elif type_ == InstanceType.NODE:
+        return NodeContext
+    else:
+        raise NotImplementedError
+
+
+def get_context(
+    type_: InstanceType, name: str, system_folders: bool
+) -> ServerContext | NodeContext | AlgorithmStoreContext:
+    """
+    Load the server context from the configuration file.
+
+    Parameters
+    ----------
+    type_ : InstanceType
+        The type of instance to get the context for
+    name : str
+        Name of the instance
+    system_folders : bool
+        Wether to use system folders or if False, the user folders
+
+    Returns
+    -------
+    AppContext
+        Specialized subclass context of AppContext for the given instance type
+    """
+    ctx_class = select_context_class(type_)
+    if not ctx_class.config_exists(name, system_folders):
+        scope = "system" if system_folders else "user"
+        error(
+            f"Configuration {Fore.RED}{name}{Style.RESET_ALL} does not "
+            f"exist in the {Fore.RED}{scope}{Style.RESET_ALL} folders!"
+        )
+        exit(1)
+
+    # We do not want to log this here, we do this in the container and not on
+    # the host. We only want CLI logging here.
+    ctx_class.LOGGING_ENABLED = False
+
+    # create server context, and initialize db
+    ctx = ctx_class(name, system_folders=system_folders)
+
+    return ctx