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

vantage6/cli/configuration_wizard.py

@@ -18,6 +18,7 @@ from vantage6.common.globals import (
 
 from vantage6.cli.config import CliConfig
 from vantage6.cli.configuration_manager import (
+    AlgorithmStoreConfigurationManager,
     NodeConfigurationManager,
     ServerConfigurationManager,
 )
@@ -283,7 +284,9 @@ def _get_allowed_algorithm_stores() -> list[str]:
     return allowed_algorithm_stores
 
 
-def _get_common_server_config(instance_type: InstanceType, instance_name: str) -> dict:
+def _add_common_server_config(
+    config: dict, instance_type: InstanceType, instance_name: str
+) -> dict:
     """
     Part of the questionaire that is common to all server types (vantage6
     server and algorithm store server).
@@ -300,52 +303,26 @@ def _get_common_server_config(instance_type: InstanceType, instance_name: str) -
     dict
         Dictionary with new (partial) server configuration
     """
-    config = q.unsafe_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": (
-                    str(Ports.DEV_SERVER)
-                    if instance_type == InstanceType.SERVER
-                    else str(Ports.DEV_ALGO_STORE)
-                ),
-            },
-        ]
+    backend_config = (
+        config["server"] if instance_type == InstanceType.SERVER else config["store"]
     )
 
-    config.update(
-        q.unsafe_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"],
-                },
-            ]
-        )
-    )
+    backend_config["port"] = q.text(
+        "Enter port to which the server listens:",
+        default=(
+            str(Ports.DEV_SERVER)
+            if instance_type == InstanceType.SERVER
+            else str(Ports.DEV_ALGO_STORE)
+        ),
+    ).unsafe_ask()
 
     res = q.select(
         "Which level of logging would you like?",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NOTSET"],
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
     ).unsafe_ask()
 
-    config["logging"] = {
+    backend_config["logging"] = {
         "level": res,
         "file": f"{instance_name}.log",
         "use_console": True,
@@ -359,25 +336,42 @@ def _get_common_server_config(instance_type: InstanceType, instance_name: str) -
             {"name": "socketio.server", "level": "warning"},
             {"name": "engineio.server", "level": "warning"},
             {"name": "sqlalchemy.engine", "level": "warning"},
-            {"name": "requests_oauthlib.oauth2_session", "level": "warning"},
         ],
     }
 
-    config["api_path"] = DEFAULT_API_PATH
+    backend_config["api_path"] = DEFAULT_API_PATH
 
-    return config
+    # === Database settings ===
+    config["database"]["volumePath"] = q.text(
+        "Where is your server database located on the host machine?",
+        default=f"{Path.cwd()}/dev/.db/db_pv_server",
+    ).unsafe_ask()
 
+    config["database"]["k8sNodeName"] = q.text(
+        "What is the name of the k8s node where the databases are running?",
+        default="docker-desktop",
+    ).unsafe_ask()
 
-def server_configuration_questionaire(
-    instance_name: str,
-) -> dict[str, Any]:
+    is_production = q.confirm(
+        "Do you want to use production settings for this server? If not, the server will "
+        "be configured to be more suitable for development or testing purposes.",
+        default=True,
+    ).unsafe_ask()
+
+    if is_production:
+        config = _add_production_server_config(config)
+
+    return config, is_production
+
+
+def server_configuration_questionaire(instance_name: str) -> dict[str, Any]:
     """
     Kubernetes-specific questionnaire to generate Helm values for server.
 
     Parameters
     ----------
     instance_name : str
-        Name of the server instance
+        Name of the server instance.
 
     Returns
     -------
@@ -389,14 +383,23 @@ def server_configuration_questionaire(
     kube_namespace = cli_config.get_last_namespace()
 
     # Initialize config with basic structure
-    config = {"server": {}, "database": {}, "ui": {}}
+    config = {"server": {}, "database": {}, "ui": {}, "rabbitmq": {}}
 
+    config, is_production = _add_common_server_config(
+        config, InstanceType.SERVER, instance_name
+    )
+    if not is_production:
+        config["server"]["jwt"] = {
+            "secret": "constant_development_secret`",
+        }
+        config["server"]["dev"] = {
+            "host_uri": "host.docker.internal",
+            "store_in_local_cluster": True,
+        }
+
+    # TODO v5+ these should be removed, latest should usually be used so question is
+    # not needed. However, for now we want to specify alpha/beta images.
     # === Server settings ===
-    config["server"]["description"] = q.text(
-        "Enter a human-readable description:",
-        default=f"Vantage6 server {instance_name}",
-    ).unsafe_ask()
-
     config["server"]["image"] = q.text(
         "Server Docker image:",
         default="harbor2.vantage6.ai/infrastructure/server:latest",
@@ -408,29 +411,36 @@ def server_configuration_questionaire(
         default="harbor2.vantage6.ai/infrastructure/ui:latest",
     ).unsafe_ask()
 
-    # === Database settings ===
-    config["database"]["volumePath"] = q.text(
-        "Where is your server database located on the host machine?",
-        default=f"{Path.cwd()}/dev/.db/db_pv_server",
-    ).unsafe_ask()
-
-    config["database"]["k8sNodeName"] = q.text(
-        "What is the name of the k8s node where the databases are running?",
-        default="docker-desktop",
-    ).unsafe_ask()
-
     # === Keycloak settings ===
     keycloak_url = f"http://vantage6-auth-keycloak.{kube_namespace}.svc.cluster.local"
     config["server"]["keycloakUrl"] = keycloak_url
 
-    # === Other settings ===
-    log_level = q.select(
-        "Which level of logging would you like?",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
-        default="INFO",
-    ).unsafe_ask()
+    return config
+
+
+def _add_production_server_config(config: dict) -> dict:
+    """
+    Add the production server configuration to the config
+
+    Parameters
+    ----------
+    config : dict
+        The config to add the production server configuration to
 
-    config["server"]["logging"] = {"level": log_level}
+    Returns
+    -------
+    dict
+        The config with the production server configuration added
+    """
+    info("For production environments, it is recommended to use an external database.")
+    info("Please provide the URI of the external database.")
+    info("Example: postgresql://username:password@localhost:5432/vantage6")
+
+    config["database"]["external"] = True
+    config["database"]["uri"] = q.text(
+        "Database URI:",
+        default="postgresql://vantage6:vantage6@localhost:5432/vantage6",
+    ).unsafe_ask()
 
     return config
 
@@ -450,7 +460,17 @@ def algo_store_configuration_questionaire(instance_name: str) -> dict:
     dict
         Dictionary with the new server configuration
     """
-    config = _get_common_server_config(InstanceType.ALGORITHM_STORE, instance_name)
+    config = {"store": {}, "database": {}}
+
+    config, is_production = _add_common_server_config(
+        config, InstanceType.ALGORITHM_STORE, instance_name
+    )
+    if not is_production:
+        config["store"]["dev"] = {
+            "host_uri": "host.docker.internal",
+            "disable_review": True,
+            "review_own_algorithm": True,
+        }
 
     default_v6_server_uri = f"http://localhost:{Ports.DEV_SERVER}{DEFAULT_API_PATH}"
     default_root_username = "admin"
@@ -472,6 +492,7 @@ def algo_store_configuration_questionaire(instance_name: str) -> dict:
     }
 
     # ask about openness of the algorithm store
+    config["policies"] = {}
     is_open = q.confirm(
         "Do you want to open the algorithm store to the public? This will allow anyone "
         "to view the algorithms, but they cannot modify them.",
@@ -523,11 +544,9 @@ def configuration_wizard(
         config = node_configuration_questionaire(dirs, instance_name)
     elif type_ == InstanceType.SERVER:
         conf_manager = ServerConfigurationManager
-        config = server_configuration_questionaire(
-            instance_name=instance_name,
-        )
+        config = server_configuration_questionaire(instance_name)
     else:
-        conf_manager = ServerConfigurationManager
+        conf_manager = AlgorithmStoreConfigurationManager
         config = algo_store_configuration_questionaire(instance_name)
 
     # in the case of an environment we need to add it to the current

vantage6/cli/context/algorithm_store.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 from vantage6.common.globals import APPNAME, InstanceType
 
 from vantage6.cli import __version__
-from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.configuration_manager import AlgorithmStoreConfigurationManager
 from vantage6.cli.context.base_server import BaseServerContext
 from vantage6.cli.globals import (
     DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
-    AlgoStoreGlobals,
     ServerType,
 )
 
@@ -25,7 +24,7 @@ class AlgorithmStoreContext(BaseServerContext):
         System wide or user configuration, by default S_FOL
     """
 
-    INST_CONFIG_MANAGER = ServerConfigurationManager
+    INST_CONFIG_MANAGER = AlgorithmStoreConfigurationManager
 
     def __init__(self, instance_name: str, system_folders: bool = S_FOL):
         super().__init__(
@@ -44,7 +43,7 @@ class AlgorithmStoreContext(BaseServerContext):
         str
             string representation of the database uri
         """
-        return super().get_database_uri(AlgoStoreGlobals.DB_URI_ENV_VAR.value)
+        return super().get_database_uri()
 
     @property
     def docker_container_name(self) -> str:
@@ -60,7 +59,7 @@ class AlgorithmStoreContext(BaseServerContext):
 
     @classmethod
     def from_external_config_file(
-        cls, path: str, system_folders: bool = S_FOL
+        cls, path: str, system_folders: bool = S_FOL, in_container: bool = False
     ) -> AlgorithmStoreContext:
         """
         Create a server context from an external configuration file. External
@@ -73,6 +72,8 @@ class AlgorithmStoreContext(BaseServerContext):
             Path of the configuration file
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
+        in_container : bool, optional
+            Whether the application is running inside a container, by default False
 
         Returns
         -------
@@ -82,8 +83,8 @@ class AlgorithmStoreContext(BaseServerContext):
         return super().from_external_config_file(
             path,
             ServerType.ALGORITHM_STORE,
-            AlgoStoreGlobals.CONFIG_NAME_ENV_VAR.value,
             system_folders,
+            in_container,
         )
 
     @classmethod

vantage6/cli/context/base_server.py

@@ -5,6 +5,7 @@ import os.path
 from sqlalchemy.engine.url import make_url
 
 from vantage6.common.context import AppContext
+
 from vantage6.cli.globals import (
     DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
     ServerType,
@@ -19,35 +20,29 @@ class BaseServerContext(AppContext):
     in common.
     """
 
-    def get_database_uri(self, db_env_var: str) -> str:
+    def get_database_uri(self) -> str:
         """
         Obtain the database uri from the environment or the configuration.
 
-        Parameters
-        ----------
-        db_env_var : str
-            Name of the environment variable that contains the database uri
-
         Returns
         -------
         str
             string representation of the database uri
         """
-        uri = os.environ.get(db_env_var) or self.config["uri"]
-        url = make_url(uri)
-
-        if url.host is None and not os.path.isabs(url.database):
-            # We're dealing with a relative path here of a local database, when
-            # we're running the server outside of docker. Therefore we need to
-            # prepend the data directory to the database name, but after the
-            # driver name (e.g. sqlite:////db.sqlite ->
-            # sqlite:////data_dir>/db.sqlite)
-
-            # find index of database name
-            idx_db_name = str(url).find(url.database)
-
-            # add the datadir to the right location in the database uri
-            return str(url)[:idx_db_name] + str(self.data_dir / url.database)
+        # within container, the uri is set in the config file
+        if self.in_container:
+            return self.config.get("uri")
+
+        # outside container, the uri is set in the values.yaml in a different location
+        is_db_external = self.config.get("database", {}).get("external", False)
+        if is_db_external:
+            uri = self.config["database"]["uri"]
+        else:
+            db_conf = self.config["database"]
+            uri = (
+                f"postgresql://{db_conf['username']}:{db_conf['password']}@"
+                f"{self.helm_release_name}-postgres-service:5432/{db_conf['name']}"
+            )
 
         return uri
 
@@ -56,8 +51,8 @@ class BaseServerContext(AppContext):
         cls,
         path: str,
         server_type: ServerType,
-        config_name_env_var: str,
         system_folders: bool = S_FOL,
+        in_container: bool = False,
     ) -> BaseServerContext:
         """
         Create a server context from an external configuration file. External
@@ -70,20 +65,17 @@ class BaseServerContext(AppContext):
             Path of the configuration file
         server_type : ServerType
             Type of server, either 'server' or 'algorithm-store'
-        config_name_env_var : str
-            Name of the environment variable that contains the name of the
-            configuration
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
+        in_container : bool, optional
+            Whether the application is running inside a container, by default False
 
         Returns
         -------
         ServerContext
             Server context object
         """
-        cls = super().from_external_config_file(path, server_type, system_folders)
-        # if we are running a server in a docker container, the name is taken
-        # from the name of the config file (which is usually a default). Get
-        # the config name from environment if it is given.
-        cls.name = os.environ.get(config_name_env_var) or cls.name
+        cls = super().from_external_config_file(
+            path, server_type, system_folders, in_container
+        )
         return cls

vantage6/cli/context/node.py

@@ -25,6 +25,8 @@ class NodeContext(AppContext):
         _description_, by default N_FOL
     config_file : str, optional
         _description_, by default None
+    in_container : bool, optional
+        Whether the application is running inside a container, by default False
     """
 
     # The server configuration manager is aware of the structure of the server
@@ -38,6 +40,7 @@ class NodeContext(AppContext):
         config_file: str = None,
         print_log_header: bool = True,
         logger_prefix: str = "",
+        in_container: bool = False,
     ):
         super().__init__(
             InstanceType.NODE,
@@ -46,6 +49,7 @@ class NodeContext(AppContext):
             config_file=config_file,
             print_log_header=print_log_header,
             logger_prefix=logger_prefix,
+            in_container=in_container,
         )
         if print_log_header:
             self.log.info("vantage6 version '%s'", __version__)

vantage6/cli/context/server.py

@@ -10,7 +10,6 @@ from vantage6.cli.context.base_server import BaseServerContext
 from vantage6.cli.globals import (
     DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
     PROMETHEUS_DIR,
-    ServerGlobals,
     ServerType,
 )
 
@@ -32,9 +31,17 @@ class ServerContext(BaseServerContext):
     # configuration file and makes sure only valid configuration can be loaded.
     INST_CONFIG_MANAGER = ServerConfigurationManager
 
-    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
+    def __init__(
+        self,
+        instance_name: str,
+        system_folders: bool = S_FOL,
+        in_container: bool = False,
+    ):
         super().__init__(
-            InstanceType.SERVER, instance_name, system_folders=system_folders
+            InstanceType.SERVER,
+            instance_name,
+            system_folders=system_folders,
+            in_container=in_container,
         )
         self.log.info("vantage6 version '%s'", __version__)
 
@@ -47,7 +54,7 @@ class ServerContext(BaseServerContext):
         str
             string representation of the database uri
         """
-        return super().get_database_uri(ServerGlobals.DB_URI_ENV_VAR.value)
+        return super().get_database_uri()
 
     @property
     def docker_container_name(self) -> str:
@@ -59,7 +66,7 @@ class ServerContext(BaseServerContext):
         str
             Server's docker container name
         """
-        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.V6SERVER}"
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.V6SERVER.value}"
 
     @property
     def prometheus_container_name(self) -> str:
@@ -87,7 +94,7 @@ class ServerContext(BaseServerContext):
 
     @classmethod
     def from_external_config_file(
-        cls, path: str, system_folders: bool = S_FOL
+        cls, path: str, system_folders: bool = S_FOL, in_container: bool = False
     ) -> ServerContext:
         """
         Create a server context from an external configuration file. External
@@ -100,6 +107,8 @@ class ServerContext(BaseServerContext):
             Path of the configuration file
         system_folders : bool, optional
             System wide or user configuration, by default S_FOL
+        in_container : bool, optional
+            Whether the application is running inside a container, by default False
 
         Returns
         -------
@@ -109,8 +118,8 @@ class ServerContext(BaseServerContext):
         return super().from_external_config_file(
             path,
             ServerType.V6SERVER,
-            ServerGlobals.CONFIG_NAME_ENV_VAR.value,
             system_folders,
+            in_container,
         )
 
     @classmethod

vantage6/cli/globals.py

@@ -56,6 +56,12 @@ DEFAULT_PROMETHEUS_IMAGE = "prom/prometheus"
 PROMETHEUS_CONFIG = "prometheus.yml"
 PROMETHEUS_DIR = "prometheus"
 
+# template folder
+TEMPLATE_FOLDER = PACKAGE_FOLDER / APPNAME / "cli" / "template"
+SERVER_TEMPLATE_FILE = "server_config.j2"
+NODE_TEMPLATE_FILE = "node_config.j2"
+ALGO_STORE_TEMPLATE_FILE = "algo_store_config.j2"
+
 
 # datasets included in the nodes of the dev network
 class DefaultDatasets(StrEnumBase):
@@ -72,15 +78,10 @@ class ServerType(StrEnumBase):
     ALGORITHM_STORE = "algorithm-store"
 
 
-class ServerGlobals(StrEnumBase):
-    """Enum containing server environment variables"""
-
-    DB_URI_ENV_VAR = "VANTAGE6_DB_URI"
-    CONFIG_NAME_ENV_VAR = "VANTAGE6_CONFIG_NAME"
-
-
-class AlgoStoreGlobals(StrEnumBase):
-    """Enum containing algorithm store environment variables"""
+class ChartName(StrEnumBase):
+    """Enum containing chart names"""
 
-    DB_URI_ENV_VAR = "VANTAGE6_ALGO_STORE_DB_URI"
-    CONFIG_NAME_ENV_VAR = "VANTAGE6_ALGO_STORE_CONFIG_NAME"
+    SERVER = "server"
+    ALGORITHM_STORE = "store"
+    NODE = "node"
+    AUTH = "auth"

vantage6/cli/node/common/__init__.py

@@ -109,6 +109,6 @@ def find_running_node_names(client: docker.DockerClient) -> list[str]:
         List of names of running nodes
     """
     running_nodes = client.containers.list(
-        filters={"label": f"{APPNAME}-type={InstanceType.NODE}"}
+        filters={"label": f"{APPNAME}-type={InstanceType.NODE.value}"}
     )
     return [node.name for node in running_nodes]

vantage6/cli/node/create_private_key.py

@@ -1,19 +1,20 @@
 from pathlib import Path
+
 import click
 from colorama import Fore, Style
 
 from vantage6.common import (
-    warning,
+    bytes_to_base64s,
+    debug,
     error,
     info,
-    debug,
-    bytes_to_base64s,
+    warning,
 )
-
 from vantage6.common.encryption import RSACryptor
+
 from vantage6.cli.context.node 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
+from vantage6.cli.node.common import create_client_and_authenticate, select_node
 
 
 @click.command()
@@ -28,7 +29,7 @@ from vantage6.cli.node.common import select_node, create_client_and_authenticate
     "--system",
     "system_folders",
     flag_value=True,
-    help="Search for configuration in system folders rather than " "user folders",
+    help="Search for configuration in system folders rather than user folders",
 )
 @click.option(
     "--user",
@@ -137,6 +138,8 @@ def cli_node_create_private_key(
 
     # update config file
     info("Updating configuration")
+    # TODO v5+ this probably messes up the current config as the template is used...
+    # Fix when reimplementing this in v5
     ctx.config["encryption"]["private_key"] = str(file_)
     ctx.config_manager.put(ctx.config)
     ctx.config_manager.save(ctx.config_file)

vantage6/cli/node/set_api_key.py

@@ -1,10 +1,11 @@
 import click
 import questionary as q
 
-from vantage6.common import error, info, ensure_config_dir_writable
+from vantage6.common import ensure_config_dir_writable, error, info
+
+from vantage6.cli.configuration_wizard import NodeConfigurationManager
 from vantage6.cli.context.node 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
 
 
@@ -15,7 +16,7 @@ from vantage6.cli.node.common import select_node
     "--system",
     "system_folders",
     flag_value=True,
-    help="Search for configuration in system folders rather than " "user folders",
+    help="Search for configuration in system folders rather than user folders",
 )
 @click.option(
     "--user",
@@ -50,6 +51,8 @@ def cli_node_set_api_key(name: str, api_key: str, system_folders: bool) -> None:
 
     # set new api key, and save the file
     ctx.config["api_key"] = api_key
+    # TODO v5+ this probably messes up the current config as the template is used...
+    # Fix when reimplementing this in v5
     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}.")
+    info(f"Your new API key has been uploaded to the config file {ctx.config_file}.")

vantage6/cli/node/start.py

@@ -77,7 +77,7 @@ def cli_node_start(
 
     # check that this node is not already running
     running_nodes = docker_client.containers.list(
-        filters={"label": f"{APPNAME}-type={InstanceType.NODE}"}
+        filters={"label": f"{APPNAME}-type={InstanceType.NODE.value}"}
     )
 
     suffix = "system" if system_folders else "user"

vantage6/cli/node/stop.py

@@ -1,21 +1,21 @@
 import time
+
 import click
-import questionary as q
 import docker
-
+import questionary as q
 from colorama import Fore, Style
-from vantage6.cli.context import NodeContext
 
-from vantage6.common import warning, error, info
-from vantage6.common.globals import APPNAME
+from vantage6.common import error, info, warning
 from vantage6.common.docker.addons import (
     check_docker_running,
     delete_volume_if_exists,
     get_server_config_name,
     stop_container,
 )
-from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+from vantage6.common.globals import APPNAME
 
+from vantage6.cli.context import NodeContext
+from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
 from vantage6.cli.node.common import find_running_node_names
 
 
@@ -25,7 +25,7 @@ from vantage6.cli.node.common import find_running_node_names
     "--system",
     "system_folders",
     flag_value=True,
-    help="Search for configuration in system folders instead of " "user folders",
+    help="Search for configuration in system folders instead of user folders",
 )
 @click.option(
     "--user",