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

vantage6/cli/context/algorithm_store.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.globals import (
+    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
+    ServerType,
+    AlgoStoreGlobals,
+)
+from vantage6.cli._version import __version__
+from vantage6.cli.context.base_server import BaseServerContext
+
+
+class AlgorithmStoreContext(BaseServerContext):
+    """
+    A context class for the algorithm store server.
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the configuration instance, corresponds to the filename
+        of the configuration file.
+    system_folders : bool, optional
+        System wide or user configuration, by default S_FOL
+    """
+
+    INST_CONFIG_MANAGER = ServerConfigurationManager
+
+    def __init__(self, instance_name: str, system_folders: bool = S_FOL):
+        super().__init__(
+            InstanceType.ALGORITHM_STORE, instance_name, system_folders=system_folders
+        )
+        self.log.info("vantage6 version '%s'", __version__)
+
+    def get_database_uri(self) -> str:
+        """
+        Obtain the database uri from the environment or the configuration. The
+        `VANTAGE6_DB_URI` environment variable is used by the Docker container,
+        but can also be set by the user.
+
+        Returns
+        -------
+        str
+            string representation of the database uri
+        """
+        return super().get_database_uri(AlgoStoreGlobals.DB_URI_ENV_VAR)
+
+    @property
+    def docker_container_name(self) -> str:
+        """
+        Name of the docker container that the server is running in.
+
+        Returns
+        -------
+        str
+            Server's docker container name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.ALGORITHM_STORE}"
+
+    @classmethod
+    def from_external_config_file(
+        cls, path: str, system_folders: bool = S_FOL
+    ) -> AlgorithmStoreContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        AlgorithmStoreContext
+            Server context object
+        """
+        return super().from_external_config_file(
+            path,
+            ServerType.ALGORITHM_STORE,
+            AlgoStoreGlobals.CONFIG_NAME_ENV_VAR,
+            system_folders,
+        )
+
+    @classmethod
+    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+        """
+        Check if a configuration file exists.
+
+        Parameters
+        ----------
+        instance_name : str
+            Name of the configuration instance, corresponds to the filename
+            of the configuration file.
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        bool
+            Whether the configuration file exists or not
+        """
+        return super().config_exists(
+            InstanceType.ALGORITHM_STORE, instance_name, system_folders
+        )
+
+    @classmethod
+    def available_configurations(
+        cls, system_folders: bool = S_FOL
+    ) -> tuple[list, list]:
+        """
+        Find all available server configurations in the default folders.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        tuple[list, list]
+            The first list contains validated configuration files, the second
+            list contains invalid configuration files.
+        """
+        return super().available_configurations(
+            InstanceType.ALGORITHM_STORE, system_folders
+        )

vantage6/cli/context/base_server.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+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,
+)
+
+
+class BaseServerContext(AppContext):
+    """
+    Base context for a vantage6 server or algorithm store server
+
+    Contains functions that the ServerContext and AlgorithmStoreContext have
+    in common.
+    """
+
+    def get_database_uri(self, db_env_var: str) -> 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)
+
+        return uri
+
+    @classmethod
+    def from_external_config_file(
+        cls,
+        path: str,
+        server_type: ServerType,
+        config_name_env_var: str,
+        system_folders: bool = S_FOL,
+    ) -> BaseServerContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            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
+
+        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
+        return cls

vantage6/cli/context/node.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import os.path
+
+from pathlib import Path
+
+from vantage6.common.context import AppContext
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import NodeConfigurationManager
+from vantage6.cli.globals import DEFAULT_NODE_SYSTEM_FOLDERS as N_FOL
+from vantage6.cli._version import __version__
+
+
+class NodeContext(AppContext):
+    """
+    Node context object for the host system.
+
+    See DockerNodeContext for the node instance mounts when running as a
+    dockerized service.
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the configuration instance, corresponds to the filename
+        of the configuration file.
+    system_folders : bool, optional
+        _description_, by default N_FOL
+    config_file : str, optional
+        _description_, by default None
+    """
+
+    # The server configuration manager is aware of the structure of the server
+    # configuration file and makes sure only valid configuration can be loaded.
+    INST_CONFIG_MANAGER = NodeConfigurationManager
+
+    def __init__(
+        self, instance_name: str, system_folders: bool = N_FOL, config_file: str = None
+    ):
+        super().__init__(InstanceType.NODE, instance_name, system_folders, config_file)
+        self.log.info("vantage6 version '%s'", __version__)
+
+    @classmethod
+    def from_external_config_file(
+        cls, path: str, system_folders: bool = N_FOL
+    ) -> NodeContext:
+        """
+        Create a node context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        system_folders : bool, optional
+            System wide or user configuration, by default N_FOL
+
+        Returns
+        -------
+        NodeContext
+            Node context object
+        """
+        return super().from_external_config_file(
+            path, InstanceType.NODE, system_folders
+        )
+
+    @classmethod
+    def config_exists(cls, instance_name: str, system_folders: bool = N_FOL) -> bool:
+        """
+        Check if a configuration file exists.
+
+        Parameters
+        ----------
+        instance_name : str
+            Name of the configuration instance, corresponds to the filename
+            of the configuration file.
+        system_folders : bool, optional
+            System wide or user configuration, by default N_FOL
+
+        Returns
+        -------
+        bool
+            Whether the configuration file exists or not
+        """
+        return super().config_exists(
+            InstanceType.NODE, instance_name, system_folders=system_folders
+        )
+
+    @classmethod
+    def available_configurations(
+        cls, system_folders: bool = N_FOL
+    ) -> tuple[list, list]:
+        """
+        Find all available server configurations in the default folders.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration, by default N_FOL
+
+        Returns
+        -------
+        tuple[list, list]
+            The first list contains validated configuration files, the second
+            list contains invalid configuration files.
+        """
+        return super().available_configurations(InstanceType.NODE, system_folders)
+
+    @staticmethod
+    def type_data_folder(system_folders: bool = N_FOL) -> Path:
+        """
+        Obtain OS specific data folder where to store node specific data.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration
+
+        Returns
+        -------
+        Path
+            Path to the data folder
+        """
+        return AppContext.type_data_folder(InstanceType.NODE, system_folders)
+
+    @property
+    def databases(self) -> dict:
+        """
+        Dictionary of local databases that are available for this node.
+
+        Returns
+        -------
+        dict
+            dictionary with database names as keys and their corresponding
+            paths as values.
+        """
+        return self.config["databases"]
+
+    @property
+    def docker_container_name(self) -> str:
+        """
+        Docker container name of the node.
+
+        Returns
+        -------
+        str
+            Node's Docker container name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}"
+
+    @property
+    def docker_network_name(self) -> str:
+        """
+        Private Docker network name which is unique for this node.
+
+        Returns
+        -------
+        str
+            Docker network name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-net"
+
+    @property
+    def docker_volume_name(self) -> str:
+        """
+        Docker volume in which task data is stored. In case a file based
+        database is used, this volume contains the database file as well.
+
+        Returns
+        -------
+        str
+            Docker volume name
+        """
+        return os.environ.get("DATA_VOLUME_NAME", f"{self.docker_container_name}-vol")
+
+    @property
+    def docker_vpn_volume_name(self) -> str:
+        """
+        Docker volume in which the VPN configuration is stored.
+
+        Returns
+        -------
+        str
+            Docker volume name
+        """
+        return os.environ.get(
+            "VPN_VOLUME_NAME", f"{self.docker_container_name}-vpn-vol"
+        )
+
+    @property
+    def docker_ssh_volume_name(self) -> str:
+        """
+        Docker volume in which the SSH configuration is stored.
+
+        Returns
+        -------
+        str
+            Docker volume name
+        """
+        return os.environ.get(
+            "SSH_TUNNEL_VOLUME_NAME", f"{self.docker_container_name}-ssh-vol"
+        )
+
+    @property
+    def docker_squid_volume_name(self) -> str:
+        """
+        Docker volume in which the SSH configuration is stored.
+
+        Returns
+        -------
+        str
+            Docker volume name
+        """
+        return os.environ.get(
+            "SSH_SQUID_VOLUME_NAME", f"{self.docker_container_name}-squid-vol"
+        )
+
+    @property
+    def proxy_log_file(self):
+        return self.log_file_name(type_="proxy_server")
+
+    def docker_temporary_volume_name(self, job_id: int) -> str:
+        """
+        Docker volume in which temporary data is stored. Temporary data is
+        linked to a specific run. Multiple algorithm containers can have the
+        same run id, and therefore the share same temporary volume.
+
+        Parameters
+        ----------
+        job_id : int
+            run id provided by the server
+
+        Returns
+        -------
+        str
+            Docker volume name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-{job_id}-tmpvol"
+
+    def get_database_uri(self, label: str = "default") -> str:
+        """
+        Obtain the database URI for a specific database.
+
+        Parameters
+        ----------
+        label : str, optional
+            Database label, by default "default"
+
+        Returns
+        -------
+        str
+            URI to the database
+        """
+        return self.config["databases"][label]

vantage6/cli/context/server.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from vantage6.common.globals import APPNAME, InstanceType
+from vantage6.cli.configuration_manager import ServerConfigurationManager
+from vantage6.cli.globals import (
+    DEFAULT_SERVER_SYSTEM_FOLDERS as S_FOL,
+    ServerType,
+    ServerGlobals,
+)
+from vantage6.cli._version import __version__
+from vantage6.cli.context.base_server import BaseServerContext
+
+
+class ServerContext(BaseServerContext):
+    """
+    Server context
+
+    Parameters
+    ----------
+    instance_name : str
+        Name of the configuration instance, corresponds to the filename
+        of the configuration file.
+    system_folders : bool, optional
+        System wide or user configuration, by default S_FOL
+    """
+
+    # The server configuration manager is aware of the structure of the server
+    # 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):
+        super().__init__(
+            InstanceType.SERVER, instance_name, system_folders=system_folders
+        )
+        self.log.info("vantage6 version '%s'", __version__)
+
+    def get_database_uri(self) -> str:
+        """
+        Obtain the database uri from the environment or the configuration. The
+        `VANTAGE6_DB_URI` environment variable is used by the Docker container,
+        but can also be set by the user.
+
+        Returns
+        -------
+        str
+            string representation of the database uri
+        """
+        return super().get_database_uri(ServerGlobals.DB_URI_ENV_VAR)
+
+    @property
+    def docker_container_name(self) -> str:
+        """
+        Name of the docker container that the server is running in.
+
+        Returns
+        -------
+        str
+            Server's docker container name
+        """
+        return f"{APPNAME}-{self.name}-{self.scope}-{ServerType.V6SERVER}"
+
+    @classmethod
+    def from_external_config_file(
+        cls, path: str, system_folders: bool = S_FOL
+    ) -> ServerContext:
+        """
+        Create a server context from an external configuration file. External
+        means that the configuration file is not located in the default folders
+        but its location is specified by the user.
+
+        Parameters
+        ----------
+        path : str
+            Path of the configuration file
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        ServerContext
+            Server context object
+        """
+        return super().from_external_config_file(
+            path, ServerType.V6SERVER, ServerGlobals.CONFIG_NAME_ENV_VAR, system_folders
+        )
+
+    @classmethod
+    def config_exists(cls, instance_name: str, system_folders: bool = S_FOL) -> bool:
+        """
+        Check if a configuration file exists.
+
+        Parameters
+        ----------
+        instance_name : str
+            Name of the configuration instance, corresponds to the filename
+            of the configuration file.
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        bool
+            Whether the configuration file exists or not
+        """
+        return super().config_exists(
+            InstanceType.SERVER, instance_name, system_folders=system_folders
+        )
+
+    @classmethod
+    def available_configurations(
+        cls, system_folders: bool = S_FOL
+    ) -> tuple[list, list]:
+        """
+        Find all available server configurations in the default folders.
+
+        Parameters
+        ----------
+        system_folders : bool, optional
+            System wide or user configuration, by default S_FOL
+
+        Returns
+        -------
+        tuple[list, list]
+            The first list contains validated configuration files, the second
+            list contains invalid configuration files.
+        """
+        return super().available_configurations(InstanceType.SERVER, system_folders)