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

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__)
@@ -146,7 +150,10 @@ class NodeContext(AppContext):
             dictionary with database names as keys and their corresponding
             paths as values.
         """
-        return self.config["databases"]
+        if self.in_container:
+            return self.config["databases"]
+        else:
+            return self.config["node"]["databases"]
 
     @property
     def docker_container_name(self) -> str:
@@ -226,19 +233,6 @@ class NodeContext(AppContext):
         self.data_dir = dirs.get("data")
         self.config_dir = dirs.get("config")
 
-    @staticmethod
-    def instance_folders(*_args, **_kwargs) -> dict:
-        """Log, data and config folders are always mounted. The node manager
-        should take care of this.
-        """
-        mnt = Path("/mnt")
-
-        return {
-            "log": mnt / "log",
-            "data": mnt / "data",
-            "config": mnt / "config",
-        }
-
     def __create_node_identifier(self) -> str:
         """
         Create a unique identifier for the node.
@@ -248,6 +242,9 @@ class NodeContext(AppContext):
         str
             Unique identifier for the node
         """
-        return hashlib.sha256(
-            os.environ.get("V6_API_KEY").encode(STRING_ENCODING)
-        ).hexdigest()[:16]
+        if self.in_container:
+            api_key = os.environ.get("V6_API_KEY")
+        else:
+            api_key = self.config["node"]["apiKey"]
+
+        return hashlib.sha256(api_key.encode(STRING_ENCODING)).hexdigest()[:16]

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,30 @@ class ServerType(StrEnumBase):
     ALGORITHM_STORE = "algorithm-store"
 
 
-class ServerGlobals(StrEnumBase):
-    """Enum containing server environment variables"""
+class ChartName(StrEnumBase):
+    """Enum containing chart names"""
+
+    SERVER = "server"
+    ALGORITHM_STORE = "store"
+    NODE = "node"
+    AUTH = "auth"
+
 
-    DB_URI_ENV_VAR = "VANTAGE6_DB_URI"
-    CONFIG_NAME_ENV_VAR = "VANTAGE6_CONFIG_NAME"
+class CLICommandName(StrEnumBase):
+    """Enum containing CLI command names"""
+
+    SERVER = "server"
+    ALGORITHM_STORE = "algorithm-store"
+    NODE = "node"
+    ALGORITHM = "algorithm"
+    TEST = "test"
+    DEV = "dev"
+    USE = "use"
 
 
-class AlgoStoreGlobals(StrEnumBase):
-    """Enum containing algorithm store environment variables"""
+class InfraComponentName(StrEnumBase):
+    """Enum containing infrastructure components"""
 
-    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"

vantage6/cli/node/attach.py

@@ -1,6 +1,7 @@
 import click
 
 from vantage6.common import info
+
 from vantage6.cli.common.utils import attach_logs
 
 

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/files.py

@@ -1,42 +1,29 @@
 import click
 
 from vantage6.common import info
+from vantage6.common.globals import InstanceType
+
+from vantage6.cli.common.decorator import click_insert_context
 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
 
 
 @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:
+@click_insert_context(type_=InstanceType.NODE)
+def cli_node_files(ctx: NodeContext) -> 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']})")
+    for db in ctx.databases["fileBased"] or []:
+        info(
+            f" - {db['name']:15} = {db['volumePath']}/{db['originalName']} "
+            f"(type: {db['type']})"
+        )
+    for db in ctx.databases["serviceBased"] or []:
+        info(f" - {db['name']:15} = {db['uri']} (type: {db['type']})")